opencode-autognosis 2.0.0 → 2.0.1

package/dist/chunk-cards.d.ts

@@ -1,3 +1,29 @@
+import ts from "typescript";
+export declare const CHUNK_DIR: string;
+export interface ChunkCard {
+    id: string;
+    file_path: string;
+    chunk_type: "summary" | "api" | "invariant";
+    content: string;
+    metadata: {
+        created_at: string;
+        updated_at: string;
+        hash: string;
+        dependencies: string[];
+        symbols: string[];
+        complexity_score: number;
+    };
+}
+export declare function ensureChunkDir(): Promise<void>;
+export declare function calculateHash(content: string): string;
+export declare function calculateComplexity(content: string): number;
+export declare function extractSymbols(content: string, filePath?: string): string[];
 export declare function chunkCardsTools(): {
     [key: string]: any;
 };
+export declare function generateSummaryChunk(content: string, filePath: string, ast: ts.SourceFile | null): Promise<string>;
+export declare function generateApiChunk(content: string, filePath: string, ast: ts.SourceFile | null): Promise<string>;
+export declare function generateInvariantChunk(content: string, filePath: string, ast: ts.SourceFile | null): Promise<string>;
+export declare function extractDependencies(content: string, ast?: ts.SourceFile | null, filePath?: string): Promise<string[]>;
+export declare function parseFileAST(filePath: string, content: string): ts.SourceFile | null;
+export declare function extractSymbolsFromAST(sourceFile: ts.SourceFile | null, content: string): string[] | null;

package/dist/chunk-cards.js

@@ -5,10 +5,11 @@ import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import ts from "typescript";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
-const CHUNK_DIR = path.join(OPENCODE_DIR, "chunks");
+export const CHUNK_DIR = path.join(OPENCODE_DIR, "chunks");
 const CACHE_DIR = path.join(OPENCODE_DIR, "cache");
 // Internal logging
 function log(message, data) {
@@ -33,22 +34,39 @@ async function runCmd(cmd, cwd = PROJECT_ROOT, timeoutMs = 30000) {
         return { stdout: "", stderr: error.message, error };
     }
 }
-async function ensureChunkDir() {
+export async function ensureChunkDir() {
     await fs.mkdir(CHUNK_DIR, { recursive: true });
 }
-function calculateHash(content) {
+export function calculateHash(content) {
     return crypto.createHash('sha256').update(content).digest('hex');
 }
-function calculateComplexity(content) {
+export function calculateComplexity(content) {
     // Simple complexity calculation based on code metrics
     const lines = content.split('\n').length;
     const cyclomaticComplexity = (content.match(/\b(if|while|for|switch|case|catch)\b/g) || []).length;
     const nestingDepth = Math.max(...content.split('\n').map(line => (line.match(/^\s*/)?.[0]?.length || 0)));
     return Math.min(100, (lines * 0.1) + (cyclomaticComplexity * 5) + (nestingDepth * 2));
 }
-function extractSymbols(content) {
+export function extractSymbols(content, filePath = '') {
     // Extract function names, class names, and variable names
     const symbols = [];
+    if (filePath) {
+        const ext = path.extname(filePath);
+        if (ext === '.cpp' || ext === '.c' || ext === '.h' || ext === '.hpp' || ext === '.cc') {
+            const funcs = extractFunctionsCpp(content);
+            const classes = extractClassesCpp(content);
+            symbols.push(...funcs.map(f => f.name));
+            symbols.push(...classes.map(c => c.name));
+            return symbols;
+        }
+        if (ext === '.swift') {
+            const funcs = extractFunctionsSwift(content);
+            const classes = extractClassesSwift(content);
+            symbols.push(...funcs.map(f => f.name));
+            symbols.push(...classes.map(c => c.name));
+            return symbols;
+        }
+    }
     // Functions
     const functionMatches = content.match(/(?:function|const|let|var)\s+(\w+)\s*=/g);
     if (functionMatches) {
@@ -108,17 +126,19 @@ export function chunkCardsTools() {
                     if (!sourceContent) {
                         sourceContent = await fs.readFile(file_path, 'utf-8');
                     }
+                    // Parse AST for JS/TS files
+                    const ast = parseFileAST(file_path, sourceContent);
                     // Generate chunk content based on type
                     let chunkContent = "";
                     switch (chunk_type) {
                         case "summary":
-                            chunkContent = await generateSummaryChunk(sourceContent, file_path);
+                            chunkContent = await generateSummaryChunk(sourceContent, file_path, ast);
                             break;
                         case "api":
-                            chunkContent = await generateApiChunk(sourceContent, file_path);
+                            chunkContent = await generateApiChunk(sourceContent, file_path, ast);
                             break;
                         case "invariant":
-                            chunkContent = await generateInvariantChunk(sourceContent, file_path);
+                            chunkContent = await generateInvariantChunk(sourceContent, file_path, ast);
                             break;
                     }
                     // Create chunk card
@@ -131,8 +151,8 @@ export function chunkCardsTools() {
                             created_at: new Date().toISOString(),
                             updated_at: new Date().toISOString(),
                             hash: calculateHash(chunkContent),
-                            dependencies: await extractDependencies(sourceContent),
-                            symbols: extractSymbols(sourceContent),
+                            dependencies: await extractDependencies(sourceContent, ast, file_path),
+                            symbols: extractSymbolsFromAST(ast, sourceContent) || extractSymbols(sourceContent, file_path),
                             complexity_score: calculateComplexity(sourceContent)
                         }
                     };
@@ -295,15 +315,37 @@ export function chunkCardsTools() {
 // =============================================================================
 // CHUNK GENERATION HELPERS
 // =============================================================================
-async function generateSummaryChunk(content, filePath) {
+export async function generateSummaryChunk(content, filePath, ast) {
     const lines = content.split('\n');
     const fileName = path.basename(filePath);
     const fileExtension = path.extname(filePath);
     // Extract key information
-    const functions = extractFunctions(content);
-    const classes = extractClasses(content);
-    const imports = extractImports(content);
-    const exports = extractExports(content);
+    let functions = [];
+    let classes = [];
+    let imports = [];
+    let exports = [];
+    if (ast) {
+        functions = extractFunctionsFromAST(ast);
+        classes = extractClassesFromAST(ast);
+        imports = extractImportsFromAST(ast);
+        exports = extractExportsFromAST(ast);
+    }
+    else if (fileExtension === '.cpp' || fileExtension === '.c' || fileExtension === '.h' || fileExtension === '.hpp' || fileExtension === '.cc') {
+        functions = extractFunctionsCpp(content);
+        classes = extractClassesCpp(content);
+        imports = extractImportsCpp(content);
+    }
+    else if (fileExtension === '.swift') {
+        functions = extractFunctionsSwift(content);
+        classes = extractClassesSwift(content);
+        imports = extractImportsSwift(content);
+    }
+    else {
+        functions = extractFunctions(content);
+        classes = extractClasses(content);
+        imports = extractImports(content);
+        exports = extractExports(content);
+    }
     const summary = `# Summary: ${fileName}
 
 ## File Type
@@ -337,11 +379,34 @@ ${exports.length > 0 ? exports.map(exp => `- ${exp}`).join('\n') : 'No exports'}
 ${extractNotes(content)}`;
     return summary;
 }
-async function generateApiChunk(content, filePath) {
-    const functions = extractFunctions(content);
-    const classes = extractClasses(content);
-    const interfaces = extractInterfaces(content);
-    const types = extractTypes(content);
+export async function generateApiChunk(content, filePath, ast) {
+    let functions = [];
+    let classes = [];
+    let interfaces = [];
+    let types = [];
+    const fileExtension = path.extname(filePath);
+    if (ast) {
+        functions = extractFunctionsFromAST(ast);
+        classes = extractClassesFromAST(ast);
+        interfaces = extractInterfacesFromAST(ast);
+        types = extractTypesFromAST(ast);
+    }
+    else if (fileExtension === '.cpp' || fileExtension === '.c' || fileExtension === '.h' || fileExtension === '.hpp' || fileExtension === '.cc') {
+        functions = extractFunctionsCpp(content);
+        classes = extractClassesCpp(content);
+        // C++ interfaces/types logic is complex, skipping for now
+    }
+    else if (fileExtension === '.swift') {
+        functions = extractFunctionsSwift(content);
+        classes = extractClassesSwift(content);
+        // Swift protocols could map to interfaces
+    }
+    else {
+        functions = extractFunctions(content);
+        classes = extractClasses(content);
+        interfaces = extractInterfaces(content);
+        types = extractTypes(content);
+    }
     const api = `# API Surface: ${path.basename(filePath)}
 
 ## Public Functions
@@ -394,7 +459,7 @@ ${type.description}
 `).join('\n')}`;
     return api;
 }
-async function generateInvariantChunk(content, filePath) {
+export async function generateInvariantChunk(content, filePath, ast) {
     const invariants = extractInvariants(content);
     const constraints = extractConstraints(content);
     const assumptions = extractAssumptions(content);
@@ -543,28 +608,89 @@ function extractTypeDescription(content, typeName) {
     return "Type description not available";
 }
 function extractInvariants(content) {
-    // Extract invariants from comments and code
-    return [];
+    const invariants = [];
+    // Look for validation checks that throw errors
+    const throwMatches = content.match(/if\s*\(([^)]+)\)\s*throw\s*new\s*Error\(([^)]+)\)/g);
+    if (throwMatches) {
+        throwMatches.forEach(m => {
+            invariants.push({ name: "Validation Check", description: m });
+        });
+    }
+    // Look for assert calls
+    const assertMatches = content.match(/assert\(([^,]+)(?:,\s*["']([^"']+)["'])?\)/g);
+    if (assertMatches) {
+        assertMatches.forEach(m => {
+            invariants.push({ name: "Assertion", description: m });
+        });
+    }
+    return invariants;
 }
 function extractConstraints(content) {
-    // Extract constraints from comments and code
-    return [];
+    const constraints = [];
+    // Look for UPPERCASE constants which usually denote limits/config
+    const constMatches = content.match(/const\s+([A-Z_][A-Z0-9_]*)\s*=\s*([^;]+)/g);
+    if (constMatches) {
+        constMatches.forEach(m => {
+            const parts = m.split('=');
+            constraints.push({ name: parts[0].replace('const', '').trim(), description: parts[1].trim() });
+        });
+    }
+    return constraints;
 }
 function extractAssumptions(content) {
-    // Extract assumptions from comments and code
-    return [];
+    const assumptions = [];
+    // Look for comments indicating assumptions
+    const commentMatches = content.match(/\/\/\s*(TODO|FIXME|ASSUME|NOTE):\s*(.+)/g);
+    if (commentMatches) {
+        commentMatches.forEach(m => {
+            assumptions.push({ name: "Code Annotation", description: m.replace(/\/\/\s*/, '').trim() });
+        });
+    }
+    return assumptions;
 }
 function extractStateManagement(content) {
-    return "State management analysis not implemented";
+    const patterns = [];
+    if (content.includes('useState'))
+        patterns.push("React useState hook");
+    if (content.includes('useReducer'))
+        patterns.push("React useReducer hook");
+    if (content.includes('this.state'))
+        patterns.push("Class component state");
+    if (content.includes('redux') || content.includes('dispatch'))
+        patterns.push("Redux/Flux pattern");
+    if (content.includes('mobx') || content.includes('observable'))
+        patterns.push("MobX pattern");
+    return patterns.length > 0 ? `Detected patterns: ${patterns.join(', ')}` : "No explicit state management patterns detected";
 }
 function extractErrorHandling(content) {
-    return "Error handling analysis not implemented";
+    const tryCount = (content.match(/try\s*\{/g) || []).length;
+    const catchCount = (content.match(/catch\s*(\(|{)/g) || []).length;
+    const throwCount = (content.match(/throw\s+new\s+Error/g) || []).length;
+    if (tryCount === 0 && throwCount === 0)
+        return "No explicit error handling patterns detected";
+    return `Error handling metrics: ${tryCount} try-catch blocks, ${throwCount} throw statements`;
 }
 function extractPerformanceConsiderations(content) {
-    return "Performance considerations not analyzed";
+    const patterns = [];
+    if (content.includes('useMemo'))
+        patterns.push("Uses React.useMemo");
+    if (content.includes('useCallback'))
+        patterns.push("Uses React.useCallback");
+    if (content.match(/await\s+Promise\.all/))
+        patterns.push("Uses parallel execution (Promise.all)");
+    if (content.match(/for\s*\(.*;.*;.*\)/))
+        patterns.push("Contains explicit loops");
+    return patterns.length > 0 ? `Performance patterns: ${patterns.join(', ')}` : "No obvious performance optimization patterns detected";
 }
 function extractSecurityConsiderations(content) {
-    return "Security considerations not analyzed";
+    const risks = [];
+    if (content.includes('innerHTML'))
+        risks.push("Potential XSS risk (innerHTML usage)");
+    if (content.includes('eval('))
+        risks.push("Critical security risk (eval usage)");
+    if (content.includes('dangerouslySetInnerHTML'))
+        risks.push("Explicit React XSS risk");
+    return risks.length > 0 ? `Security alerts: ${risks.join(', ')}` : "No obvious security risks detected via static analysis";
 }
 function getFileTypeDescription(extension) {
     const descriptions = {
@@ -580,7 +706,277 @@ function getFileTypeDescription(extension) {
     };
     return descriptions[extension] || 'Unknown file type';
 }
-async function extractDependencies(content) {
+export async function extractDependencies(content, ast = null, filePath = '') {
     // Extract dependency information from imports
+    if (ast) {
+        return extractImportsFromAST(ast);
+    }
+    if (filePath) {
+        const ext = path.extname(filePath);
+        if (ext === '.cpp' || ext === '.c' || ext === '.h' || ext === '.hpp' || ext === '.cc') {
+            return extractImportsCpp(content);
+        }
+        if (ext === '.swift') {
+            return extractImportsSwift(content);
+        }
+    }
     return extractImports(content);
 }
+// =============================================================================
+// AST EXTRACTION HELPERS
+// =============================================================================
+export function parseFileAST(filePath, content) {
+    if (filePath.endsWith('.ts') || filePath.endsWith('.tsx') || filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+        return ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    }
+    return null;
+}
+function extractFunctionsFromAST(sourceFile) {
+    const functions = [];
+    function visit(node) {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            functions.push({
+                name: node.name.text,
+                signature: node.getText(sourceFile).split('{')[0].trim(),
+                isExported: isNodeExported(node),
+                params: node.parameters.map(p => ({
+                    name: p.name.getText(sourceFile),
+                    type: p.type ? p.type.getText(sourceFile) : 'any',
+                    description: ''
+                })),
+                returns: node.type ? node.type.getText(sourceFile) : 'void',
+                description: getJSDocDescription(node, sourceFile)
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return functions;
+}
+function extractClassesFromAST(sourceFile) {
+    const classes = [];
+    function visit(node) {
+        if (ts.isClassDeclaration(node) && node.name) {
+            const methods = [];
+            const properties = [];
+            node.members.forEach(member => {
+                if (ts.isMethodDeclaration(member) && member.name) {
+                    methods.push({
+                        name: member.name.getText(sourceFile),
+                        signature: member.getText(sourceFile).split('{')[0].trim()
+                    });
+                }
+                else if (ts.isPropertyDeclaration(member) && member.name) {
+                    properties.push({
+                        name: member.name.getText(sourceFile),
+                        type: member.type ? member.type.getText(sourceFile) : 'any'
+                    });
+                }
+            });
+            classes.push({
+                name: node.name.text,
+                signature: node.getText(sourceFile).split('{')[0].trim(),
+                extends: node.heritageClauses?.find(h => h.token === ts.SyntaxKind.ExtendsKeyword)?.types[0].expression.getText(sourceFile) || null,
+                description: getJSDocDescription(node, sourceFile),
+                methods,
+                properties
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return classes;
+}
+function extractInterfacesFromAST(sourceFile) {
+    const interfaces = [];
+    function visit(node) {
+        if (ts.isInterfaceDeclaration(node)) {
+            interfaces.push({
+                name: node.name.text,
+                signature: node.getText(sourceFile).split('{')[0].trim(),
+                description: getJSDocDescription(node, sourceFile)
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return interfaces;
+}
+function extractTypesFromAST(sourceFile) {
+    const types = [];
+    function visit(node) {
+        if (ts.isTypeAliasDeclaration(node)) {
+            types.push({
+                name: node.name.text,
+                signature: node.getText(sourceFile).split('=')[0].trim(),
+                description: getJSDocDescription(node, sourceFile)
+            });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return types;
+}
+function extractImportsFromAST(sourceFile) {
+    const imports = [];
+    function visit(node) {
+        if (ts.isImportDeclaration(node)) {
+            const moduleSpecifier = node.moduleSpecifier;
+            if (ts.isStringLiteral(moduleSpecifier)) {
+                imports.push(moduleSpecifier.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return imports;
+}
+function extractExportsFromAST(sourceFile) {
+    const exports = [];
+    function visit(node) {
+        if (isNodeExported(node)) {
+            if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) && node.name) {
+                exports.push(node.name.text);
+            }
+            else if (ts.isVariableStatement(node)) {
+                node.declarationList.declarations.forEach(decl => {
+                    if (ts.isIdentifier(decl.name)) {
+                        exports.push(decl.name.text);
+                    }
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return exports;
+}
+export function extractSymbolsFromAST(sourceFile, content) {
+    if (!sourceFile)
+        return null;
+    const symbols = [];
+    function visit(node) {
+        if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) && node.name) {
+            symbols.push(node.name.text);
+        }
+        else if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) {
+            symbols.push(node.name.text);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return symbols;
+}
+function isNodeExported(node) {
+    return ((ts.getCombinedModifierFlags(node) & ts.ModifierFlags.Export) !== 0 ||
+        (!!node.parent && node.parent.kind === ts.SyntaxKind.SourceFile && ts.isExportAssignment(node)));
+}
+function getJSDocDescription(node, sourceFile) {
+    const jsDocTags = node.jsDoc;
+    if (jsDocTags && jsDocTags.length > 0) {
+        return jsDocTags[0].comment || "Documented in JSDoc";
+    }
+    return "No documentation found";
+}
+// =============================================================================
+// C++ EXTRACTION HELPERS
+// =============================================================================
+function extractFunctionsCpp(content) {
+    const functions = [];
+    // Regex for C++ functions: returnType name(params) {
+    // Simplistic approximation
+    const regex = /((?:[\w:<>_]+\s+)+)(\w+)\s*\(([^)]*)\)\s*(?:const|noexcept|override|final)*\s*\{/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        const returnType = match[1].trim();
+        // Skip if it looks like a control structure
+        if (['if', 'for', 'while', 'switch', 'catch'].includes(match[2]))
+            continue;
+        functions.push({
+            name: match[2],
+            signature: `${returnType} ${match[2]}(${match[3]})`,
+            isExported: true, // Assuming public/header
+            params: match[3].split(',').filter(Boolean).map(p => {
+                const parts = p.trim().split(/\s+/);
+                const name = parts.pop() || '';
+                return { name, type: parts.join(' '), description: '' };
+            }),
+            returns: returnType,
+            description: "C++ Function"
+        });
+    }
+    return functions;
+}
+function extractClassesCpp(content) {
+    const classes = [];
+    const regex = /(class|struct)\s+(\w+)(?:\s*:\s*(?:public|private|protected)\s+([^{]+))?\s*\{/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        classes.push({
+            name: match[2],
+            signature: match[0].trim(),
+            extends: match[3] ? match[3].trim() : null,
+            description: `C++ ${match[1]}`,
+            methods: [], // Deep parsing requires more complex logic
+            properties: []
+        });
+    }
+    return classes;
+}
+function extractImportsCpp(content) {
+    const imports = [];
+    const regex = /#include\s*[<"]([^>"]+)[>"]/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        imports.push(match[1]);
+    }
+    return imports;
+}
+// =============================================================================
+// SWIFT EXTRACTION HELPERS
+// =============================================================================
+function extractFunctionsSwift(content) {
+    const functions = [];
+    // Regex for Swift functions: func name(params) -> ReturnType {
+    const regex = /(?:public|private|internal|fileprivate|open)?\s*func\s+(\w+)\s*\(([^)]*)\)(?:\s*->\s*([^{]+))?\s*\{/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        functions.push({
+            name: match[1],
+            signature: match[0].split('{')[0].trim(),
+            isExported: !match[0].includes('private') && !match[0].includes('fileprivate'),
+            params: match[2].split(',').filter(Boolean).map(p => {
+                const parts = p.trim().split(':');
+                return { name: parts[0].trim(), type: parts[1]?.trim() || 'Any', description: '' };
+            }),
+            returns: match[3]?.trim() || 'Void',
+            description: "Swift Function"
+        });
+    }
+    return functions;
+}
+function extractClassesSwift(content) {
+    const classes = [];
+    const regex = /(?:public|private|internal|fileprivate|open)?\s*(class|struct|enum|extension|protocol)\s+(\w+)(?:\s*:\s*([^{]+))?\s*\{/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        classes.push({
+            name: match[2],
+            signature: match[0].trim(),
+            extends: match[3] ? match[3].trim() : null,
+            description: `Swift ${match[1]}`,
+            methods: [],
+            properties: []
+        });
+    }
+    return classes;
+}
+function extractImportsSwift(content) {
+    const imports = [];
+    const regex = /import\s+(\w+)/g;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+        imports.push(match[1]);
+    }
+    return imports;
+}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
-export default function plugin(): {
-    tools: {
-        [key: string]: any;
+export declare const AutognosisPlugin: () => Promise<{
+    tool: {
+        [x: string]: any;
     };
-};
+}>;
+export default AutognosisPlugin;

package/dist/index.js

@@ -5,9 +5,9 @@ import { chunkCardsTools } from "./chunk-cards.js";
 import { activeSetTools } from "./activeset.js";
 import { moduleSummariesTools } from "./module-summaries.js";
 import { performanceTools } from "./performance-optimization.js";
-export default function plugin() {
+export const AutognosisPlugin = async () => {
     return {
-        tools: {
+        tool: {
             ...systemTools(),
             ...gitWorktreeTools(),
             ...testingTools(),
@@ -17,4 +17,5 @@ export default function plugin() {
             ...performanceTools(),
         },
     };
-}
+};
+export default AutognosisPlugin;

package/dist/performance-optimization.js

@@ -5,6 +5,7 @@ import * as fsSync from "node:fs";
 import * as path from "node:path";
 import { promisify } from "node:util";
 import * as crypto from "node:crypto";
+import { CHUNK_DIR, ensureChunkDir, calculateHash, calculateComplexity, parseFileAST, generateSummaryChunk, generateApiChunk, generateInvariantChunk, extractDependencies, extractSymbolsFromAST, extractSymbols } from "./chunk-cards.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -593,10 +594,43 @@ async function getAllSourceFiles() {
     return sourceFiles;
 }
 async function indexFile(filePath) {
-    // Simplified indexing - would create chunk cards, analyze symbols, etc.
-    // For now, just touch the file to update its timestamp
-    const stats = await fs.stat(filePath);
-    // Indexing logic would go here
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        await ensureChunkDir();
+        const ast = parseFileAST(filePath, content);
+        const chunkTypes = ["summary", "api", "invariant"];
+        // Generate file hash for ID consistency
+        const fileHash = calculateHash(filePath);
+        for (const chunkType of chunkTypes) {
+            const cardId = `${path.basename(filePath)}-${chunkType}-${fileHash.slice(0, 8)}`;
+            const cardPath = path.join(CHUNK_DIR, `${cardId}.json`);
+            let chunkContent = "";
+            if (chunkType === "summary")
+                chunkContent = await generateSummaryChunk(content, filePath, ast);
+            else if (chunkType === "api")
+                chunkContent = await generateApiChunk(content, filePath, ast);
+            else if (chunkType === "invariant")
+                chunkContent = await generateInvariantChunk(content, filePath, ast);
+            const chunkCard = {
+                id: cardId,
+                file_path: filePath,
+                chunk_type: chunkType,
+                content: chunkContent,
+                metadata: {
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                    hash: calculateHash(chunkContent),
+                    dependencies: await extractDependencies(content, ast, filePath),
+                    symbols: extractSymbolsFromAST(ast, content) || extractSymbols(content, filePath),
+                    complexity_score: calculateComplexity(content)
+                }
+            };
+            await fs.writeFile(cardPath, JSON.stringify(chunkCard, null, 2));
+        }
+    }
+    catch (error) {
+        log(`Failed to index file ${filePath}`, error);
+    }
 }
 async function runBackgroundIndexing(taskId, indexingState) {
     try {
@@ -606,11 +640,65 @@ async function runBackgroundIndexing(taskId, indexingState) {
         task.status = "running";
         task.started_at = new Date().toISOString();
         await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
-        // Simulate background indexing work
-        for (let i = 0; i < 10; i++) {
-            task.progress = (i + 1) * 10;
+        // Determine files to index
+        const force_full = task.metadata?.force_full || false;
+        let filesToIndex = [];
+        if (force_full) {
+            filesToIndex = await getAllSourceFiles();
+        }
+        else {
+            // For incremental, we try to use git diff. If that fails or returns empty,
+            // we might default to all files or just recent ones. For robustness here:
+            try {
+                const { stdout: gitDiff } = await runCmd(`git diff --name-only --since="${indexingState.last_indexed}"`);
+                const changedFiles = gitDiff.split('\n').filter(Boolean);
+                if (changedFiles.length > 0) {
+                    filesToIndex = changedFiles;
+                }
+                else {
+                    // If no changes detected by git, maybe we don't need to do anything?
+                    // But if forced or state is stale, maybe we should.
+                    // For background task simplicity, if not full, and no git changes, we index nothing or check simple timestamps.
+                    // Let's rely on getAllSourceFiles filtering if we wanted robust check.
+                    // Here, we'll just check timestamps of all source files against last_indexed.
+                    const allFiles = await getAllSourceFiles();
+                    filesToIndex = [];
+                    for (const f of allFiles) {
+                        const fp = path.join(PROJECT_ROOT, f);
+                        if (fsSync.existsSync(fp)) {
+                            const stats = await fs.stat(fp);
+                            if (stats.mtime.toISOString() > indexingState.last_indexed) {
+                                filesToIndex.push(f);
+                            }
+                        }
+                    }
+                }
+            }
+            catch (e) {
+                // Fallback to full scan if git fails
+                filesToIndex = await getAllSourceFiles();
+            }
+        }
+        const total = filesToIndex.length;
+        let processed = 0;
+        if (total === 0) {
+            task.progress = 100;
+            task.status = "completed";
+            task.completed_at = new Date().toISOString();
             await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            return;
+        }
+        for (const file of filesToIndex) {
+            const filePath = path.join(PROJECT_ROOT, file);
+            if (fsSync.existsSync(filePath)) {
+                await indexFile(filePath);
+            }
+            processed++;
+            // Update progress periodically
+            if (processed % 5 === 0 || processed === total) {
+                task.progress = Math.round((processed / total) * 100);
+                await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+            }
         }
         // Complete task
         task.status = "completed";
@@ -621,11 +709,18 @@ async function runBackgroundIndexing(taskId, indexingState) {
     catch (error) {
         // Update task with error
         const taskPath = path.join(PERF_DIR, `${taskId}.json`);
-        const task = JSON.parse(await fs.readFile(taskPath, 'utf-8'));
-        task.status = "failed";
-        task.error = error instanceof Error ? error.message : `${error}`;
-        task.completed_at = new Date().toISOString();
-        await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+        try {
+            if (fsSync.existsSync(taskPath)) {
+                const task = JSON.parse(await fs.readFile(taskPath, 'utf-8'));
+                task.status = "failed";
+                task.error = error instanceof Error ? error.message : `${error}`;
+                task.completed_at = new Date().toISOString();
+                await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+            }
+        }
+        catch (writeError) {
+            console.error("Failed to update task error state", writeError);
+        }
     }
 }
 function calculateMetricsSummary(metrics) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-autognosis",
-  "version": "2.0.0",
+  "version": "2.0.1",
   "description": "Advanced RAG-powered codebase awareness for OpenCode agents. Features Chunk Cards synthesis, hierarchical reasoning, ActiveSet working memory, and performance optimization for enterprise-scale repositories.",
   "type": "module",
   "main": "dist/index.js",