sigmap 3.3.3 → 3.4.0

package/CHANGELOG.md

@@ -10,6 +10,23 @@ Format: [Semantic Versioning](https://semver.org/)
 
 ---
 
+## [3.4.0] — 2026-04-14 — Phase A/B Coverage Expansion
+
+### Added
+- **Phase A extractor support** for high-value config and docs formats:
+  - TOML: `.toml`
+  - Java/INI properties: `.properties`
+  - XML: `.xml`
+  - Markdown technical docs: `.md`
+- **Bundled runtime factory wiring** for new extractors so standalone/binary execution resolves the same modules as source mode.
+
+### Changed
+- **Framework-aware source discovery** defaults expanded for Next/React, Angular, Rails, Laravel, and Flask/Python-style layouts.
+- **Strategy audit coverage rules** updated to treat Phase A formats as supported instead of important unsupported baselines.
+- **Default srcDirs** broadened to improve first-run context quality on framework-heavy repositories.
+
+---
+
 ## [3.3.3] — 2026-04-14 — Auto srcDirs + P1 Extractors
 
 ### Added

package/README.md

@@ -469,6 +469,8 @@ Compatible with **IntelliJ IDEA 2024.1+** (Community & Ultimate), **WebStorm**,
 ## 🌐 Languages supported
 
 > 25 languages. All implemented with zero external dependencies — pure regex + Node built-ins.
+>
+> Also includes lightweight config/doc extraction for `.toml`, `.properties`, `.xml`, and `.md` to improve real-repo coverage beyond source-code files.
 
 <details>
 <summary><strong>Show all 25 languages</strong></summary>

package/gen-context.js

@@ -1680,6 +1680,505 @@ __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/toml ──
+__factories["./src/extractors/toml"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Extract signatures from TOML configuration files.
+   * Focuses on section/table names and high-value keys.
+   *
+   * @param {string} src - Raw TOML content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Remove # comments while preserving values before comment markers.
+    const stripped = src.replace(/\s+#.*$/gm, '');
+  
+    // [section] and [[array.section]]
+    for (const m of stripped.matchAll(/^\s*(\[\[?[^\]]+\]\]?)\s*$/gm)) {
+      sigs.push(`table ${m[1].trim()}`);
+    }
+  
+    // Key-value lines (top-level and nested) — keep key names only.
+    for (const m of stripped.matchAll(/^\s*([A-Za-z0-9_.-]+)\s*=\s*(.+)$/gm)) {
+      const key = m[1].trim();
+      const value = m[2].trim();
+  
+      // Prefer common metadata/config keys for compact, useful output.
+      if (/^(name|version|description|authors|license|requires-python|dependencies|optional-dependencies|scripts|tool\.|build-system\.|project\.)/.test(key)) {
+        sigs.push(`key ${key}`);
+        continue;
+      }
+  
+      // Include booleans and simple scalar keys as generic config signal.
+      if (/^(true|false|"[^"]*"|'[^']*'|[0-9._-]+)$/.test(value)) {
+        sigs.push(`key ${key}`);
+      }
+    }
+  
+    return Array.from(new Set(sigs)).slice(0, 40);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/properties ──
+__factories["./src/extractors/properties"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Extract signatures from .properties configuration files.
+   * Captures key names, grouped by prefixes where possible.
+   *
+   * @param {string} src - Raw properties content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    const lines = src.split(/\r?\n/);
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) continue;
+  
+      const idxEq = trimmed.indexOf('=');
+      const idxColon = trimmed.indexOf(':');
+      const idx = idxEq >= 0 && idxColon >= 0 ? Math.min(idxEq, idxColon) : Math.max(idxEq, idxColon);
+      if (idx <= 0) continue;
+  
+      const key = trimmed.slice(0, idx).trim();
+      if (!key) continue;
+  
+      const parts = key.split('.').filter(Boolean);
+      if (parts.length >= 2) {
+        sigs.push(`group ${parts[0]}.${parts[1]}`);
+      }
+      sigs.push(`key ${key}`);
+    }
+  
+    return Array.from(new Set(sigs)).slice(0, 50);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/xml ──
+__factories["./src/extractors/xml"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Lightweight XML config extractor.
+   * Captures root tags, key config tags, and id/name/class attributes.
+   *
+   * @param {string} src - Raw XML content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Remove comments and XML declaration for simpler scanning.
+    const stripped = src
+      .replace(/<!--[\s\S]*?-->/g, '')
+      .replace(/<\?xml[\s\S]*?\?>/gi, '');
+  
+    // Root element (first opening tag).
+    const root = stripped.match(/<\s*([A-Za-z_][\w:.-]*)\b[^>]*>/);
+    if (root) sigs.push(`root ${root[1]}`);
+  
+    // High-value config-like tags.
+    const tagRe = /<\s*([A-Za-z_][\w:.-]*)\b([^>]*)>/g;
+    for (const m of stripped.matchAll(tagRe)) {
+      const tag = m[1];
+      const attrs = m[2] || '';
+  
+      if (/^(bean|beans|route|routes|property|properties|dependency|dependencies|plugin|plugins|configuration|settings|profile|profiles|module|modules)$/i.test(tag)) {
+        sigs.push(`tag ${tag}`);
+      }
+  
+      const id = attrs.match(/\bid\s*=\s*"([^"]+)"/i);
+      if (id) sigs.push(`${tag}#${id[1]}`);
+  
+      const name = attrs.match(/\bname\s*=\s*"([^"]+)"/i);
+      if (name) sigs.push(`${tag}[name=${name[1]}]`);
+  
+      const cls = attrs.match(/\bclass\s*=\s*"([^"]+)"/i);
+      if (cls) sigs.push(`${tag} -> ${cls[1]}`);
+    }
+  
+    return Array.from(new Set(sigs)).slice(0, 50);
+  }
+  
+  module.exports = { extract };
+  
+};
+
+// ── ./src/extractors/markdown ──
+__factories["./src/extractors/markdown"] = function(module, exports) {
+  
+  'use strict';
+  
+  /**
+   * Lightweight markdown technical indexer.
+   * Captures headings and fenced code block language hints only.
+   *
+   * @param {string} src - Raw markdown content
+   * @returns {string[]} Array of signature strings
+   */
+  function extract(src) {
+    if (!src || typeof src !== 'string') return [];
+    const sigs = [];
+  
+    // Headings: # .. ######
+    for (const m of src.matchAll(/^(#{1,6})\s+(.+)$/gm)) {
+      const level = m[1].length;
+      const title = m[2].trim().replace(/\s+/g, ' ');
+      if (title) sigs.push(`h${level} ${title}`);
+    }
+  
+    // Fenced code blocks: ```lang
+    for (const m of src.matchAll(/^```\s*([A-Za-z0-9_+-]*)\s*$/gm)) {
+      const lang = m[1] ? m[1].toLowerCase() : 'plain';
+      sigs.push(`code-fence ${lang}`);
+    }
+  
+    return Array.from(new Set(sigs)).slice(0, 40);
+  }
+  
+  module.exports = { extract };
+  
+};
+
 // ── ./src/extractors/deps ──
 __factories["./src/extractors/deps"] = function(module, exports) {
   
@@ -3700,7 +4199,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '3.3.3',
+    version: '3.4.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -4624,6 +5123,11 @@ __factories["./src/eval/analyzer"] = function(module, exports) {
     '.graphql': 'graphql', '.gql': 'graphql',
     '.tf': 'terraform', '.tfvars': 'terraform',
     '.proto': 'protobuf',
+    // Phase A formats
+    '.toml': 'toml',
+    '.properties': 'properties',
+    '.xml': 'xml',
+    '.md': 'markdown',
   };
 
   function isDockerfile(name) { return name === 'Dockerfile' || name.startsWith('Dockerfile.'); }
@@ -5110,7 +5614,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '3.3.3';
+const VERSION = '3.4.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -5157,6 +5661,11 @@ const EXT_MAP = {
   '.graphql': 'graphql', '.gql': 'graphql',
   '.tf': 'terraform', '.tfvars': 'terraform',
   '.proto': 'protobuf',
+  // Phase A formats
+  '.toml': 'toml',
+  '.properties': 'properties',
+  '.xml': 'xml',
+  '.md': 'markdown',
 };
 
 // Dockerfile handled separately (no extension)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap",
-  "version": "3.3.3",
+  "version": "3.4.0",
   "description": "Zero-dependency AI context engine — 97% token reduction. No npm install. Runs on Node 18+.",
   "main": "gen-context.js",
   "exports": {

package/packages/cli/package.json

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

package/packages/core/index.js

@@ -40,6 +40,11 @@ const EXT_MAP = {
   '.graphql': 'graphql', '.gql': 'graphql',
   '.tf': 'terraform', '.tfvars': 'terraform',
   '.proto': 'protobuf',
+  // Phase A formats
+  '.toml': 'toml',
+  '.properties': 'properties',
+  '.xml': 'xml',
+  '.md': 'markdown',
 };
 
 const SRC_ROOT = path.resolve(__dirname, '..', '..', 'src');

package/packages/core/package.json

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

package/src/config/defaults.js

@@ -22,6 +22,10 @@ const DEFAULTS = {
     'server', 'client', 'web', 'frontend', 'backend',
     'desktop', 'mobile', 'shared', 'common', 'core',
     'workers', 'functions', 'lambda', 'cmd',
+    // framework convention folders
+    'pages', 'components', 'hooks', 'routes', 'controllers',
+    'models', 'views', 'resources', 'config', 'db',
+    'projects', 'apps', 'libs', 'instance', 'blueprints',
   ],
 
   // Directory/file names to exclude entirely

package/src/config/loader.js

@@ -26,6 +26,7 @@ const SUPPORTED_CODE_EXTS = new Set([
   '.html', '.htm', '.css', '.scss', '.sass', '.less',
   '.yml', '.yaml', '.sh', '.bash', '.zsh', '.fish',
   '.sql', '.graphql', '.gql', '.tf', '.tfvars', '.proto',
+  '.toml', '.properties', '.xml', '.md',
 ]);
 
 /**
@@ -71,7 +72,7 @@ function detectAutoSrcDirs(cwd, excludeList) {
   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);
+    for (const d of ['src', 'app', 'apps', 'tests', 'examples', 'instance', 'blueprints']) candidates.add(d);
   }
 
   if (fs.existsSync(path.join(cwd, 'Gemfile'))) {

package/src/eval/analyzer.js

@@ -35,6 +35,10 @@ const EXT_MAP = {
   '.css': 'css',       '.scss': 'css', '.sass': 'css', '.less': 'css',
   '.yml': 'yaml',      '.yaml': 'yaml',
   '.sh': 'shell',      '.bash': 'shell', '.zsh': 'shell', '.fish': 'shell',
+  '.toml': 'toml',
+  '.properties': 'properties',
+  '.xml': 'xml',
+  '.md': 'markdown',
 };
 
 function isDockerfile(name) {

package/src/extractors/markdown.js

@@ -0,0 +1,30 @@
+'use strict';
+
+/**
+ * Lightweight markdown technical indexer.
+ * Captures headings and fenced code block language hints only.
+ *
+ * @param {string} src - Raw markdown content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Headings: # .. ######
+  for (const m of src.matchAll(/^(#{1,6})\s+(.+)$/gm)) {
+    const level = m[1].length;
+    const title = m[2].trim().replace(/\s+/g, ' ');
+    if (title) sigs.push(`h${level} ${title}`);
+  }
+
+  // Fenced code blocks: ```lang
+  for (const m of src.matchAll(/^```\s*([A-Za-z0-9_+-]*)\s*$/gm)) {
+    const lang = m[1] ? m[1].toLowerCase() : 'plain';
+    sigs.push(`code-fence ${lang}`);
+  }
+
+  return Array.from(new Set(sigs)).slice(0, 40);
+}
+
+module.exports = { extract };

package/src/extractors/properties.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Extract signatures from .properties configuration files.
+ * Captures key names, grouped by prefixes where possible.
+ *
+ * @param {string} src - Raw properties content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  const lines = src.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('!')) continue;
+
+    const idxEq = trimmed.indexOf('=');
+    const idxColon = trimmed.indexOf(':');
+    const idx = idxEq >= 0 && idxColon >= 0 ? Math.min(idxEq, idxColon) : Math.max(idxEq, idxColon);
+    if (idx <= 0) continue;
+
+    const key = trimmed.slice(0, idx).trim();
+    if (!key) continue;
+
+    const parts = key.split('.').filter(Boolean);
+    if (parts.length >= 2) {
+      sigs.push(`group ${parts[0]}.${parts[1]}`);
+    }
+    sigs.push(`key ${key}`);
+  }
+
+  return Array.from(new Set(sigs)).slice(0, 50);
+}
+
+module.exports = { extract };

package/src/extractors/toml.js

@@ -0,0 +1,42 @@
+'use strict';
+
+/**
+ * Extract signatures from TOML configuration files.
+ * Focuses on section/table names and high-value keys.
+ *
+ * @param {string} src - Raw TOML content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Remove # comments while preserving values before comment markers.
+  const stripped = src.replace(/\s+#.*$/gm, '');
+
+  // [section] and [[array.section]]
+  for (const m of stripped.matchAll(/^\s*(\[\[?[^\]]+\]\]?)\s*$/gm)) {
+    sigs.push(`table ${m[1].trim()}`);
+  }
+
+  // Key-value lines (top-level and nested) — keep key names only.
+  for (const m of stripped.matchAll(/^\s*([A-Za-z0-9_.-]+)\s*=\s*(.+)$/gm)) {
+    const key = m[1].trim();
+    const value = m[2].trim();
+
+    // Prefer common metadata/config keys for compact, useful output.
+    if (/^(name|version|description|authors|license|requires-python|dependencies|optional-dependencies|scripts|tool\.|build-system\.|project\.)/.test(key)) {
+      sigs.push(`key ${key}`);
+      continue;
+    }
+
+    // Include booleans and simple scalar keys as generic config signal.
+    if (/^(true|false|"[^"]*"|'[^']*'|[0-9._-]+)$/.test(value)) {
+      sigs.push(`key ${key}`);
+    }
+  }
+
+  return Array.from(new Set(sigs)).slice(0, 40);
+}
+
+module.exports = { extract };

package/src/extractors/xml.js

@@ -0,0 +1,46 @@
+'use strict';
+
+/**
+ * Lightweight XML config extractor.
+ * Captures root tags, key config tags, and id/name/class attributes.
+ *
+ * @param {string} src - Raw XML content
+ * @returns {string[]} Array of signature strings
+ */
+function extract(src) {
+  if (!src || typeof src !== 'string') return [];
+  const sigs = [];
+
+  // Remove comments and XML declaration for simpler scanning.
+  const stripped = src
+    .replace(/<!--[\s\S]*?-->/g, '')
+    .replace(/<\?xml[\s\S]*?\?>/gi, '');
+
+  // Root element (first opening tag).
+  const root = stripped.match(/<\s*([A-Za-z_][\w:.-]*)\b[^>]*>/);
+  if (root) sigs.push(`root ${root[1]}`);
+
+  // High-value config-like tags.
+  const tagRe = /<\s*([A-Za-z_][\w:.-]*)\b([^>]*)>/g;
+  for (const m of stripped.matchAll(tagRe)) {
+    const tag = m[1];
+    const attrs = m[2] || '';
+
+    if (/^(bean|beans|route|routes|property|properties|dependency|dependencies|plugin|plugins|configuration|settings|profile|profiles|module|modules)$/i.test(tag)) {
+      sigs.push(`tag ${tag}`);
+    }
+
+    const id = attrs.match(/\bid\s*=\s*"([^"]+)"/i);
+    if (id) sigs.push(`${tag}#${id[1]}`);
+
+    const name = attrs.match(/\bname\s*=\s*"([^"]+)"/i);
+    if (name) sigs.push(`${tag}[name=${name[1]}]`);
+
+    const cls = attrs.match(/\bclass\s*=\s*"([^"]+)"/i);
+    if (cls) sigs.push(`${tag} -> ${cls[1]}`);
+  }
+
+  return Array.from(new Set(sigs)).slice(0, 50);
+}
+
+module.exports = { extract };

package/src/mcp/server.js

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