sigmap 7.7.0 → 7.8.0

package/CHANGELOG.md

@@ -10,6 +10,15 @@ 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).

package/gen-context.js

@@ -22,6 +22,121 @@ 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) {
   
   /**
@@ -6786,7 +6901,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
 
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '7.7.0',
+    version: '7.8.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
 
@@ -12464,7 +12579,7 @@ function __tryGit(args, opts = {}) {
   catch (_) { return ''; }
 }
 
-const VERSION = '7.7.0';
+const VERSION = '7.8.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -15642,6 +15757,38 @@ function main() {
     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 {

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.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.7.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.7.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.7.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.7.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

@@ -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/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.8.0',
   description: 'SigMap MCP server — code signatures on demand',
 };