Plugin Development Guide¶

my-plugin/
├── package.json          # Plugin metadata and dependencies
├── plugin.js            # Main plugin file
├── manifest.json        # Plugin manifest
├── README.md            # Documentation
├── tests/               # Test files
│   ├── unit/           # Unit tests
│   └── integration/    # Integration tests
├── assets/             # Static assets
│   ├── icons/         # Plugin icons
│   └── images/        # Documentation images
└── docs/              # Additional documentation

{
  "id": "my-awesome-plugin",
  "name": "My Awesome Plugin",
  "version": "1.0.0",
  "description": "A plugin that does awesome things with genomic data",
  "author": "Your Name",
  "license": "MIT",
  "homepage": "https://github.com/yourname/my-awesome-plugin",
  "keywords": ["genomics", "analysis", "visualization"],
  "engines": {
    "codexomics": ">=0.7.0"
  },
  "main": "plugin.js",
  "category": "analysis",
  "permissions": ["read-files", "write-files", "network-access"],
  "dependencies": {
    "lodash": "^4.17.21"
  },
  "aiIntegration": {
    "enabled": true,
    "functions": ["analyzeSequence", "generateReport"]
  }
}

/**
 * My Awesome Plugin for CodeXomics
 * @version 1.0.0
 */
class MyAwesomePlugin {
  constructor(app, api) {
    this.app = app;
    this.api = api;
    this.name = 'My Awesome Plugin';
    this.version = '1.0.0';
    this.initialized = false;
  }

  /**
   * Initialize the plugin
   */
  async initialize() {
    try {
      // Setup plugin resources
      await this.setupResources();

      // Register UI components
      this.registerUI();

      // Register AI functions
      this.registerAIFunctions();

      this.initialized = true;
      console.log(`${this.name} initialized successfully`);
    } catch (error) {
      console.error(`Failed to initialize ${this.name}:`, error);
      throw error;
    }
  }

  /**
   * Setup plugin resources
   */
  async setupResources() {
    // Initialize data structures, load assets, etc.
  }

  /**
   * Register UI components
   */
  registerUI() {
    // Add menu items, toolbar buttons, panels, etc.
    this.api.ui.addMenuItem({
      label: 'My Analysis Tool',
      action: () => this.openAnalysisTool(),
      category: 'Tools',
    });
  }

  /**
   * Register AI-callable functions
   */
  registerAIFunctions() {
    this.api.ai.registerFunction({
      name: 'analyzeSequence',
      description: 'Analyze DNA sequence with my awesome algorithm',
      parameters: {
        sequence: { type: 'string', required: true },
        options: { type: 'object', required: false },
      },
      execute: this.analyzeSequence.bind(this),
    });
  }

  /**
   * Main analysis function
   */
  async analyzeSequence(params) {
    const { sequence, options = {} } = params;

    // Validate input
    if (!sequence || typeof sequence !== 'string') {
      throw new Error('Invalid sequence provided');
    }

    // Perform analysis
    const results = await this.performAnalysis(sequence, options);

    // Return results in standard format
    return {
      success: true,
      data: results,
      metadata: {
        plugin: this.name,
        version: this.version,
        timestamp: new Date().toISOString(),
      },
    };
  }

  /**
   * Open analysis tool interface
   */
  openAnalysisTool() {
    const panel = this.api.ui.createPanel({
      title: 'My Analysis Tool',
      content: this.createAnalysisUI(),
      width: 800,
      height: 600,
    });

    panel.show();
  }

  /**
   * Create analysis UI
   */
  createAnalysisUI() {
    return `
            <div class="my-plugin-panel">
                <h3>Sequence Analysis</h3>
                <textarea id="sequence-input" placeholder="Enter DNA sequence..."></textarea>
                <button onclick="this.runAnalysis()">Analyze</button>
                <div id="results-area"></div>
            </div>
        `;
  }

  /**
   * Perform the actual analysis
   */
  async performAnalysis(sequence, options) {
    // Implement your analysis algorithm here
    return {
      length: sequence.length,
      gcContent: this.calculateGCContent(sequence),
      composition: this.analyzeComposition(sequence),
    };
  }

  /**
   * Calculate GC content
   */
  calculateGCContent(sequence) {
    const gcCount = (sequence.match(/[GC]/gi) || []).length;
    return (gcCount / sequence.length) * 100;
  }

  /**
   * Analyze sequence composition
   */
  analyzeComposition(sequence) {
    const composition = { A: 0, T: 0, G: 0, C: 0 };
    for (const base of sequence.toUpperCase()) {
      if (composition.hasOwnProperty(base)) {
        composition[base]++;
      }
    }
    return composition;
  }

  /**
   * Cleanup when plugin is deactivated
   */
  async deactivate() {
    // Clean up resources, remove UI elements, etc.
    this.api.ui.removeAllComponents(this.name);
    this.initialized = false;
  }
}

// Export plugin class
if (typeof module !== 'undefined' && module.exports) {
  module.exports = MyAwesomePlugin;
}

// Browser export
if (typeof window !== 'undefined') {
  window.MyAwesomePlugin = MyAwesomePlugin;
}

git clone https://github.com/codexomics/plugin-template.git my-plugin
cd my-plugin
npm install

# Link to local CodeXomics for testing
npm link ../CodeXomics

# Start development server
npm run dev

# Run plugin tests
npm test

# Run with coverage
npm run test:coverage

// webpack.config.js for plugin development
module.exports = {
  entry: './plugin.js',
  output: {
    filename: 'plugin.bundle.js',
    library: 'MyPlugin',
    libraryTarget: 'umd',
  },
  externals: {
    codexomics: 'CodeXomics',
  },
  module: {
    rules: [
      {
        test: /\.js$/,
        exclude: /node_modules/,
        use: 'babel-loader',
      },
      {
        test: /\.css$/,
        use: ['style-loader', 'css-loader'],
      },
    ],
  },
};

// Access to main application
this.app.fileManager; // File operations
this.app.trackRenderer; // Visualization
this.app.navigationManager; // Navigation
this.app.chatManager; // AI integration

// UI Methods
this.api.ui.addMenuItem(options)
this.api.ui.createPanel(options)
this.api.ui.showNotification(message, type)

// Data Methods
this.api.data.getCurrentGenome()
this.api.data.getSelectedRegion()
this.api.data.exportSequence(format, region)

// AI Methods
this.api.ai.registerFunction(function)
this.api.ai.callFunction(name, params)
this.api.ai.addToChat(message)

// Utility Methods
this.api.utils.validateSequence(sequence)
this.api.utils.formatNumber(number)
this.api.utils.downloadFile(data, filename)

// Listen to application events
this.api.events.on('genome-loaded', genome => {
  console.log('New genome loaded:', genome.name);
});

this.api.events.on('region-selected', region => {
  console.log('Region selected:', region);
});

// Emit custom events
this.api.events.emit('plugin-analysis-complete', {
  plugin: this.name,
  results: analysisResults,
});

// Access current genomic data
const genome = this.api.data.getCurrentGenome();
const annotations = this.api.data.getAnnotations();
const variants = this.api.data.getVariants();

// Work with selected regions
const selectedRegion = this.api.data.getSelectedRegion();
if (selectedRegion) {
  const sequence = this.api.data.getSequence(selectedRegion);
  // Process sequence
}

// Export data
this.api.data.exportSequence('fasta', selectedRegion);
this.api.data.exportAnnotations('gff', selectedRegion);

class CustomVisualization {
  constructor(container, data, options) {
    this.container = container;
    this.data = data;
    this.options = options;
    this.svg = null;
  }

  render() {
    // Create SVG visualization
    this.svg = d3
      .select(this.container)
      .append('svg')
      .attr('width', this.options.width)
      .attr('height', this.options.height);

    // Render your custom visualization
    this.renderChart();
  }

  renderChart() {
    // Implement custom D3.js visualization
    const chart = this.svg
      .selectAll('.data-point')
      .data(this.data)
      .enter()
      .append('circle')
      .attr('class', 'data-point')
      .attr('r', 5)
      .attr('cx', d => d.x)
      .attr('cy', d => d.y);
  }

  update(newData) {
    this.data = newData;
    this.renderChart();
  }
}

// Register sophisticated AI functions
this.api.ai.registerFunction({
  name: 'predictGeneFunction',
  description: 'Predict gene function using machine learning',
  parameters: {
    sequence: {
      type: 'string',
      required: true,
      description: 'DNA sequence to analyze',
    },
    model: {
      type: 'string',
      required: false,
      default: 'default',
      enum: ['default', 'prokaryotic', 'eukaryotic'],
    },
    confidence: {
      type: 'number',
      required: false,
      default: 0.8,
      minimum: 0.0,
      maximum: 1.0,
    },
  },
  execute: async params => {
    const prediction = await this.mlModel.predict(params);
    return {
      prediction: prediction.function,
      confidence: prediction.confidence,
      evidence: prediction.evidence,
    };
  },
});

class DatabaseConnector {
  constructor(config) {
    this.config = config;
    this.connected = false;
  }

  async connect() {
    try {
      this.connection = await this.establishConnection();
      this.connected = true;
    } catch (error) {
      throw new Error(`Database connection failed: ${error.message}`);
    }
  }

  async query(sql, params) {
    if (!this.connected) {
      await this.connect();
    }
    return await this.connection.query(sql, params);
  }

  async searchGenes(criteria) {
    const sql = `
            SELECT gene_id, symbol, description, organism
            FROM genes 
            WHERE description LIKE ? 
            AND organism = ?
        `;
    return await this.query(sql, [`%${criteria.keyword}%`, criteria.organism]);
  }
}

// test/unit/plugin.test.js
const MyAwesomePlugin = require('../../plugin.js');
const mockAPI = require('../mocks/api-mock.js');

describe('MyAwesomePlugin', () => {
  let plugin;
  let mockApp;

  beforeEach(() => {
    mockApp = {
      /* mock app object */
    };
    plugin = new MyAwesomePlugin(mockApp, mockAPI);
  });

  test('should initialize correctly', async () => {
    await plugin.initialize();
    expect(plugin.initialized).toBe(true);
  });

  test('should calculate GC content correctly', () => {
    const sequence = 'ATGCGCTA';
    const gcContent = plugin.calculateGCContent(sequence);
    expect(gcContent).toBe(50);
  });

  test('should handle invalid sequence', async () => {
    await expect(plugin.analyzeSequence({ sequence: null })).rejects.toThrow('Invalid sequence provided');
  });
});

// test/integration/plugin-integration.test.js
const PluginTestFramework = require('codexomics/test-framework');

describe('Plugin Integration Tests', () => {
  let testFramework;

  beforeAll(async () => {
    testFramework = new PluginTestFramework();
    await testFramework.setup();
  });

  test('should integrate with AI system', async () => {
    const plugin = await testFramework.loadPlugin('./plugin.js');
    const result = await testFramework.callAIFunction('analyzeSequence', {
      sequence: 'ATGCGCTAG',
    });

    expect(result.success).toBe(true);
    expect(result.data).toHaveProperty('gcContent');
  });

  afterAll(async () => {
    await testFramework.cleanup();
  });
});

// Enable debug mode
const DEBUG = true;

class MyAwesomePlugin {
  debug(message, data) {
    if (DEBUG) {
      console.log(`[${this.name}] ${message}`, data);
    }
  }

  async analyzeSequence(params) {
    this.debug('Starting sequence analysis', { params });

    try {
      const results = await this.performAnalysis(params.sequence);
      this.debug('Analysis complete', { results });
      return results;
    } catch (error) {
      this.debug('Analysis failed', { error });
      throw error;
    }
  }
}

# Install marketplace CLI
npm install -g codexomics-cli

# Login to marketplace
gai-cli login

# Validate plugin
gai-cli validate ./

# Publish plugin
gai-cli publish --version 1.0.0 --description "Initial release"

// marketplace-config.json
{
  "category": "analysis",
  "tags": ["genomics", "sequence-analysis", "machine-learning"],
  "screenshots": ["assets/screenshot-1.png", "assets/screenshot-2.png"],
  "demo": {
    "enabled": true,
    "sampleData": "assets/sample-data.json"
  },
  "pricing": {
    "model": "free",
    "license": "MIT"
  },
  "support": {
    "email": "support@example.com",
    "github": "https://github.com/username/plugin",
    "documentation": "https://plugin-docs.example.com"
  }
}

class SequenceAnalyzerPlugin {
  constructor(app, api) {
    this.app = app;
    this.api = api;
    this.name = 'Sequence Analyzer';
  }

  async initialize() {
    this.api.ai.registerFunction({
      name: 'analyzeBasicStats',
      description: 'Calculate basic sequence statistics',
      parameters: {
        sequence: { type: 'string', required: true },
      },
      execute: this.analyzeBasicStats.bind(this),
    });
  }

  analyzeBasicStats({ sequence }) {
    return {
      length: sequence.length,
      gcContent: this.calculateGC(sequence),
      composition: this.getComposition(sequence),
      melting_temperature: this.calculateTm(sequence),
    };
  }

  calculateGC(sequence) {
    const gc = (sequence.match(/[GC]/gi) || []).length;
    return ((gc / sequence.length) * 100).toFixed(2);
  }

  // Additional methods...
}

class GenomeCircosPlugin {
  constructor(app, api) {
    this.app = app;
    this.api = api;
    this.name = 'Circos Visualizer';
  }

  async initialize() {
    this.api.ui.addMenuItem({
      label: 'Circos Plot',
      action: () => this.createCircosPlot(),
      category: 'Visualization',
    });
  }

  createCircosPlot() {
    const panel = this.api.ui.createPanel({
      title: 'Circos Genome Plot',
      content: '<div id="circos-container"></div>',
      width: 800,
      height: 800,
    });

    panel.onShow(() => {
      this.renderCircos('#circos-container');
    });

    panel.show();
  }

  renderCircos(container) {
    // Implement Circos visualization using D3.js
    const svg = d3.select(container).append('svg').attr('width', 800).attr('height', 800);

    // Render circular genome plot
    this.drawChromosomes(svg);
    this.drawGenes(svg);
    this.drawConnections(svg);
  }

  // Circos rendering methods...
}