sigmap 3.4.0 → 3.5.1

package/gen-context.js

@@ -2179,6 +2179,285 @@ __factories["./src/extractors/markdown"] = function(module, exports) {
   
 };
 
+// ── ./src/extractors/typescript_react ──
+__factories["./src/extractors/typescript_react"] = function(module, exports) {
+  
+  'use strict';
+  
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+    const stripped = src
+      .replace(/\/\*[\s\S]*?\*\//g, '')
+      .replace(/\/\/.*$/gm, '');
+    const compRe = /(?:export\s+)?(?:const|function)\s+([A-Z]\w*)\s*(?:<[^>]*>)?\s*\(\s*(?:props|{\s*[^}]*})?/g;
+    for (const m of stripped.matchAll(compRe)) {
+      sigs.push(`component ${m[1]}`);
+    }
+    const propsRe = /interface\s+(\w*Props)\s*(?:<[^>]*>)?\s*{/g;
+    for (const m of stripped.matchAll(propsRe)) {
+      sigs.push(`props ${m[1]}`);
+    }
+    const hookRe = /use([A-Z]\w*)\s*(?:<[^>]*>)?\s*\(/g;
+    const hooks = new Set();
+    for (const m of stripped.matchAll(hookRe)) {
+      hooks.add(m[1]);
+    }
+    for (const h of hooks) {
+      sigs.push(`hook use${h}`);
+    }
+    const exportRe = /export\s+(?:const|function|default|interface|type)\s+([A-Z]\w*)/g;
+    for (const m of stripped.matchAll(exportRe)) {
+      sigs.push(`export ${m[1]}`);
+    }
+    const handlerRe = /on([A-Z]\w+)\s*=\s*{?\s*\(?[a-zA-Z_$]/g;
+    const handlers = new Set();
+    for (const m of stripped.matchAll(handlerRe)) {
+      handlers.add(m[1]);
+    }
+    for (const h of handlers) {
+      sigs.push(`handler on${h}`);
+    }
+    return Array.from(new Set(sigs)).slice(0, 50);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/vue_sfc ──
+__factories["./src/extractors/vue_sfc"] = function(module, exports) {
+  
+  'use strict';
+  
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+    const scriptMatch = src.match(/<script[^>]*>([\s\S]*?)<\/script>/);
+    if (!scriptMatch) return sigs;
+    const script = scriptMatch[1];
+    const nameRe = /(?:name\s*:\s*['"`]([a-zA-Z0-9]+)['"`]|export\s+default\s+defineComponent\s*\(\s*{\s*name\s*:\s*['"`]([a-zA-Z0-9]+)['"`])/;
+    const nameMatch = script.match(nameRe);
+    if (nameMatch) {
+      sigs.push(`component ${nameMatch[1] || nameMatch[2]}`);
+    }
+    const propsRe = /props\s*:\s*{([^}]*)}/;
+    const propsMatch = script.match(propsRe);
+    if (propsMatch) {
+      const propLines = propsMatch[1].split(',');
+      for (const line of propLines) {
+        const propName = line.trim().match(/([a-zA-Z_$]\w*)/);
+        if (propName) sigs.push(`prop ${propName[1]}`);
+      }
+    }
+    const definePropsRe = /defineProps\s*(?:<([^>]+)>)?\s*\(/;
+    if (definePropsRe.test(script)) {
+      sigs.push('props composition-api');
+    }
+    const emitsRe = /emits\s*:\s*\[([^\]]+)\]/;
+    const emitsMatch = script.match(emitsRe);
+    if (emitsMatch) {
+      const emitNames = emitsMatch[1].split(',').map(e => e.trim().replace(/['"`]/g, ''));
+      for (const e of emitNames) {
+        if (e) sigs.push(`emit ${e}`);
+      }
+    }
+    const defineEmitsRe = /defineEmits\s*(?:<([^>]+)>)?\s*\(/;
+    if (defineEmitsRe.test(script)) {
+      sigs.push('emits composition-api');
+    }
+    const lifecycleHooks = ['setup', 'created', 'mounted', 'updated', 'unmounted'];
+    for (const hook of lifecycleHooks) {
+      if (new RegExp(`\\b${hook}\\s*\\(`).test(script)) {
+        sigs.push(`lifecycle ${hook}`);
+      }
+    }
+    const namedSlotRe = /<slot\s+name=['"]([a-zA-Z_$]\w*)['"][^>]*>/g;
+    const templateSlotRe = /<template\s+#([a-zA-Z_$]\w*)|v-slot:([a-zA-Z_$]\w*)/g;
+    const slots = new Set();
+    for (const m of src.matchAll(namedSlotRe)) {
+      if (m[1]) slots.add(m[1]);
+    }
+    for (const m of src.matchAll(templateSlotRe)) {
+      const slotName = m[1] || m[2];
+      if (slotName) slots.add(slotName);
+    }
+    for (const s of slots) {
+      sigs.push(`slot ${s}`);
+    }
+    return Array.from(new Set(sigs)).slice(0, 50);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/python_dataclass ──
+__factories["./src/extractors/python_dataclass"] = function(module, exports) {
+  
+  'use strict';
+  
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+    const dataclassRe = /@dataclass(?:\([^)]*\))?[\s\n]+class\s+([A-Z]\w*)/g;
+    for (const m of src.matchAll(dataclassRe)) {
+      sigs.push(`dataclass ${m[1]}`);
+    }
+    const pydanticRe = /class\s+([A-Z]\w*)\s*\([^)]*BaseModel[^)]*\)/g;
+    for (const m of src.matchAll(pydanticRe)) {
+      sigs.push(`model ${m[1]}`);
+    }
+    if (/model_validate|field_validator|computed_field/.test(src)) {
+      sigs.push('pydantic v2+');
+    }
+    const sqlalchemyRe = /class\s+([A-Z]\w*)\s*\([^)]*(?:Base|declarative_base)[^)]*\)/g;
+    for (const m of src.matchAll(sqlalchemyRe)) {
+      sigs.push(`orm ${m[1]}`);
+    }
+    const fieldRe = /^\s+([a-z_]\w*)\s*:\s*([A-Z]\w*|List|Dict|Optional|Union)[^=]*/gm;
+    const fields = new Set();
+    for (const m of src.matchAll(fieldRe)) {
+      if (fields.size < 15) fields.add(m[1]);
+    }
+    for (const f of fields) {
+      sigs.push(`field ${f}`);
+    }
+    const columnRe = /([a-z_]\w*)\s*=\s*Column\s*\([^)]*\)/g;
+    for (const m of src.matchAll(columnRe)) {
+      sigs.push(`column ${m[1]}`);
+    }
+    const relRe = /(?:ForeignKey|relationship)\s*\(\s*['"]([a-zA-Z_]\w*)['"]/g;
+    for (const m of src.matchAll(relRe)) {
+      sigs.push(`relation ${m[1]}`);
+    }
+    const validatorRe = /@(?:validator|field_validator)\s*\(\s*['"]?([a-z_]\w*)(?:['"]|,|\s|\))/g;
+    const validators = new Set();
+    for (const m of src.matchAll(validatorRe)) {
+      validators.add(m[1]);
+    }
+    for (const v of validators) {
+      sigs.push(`validator ${v}`);
+    }
+    if (/class\s+Config\s*:/.test(src)) {
+      sigs.push('config-class');
+    }
+    return Array.from(new Set(sigs)).slice(0, 50);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/patterns ──
+__factories["./src/extractors/patterns"] = function(module, exports) {
+  
+  'use strict';
+  
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+
+    // Service container / factory patterns
+    const containerRe = /(?:class|function|const)\s+([A-Z]\w*(?:Container|Factory|Registry|Provider|Injector))\b/g;
+    for (const m of src.matchAll(containerRe)) {
+      sigs.push(`di-container ${m[1]}`);
+    }
+
+    // Service decorators: @Injectable, @Service, @Singleton, @Provide
+    const decoratorRe = /@(?:Injectable|Service|Singleton|Provide|Module|Component)\s*(?:\([^)]*\))?\s*(?:class|export\s+class|const\s+)\s+([A-Z]\w*)/g;
+    for (const m of src.matchAll(decoratorRe)) {
+      sigs.push(`service-decorated ${m[1]}`);
+    }
+
+    // Dependency injection via constructor: constructor(private readonly ...: Service)
+    const ctorDiRe = /constructor\s*\([^)]*(?:private|protected)?\s+(?:readonly\s+)?([a-z_]\w*)\s*:\s*([A-Z]\w*)/g;
+    const diServices = new Set();
+    for (const m of src.matchAll(ctorDiRe)) {
+      diServices.add(m[1]);
+    }
+    if (diServices.size > 0) {
+      sigs.push(`di-injection ${diServices.size} params`);
+    }
+
+    // Repository pattern: extends Repository, implements IRepository
+    const repoRe = /class\s+([A-Z]\w*(?:Repository|Repo|DataAccess))\b/g;
+    for (const m of src.matchAll(repoRe)) {
+      sigs.push(`repo ${m[1]}`);
+    }
+
+    // Service layer: @Service or ServiceImpl pattern
+    const serviceRe = /(?:export\s+)?class\s+([A-Z]\w*Service\b)/g;
+    for (const m of src.matchAll(serviceRe)) {
+      sigs.push(`service ${m[1]}`);
+    }
+
+    // Middleware detection: app.use(), router.use(), middleware function
+    if (/app\.use\s*\(|router\.use\s*\(|\.use\s*\(\s*function|middleware|app\.get\s*\(\s*['"`]\/[^'"`]*['"`]/.test(src)) {
+      sigs.push('middleware-present');
+    }
+
+    // Export type/interface followed by class implementing it
+    const exportTypeRe = /export\s+(?:type|interface)\s+([A-Z]\w*)/g;
+    const exportedTypes = new Set();
+    for (const m of src.matchAll(exportTypeRe)) {
+      exportedTypes.add(m[1]);
+    }
+
+    // Check if exported types have implementations
+    for (const type of exportedTypes) {
+      const implRe = new RegExp(`class\\s+([A-Z]\\w*)\\s+(?:extends|implements)\\s+(?:.*\\s+)?${type}\\b`, 'i');
+      if (implRe.test(src)) {
+        sigs.push(`type-impl ${type}`);
+      }
+    }
+
+    // Unchecked nulls / optional without validation
+    if (/\?\s*{|Optional\s*<|\?\s*\.get\(\)|\?\s*\[|\?\s*\.length|\.split\(\)\.filter\(Boolean\)|if\s*\(\s*!.*\).*throw/.test(src)) {
+      sigs.push('unsafe-null-check');
+    }
+
+    // Missing validation (direct use of user input)
+    const userInputRe = /(?:request|input|params|body|query|args)\s*\[\s*['"][^'"]*['"]\s*\]|req(?:uest)?\..*\s*==|params\.split|String\(.*\)\.toLowerCase/;
+    if (userInputRe.test(src)) {
+      sigs.push('unsafe-input-validation');
+    }
+
+    // Weak error handling (catch {} or empty catch)
+    if (/catch\s*\(\s*\)\s*\{|\}\s*catch\s*\{(\s*\/\/|\s*\})/.test(src)) {
+      sigs.push('weak-error-handling');
+    }
+
+    // Direct error exposure
+    if (/throw\s+new\s+Error\(|console\s*\.\s*error|res\.status\(500\)\.send\(err\)/.test(src)) {
+      sigs.push('unsafe-error-exposure');
+    }
+
+    // Heavy imports
+    const importRe = /(?:import|require)\s+(?:{[^}]*}|[a-zA-Z_]\w*)\s+from\s+['"]\.?\.?\/[^'"]+['"]/g;
+    const importCount = (src.match(importRe) || []).length;
+    if (importCount > 5) {
+      sigs.push(`heavy-imports ${importCount}`);
+    }
+
+    // Controller/Handler layer
+    const controllerRe = /(?:class|export)\s+([A-Z]\w*(?:Controller|Handler|Route))\b/g;
+    for (const m of src.matchAll(controllerRe)) {
+      sigs.push(`controller ${m[1]}`);
+    }
+
+    // Use case / Domain logic
+    if (/UseCase|Command|Query|UseCase\b|Interactor/.test(src)) {
+      sigs.push('domain-usecase');
+    }
+
+    return Array.from(new Set(sigs)).slice(0, 60);
+  }
+  
+  module.exports = { extract };
+  
+};
+
 // ── ./src/extractors/deps ──
 __factories["./src/extractors/deps"] = function(module, exports) {
   
@@ -4199,7 +4478,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '3.4.0',
+    version: '3.5.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -5098,7 +5377,7 @@ __factories["./src/eval/analyzer"] = function(module, exports) {
   const path = require('path');
 
   const EXT_MAP = {
-    '.ts': 'typescript', '.tsx': 'typescript',
+    '.ts': 'typescript', '.tsx': 'typescript_react',
     '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
     '.py': 'python',     '.pyw': 'python',
     '.java': 'java',
@@ -5112,7 +5391,7 @@ __factories["./src/eval/analyzer"] = function(module, exports) {
     '.swift': 'swift',
     '.dart': 'dart',
     '.scala': 'scala',   '.sc': 'scala',
-    '.vue': 'vue',
+    '.vue': 'vue_sfc',
     '.svelte': 'svelte',
     '.html': 'html',     '.htm': 'html',
     '.css': 'css',       '.scss': 'css', '.sass': 'css', '.less': 'css',
@@ -5602,6 +5881,153 @@ __factories["./packages/adapters/index"] = function(module, exports) {
   module.exports = { getAdapter, listAdapters, adapt, outputsToAdapters };
 };
 
+// ── ./src/extractors/generic ──
+__factories["./src/extractors/generic"] = function(module, exports) {
+  'use strict';
+  const PATTERNS = [
+    /^(?:pub\s+)?(?:async\s+)?function\s+\w+\s*\(/,
+    /^(?:pub\s+)?(?:async\s+)?fn\s+\w+[\s(<]/,
+    /^def\s+\w+[\s(|:]/,
+    /^(?:pub\s+)?func\s+\w+\s*\(/,
+    /^(?:let|let\s+rec)\s+\w+\s*[=(]/,
+    /^class\s+\w+/,
+    /^(?:proc|sub|method)\s+\w+\s*\(/,
+  ];
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const results = [];
+    for (const raw of src.split('\n')) {
+      const line = raw.trim();
+      if (!line || /^[#\-]/.test(line) || /^\/\//.test(line) || line.includes('\0')) continue;
+      for (const pat of PATTERNS) {
+        if (pat.test(line)) { results.push(line.slice(0, 120)); break; }
+      }
+      if (results.length >= 15) break;
+    }
+    return results;
+  }
+  module.exports = { extract };
+};
+
+// ── ./src/format/llm-txt ──
+__factories["./src/format/llm-txt"] = function(module, exports) {
+  'use strict';
+  const path = require('path');
+  function outputPath(cwd) { return path.join(cwd, 'llm.txt'); }
+  function format(context, cwd, version) {
+    const name  = context.projectName || path.basename(cwd);
+    const langs = [...new Set((context.fileEntries || []).map(f => f.language).filter(Boolean))];
+    const mods  = context.srcDirs || [];
+    return [
+      `# Project: ${name}`,
+      `Languages: ${langs.join(', ') || 'unknown'}`,
+      `Root: ${mods[0] || 'src/'}`,
+      '',
+      '## Modules',
+      ...mods.map(m => `- ${m}/`),
+      '',
+      '## Key flows',
+      '- <!-- describe your main user flows here -->',
+      '',
+      '## Rules',
+      '- <!-- describe your team conventions here -->',
+      '',
+      `Generated: ${new Date().toISOString()} | SigMap v${version}`,
+    ].join('\n');
+  }
+  module.exports = { format, outputPath };
+};
+
+// ── ./src/format/llms-txt ──
+__factories["./src/format/llms-txt"] = function(module, exports) {
+  'use strict';
+  const path = require('path');
+  const fs   = require('fs');
+  const { execSync } = require('child_process');
+  function outputPath(cwd) { return path.join(cwd, 'llms.txt'); }
+  function getShortCommit(cwd) {
+    try { return execSync('git rev-parse --short HEAD', { cwd, timeout: 2000 }).toString().trim(); }
+    catch (_) { return ''; }
+  }
+  function detectVersion(cwd) {
+    try {
+      const pkg = path.join(cwd, 'package.json');
+      if (fs.existsSync(pkg)) return JSON.parse(fs.readFileSync(pkg, 'utf8')).version || '';
+    } catch (_) {}
+    return '';
+  }
+  function format(context, cwd, writtenFiles, sigmapVersion) {
+    writtenFiles  = writtenFiles  || [];
+    sigmapVersion = sigmapVersion || '';
+    const name   = context.projectName || path.basename(cwd);
+    const ver    = detectVersion(cwd);
+    const commit = getShortCommit(cwd);
+    const langs  = [...new Set((context.fileEntries || []).map(f => f.language).filter(Boolean))];
+    const lines = [
+      '# SigMap Context Index',
+      `> Generated by SigMap v${sigmapVersion} — zero-dependency AI context engine`,
+      '',
+      '## Project',
+      `- Name: ${name}`,
+    ];
+    if (ver)          lines.push(`- Version: ${ver}`);
+    if (langs.length) lines.push(`- Language: ${langs.join(', ')}`);
+    if (commit)       lines.push(`- Commit: ${commit}`);
+    if (writtenFiles.length) {
+      lines.push('', '## Context Files');
+      for (const f of writtenFiles) {
+        const rel   = path.relative(cwd, f.path);
+        const extra = f.tokens ? `: ${f.tokens} tokens` : '';
+        lines.push(`- [${f.label || rel}](${rel})${extra}`);
+      }
+    }
+    const mods = context.srcDirs || [];
+    if (mods.length) {
+      lines.push('', '## Source Modules');
+      for (const m of mods) lines.push(`- [${m}/](${m}/)`);
+    }
+    const top5 = (context.fileEntries || [])
+      .sort((a, b) => (b.sigs || []).length - (a.sigs || []).length)
+      .slice(0, 5);
+    if (top5.length) {
+      lines.push('', '## Key Files');
+      for (const f of top5) {
+        const rel     = path.relative(cwd, f.filePath);
+        const preview = (f.sigs || []).slice(0, 3).join(', ');
+        lines.push(`- ${rel}: ${preview}`);
+      }
+    }
+    return lines.join('\n');
+  }
+  module.exports = { format, outputPath };
+};
+
+// ── ./packages/adapters/llm-full ──
+__factories["./packages/adapters/llm-full"] = function(module, exports) {
+  'use strict';
+  const path = require('path');
+  const fs   = require('fs');
+  function outputPath(cwd) { return path.join(cwd, 'llm-full.txt'); }
+  function format(context, opts) {
+    opts = opts || {};
+    const lines = [
+      `# ${context.projectName || 'Project'} — SigMap Context`,
+      `Generated: ${new Date().toISOString()} | SigMap v${opts.version || ''}`,
+      '',
+    ];
+    for (const entry of (context.fileEntries || [])) {
+      const rel = path.relative(opts.cwd || '', entry.filePath);
+      lines.push(`## ${rel}`, '```', ...(entry.sigs || []), '```', '');
+    }
+    return lines.join('\n');
+  }
+  function write(context, cwd, opts) {
+    opts = opts || {};
+    fs.writeFileSync(outputPath(cwd), format(context, { ...opts, cwd }));
+  }
+  module.exports = { name: 'llm-full', format, outputPath, write };
+};
+
 /**
  * SigMap — gen-context.js v1.2.0
  * Zero-dependency AI context engine.
@@ -5614,7 +6040,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '3.4.0';
+const VERSION = '3.5.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -5636,7 +6062,7 @@ const { DEFAULTS } = requireSourceOrBundled('./src/config/defaults');
 // Language → extractor mapping (by file extension)
 // ---------------------------------------------------------------------------
 const EXT_MAP = {
-  '.ts': 'typescript', '.tsx': 'typescript',
+  '.ts': 'typescript', '.tsx': 'typescript_react',
   '.js': 'javascript', '.jsx': 'javascript', '.mjs': 'javascript', '.cjs': 'javascript',
   '.py': 'python', '.pyw': 'python',
   '.java': 'java',
@@ -5650,7 +6076,7 @@ const EXT_MAP = {
   '.swift': 'swift',
   '.dart': 'dart',
   '.scala': 'scala', '.sc': 'scala',
-  '.vue': 'vue',
+  '.vue': 'vue_sfc',
   '.svelte': 'svelte',
   '.html': 'html', '.htm': 'html',
   '.css': 'css', '.scss': 'css', '.sass': 'css', '.less': 'css',
@@ -5763,7 +6189,8 @@ function detectAndExtract(filePath, content, maxSigsPerFile) {
   const ext = path.extname(base).toLowerCase();
   let extractorName = EXT_MAP[ext] || null;
   if (!extractorName && isDockerfile(base)) extractorName = 'dockerfile';
-  if (!extractorName) return [];
+  // Feature 7: generic fallback — catches Nix, Elixir, Gleam, Zig, Go templates, etc.
+  if (!extractorName) extractorName = 'generic';
 
   const extractor = getExtractor(extractorName);
   if (!extractor) return [];
@@ -6701,7 +7128,37 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
       const finalTokens = estimateTokens(content);
       const formatIdx = process.argv.indexOf('--format');
       const formatValue = formatIdx >= 0 ? process.argv[formatIdx + 1] : (config.format || 'default');
-      writeOutputs(content, config.outputs, cwd, config);
+      // Feature 2: --mode write matrix
+      const activeMode = process.argv.indexOf('--mode') >= 0
+        ? process.argv[process.argv.indexOf('--mode') + 1]
+        : (config.mode || 'default');
+      if (activeMode === 'fast') {
+        const llmTxtMod = requireSourceOrBundled('./src/format/llm-txt');
+        const syncContext = { projectName: path.basename(cwd), fileEntries, srcDirs: config.srcDirs || [] };
+        fs.writeFileSync(llmTxtMod.outputPath(cwd), llmTxtMod.format(syncContext, cwd, VERSION));
+        console.warn(`[sigmap] --mode fast → llm.txt`);
+      } else if (activeMode === 'full') {
+        const llmFullMod = requireSourceOrBundled('./packages/adapters/llm-full');
+        const syncContext = { projectName: path.basename(cwd), fileEntries, srcDirs: config.srcDirs || [] };
+        llmFullMod.write(syncContext, cwd, { version: VERSION });
+        console.warn(`[sigmap] --mode full → llm-full.txt`);
+      } else if (activeMode === 'both') {
+        const llmTxtMod  = requireSourceOrBundled('./src/format/llm-txt');
+        const llmFullMod = requireSourceOrBundled('./packages/adapters/llm-full');
+        const llmsMod    = requireSourceOrBundled('./src/format/llms-txt');
+        const syncContext = { projectName: path.basename(cwd), fileEntries, srcDirs: config.srcDirs || [] };
+        fs.writeFileSync(llmTxtMod.outputPath(cwd),  llmTxtMod.format(syncContext, cwd, VERSION));
+        llmFullMod.write(syncContext, cwd, { version: VERSION });
+        writeOutputs(content, config.outputs, cwd, config);
+        const llmsContent = llmsMod.format(syncContext, cwd, [
+          { path: llmTxtMod.outputPath(cwd),  label: 'llm.txt' },
+          { path: llmFullMod.outputPath(cwd), label: 'llm-full.txt' },
+        ], VERSION);
+        fs.writeFileSync(llmsMod.outputPath(cwd), llmsContent);
+        console.warn(`[sigmap] --mode both → copilot-instructions.md + llm.txt + llm-full.txt + llms.txt`);
+      } else {
+        writeOutputs(content, config.outputs, cwd, config);
+      }
       if (formatValue === 'cache') writeCacheOutput(content, cwd);
       result = { inputTokenTotal, finalTokens, fileCount: beforeCount, droppedCount };
     }
@@ -6737,6 +7194,29 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     }
   }
 
+  // Feature 8: post-run summary — 6-line stdout after every normal run
+  if (!reportMode
+    && !process.argv.includes('--json')
+    && !process.argv.includes('--report')
+    && !process.argv.includes('--quiet')) {
+    const bar  = '\u2500'.repeat(43);
+    const syms = fileEntries.reduce((n, f) => n + (f.sigs ? f.sigs.length : 0), 0);
+    const pct  = result.inputTokenTotal > 0
+      ? Math.round((1 - result.finalTokens / result.inputTokenTotal) * 100)
+      : 0;
+    process.stderr.write([
+      bar,
+      ` SigMap v${VERSION}`,
+      ` Files scanned  : ${result.fileCount}`,
+      ` Symbols found  : ${syms.toLocaleString()}`,
+      ` Token reduction: ${pct}%  (${result.inputTokenTotal.toLocaleString()} \u2192 ${result.finalTokens.toLocaleString()})`,
+      ` Output         : .github/copilot-instructions.md`,
+      bar,
+      ` Try: "explain the architecture" \u00b7 "find the auth module"`,
+      bar, '',
+    ].join('\n'));
+  }
+
   return result;
 }
 
@@ -7048,6 +7528,12 @@ function registerMcp(cwd, scriptPath) {
 
 function main() {
   const args = process.argv.slice(2);
+
+  // Feature 1: `sigmap run` alias — strip positional 'run' so existing logic handles it
+  if (args[0] === 'run' && !args[0].startsWith('--')) {
+    args.shift();
+  }
+
   const invokedFrom = process.cwd();
   const cwd = resolveProjectRoot(invokedFrom);
   const scriptPath = process.argv[1] || path.join(invokedFrom, 'gen-context.js');
@@ -7075,6 +7561,73 @@ function main() {
 
   const config = loadConfig(cwd);
 
+  // Feature 2: `--mode fast|full|both`
+  const modeIdx = args.indexOf('--mode');
+  const mode = modeIdx !== -1
+    ? args[modeIdx + 1]
+    : (config.mode || 'default');
+  const VALID_MODES = ['default', 'fast', 'full', 'both'];
+  if (mode && !VALID_MODES.includes(mode)) {
+    console.error(`[sigmap] unknown --mode "${mode}". Valid: ${VALID_MODES.join(', ')}`);
+    process.exit(1);
+  }
+
+  // Feature 6: `sigmap sync` — write all outputs + llms.txt + print compact diff
+  if (args[0] === 'sync') {
+    try {
+      // Generate copilot-instructions.md first (existing output)
+      runGenerate(cwd, config, false);
+      const llmTxt = requireSourceOrBundled('./src/format/llm-txt');
+      const llmsGen = requireSourceOrBundled('./src/format/llms-txt');
+      const llmFullMod = requireSourceOrBundled('./packages/adapters/llm-full');
+
+      // Gather file entries for llm.txt / llm-full.txt
+      const ignorePatterns = loadIgnorePatterns(cwd);
+      let syncFiles = buildFileList(cwd, config).filter((f) => {
+        const rel = path.relative(cwd, f).replace(/\\/g, '/');
+        return !matchesIgnore(rel, ignorePatterns);
+      });
+      const syncEntries = [];
+      for (const fp of syncFiles) {
+        let content = '';
+        try { content = fs.readFileSync(fp, 'utf8'); } catch (_) { continue; }
+        const sigs = detectAndExtract(fp, content, config.maxSigsPerFile || 25);
+        if (sigs.length === 0) continue;
+        syncEntries.push({ filePath: fp, sigs, language: null });
+      }
+      const syncContext = {
+        projectName: path.basename(cwd),
+        fileEntries: syncEntries,
+        srcDirs: config.srcDirs || [],
+      };
+
+      const llmTxtPath   = llmTxt.outputPath(cwd);
+      const llmFullPath  = llmFullMod.outputPath(cwd);
+      const llmsTxtPath  = llmsGen.outputPath(cwd);
+
+      fs.writeFileSync(llmTxtPath,  llmTxt.format(syncContext, cwd, VERSION));
+      llmFullMod.write(syncContext, cwd, { version: VERSION });
+
+      const prev  = fs.existsSync(llmsTxtPath) ? fs.readFileSync(llmsTxtPath, 'utf8') : '';
+      const next  = llmsGen.format(syncContext, cwd, [
+        { path: llmTxtPath,  label: 'llm.txt' },
+        { path: llmFullPath, label: 'llm-full.txt' },
+      ], VERSION);
+      const changed = prev !== next ? 'updated' : 'no change';
+      fs.writeFileSync(llmsTxtPath, next);
+
+      console.log('[sigmap] sync complete');
+      console.log(`  .github/copilot-instructions.md  updated`);
+      console.log(`  llm.txt                          updated`);
+      console.log(`  llm-full.txt                     updated`);
+      console.log(`  llms.txt                         ${changed}`);
+    } catch (err) {
+      console.error(`[sigmap] sync error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
   if (args.includes('--init')) {
     writeInitConfig(cwd);
     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "3.4.0",
+  "version": "3.5.1",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {
@@ -24,6 +24,7 @@
     "init": "node gen-context.js --init",
     "report": "node gen-context.js --report",
     "audit:strategies": "node scripts/run-strategy-audit.mjs",
+    "benchmark:matrix": "node scripts/run-benchmark-matrix.mjs --save --skip-clone",
     "health": "node gen-context.js --health",
     "map": "node gen-project-map.js",
     "mcp": "node gen-context.js --mcp",