sigmap 3.3.2 → 3.3.4

package/CHANGELOG.md

@@ -10,6 +10,37 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [3.3.4] — 2026-04-14 — Binary Bundle Fix
+
+### Fixed
+- **Standalone binary pre-flight now passes for new P1 extractors**
+  - Added missing bundled `__factories` entries in `gen-context.js` for:
+    - `./src/extractors/graphql`
+    - `./src/extractors/protobuf`
+    - `./src/extractors/sql`
+    - `./src/extractors/terraform`
+  - Resolves CI/build failure in `scripts/build-binary.mjs` reporting missing `src/` modules in bundle.
+
+---
+
+## [3.3.3] — 2026-04-14 — Auto srcDirs + P1 Extractors
+
+### Added
+- **P1 extractor support** for additional high-value formats:
+  - SQL: `.sql`
+  - GraphQL: `.graphql`, `.gql`
+  - Terraform: `.tf`, `.tfvars`
+  - Protobuf: `.proto`
+- **Extractor registration updates** across runtime and core mapping so the new file types are parsed consistently.
+
+### Changed
+- **Auto source directory detection** (framework- and manifest-aware) in config loading and strategy auditing.
+- **Auto maxDepth tuning** in strategy audit based on repository file-depth distribution.
+- **Benchmark strategy-audit reports refreshed** to reflect improved source discovery and coverage.
+- **Language support count updated from 21 to 25** across core README and extension README.
+
+---
+
 ## [3.3.1] — 2026-04-10 — Patch: `--each --adapter` flag combination
 
 ### Fixed

package/README.md

@@ -19,6 +19,12 @@
 npx sigmap   # 10 seconds. zero config. your AI never reads the wrong file again.
 ```
 
+> Latest: **v3.3.4** includes a standalone binary bundle fix for newly added P1 extractors.
+
+<div align="center">
+<img src="demo.gif" alt="SigMap demo — reducing 80K tokens to 4K in under 10 seconds" width="760" />
+</div>
+
 <details>
 <summary><strong>Trust signals</strong></summary>
 
@@ -68,7 +74,7 @@ npx sigmap   # 10 seconds. zero config. your AI never reads the wrong file again
 | [Standalone binaries](docs/readmes/binaries.md) | macOS, Linux, Windows — no Node required |
 | [VS Code extension](#-vs-code-extension) | Status bar, stale alerts, commands |
 | [JetBrains plugin](#-jetbrains-plugin) | IntelliJ IDEA, WebStorm, PyCharm support |
-| [Languages supported](#-languages-supported) | 21 languages |
+| [Languages supported](#-languages-supported) | 25 languages |
 | [Context strategies](#-context-strategies) | full / per-module / hot-cold |
 | [MCP server](#-mcp-server) | 8 on-demand tools |
 | [CLI reference](#-cli-reference) | All flags |
@@ -91,7 +97,7 @@ SigMap scans your source files and extracts only the **function and class signat
 Your codebase
     │
     ▼
-sigmap ─────────► extracts signatures from 21 languages
+sigmap ─────────► extracts signatures from 25 languages
     │
     ▼
 .github/copilot-instructions.md   ◄── auto-read by Copilot / Claude / Cursor
@@ -433,6 +439,11 @@ The official SigMap VS Code extension keeps your context fresh without any manua
 | **Open context command** | `SigMap: Open Context File` — opens `.github/copilot-instructions.md` |
 | **Script path setting** | `sigmap.scriptPath` — override the path to the `sigmap` binary or `gen-context.js` |
 
+<div align="center">
+<img src="vscode.gif" alt="SigMap VS Code extension — status bar, stale notification, regenerate context" width="760" />
+</div>
+
+
 Activates on startup (`onStartupFinished`) — loads within 3 s, never blocks editor startup.
 
 **Install:** [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=manojmallick.sigmap) | [Open VSX Registry](https://open-vsx.org/extension/manojmallick/sigmap)
@@ -459,10 +470,10 @@ Compatible with **IntelliJ IDEA 2024.1+** (Community & Ultimate), **WebStorm**,
 
 ## 🌐 Languages supported
 
-> 21 languages. All implemented with zero external dependencies — pure regex + Node built-ins.
+> 25 languages. All implemented with zero external dependencies — pure regex + Node built-ins.
 
 <details>
-<summary><strong>Show all 21 languages</strong></summary>
+<summary><strong>Show all 25 languages</strong></summary>
 
 | Language | Extensions | Extracts |
 |---|---|---|
@@ -486,6 +497,10 @@ Compatible with **IntelliJ IDEA 2024.1+** (Community & Ultimate), **WebStorm**,
 | CSS/SCSS | `.css` `.scss` `.sass` `.less` | custom properties and keyframes |
 | YAML | `.yml` `.yaml` | top-level keys and pipeline jobs |
 | Shell | `.sh` `.bash` `.zsh` `.fish` | function declarations |
+| SQL | `.sql` | tables, views, indexes, functions, procedures |
+| GraphQL | `.graphql` `.gql` | types, interfaces, enums, operations, fragments |
+| Terraform | `.tf` `.tfvars` | resources, modules, variables, outputs |
+| Protobuf | `.proto` | messages, services, rpc, enums |
 | Dockerfile | `Dockerfile` `Dockerfile.*` | stages and key instructions |
 
 </details>

package/gen-context.js

@@ -1680,6 +1680,326 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
   
 };
 
+// ── ./src/extractors/graphql ──
+__factories["./src/extractors/graphql"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Extract signatures from GraphQL schema / operation files.
+   * Captures type, interface, enum, input, union, scalar, query, mutation,
+   * subscription, fragment definitions.
+   *
+   * @param {string} src - Raw GraphQL content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Strip comments (# style)
+    const stripped = src.replace(/#[^\n]*/g, '');
+  
+    // Schema type definitions: type Foo [implements Bar] { ... }
+    for (const m of stripped.matchAll(
+      /\b(type|interface|input)\s+(\w+)(?:\s+implements\s+([\w\s&]+))?\s*\{/g
+    )) {
+      const implements_ = m[3] ? ` implements ${m[3].trim().replace(/\s+/g, ' ')}` : '';
+      sigs.push(`${m[1]} ${m[2]}${implements_}`);
+    }
+  
+    // enum
+    for (const m of stripped.matchAll(/\benum\s+(\w+)\s*\{/g)) {
+      sigs.push(`enum ${m[1]}`);
+    }
+  
+    // union
+    for (const m of stripped.matchAll(/\bunion\s+(\w+)\s*=/g)) {
+      sigs.push(`union ${m[1]}`);
+    }
+  
+    // scalar
+    for (const m of stripped.matchAll(/\bscalar\s+(\w+)/g)) {
+      sigs.push(`scalar ${m[1]}`);
+    }
+  
+    // extend type / extend interface
+    for (const m of stripped.matchAll(/\bextend\s+(type|interface)\s+(\w+)/g)) {
+      sigs.push(`extend ${m[1]} ${m[2]}`);
+    }
+  
+    // Query / Mutation / Subscription operations
+    for (const m of stripped.matchAll(
+      /\b(query|mutation|subscription)\s+(\w+)\s*(?:\([^)]*\))?\s*\{/g
+    )) {
+      sigs.push(`${m[1]} ${m[2]}`);
+    }
+  
+    // Named fragments
+    for (const m of stripped.matchAll(/\bfragment\s+(\w+)\s+on\s+(\w+)/g)) {
+      sigs.push(`fragment ${m[1]} on ${m[2]}`);
+    }
+  
+    // Top-level schema { query: ... }
+    if (/\bschema\s*\{/.test(stripped)) {
+      sigs.push('schema { ... }');
+    }
+  
+    return sigs;
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/protobuf ──
+__factories["./src/extractors/protobuf"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Extract signatures from Protocol Buffer (.proto) files.
+   * Captures message, enum, service, rpc, oneof, extend definitions.
+   *
+   * @param {string} src - Raw .proto content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Strip single-line and block comments
+    const stripped = src
+      .replace(/\/\/[^\n]*/g, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // syntax / package / option (top-level metadata)
+    const syntaxM = stripped.match(/\bsyntax\s*=\s*"([^"]+)"/);
+    if (syntaxM) sigs.push(`syntax = "${syntaxM[1]}"`);
+  
+    const pkgM = stripped.match(/\bpackage\s+([\w.]+)\s*;/);
+    if (pkgM) sigs.push(`package ${pkgM[1]}`);
+  
+    // message <Name> { ... }
+    for (const m of stripped.matchAll(/\bmessage\s+(\w+)\s*\{/g)) {
+      sigs.push(`message ${m[1]}`);
+    }
+  
+    // enum <Name> { ... }
+    for (const m of stripped.matchAll(/\benum\s+(\w+)\s*\{/g)) {
+      sigs.push(`enum ${m[1]}`);
+    }
+  
+    // service <Name> { ... }
+    for (const m of stripped.matchAll(/\bservice\s+(\w+)\s*\{/g)) {
+      sigs.push(`service ${m[1]}`);
+    }
+  
+    // rpc <Name>(<Request>) returns (<Response>)
+    for (const m of stripped.matchAll(
+      /\brpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s+returns\s*\(\s*(stream\s+)?(\w+)\s*\)/g
+    )) {
+      const req = `${m[2] || ''}${m[3]}`.trim();
+      const res = `${m[4] || ''}${m[5]}`.trim();
+      sigs.push(`rpc ${m[1]}(${req}) returns (${res})`);
+    }
+  
+    // oneof <name>
+    for (const m of stripped.matchAll(/\boneof\s+(\w+)\s*\{/g)) {
+      sigs.push(`oneof ${m[1]}`);
+    }
+  
+    // extend <TypeName>
+    for (const m of stripped.matchAll(/\bextend\s+([\w.]+)\s*\{/g)) {
+      sigs.push(`extend ${m[1]}`);
+    }
+  
+    return sigs;
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/sql ──
+__factories["./src/extractors/sql"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Extract signatures from SQL source files.
+   * Captures CREATE TABLE, VIEW, INDEX, FUNCTION, PROCEDURE, TRIGGER, TYPE, SEQUENCE.
+   *
+   * @param {string} src - Raw SQL content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Strip single-line comments and block comments
+    const stripped = src
+      .replace(/--[^\n]*/g, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // CREATE TABLE [IF NOT EXISTS] <name> / CREATE [TEMP] TABLE ...
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?(?:TEMP(?:ORARY)?\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+    )) {
+      sigs.push(`TABLE ${_cleanName(m[1])}`);
+    }
+  
+    // CREATE VIEW / MATERIALIZED VIEW
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+    )) {
+      sigs.push(`VIEW ${_cleanName(m[1])}`);
+    }
+  
+    // CREATE INDEX / UNIQUE INDEX
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)\s+ON\s+([`"[\w.]+)/gi
+    )) {
+      sigs.push(`INDEX ${_cleanName(m[1])} ON ${_cleanName(m[2])}`);
+    }
+  
+    // CREATE FUNCTION / CREATE OR REPLACE FUNCTION
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([`"[\w.]+)\s*\(([^)]*)\)/gi
+    )) {
+      const params = _normalizeParams(m[2]);
+      sigs.push(`FUNCTION ${_cleanName(m[1])}(${params})`);
+    }
+  
+    // CREATE PROCEDURE
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+([`"[\w.]+)\s*\(([^)]*)\)/gi
+    )) {
+      const params = _normalizeParams(m[2]);
+      sigs.push(`PROCEDURE ${_cleanName(m[1])}(${params})`);
+    }
+  
+    // CREATE TRIGGER
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\s+([`"[\w.]+)/gi
+    )) {
+      sigs.push(`TRIGGER ${_cleanName(m[1])}`);
+    }
+  
+    // CREATE TYPE (composite, enum, domain)
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?TYPE\s+([`"[\w.]+)/gi
+    )) {
+      sigs.push(`TYPE ${_cleanName(m[1])}`);
+    }
+  
+    // CREATE SEQUENCE
+    for (const m of stripped.matchAll(
+      /CREATE\s+(?:OR\s+REPLACE\s+)?SEQUENCE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+    )) {
+      sigs.push(`SEQUENCE ${_cleanName(m[1])}`);
+    }
+  
+    return sigs;
+  }
+  
+  function _cleanName(raw) {
+    return raw.replace(/^[`"[]|[`"\]]+$/g, '').trim();
+  }
+  
+  function _normalizeParams(raw) {
+    if (!raw || !raw.trim()) return '';
+    return raw.trim()
+      .split(',')
+      .map((p) => p.trim().replace(/\s+/g, ' ').split(' ').slice(0, 2).join(' '))
+      .filter(Boolean)
+      .join(', ');
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/terraform ──
+__factories["./src/extractors/terraform"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Extract signatures from Terraform (.tf / .tfvars) configuration files.
+   * Captures resource, data, module, variable, output, locals, provider,
+   * terraform blocks, and moved/import blocks.
+   *
+   * @param {string} src - Raw Terraform content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Strip single-line comments
+    const stripped = src
+      .replace(/\/\/[^\n]*/g, '')
+      .replace(/#[^\n]*/g, '')
+      .replace(/\/\*[\s\S]*?\*\//g, '');
+  
+    // resource "<type>" "<name>" { ... }
+    for (const m of stripped.matchAll(/\bresource\s+"([^"]+)"\s+"([^"]+)"\s*\{/g)) {
+      sigs.push(`resource "${m[1]}" "${m[2]}"`);
+    }
+  
+    // data "<type>" "<name>" { ... }
+    for (const m of stripped.matchAll(/\bdata\s+"([^"]+)"\s+"([^"]+)"\s*\{/g)) {
+      sigs.push(`data "${m[1]}" "${m[2]}"`);
+    }
+  
+    // module "<name>" { ... }
+    for (const m of stripped.matchAll(/\bmodule\s+"([^"]+)"\s*\{/g)) {
+      sigs.push(`module "${m[1]}"`);
+    }
+  
+    // variable "<name>" { ... }
+    for (const m of stripped.matchAll(/\bvariable\s+"([^"]+)"\s*\{/g)) {
+      sigs.push(`variable "${m[1]}"`);
+    }
+  
+    // output "<name>" { ... }
+    for (const m of stripped.matchAll(/\boutput\s+"([^"]+)"\s*\{/g)) {
+      sigs.push(`output "${m[1]}"`);
+    }
+  
+    // provider "<name>" { ... }
+    for (const m of stripped.matchAll(/\bprovider\s+"([^"]+)"\s*\{/g)) {
+      sigs.push(`provider "${m[1]}"`);
+    }
+  
+    // locals { ... } (just mark presence; key names too noisy to enumerate)
+    if (/\blocals\s*\{/.test(stripped)) {
+      sigs.push('locals { ... }');
+    }
+  
+    // terraform { required_providers / backend }
+    if (/\bterraform\s*\{/.test(stripped)) {
+      sigs.push('terraform { ... }');
+    }
+  
+    // moved block
+    for (const m of stripped.matchAll(/\bmoved\s*\{[\s\S]*?from\s*=\s*([^\n]+)/g)) {
+      sigs.push(`moved from ${m[1].trim()}`);
+    }
+  
+    // import block (Terraform 1.5+)
+    for (const m of stripped.matchAll(/\bimport\s*\{[\s\S]*?to\s*=\s*([^\n]+)/g)) {
+      sigs.push(`import to ${m[1].trim()}`);
+    }
+  
+    return sigs;
+  }
+  
+  module.exports = { extract };
+  
+};
+
 // ── ./src/extractors/deps ──
 __factories["./src/extractors/deps"] = function(module, exports) {
   
@@ -3700,7 +4020,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '3.3.2',
+    version: '3.3.4',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -4619,6 +4939,11 @@ __factories["./src/eval/analyzer"] = function(module, exports) {
     '.css': 'css',       '.scss': 'css', '.sass': 'css', '.less': 'css',
     '.yml': 'yaml',      '.yaml': 'yaml',
     '.sh': 'shell',      '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+    // P1 languages
+    '.sql': 'sql',
+    '.graphql': 'graphql', '.gql': 'graphql',
+    '.tf': 'terraform', '.tfvars': 'terraform',
+    '.proto': 'protobuf',
   };
 
   function isDockerfile(name) { return name === 'Dockerfile' || name.startsWith('Dockerfile.'); }
@@ -5105,7 +5430,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '3.3.2';
+const VERSION = '3.3.4';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -5147,6 +5472,11 @@ const EXT_MAP = {
   '.css': 'css', '.scss': 'css', '.sass': 'css', '.less': 'css',
   '.yml': 'yaml', '.yaml': 'yaml',
   '.sh': 'shell', '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+  // P1 languages
+  '.sql': 'sql',
+  '.graphql': 'graphql', '.gql': 'graphql',
+  '.tf': 'terraform', '.tfvars': 'terraform',
+  '.proto': 'protobuf',
 };
 
 // Dockerfile handled separately (no extension)

package/package.json

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

package/packages/cli/package.json

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

package/packages/core/index.js

@@ -35,6 +35,11 @@ const EXT_MAP = {
   '.css': 'css',       '.scss': 'css', '.sass': 'css', '.less': 'css',
   '.yml': 'yaml',      '.yaml': 'yaml',
   '.sh': 'shell',      '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+  // P1 languages
+  '.sql': 'sql',
+  '.graphql': 'graphql', '.gql': 'graphql',
+  '.tf': 'terraform', '.tfvars': 'terraform',
+  '.proto': 'protobuf',
 };
 
 const SRC_ROOT = path.resolve(__dirname, '..', '..', 'src');

package/packages/core/package.json

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

package/src/config/loader.js

@@ -7,6 +7,142 @@ const { DEFAULTS } = require('./defaults');
 // Keys that are valid in gen-context.config.json
 const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
 
+// Common top-level folder names that reliably hold source code
+const COMMON_CODE_DIRS = new Set([
+  'src', 'app', 'lib', 'packages', 'services', 'api', 'core', 'cmd',
+  'internal', 'pkg', 'handlers', 'controllers', 'models', 'views',
+  'components', 'pages', 'routes', 'middleware', 'utils', 'helpers',
+  'modules', 'plugins', 'extensions', 'adapters', 'drivers',
+  'examples', 'sample', 'demo', 'tests', 'test', 'spec', '__tests__',
+  'hooks', 'composables', 'stores', 'features', 'domain', 'infra',
+  'infrastructure', 'application', 'data', 'Sources', 'Tests',
+]);
+
+const SUPPORTED_CODE_EXTS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.pyw', '.java', '.kt', '.kts', '.go', '.rs', '.cs',
+  '.cpp', '.c', '.h', '.hpp', '.cc', '.rb', '.rake', '.php',
+  '.swift', '.dart', '.scala', '.sc', '.vue', '.svelte',
+  '.html', '.htm', '.css', '.scss', '.sass', '.less',
+  '.yml', '.yaml', '.sh', '.bash', '.zsh', '.fish',
+  '.sql', '.graphql', '.gql', '.tf', '.tfvars', '.proto',
+]);
+
+/**
+ * Detect source directories for the given project root by reading manifest
+ * files and scanning top-level directories for code files.
+ *
+ * @param {string} cwd - Project root
+ * @param {string[]} excludeList - Folders to skip
+ * @returns {string[]}
+ */
+function detectAutoSrcDirs(cwd, excludeList) {
+  const excludeSet = new Set(excludeList || []);
+  const candidates = new Set(DEFAULTS.srcDirs);
+
+  // ── Manifest-based detection ──────────────────────────────────────────────
+  const pkgPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      const allDeps = { ...pkg.dependencies, ...pkg.devDependencies, ...pkg.peerDependencies };
+      if (allDeps.react || allDeps.next) {
+        for (const d of ['src', 'app', 'pages', 'components', 'hooks', 'lib', 'utils']) candidates.add(d);
+      }
+      if (allDeps['@angular/core']) {
+        for (const d of ['src', 'projects', 'apps', 'libs']) candidates.add(d);
+      }
+      if (allDeps['@nestjs/core']) {
+        for (const d of ['src', 'libs', 'apps']) candidates.add(d);
+      }
+      if (allDeps.vue) {
+        for (const d of ['src', 'components', 'views', 'stores', 'composables', 'plugins']) candidates.add(d);
+      }
+      if (allDeps.svelte || allDeps['@sveltejs/kit']) {
+        for (const d of ['src', 'lib', 'routes']) candidates.add(d);
+      }
+      if (allDeps.nx || allDeps.turbo || allDeps.lerna || pkg.workspaces) {
+        for (const d of ['packages', 'apps', 'libs', 'services']) candidates.add(d);
+      }
+    } catch (_) {}
+  }
+
+  const hasPyproject = fs.existsSync(path.join(cwd, 'pyproject.toml'));
+  const hasRequirements = fs.existsSync(path.join(cwd, 'requirements.txt'));
+  const hasSetupPy = fs.existsSync(path.join(cwd, 'setup.py'));
+  if (hasPyproject || hasRequirements || hasSetupPy) {
+    for (const d of ['src', 'app', 'tests', 'examples']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'Gemfile'))) {
+    for (const d of ['app', 'lib', 'config', 'db', 'spec', 'test']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'composer.json'))) {
+    for (const d of ['app', 'resources', 'routes', 'database', 'tests']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'go.mod'))) {
+    for (const d of ['cmd', 'internal', 'pkg', 'api', 'handler', 'handlers', 'middleware', 'service']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'Cargo.toml'))) {
+    for (const d of ['src', 'crates', 'examples', 'tests', 'benches']) candidates.add(d);
+  }
+
+  const hasGradle = fs.existsSync(path.join(cwd, 'build.gradle')) ||
+                    fs.existsSync(path.join(cwd, 'build.gradle.kts'));
+  const hasMaven = fs.existsSync(path.join(cwd, 'pom.xml'));
+  if (hasGradle || hasMaven) {
+    for (const d of [
+      'src/main/java', 'src/main/kotlin', 'src/main/scala',
+      'src/main/resources', 'src/test/java', 'src/test/kotlin',
+    ]) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'pubspec.yaml'))) {
+    for (const d of ['lib', 'test', 'integration_test', 'example', 'bin']) candidates.add(d);
+  }
+
+  if (fs.existsSync(path.join(cwd, 'Package.swift'))) {
+    for (const d of ['Sources', 'Tests']) candidates.add(d);
+  }
+
+  // ── Top-level directory scan ──────────────────────────────────────────────
+  try {
+    const entries = fs.readdirSync(cwd, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name.startsWith('.')) continue;
+      if (excludeSet.has(entry.name)) continue;
+
+      const lname = entry.name.toLowerCase();
+      if (COMMON_CODE_DIRS.has(entry.name) || COMMON_CODE_DIRS.has(lname)) {
+        candidates.add(entry.name);
+        continue;
+      }
+      // Unknown dir: add if it directly contains source files
+      const dirPath = path.join(cwd, entry.name);
+      try {
+        const subs = fs.readdirSync(dirPath, { withFileTypes: true });
+        const hasSrc = subs.some((s) => {
+          if (!s.isFile()) return false;
+          return SUPPORTED_CODE_EXTS.has(path.extname(s.name).toLowerCase()) || s.name === 'Dockerfile';
+        });
+        if (hasSrc) { candidates.add(entry.name); continue; }
+        const hasSrcSub = subs.some((s) =>
+          s.isDirectory() && ['src', 'lib', 'main', 'java', 'kotlin', 'scala', 'python'].includes(s.name));
+        if (hasSrcSub) candidates.add(entry.name);
+      } catch (_) {}
+    }
+  } catch (_) {}
+
+  // Only return those that exist
+  return Array.from(candidates).filter((d) => {
+    try { return fs.statSync(path.join(cwd, d)).isDirectory(); } catch (_) { return false; }
+  });
+}
+
 /**
  * Load and merge configuration for a given working directory.
  *
@@ -16,7 +152,10 @@ const KNOWN_KEYS = new Set(Object.keys(DEFAULTS));
 function loadConfig(cwd) {
   const configPath = path.join(cwd, 'gen-context.config.json');
   if (!fs.existsSync(configPath)) {
-    return deepClone(DEFAULTS);
+    const cfg = deepClone(DEFAULTS);
+    const detected = detectAutoSrcDirs(cwd, cfg.exclude);
+    if (detected.length > 0) cfg.srcDirs = detected;
+    return cfg;
   }
 
   let userConfig;
@@ -25,7 +164,10 @@ function loadConfig(cwd) {
     userConfig = JSON.parse(raw);
   } catch (err) {
     console.warn(`[sigmap] config parse error in ${configPath}: ${err.message}`);
-    return deepClone(DEFAULTS);
+    const cfg = deepClone(DEFAULTS);
+    const detected = detectAutoSrcDirs(cwd, cfg.exclude);
+    if (detected.length > 0) cfg.srcDirs = detected;
+    return cfg;
   }
 
   // Warn on unknown keys (helps catch typos)
@@ -50,6 +192,13 @@ function loadConfig(cwd) {
       merged[key] = val;
     }
   }
+
+  // If user didn't specify srcDirs, auto-detect; fall back to DEFAULTS if nothing found
+  if (!Array.isArray(userConfig.srcDirs)) {
+    const detected = detectAutoSrcDirs(cwd, merged.exclude);
+    merged.srcDirs = detected.length > 0 ? detected : deepClone(DEFAULTS.srcDirs);
+  }
+
   // Backward compat (v3.0+): mirror outputs ↔ adapters
   if (merged.adapters && !Array.isArray(merged.adapters)) merged.adapters = null;
   if (!merged.adapters && Array.isArray(merged.outputs)) {

package/src/extractors/graphql.js

@@ -0,0 +1,66 @@
+'use strict';
+
+/**
+ * Extract signatures from GraphQL schema / operation files.
+ * Captures type, interface, enum, input, union, scalar, query, mutation,
+ * subscription, fragment definitions.
+ *
+ * @param {string} src - Raw GraphQL content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip comments (# style)
+  const stripped = src.replace(/#[^\n]*/g, '');
+
+  // Schema type definitions: type Foo [implements Bar] { ... }
+  for (const m of stripped.matchAll(
+    /\b(type|interface|input)\s+(\w+)(?:\s+implements\s+([\w\s&]+))?\s*\{/g
+  )) {
+    const implements_ = m[3] ? ` implements ${m[3].trim().replace(/\s+/g, ' ')}` : '';
+    sigs.push(`${m[1]} ${m[2]}${implements_}`);
+  }
+
+  // enum
+  for (const m of stripped.matchAll(/\benum\s+(\w+)\s*\{/g)) {
+    sigs.push(`enum ${m[1]}`);
+  }
+
+  // union
+  for (const m of stripped.matchAll(/\bunion\s+(\w+)\s*=/g)) {
+    sigs.push(`union ${m[1]}`);
+  }
+
+  // scalar
+  for (const m of stripped.matchAll(/\bscalar\s+(\w+)/g)) {
+    sigs.push(`scalar ${m[1]}`);
+  }
+
+  // extend type / extend interface
+  for (const m of stripped.matchAll(/\bextend\s+(type|interface)\s+(\w+)/g)) {
+    sigs.push(`extend ${m[1]} ${m[2]}`);
+  }
+
+  // Query / Mutation / Subscription operations
+  for (const m of stripped.matchAll(
+    /\b(query|mutation|subscription)\s+(\w+)\s*(?:\([^)]*\))?\s*\{/g
+  )) {
+    sigs.push(`${m[1]} ${m[2]}`);
+  }
+
+  // Named fragments
+  for (const m of stripped.matchAll(/\bfragment\s+(\w+)\s+on\s+(\w+)/g)) {
+    sigs.push(`fragment ${m[1]} on ${m[2]}`);
+  }
+
+  // Top-level schema { query: ... }
+  if (/\bschema\s*\{/.test(stripped)) {
+    sigs.push('schema { ... }');
+  }
+
+  return sigs;
+}
+
+module.exports = { extract };

package/src/extractors/protobuf.js

@@ -0,0 +1,63 @@
+'use strict';
+
+/**
+ * Extract signatures from Protocol Buffer (.proto) files.
+ * Captures message, enum, service, rpc, oneof, extend definitions.
+ *
+ * @param {string} src - Raw .proto content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip single-line and block comments
+  const stripped = src
+    .replace(/\/\/[^\n]*/g, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // syntax / package / option (top-level metadata)
+  const syntaxM = stripped.match(/\bsyntax\s*=\s*"([^"]+)"/);
+  if (syntaxM) sigs.push(`syntax = "${syntaxM[1]}"`);
+
+  const pkgM = stripped.match(/\bpackage\s+([\w.]+)\s*;/);
+  if (pkgM) sigs.push(`package ${pkgM[1]}`);
+
+  // message <Name> { ... }
+  for (const m of stripped.matchAll(/\bmessage\s+(\w+)\s*\{/g)) {
+    sigs.push(`message ${m[1]}`);
+  }
+
+  // enum <Name> { ... }
+  for (const m of stripped.matchAll(/\benum\s+(\w+)\s*\{/g)) {
+    sigs.push(`enum ${m[1]}`);
+  }
+
+  // service <Name> { ... }
+  for (const m of stripped.matchAll(/\bservice\s+(\w+)\s*\{/g)) {
+    sigs.push(`service ${m[1]}`);
+  }
+
+  // rpc <Name>(<Request>) returns (<Response>)
+  for (const m of stripped.matchAll(
+    /\brpc\s+(\w+)\s*\(\s*(stream\s+)?(\w+)\s*\)\s+returns\s*\(\s*(stream\s+)?(\w+)\s*\)/g
+  )) {
+    const req = `${m[2] || ''}${m[3]}`.trim();
+    const res = `${m[4] || ''}${m[5]}`.trim();
+    sigs.push(`rpc ${m[1]}(${req}) returns (${res})`);
+  }
+
+  // oneof <name>
+  for (const m of stripped.matchAll(/\boneof\s+(\w+)\s*\{/g)) {
+    sigs.push(`oneof ${m[1]}`);
+  }
+
+  // extend <TypeName>
+  for (const m of stripped.matchAll(/\bextend\s+([\w.]+)\s*\{/g)) {
+    sigs.push(`extend ${m[1]}`);
+  }
+
+  return sigs;
+}
+
+module.exports = { extract };

package/src/extractors/sql.js

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Extract signatures from SQL source files.
+ * Captures CREATE TABLE, VIEW, INDEX, FUNCTION, PROCEDURE, TRIGGER, TYPE, SEQUENCE.
+ *
+ * @param {string} src - Raw SQL content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip single-line comments and block comments
+  const stripped = src
+    .replace(/--[^\n]*/g, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // CREATE TABLE [IF NOT EXISTS] <name> / CREATE [TEMP] TABLE ...
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?(?:TEMP(?:ORARY)?\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+  )) {
+    sigs.push(`TABLE ${_cleanName(m[1])}`);
+  }
+
+  // CREATE VIEW / MATERIALIZED VIEW
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?(?:MATERIALIZED\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+  )) {
+    sigs.push(`VIEW ${_cleanName(m[1])}`);
+  }
+
+  // CREATE INDEX / UNIQUE INDEX
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)\s+ON\s+([`"[\w.]+)/gi
+  )) {
+    sigs.push(`INDEX ${_cleanName(m[1])} ON ${_cleanName(m[2])}`);
+  }
+
+  // CREATE FUNCTION / CREATE OR REPLACE FUNCTION
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?FUNCTION\s+([`"[\w.]+)\s*\(([^)]*)\)/gi
+  )) {
+    const params = _normalizeParams(m[2]);
+    sigs.push(`FUNCTION ${_cleanName(m[1])}(${params})`);
+  }
+
+  // CREATE PROCEDURE
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?PROCEDURE\s+([`"[\w.]+)\s*\(([^)]*)\)/gi
+  )) {
+    const params = _normalizeParams(m[2]);
+    sigs.push(`PROCEDURE ${_cleanName(m[1])}(${params})`);
+  }
+
+  // CREATE TRIGGER
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?(?:CONSTRAINT\s+)?TRIGGER\s+([`"[\w.]+)/gi
+  )) {
+    sigs.push(`TRIGGER ${_cleanName(m[1])}`);
+  }
+
+  // CREATE TYPE (composite, enum, domain)
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?TYPE\s+([`"[\w.]+)/gi
+  )) {
+    sigs.push(`TYPE ${_cleanName(m[1])}`);
+  }
+
+  // CREATE SEQUENCE
+  for (const m of stripped.matchAll(
+    /CREATE\s+(?:OR\s+REPLACE\s+)?SEQUENCE\s+(?:IF\s+NOT\s+EXISTS\s+)?([`"[\w.]+)/gi
+  )) {
+    sigs.push(`SEQUENCE ${_cleanName(m[1])}`);
+  }
+
+  return sigs;
+}
+
+function _cleanName(raw) {
+  return raw.replace(/^[`"[]|[`"\]]+$/g, '').trim();
+}
+
+function _normalizeParams(raw) {
+  if (!raw || !raw.trim()) return '';
+  return raw.trim()
+    .split(',')
+    .map((p) => p.trim().replace(/\s+/g, ' ').split(' ').slice(0, 2).join(' '))
+    .filter(Boolean)
+    .join(', ');
+}
+
+module.exports = { extract };

package/src/extractors/terraform.js

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * Extract signatures from Terraform (.tf / .tfvars) configuration files.
+ * Captures resource, data, module, variable, output, locals, provider,
+ * terraform blocks, and moved/import blocks.
+ *
+ * @param {string} src - Raw Terraform content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Strip single-line comments
+  const stripped = src
+    .replace(/\/\/[^\n]*/g, '')
+    .replace(/#[^\n]*/g, '')
+    .replace(/\/\*[\s\S]*?\*\//g, '');
+
+  // resource "<type>" "<name>" { ... }
+  for (const m of stripped.matchAll(/\bresource\s+"([^"]+)"\s+"([^"]+)"\s*\{/g)) {
+    sigs.push(`resource "${m[1]}" "${m[2]}"`);
+  }
+
+  // data "<type>" "<name>" { ... }
+  for (const m of stripped.matchAll(/\bdata\s+"([^"]+)"\s+"([^"]+)"\s*\{/g)) {
+    sigs.push(`data "${m[1]}" "${m[2]}"`);
+  }
+
+  // module "<name>" { ... }
+  for (const m of stripped.matchAll(/\bmodule\s+"([^"]+)"\s*\{/g)) {
+    sigs.push(`module "${m[1]}"`);
+  }
+
+  // variable "<name>" { ... }
+  for (const m of stripped.matchAll(/\bvariable\s+"([^"]+)"\s*\{/g)) {
+    sigs.push(`variable "${m[1]}"`);
+  }
+
+  // output "<name>" { ... }
+  for (const m of stripped.matchAll(/\boutput\s+"([^"]+)"\s*\{/g)) {
+    sigs.push(`output "${m[1]}"`);
+  }
+
+  // provider "<name>" { ... }
+  for (const m of stripped.matchAll(/\bprovider\s+"([^"]+)"\s*\{/g)) {
+    sigs.push(`provider "${m[1]}"`);
+  }
+
+  // locals { ... } (just mark presence; key names too noisy to enumerate)
+  if (/\blocals\s*\{/.test(stripped)) {
+    sigs.push('locals { ... }');
+  }
+
+  // terraform { required_providers / backend }
+  if (/\bterraform\s*\{/.test(stripped)) {
+    sigs.push('terraform { ... }');
+  }
+
+  // moved block
+  for (const m of stripped.matchAll(/\bmoved\s*\{[\s\S]*?from\s*=\s*([^\n]+)/g)) {
+    sigs.push(`moved from ${m[1].trim()}`);
+  }
+
+  // import block (Terraform 1.5+)
+  for (const m of stripped.matchAll(/\bimport\s*\{[\s\S]*?to\s*=\s*([^\n]+)/g)) {
+    sigs.push(`import to ${m[1].trim()}`);
+  }
+
+  return sigs;
+}
+
+module.exports = { extract };