sigmap 2.10.0 → 3.0.0

package/CHANGELOG.md

@@ -6,7 +6,29 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
-## [2.10.0] — upcoming · [#25](https://github.com/manojmallick/sigmap/issues/25) · branch: `feat/v2.10-reporting-charts-advanced-metrics`
+## [3.0.0] — 2026-04-06 — Platform: Multi-Adapter Architecture
+
+### Added
+- **Multi-adapter platform** — `packages/adapters/` with 6 output adapters: `copilot`, `claude`, `cursor`, `windsurf`, `openai`, `gemini`
+- **`--adapter <name>` CLI flag** — generate output for a specific adapter only (e.g. `node gen-context.js --adapter openai`)
+- **`adapt()` in packages/core** — programmatic API: `const { adapt } = require('sigmap'); adapt(context, 'openai')`
+- **New config key `adapters`** — replaces `outputs`; old `outputs` key is silently mapped for full backward compatibility
+- **OpenAI adapter** — formats context as an OpenAI system prompt, writes `.github/openai-context.md`
+- **Gemini adapter** — formats context as a Gemini system instruction, writes `.github/gemini-context.md`
+- **API stability guarantee** — `packages/core` API is now semver-stable; breaking changes require v4.0
+- **20 new integration tests** in `test/integration/adapters.test.js`
+
+### Changed
+- `packages/core/index.js` — adds `adapt()` export alongside existing `extract`, `rank`, `scan`, `score`, `buildSigIndex`
+- `writeOutputs()` in `gen-context.js` — now routes `openai`, `gemini` through adapter pipeline
+
+### Backward compat
+- `outputs: ["copilot","claude"]` config still works — automatically mirrored to `adapters`
+- All existing CLI flags unchanged
+
+---
+
+## [2.10.0] — 2026-04-06 · [#25](https://github.com/manojmallick/sigmap/issues/25)
 
 ### Planned additions
 - **Report charts** — add chart-ready output for token reduction, signatures per file, and budget utilization trends.

package/README.md

@@ -123,20 +123,38 @@ AI agent session starts with full context
 | **Evaluation dashboard output** | Generate shareable HTML/JSON benchmark summaries from CLI runs |
 | **CI-friendly metrics export** | Persist machine-readable metrics for release gates and regression tracking |
 | **Release quality gates** | Add pass/fail thresholds for hit@5 and precision before publish |
+## 🔌 v3.0 — Platform: Multi-Adapter Architecture
 
----
-| **`get_impact` MCP tool** | 9th MCP tool — `{ file, depth? }` → impacted files + signatures |
-| **`src/map/dep-graph.js`** | Reverse-dependency graph built from the import analysis; circular deps handled safely |
-| **15 new tests** | `impact.test.js` — direct deps, transitive deps, depth limit, JSON output |
+SigMap is now an **adapter platform**. Any AI assistant — Copilot, Claude, Cursor, Windsurf, OpenAI, or Gemini — plugs in through a standard interface.
 
----
+```bash
+# Generate for a specific AI assistant
+node gen-context.js --adapter copilot    # → .github/copilot-instructions.md
+node gen-context.js --adapter openai     # → .github/openai-context.md
+node gen-context.js --adapter gemini     # → .github/gemini-context.md
+node gen-context.js --adapter claude     # → CLAUDE.md (append)
+```
 
-## 🚀 Quick start
+```js
+// Programmatic API — fully semver-stable from v3.0
+const { adapt } = require('sigmap');
+const systemPrompt = adapt(context, 'openai', { version: '3.0.0' });
+```
 
-**No install required — just Node.js 18+.**
+| Adapter | Output file | AI assistant |
+|---|---|---|
+| `copilot` | `.github/copilot-instructions.md` | GitHub Copilot |
+| `claude` | `CLAUDE.md` (append) | Claude / Claude Code |
+| `cursor` | `.cursorrules` | Cursor |
+| `windsurf` | `.windsurfrules` | Windsurf |
+| `openai` | `.github/openai-context.md` | Any OpenAI model |
+| `gemini` | `.github/gemini-context.md` | Google Gemini |
 
-```bash
-# 1. Copy gen-context.js into your project root
+**Backward compat:** existing `outputs` config key silently maps to `adapters` — no migration needed.
+
+See full roadmap: [manojmallick.github.io/sigmap/roadmap.html](https://manojmallick.github.io/sigmap/roadmap.html)
+
+---
 curl -O https://raw.githubusercontent.com/manojmallick/sigmap/main/gen-context.js
 
 # 2. Generate your context file

package/gen-context.js

@@ -33,6 +33,10 @@ __factories["./src/config/defaults"] = function(module, exports) {
   
     // Output targets: 'copilot' | 'claude' | 'cursor' | 'windsurf'
     outputs: ['copilot'],
+
+    // Adapter targets (v3.0+): replaces 'outputs'. Same names, adds 'openai' | 'gemini'.
+    // Old 'outputs' config key is still accepted and silently maps to 'adapters'.
+    adapters: null, // null means: use 'outputs' for backward compat
   
     // Directories to scan (relative to project root)
     srcDirs: [
@@ -163,6 +167,14 @@ __factories["./src/config/loader"] = function(module, exports) {
         merged[key] = val;
       }
     }
+    // Backward compat (v3.0+): if user specified 'adapters', use it as 'outputs' too.
+    // If user specified only 'outputs' (old configs), mirror to 'adapters'.
+    if (merged.adapters && !Array.isArray(merged.adapters)) merged.adapters = null;
+    if (!merged.adapters && Array.isArray(merged.outputs)) {
+      merged.adapters = merged.outputs.slice();
+    } else if (Array.isArray(merged.adapters) && !userConfig.outputs) {
+      merged.outputs = merged.adapters.filter((a) => ['copilot','claude','cursor','windsurf'].includes(a));
+    }
     return merged;
   }
   
@@ -4727,6 +4739,158 @@ __factories["./src/eval/runner"] = function(module, exports) {
 };
 
 
+// ── ./packages/adapters/copilot (bundled) ──
+__factories["./packages/adapters/copilot"] = function(module, exports) {
+  const path = require('path');
+  const name = 'copilot';
+  function format(context, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const version = (opts && opts.version) || 'unknown';
+    const timestamp = new Date().toISOString();
+    return [
+      `<!-- Generated by SigMap gen-context.js v${version} -->`,
+      `<!-- Updated: ${timestamp} -->`,
+      `<!-- Do not edit below — regenerate with: node gen-context.js -->`,
+      '',
+      '# Code signatures',
+      '',
+      context,
+    ].join('\n');
+  }
+  function outputPath(cwd) { return path.join(cwd, '.github', 'copilot-instructions.md'); }
+  module.exports = { name, format, outputPath };
+};
+
+// ── ./packages/adapters/claude (bundled) ──
+__factories["./packages/adapters/claude"] = function(module, exports) {
+  const path = require('path');
+  const fs = require('fs');
+  const name = 'claude';
+  const CLAUDE_MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+  function format(context, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const version = (opts && opts.version) || 'unknown';
+    const timestamp = new Date().toISOString();
+    return [`<!-- Generated by SigMap v${version} — ${timestamp} -->`, '', context].join('\n');
+  }
+  function outputPath(cwd) { return path.join(cwd, 'CLAUDE.md'); }
+  function write(context, cwd, opts = {}) {
+    const filePath = outputPath(cwd);
+    let existing = '';
+    if (fs.existsSync(filePath)) existing = fs.readFileSync(filePath, 'utf8');
+    const formatted = format(context, opts);
+    const markerIdx = existing.indexOf('## Auto-generated signatures');
+    const newContent = markerIdx !== -1
+      ? existing.slice(0, markerIdx) + CLAUDE_MARKER.trimStart() + formatted
+      : existing + CLAUDE_MARKER + formatted;
+    fs.writeFileSync(filePath, newContent, 'utf8');
+  }
+  module.exports = { name, format, outputPath, write };
+};
+
+// ── ./packages/adapters/cursor (bundled) ──
+__factories["./packages/adapters/cursor"] = function(module, exports) {
+  const path = require('path');
+  const name = 'cursor';
+  function format(context, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const version = (opts && opts.version) || 'unknown';
+    const timestamp = new Date().toISOString();
+    return [`# Code signatures — generated by SigMap v${version}`, `# Updated: ${timestamp}`, `# Regenerate: node gen-context.js`, '', context].join('\n');
+  }
+  function outputPath(cwd) { return path.join(cwd, '.cursorrules'); }
+  module.exports = { name, format, outputPath };
+};
+
+// ── ./packages/adapters/windsurf (bundled) ──
+__factories["./packages/adapters/windsurf"] = function(module, exports) {
+  const path = require('path');
+  const name = 'windsurf';
+  function format(context, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const version = (opts && opts.version) || 'unknown';
+    const timestamp = new Date().toISOString();
+    return [`# Code signatures — generated by SigMap v${version}`, `# Updated: ${timestamp}`, `# Regenerate: node gen-context.js`, '', context].join('\n');
+  }
+  function outputPath(cwd) { return path.join(cwd, '.windsurfrules'); }
+  module.exports = { name, format, outputPath };
+};
+
+// ── ./packages/adapters/openai (bundled) ──
+__factories["./packages/adapters/openai"] = function(module, exports) {
+  const path = require('path');
+  const name = 'openai';
+  function format(context, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const version = (opts && opts.version) || 'unknown';
+    const timestamp = new Date().toISOString();
+    const projectLine = (opts && opts.projectName) ? `Project: ${opts.projectName}\n` : '';
+    return [
+      `You are a coding assistant with full knowledge of this codebase.`,
+      `Below are the code signatures extracted by SigMap v${version} on ${timestamp}.`,
+      projectLine,
+      `Use these signatures to answer questions about the code accurately.`,
+      ``,
+      `## Code Signatures`,
+      ``,
+      context,
+    ].join('\n');
+  }
+  function outputPath(cwd) { return path.join(cwd, '.github', 'openai-context.md'); }
+  module.exports = { name, format, outputPath };
+};
+
+// ── ./packages/adapters/gemini (bundled) ──
+__factories["./packages/adapters/gemini"] = function(module, exports) {
+  const path = require('path');
+  const name = 'gemini';
+  function format(context, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const version = (opts && opts.version) || 'unknown';
+    const timestamp = new Date().toISOString();
+    const projectLine = (opts && opts.projectName) ? `Project: ${opts.projectName}\n` : '';
+    return [
+      `You are a coding assistant with complete knowledge of this codebase.`,
+      `The following code signatures were extracted by SigMap v${version} on ${timestamp}.`,
+      projectLine,
+      `These signatures represent every public function, class, and type in the project.`,
+      ``,
+      `## Code Signatures`,
+      ``,
+      context,
+    ].join('\n');
+  }
+  function outputPath(cwd) { return path.join(cwd, '.github', 'gemini-context.md'); }
+  module.exports = { name, format, outputPath };
+};
+
+// ── ./packages/adapters/index (bundled) ──
+__factories["./packages/adapters/index"] = function(module, exports) {
+  const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini'];
+  const _adapterCache = {};
+  function getAdapter(name) {
+    if (!name || typeof name !== 'string') return null;
+    const key = name.toLowerCase();
+    if (!ADAPTER_NAMES.includes(key)) return null;
+    if (!_adapterCache[key]) {
+      try { _adapterCache[key] = __require('./packages/adapters/' + key); } catch (_) { return null; }
+    }
+    return _adapterCache[key];
+  }
+  function listAdapters() { return ADAPTER_NAMES.slice(); }
+  function adapt(context, adapterName, opts = {}) {
+    if (!context || typeof context !== 'string') return '';
+    const adapter = getAdapter(adapterName);
+    if (!adapter || typeof adapter.format !== 'function') return '';
+    try { return adapter.format(context, opts); } catch (_) { return ''; }
+  }
+  function outputsToAdapters(outputs) {
+    if (!Array.isArray(outputs)) return ['copilot'];
+    return outputs.map((o) => ADAPTER_NAMES.includes(o) ? o : o);
+  }
+  module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters };
+};
+
 /**
  * SigMap — gen-context.js v1.2.0
  * Zero-dependency AI context engine.
@@ -4739,7 +4903,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '2.10.0';
+const VERSION = '3.0.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -5297,6 +5461,9 @@ function writeCacheOutput(content, cwd) {
 }
 
 function writeOutputs(content, targets, cwd) {
+  // v3.0+: adapter-aware output targets
+  const ADAPTER_TARGETS = new Set(['openai', 'gemini']);
+
   const targetMap = {
     copilot: path.join(cwd, '.github', 'copilot-instructions.md'),
     cursor: path.join(cwd, '.cursorrules'),
@@ -5308,6 +5475,20 @@ function writeOutputs(content, targets, cwd) {
       writeClaude(content, cwd);
       continue;
     }
+    // v3.0+ adapter targets (openai, gemini) — use bundled adapter to format + write
+    if (ADAPTER_TARGETS.has(target)) {
+      try {
+        const adapterMod = __require('./packages/adapters/' + target);
+        const formatted = adapterMod.format(content, { version: VERSION });
+        const outPath = adapterMod.outputPath(cwd);
+        ensureDir(outPath);
+        fs.writeFileSync(outPath, formatted, 'utf8');
+        console.warn(`[sigmap] wrote ${path.relative(cwd, outPath)}`);
+      } catch (err) {
+        console.warn(`[sigmap] adapter "${target}" failed: ${err.message}`);
+      }
+      continue;
+    }
     const outPath = targetMap[target];
     if (!outPath) {
       console.warn(`[sigmap] unknown output target: ${target}`);
@@ -5948,6 +6129,8 @@ Usage:
   node gen-context.js --diff <base-ref>                 Generate context + structural diff vs base ref (e.g. main)
   node gen-context.js --diff --staged                   Generate context for staged files only
   node gen-context.js --benchmark                       Run retrieval benchmark (benchmarks/tasks/retrieval.jsonl)
+  node gen-context.js --adapter <name>                  Generate for a specific adapter only (v3.0+)
+  node gen-context.js --adapter <name> --json           Show adapter output path as JSON
   node gen-context.js --benchmark --json                Benchmark results as JSON
   node gen-context.js --eval                            Alias for --benchmark
   node gen-context.js --analyze                         Per-file breakdown: sigs, tokens, extractor, coverage
@@ -5972,6 +6155,10 @@ Strategies (set via config "strategy" key):
                 ~90% fewer tokens. Best with MCP (Claude Code, Cursor).
                 Set "hotCommits": N to control how many commits count as hot (default 10).
 
+Adapters (v3.0+): copilot | claude | cursor | windsurf | openai | gemini
+  Set "adapters": ["copilot","openai"] in config to write multiple adapter outputs.
+  Old "outputs" config key is still accepted (maps to adapters automatically).
+
 Config: gen-context.config.json
 Ignore: .contextignore, .repomixignore
 Output: .github/copilot-instructions.md (default)
@@ -6303,6 +6490,44 @@ function main() {
     process.exit(0);
   }
 
+  // ── --adapter <name> ───────────────────────────────────────────────────────
+  if (args.includes('--adapter')) {
+    try {
+      const adpIdx = args.indexOf('--adapter');
+      const adapterName = (args[adpIdx + 1] || '').trim().toLowerCase();
+      const VALID_ADAPTERS = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini'];
+      if (!adapterName || adapterName.startsWith('--')) {
+        console.error('[sigmap] --adapter requires an adapter name');
+        console.error(`  Valid adapters: ${VALID_ADAPTERS.join(', ')}`);
+        console.error('  Example: node gen-context.js --adapter copilot');
+        process.exit(1);
+      }
+      if (!VALID_ADAPTERS.includes(adapterName)) {
+        console.error(`[sigmap] unknown adapter: "${adapterName}"`);
+        console.error(`  Valid adapters: ${VALID_ADAPTERS.join(', ')}`);
+        process.exit(1);
+      }
+      if (args.includes('--json')) {
+        const adapterMod = __require('./packages/adapters/' + adapterName);
+        const outPath = adapterMod.outputPath(cwd);
+        process.stdout.write(JSON.stringify({ adapter: adapterName, outputPath: outPath, version: VERSION }) + '\n');
+        process.exit(0);
+      }
+      // Run generate with this adapter's output targets
+      const singleAdapterConfig = Object.assign({}, config, {
+        outputs: adapterName === 'claude' ? ['claude'] : [adapterName],
+        adapters: [adapterName],
+      });
+      runGenerate(cwd, singleAdapterConfig, false);
+      const adapterMod = __require('./packages/adapters/' + adapterName);
+      console.warn(`[sigmap] adapter "${adapterName}" → ${path.relative(cwd, adapterMod.outputPath(cwd))}`);
+    } catch (err) {
+      console.error(`[sigmap] adapter error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
   // ── --impact <file> ────────────────────────────────────────────────────────
   if (args.includes('--impact')) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "2.10.0",
+  "version": "3.0.0",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {

package/packages/adapters/claude.js

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * Claude adapter — appends to CLAUDE.md under a marker line.
+ * Never overwrites human-written content above the marker.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ *   write(context, cwd, opts?) → void   (handles append logic)
+ */
+
+const path = require('path');
+const fs = require('fs');
+
+const name = 'claude';
+
+const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
+
+/**
+ * Format context suited for CLAUDE.md.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  return [
+    `<!-- Generated by SigMap v${version} — ${timestamp} -->`,
+    '',
+    context,
+  ].join('\n');
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, 'CLAUDE.md');
+}
+
+/**
+ * Write signatures into CLAUDE.md using the append-under-marker strategy.
+ * Human content above the marker is never touched.
+ * @param {string} context - Raw signature context string
+ * @param {string} cwd - Project root
+ * @param {object} [opts]
+ */
+function write(context, cwd, opts = {}) {
+  const filePath = outputPath(cwd);
+  let existing = '';
+  if (fs.existsSync(filePath)) {
+    existing = fs.readFileSync(filePath, 'utf8');
+  }
+  const formatted = format(context, opts);
+  const markerIdx = existing.indexOf('## Auto-generated signatures');
+  let newContent;
+  if (markerIdx !== -1) {
+    newContent = existing.slice(0, markerIdx) + MARKER.trimStart() + formatted;
+  } else {
+    newContent = existing + MARKER + formatted;
+  }
+  fs.writeFileSync(filePath, newContent, 'utf8');
+}
+
+module.exports = { name, format, outputPath, write };

package/packages/adapters/copilot.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+ * Copilot adapter — writes to .github/copilot-instructions.md
+ * GitHub Copilot reads this file automatically in every workspace.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'copilot';
+
+/**
+ * Format context for GitHub Copilot instructions.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const header = [
+    `<!-- Generated by SigMap gen-context.js v${version} -->`,
+    `<!-- Updated: ${timestamp} -->`,
+    `<!-- Do not edit below — regenerate with: node gen-context.js -->`,
+    '',
+    '# Code signatures',
+    '',
+  ].join('\n');
+  return header + context;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.github', 'copilot-instructions.md');
+}
+
+module.exports = { name, format, outputPath };

package/packages/adapters/cursor.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Cursor adapter — writes to .cursorrules
+ * Cursor reads .cursorrules automatically in every workspace.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'cursor';
+
+/**
+ * Format context for Cursor rules file.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const header = [
+    `# Code signatures — generated by SigMap v${version}`,
+    `# Updated: ${timestamp}`,
+    `# Regenerate: node gen-context.js`,
+    '',
+  ].join('\n');
+  return header + context;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.cursorrules');
+}
+
+module.exports = { name, format, outputPath };

package/packages/adapters/gemini.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * Gemini adapter — formats context as a Gemini system instruction.
+ * Use the output as the `system_instruction` field in a Gemini API request.
+ *
+ * Example usage:
+ *   const { format } = require('sigmap/adapters/gemini');
+ *   const instruction = format(context);
+ *   // Pass to: genAI.getGenerativeModel({ model: 'gemini-pro', systemInstruction: instruction })
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'gemini';
+
+/**
+ * Format context as a Gemini system instruction.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @param {string} [opts.projectName] - Optional project name
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const projectLine = opts.projectName
+    ? `Project: ${opts.projectName}\n`
+    : '';
+
+  return [
+    `You are a coding assistant with complete knowledge of this codebase.`,
+    `The following code signatures were extracted by SigMap v${version} on ${timestamp}.`,
+    projectLine,
+    `These signatures represent every public function, class, and type in the project.`,
+    `Refer to them when answering questions about code structure, APIs, and implementation.`,
+    ``,
+    `## Code Signatures`,
+    ``,
+    context,
+  ].join('\n');
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.github', 'gemini-context.md');
+}
+
+module.exports = { name, format, outputPath };

package/packages/adapters/index.js

@@ -0,0 +1,79 @@
+'use strict';
+
+/**
+ * packages/adapters/index.js
+ * Central registry for all SigMap output adapters.
+ *
+ * Usage:
+ *   const { getAdapter, listAdapters, adapt } = require('sigmap/adapters');
+ *   const output = adapt(context, 'copilot', { version: '3.0.0' });
+ */
+
+const path = require('path');
+
+const ADAPTER_NAMES = ['copilot', 'claude', 'cursor', 'windsurf', 'openai', 'gemini'];
+
+// Lazy-load adapters so unused ones don't pay any require() cost
+const _cache = {};
+
+/**
+ * Load and return an adapter module by name.
+ * @param {string} name - Adapter name (copilot|claude|cursor|windsurf|openai|gemini)
+ * @returns {{ name: string, format: Function, outputPath: Function }|null}
+ */
+function getAdapter(name) {
+  if (!name || typeof name !== 'string') return null;
+  const key = name.toLowerCase();
+  if (!ADAPTER_NAMES.includes(key)) return null;
+  if (!_cache[key]) {
+    try {
+      _cache[key] = require(path.join(__dirname, key + '.js'));
+    } catch (_) {
+      return null;
+    }
+  }
+  return _cache[key];
+}
+
+/**
+ * List all available adapter names.
+ * @returns {string[]}
+ */
+function listAdapters() {
+  return ADAPTER_NAMES.slice();
+}
+
+/**
+ * Format context using the named adapter.
+ * @param {string} context - Raw signature context string
+ * @param {string} adapterName - Adapter name
+ * @param {object} [opts] - Options passed to adapter.format()
+ * @returns {string} Formatted output string (empty string if adapter not found or context empty)
+ */
+function adapt(context, adapterName, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const adapter = getAdapter(adapterName);
+  if (!adapter || typeof adapter.format !== 'function') return '';
+  try {
+    return adapter.format(context, opts);
+  } catch (_) {
+    return '';
+  }
+}
+
+/**
+ * Map old `outputs` config values to new `adapters` names.
+ * Provides backward compatibility for existing configurations.
+ * @param {string[]} outputs - Legacy outputs array
+ * @returns {string[]} Equivalent adapters array
+ */
+function outputsToAdapters(outputs) {
+  if (!Array.isArray(outputs)) return ['copilot'];
+  return outputs.map((o) => {
+    // All current output names already match adapter names
+    if (ADAPTER_NAMES.includes(o)) return o;
+    return o; // pass through unknowns — getAdapter() will handle gracefully
+  });
+}
+
+module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters };

package/packages/adapters/openai.js

@@ -0,0 +1,60 @@
+'use strict';
+
+/**
+ * OpenAI adapter — formats context as an OpenAI system message.
+ * Use the output as the `content` field of a system role message.
+ *
+ * Example usage in code:
+ *   const { format } = require('sigmap/adapters/openai');
+ *   const systemPrompt = format(context);
+ *   // Pass to: openai.chat.completions.create({ messages: [{ role: 'system', content: systemPrompt }] })
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'openai';
+
+/**
+ * Format context as an OpenAI system prompt.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @param {string} [opts.projectName] - Optional project name
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const projectLine = opts.projectName
+    ? `Project: ${opts.projectName}\n`
+    : '';
+
+  return [
+    `You are a coding assistant with full knowledge of this codebase.`,
+    `Below are the code signatures extracted by SigMap v${version} on ${timestamp}.`,
+    projectLine,
+    `Use these signatures to answer questions about the code accurately.`,
+    `When the user asks about a specific file or function, refer to the signatures below.`,
+    ``,
+    `## Code Signatures`,
+    ``,
+    context,
+  ].join('\n');
+}
+
+/**
+ * Return the output file path for this adapter.
+ * Writes a .openai-context.md file that can be loaded at runtime.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.github', 'openai-context.md');
+}
+
+module.exports = { name, format, outputPath };

package/packages/adapters/windsurf.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Windsurf adapter — writes to .windsurfrules
+ * Windsurf reads .windsurfrules automatically in every workspace.
+ *
+ * Contract:
+ *   format(context, opts?) → string
+ *   outputPath(cwd) → string
+ */
+
+const path = require('path');
+
+const name = 'windsurf';
+
+/**
+ * Format context for Windsurf rules file.
+ * @param {string} context - Raw signature context string
+ * @param {object} [opts]
+ * @param {string} [opts.version] - SigMap version string
+ * @returns {string}
+ */
+function format(context, opts = {}) {
+  if (!context || typeof context !== 'string') return '';
+  const version = opts.version || 'unknown';
+  const timestamp = new Date().toISOString();
+  const header = [
+    `# Code signatures — generated by SigMap v${version}`,
+    `# Updated: ${timestamp}`,
+    `# Regenerate: node gen-context.js`,
+    '',
+  ].join('\n');
+  return header + context;
+}
+
+/**
+ * Return the output file path for this adapter.
+ * @param {string} cwd - Project root
+ * @returns {string}
+ */
+function outputPath(cwd) {
+  return path.join(cwd, '.windsurfrules');
+}
+
+module.exports = { name, format, outputPath };

package/packages/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-cli",
-  "version": "2.10.0",
+  "version": "3.0.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/README.md

@@ -1,6 +1,6 @@
 # sigmap-core
 
-Programmatic API for [SigMap](https://manojmallick.github.io/sigmap/) — zero-dependency code signature extraction, ranked retrieval, secret scanning, and project health scoring.
+Programmatic API for [SigMap](https://manojmallick.github.io/sigmap/) — zero-dependency code signature extraction, ranked retrieval, secret scanning, project health scoring, and multi-adapter output formatting (v3.0+).
 
 ## Installation
 
@@ -13,7 +13,7 @@ npm install sigmap        # installs the full package (CLI + core)
 ## Quick start
 
 ```js
-const { extract, rank, buildSigIndex, scan, score } = require('sigmap');
+const { extract, rank, buildSigIndex, scan, score, adapt } = require('sigmap');
 
 // 1. Extract signatures from any source file
 const sigs = extract('function hello() { return "world"; }', 'javascript');
@@ -128,9 +128,21 @@ const health = score('/path/to/project');
 
 All existing CLI flags (`--generate`, `--watch`, `--mcp`, `--query`, `--analyze`, `--benchmark`, `--health`, …) are unchanged.
 
-## What's next — v2.10
+## v3.0 — Multi-Adapter Architecture (released)
 
-v2.10 adds reporting charts and advanced metrics for benchmark visibility. This milestone focuses on chart-ready report output, precision@K/recall@K/MRR trends, and CI-friendly metrics artifacts. See [issue #25](https://github.com/manojmallick/sigmap/issues/25).
+v3.0 adds the `adapt()` function to `packages/core`, making the API **semver-stable**. Breaking changes now require v4.0.
+
+```js
+const { adapt } = require('sigmap');
+
+// Format context as an OpenAI system prompt
+const systemPrompt = adapt(context, 'openai', { version: '3.0.0' });
+
+// Format context as a Gemini system instruction
+const geminiInstruction = adapt(context, 'gemini');
+
+// All 6 adapters: copilot | claude | cursor | windsurf | openai | gemini
+```
 
 See the full [roadmap](https://manojmallick.github.io/sigmap/roadmap.html).
 

package/packages/core/index.js

@@ -198,6 +198,33 @@ function score(cwd) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// adapt(context, adapterName, opts?) → string   (v3.0+)
+// ---------------------------------------------------------------------------
+/**
+ * Format a context string using the named output adapter.
+ *
+ * @param {string} context     - Raw signature context string
+ * @param {string} adapterName - One of: 'copilot'|'claude'|'cursor'|'windsurf'|'openai'|'gemini'
+ * @param {object} [opts]      - Passed through to adapter.format()
+ * @returns {string} Formatted output string (empty string if adapter not found)
+ *
+ * @example
+ *   const { adapt } = require('sigmap');
+ *   const systemPrompt = adapt(context, 'openai', { version: '3.0.0' });
+ *
+ *   const copilotMd = adapt(context, 'copilot');
+ */
+function adapt(context, adapterName, opts = {}) {
+  try {
+    const adaptersPath = path.resolve(__dirname, '..', 'adapters', 'index.js');
+    const { adapt: _adapt } = require(adaptersPath);
+    return _adapt(context, adapterName, opts);
+  } catch (_) {
+    return '';
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Exports
 // ---------------------------------------------------------------------------
@@ -212,4 +239,6 @@ module.exports = {
   scan,
   /** Compute project health score */
   score,
+  /** Format context using a named output adapter (v3.0+) */
+  adapt,
 };

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "2.10.0",
+  "version": "3.0.0",
   "description": "SigMap core library — zero-dependency code signature extraction, retrieval, and security scanning",
   "main": "index.js",
   "keywords": [

package/src/config/defaults.js

@@ -11,6 +11,10 @@ const DEFAULTS = {
   // Output targets: 'copilot' | 'claude' | 'cursor' | 'windsurf'
   outputs: ['copilot'],
 
+  // Adapter targets (v3.0+): replaces 'outputs'. Same names, adds 'openai' | 'gemini'.
+  // Old 'outputs' config key is still accepted and silently maps to 'adapters'.
+  adapters: null,
+
   // Directories to scan (relative to project root)
   srcDirs: [
     'src', 'app', 'lib', 'packages', 'services', 'api',

package/src/config/loader.js

@@ -50,6 +50,13 @@ function loadConfig(cwd) {
       merged[key] = val;
     }
   }
+  // Backward compat (v3.0+): mirror outputs ↔ adapters
+  if (merged.adapters && !Array.isArray(merged.adapters)) merged.adapters = null;
+  if (!merged.adapters && Array.isArray(merged.outputs)) {
+    merged.adapters = merged.outputs.slice();
+  } else if (Array.isArray(merged.adapters) && !userConfig.outputs) {
+    merged.outputs = merged.adapters.filter((a) => ['copilot','claude','cursor','windsurf'].includes(a));
+  }
   return merged;
 }
 

package/src/mcp/server.js

@@ -18,7 +18,7 @@ const { readContext, searchSignatures, getMap, createCheckpoint, getRouting, exp
 
 const SERVER_INFO = {
   name: 'sigmap',
-  version: '2.10.0',
+  version: '3.0.0',
   description: 'SigMap MCP server — code signatures on demand',
 };