sigmap 3.3.4 → 3.5.0

package/gen-context.js

@@ -2000,6 +2000,464 @@ __factories["./src/extractors/terraform"] = function(module, exports) {
   
 };
 
+// ── ./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/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) {
   
@@ -4020,7 +4478,7 @@ __factories["./src/mcp/server"] = function(module, exports) {
   
   const SERVER_INFO = {
     name: 'sigmap',
-    version: '3.3.4',
+    version: '3.5.0',
     description: 'SigMap MCP server — code signatures on demand',
   };
   
@@ -4919,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',
@@ -4933,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',
@@ -4944,6 +5402,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.'); }
@@ -5430,7 +5893,7 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '3.3.4';
+const VERSION = '3.5.0';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
 function requireSourceOrBundled(key) {
@@ -5452,7 +5915,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',
@@ -5466,7 +5929,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',
@@ -5477,6 +5940,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.4",
+  "version": "3.5.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.4",
+  "version": "3.5.0",
   "description": "SigMap CLI wrapper — thin adapter for programmatic CLI invocation",
   "main": "index.js",
   "keywords": [

package/packages/core/index.js

@@ -40,6 +40,21 @@ const EXT_MAP = {
   '.graphql': 'graphql', '.gql': 'graphql',
   '.tf': 'terraform', '.tfvars': 'terraform',
   '.proto': 'protobuf',
+  // Phase A formats
+  '.toml': 'toml',
+  '.properties': 'properties',
+  '.xml': 'xml',
+  '.md': 'markdown',
+  // Phase C specialized extractors
+  '.tsx': 'typescript_react',
+  '.vue': 'vue_sfc',
+};
+
+// Phase C fallback: also try specialized extractors for base extensions
+const PHASE_C_EXTRACTORS = {
+  'typescript_react': '.tsx',
+  'vue_sfc': '.vue',
+  'python_dataclass': '.py',
 };
 
 const SRC_ROOT = path.resolve(__dirname, '..', '..', 'src');

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sigmap-core",
-  "version": "3.3.4",
+  "version": "3.5.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,13 @@ 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',
+  // Phase C specialized extractors
+  '.tsx': 'typescript_react',
+  '.vue': 'vue_sfc',
 };
 
 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 };