sigmap 1.5.1 → 2.0.0-beta.1

package/gen-context.js

@@ -35,7 +35,12 @@ __factories["./src/config/defaults"] = function(module, exports) {
     outputs: ['copilot'],
   
     // Directories to scan (relative to project root)
-    srcDirs: ['src', 'app', 'lib', 'packages', 'services', 'api'],
+    srcDirs: [
+      'src', 'app', 'lib', 'packages', 'services', 'api',
+      'server', 'client', 'web', 'frontend', 'backend',
+      'desktop', 'mobile', 'shared', 'common', 'core',
+      'workers', 'functions', 'lambda', 'cmd',
+    ],
   
     // Directory/file names to exclude entirely
     exclude: [
@@ -195,9 +200,11 @@ __factories["./src/extractors/cpp"] = function(module, exports) {
     }
   
     // Top-level function declarations/definitions (not inside a class)
-    for (const m of stripped.matchAll(/^(?!class|struct|if|for|while|switch)[\w:*&<> ]+\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?\{/gm)) {
-      if (m[1].startsWith('_')) continue;
-      sigs.push(`${m[1]}(${normalizeParams(m[2])})`);
+    for (const m of stripped.matchAll(/^(?!class|struct|if|for|while|switch)([\w:*&<> ]+?)\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?\{/gm)) {
+      if (m[2].startsWith('_')) continue;
+      const ret = normalizeType(m[1]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      sigs.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -216,10 +223,12 @@ __factories["./src/extractors/cpp"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    const methodRe = /^\s+(?:virtual\s+|static\s+|inline\s+)?(?!private:|protected:|public:)[\w:*&<> ]+\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?(?:override\s*)?(?:=\s*0\s*)?;/gm;
+    const methodRe = /^\s+(?:virtual\s+|static\s+|inline\s+)?(?!private:|protected:|public:)([\w:*&<> ]+?)\s+(\w+)\s*\(([^)]*)\)\s*(?:const\s*)?(?:override\s*)?(?:=\s*0\s*)?;/gm;
     for (const m of block.matchAll(methodRe)) {
-      if (m[1].startsWith('_')) continue;
-      members.push(`${m[1]}(${normalizeParams(m[2])})`);
+      if (m[2].startsWith('_')) continue;
+      const ret = normalizeType(m[1]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -228,6 +237,11 @@ __factories["./src/extractors/cpp"] = function(module, exports) {
     if (!params) return '';
     return params.trim().replace(/\s+/g, ' ');
   }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/\s+/g, ' ').slice(0, 30);
+  }
   
   module.exports = { extract };
   
@@ -273,13 +287,24 @@ __factories["./src/extractors/csharp"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    const methodRe = /^\s+(?:public|internal|protected)\s+(?:static\s+|virtual\s+|override\s+|async\s+)*(?:[\w<>\[\]?]+\s+)+(\w+)\s*\(([^)]*)\)/gm;
+    const methodRe = /^\s+(?:public|internal|protected)\s+(?:static\s+|virtual\s+|override\s+|async\s+)*(?:where\s+\w+\s*:\s*[^\n]+\s+)?([\w<>\[\]?., ]+)\s+(\w+)\s*\(([^)]*)\)/gm;
     for (const m of block.matchAll(methodRe)) {
-      const sig = m[0].trim().split('{')[0].trim();
-      members.push(sig);
+      const ret = normalizeType(m[1]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
     return members.slice(0, 8);
   }
+
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/\s+/g, ' ').slice(0, 30);
+  }
   
   module.exports = { extract };
   
@@ -365,9 +390,11 @@ __factories["./src/extractors/dart"] = function(module, exports) {
     }
   
     // Top-level functions
-    for (const m of stripped.matchAll(/^(?:Future|void|[\w<>?]+)\s+(\w+)\s*\(([^)]*)\)/gm)) {
-      if (m[1].startsWith('_')) continue;
-      sigs.push(`${m[1]}(${normalizeParams(m[2])})`);
+    // Top-level functions — capture return type (prefix before name) and show as suffix
+    for (const m of stripped.matchAll(/^((?:Future<[\w<>?,\s]*>|[\w<>?]+))\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      if (m[2].startsWith('_')) continue;
+      const retStr = (m[1] && m[1] !== 'void') ? ` \u2192 ${m[1].replace(/\s+/g, '').slice(0, 25)}` : '';
+      sigs.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -386,9 +413,10 @@ __factories["./src/extractors/dart"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    for (const m of block.matchAll(/^\s+(?:@override\s+)?(?:Future|void|[\w<>?]+)\s+(\w+)\s*\(([^)]*)\)/gm)) {
-      if (m[1].startsWith('_')) continue;
-      members.push(`${m[1]}(${normalizeParams(m[2])})`);
+    for (const m of block.matchAll(/^\s+(?:@override\s+)?(?:@\w+\s+)*((?:Future<[\w<>?,\s]*>|[\w<>?]+))\s+(\w+)\s*\(([^)]*)\)/gm)) {
+      if (m[2].startsWith('_')) continue;
+      const retStr = (m[1] && m[1] !== 'void') ? ` \u2192 ${m[1].replace(/\s+/g, '').slice(0, 25)}` : '';
+      members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -484,9 +512,12 @@ __factories["./src/extractors/go"] = function(module, exports) {
     }
   
     // Functions and methods
-    for (const m of stripped.matchAll(/^func\s+(?:\((\w+)\s+[\w*]+\)\s+)?(\w+)\s*\(([^)]*)\)(?:\s*[\w*()\[\],\s]+)?\s*\{/gm)) {
+    // Functions and methods — capture return type between ) and {
+    for (const m of stripped.matchAll(/^func\s+(?:\((\w+)\s+[\w*]+\)\s+)?(\w+)\s*\(([^)]*)\)([^{]*)\{/gm)) {
       const receiver = m[1] ? `(${m[1]}) ` : '';
-      sigs.push(`func ${receiver}${m[2]}(${normalizeParams(m[3])})`);
+      const retType = m[4] ? m[4].trim().replace(/\s+/g, ' ') : '';
+      const retStr = retType ? ` \u2192 ${retType.slice(0, 30)}` : '';
+      sigs.push(`func ${receiver}${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -505,8 +536,10 @@ __factories["./src/extractors/go"] = function(module, exports) {
   
   function extractInterfaceMethods(block) {
     const methods = [];
-    for (const m of block.matchAll(/^\s+(\w+)\s*\(([^)]*)\)/gm)) {
-      methods.push(`${m[1]}(${normalizeParams(m[2])})`);
+    for (const m of block.matchAll(/^\s+(\w+)\s*\(([^)]*)\)([^\n]*)/gm)) {
+      const retType = m[3] ? m[3].trim().replace(/\s+/g, ' ') : '';
+      const retStr = retType ? ` \u2192 ${retType.slice(0, 30)}` : '';
+      methods.push(`${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return methods.slice(0, 8);
   }
@@ -604,13 +637,24 @@ __factories["./src/extractors/java"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?(?:final\s+)?(?:[\w<>\[\]]+\s+)+(\w+)\s*\(([^)]*)\)/gm;
+    const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?(?:final\s+)?(?:synchronized\s+)?(?:<[^>]+>\s+)?([\w<>\[\], ?.]+)\s+(\w+)\s*\(([^)]*)\)/gm;
     for (const m of block.matchAll(methodRe)) {
-      const sig = m[0].trim().split('{')[0].trim();
-      members.push(sig);
+      const ret = normalizeType(m[1]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      members.push(`${m[2]}(${normalizeParams(m[3])})${retStr}`);
     }
     return members.slice(0, 8);
   }
+
+  function normalizeParams(params) {
+    if (!params) return '';
+    return params.trim().replace(/\s+/g, ' ');
+  }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/\s+/g, ' ').slice(0, 30);
+  }
   
   module.exports = { extract };
   
@@ -627,6 +671,7 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
   function extract(src) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
+    const returnHints = buildReturnHints(src);
   
     const stripped = src
       .replace(/\/\/.*$/gm, '')
@@ -638,19 +683,21 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
       const prefix = m[1] ? m[1].trim() + ' ' : '';
       sigs.push(`${prefix}class ${m[2]}`);
       const block = extractBlock(stripped, m.index + m[0].length);
-      for (const meth of extractClassMembers(block)) sigs.push(`  ${meth}`);
+      for (const meth of extractClassMembers(block, returnHints)) sigs.push(`  ${meth}`);
     }
   
     // Exported named functions
     for (const m of stripped.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
       const asyncKw = /export\s+async/.test(m[0]) ? 'async ' : '';
-      sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = formatReturnHint(returnHints.get(m[1]));
+      sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     // Exported arrow functions
     for (const m of stripped.matchAll(/^export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(([^)]*)\)\s*=>/gm)) {
       const asyncKw = m[0].includes('async') ? 'async ' : '';
-      sigs.push(`export const ${m[1]} = ${asyncKw}(${normalizeParams(m[2])}) =>`);
+      const retStr = formatReturnHint(returnHints.get(m[1]));
+      sigs.push(`export const ${m[1]} = ${asyncKw}(${normalizeParams(m[2])}) =>${retStr}`);
     }
   
     // module.exports = { ... }
@@ -663,7 +710,8 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
     // Top-level named functions (non-exported)
     for (const m of stripped.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
       const asyncKw = m[0].startsWith('async') ? 'async ' : '';
-      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = formatReturnHint(returnHints.get(m[1]));
+      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -681,17 +729,41 @@ __factories["./src/extractors/javascript"] = function(module, exports) {
     return src.slice(startIndex, i - 1);
   }
   
-  function extractClassMembers(block) {
+  function extractClassMembers(block, returnHints) {
     const members = [];
     for (const m of block.matchAll(/^\s+(?:static\s+|async\s+|get\s+|set\s+)*(\w+)\s*\(([^)]*)\)\s*\{/gm)) {
       if (/^_/.test(m[1])) continue;
       if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
       const isAsync = m[0].includes('async ') ? 'async ' : '';
       const isStatic = m[0].includes('static ') ? 'static ' : '';
-      members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = formatReturnHint(returnHints.get(m[1]));
+      members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return members.slice(0, 8);
   }
+
+  function buildReturnHints(src) {
+    const hints = new Map();
+    for (const m of src.matchAll(/\/\*\*[\s\S]*?@returns?\s+\{([^}]+)\}[\s\S]*?\*\/\s*(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(/g)) {
+      hints.set(m[2], normalizeType(m[1]));
+    }
+    for (const m of src.matchAll(/\/\*\*[\s\S]*?@returns?\s+\{([^}]+)\}[\s\S]*?\*\/\s*export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(/g)) {
+      hints.set(m[2], normalizeType(m[1]));
+    }
+    for (const m of src.matchAll(/\/\*\*[\s\S]*?@returns?\s+\{([^}]+)\}[\s\S]*?\*\/\s*(?:static\s+|async\s+|get\s+|set\s+)*(\w+)\s*\(/g)) {
+      hints.set(m[2], normalizeType(m[1]));
+    }
+    return hints;
+  }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/\s+/g, ' ').slice(0, 25);
+  }
+
+  function formatReturnHint(type) {
+    return type ? ` \u2192 ${type}` : '';
+  }
   
   function normalizeParams(params) {
     if (!params) return '';
@@ -726,9 +798,12 @@ __factories["./src/extractors/kotlin"] = function(module, exports) {
     }
   
     // Top-level functions
-    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    // Top-level functions — capture `: RetType` after params
+    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^\n{=]+))?/gm)) {
       const suspend = m[0].includes('suspend') ? 'suspend ' : '';
-      sigs.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})`);
+      const retType = m[3] ? m[3].trim().replace(/\s+/g, ' ') : '';
+      const retStr = retType ? ` \u2192 ${retType.slice(0, 25)}` : '';
+      sigs.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -747,10 +822,12 @@ __factories["./src/extractors/kotlin"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|override\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|override\s+)?(?:suspend\s+)?fun\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*([^\n{=]+))?/gm)) {
       if (m[1].startsWith('_')) continue;
       const suspend = m[0].includes('suspend') ? 'suspend ' : '';
-      members.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})`);
+      const retType = m[3] ? m[3].trim().replace(/\s+/g, ' ') : '';
+      const retStr = retType ? ` \u2192 ${retType.slice(0, 25)}` : '';
+      members.push(`${suspend}fun ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -796,8 +873,10 @@ __factories["./src/extractors/php"] = function(module, exports) {
     }
   
     // Top-level functions
-    for (const m of stripped.matchAll(/^function\s+(\w+)\s*\(([^)]*)\)/gm)) {
-      sigs.push(`function ${m[1]}(${normalizeParams(m[2])})`);
+    for (const m of stripped.matchAll(/^function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^\n{]+))?/gm)) {
+      const ret = normalizeType(m[3]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      sigs.push(`function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -816,11 +895,13 @@ __factories["./src/extractors/php"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm;
+    const methodRe = /^\s+(?:public|protected)\s+(?:static\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*(?::\s*([^\n{]+))?/gm;
     for (const m of block.matchAll(methodRe)) {
       if (m[1].startsWith('_')) continue;
       const isStatic = m[0].includes('static ') ? 'static ' : '';
-      members.push(`${isStatic}function ${m[1]}(${normalizeParams(m[2])})`);
+      const ret = normalizeType(m[3]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      members.push(`${isStatic}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -829,6 +910,11 @@ __factories["./src/extractors/php"] = function(module, exports) {
     if (!params) return '';
     return params.trim().replace(/\s+/g, ' ');
   }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/[;\s]+$/g, '').replace(/\s+/g, ' ').slice(0, 25);
+  }
   
   module.exports = { extract };
   
@@ -846,60 +932,152 @@ __factories["./src/extractors/python"] = function(module, exports) {
     if (!src || typeof src !== 'string') return [];
     const sigs = [];
   
-    // Strip comments and docstrings (simple approach)
-    const stripped = src
-      .replace(/#.*$/gm, '')
+    // noComments: strip only # comments, keep docstrings (needed for @decorator detection)
+    const noComments = src.replace(/#.*$/gm, '');
+    // stripped: also strip docstrings (safe for regex matching)
+    const stripped = noComments
       .replace(/"""[\s\S]*?"""/g, '')
       .replace(/'''[\s\S]*?'''/g, '');
   
     // Classes
     for (const m of stripped.matchAll(/^class\s+(\w+)(?:\s*\(([^)]*)\))?\s*:/gm)) {
-      const base = m[2] ? `(${m[2].trim()})` : '';
-      sigs.push(`class ${m[1]}${base}`);
-      // Get class body methods
+      const className = m[1];
+      const baseName = m[2] ? m[2].trim() : '';
       const bodyStart = m.index + m[0].length;
+  
+      // Try @dataclass collapse
+      const dcFields = tryExtractDataclassFields(stripped, m.index);
+      if (dcFields !== null) {
+        sigs.push(`@dataclass ${className}(${dcFields})`);
+        continue;
+      }
+  
+      // Try BaseModel/BaseSettings collapse
+      if (/(BaseModel|BaseSettings)/.test(baseName)) {
+        const bmFields = tryExtractBaseModelFields(stripped, bodyStart);
+        if (bmFields) {
+          sigs.push(`class ${className}(${baseName}) ${bmFields}`);
+          continue;
+        }
+      }
+  
+      const baseStr = baseName ? `(${baseName})` : '';
+      sigs.push(`class ${className}${baseStr}`);
+  
+      // Class-level ALL_CAPS constants
+      for (const c of extractClassConstants(stripped, bodyStart)) {
+        sigs.push(`  ${c}`);
+      }
+  
+      // Methods
       const methods = extractClassMethods(stripped, bodyStart);
       for (const meth of methods) sigs.push(`  ${meth}`);
     }
   
     // Top-level functions
-    for (const m of stripped.matchAll(/^(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/gm)) {
-      if (/^_/.test(m[1])) continue; // skip private
-      const asyncKw = m[0].trimStart().startsWith('async') ? 'async ' : '';
-      const params = normalizeParams(m[2]);
-      sigs.push(`${asyncKw}def ${m[1]}(${params})`);
+    for (const m of stripped.matchAll(/^((?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*[^:]+)?)\s*:/gm)) {
+      if (/^_/.test(m[2])) continue;
+      const asyncKw = m[1].trimStart().startsWith('async') ? 'async ' : '';
+      const params = normalizeParams(m[3]);
+      const retType = extractReturnType(m[1] + ':');
+      const retStr = retType ? ` \u2192 ${retType}` : '';
+      sigs.push(`${asyncKw}def ${m[2]}(${params})${retStr}`);
     }
   
     return sigs.slice(0, 25);
   }
   
-  function extractClassMethods(src, startIndex) {
+  function extractClassMethods(stripped, startIndex) {
     const methods = [];
-    // Extract indented block
-    const lines = src.slice(startIndex).split('\n');
+    const lines = stripped.slice(startIndex).split('\n');
     for (const line of lines) {
       if (line.trim() === '') continue;
-      // End of class body: line with no leading indent that is not blank
       const indent = line.match(/^(\s+)/);
       if (!indent) break;
-      const m = line.match(/^\s+(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)/);
+      const m = line.match(/^\s+(?:async\s+)?def\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^:]+))?\s*:/);
       if (m) {
         if (m[1].startsWith('__') && m[1] !== '__init__') continue;
         if (m[1].startsWith('_') && !m[1].startsWith('__')) continue;
         const asyncKw = line.trimStart().startsWith('async') ? 'async ' : '';
-        const params = normalizeParams(m[2]).replace(/^self,?\s*/, '');
-        methods.push(`${asyncKw}def ${m[1]}(${params})`);
+        const params = normalizeParams(m[2]).replace(/^self,?\s*/, '').replace(/^cls,?\s*/, '');
+        const retType = m[3] ? m[3].trim().replace(/Optional\[([^\]]+)\]/, '$1|None').slice(0, 30) : '';
+        const retStr = retType ? ` \u2192 ${retType}` : '';
+        methods.push(`${asyncKw}def ${m[1]}(${params})${retStr}`);
       }
     }
     return methods.slice(0, 8);
   }
   
+  function tryExtractDataclassFields(stripped, classIndex) {
+    const before = stripped.slice(Math.max(0, classIndex - 120), classIndex);
+    if (!/@dataclass/.test(before)) return null;
+    const lines = stripped.slice(classIndex).split('\n');
+    const fields = [];
+    for (const line of lines.slice(1)) {
+      if (line.trim() === '') continue;
+      if (!line.match(/^\s+/)) break;
+      const f = line.match(/^\s+(\w+)\s*:\s*([^=\n]+?)(?:\s*=.*)?$/);
+      if (!f) break;
+      const isOptional = f[2].includes('Optional') || /=\s*None/.test(line);
+      fields.push(isOptional ? `${f[1]}?` : f[1]);
+    }
+    return fields.length ? fields.join(', ') : null;
+  }
+  
+  function tryExtractBaseModelFields(stripped, bodyStart) {
+    const lines = stripped.slice(bodyStart, bodyStart + 800).split('\n');
+    const fields = [];
+    for (const line of lines) {
+      if (!line.match(/^\s{4}\w/)) continue;
+      const f = line.match(/^\s{4}(\w+)\s*(?::\s*([^=\n]+?))?(?:\s*=\s*(.*))?$/);
+      if (!f || f[1].startsWith('_') || f[1] === 'class' || f[1] === 'def') continue;
+      const isOptional = (f[2] || '').includes('Optional') || f[3] !== undefined;
+      fields.push(isOptional ? `${f[1]}?` : `${f[1]}*`);
+    }
+    return fields.length ? `{${fields.slice(0, 6).join(', ')}}` : null;
+  }
+  
+  function extractClassConstants(stripped, startIndex) {
+    const lines = stripped.slice(startIndex).split('\n');
+    const consts = [];
+    for (const line of lines) {
+      if (!line.match(/^\s+/)) break;
+      const c = line.match(/^\s+([A-Z][A-Z0-9_]{2,})\s*=\s*(.+)/);
+      if (!c) continue;
+      let val = c[2].trim();
+      const items = (val.match(/"([^"]+)"/g) || val.match(/'([^']+)'/g) || []);
+      if (items.length > 3) val = `[${items[0].replace(/['"]/g, '')}..${items[items.length - 1].replace(/['"]/g, '')}]`;
+      if (val.length > 40) val = val.slice(0, 37) + '...';
+      consts.push(`${c[1]}=${val}`);
+    }
+    return consts.slice(0, 3);
+  }
+  
+  function extractReturnType(sigLine) {
+    const m = sigLine.match(/->\s*([^:]+):/);
+    if (!m) return '';
+    let rt = m[1].trim();
+    rt = rt.replace(/Optional\[([^\]]+)\]/, '$1|None');
+    return rt.length > 30 ? rt.slice(0, 27) + '...' : rt;
+  }
+  
   function normalizeParams(params) {
     if (!params) return '';
     return params.trim()
       .split(',')
-      .map((p) => p.trim().split(':')[0].split('=')[0].trim())
-      .filter(Boolean)
+      .map((p) => {
+        const part = p.trim();
+        if (!part) return '';
+        const stars = part.match(/^(\*{1,2})/)?.[1] || '';
+        const rest = part.slice(stars.length);
+        const eqIdx = rest.indexOf('=');
+        const noDefault = eqIdx !== -1 ? rest.slice(0, eqIdx).trim() : rest.trim();
+        const clean = noDefault
+          .replace(/Optional\[([^\]]+)\]/, '$1?')
+          .replace(/Union\[([^\]]+),\s*None\]/, '$1?');
+        return stars + clean;
+      })
+      .filter((p) => p && p !== 'self' && p !== 'cls')
       .join(', ');
   }
   
@@ -932,14 +1110,16 @@ __factories["./src/extractors/ruby"] = function(module, exports) {
       if (m[1].startsWith('_')) continue;
       const params = m[2] ? `(${normalizeParams(m[2])})` : '';
       const selfPrefix = m[0].includes('self.') ? 'self.' : '';
-      sigs.push(`  def ${selfPrefix}${m[1]}${params}`);
+      const retStr = extractReturnHint(stripped, m.index);
+      sigs.push(`  def ${selfPrefix}${m[1]}${params}${retStr}`);
     }
   
     // Top-level def
     for (const m of stripped.matchAll(/^def\s+(\w+)(?:\s*\(([^)]*)\))?/gm)) {
       if (m[1].startsWith('_')) continue;
       const params = m[2] ? `(${normalizeParams(m[2])})` : '';
-      sigs.push(`def ${m[1]}${params}`);
+      const retStr = extractReturnHint(stripped, m.index);
+      sigs.push(`def ${m[1]}${params}${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -949,6 +1129,15 @@ __factories["./src/extractors/ruby"] = function(module, exports) {
     if (!params) return '';
     return params.trim().replace(/\s+/g, ' ');
   }
+
+  function extractReturnHint(stripped, index) {
+    const start = Math.max(0, index - 180);
+    const before = stripped.slice(start, index);
+    const m = before.match(/sig\s*\{[\s\S]*?returns\(([^)]+)\)[\s\S]*?\}\s*$/);
+    if (!m) return '';
+    const type = m[1].trim().replace(/\s+/g, ' ').slice(0, 25);
+    return type ? ` \u2192 ${type}` : '';
+  }
   
   module.exports = { extract };
   
@@ -993,9 +1182,11 @@ __factories["./src/extractors/rust"] = function(module, exports) {
     }
   
     // Top-level pub fns
-    for (const m of stripped.matchAll(/^pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    // Top-level pub fns — capture everything after ) up to { or ; for return type
+    for (const m of stripped.matchAll(/^pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)([^{;]*)/gm)) {
       const asyncKw = m[0].includes('async') ? 'async ' : '';
-      sigs.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = extractReturnType(m[3]);
+      sigs.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -1014,9 +1205,10 @@ __factories["./src/extractors/rust"] = function(module, exports) {
   
   function extractMethods(block) {
     const methods = [];
-    for (const m of block.matchAll(/^\s+pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    for (const m of block.matchAll(/^\s+pub(?:\s+async)?\s+fn\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)([^{;]*)/gm)) {
       const asyncKw = m[0].includes('async') ? 'async ' : '';
-      methods.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = extractReturnType(m[3]);
+      methods.push(`pub ${asyncKw}fn ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return methods.slice(0, 8);
   }
@@ -1026,6 +1218,14 @@ __factories["./src/extractors/rust"] = function(module, exports) {
     return params.trim().replace(/\s+/g, ' ');
   }
   
+    function extractReturnType(afterParen) {
+      if (!afterParen) return '';
+      const m = afterParen.match(/->\s*([^{;]+)/);
+      if (!m) return '';
+      const rt = m[1].trim().replace(/\s+/g, ' ');
+      return ` \u2192 ${rt.length > 30 ? rt.slice(0, 27) + '...' : rt}`;
+    }
+
   module.exports = { extract };
   
 };
@@ -1058,10 +1258,12 @@ __factories["./src/extractors/scala"] = function(module, exports) {
     }
   
     // Top-level defs
-    for (const m of stripped.matchAll(/^def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?/gm)) {
+    for (const m of stripped.matchAll(/^def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?(?:\s*:\s*([^=\n{]+))?/gm)) {
       if (m[1].startsWith('_')) continue;
       const params = m[2] ? `(${normalizeParams(m[2])})` : '';
-      sigs.push(`def ${m[1]}${params}`);
+      const ret = normalizeType(m[3]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      sigs.push(`def ${m[1]}${params}${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -1080,10 +1282,12 @@ __factories["./src/extractors/scala"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    for (const m of block.matchAll(/^\s+def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?/gm)) {
+    for (const m of block.matchAll(/^\s+def\s+(\w+)(?:\[[\w, ]+\])?\s*(?:\(([^)]*)\))?(?:\s*:\s*([^=\n{]+))?/gm)) {
       if (m[1].startsWith('_')) continue;
       const params = m[2] ? `(${normalizeParams(m[2])})` : '';
-      members.push(`def ${m[1]}${params}`);
+      const ret = normalizeType(m[3]);
+      const retStr = ret ? ` \u2192 ${ret}` : '';
+      members.push(`def ${m[1]}${params}${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -1096,6 +1300,11 @@ __factories["./src/extractors/scala"] = function(module, exports) {
       .filter(Boolean)
       .join(', ');
   }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/\s+/g, ' ').slice(0, 25);
+  }
   
   module.exports = { extract };
   
@@ -1174,16 +1383,18 @@ __factories["./src/extractors/svelte"] = function(module, exports) {
     }
   
     // Exported functions
-    for (const m of script.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    for (const m of script.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?/gm)) {
       const asyncKw = m[0].includes('async') ? 'async ' : '';
-      sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = m[3] ? ` \u2192 ${normalizeType(m[3])}` : '';
+      sigs.push(`export ${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     // Top-level functions
-    for (const m of script.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/gm)) {
+    for (const m of script.matchAll(/^(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?/gm)) {
       if (m[1].startsWith('_')) continue;
       const asyncKw = m[0].startsWith('async') ? 'async ' : '';
-      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = m[3] ? ` \u2192 ${normalizeType(m[3])}` : '';
+      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     // Reactive declarations $:
@@ -1198,6 +1409,11 @@ __factories["./src/extractors/svelte"] = function(module, exports) {
     if (!params) return '';
     return params.trim().replace(/\s+/g, ' ');
   }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/[;\s]+$/g, '').replace(/\s+/g, ' ').slice(0, 25);
+  }
   
   module.exports = { extract };
   
@@ -1228,9 +1444,11 @@ __factories["./src/extractors/swift"] = function(module, exports) {
     }
   
     // Top-level public functions
-    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:static\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    // Top-level public functions — capture everything after ) to end of line for arrow type
+    for (const m of stripped.matchAll(/^(?:public\s+|internal\s+)?(?:static\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)([^{\n]*)/gm)) {
       const asyncKw = m[0].includes('async') ? 'async ' : '';
-      sigs.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = extractArrowType(m[3]);
+      sigs.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
   
     return sigs.slice(0, 25);
@@ -1249,10 +1467,11 @@ __factories["./src/extractors/swift"] = function(module, exports) {
   
   function extractMembers(block) {
     const members = [];
-    for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|open\s+)?(?:static\s+|class\s+)?(?:mutating\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)/gm)) {
+    for (const m of block.matchAll(/^\s+(?:public\s+|internal\s+|open\s+)?(?:static\s+|class\s+)?(?:mutating\s+)?(?:async\s+)?func\s+(\w+)(?:<[^(]*>)?\s*\(([^)]*)\)([^{\n]*)/gm)) {
       if (m[1].startsWith('_')) continue;
       const asyncKw = m[0].includes('async') ? 'async ' : '';
-      members.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})`);
+      const retStr = extractArrowType(m[3]);
+      members.push(`${asyncKw}func ${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -1266,6 +1485,14 @@ __factories["./src/extractors/swift"] = function(module, exports) {
       .join(', ');
   }
   
+    function extractArrowType(str) {
+      if (!str) return '';
+      const m = str.match(/->\s*([^\n{]+)/);
+      if (!m) return '';
+      const rt = m[1].trim().replace(/\s+/g, ' ');
+      return ` \u2192 ${rt.length > 25 ? rt.slice(0, 22) + '...' : rt}`;
+    }
+
   module.exports = { extract };
   
 };
@@ -1323,7 +1550,10 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
     for (const m of stripped.matchAll(/^export\s+(?:async\s+)?function\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)(?:\s*:\s*[^{]+)?\s*\{/gm)) {
       const asyncKw = /export\s+async/.test(m[0]) ? 'async ' : '';
       const params = normalizeParams(m[2]);
-      sigs.push(`export ${asyncKw}function ${m[1]}(${params})`);
+      const retMatch = m[0].match(/\)\s*:\s*([^{]+)\s*\{/);
+      const retType = retMatch ? retMatch[1].trim().replace(/\s+/g, ' ').slice(0, 30) : '';
+      const retStr = retType ? ` \u2192 ${retType}` : '';
+      sigs.push(`export ${asyncKw}function ${m[1]}(${params})${retStr}`);
     }
   
     // Exported arrow functions / const functions
@@ -1350,9 +1580,11 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
   
   function extractInterfaceMembers(block) {
     const members = [];
-    for (const m of block.matchAll(/^\s+(readonly\s+)?(\w+)\??:\s*[^;]+;/gm)) {
+    for (const m of block.matchAll(/^\s+(readonly\s+)?(\w+)(\??):\s*([^;]+);/gm)) {
       const readonly = m[1] ? 'readonly ' : '';
-      members.push(`${readonly}${m[2]}`);
+      const optional = m[3] ? '?' : '';
+      const typeStr = m[4].trim().replace(/\s+/g, ' ').slice(0, 20);
+      members.push(`${readonly}${m[2]}${optional}: ${typeStr}`);
     }
     for (const m of block.matchAll(/^\s+(\w+)\s*(?:<[^(]*>)?\s*\(([^)]*)\)\s*:/gm)) {
       members.push(`${m[1]}(${normalizeParams(m[2])})`);
@@ -1369,7 +1601,10 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
       if (m[1] === 'constructor') { members.push(`constructor(${normalizeParams(m[2])})`); continue; }
       const isAsync = m[0].includes('async ') ? 'async ' : '';
       const isStatic = m[0].includes('static ') ? 'static ' : '';
-      members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})`);
+      const retMatch = m[0].match(/\)\s*:\s*([^{;]+)\s*\{/);
+      const retType = retMatch ? retMatch[1].trim().replace(/\s+/g, ' ').slice(0, 20) : '';
+      const retStr = retType ? ` \u2192 ${retType}` : '';
+      members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})${retStr}`);
     }
     return members.slice(0, 8);
   }
@@ -1383,6 +1618,58 @@ __factories["./src/extractors/typescript"] = function(module, exports) {
   
 };
 
+// ── ./src/extractors/deps ──
+__factories["./src/extractors/deps"] = function(module, exports) {
+  
+  'use strict';
+  
+  const PYTHON_STDLIB = new Set([
+    'os', 'sys', 're', 'json', 'time', 'threading', 'logging', 'typing',
+    'dataclasses', 'datetime', 'uuid', 'pathlib', 'collections', 'functools',
+    'itertools', 'math', 'random', 'string', 'struct', 'io', 'copy', 'pprint',
+    'traceback', 'inspect', 'abc', 'enum', 'contextlib', 'weakref', 'gc',
+    'socket', 'ssl', 'http', 'urllib', 'email', 'html', 'xml', 'csv', 'sqlite3',
+    'argparse', 'subprocess', 'shutil', 'tempfile', 'glob', 'fnmatch', 'stat',
+    'hashlib', 'hmac', 'base64', 'binascii', 'codecs', 'unicodedata', 'locale',
+    'decimal', 'fractions', 'numbers', 'cmath', 'heapq', 'bisect', 'array',
+    'queue', 'asyncio', 'concurrent', 'multiprocessing', 'signal', 'mmap',
+    'builtins', 'warnings', 'operator', 'textwrap', 'difflib', 'readline',
+  ]);
+  
+  function extractPythonDeps(src) {
+    const deps = new Set();
+    for (const m of src.matchAll(/^from\s+([\w.]+)\s+import/gm)) {
+      const mod = m[1];
+      const root = mod.replace(/^\.+/, '').split('.')[0];
+      if (mod.startsWith('.') || (root && !PYTHON_STDLIB.has(root))) {
+        deps.add(root || mod);
+      }
+    }
+    for (const m of src.matchAll(/^import\s+([\w.]+)/gm)) {
+      const root = m[1].split('.')[0];
+      if (root && !PYTHON_STDLIB.has(root)) deps.add(root);
+    }
+    return [...deps].filter(Boolean).slice(0, 5);
+  }
+  
+  function extractTSDeps(src) {
+    // Strip single-line comments to avoid matching commented-out imports
+    const stripped = src.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+    const deps = new Set();
+    for (const m of stripped.matchAll(/from\s+['"](\.[\/\w.-]+)['"]/g)) {
+      const clean = m[1]
+        .replace(/^\.\.\//, '')
+        .replace(/^\.\//, '')
+        .replace(/\.\w+$/, '');
+      if (clean) deps.add(clean);
+    }
+    return [...deps].slice(0, 5);
+  }
+  
+  module.exports = { extractPythonDeps, extractTSDeps };
+  
+};
+
 // ── ./src/extractors/vue ──
 __factories["./src/extractors/vue"] = function(module, exports) {
   
@@ -1420,12 +1707,21 @@ __factories["./src/extractors/vue"] = function(module, exports) {
     // Methods in options API
     const methodsMatch = script.match(/methods\s*:\s*\{([\s\S]*?)\},?\s*(?:computed|watch|mounted|created|data|\})/);
     if (methodsMatch) {
-      for (const m of methodsMatch[1].matchAll(/^\s+(?:async\s+)?(\w+)\s*\(([^)]*)\)/gm)) {
+      for (const m of methodsMatch[1].matchAll(/^\s+(?:async\s+)?(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?/gm)) {
         if (m[1].startsWith('_')) continue;
         const asyncKw = m[0].includes('async') ? 'async ' : '';
-        sigs.push(`  ${asyncKw}${m[1]}(${normalizeParams(m[2])})`);
+        const retStr = m[3] ? ` \u2192 ${normalizeType(m[3])}` : '';
+        sigs.push(`  ${asyncKw}${m[1]}(${normalizeParams(m[2])})${retStr}`);
       }
     }
+
+    // Top-level functions in <script> (e.g., composition API helpers)
+    for (const m of script.matchAll(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)(?:\s*:\s*([^{=\n]+))?/gm)) {
+      if (m[1].startsWith('_')) continue;
+      const asyncKw = m[0].includes('async') ? 'async ' : '';
+      const retStr = m[3] ? ` \u2192 ${normalizeType(m[3])}` : '';
+      sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
+    }
   
     // defineProps (Composition API)
     const definePropsMatch = script.match(/defineProps(?:<[^>]*>)?\s*\(\s*(\{[\s\S]*?\})\s*\)/);
@@ -1448,6 +1744,11 @@ __factories["./src/extractors/vue"] = function(module, exports) {
     if (!params) return '';
     return params.trim().replace(/\s+/g, ' ');
   }
+
+  function normalizeType(type) {
+    if (!type) return '';
+    return type.trim().replace(/[;\s]+$/g, '').replace(/\s+/g, ' ').slice(0, 25);
+  }
   
   module.exports = { extract };
   
@@ -3219,14 +3520,23 @@ const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VERSION = '1.5.1';
+const VERSION = '2.0.0-beta.1';
 const MARKER = '\n\n## Auto-generated signatures\n<!-- Updated by gen-context.js -->\n';
 
+function requireSourceOrBundled(key) {
+  try {
+    const rel = key.replace(/^\.\//, '') + '.js';
+    const abs = path.join(__dirname, rel);
+    if (fs.existsSync(abs)) return require(abs);
+  } catch (_) {}
+  return __require(key);
+}
+
 // ---------------------------------------------------------------------------
 // Config — delegate to src/config/loader.js
 // ---------------------------------------------------------------------------
-const { loadConfig } = __require('./src/config/loader');
-const { DEFAULTS } = __require('./src/config/defaults');
+const { loadConfig } = requireSourceOrBundled('./src/config/loader');
+const { DEFAULTS } = requireSourceOrBundled('./src/config/defaults');
 
 // ---------------------------------------------------------------------------
 // Language → extractor mapping (by file extension)
@@ -3335,7 +3645,7 @@ const _extractorCache = {};
 function getExtractor(name) {
   if (_extractorCache[name]) return _extractorCache[name];
   try {
-    const mod = __require(`./src/extractors/${name}`);
+    const mod = requireSourceOrBundled(`./src/extractors/${name}`);
     _extractorCache[name] = mod;
     return mod;
   } catch (err) {
@@ -3363,6 +3673,35 @@ function detectAndExtract(filePath, content, maxSigsPerFile) {
   }
 }
 
+function extractFileDeps(filePath, content, config) {
+  if (config && config.depMap === false) return [];
+  try {
+    const { extractPythonDeps, extractTSDeps } = requireSourceOrBundled('./src/extractors/deps');
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.py' || ext === '.pyw') return extractPythonDeps(content);
+    if (['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext)) return extractTSDeps(content);
+  } catch (_) {}
+  return [];
+}
+
+function extractSignatureName(sig) {
+  const s = (sig || '').trim();
+  const m = s.match(/(?:def|function|func|constructor|async\s+def|async\s+function)?\s*([A-Za-z_][A-Za-z0-9_]*)\s*\(/);
+  return m ? m[1] : '';
+}
+
+function annotateCoverage(sigs, testIndex, enabled) {
+  if (!enabled || !testIndex || testIndex.size === 0) return sigs;
+  const { isTested } = requireSourceOrBundled('./src/extractors/coverage');
+  return sigs.map((sig) => {
+    const name = extractSignatureName(sig);
+    if (!name) return sig;
+    // Skip non-callable/type declarations.
+    if (/^(class|interface|enum|type|module|trait|struct|record)\b/.test(sig.trim())) return sig;
+    return `${sig}  ${isTested(name, testIndex) ? '✓' : '✗'}`;
+  });
+}
+
 // ---------------------------------------------------------------------------
 // Token budget enforcement
 // ---------------------------------------------------------------------------
@@ -3454,10 +3793,163 @@ function getDiffFiles(cwd, stagedOnly) {
   }
 }
 
+function getFilesChangedSinceBase(cwd, baseRef) {
+  try {
+    const out = execSync(`git diff ${baseRef}..HEAD --name-only`, {
+      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return new Set(out.split('\n').map((f) => f.trim()).filter(Boolean).map((f) => path.resolve(cwd, f)));
+  } catch (_) {
+    return new Set();
+  }
+}
+
+function buildDiffSectionFromBase(cwd, baseRef, currentEntries, config) {
+  const { diffSignatures, extractName } = requireSourceOrBundled('./src/extractors/prdiff');
+  const lines = ['## diff (vs ' + baseRef + ')', '```'];
+
+  for (const entry of currentEntries) {
+    const rel = path.relative(cwd, entry.filePath);
+    let baseSrc = '';
+    try {
+      baseSrc = execSync(`git show ${baseRef}:"${rel}" 2>/dev/null`, {
+        cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (_) {
+      baseSrc = '';
+    }
+
+    const baseSigs = baseSrc ? detectAndExtract(entry.filePath, baseSrc, config.maxSigsPerFile) : [];
+    const d = diffSignatures(baseSigs, entry.sigs || []);
+
+    const markers = [];
+    for (const a of d.added.slice(0, 4)) {
+      const n = extractName(a);
+      if (n) markers.push(`+${n}`);
+    }
+    for (const r of d.removed.slice(0, 4)) {
+      const n = extractName(r);
+      if (n) markers.push(`-${n}`);
+    }
+    for (const m of d.modified.slice(0, 4)) markers.push(`~${m}`);
+    if (markers.length === 0) continue;
+    lines.push(`${rel}`);
+    lines.push(`  ${[...new Set(markers)].slice(0, 6).join('  ')}`);
+  }
+
+  lines.push('```', '');
+  return lines.length > 3 ? lines : [];
+}
+
 // ---------------------------------------------------------------------------
 // Output formatter
 // ---------------------------------------------------------------------------
-function formatOutput(fileEntries, cwd, routingEnabled) {
+function buildDepMap(fileEntries, cwd) {
+  const lines = [];
+  for (const entry of fileEntries) {
+    const deps = entry.deps;
+    if (!deps || deps.length === 0) continue;
+    const rel = path.relative(cwd, entry.filePath);
+    lines.push(`${rel} \u2190 ${deps.join(', ')}`);
+  }
+  return lines;
+}
+
+function buildTodoSection(fileEntries, cwd, config) {
+  if (config && config.todos === false) return [];
+  const { extractTodos } = requireSourceOrBundled('./src/extractors/todos');
+  const out = [];
+  for (const entry of fileEntries) {
+    const todos = extractTodos(entry.content || '');
+    if (!todos || todos.length === 0) continue;
+    const rel = path.relative(cwd, entry.filePath);
+    for (const t of todos) {
+      out.push(`${rel}:${t.line}  # ${t.tag}: ${t.text}`);
+    }
+  }
+  return out.slice(0, 20);
+}
+
+function buildChangesSection(cwd, config, fileEntries) {
+  if (config && config.changes === false) return [];
+  const n = (config && config.changesCommits) || 5;
+  try {
+    let range = `HEAD~${n}..HEAD`;
+    try {
+      execSync(`git rev-parse --verify HEAD~${n} 2>/dev/null`, {
+        cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (_) {
+      range = 'HEAD~1..HEAD';
+    }
+
+    const namesOnly = execSync(`git diff ${range} --name-only 2>/dev/null`, {
+      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    const changed = new Set(namesOnly.split('\n').map((l) => l.trim()).filter(Boolean).map((f) => path.resolve(cwd, f)));
+    if (changed.size === 0) return [];
+
+    const timeAgo = execSync('git log -1 --format="%cr" 2>/dev/null', {
+      cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+
+    const lines = [`## changes (last ${n} commits — ${timeAgo})`, '```'];
+    let hasDelta = false;
+    for (const entry of fileEntries) {
+      if (!changed.has(entry.filePath)) continue;
+      const rel = path.relative(cwd, entry.filePath);
+      let diff = '';
+      try {
+        diff = execSync(`git diff ${range} -- "${rel}" 2>/dev/null`, {
+          cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      } catch (_) {
+        continue;
+      }
+      const plus = [...diff.matchAll(/^\+.*(?:def\s+|function\s+|class\s+|func\s+)(\w+)/gm)].map((m) => `+${m[1]}`);
+      const mod = [...diff.matchAll(/^-.*(?:def\s+|function\s+|class\s+|func\s+)(\w+)/gm)].map((m) => `~${m[1]}`);
+      const delta = [...new Set([...plus, ...mod])].slice(0, 4).join('  ');
+      if (delta) {
+        hasDelta = true;
+        lines.push(`${rel.padEnd(45)} ${delta}`);
+      }
+    }
+    lines.push('```', '');
+    return hasDelta ? lines : [];
+  } catch (_) {
+    return [];
+  }
+}
+
+function normalizeRelNoExt(rel) {
+  return rel.replace(/\.[^.]+$/, '').replace(/\\/g, '/');
+}
+
+function resolveImpactRadius(fileEntries, cwd, config) {
+  const map = new Map();
+  if (!config || !config.impactRadius) return map;
+  const rels = fileEntries.map((e) => path.relative(cwd, e.filePath));
+  const keys = rels.map((r) => ({ rel: r, norm: normalizeRelNoExt(r), base: path.basename(normalizeRelNoExt(r)) }));
+
+  for (const entry of fileEntries) {
+    const importer = path.relative(cwd, entry.filePath);
+    for (const dep of (entry.deps || [])) {
+      const depNorm = dep.replace(/\\/g, '/').replace(/^\.\//, '').replace(/\.[^.]+$/, '');
+      const matches = keys.filter((k) => k.norm.endsWith(depNorm) || k.base === depNorm || k.norm === depNorm);
+      for (const m of matches) {
+        if (!map.has(m.rel)) map.set(m.rel, []);
+        map.get(m.rel).push(importer);
+      }
+    }
+  }
+
+  for (const [k, v] of map.entries()) {
+    map.set(k, [...new Set(v)].slice(0, 5));
+  }
+  return map;
+}
+
+function formatOutput(fileEntries, cwd, routingEnabled, config, extras) {
   const lines = [
     '<!-- Generated by SigMap gen-context.js v' + VERSION + ' -->',
     '<!-- DO NOT EDIT below the marker line — run gen-context.js to regenerate -->',
@@ -3466,6 +3958,34 @@ function formatOutput(fileEntries, cwd, routingEnabled) {
     '',
   ];
 
+  // Compact dependency map section (shows import relationships, ~50-100 tokens)
+  const depLines = buildDepMap(fileEntries, cwd);
+  if ((!config || config.depMap !== false) && depLines.length) {
+    lines.push('## deps');
+    lines.push('```');
+    lines.push(...depLines);
+    lines.push('```');
+    lines.push('');
+  }
+
+  const todoLines = buildTodoSection(fileEntries, cwd, config || {});
+  if (todoLines.length) {
+    lines.push('## todos');
+    lines.push('```');
+    lines.push(...todoLines);
+    lines.push('```');
+    lines.push('');
+  }
+
+  const changesLines = buildChangesSection(cwd, config || {}, fileEntries);
+  if (changesLines.length) lines.push(...changesLines);
+
+  if (extras && Array.isArray(extras.diffSection) && extras.diffSection.length) {
+    lines.push(...extras.diffSection);
+  }
+
+  const impactMap = resolveImpactRadius(fileEntries, cwd, config || {});
+
   // Group by top-level src dir
   const groups = {};
   for (const entry of fileEntries) {
@@ -3481,7 +4001,9 @@ function formatOutput(fileEntries, cwd, routingEnabled) {
     lines.push('');
     for (const { rel, sigs } of entries) {
       if (sigs.length === 0) continue;
-      lines.push(`### ${rel}`);
+      const usedBy = impactMap.get(rel);
+      const usedByStr = usedBy && usedBy.length ? ` (used by: ${usedBy.join(', ')})` : '';
+      lines.push(`### ${rel}${usedByStr}`);
       lines.push('```');
       lines.push(...sigs);
       lines.push('```');
@@ -3491,8 +4013,8 @@ function formatOutput(fileEntries, cwd, routingEnabled) {
 
   if (routingEnabled) {
     try {
-      const { classifyAll } = __require('./src/routing/classifier');
-      const { formatRoutingSection } = __require('./src/routing/hints');
+      const { classifyAll } = requireSourceOrBundled('./src/routing/classifier');
+      const { formatRoutingSection } = requireSourceOrBundled('./src/routing/hints');
       const groups = classifyAll(fileEntries, cwd);
       lines.push(formatRoutingSection(groups));
     } catch (err) {
@@ -3743,7 +4265,7 @@ function runPerModuleStrategy(cwd, config, fileEntries, inputTokenTotal) {
     const modBudget = Math.max(1000, Math.floor(config.maxTokens / moduleNames.length));
     const budgeted = applyTokenBudget(modEntries, modBudget);
 
-    const content = formatOutput(budgeted, cwd, false);
+    const content = formatOutput(budgeted, cwd, false, config, null);
     ensureDir(outPath);
     fs.writeFileSync(outPath, content, 'utf8');
     const modTokens = estimateTokens(content);
@@ -3774,7 +4296,7 @@ function runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTot
 
   // Hot → primary output (auto-injected by IDE)
   const hotContent = hotEntries.length > 0
-    ? formatOutput(hotEntries, cwd, false)
+    ? formatOutput(hotEntries, cwd, false, config, null)
     : '<!-- Generated by SigMap — no recently changed files -->\n';
   const primaryTargets = (config.outputs || ['copilot']).filter((t) => t !== 'claude');
   writeOutputs(hotContent, primaryTargets, cwd);
@@ -3787,7 +4309,7 @@ function runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTot
     '<!-- NOT auto-injected. Retrieve via MCP: read_context({ module: "..." }) -->',
     '',
   ].join('\n');
-  const coldContent = coldHeader + formatOutput(coldEntries, cwd, false);
+  const coldContent = coldHeader + formatOutput(coldEntries, cwd, false, config, null);
   ensureDir(coldPath);
   fs.writeFileSync(coldPath, coldContent, 'utf8');
   const coldTokens = estimateTokens(coldContent);
@@ -3805,11 +4327,11 @@ function runHotColdStrategy(cwd, config, fileEntries, recentFiles, inputTokenTot
 // ---------------------------------------------------------------------------
 // Diff-mode pipeline — context for changed files only
 // ---------------------------------------------------------------------------
-function runDiff(cwd, config, stagedOnly) {
-  const diffFiles = getDiffFiles(cwd, stagedOnly);
+function runDiff(cwd, config, stagedOnly, baseRef) {
+  const diffFiles = baseRef ? getFilesChangedSinceBase(cwd, baseRef) : getDiffFiles(cwd, stagedOnly);
 
   if (diffFiles.size === 0) {
-    const scope = stagedOnly ? 'staged' : 'working tree';
+    const scope = baseRef ? `base ${baseRef}` : (stagedOnly ? 'staged' : 'working tree');
     console.warn(`[sigmap] --diff: no changed files found in ${scope} — running full generate`);
     runGenerate(cwd, config, false);
     return;
@@ -3833,6 +4355,15 @@ function runDiff(cwd, config, stagedOnly) {
 
   let inputTokenTotal = 0;
   let fileEntries = [];
+  let testIndex = null;
+  if (config.testCoverage) {
+    try {
+      const { buildTestIndex } = requireSourceOrBundled('./src/extractors/coverage');
+      testIndex = buildTestIndex(cwd, config.testDirs);
+    } catch (err) {
+      console.warn(`[sigmap] coverage index failed: ${err.message}`);
+    }
+  }
 
   for (const filePath of diffFiltered) {
     let content = '';
@@ -3848,7 +4379,7 @@ function runDiff(cwd, config, stagedOnly) {
     inputTokenTotal += estimateTokens(content);
 
     if (config.secretScan) {
-      const { scan } = __require('./src/security/scanner');
+      const { scan } = requireSourceOrBundled('./src/security/scanner');
       const result = scan(sigs, filePath);
       if (result.redacted) {
         console.warn(`[sigmap] secrets redacted in ${path.relative(cwd, filePath)}`);
@@ -3856,7 +4387,9 @@ function runDiff(cwd, config, stagedOnly) {
       sigs = result.safe;
     }
 
-    fileEntries.push({ filePath, sigs, mtime: Date.now() });
+    sigs = annotateCoverage(sigs, testIndex, !!config.testCoverage);
+
+    fileEntries.push({ filePath, sigs, deps: extractFileDeps(filePath, content, config), content, mtime: Date.now() });
   }
 
   if (fileEntries.length === 0) {
@@ -3866,11 +4399,12 @@ function runDiff(cwd, config, stagedOnly) {
   }
 
   const routingEnabled = !!(config.routing || process.argv.includes('--routing'));
-  const content = formatOutput(fileEntries, cwd, routingEnabled);
+  const diffSection = baseRef ? buildDiffSectionFromBase(cwd, baseRef, fileEntries, config) : [];
+  const content = formatOutput(fileEntries, cwd, routingEnabled, config, { diffSection });
   const finalTokens = estimateTokens(content);
   writeOutputs(content, config.outputs, cwd);
 
-  const scope = stagedOnly ? 'staged' : 'diff';
+  const scope = baseRef ? `diff-vs-${baseRef}` : (stagedOnly ? 'staged' : 'diff');
   console.warn(`[sigmap] ${scope} files: ${fileEntries.length}, diff tokens: ~${finalTokens}`);
 
   if (process.argv.includes('--report')) {
@@ -3904,6 +4438,15 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
 
   let inputTokenTotal = 0;
   let fileEntries = [];
+  let testIndex = null;
+  if (config.testCoverage) {
+    try {
+      const { buildTestIndex } = requireSourceOrBundled('./src/extractors/coverage');
+      testIndex = buildTestIndex(cwd, config.testDirs);
+    } catch (err) {
+      console.warn(`[sigmap] coverage index failed: ${err.message}`);
+    }
+  }
 
   for (const filePath of allFiles) {
     let content = '';
@@ -3920,7 +4463,7 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     inputTokenTotal += estimateTokens(content);
 
     if (config.secretScan) {
-      const { scan } = __require('./src/security/scanner');
+      const { scan } = requireSourceOrBundled('./src/security/scanner');
       const result = scan(sigs, filePath);
       if (result.redacted) {
         console.warn(`[sigmap] secrets redacted in ${path.relative(cwd, filePath)}`);
@@ -3928,6 +4471,8 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
       sigs = result.safe;
     }
 
+    sigs = annotateCoverage(sigs, testIndex, !!config.testCoverage);
+
     let mtime = 0;
     try {
       mtime = fs.statSync(filePath).mtimeMs;
@@ -3936,7 +4481,7 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     // Boost recently committed files (give them max mtime so they aren't dropped first)
     if (recentFiles.has(filePath)) mtime = Date.now();
 
-    fileEntries.push({ filePath, sigs, mtime });
+    fileEntries.push({ filePath, sigs, deps: extractFileDeps(filePath, content, config), content, mtime });
   }
 
   const strategy = config.strategy || 'full';
@@ -3962,7 +4507,7 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
       fileEntries = applyTokenBudget(fileEntries, config.maxTokens);
       const droppedCount = beforeCount - fileEntries.length;
       const routingEnabled = !!(config.routing || process.argv.includes('--routing'));
-      const content = formatOutput(fileEntries, cwd, routingEnabled);
+      const content = formatOutput(fileEntries, cwd, routingEnabled, config, null);
       const finalTokens = estimateTokens(content);
       const formatIdx = process.argv.indexOf('--format');
       const formatValue = formatIdx >= 0 ? process.argv[formatIdx + 1] : (config.format || 'default');
@@ -3974,7 +4519,7 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
     // report mode: always run full pipeline for accurate stats
     const budgeted = applyTokenBudget([...fileEntries], config.maxTokens);
     const droppedCount = beforeCount - budgeted.length;
-    const content = formatOutput(budgeted, cwd, false);
+    const content = formatOutput(budgeted, cwd, false, config, null);
     const finalTokens = estimateTokens(content);
     result = { inputTokenTotal, finalTokens, fileCount: beforeCount, droppedCount };
   }
@@ -3987,7 +4532,7 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
   const trackingEnabled = !!(config.tracking || process.argv.includes('--track'));
   if (trackingEnabled && !reportMode) {
     try {
-      const { logRun } = __require('./src/tracking/logger');
+      const { logRun } = requireSourceOrBundled('./src/tracking/logger');
       logRun({
         version: VERSION,
         fileCount: result.fileCount,
@@ -4009,10 +4554,24 @@ function runGenerate(cwd, config, reportMode, reportJson = false) {
 // Monorepo support
 // ---------------------------------------------------------------------------
 const MONO_ROOTS  = ['packages', 'apps', 'services', 'libs'];
-const PKG_MANIFESTS = ['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'build.gradle', 'pom.xml'];
+const PKG_MANIFESTS = ['package.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'build.gradle', 'pom.xml', 'requirements.txt'];
 
-function detectMonorepoPackages(cwd) {
+function detectMonorepoPackages(cwd, config) {
   const packages = [];
+  const seen = new Set();
+
+  const addIfPackage = (pkgPath) => {
+    if (seen.has(pkgPath)) return;
+    seen.add(pkgPath);
+    for (const manifest of PKG_MANIFESTS) {
+      if (fs.existsSync(path.join(pkgPath, manifest))) {
+        packages.push(pkgPath);
+        return;
+      }
+    }
+  };
+
+  // Strategy 1: classic JS monorepo roots (packages/, apps/, services/, libs/)
   for (const monoDir of MONO_ROOTS) {
     const abs = path.join(cwd, monoDir);
     if (!fs.existsSync(abs)) continue;
@@ -4020,20 +4579,25 @@ function detectMonorepoPackages(cwd) {
     try { entries = fs.readdirSync(abs, { withFileTypes: true }); } catch (_) { continue; }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const pkgPath = path.join(abs, entry.name);
-      for (const manifest of PKG_MANIFESTS) {
-        if (fs.existsSync(path.join(pkgPath, manifest))) {
-          packages.push(pkgPath);
-          break;
-        }
-      }
+      addIfPackage(path.join(abs, entry.name));
+    }
+  }
+
+  // Strategy 2: treat each srcDir that has a manifest as its own package
+  // (covers server/web/desktop-style layouts)
+  if (packages.length === 0 && config && config.srcDirs) {
+    for (const srcDir of config.srcDirs) {
+      const abs = path.join(cwd, srcDir);
+      if (!fs.existsSync(abs)) continue;
+      addIfPackage(abs);
     }
   }
+
   return packages;
 }
 
 function runMonorepo(cwd, config) {
-  const packages = detectMonorepoPackages(cwd);
+  const packages = detectMonorepoPackages(cwd, config);
   if (packages.length === 0) {
     console.warn('[sigmap] no monorepo packages found — checked packages/, apps/, services/, libs/');
     return;
@@ -4131,6 +4695,7 @@ Usage:
   node gen-context.js --health                          Print composite health score
   node gen-context.js --health --json                   Machine-readable health score
   node gen-context.js --diff                            Generate context for git-changed files only
+  node gen-context.js --diff <base-ref>                 Generate context + structural diff vs base ref (e.g. main)
   node gen-context.js --diff --staged                   Generate context for staged files only
   node gen-context.js --init                            Write example config + .contextignore scaffold
   node gen-context.js --help                            Show this message
@@ -4305,7 +4870,10 @@ function main() {
   }
 
   if (args.includes('--diff')) {
-    runDiff(cwd, config, args.includes('--staged'));
+    const idx = args.indexOf('--diff');
+    const maybeBase = args[idx + 1];
+    const baseRef = (maybeBase && !maybeBase.startsWith('--')) ? maybeBase : null;
+    runDiff(cwd, config, args.includes('--staged'), baseRef);
     process.exit(0);
   }