minovative-mind-cli 2.9.1 → 2.11.0

package/dist/utils/symbolExtractor.js

@@ -369,3 +369,949 @@ export function extractSymbols(content, filePath, targetElements) {
     }
     return output.join('\n');
 }
+/**
+ * Extracts a compact declarations outline for TypeScript/JavaScript source files.
+ *
+ * @param lines - File lines
+ * @returns Declarations outline
+ */
+function extractTsJsOutline(lines) {
+    const output = [];
+    let docBuffer = [];
+    let i = 0;
+    const isDocOrDecorator = (line) => {
+        const trimmed = line.trim();
+        return (trimmed.startsWith('/**') ||
+            trimmed.startsWith('*') ||
+            trimmed.startsWith('*/') ||
+            trimmed.startsWith('//') ||
+            trimmed.startsWith('@'));
+    };
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (docBuffer.length > 0 && docBuffer.every((l) => l.trim().startsWith('//') || l.trim().startsWith('/*'))) {
+                docBuffer = [];
+            }
+            i++;
+            continue;
+        }
+        if (isDocOrDecorator(line)) {
+            docBuffer.push(line);
+            i++;
+            continue;
+        }
+        // Check for interface
+        if (/^(?:export\s+|declare\s+|default\s+)*interface\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            let braces = 0;
+            let foundOpen = false;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '{') {
+                        braces++;
+                        foundOpen = true;
+                    }
+                    else if (ch === '}') {
+                        braces--;
+                    }
+                }
+                output.push(lines[i]);
+                i++;
+                if (foundOpen && braces <= 0)
+                    break;
+            }
+            output.push('');
+            continue;
+        }
+        // Check for type alias
+        if (/^(?:export\s+|declare\s+)*type\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            let braces = 0;
+            let parens = 0;
+            let brackets = 0;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '{')
+                        braces++;
+                    else if (ch === '}')
+                        braces--;
+                    else if (ch === '(')
+                        parens++;
+                    else if (ch === ')')
+                        parens--;
+                    else if (ch === '[')
+                        brackets++;
+                    else if (ch === ']')
+                        brackets--;
+                }
+                output.push(lines[i]);
+                if (braces <= 0 && parens <= 0 && brackets <= 0 && lines[i].includes(';')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            output.push('');
+            continue;
+        }
+        // Check for enum
+        if (/^(?:export\s+|const\s+|declare\s+)*enum\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            let braces = 0;
+            let foundOpen = false;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '{') {
+                        braces++;
+                        foundOpen = true;
+                    }
+                    else if (ch === '}') {
+                        braces--;
+                    }
+                }
+                output.push(lines[i]);
+                i++;
+                if (foundOpen && braces <= 0)
+                    break;
+            }
+            output.push('');
+            continue;
+        }
+        // Check for class
+        if (/^(?:export\s+|default\s+|abstract\s+|declare\s+)*class\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const classHeaderLines = [];
+            while (i < lines.length) {
+                classHeaderLines.push(lines[i]);
+                if (lines[i].includes('{')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            output.push(classHeaderLines.join('\n'));
+            let classBraces = 1;
+            let memberDoc = [];
+            while (i < lines.length && classBraces > 0) {
+                const curLine = lines[i];
+                const curTrim = curLine.trim();
+                if (!curTrim) {
+                    memberDoc = [];
+                    i++;
+                    continue;
+                }
+                if (isDocOrDecorator(curLine)) {
+                    memberDoc.push(curLine);
+                    i++;
+                    continue;
+                }
+                if (curTrim === '}' && classBraces === 1) {
+                    output.push(curLine);
+                    i++;
+                    break;
+                }
+                const isMethodOrCtor = /^(?:public\s+|private\s+|protected\s+|static\s+|async\s+|abstract\s+|override\s+|readonly\s+|get\s+|set\s+)*(?:constructor|[A-Za-z0-9_$]+)\s*(?:<[^>]+>)?\s*\(/.test(curTrim);
+                const isField = /^(?:public\s+|private\s+|protected\s+|static\s+|readonly\s+|declare\s+)*(?:[A-Za-z0-9_$#]+)\s*[:=;]/.test(curTrim);
+                if (isMethodOrCtor) {
+                    if (memberDoc.length > 0) {
+                        output.push(...memberDoc);
+                        memberDoc = [];
+                    }
+                    const sigLines = [];
+                    let methodHasBody = false;
+                    let methodBraces = 0;
+                    while (i < lines.length) {
+                        const mLine = lines[i];
+                        sigLines.push(mLine);
+                        if (mLine.includes('{')) {
+                            methodHasBody = true;
+                            methodBraces = 1;
+                            i++;
+                            break;
+                        }
+                        if (mLine.trim().endsWith(';')) {
+                            i++;
+                            break;
+                        }
+                        i++;
+                    }
+                    if (methodHasBody) {
+                        const sig = sigLines.join('\n');
+                        const braceIdx = sig.lastIndexOf('{');
+                        const cleanSig = sig.substring(0, braceIdx).trimEnd();
+                        output.push(cleanSig + ' { ... }');
+                        while (i < lines.length && methodBraces > 0) {
+                            for (const ch of lines[i]) {
+                                if (ch === '{')
+                                    methodBraces++;
+                                else if (ch === '}')
+                                    methodBraces--;
+                            }
+                            i++;
+                        }
+                    }
+                    else {
+                        output.push(sigLines.join('\n'));
+                    }
+                    continue;
+                }
+                else if (isField) {
+                    if (memberDoc.length > 0) {
+                        output.push(...memberDoc);
+                        memberDoc = [];
+                    }
+                    output.push(curLine);
+                    i++;
+                    continue;
+                }
+                else {
+                    for (const ch of curLine) {
+                        if (ch === '{')
+                            classBraces++;
+                        else if (ch === '}')
+                            classBraces--;
+                    }
+                    if (classBraces === 0) {
+                        output.push(curLine);
+                    }
+                    i++;
+                }
+            }
+            output.push('');
+            continue;
+        }
+        // Check for top-level function
+        if (/^(?:export\s+|default\s+|async\s+|declare\s+)*function(?:\s*\*|\s+\w+)/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const sigLines = [];
+            let fnBraces = 0;
+            let hasBody = false;
+            while (i < lines.length) {
+                const fLine = lines[i];
+                sigLines.push(fLine);
+                if (fLine.includes('{')) {
+                    hasBody = true;
+                    fnBraces = 1;
+                    i++;
+                    break;
+                }
+                if (fLine.trim().endsWith(';')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            if (hasBody) {
+                const sig = sigLines.join('\n');
+                const braceIdx = sig.lastIndexOf('{');
+                const cleanSig = sig.substring(0, braceIdx).trimEnd();
+                output.push(cleanSig + ' { ... }');
+                while (i < lines.length && fnBraces > 0) {
+                    for (const ch of lines[i]) {
+                        if (ch === '{')
+                            fnBraces++;
+                        else if (ch === '}')
+                            fnBraces--;
+                    }
+                    i++;
+                }
+            }
+            else {
+                output.push(sigLines.join('\n'));
+            }
+            output.push('');
+            continue;
+        }
+        // Check for const / let / var function or export
+        if (/^(?:export\s+)?(?:const|let|var)\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            if (trimmed.includes('=>') && trimmed.includes('{')) {
+                const sigLines = [];
+                let arrowBraces = 0;
+                while (i < lines.length) {
+                    const aLine = lines[i];
+                    sigLines.push(aLine);
+                    if (aLine.includes('{')) {
+                        arrowBraces = 1;
+                        i++;
+                        break;
+                    }
+                    i++;
+                }
+                const sig = sigLines.join('\n');
+                const braceIdx = sig.lastIndexOf('{');
+                output.push(sig.substring(0, braceIdx).trimEnd() + ' { ... };');
+                while (i < lines.length && arrowBraces > 0) {
+                    for (const ch of lines[i]) {
+                        if (ch === '{')
+                            arrowBraces++;
+                        else if (ch === '}')
+                            arrowBraces--;
+                    }
+                    i++;
+                }
+                output.push('');
+                continue;
+            }
+            else if (trimmed.includes('=>')) {
+                output.push(line);
+                i++;
+                continue;
+            }
+            else {
+                output.push(line);
+                i++;
+                continue;
+            }
+        }
+        docBuffer = [];
+        i++;
+    }
+    return output.join('\n').trim();
+}
+/**
+ * Extracts a compact declarations outline for Python source files.
+ *
+ * @param lines - File lines
+ * @returns Declarations outline
+ */
+function extractPythonOutline(lines) {
+    const output = [];
+    let docBuffer = [];
+    let i = 0;
+    const isDocOrDecorator = (line) => {
+        const trimmed = line.trim();
+        return trimmed.startsWith('#') || trimmed.startsWith('@');
+    };
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (docBuffer.length > 0 && docBuffer.every((l) => l.trim().startsWith('#'))) {
+                docBuffer = [];
+            }
+            i++;
+            continue;
+        }
+        if (isDocOrDecorator(line)) {
+            docBuffer.push(line);
+            i++;
+            continue;
+        }
+        // Class definition
+        if (/^class\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const classBaseIndent = getIndentation(line);
+            const classHeaderLines = [];
+            while (i < lines.length) {
+                classHeaderLines.push(lines[i]);
+                if (lines[i].trim().endsWith(':') || lines[i].includes(':')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            output.push(classHeaderLines.join('\n'));
+            let methodDoc = [];
+            let inClassDocstring = false;
+            let docstringChar = null;
+            while (i < lines.length) {
+                const cLine = lines[i];
+                const cTrim = cLine.trim();
+                const cIndent = getIndentation(cLine);
+                if (!cTrim) {
+                    i++;
+                    continue;
+                }
+                if (cIndent <= classBaseIndent && !inClassDocstring) {
+                    break;
+                }
+                if (inClassDocstring) {
+                    output.push(cLine);
+                    if (docstringChar && (cTrim.endsWith(docstringChar) || cTrim.includes(docstringChar))) {
+                        inClassDocstring = false;
+                    }
+                    i++;
+                    continue;
+                }
+                if (cTrim.startsWith('"""') || cTrim.startsWith("'''")) {
+                    const delim = cTrim.startsWith('"""') ? '"""' : "'''";
+                    output.push(cLine);
+                    if (cTrim.length > 3 && cTrim.endsWith(delim) && cTrim.indexOf(delim, 3) !== -1) {
+                        // single line docstring
+                    }
+                    else {
+                        inClassDocstring = true;
+                        docstringChar = delim;
+                    }
+                    i++;
+                    continue;
+                }
+                if (isDocOrDecorator(cLine)) {
+                    methodDoc.push(cLine);
+                    i++;
+                    continue;
+                }
+                if (/^(?:async\s+)?def\s+\w+/.test(cTrim)) {
+                    if (methodDoc.length > 0) {
+                        output.push(...methodDoc);
+                        methodDoc = [];
+                    }
+                    const methodIndent = cIndent;
+                    const methodSigLines = [];
+                    while (i < lines.length) {
+                        methodSigLines.push(lines[i]);
+                        if (lines[i].trim().endsWith(':') || lines[i].includes(':')) {
+                            i++;
+                            break;
+                        }
+                        i++;
+                    }
+                    output.push(methodSigLines.join('\n'));
+                    const pad = ' '.repeat(methodIndent + 4);
+                    output.push(`${pad}...`);
+                    while (i < lines.length) {
+                        const bLine = lines[i];
+                        const bTrim = bLine.trim();
+                        const bIndent = getIndentation(bLine);
+                        if (!bTrim) {
+                            i++;
+                            continue;
+                        }
+                        if (bIndent <= methodIndent)
+                            break;
+                        i++;
+                    }
+                    continue;
+                }
+                if (cTrim.includes(':') || cTrim.includes('=')) {
+                    if (methodDoc.length > 0) {
+                        output.push(...methodDoc);
+                        methodDoc = [];
+                    }
+                    output.push(cLine);
+                    i++;
+                    continue;
+                }
+                methodDoc = [];
+                i++;
+            }
+            output.push('');
+            continue;
+        }
+        // Top-level function
+        if (/^(?:async\s+)?def\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const fnIndent = getIndentation(line);
+            const fnSigLines = [];
+            while (i < lines.length) {
+                fnSigLines.push(lines[i]);
+                if (lines[i].trim().endsWith(':') || lines[i].includes(':')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            output.push(fnSigLines.join('\n'));
+            const pad = ' '.repeat(fnIndent + 4);
+            output.push(`${pad}...`);
+            while (i < lines.length) {
+                const bLine = lines[i];
+                const bTrim = bLine.trim();
+                const bIndent = getIndentation(bLine);
+                if (!bTrim) {
+                    i++;
+                    continue;
+                }
+                if (bIndent <= fnIndent)
+                    break;
+                i++;
+            }
+            output.push('');
+            continue;
+        }
+        // Global variable / type alias
+        if (trimmed.includes(':') || trimmed.includes('=')) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            output.push(line);
+            i++;
+            continue;
+        }
+        docBuffer = [];
+        i++;
+    }
+    return output.join('\n').trim();
+}
+/**
+ * Extracts a compact declarations outline for Go source files.
+ *
+ * @param lines - File lines
+ * @returns Declarations outline
+ */
+function extractGoOutline(lines) {
+    const output = [];
+    let docBuffer = [];
+    let i = 0;
+    const isComment = (line) => {
+        const trimmed = line.trim();
+        return trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*');
+    };
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            docBuffer = [];
+            i++;
+            continue;
+        }
+        if (isComment(line)) {
+            docBuffer.push(line);
+            i++;
+            continue;
+        }
+        // Package statement
+        if (/^package\s+\w+/.test(trimmed)) {
+            output.push(line);
+            output.push('');
+            docBuffer = [];
+            i++;
+            continue;
+        }
+        // Type definition (struct, interface, alias)
+        if (/^type\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            let braces = 0;
+            let parens = 0;
+            let foundBlock = false;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '{') {
+                        braces++;
+                        foundBlock = true;
+                    }
+                    else if (ch === '}') {
+                        braces--;
+                    }
+                    else if (ch === '(') {
+                        parens++;
+                        foundBlock = true;
+                    }
+                    else if (ch === ')') {
+                        parens--;
+                    }
+                }
+                output.push(lines[i]);
+                i++;
+                if (foundBlock && braces <= 0 && parens <= 0)
+                    break;
+                if (!foundBlock && (lines[i - 1].trim().endsWith(';') || !lines[i - 1].includes('{')))
+                    break;
+            }
+            output.push('');
+            continue;
+        }
+        // Const / Var blocks
+        if (/^(?:const|var)\s*(?:\(|$)/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            let parens = 0;
+            let foundParen = false;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '(') {
+                        parens++;
+                        foundParen = true;
+                    }
+                    else if (ch === ')') {
+                        parens--;
+                    }
+                }
+                output.push(lines[i]);
+                i++;
+                if (foundParen && parens <= 0)
+                    break;
+                if (!foundParen)
+                    break;
+            }
+            output.push('');
+            continue;
+        }
+        // Single-line const / var
+        if (/^(?:const|var)\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            output.push(line);
+            output.push('');
+            i++;
+            continue;
+        }
+        // Function or Method
+        if (/^func\s+(?:\([^)]+\)\s+)?\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const sigLines = [];
+            let fnBraces = 0;
+            let hasBody = false;
+            while (i < lines.length) {
+                const fLine = lines[i];
+                sigLines.push(fLine);
+                if (fLine.includes('{')) {
+                    hasBody = true;
+                    fnBraces = 1;
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            if (hasBody) {
+                const sig = sigLines.join('\n');
+                const braceIdx = sig.lastIndexOf('{');
+                const cleanSig = sig.substring(0, braceIdx).trimEnd();
+                output.push(cleanSig + ' { ... }');
+                while (i < lines.length && fnBraces > 0) {
+                    for (const ch of lines[i]) {
+                        if (ch === '{')
+                            fnBraces++;
+                        else if (ch === '}')
+                            fnBraces--;
+                    }
+                    i++;
+                }
+            }
+            else {
+                output.push(sigLines.join('\n'));
+            }
+            output.push('');
+            continue;
+        }
+        docBuffer = [];
+        i++;
+    }
+    return output.join('\n').trim();
+}
+/**
+ * Extracts a compact declarations outline for Rust source files.
+ *
+ * @param lines - File lines
+ * @returns Declarations outline
+ */
+function extractRustOutline(lines) {
+    const output = [];
+    let docBuffer = [];
+    let i = 0;
+    const isDocOrAttr = (line) => {
+        const trimmed = line.trim();
+        return (trimmed.startsWith('///') ||
+            trimmed.startsWith('//!') ||
+            trimmed.startsWith('//') ||
+            trimmed.startsWith('/*') ||
+            trimmed.startsWith('*') ||
+            trimmed.startsWith('#['));
+    };
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            if (docBuffer.length > 0 && docBuffer.every((l) => l.trim().startsWith('//'))) {
+                docBuffer = [];
+            }
+            i++;
+            continue;
+        }
+        if (isDocOrAttr(line)) {
+            docBuffer.push(line);
+            i++;
+            continue;
+        }
+        // Struct, Enum, Trait
+        if (/^(?:pub(?:\([^)]+\))?\s+)?(?:struct|enum|trait)\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            if (trimmed.endsWith(';')) {
+                output.push(line);
+                output.push('');
+                i++;
+                continue;
+            }
+            let braces = 0;
+            let foundOpen = false;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '{') {
+                        braces++;
+                        foundOpen = true;
+                    }
+                    else if (ch === '}') {
+                        braces--;
+                    }
+                }
+                output.push(lines[i]);
+                i++;
+                if (foundOpen && braces <= 0)
+                    break;
+                if (!foundOpen && lines[i - 1].trim().endsWith(';'))
+                    break;
+            }
+            output.push('');
+            continue;
+        }
+        // Type alias or Const / Static
+        if (/^(?:pub(?:\([^)]+\))?\s+)?(?:type|const|static)\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            let braces = 0;
+            let parens = 0;
+            while (i < lines.length) {
+                for (const ch of lines[i]) {
+                    if (ch === '{')
+                        braces++;
+                    else if (ch === '}')
+                        braces--;
+                    else if (ch === '(')
+                        parens++;
+                    else if (ch === ')')
+                        parens--;
+                }
+                output.push(lines[i]);
+                if (braces <= 0 && parens <= 0 && lines[i].includes(';')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            output.push('');
+            continue;
+        }
+        // Impl block
+        if (/^(?:pub(?:\([^)]+\))?\s+)?impl(?:\s+<[^>]+>)?\s+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const implHeaderLines = [];
+            while (i < lines.length) {
+                implHeaderLines.push(lines[i]);
+                if (lines[i].includes('{')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            output.push(implHeaderLines.join('\n'));
+            let implBraces = 1;
+            let memberDoc = [];
+            while (i < lines.length && implBraces > 0) {
+                const curLine = lines[i];
+                const curTrim = curLine.trim();
+                if (!curTrim) {
+                    memberDoc = [];
+                    i++;
+                    continue;
+                }
+                if (isDocOrAttr(curLine)) {
+                    memberDoc.push(curLine);
+                    i++;
+                    continue;
+                }
+                if (curTrim === '}' && implBraces === 1) {
+                    output.push(curLine);
+                    i++;
+                    break;
+                }
+                if (/^(?:pub(?:\([^)]+\))?\s+)?(?:async\s+|const\s+|unsafe\s+|extern\s+)*fn\s+\w+/.test(curTrim)) {
+                    if (memberDoc.length > 0) {
+                        output.push(...memberDoc);
+                        memberDoc = [];
+                    }
+                    const sigLines = [];
+                    let fnBraces = 0;
+                    let hasBody = false;
+                    while (i < lines.length) {
+                        const fLine = lines[i];
+                        sigLines.push(fLine);
+                        if (fLine.includes('{')) {
+                            hasBody = true;
+                            fnBraces = 1;
+                            i++;
+                            break;
+                        }
+                        if (fLine.trim().endsWith(';')) {
+                            i++;
+                            break;
+                        }
+                        i++;
+                    }
+                    if (hasBody) {
+                        const sig = sigLines.join('\n');
+                        const braceIdx = sig.lastIndexOf('{');
+                        const cleanSig = sig.substring(0, braceIdx).trimEnd();
+                        output.push(cleanSig + ' { ... }');
+                        while (i < lines.length && fnBraces > 0) {
+                            for (const ch of lines[i]) {
+                                if (ch === '{')
+                                    fnBraces++;
+                                else if (ch === '}')
+                                    fnBraces--;
+                            }
+                            i++;
+                        }
+                    }
+                    else {
+                        output.push(sigLines.join('\n'));
+                    }
+                    continue;
+                }
+                else if (/^(?:pub(?:\([^)]+\))?\s+)?(?:type|const)\s+\w+/.test(curTrim)) {
+                    if (memberDoc.length > 0) {
+                        output.push(...memberDoc);
+                        memberDoc = [];
+                    }
+                    output.push(curLine);
+                    i++;
+                    continue;
+                }
+                else {
+                    for (const ch of curLine) {
+                        if (ch === '{')
+                            implBraces++;
+                        else if (ch === '}')
+                            implBraces--;
+                    }
+                    if (implBraces === 0) {
+                        output.push(curLine);
+                    }
+                    i++;
+                }
+            }
+            output.push('');
+            continue;
+        }
+        // Free fn
+        if (/^(?:pub(?:\([^)]+\))?\s+)?(?:async\s+|const\s+|unsafe\s+|extern\s+)*fn\s+\w+/.test(trimmed)) {
+            if (docBuffer.length > 0) {
+                output.push(...docBuffer);
+                docBuffer = [];
+            }
+            const sigLines = [];
+            let fnBraces = 0;
+            let hasBody = false;
+            while (i < lines.length) {
+                const fLine = lines[i];
+                sigLines.push(fLine);
+                if (fLine.includes('{')) {
+                    hasBody = true;
+                    fnBraces = 1;
+                    i++;
+                    break;
+                }
+                if (fLine.trim().endsWith(';')) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            if (hasBody) {
+                const sig = sigLines.join('\n');
+                const braceIdx = sig.lastIndexOf('{');
+                const cleanSig = sig.substring(0, braceIdx).trimEnd();
+                output.push(cleanSig + ' { ... }');
+                while (i < lines.length && fnBraces > 0) {
+                    for (const ch of lines[i]) {
+                        if (ch === '{')
+                            fnBraces++;
+                        else if (ch === '}')
+                            fnBraces--;
+                    }
+                    i++;
+                }
+            }
+            else {
+                output.push(sigLines.join('\n'));
+            }
+            output.push('');
+            continue;
+        }
+        docBuffer = [];
+        i++;
+    }
+    return output.join('\n').trim();
+}
+/**
+ * Extracts a compact declarations outline (type/interface definitions, class skeletons,
+ * and function signatures without full implementation bodies) across TypeScript/JavaScript,
+ * Python, Go, and Rust.
+ *
+ * This dramatically reduces token usage when injecting multi-file context into prompts.
+ *
+ * @param content - Raw source code content
+ * @param filePath - File path used to infer language and syntax rules
+ * @returns Compact declarations outline string
+ */
+export function extractDeclarationsOutline(content, filePath) {
+    if (!content || !content.trim())
+        return '';
+    const ext = path.extname(filePath).toLowerCase();
+    const lines = content.split('\n');
+    switch (ext) {
+        case '.ts':
+        case '.tsx':
+        case '.js':
+        case '.jsx':
+        case '.mjs':
+        case '.cjs':
+        case '.mts':
+        case '.cts':
+            return extractTsJsOutline(lines);
+        case '.py':
+        case '.pyi':
+            return extractPythonOutline(lines);
+        case '.go':
+            return extractGoOutline(lines);
+        case '.rs':
+            return extractRustOutline(lines);
+        default:
+            return content.trim();
+    }
+}