sigmap 7.6.0 → 7.8.0

package/CHANGELOG.md

@@ -10,6 +10,24 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [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).
+
+### Added
+- **`sigmap conventions` — extract & report a repo's coding conventions (#298):** the first slice of Layer 3 (grounded code generation). Detects the dominant **file naming** style, **export style**, and **test framework** for TS/JS/Python so generated code matches the house style instead of drifting (Cause 4: naming/convention drift). New zero-dependency, bundle-safe `src/conventions/extract.js` exposes `classifyNaming` (PascalCase / camelCase / kebab-case / snake_case), `scoreConvention` (a reusable consistency scorer returning `{ dominant, dominantPct, variants, tier }` with tiers at 90% / 70% — Gap 1's scaffold-confidence floor will reuse it), and `extractConventions`. The command writes `.context/conventions.json` and prints a readable report; `--json` emits machine output. `--conflicts`, `--fix`, `--ci`, and CLAUDE.md injection are deferred to follow-ups.
+
+---
+
 ## [7.6.0] — 2026-06-17
 
 Minor release — the grounding benchmark (the offline GATE for grounded codegen).

package/gen-context.js

@@ -21,6 +21,281 @@ function __require(key) {
 
 
 // ── ./src/cache/freshen ──
+// ── ./src/conventions/extract ──
+// ── ./src/conventions/conflicts ──
+__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) {
+  
+  /**
+   * Convention extraction (IMPL.md Layer 3 — grounded code generation).
+   *
+   * Detects a repo's dominant coding conventions so generated code matches the
+   * house style instead of drifting (Cause 4: naming/convention drift). This
+   * first slice covers TS/JS/Python and three conventions: file naming, export
+   * style, and test framework. `scoreConvention` is the reusable consistency
+   * primitive that Gap 1 (scaffold confidence) will also build on.
+   *
+   * Zero dependencies, bundle-safe (fs + path only).
+   */
+
+  const fs = require('fs');
+  const path = require('path');
+
+  const JS_TS_EXTS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+  const PY_EXTS = new Set(['.py']);
+  const SCOPED_EXTS = new Set([...JS_TS_EXTS, ...PY_EXTS]);
+
+  // Consistency tiers (IMPL.md §5.1): a convention is only safe to enforce when
+  // it is actually consistent.
+  const TIER_CONSISTENT = 0.9;
+  const TIER_MOSTLY = 0.7;
+
+  /**
+   * Classify a file's base name (without extension) into a naming style.
+   * @param {string} basename a file basename, e.g. "user-service.ts"
+   * @returns {'PascalCase'|'camelCase'|'kebab-case'|'snake_case'|'other'}
+   */
+  function classifyNaming(basename) {
+    let stem = String(basename || '');
+    const dot = stem.indexOf('.');
+    if (dot > 0) stem = stem.slice(0, dot); // strip ext + compound suffix (.test, .d)
+    if (!stem) return 'other';
+    if (/[-]/.test(stem) && /^[a-z0-9]+(?:-[a-z0-9]+)+$/.test(stem)) return 'kebab-case';
+    if (/[_]/.test(stem) && /^[a-z0-9]+(?:_[a-z0-9]+)+$/.test(stem)) return 'snake_case';
+    if (/^[A-Z][A-Za-z0-9]*$/.test(stem) && /[a-z]/.test(stem)) return 'PascalCase';
+    if (/^[a-z][A-Za-z0-9]*$/.test(stem) && /[A-Z]/.test(stem)) return 'camelCase';
+    if (/^[a-z][a-z0-9]*$/.test(stem)) return 'camelCase'; // single lowercase word
+    return 'other';
+  }
+
+  /**
+   * 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)
+   * @returns {{ dominant: string|null, dominantPct: number, total: number,
+   *             variants: Array<{label:string, count:number, pct:number}>,
+   *             tier: 'consistent'|'mostly'|'inconsistent'|'unknown' }}
+   */
+  function scoreConvention(labels) {
+    const list = (labels || []).filter((l) => l != null && l !== 'other');
+    const total = list.length;
+    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 }))
+      .sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+    const top = variants[0];
+    let tier = 'inconsistent';
+    if (top.pct >= TIER_CONSISTENT) tier = 'consistent';
+    else if (top.pct >= TIER_MOSTLY) tier = 'mostly';
+    return {
+      dominant: top.label,
+      dominantPct: top.pct,
+      total,
+      variants,
+      tier,
+    };
+  }
+
+  /** Detect JS/TS export style for a single file's source. */
+  function _jsExportStyle(src) {
+    const s = String(src || '');
+    if (/\bexport\s+default\b/.test(s) || /\bmodule\.exports\s*=\s*(?:function|class|\{?\s*[A-Za-z_$])/.test(s)) {
+      // module.exports = { a, b } reads as named; only treat bare assignment as default.
+      if (/\bexport\s+default\b/.test(s)) return 'default';
+      if (/\bmodule\.exports\s*=\s*\{/.test(s)) return 'named';
+      return 'default';
+    }
+    if (/\bexport\s+(?:const|let|var|function|class|async\s+function|\{|type|interface|enum)\b/.test(s)
+      || /\bmodule\.exports\s*=\s*\{/.test(s) || /\bexports\.[A-Za-z_$]/.test(s)) {
+      return 'named';
+    }
+    return 'other';
+  }
+
+  /** Detect the test framework in use from manifests + source heuristics. */
+  function _detectTestFramework(cwd, files) {
+    const deps = {};
+    try {
+      const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+      Object.assign(deps, pkg.dependencies, pkg.devDependencies);
+    } catch (_) {}
+    for (const fw of ['vitest', 'jest', 'mocha', 'ava', 'jasmine']) {
+      if (deps[fw]) return fw;
+    }
+    // Python: pytest in requirements / pyproject.
+    for (const manifest of ['requirements.txt', 'requirements-dev.txt', 'pyproject.toml', 'setup.cfg']) {
+      try {
+        const raw = fs.readFileSync(path.join(cwd, manifest), 'utf8');
+        if (/\bpytest\b/.test(raw)) return 'pytest';
+        if (/\bunittest\b/.test(raw)) return 'unittest';
+      } catch (_) {}
+    }
+    // Fallback: infer from test file contents.
+    for (const f of files) {
+      if (!/\.(test|spec)\.[jt]sx?$|(^|\/)test_|_test\.py$/.test(f)) continue;
+      let src = '';
+      try { src = fs.readFileSync(f, 'utf8'); } catch (_) { continue; }
+      if (/\bvi\.(fn|mock|spyOn)\b|from ['"]vitest['"]/.test(src)) return 'vitest';
+      if (/\bjest\.(fn|mock|spyOn)\b/.test(src)) return 'jest';
+      if (/\bimport pytest\b|@pytest\./.test(src)) return 'pytest';
+      if (/\bdescribe\(|\bit\(/.test(src)) return 'mocha/jest-style';
+    }
+    return null;
+  }
+
+  /**
+   * Extract repo coding conventions for the scoped languages (TS/JS/Python).
+   * @param {string} cwd repo root
+   * @param {string[]} files absolute paths to source files (e.g. from buildFileList)
+   * @returns {{ fileNaming: object, exportStyle: object, testFramework: string|null,
+   *             scope: string[], scannedFiles: number }}
+   */
+  function extractConventions(cwd, files) {
+    const scoped = (files || []).filter((f) => SCOPED_EXTS.has(path.extname(f).toLowerCase()));
+    const namingLabels = [];
+    const exportLabels = [];
+    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));
+      }
+      if (JS_TS_EXTS.has(path.extname(f).toLowerCase())) {
+        let src = '';
+        try { src = fs.readFileSync(f, 'utf8'); } catch (_) {}
+        exportLabels.push(_jsExportStyle(src));
+      }
+    }
+    return {
+      fileNaming: scoreConvention(namingLabels),
+      exportStyle: scoreConvention(exportLabels),
+      testFramework: _detectTestFramework(cwd, scoped),
+      scope: ['typescript', 'javascript', 'python'],
+      scannedFiles: scoped.length,
+    };
+  }
+
+  module.exports = { classifyNaming, scoreConvention, extractConventions };
+  
+};
+
 __factories["./src/cache/freshen"] = function(module, exports) {
   
   /**
@@ -6626,7 +6901,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '7.6.0',
+    version: '7.8.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -12304,7 +12579,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '7.6.0';
+const VERSION = '7.8.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -15473,6 +15748,80 @@ function main() {
     process.exit(0);
   }
 
+  // Layer 3: `sigmap conventions` — extract & report repo coding conventions
+  // (file naming, export style, test framework) for TS/JS/Python so generated
+  // code matches the house style. Writes .context/conventions.json.
+  if (args[0] === 'conventions') {
+    const jsonOut = args.includes('--json');
+    const { extractConventions } = requireSourceOrBundled('./src/conventions/extract');
+    const files = buildFileList(cwd, config);
+    const result = extractConventions(cwd, files);
+
+    // `--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 {
+      fs.mkdirSync(outDir, { recursive: true });
+      fs.writeFileSync(outPath, JSON.stringify(result, null, 2) + '\n');
+    } catch (e) {
+      console.error(`[sigmap] cannot write ${outPath}: ${e.message}`);
+      process.exit(1);
+    }
+
+    if (jsonOut) {
+      process.stdout.write(JSON.stringify(result) + '\n');
+      process.exit(0);
+    }
+
+    const pct = (n) => `${(n * 100).toFixed(0)}%`;
+    const tierLabel = { consistent: 'consistent', mostly: 'mostly', inconsistent: 'mixed', unknown: 'n/a' };
+    const line = (name, conv) => {
+      if (!conv || conv.total === 0) return `  ${name.padEnd(14)} n/a (no samples)`;
+      const variants = conv.variants.slice(1, 3).map((v) => `${v.label} ${pct(v.pct)}`).join(', ');
+      const tail = variants ? `  ·  also: ${variants}` : '';
+      return `  ${name.padEnd(14)} ${conv.dominant} ${pct(conv.dominantPct)} [${tierLabel[conv.tier]}]${tail}`;
+    };
+
+    console.log('[sigmap] conventions  (TS/JS/Python)');
+    console.log(`  scanned        ${result.scannedFiles} file${result.scannedFiles === 1 ? '' : 's'}`);
+    console.log(line('file naming', result.fileNaming));
+    console.log(line('export style', result.exportStyle));
+    console.log(`  ${'test framework'.padEnd(14)} ${result.testFramework || 'none detected'}`);
+    console.log(`\n  → wrote ${path.relative(cwd, outPath)}`);
+    process.exit(0);
+  }
+
   // v7.0.0: `sigmap squeeze <file|->` — minimize a pasted stacktrace / CI-log / JSON blob
   if (args[0] === 'squeeze') {
     const jsonOut = args.includes('--json');

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.6.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.8.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.6.0 | Benchmark: sigmap-v7.0-main (2026-06-14)
+# Version: 7.8.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.6.0",
+  "version": "7.8.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.6.0",
+  "version": "7.8.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.6.0",
+  "version": "7.8.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

@@ -0,0 +1,178 @@
+'use strict';
+
+/**
+ * Convention extraction (IMPL.md Layer 3 — grounded code generation).
+ *
+ * Detects a repo's dominant coding conventions so generated code matches the
+ * house style instead of drifting (Cause 4: naming/convention drift). This
+ * first slice covers TS/JS/Python and three conventions: file naming, export
+ * style, and test framework. `scoreConvention` is the reusable consistency
+ * primitive that Gap 1 (scaffold confidence) will also build on.
+ *
+ * Zero dependencies, bundle-safe (fs + path only).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const JS_TS_EXTS = new Set(['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs']);
+const PY_EXTS = new Set(['.py']);
+const SCOPED_EXTS = new Set([...JS_TS_EXTS, ...PY_EXTS]);
+
+// Consistency tiers (IMPL.md §5.1): a convention is only safe to enforce when
+// it is actually consistent.
+const TIER_CONSISTENT = 0.9;
+const TIER_MOSTLY = 0.7;
+
+/**
+ * Classify a file's base name (without extension) into a naming style.
+ * @param {string} basename a file basename, e.g. "user-service.ts"
+ * @returns {'PascalCase'|'camelCase'|'kebab-case'|'snake_case'|'other'}
+ */
+function classifyNaming(basename) {
+  let stem = String(basename || '');
+  const dot = stem.indexOf('.');
+  if (dot > 0) stem = stem.slice(0, dot); // strip ext + compound suffix (.test, .d)
+  if (!stem) return 'other';
+  if (/[-]/.test(stem) && /^[a-z0-9]+(?:-[a-z0-9]+)+$/.test(stem)) return 'kebab-case';
+  if (/[_]/.test(stem) && /^[a-z0-9]+(?:_[a-z0-9]+)+$/.test(stem)) return 'snake_case';
+  if (/^[A-Z][A-Za-z0-9]*$/.test(stem) && /[a-z]/.test(stem)) return 'PascalCase';
+  if (/^[a-z][A-Za-z0-9]*$/.test(stem) && /[A-Z]/.test(stem)) return 'camelCase';
+  if (/^[a-z][a-z0-9]*$/.test(stem)) return 'camelCase'; // single lowercase word
+  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, examples?:string[]}>,
+ *             tier: 'consistent'|'mostly'|'inconsistent'|'unknown' }}
+ */
+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 variants = [...counts.entries()]
+    .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';
+  if (top.pct >= TIER_CONSISTENT) tier = 'consistent';
+  else if (top.pct >= TIER_MOSTLY) tier = 'mostly';
+  return {
+    dominant: top.label,
+    dominantPct: top.pct,
+    total,
+    variants,
+    tier,
+  };
+}
+
+/** Detect JS/TS export style for a single file's source. */
+function _jsExportStyle(src) {
+  const s = String(src || '');
+  if (/\bexport\s+default\b/.test(s) || /\bmodule\.exports\s*=\s*(?:function|class|\{?\s*[A-Za-z_$])/.test(s)) {
+    // module.exports = { a, b } reads as named; only treat bare assignment as default.
+    if (/\bexport\s+default\b/.test(s)) return 'default';
+    if (/\bmodule\.exports\s*=\s*\{/.test(s)) return 'named';
+    return 'default';
+  }
+  if (/\bexport\s+(?:const|let|var|function|class|async\s+function|\{|type|interface|enum)\b/.test(s)
+    || /\bmodule\.exports\s*=\s*\{/.test(s) || /\bexports\.[A-Za-z_$]/.test(s)) {
+    return 'named';
+  }
+  return 'other';
+}
+
+/** Detect the test framework in use from manifests + source heuristics. */
+function _detectTestFramework(cwd, files) {
+  const deps = {};
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+    Object.assign(deps, pkg.dependencies, pkg.devDependencies);
+  } catch (_) {}
+  for (const fw of ['vitest', 'jest', 'mocha', 'ava', 'jasmine']) {
+    if (deps[fw]) return fw;
+  }
+  // Python: pytest in requirements / pyproject.
+  for (const manifest of ['requirements.txt', 'requirements-dev.txt', 'pyproject.toml', 'setup.cfg']) {
+    try {
+      const raw = fs.readFileSync(path.join(cwd, manifest), 'utf8');
+      if (/\bpytest\b/.test(raw)) return 'pytest';
+      if (/\bunittest\b/.test(raw)) return 'unittest';
+    } catch (_) {}
+  }
+  // Fallback: infer from test file contents.
+  for (const f of files) {
+    if (!/\.(test|spec)\.[jt]sx?$|(^|\/)test_|_test\.py$/.test(f)) continue;
+    let src = '';
+    try { src = fs.readFileSync(f, 'utf8'); } catch (_) { continue; }
+    if (/\bvi\.(fn|mock|spyOn)\b|from ['"]vitest['"]/.test(src)) return 'vitest';
+    if (/\bjest\.(fn|mock|spyOn)\b/.test(src)) return 'jest';
+    if (/\bimport pytest\b|@pytest\./.test(src)) return 'pytest';
+    if (/\bdescribe\(|\bit\(/.test(src)) return 'mocha/jest-style';
+  }
+  return null;
+}
+
+/**
+ * Extract repo coding conventions for the scoped languages (TS/JS/Python).
+ * @param {string} cwd repo root
+ * @param {string[]} files absolute paths to source files (e.g. from buildFileList)
+ * @returns {{ fileNaming: object, exportStyle: object, testFramework: string|null,
+ *             scope: string[], scannedFiles: number }}
+ */
+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, namingRefs),
+    exportStyle: scoreConvention(exportLabels, exportRefs),
+    testFramework: _detectTestFramework(cwd, scoped),
+    scope: ['typescript', 'javascript', 'python'],
+    scannedFiles: scoped.length,
+  };
+}
+
+module.exports = { classifyNaming, scoreConvention, extractConventions };

package/src/mcp/server.js

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