@renseiai/agentfactory-code-intelligence 0.8.4

package/dist/src/parser/go-extractor.js

@@ -0,0 +1,127 @@
+/** Regex-based Go symbol extractor. */
+export class GoExtractor {
+    languages = ['go'];
+    extract(source, filePath) {
+        const lines = source.split('\n');
+        const symbols = [];
+        const imports = [];
+        const exports = [];
+        let currentComment;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Skip comments, but track for documentation
+            if (trimmed.startsWith('//')) {
+                currentComment = (currentComment ? currentComment + '\n' : '') + trimmed.slice(2).trim();
+                continue;
+            }
+            // Imports
+            const importMatch = trimmed.match(/^import\s+"([^"]+)"/);
+            if (importMatch) {
+                imports.push(importMatch[1]);
+                continue;
+            }
+            // Multi-line import
+            if (trimmed === 'import (') {
+                for (let j = i + 1; j < lines.length; j++) {
+                    const importLine = lines[j].trim();
+                    if (importLine === ')')
+                        break;
+                    const pkg = importLine.match(/"([^"]+)"/);
+                    if (pkg)
+                        imports.push(pkg[1]);
+                }
+                continue;
+            }
+            // Function declarations (with optional receiver)
+            const funcMatch = trimmed.match(/^func\s+(?:\((\w+)\s+\*?(\w+)\)\s+)?(\w+)\s*\(/);
+            if (funcMatch) {
+                const receiverVar = funcMatch[1];
+                const receiverType = funcMatch[2];
+                const name = funcMatch[3];
+                const isExported = name[0] === name[0].toUpperCase() && name[0] !== name[0].toLowerCase();
+                symbols.push({
+                    name,
+                    kind: receiverType ? 'method' : 'function',
+                    filePath, line: i,
+                    exported: isExported,
+                    signature: trimmed.split('{')[0].trim(),
+                    documentation: currentComment,
+                    language: 'go',
+                    ...(receiverType ? { parentName: receiverType } : {}),
+                });
+                if (isExported)
+                    exports.push(name);
+                currentComment = undefined;
+                continue;
+            }
+            // Struct declaration
+            const structMatch = trimmed.match(/^type\s+(\w+)\s+struct\b/);
+            if (structMatch) {
+                const name = structMatch[1];
+                const isExported = name[0] === name[0].toUpperCase();
+                symbols.push({
+                    name, kind: 'struct', filePath, line: i,
+                    exported: isExported,
+                    documentation: currentComment,
+                    language: 'go',
+                });
+                if (isExported)
+                    exports.push(name);
+                currentComment = undefined;
+                continue;
+            }
+            // Interface declaration
+            const ifaceMatch = trimmed.match(/^type\s+(\w+)\s+interface\b/);
+            if (ifaceMatch) {
+                const name = ifaceMatch[1];
+                const isExported = name[0] === name[0].toUpperCase();
+                symbols.push({
+                    name, kind: 'interface', filePath, line: i,
+                    exported: isExported,
+                    documentation: currentComment,
+                    language: 'go',
+                });
+                if (isExported)
+                    exports.push(name);
+                currentComment = undefined;
+                continue;
+            }
+            // Type alias
+            const typeMatch = trimmed.match(/^type\s+(\w+)\s+(?!struct|interface)/);
+            if (typeMatch) {
+                const name = typeMatch[1];
+                const isExported = name[0] === name[0].toUpperCase();
+                symbols.push({
+                    name, kind: 'type', filePath, line: i,
+                    exported: isExported,
+                    language: 'go',
+                });
+                if (isExported)
+                    exports.push(name);
+                currentComment = undefined;
+                continue;
+            }
+            // Variable/constant
+            const varMatch = trimmed.match(/^(?:var|const)\s+(\w+)/);
+            if (varMatch) {
+                const name = varMatch[1];
+                const isExported = name[0] === name[0].toUpperCase();
+                symbols.push({
+                    name, kind: 'variable', filePath, line: i,
+                    exported: isExported,
+                    language: 'go',
+                });
+                if (isExported)
+                    exports.push(name);
+                currentComment = undefined;
+                continue;
+            }
+            // Clear comment if line is not empty and not a comment
+            if (trimmed.length > 0) {
+                currentComment = undefined;
+            }
+        }
+        return { filePath, language: 'go', symbols, imports, exports };
+    }
+}

package/dist/src/parser/python-extractor.d.ts

@@ -0,0 +1,8 @@
+import type { FileAST } from '../types.js';
+import type { LanguageExtractor } from './symbol-extractor.js';
+/** Regex-based Python symbol extractor. */
+export declare class PythonExtractor implements LanguageExtractor {
+    languages: string[];
+    extract(source: string, filePath: string): FileAST;
+}
+//# sourceMappingURL=python-extractor.d.ts.map

package/dist/src/parser/python-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"python-extractor.d.ts","sourceRoot":"","sources":["../../../src/parser/python-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,OAAO,EAAc,MAAM,aAAa,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D,2CAA2C;AAC3C,qBAAa,eAAgB,YAAW,iBAAiB;IACvD,SAAS,WAAa;IAEtB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;CA+FnD"}

package/dist/src/parser/python-extractor.js

@@ -0,0 +1,92 @@
+/** Regex-based Python symbol extractor. */
+export class PythonExtractor {
+    languages = ['python'];
+    extract(source, filePath) {
+        const lines = source.split('\n');
+        const symbols = [];
+        const imports = [];
+        const exports = [];
+        let currentDocstring;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Skip comments
+            if (trimmed.startsWith('#'))
+                continue;
+            // Docstrings (single-line)
+            if (trimmed.startsWith('"""') || trimmed.startsWith("'''")) {
+                if (trimmed.slice(3).includes(trimmed.slice(0, 3))) {
+                    currentDocstring = trimmed.slice(3, trimmed.lastIndexOf(trimmed.slice(0, 3)));
+                }
+                continue;
+            }
+            // Imports
+            const importMatch = trimmed.match(/^(?:from\s+(\S+)\s+)?import\s+(.+)/);
+            if (importMatch) {
+                const module = importMatch[1] ?? importMatch[2].split(',')[0].trim().split(/\s+as\s+/)[0];
+                imports.push(module);
+                continue;
+            }
+            // Decorators
+            const decoratorMatch = trimmed.match(/^@(\w+)/);
+            if (decoratorMatch) {
+                symbols.push({
+                    name: decoratorMatch[1], kind: 'decorator', filePath, line: i,
+                    exported: false, language: 'python',
+                });
+                continue;
+            }
+            // Function definitions
+            const funcMatch = trimmed.match(/^(?:async\s+)?def\s+(\w+)\s*\(/);
+            if (funcMatch) {
+                const name = funcMatch[1];
+                const indent = line.length - line.trimStart().length;
+                const isMethod = indent > 0;
+                const exported = !name.startsWith('_');
+                symbols.push({
+                    name,
+                    kind: isMethod ? 'method' : 'function',
+                    filePath, line: i,
+                    exported,
+                    signature: trimmed.split(':')[0],
+                    documentation: currentDocstring,
+                    language: 'python',
+                });
+                if (exported && !isMethod)
+                    exports.push(name);
+                currentDocstring = undefined;
+                continue;
+            }
+            // Class definitions
+            const classMatch = trimmed.match(/^class\s+(\w+)/);
+            if (classMatch) {
+                const name = classMatch[1];
+                const exported = !name.startsWith('_');
+                symbols.push({
+                    name, kind: 'class', filePath, line: i,
+                    exported,
+                    signature: trimmed.split(':')[0],
+                    documentation: currentDocstring,
+                    language: 'python',
+                });
+                if (exported)
+                    exports.push(name);
+                currentDocstring = undefined;
+                continue;
+            }
+            // Module-level variable assignment
+            const varMatch = trimmed.match(/^(\w+)\s*(?::\s*\w[^=]*)?\s*=/);
+            if (varMatch && line.length - line.trimStart().length === 0) {
+                const name = varMatch[1];
+                const exported = !name.startsWith('_') && name === name.toUpperCase() || !name.startsWith('_');
+                symbols.push({
+                    name, kind: 'variable', filePath, line: i,
+                    exported: !name.startsWith('_'),
+                    language: 'python',
+                });
+                continue;
+            }
+        }
+        return { filePath, language: 'python', symbols, imports, exports };
+    }
+}

package/dist/src/parser/rust-extractor.d.ts

@@ -0,0 +1,8 @@
+import type { FileAST } from '../types.js';
+import type { LanguageExtractor } from './symbol-extractor.js';
+/** Regex-based Rust symbol extractor. */
+export declare class RustExtractor implements LanguageExtractor {
+    languages: string[];
+    extract(source: string, filePath: string): FileAST;
+}
+//# sourceMappingURL=rust-extractor.d.ts.map

package/dist/src/parser/rust-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rust-extractor.d.ts","sourceRoot":"","sources":["../../../src/parser/rust-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,OAAO,EAAc,MAAM,aAAa,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D,yCAAyC;AACzC,qBAAa,aAAc,YAAW,iBAAiB;IACrD,SAAS,WAAW;IAEpB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;CA4KnD"}

package/dist/src/parser/rust-extractor.js

@@ -0,0 +1,168 @@
+/** Regex-based Rust symbol extractor. */
+export class RustExtractor {
+    languages = ['rust'];
+    extract(source, filePath) {
+        const lines = source.split('\n');
+        const symbols = [];
+        const imports = [];
+        const exports = [];
+        let currentDoc;
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const trimmed = line.trim();
+            // Doc comments
+            if (trimmed.startsWith('///')) {
+                currentDoc = (currentDoc ? currentDoc + '\n' : '') + trimmed.slice(3).trim();
+                continue;
+            }
+            // Regular comments
+            if (trimmed.startsWith('//'))
+                continue;
+            // Use statements (imports)
+            const useMatch = trimmed.match(/^(?:pub\s+)?use\s+(.+);/);
+            if (useMatch) {
+                imports.push(useMatch[1]);
+                continue;
+            }
+            const isPublic = trimmed.startsWith('pub ');
+            const effective = isPublic ? trimmed.replace(/^pub\s+(?:\(crate\)\s+)?/, '') : trimmed;
+            // Function declarations
+            const fnMatch = effective.match(/^(?:async\s+)?(?:unsafe\s+)?fn\s+(\w+)/);
+            if (fnMatch) {
+                const name = fnMatch[1];
+                symbols.push({
+                    name, kind: 'function', filePath, line: i,
+                    exported: isPublic,
+                    signature: effective.split('{')[0].trim(),
+                    documentation: currentDoc,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Struct declarations
+            const structMatch = effective.match(/^struct\s+(\w+)/);
+            if (structMatch) {
+                const name = structMatch[1];
+                symbols.push({
+                    name, kind: 'struct', filePath, line: i,
+                    exported: isPublic,
+                    documentation: currentDoc,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Enum declarations
+            const enumMatch = effective.match(/^enum\s+(\w+)/);
+            if (enumMatch) {
+                const name = enumMatch[1];
+                symbols.push({
+                    name, kind: 'enum', filePath, line: i,
+                    exported: isPublic,
+                    documentation: currentDoc,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Trait declarations
+            const traitMatch = effective.match(/^trait\s+(\w+)/);
+            if (traitMatch) {
+                const name = traitMatch[1];
+                symbols.push({
+                    name, kind: 'trait', filePath, line: i,
+                    exported: isPublic,
+                    documentation: currentDoc,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Impl blocks
+            const implMatch = effective.match(/^impl(?:<[^>]+>)?\s+(?:(\w+)\s+for\s+)?(\w+)/);
+            if (implMatch) {
+                const traitName = implMatch[1];
+                const typeName = implMatch[2];
+                const name = traitName ? `${traitName} for ${typeName}` : typeName;
+                symbols.push({
+                    name, kind: 'impl', filePath, line: i,
+                    exported: false,
+                    documentation: currentDoc,
+                    language: 'rust',
+                });
+                currentDoc = undefined;
+                continue;
+            }
+            // Macro definitions
+            const macroMatch = effective.match(/^macro_rules!\s+(\w+)/);
+            if (macroMatch) {
+                const name = macroMatch[1];
+                symbols.push({
+                    name, kind: 'macro', filePath, line: i,
+                    exported: isPublic,
+                    documentation: currentDoc,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Const/static
+            const constMatch = effective.match(/^(?:const|static)\s+(\w+)/);
+            if (constMatch) {
+                const name = constMatch[1];
+                symbols.push({
+                    name, kind: 'variable', filePath, line: i,
+                    exported: isPublic,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Type alias
+            const typeMatch = effective.match(/^type\s+(\w+)/);
+            if (typeMatch) {
+                const name = typeMatch[1];
+                symbols.push({
+                    name, kind: 'type', filePath, line: i,
+                    exported: isPublic,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            // Module declarations
+            const modMatch = effective.match(/^mod\s+(\w+)/);
+            if (modMatch) {
+                const name = modMatch[1];
+                symbols.push({
+                    name, kind: 'module', filePath, line: i,
+                    exported: isPublic,
+                    language: 'rust',
+                });
+                if (isPublic)
+                    exports.push(name);
+                currentDoc = undefined;
+                continue;
+            }
+            if (trimmed.length > 0 && !trimmed.startsWith('*')) {
+                currentDoc = undefined;
+            }
+        }
+        return { filePath, language: 'rust', symbols, imports, exports };
+    }
+}

package/dist/src/parser/symbol-extractor.d.ts

@@ -0,0 +1,14 @@
+import type { FileAST } from '../types.js';
+export interface LanguageExtractor {
+    languages: string[];
+    extract(source: string, filePath: string): FileAST;
+}
+export declare class SymbolExtractor {
+    private extractors;
+    constructor();
+    registerExtractor(extractor: LanguageExtractor): void;
+    extractFromSource(source: string, filePath: string): FileAST;
+    detectLanguage(filePath: string): string;
+    supportsLanguage(language: string): boolean;
+}
+//# sourceMappingURL=symbol-extractor.d.ts.map

package/dist/src/parser/symbol-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol-extractor.d.ts","sourceRoot":"","sources":["../../../src/parser/symbol-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,OAAO,EAAc,MAAM,aAAa,CAAA;AAGlE,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAA;CACnD;AAcD,qBAAa,eAAe;IAC1B,OAAO,CAAC,UAAU,CAA4C;;IAS9D,iBAAiB,CAAC,SAAS,EAAE,iBAAiB,GAAG,IAAI;IAMrD,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IAe5D,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;IAKxC,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;CAG5C"}

package/dist/src/parser/symbol-extractor.js

@@ -0,0 +1,47 @@
+import { TypeScriptExtractor } from './typescript-extractor.js';
+const EXTENSION_MAP = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.py': 'python',
+    '.go': 'go',
+    '.rs': 'rust',
+};
+export class SymbolExtractor {
+    extractors = new Map();
+    constructor() {
+        const tsExtractor = new TypeScriptExtractor();
+        for (const lang of tsExtractor.languages) {
+            this.extractors.set(lang, tsExtractor);
+        }
+    }
+    registerExtractor(extractor) {
+        for (const lang of extractor.languages) {
+            this.extractors.set(lang, extractor);
+        }
+    }
+    extractFromSource(source, filePath) {
+        const language = this.detectLanguage(filePath);
+        const extractor = this.extractors.get(language);
+        if (!extractor) {
+            return {
+                filePath,
+                language,
+                symbols: [],
+                imports: [],
+                exports: [],
+            };
+        }
+        return extractor.extract(source, filePath);
+    }
+    detectLanguage(filePath) {
+        const ext = filePath.slice(filePath.lastIndexOf('.'));
+        return EXTENSION_MAP[ext] ?? 'unknown';
+    }
+    supportsLanguage(language) {
+        return this.extractors.has(language);
+    }
+}

package/dist/src/parser/typescript-extractor.d.ts

@@ -0,0 +1,13 @@
+import type { FileAST } from '../types.js';
+import type { LanguageExtractor } from './symbol-extractor.js';
+/** Regex-based TypeScript/JavaScript symbol extractor (no native deps). */
+export declare class TypeScriptExtractor implements LanguageExtractor {
+    languages: string[];
+    extract(source: string, filePath: string): FileAST;
+    private extractClassMembers;
+    private makeSymbol;
+    private extractSignature;
+    private findBlockEnd;
+    private lineOffset;
+}
+//# sourceMappingURL=typescript-extractor.d.ts.map

package/dist/src/parser/typescript-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-extractor.d.ts","sourceRoot":"","sources":["../../../src/parser/typescript-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAc,OAAO,EAAc,MAAM,aAAa,CAAA;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAE9D,2EAA2E;AAC3E,qBAAa,mBAAoB,YAAW,iBAAiB;IAC3D,SAAS,WAA+B;IAExC,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO;IA4KlD,OAAO,CAAC,mBAAmB;IAwB3B,OAAO,CAAC,UAAU;IAelB,OAAO,CAAC,gBAAgB;IAYxB,OAAO,CAAC,YAAY;IAcpB,OAAO,CAAC,UAAU;CAOnB"}