opencode-autognosis 2.0.4 → 2.2.0

package/dist/activeset.d.ts

@@ -1,3 +1,31 @@
+interface ActiveSet {
+    id: string;
+    name: string;
+    chunks: string[];
+    context_window: number;
+    priority: "high" | "medium" | "low";
+    created_at: string;
+    last_accessed: string;
+    metadata: {
+        description?: string;
+        tags?: string[];
+        session_id?: string;
+        agent_id?: string;
+    };
+}
+interface WorkingMemory {
+    current_set: string | null;
+    history: Array<{
+        set_id: string;
+        action: "created" | "loaded" | "updated" | "closed";
+        timestamp: string;
+    }>;
+    capacity: number;
+    usage: number;
+}
+export declare function loadActiveSet(setId: string): Promise<ActiveSet | null>;
+export declare function loadWorkingMemory(): Promise<WorkingMemory>;
 export declare function activeSetTools(): {
     [key: string]: any;
 };
+export {};

package/dist/activeset.js

@@ -24,7 +24,7 @@ function calculateContextUsage(chunks) {
     // Simple calculation - in real implementation this would consider actual chunk sizes
     return chunks.length * 100; // Assume 100 tokens per chunk
 }
-async function loadActiveSet(setId) {
+export async function loadActiveSet(setId) {
     try {
         const setPath = path.join(ACTIVESET_DIR, `${setId}.json`);
         if (!fsSync.existsSync(setPath)) {
@@ -41,7 +41,7 @@ async function saveActiveSet(activeSet) {
     const setPath = path.join(ACTIVESET_DIR, `${activeSet.id}.json`);
     await fs.writeFile(setPath, JSON.stringify(activeSet, null, 2));
 }
-async function loadWorkingMemory() {
+export async function loadWorkingMemory() {
     const memoryPath = path.join(ACTIVESET_DIR, "working-memory.json");
     try {
         if (fsSync.existsSync(memoryPath)) {

package/dist/chunk-cards.d.ts

@@ -11,6 +11,10 @@ export interface ChunkCard {
         hash: string;
         dependencies: string[];
         symbols: string[];
+        calls?: Array<{
+            name: string;
+            line: number;
+        }>;
         complexity_score: number;
     };
 }

package/dist/chunk-cards.js

@@ -155,6 +155,7 @@ export function chunkCardsTools() {
                             hash: calculateHash(chunkContent),
                             dependencies: await extractDependencies(sourceContent, ast, file_path),
                             symbols: extractSymbolsFromAST(ast, sourceContent) || extractSymbols(sourceContent, file_path),
+                            calls: ast ? extractCallsFromAST(ast, sourceContent) : extractCalls(sourceContent, file_path),
                             complexity_score: calculateComplexity(sourceContent)
                         }
                     };
@@ -884,6 +885,45 @@ function getJSDocDescription(node, sourceFile) {
     }
     return "No documentation found";
 }
+function extractCallsFromAST(sourceFile, content) {
+    const calls = [];
+    function visit(node) {
+        if (ts.isCallExpression(node)) {
+            const expression = node.expression;
+            let name = "";
+            if (ts.isIdentifier(expression)) {
+                name = expression.text;
+            }
+            else if (ts.isPropertyAccessExpression(expression)) {
+                name = expression.name.text;
+            }
+            if (name) {
+                const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+                calls.push({ name, line: line + 1 });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return calls;
+}
+function extractCalls(content, filePath) {
+    const calls = [];
+    // Basic regex fallback for non-TS languages: matches word(...)
+    const regex = /\b(\w+)\s*\(/g;
+    let match;
+    const lines = content.split('\n');
+    while ((match = regex.exec(content)) !== null) {
+        const name = match[1];
+        if (['if', 'for', 'while', 'switch', 'catch', 'return'].includes(name))
+            continue;
+        // Find line number
+        const offset = match.index;
+        const lineNumber = content.substring(0, offset).split('\n').length;
+        calls.push({ name, line: lineNumber });
+    }
+    return calls;
+}
 // =============================================================================
 // C++ EXTRACTION HELPERS
 // =============================================================================

package/dist/database.d.ts

@@ -4,9 +4,6 @@ export declare class CodeGraphDB {
     private workerRunning;
     constructor();
     private initialize;
-    /**
-     * Background Job Management
-     */
     createJob(id: string, type: string, metadata?: any): void;
     updateJob(id: string, updates: {
         status?: string;
@@ -14,16 +11,27 @@ export declare class CodeGraphDB {
         result?: string;
         error?: string;
     }): void;
-    getJob(id: string): unknown;
-    listJobs(type?: string, limit?: number): unknown[];
+    getJob(id: string): any;
+    listJobs(type?: string, limit?: number): any;
+    postToBlackboard(author: string, message: string, topic?: string): void;
+    readBlackboard(topic?: string, limit?: number): any;
+    storeIntent(patchId: string, reasoning: string, planId: string): void;
+    getIntent(patchId: string): any;
+    addArchRule(source: string, target: string): void;
+    checkArchViolation(sourcePath: string, targetPath: string): any;
     private startWorker;
     private processEmbeddingQueue;
-    /**
-     * Syncs a ChunkCard (JSON) into the SQLite Index.
-     */
     ingestChunkCard(card: ChunkCard): void;
+    findCallers(functionName: string): {
+        path: string;
+        line_number: number;
+    }[];
     deleteChunkCard(cardId: string): void;
     recordExecution(planId: string | undefined, toolName: string, args: any, isOnPlan: boolean): void;
+    logAccess(chunkId: string, planId?: string): void;
+    getLruChunks(limit?: number): {
+        chunk_id: string;
+    }[];
     ingestCommits(commits: any[]): void;
     getHotFiles(pathPrefix?: string, limit?: number): {
         path: string;