sigmap 7.7.0 → 7.9.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [7.9.0] — 2026-06-17
+
+Minor release — `sigmap conventions --inject` (grounded codegen, Layer 3).
+
+### Added
+- **`sigmap conventions --inject` — write the conventions block into CLAUDE.md (#304):** the next slice of Layer 3, completing the "agent sees the house style" link in the grounded-creation loop. Renders the detected conventions (file naming, export style, test framework — each with its dominant pattern and consistency tier) into a marker-delimited block and injects it into `CLAUDE.md`, creating the file if absent. New zero-dependency, bundle-safe `src/conventions/inject.js` (`renderConventionsBlock`, `injectConventions`): the injection is idempotent and marker-scoped (`<!-- sigmap-conventions:start -->` … `:end -->`), preserving all human content and coexisting with the existing `## Auto-generated signatures` block. `--report`, `--fix`, `--update`, `--ci`, and Layer 4 scaffold remain follow-ups.
+
+---
+
+## [7.8.0] — 2026-06-17
+
+Minor release — `sigmap conventions --conflicts` (grounded codegen, Layer 3).
+
+### Added
+- **`sigmap conventions --conflicts` — per-convention breakdown + rename suggestions (#301):** the next slice of Layer 3. Where `conventions` reports the dominant pattern and a consistency tier, `--conflicts` surfaces *why* a convention is mixed — every variant pattern with its file count, share, a visual bar, and example files, plus rename suggestions that move minority file-naming files toward the dominant style. New zero-dependency, bundle-safe `src/conventions/conflicts.js` (`analyzeConflicts`, `toNamingStyle`, `renameSuggestion`); export-style conflicts list variants but no renames (that's a code change, not a rename). `scoreConvention(labels, refs?)` now attaches up to 3 example files per variant (backward compatible). `--json` emits the structured conflict report; a consistent repo prints "no conflicts". `--report`, `--fix`, `--update`, `--ci`, and CLAUDE.md injection remain follow-ups.
+
+---
+
 ## [7.7.0] — 2026-06-17
 
 Minor release — `sigmap conventions` (grounded codegen, Layer 3).

package/gen-context.js

@@ -22,6 +22,223 @@ function __require(key) {
 
 // ── ./src/cache/freshen ──
 // ── ./src/conventions/extract ──
+// ── ./src/conventions/conflicts ──
+// ── ./src/conventions/inject ──
+__factories["./src/conventions/inject"] = function(module, exports) {
+  
+  /**
+   * CLAUDE.md convention injection (IMPL.md §7 Phase 2 / §8 step 5).
+   *
+   * Renders the conventions detected by `extractConventions` into a
+   * marker-delimited markdown block and injects it into CLAUDE.md so an agent
+   * reading the file plans grounded in the repo's house style. Idempotent and
+   * marker-scoped — it never touches human content or the `## Auto-generated
+   * signatures` block. Pure string transforms; zero-dependency, bundle-safe.
+   */
+
+  const START = '<!-- sigmap-conventions:start -->';
+  const END = '<!-- sigmap-conventions:end -->';
+
+  const TIER_NOTE = {
+    consistent: 'consistent — match it',
+    mostly: 'dominant, with some drift',
+    inconsistent: 'no clear convention — check neighboring files',
+  };
+
+  const NAMES = {
+    fileNaming: 'File naming',
+    exportStyle: 'Export style',
+  };
+
+  const _pct = (n) => `${Math.round(n * 100)}%`;
+
+  function _conventionLine(label, conv) {
+    if (!conv || conv.total === 0 || !conv.dominant) return null;
+    const note = TIER_NOTE[conv.tier] || conv.tier;
+    let line = `- **${label}:** ${conv.dominant} (${_pct(conv.dominantPct)} — ${note}).`;
+    const others = conv.variants.slice(1).filter((v) => v.pct > 0);
+    if (others.length) {
+      line += ` Variants: ${others.map((v) => `${v.label} ${_pct(v.pct)}`).join(', ')}.`;
+    }
+    return line;
+  }
+
+  /**
+   * Render the conventions block (including its start/end markers).
+   * @param {object} result an `extractConventions` result
+   * @param {string} [version] SigMap version for the footer
+   * @returns {string}
+   */
+  function renderConventionsBlock(result, version) {
+    const lines = [];
+    for (const key of ['fileNaming', 'exportStyle']) {
+      const l = _conventionLine(NAMES[key], result && result[key]);
+      if (l) lines.push(l);
+    }
+    if (result && result.testFramework) {
+      lines.push(`- **Test framework:** ${result.testFramework}.`);
+    }
+
+    const body = lines.length
+      ? lines
+      : ['- No conventions detected yet (run `sigmap conventions` on a TS/JS/Python repo).'];
+
+    const ver = version ? ` v${version}` : '';
+    return [
+      START,
+      '## Conventions (auto-detected by SigMap)',
+      '',
+      'Match these when writing or editing code (TS/JS/Python):',
+      '',
+      ...body,
+      '',
+      `<sub>Generated by SigMap${ver} · run \`sigmap conventions --inject\` to refresh.</sub>`,
+      END,
+    ].join('\n');
+  }
+
+  /**
+   * Inject (or replace) the conventions block in existing CLAUDE.md content.
+   * Replaces an existing marked block in place; appends one when absent.
+   * Idempotent — never touches content outside the markers.
+   * @param {string} existing current file content ('' if the file is new)
+   * @param {string} block the block returned by `renderConventionsBlock`
+   * @returns {string}
+   */
+  function injectConventions(existing, block) {
+    const src = String(existing || '');
+    const startIdx = src.indexOf(START);
+    if (startIdx !== -1) {
+      const endIdx = src.indexOf(END, startIdx);
+      if (endIdx !== -1) {
+        const before = src.slice(0, startIdx);
+        const after = src.slice(endIdx + END.length);
+        return before + block + after;
+      }
+    }
+    if (src.trim() === '') return block + '\n';
+    const sep = src.endsWith('\n') ? '\n' : '\n\n';
+    return src + sep + block + '\n';
+  }
+
+  module.exports = { renderConventionsBlock, injectConventions, START, END };
+  
+};
+
+__factories["./src/conventions/conflicts"] = function(module, exports) {
+  
+  /**
+   * Convention conflict analysis (IMPL.md §4 / §5.3 — grounded codegen, Layer 3).
+   *
+   * Given an `extractConventions` result, surface *why* a convention is mixed:
+   * every variant pattern with its file count, share, and example files, plus
+   * rename suggestions that move minority file-naming files toward the dominant
+   * style. Pure, zero-dependency, bundle-safe.
+   */
+
+  /** Split a file name into its stem (before the first dot) and the rest. */
+  function _splitName(filename) {
+    const s = String(filename || '');
+    const dot = s.indexOf('.');
+    if (dot <= 0) return { stem: s, ext: '' };
+    return { stem: s.slice(0, dot), ext: s.slice(dot) };
+  }
+
+  /** Break a stem into lowercase word parts regardless of its current style. */
+  function _words(stem) {
+    return String(stem || '')
+      .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // camel/Pascal boundaries
+      .replace(/[-_]+/g, ' ')                 // kebab / snake separators
+      .trim()
+      .split(/\s+/)
+      .filter(Boolean)
+      .map((w) => w.toLowerCase());
+  }
+
+  const _cap = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+
+  /**
+   * Convert a file stem to a target naming style.
+   * @param {string} stem name without extension
+   * @param {'PascalCase'|'camelCase'|'kebab-case'|'snake_case'} style
+   * @returns {string}
+   */
+  function toNamingStyle(stem, style) {
+    const w = _words(stem);
+    if (w.length === 0) return String(stem || '');
+    switch (style) {
+      case 'PascalCase': return w.map(_cap).join('');
+      case 'camelCase': return w[0] + w.slice(1).map(_cap).join('');
+      case 'kebab-case': return w.join('-');
+      case 'snake_case': return w.join('_');
+      default: return String(stem || '');
+    }
+  }
+
+  /** Rename suggestion to bring a file to the dominant naming style. */
+  function renameSuggestion(filename, dominantStyle) {
+    const { stem, ext } = _splitName(filename);
+    const to = toNamingStyle(stem, dominantStyle) + ext;
+    return { from: filename, to };
+  }
+
+  const LABELS = {
+    fileNaming: 'file naming',
+    exportStyle: 'export style',
+  };
+
+  /**
+   * Analyze an `extractConventions` result for conflicts.
+   * @param {object} result the object returned by `extractConventions`
+   * @returns {{ hasConflicts: boolean, conventions: Array<{
+   *   key:string, name:string, dominant:string|null, dominantPct:number,
+   *   tier:string, total:number,
+   *   variants:Array<{pattern:string,count:number,pct:number,examples:string[]}>,
+   *   renames:Array<{from:string,to:string}> }> }}
+   */
+  function analyzeConflicts(result) {
+    const out = [];
+    for (const key of ['fileNaming', 'exportStyle']) {
+      const conv = result && result[key];
+      // A conflict is any convention with more than one observed pattern.
+      if (!conv || conv.total === 0 || conv.variants.length < 2) continue;
+
+      const variants = conv.variants.map((v) => ({
+        pattern: v.label,
+        count: v.count,
+        pct: v.pct,
+        examples: v.examples || [],
+      }));
+
+      // Rename suggestions only for file naming (export style is a code change, not a rename).
+      const renames = [];
+      if (key === 'fileNaming' && conv.dominant) {
+        for (const v of conv.variants) {
+          if (v.label === conv.dominant) continue;
+          for (const ex of (v.examples || [])) {
+            renames.push(renameSuggestion(ex, conv.dominant));
+          }
+        }
+      }
+
+      out.push({
+        key,
+        name: LABELS[key] || key,
+        dominant: conv.dominant,
+        dominantPct: conv.dominantPct,
+        tier: conv.tier,
+        total: conv.total,
+        variants,
+        renames,
+      });
+    }
+    return { hasConflicts: out.length > 0, conventions: out };
+  }
+
+  module.exports = { analyzeConflicts, toNamingStyle, renameSuggestion };
+  
+};
+
 __factories["./src/conventions/extract"] = function(module, exports) {
   
   /**
@@ -6786,7 +7003,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '7.7.0',
+    version: '7.9.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -12464,7 +12681,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '7.7.0';
+const VERSION = '7.9.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -15642,6 +15859,55 @@ function main() {
     const files = buildFileList(cwd, config);
     const result = extractConventions(cwd, files);
 
+    // `--inject`: write/update the conventions block in CLAUDE.md (idempotent).
+    if (args.includes('--inject')) {
+      const { renderConventionsBlock, injectConventions } = requireSourceOrBundled('./src/conventions/inject');
+      const claudePath = path.join(cwd, 'CLAUDE.md');
+      let existing = '';
+      try { if (fs.existsSync(claudePath)) existing = fs.readFileSync(claudePath, 'utf8'); } catch (_) {}
+      const block = renderConventionsBlock(result, VERSION);
+      try {
+        fs.writeFileSync(claudePath, injectConventions(existing, block));
+      } catch (e) {
+        console.error(`[sigmap] cannot write ${claudePath}: ${e.message}`);
+        process.exit(1);
+      }
+      console.log(`[sigmap] conventions → injected block into ${path.relative(cwd, claudePath) || 'CLAUDE.md'}`);
+      process.exit(0);
+    }
+
+    // `--conflicts`: surface why a convention is mixed (breakdown + rename suggestions).
+    if (args.includes('--conflicts')) {
+      const { analyzeConflicts } = requireSourceOrBundled('./src/conventions/conflicts');
+      const report = analyzeConflicts(result);
+      if (jsonOut) {
+        process.stdout.write(JSON.stringify(report) + '\n');
+        process.exit(0);
+      }
+      const pctC = (n) => `${(n * 100).toFixed(0)}%`;
+      if (!report.hasConflicts) {
+        console.log('[sigmap] conventions --conflicts  (TS/JS/Python)');
+        console.log('  no conflicts — conventions are consistent ✓');
+        process.exit(0);
+      }
+      console.log('[sigmap] conventions --conflicts  (TS/JS/Python)');
+      for (const c of report.conventions) {
+        console.log(`\n  ${c.name} — dominant: ${c.dominant} ${pctC(c.dominantPct)} [${c.tier}]`);
+        for (const v of c.variants) {
+          const barLen = Math.max(1, Math.round(v.pct * 20));
+          const bar = '█'.repeat(barLen);
+          const tag = v.pattern === c.dominant ? ' (dominant)' : '';
+          const ex = v.examples.length ? `  e.g. ${v.examples.join(', ')}` : '';
+          console.log(`    ${v.pattern.padEnd(12)} ${String(v.count).padStart(4)}  ${pctC(v.pct).padStart(4)} ${bar}${tag}${ex}`);
+        }
+        if (c.renames.length) {
+          console.log(`    rename to match ${c.dominant}:`);
+          for (const r of c.renames) console.log(`      ${r.from}  →  ${r.to}`);
+        }
+      }
+      process.exit(0);
+    }
+
     const outDir = path.join(cwd, '.context');
     const outPath = path.join(outDir, 'conventions.json');
     try {

package/llms-full.txt

@@ -9,7 +9,7 @@ the files relevant to the task — cutting tokens ~97% while keeping answers
 grounded. Deterministic, offline, no embeddings or vector database. Works with
 Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 7.7.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.9.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
 # Source: auto-generated from package.json, version.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 

package/llms.txt

@@ -9,7 +9,7 @@ the files relevant to the task — cutting tokens ~97% while keeping answers
 grounded. Deterministic, offline, no embeddings or vector database. Works with
 Claude, Cursor, GitHub Copilot, Aider, Windsurf, local LLMs, and MCP.
 
-# Version: 7.7.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.9.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
 # Source: auto-generated from package.json, version.json, src/mcp/tools.js, src/config/defaults.js
 # Regenerate: npm run generate:llms   |   Validate: npm run validate:llms
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "7.7.0",
+  "version": "7.9.0",
   "description": "97% token reduction for AI coding. Extracts function & class signatures with TF-IDF ranking to feed only the right files to Claude, Cursor, Copilot, Aider, Windsurf, local LLMs & MCP. Zero dependencies, runs offline via npx.",
   "main": "packages/core/index.js",
   "exports": {

package/packages/cli/package.json

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

package/packages/core/package.json

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

package/src/conventions/conflicts.js

@@ -0,0 +1,111 @@
+'use strict';
+
+/**
+ * Convention conflict analysis (IMPL.md §4 / §5.3 — grounded codegen, Layer 3).
+ *
+ * Given an `extractConventions` result, surface *why* a convention is mixed:
+ * every variant pattern with its file count, share, and example files, plus
+ * rename suggestions that move minority file-naming files toward the dominant
+ * style. Pure, zero-dependency, bundle-safe.
+ */
+
+/** Split a file name into its stem (before the first dot) and the rest. */
+function _splitName(filename) {
+  const s = String(filename || '');
+  const dot = s.indexOf('.');
+  if (dot <= 0) return { stem: s, ext: '' };
+  return { stem: s.slice(0, dot), ext: s.slice(dot) };
+}
+
+/** Break a stem into lowercase word parts regardless of its current style. */
+function _words(stem) {
+  return String(stem || '')
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2') // camel/Pascal boundaries
+    .replace(/[-_]+/g, ' ')                 // kebab / snake separators
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.toLowerCase());
+}
+
+const _cap = (w) => w.charAt(0).toUpperCase() + w.slice(1);
+
+/**
+ * Convert a file stem to a target naming style.
+ * @param {string} stem name without extension
+ * @param {'PascalCase'|'camelCase'|'kebab-case'|'snake_case'} style
+ * @returns {string}
+ */
+function toNamingStyle(stem, style) {
+  const w = _words(stem);
+  if (w.length === 0) return String(stem || '');
+  switch (style) {
+    case 'PascalCase': return w.map(_cap).join('');
+    case 'camelCase': return w[0] + w.slice(1).map(_cap).join('');
+    case 'kebab-case': return w.join('-');
+    case 'snake_case': return w.join('_');
+    default: return String(stem || '');
+  }
+}
+
+/** Rename suggestion to bring a file to the dominant naming style. */
+function renameSuggestion(filename, dominantStyle) {
+  const { stem, ext } = _splitName(filename);
+  const to = toNamingStyle(stem, dominantStyle) + ext;
+  return { from: filename, to };
+}
+
+const LABELS = {
+  fileNaming: 'file naming',
+  exportStyle: 'export style',
+};
+
+/**
+ * Analyze an `extractConventions` result for conflicts.
+ * @param {object} result the object returned by `extractConventions`
+ * @returns {{ hasConflicts: boolean, conventions: Array<{
+ *   key:string, name:string, dominant:string|null, dominantPct:number,
+ *   tier:string, total:number,
+ *   variants:Array<{pattern:string,count:number,pct:number,examples:string[]}>,
+ *   renames:Array<{from:string,to:string}> }> }}
+ */
+function analyzeConflicts(result) {
+  const out = [];
+  for (const key of ['fileNaming', 'exportStyle']) {
+    const conv = result && result[key];
+    // A conflict is any convention with more than one observed pattern.
+    if (!conv || conv.total === 0 || conv.variants.length < 2) continue;
+
+    const variants = conv.variants.map((v) => ({
+      pattern: v.label,
+      count: v.count,
+      pct: v.pct,
+      examples: v.examples || [],
+    }));
+
+    // Rename suggestions only for file naming (export style is a code change, not a rename).
+    const renames = [];
+    if (key === 'fileNaming' && conv.dominant) {
+      for (const v of conv.variants) {
+        if (v.label === conv.dominant) continue;
+        for (const ex of (v.examples || [])) {
+          renames.push(renameSuggestion(ex, conv.dominant));
+        }
+      }
+    }
+
+    out.push({
+      key,
+      name: LABELS[key] || key,
+      dominant: conv.dominant,
+      dominantPct: conv.dominantPct,
+      tier: conv.tier,
+      total: conv.total,
+      variants,
+      renames,
+    });
+  }
+  return { hasConflicts: out.length > 0, conventions: out };
+}
+
+module.exports = { analyzeConflicts, toNamingStyle, renameSuggestion };

package/src/conventions/extract.js

@@ -42,24 +42,42 @@ function classifyNaming(basename) {
   return 'other';
 }
 
+const MAX_EXAMPLES = 3;
+
 /**
  * Score a set of categorical observations into a dominant convention plus its
  * consistency tier. The reusable primitive (IMPL.md §5.2).
  * @param {string[]} labels observed category for each sample (e.g. naming styles)
+ * @param {string[]} [refs] optional identifier (e.g. file name) parallel to
+ *   `labels`; when given, each variant carries up to 3 `examples`.
  * @returns {{ dominant: string|null, dominantPct: number, total: number,
- *             variants: Array<{label:string, count:number, pct:number}>,
+ *             variants: Array<{label:string, count:number, pct:number, examples?:string[]}>,
  *             tier: 'consistent'|'mostly'|'inconsistent'|'unknown' }}
  */
-function scoreConvention(labels) {
-  const list = (labels || []).filter((l) => l != null && l !== 'other');
-  const total = list.length;
+function scoreConvention(labels, refs) {
+  const all = labels || [];
+  const counts = new Map();
+  const examples = new Map();
+  let total = 0;
+  for (let i = 0; i < all.length; i++) {
+    const l = all[i];
+    if (l == null || l === 'other') continue;
+    total++;
+    counts.set(l, (counts.get(l) || 0) + 1);
+    if (refs && refs[i] != null) {
+      const ex = examples.get(l) || [];
+      if (ex.length < MAX_EXAMPLES) { ex.push(refs[i]); examples.set(l, ex); }
+    }
+  }
   if (total === 0) {
     return { dominant: null, dominantPct: 0, total: 0, variants: [], tier: 'unknown' };
   }
-  const counts = new Map();
-  for (const l of list) counts.set(l, (counts.get(l) || 0) + 1);
   const variants = [...counts.entries()]
-    .map(([label, count]) => ({ label, count, pct: count / total }))
+    .map(([label, count]) => {
+      const v = { label, count, pct: count / total };
+      if (refs) v.examples = examples.get(label) || [];
+      return v;
+    })
     .sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
   const top = variants[0];
   let tier = 'inconsistent';
@@ -131,22 +149,26 @@ function _detectTestFramework(cwd, files) {
 function extractConventions(cwd, files) {
   const scoped = (files || []).filter((f) => SCOPED_EXTS.has(path.extname(f).toLowerCase()));
   const namingLabels = [];
+  const namingRefs = [];
   const exportLabels = [];
+  const exportRefs = [];
   for (const f of scoped) {
     const base = path.basename(f);
     // Skip test files for the naming convention (they have their own naming).
     if (!/\.(test|spec)\.[jt]sx?$|(^|\/)test_|_test\.py$/.test(f)) {
       namingLabels.push(classifyNaming(base));
+      namingRefs.push(base);
     }
     if (JS_TS_EXTS.has(path.extname(f).toLowerCase())) {
       let src = '';
       try { src = fs.readFileSync(f, 'utf8'); } catch (_) {}
       exportLabels.push(_jsExportStyle(src));
+      exportRefs.push(base);
     }
   }
   return {
-    fileNaming: scoreConvention(namingLabels),
-    exportStyle: scoreConvention(exportLabels),
+    fileNaming: scoreConvention(namingLabels, namingRefs),
+    exportStyle: scoreConvention(exportLabels, exportRefs),
     testFramework: _detectTestFramework(cwd, scoped),
     scope: ['typescript', 'javascript', 'python'],
     scannedFiles: scoped.length,

package/src/conventions/inject.js

@@ -0,0 +1,98 @@
+'use strict';
+
+/**
+ * CLAUDE.md convention injection (IMPL.md §7 Phase 2 / §8 step 5).
+ *
+ * Renders the conventions detected by `extractConventions` into a
+ * marker-delimited markdown block and injects it into CLAUDE.md so an agent
+ * reading the file plans grounded in the repo's house style. Idempotent and
+ * marker-scoped — it never touches human content or the `## Auto-generated
+ * signatures` block. Pure string transforms; zero-dependency, bundle-safe.
+ */
+
+const START = '<!-- sigmap-conventions:start -->';
+const END = '<!-- sigmap-conventions:end -->';
+
+const TIER_NOTE = {
+  consistent: 'consistent — match it',
+  mostly: 'dominant, with some drift',
+  inconsistent: 'no clear convention — check neighboring files',
+};
+
+const NAMES = {
+  fileNaming: 'File naming',
+  exportStyle: 'Export style',
+};
+
+const _pct = (n) => `${Math.round(n * 100)}%`;
+
+function _conventionLine(label, conv) {
+  if (!conv || conv.total === 0 || !conv.dominant) return null;
+  const note = TIER_NOTE[conv.tier] || conv.tier;
+  let line = `- **${label}:** ${conv.dominant} (${_pct(conv.dominantPct)} — ${note}).`;
+  const others = conv.variants.slice(1).filter((v) => v.pct > 0);
+  if (others.length) {
+    line += ` Variants: ${others.map((v) => `${v.label} ${_pct(v.pct)}`).join(', ')}.`;
+  }
+  return line;
+}
+
+/**
+ * Render the conventions block (including its start/end markers).
+ * @param {object} result an `extractConventions` result
+ * @param {string} [version] SigMap version for the footer
+ * @returns {string}
+ */
+function renderConventionsBlock(result, version) {
+  const lines = [];
+  for (const key of ['fileNaming', 'exportStyle']) {
+    const l = _conventionLine(NAMES[key], result && result[key]);
+    if (l) lines.push(l);
+  }
+  if (result && result.testFramework) {
+    lines.push(`- **Test framework:** ${result.testFramework}.`);
+  }
+
+  const body = lines.length
+    ? lines
+    : ['- No conventions detected yet (run `sigmap conventions` on a TS/JS/Python repo).'];
+
+  const ver = version ? ` v${version}` : '';
+  return [
+    START,
+    '## Conventions (auto-detected by SigMap)',
+    '',
+    'Match these when writing or editing code (TS/JS/Python):',
+    '',
+    ...body,
+    '',
+    `<sub>Generated by SigMap${ver} · run \`sigmap conventions --inject\` to refresh.</sub>`,
+    END,
+  ].join('\n');
+}
+
+/**
+ * Inject (or replace) the conventions block in existing CLAUDE.md content.
+ * Replaces an existing marked block in place; appends one when absent.
+ * Idempotent — never touches content outside the markers.
+ * @param {string} existing current file content ('' if the file is new)
+ * @param {string} block the block returned by `renderConventionsBlock`
+ * @returns {string}
+ */
+function injectConventions(existing, block) {
+  const src = String(existing || '');
+  const startIdx = src.indexOf(START);
+  if (startIdx !== -1) {
+    const endIdx = src.indexOf(END, startIdx);
+    if (endIdx !== -1) {
+      const before = src.slice(0, startIdx);
+      const after = src.slice(endIdx + END.length);
+      return before + block + after;
+    }
+  }
+  if (src.trim() === '') return block + '\n';
+  const sep = src.endsWith('\n') ? '\n' : '\n\n';
+  return src + sep + block + '\n';
+}
+
+module.exports = { renderConventionsBlock, injectConventions, START, END };

package/src/mcp/server.js

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