sigmap 1.5.1 → 2.0.0-beta.1

package/src/extractors/python.js

@@ -9,61 +9,177 @@ function extract(src) {
   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 ? ` → ${retType}` : '';
+    const hint = extractDocHint(src, m[2], m[0]);
+    const hintStr = hint ? `  # ${hint}` : '';
+    sigs.push(`${asyncKw}def ${m[2]}(${params})${retStr}${hintStr}`);
   }
 
   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 ? ` → ${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(', ');
 }
 
+function extractDocHint(src, fnName, fnSigLine) {
+  if (!src || !fnName || !fnSigLine) return '';
+  const escSig = fnSigLine.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const re = new RegExp(`^${escSig.replace(/\s+/g, '\\s+')}`, 'm');
+  const pos = src.search(re);
+  if (pos === -1) return '';
+  const afterSig = src.slice(pos + fnSigLine.length, pos + fnSigLine.length + 600);
+
+  // Find first non-empty line after function signature indentation
+  const m = afterSig.match(/^\s*\n\s*(?:[rubfRUBF]{0,2})?("""|''')([\s\S]*?)\1/m);
+  if (!m) return '';
+
+  const firstLine = m[2]
+    .split('\n')
+    .map((l) => l.trim())
+    .find(Boolean);
+  if (!firstLine) return '';
+
+  const sentence = firstLine.split(/[.!?]/)[0].trim();
+  return sentence.slice(0, 60);
+}
+
 module.exports = { extract };

package/src/extractors/ruby.js

@@ -22,14 +22,16 @@ function extract(src) {
     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);
@@ -40,4 +42,13 @@ function normalizeParams(params) {
   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 ? ` → ${type}` : '';
+}
+
 module.exports = { extract };

package/src/extractors/rust.js

@@ -35,10 +35,11 @@ function extract(src) {
     for (const fn of extractMethods(block)) sigs.push(`  ${fn}`);
   }
 
-  // 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);
@@ -57,9 +58,10 @@ function extractBlock(src, startIndex) {
 
 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);
 }
@@ -69,4 +71,12 @@ function normalizeParams(params) {
   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 };

package/src/extractors/scala.js

@@ -25,10 +25,12 @@ function extract(src) {
   }
 
   // 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 ? ` → ${ret}` : '';
+    sigs.push(`def ${m[1]}${params}${retStr}`);
   }
 
   return sigs.slice(0, 25);
@@ -47,10 +49,12 @@ function extractBlock(src, startIndex) {
 
 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 ? ` → ${ret}` : '';
+    members.push(`def ${m[1]}${params}${retStr}`);
   }
   return members.slice(0, 8);
 }
@@ -64,4 +68,9 @@ function normalizeParams(params) {
     .join(', ');
 }
 
+function normalizeType(type) {
+  if (!type) return '';
+  return type.trim().replace(/\s+/g, ' ').slice(0, 25);
+}
+
 module.exports = { extract };

package/src/extractors/svelte.js

@@ -23,16 +23,18 @@ function extract(src) {
   }
 
   // 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] ? ` → ${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] ? ` → ${normalizeType(m[3])}` : '';
+    sigs.push(`${asyncKw}function ${m[1]}(${normalizeParams(m[2])})${retStr}`);
   }
 
   // Reactive declarations $:
@@ -48,4 +50,9 @@ function normalizeParams(params) {
   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 };

package/src/extractors/swift.js

@@ -21,10 +21,11 @@ function extract(src) {
     for (const fn of extractMembers(block)) sigs.push(`  ${fn}`);
   }
 
-  // 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);
@@ -43,10 +44,11 @@ function extractBlock(src, startIndex) {
 
 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);
 }
@@ -60,4 +62,12 @@ function normalizeParams(params) {
     .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 };

package/src/extractors/todos.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+ * Extract TODO/FIXME/HACK/XXX comments from source text.
+ * @param {string} src - Raw file content
+ * @returns {{line:number, tag:string, text:string}[]}
+ */
+function extractTodos(src) {
+  if (!src || typeof src !== 'string') return [];
+  const todos = [];
+  const lines = src.split('\n');
+
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(/(?:\/\/|#)\s*(TODO|FIXME|HACK|XXX)\s*:?\s*(.+)/i);
+    if (!m) continue;
+    todos.push({
+      line: i + 1,
+      tag: m[1].toUpperCase(),
+      text: m[2].trim().slice(0, 70),
+    });
+  }
+
+  return todos;
+}
+
+module.exports = { extractTodos };

package/src/extractors/typescript.js

@@ -50,7 +50,10 @@ function extract(src) {
   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 ? ` → ${retType}` : '';
+    sigs.push(`export ${asyncKw}function ${m[1]}(${params})${retStr}`);
   }
 
   // Exported arrow functions / const functions
@@ -58,6 +61,25 @@ function extract(src) {
     const asyncKw = /=\s*async\s+/.test(m[0]) ? 'async ' : '';
     const params = normalizeParams(m[2]);
     sigs.push(`export const ${m[1]} = ${asyncKw}(${params}) =>`);
+
+    // Hooks: capture compact return object shape for use* functions.
+    if (m[1].startsWith('use')) {
+      const bodyStart = stripped.indexOf('{', m.index + m[0].length);
+      if (bodyStart !== -1) {
+        const body = stripped.slice(bodyStart, bodyStart + 800);
+        const ret = body.match(/return\s*\{([^}]{1,260})\}/);
+        if (ret) {
+          const keys = ret[1]
+            .split(',')
+            .map((s) => s.trim().split(':')[0].split('(')[0].trim())
+            .filter(Boolean)
+            .slice(0, 8);
+          if (keys.length) {
+            sigs[sigs.length - 1] += ` → { ${keys.join(', ')} }`;
+          }
+        }
+      }
+    }
   }
 
   return sigs.slice(0, 25);
@@ -77,9 +99,11 @@ function extractBlock(src, startIndex) {
 
 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])})`);
@@ -96,7 +120,10 @@ function extractClassMembers(block) {
     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 ? ` → ${retType}` : '';
+    members.push(`${isStatic}${isAsync}${m[1]}(${normalizeParams(m[2])})${retStr}`);
   }
   return members.slice(0, 8);
 }

package/src/extractors/vue.js

@@ -34,13 +34,22 @@ function extract(src) {
   // 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] ? ` → ${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] ? ` → ${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*\)/);
   if (definePropsMatch) {
@@ -63,4 +72,9 @@ function normalizeParams(params) {
   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 };

package/src/mcp/server.js

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