opencode-autognosis 1.0.1 → 2.0.0

package/dist/chunk-cards.js

@@ -0,0 +1,586 @@
+import { tool } from "@opencode-ai/plugin";
+import { exec } from "node:child_process";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import * as crypto from "node:crypto";
+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");
+const CACHE_DIR = path.join(OPENCODE_DIR, "cache");
+// Internal logging
+function log(message, data) {
+    console.error(`[ChunkCards] ${message}`, data || '');
+}
+// =============================================================================
+// HELPERS
+// =============================================================================
+async function runCmd(cmd, cwd = PROJECT_ROOT, timeoutMs = 30000) {
+    try {
+        const { stdout, stderr } = await execAsync(cmd, {
+            cwd,
+            maxBuffer: 10 * 1024 * 1024,
+            timeout: timeoutMs
+        });
+        return { stdout: stdout.trim(), stderr: stderr.trim() };
+    }
+    catch (error) {
+        if (error.signal === 'SIGTERM' && error.code === undefined) {
+            return { stdout: "", stderr: `Command timed out after ${timeoutMs}ms`, error, timedOut: true };
+        }
+        return { stdout: "", stderr: error.message, error };
+    }
+}
+async function ensureChunkDir() {
+    await fs.mkdir(CHUNK_DIR, { recursive: true });
+}
+function calculateHash(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+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) {
+    // Extract function names, class names, and variable names
+    const symbols = [];
+    // Functions
+    const functionMatches = content.match(/(?:function|const|let|var)\s+(\w+)\s*=/g);
+    if (functionMatches) {
+        symbols.push(...functionMatches.map(m => m.split(/\s+/)[1]));
+    }
+    // Classes
+    const classMatches = content.match(/class\s+(\w+)/g);
+    if (classMatches) {
+        symbols.push(...classMatches.map(m => m.split(/\s+/)[1]));
+    }
+    // Interfaces/Types
+    const typeMatches = content.match(/(?:interface|type)\s+(\w+)/g);
+    if (typeMatches) {
+        symbols.push(...typeMatches.map(m => m.split(/\s+/)[1]));
+    }
+    return symbols.filter(s => s && s.length > 0);
+}
+// =============================================================================
+// CHUNK CARDS IMPLEMENTATION
+// =============================================================================
+export function chunkCardsTools() {
+    return {
+        chunk_create_card: tool({
+            description: "Create a Chunk Card for code analysis. Supports summary, API, and invariant card types with automatic metadata extraction.",
+            args: {
+                file_path: tool.schema.string().describe("Absolute path to the source file"),
+                chunk_type: tool.schema.enum(["summary", "api", "invariant"]).describe("Type of chunk card to create"),
+                content: tool.schema.string().optional().describe("Custom content (auto-generated if not provided)"),
+                force_recreate: tool.schema.boolean().optional().default(false).describe("Force recreation even if card exists")
+            },
+            async execute({ file_path, chunk_type, content, force_recreate }) {
+                log("Tool call: chunk_create_card", { file_path, chunk_type, force_recreate });
+                try {
+                    await ensureChunkDir();
+                    // Validate file exists
+                    if (!fsSync.existsSync(file_path)) {
+                        return JSON.stringify({
+                            status: "ERROR",
+                            message: `File not found: ${file_path}`
+                        }, null, 2);
+                    }
+                    // Generate card ID
+                    const fileHash = calculateHash(file_path);
+                    const cardId = `${path.basename(file_path)}-${chunk_type}-${fileHash.slice(0, 8)}`;
+                    const cardPath = path.join(CHUNK_DIR, `${cardId}.json`);
+                    // Check if card already exists
+                    if (!force_recreate && fsSync.existsSync(cardPath)) {
+                        const existingCard = JSON.parse(await fs.readFile(cardPath, 'utf-8'));
+                        return JSON.stringify({
+                            status: "EXISTS",
+                            card: existingCard,
+                            message: "Card already exists. Use force_recreate=true to override."
+                        }, null, 2);
+                    }
+                    // Read source file if no custom content provided
+                    let sourceContent = content;
+                    if (!sourceContent) {
+                        sourceContent = await fs.readFile(file_path, 'utf-8');
+                    }
+                    // Generate chunk content based on type
+                    let chunkContent = "";
+                    switch (chunk_type) {
+                        case "summary":
+                            chunkContent = await generateSummaryChunk(sourceContent, file_path);
+                            break;
+                        case "api":
+                            chunkContent = await generateApiChunk(sourceContent, file_path);
+                            break;
+                        case "invariant":
+                            chunkContent = await generateInvariantChunk(sourceContent, file_path);
+                            break;
+                    }
+                    // Create chunk card
+                    const chunkCard = {
+                        id: cardId,
+                        file_path,
+                        chunk_type,
+                        content: chunkContent,
+                        metadata: {
+                            created_at: new Date().toISOString(),
+                            updated_at: new Date().toISOString(),
+                            hash: calculateHash(chunkContent),
+                            dependencies: await extractDependencies(sourceContent),
+                            symbols: extractSymbols(sourceContent),
+                            complexity_score: calculateComplexity(sourceContent)
+                        }
+                    };
+                    // Save chunk card
+                    await fs.writeFile(cardPath, JSON.stringify(chunkCard, null, 2));
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        card: chunkCard,
+                        saved_to: cardPath
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        }),
+        chunk_get_card: tool({
+            description: "Retrieve a Chunk Card by ID or file path and type.",
+            args: {
+                card_id: tool.schema.string().optional().describe("Card ID to retrieve"),
+                file_path: tool.schema.string().optional().describe("File path to search for cards"),
+                chunk_type: tool.schema.enum(["summary", "api", "invariant"]).optional().describe("Filter by chunk type")
+            },
+            async execute({ card_id, file_path, chunk_type }) {
+                log("Tool call: chunk_get_card", { card_id, file_path, chunk_type });
+                try {
+                    await ensureChunkDir();
+                    if (card_id) {
+                        // Direct card lookup
+                        const cardPath = path.join(CHUNK_DIR, `${card_id}.json`);
+                        if (!fsSync.existsSync(cardPath)) {
+                            return JSON.stringify({
+                                status: "NOT_FOUND",
+                                message: `Card not found: ${card_id}`
+                            }, null, 2);
+                        }
+                        const card = JSON.parse(await fs.readFile(cardPath, 'utf-8'));
+                        return JSON.stringify({
+                            status: "SUCCESS",
+                            card
+                        }, null, 2);
+                    }
+                    else if (file_path) {
+                        // Search by file path
+                        const files = await fs.readdir(CHUNK_DIR);
+                        const matchingCards = [];
+                        for (const file of files) {
+                            if (file.endsWith('.json')) {
+                                const cardPath = path.join(CHUNK_DIR, file);
+                                const card = JSON.parse(await fs.readFile(cardPath, 'utf-8'));
+                                if (card.file_path === file_path && (!chunk_type || card.chunk_type === chunk_type)) {
+                                    matchingCards.push(card);
+                                }
+                            }
+                        }
+                        return JSON.stringify({
+                            status: "SUCCESS",
+                            cards: matchingCards,
+                            count: matchingCards.length
+                        }, null, 2);
+                    }
+                    else {
+                        return JSON.stringify({
+                            status: "ERROR",
+                            message: "Either card_id or file_path must be provided"
+                        }, null, 2);
+                    }
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        }),
+        chunk_list_cards: tool({
+            description: "List all Chunk Cards with optional filtering and pagination.",
+            args: {
+                chunk_type: tool.schema.enum(["summary", "api", "invariant"]).optional().describe("Filter by chunk type"),
+                file_pattern: tool.schema.string().optional().describe("Filter by file path pattern (regex)"),
+                limit: tool.schema.number().optional().default(50).describe("Maximum number of cards to return"),
+                offset: tool.schema.number().optional().default(0).describe("Number of cards to skip")
+            },
+            async execute({ chunk_type, file_pattern, limit, offset }) {
+                log("Tool call: chunk_list_cards", { chunk_type, file_pattern, limit, offset });
+                try {
+                    await ensureChunkDir();
+                    const files = await fs.readdir(CHUNK_DIR);
+                    const cards = [];
+                    for (const file of files) {
+                        if (file.endsWith('.json')) {
+                            const cardPath = path.join(CHUNK_DIR, file);
+                            const card = JSON.parse(await fs.readFile(cardPath, 'utf-8'));
+                            // Apply filters
+                            if (chunk_type && card.chunk_type !== chunk_type)
+                                continue;
+                            if (file_pattern && !new RegExp(file_pattern).test(card.file_path))
+                                continue;
+                            cards.push(card);
+                        }
+                    }
+                    // Sort by creation date (newest first)
+                    cards.sort((a, b) => new Date(b.metadata.created_at).getTime() - new Date(a.metadata.created_at).getTime());
+                    // Apply pagination
+                    const paginatedCards = cards.slice(offset, offset + limit);
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        cards: paginatedCards,
+                        pagination: {
+                            total: cards.length,
+                            limit,
+                            offset,
+                            has_more: offset + limit < cards.length
+                        }
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        }),
+        chunk_delete_card: tool({
+            description: "Delete a Chunk Card by ID.",
+            args: {
+                card_id: tool.schema.string().describe("Card ID to delete")
+            },
+            async execute({ card_id }) {
+                log("Tool call: chunk_delete_card", { card_id });
+                try {
+                    const cardPath = path.join(CHUNK_DIR, `${card_id}.json`);
+                    if (!fsSync.existsSync(cardPath)) {
+                        return JSON.stringify({
+                            status: "NOT_FOUND",
+                            message: `Card not found: ${card_id}`
+                        }, null, 2);
+                    }
+                    await fs.unlink(cardPath);
+                    return JSON.stringify({
+                        status: "SUCCESS",
+                        message: `Card deleted: ${card_id}`
+                    }, null, 2);
+                }
+                catch (error) {
+                    return JSON.stringify({
+                        status: "ERROR",
+                        message: error instanceof Error ? error.message : `${error}`
+                    }, null, 2);
+                }
+            }
+        })
+    };
+}
+// =============================================================================
+// CHUNK GENERATION HELPERS
+// =============================================================================
+async function generateSummaryChunk(content, filePath) {
+    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);
+    const summary = `# Summary: ${fileName}
+
+## File Type
+${fileExtension} - ${getFileTypeDescription(fileExtension)}
+
+## Purpose
+${extractPurpose(content)}
+
+## Key Components
+${functions.length > 0 ? `
+### Functions (${functions.length})
+${functions.map(fn => `- **${fn.name}**: ${fn.description}`).join('\n')}
+` : ''}
+
+${classes.length > 0 ? `
+### Classes (${classes.length})
+${classes.map(cls => `- **${cls.name}**: ${cls.description}`).join('\n')}
+` : ''}
+
+## Dependencies
+${imports.length > 0 ? imports.map(imp => `- ${imp}`).join('\n') : 'No external dependencies'}
+
+## Exports
+${exports.length > 0 ? exports.map(exp => `- ${exp}`).join('\n') : 'No exports'}
+
+## Complexity Metrics
+- Lines of code: ${lines.length}
+- Estimated complexity: ${calculateComplexity(content)}/100
+
+## Notes
+${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);
+    const api = `# API Surface: ${path.basename(filePath)}
+
+## Public Functions
+${functions.filter(fn => fn.isExported).map(fn => `
+### ${fn.name}
+\`\`\`typescript
+${fn.signature}
+\`\`\`
+${fn.description}
+${fn.params.length > 0 ? `
+**Parameters:**
+${fn.params.map(p => `- \`${p.name}\`: ${p.type} - ${p.description}`).join('\n')}
+` : ''}
+${fn.returns ? `**Returns:** ${fn.returns}` : ''}
+`).join('\n')}
+
+## Classes
+${classes.map(cls => `
+### ${cls.name}
+\`\`\`typescript
+${cls.signature}
+\`\`\`
+${cls.description}
+${cls.methods.length > 0 ? `
+**Methods:**
+${cls.methods.map(method => `- \`${method.name}\`: ${method.signature}`).join('\n')}
+` : ''}
+${cls.properties.length > 0 ? `
+**Properties:**
+${cls.properties.map(prop => `- \`${prop.name}\`: ${prop.type}`).join('\n')}
+` : ''}
+`).join('\n')}
+
+## Interfaces
+${interfaces.map(iface => `
+### ${iface.name}
+\`\`\`typescript
+${iface.signature}
+\`\`\`
+${iface.description}
+`).join('\n')}
+
+## Types
+${types.map(type => `
+### ${type.name}
+\`\`\`typescript
+${type.signature}
+\`\`\`
+${type.description}
+`).join('\n')}`;
+    return api;
+}
+async function generateInvariantChunk(content, filePath) {
+    const invariants = extractInvariants(content);
+    const constraints = extractConstraints(content);
+    const assumptions = extractAssumptions(content);
+    const invariant = `# Invariants: ${path.basename(filePath)}
+
+## Core Invariants
+${invariants.map(inv => `- **${inv.name}**: ${inv.description}`).join('\n')}
+
+## Constraints
+${constraints.map(con => `- **${con.name}**: ${con.description}`).join('\n')}
+
+## Assumptions
+${assumptions.map(ass => `- **${ass.name}**: ${ass.description}`).join('\n')}
+
+## State Management
+${extractStateManagement(content)}
+
+## Error Handling
+${extractErrorHandling(content)}
+
+## Performance Considerations
+${extractPerformanceConsiderations(content)}
+
+## Security Considerations
+${extractSecurityConsiderations(content)}`;
+    return invariant;
+}
+// =============================================================================
+// EXTRACTION HELPERS
+// =============================================================================
+function extractFunctions(content) {
+    const functions = [];
+    const functionRegex = /(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)\s*:\s*([^;{]+)/g;
+    let match;
+    while ((match = functionRegex.exec(content)) !== null) {
+        functions.push({
+            name: match[1],
+            signature: match[0],
+            isExported: match[0].includes('export'),
+            params: parseParameters(match[2]),
+            returns: match[3]?.trim() || 'void',
+            description: extractFunctionDescription(content, match[1])
+        });
+    }
+    return functions;
+}
+function extractClasses(content) {
+    const classes = [];
+    const classRegex = /(?:export\s+)?class\s+(\w+)(?:\s+extends\s+(\w+))?\s*{([^}]*)}/g;
+    let match;
+    while ((match = classRegex.exec(content)) !== null) {
+        classes.push({
+            name: match[1],
+            signature: match[0],
+            extends: match[2] || null,
+            description: extractClassDescription(content, match[1]),
+            methods: extractMethods(match[3]),
+            properties: extractProperties(match[3])
+        });
+    }
+    return classes;
+}
+function extractImports(content) {
+    const imports = [];
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+        imports.push(match[1]);
+    }
+    return imports;
+}
+function extractExports(content) {
+    const exports = [];
+    const exportRegex = /export\s+(?:const|let|var|function|class|interface|type)\s+(\w+)/g;
+    let match;
+    while ((match = exportRegex.exec(content)) !== null) {
+        exports.push(match[1]);
+    }
+    return exports;
+}
+function extractInterfaces(content) {
+    const interfaces = [];
+    const interfaceRegex = /(?:export\s+)?interface\s+(\w+)\s*{([^}]*)}/g;
+    let match;
+    while ((match = interfaceRegex.exec(content)) !== null) {
+        interfaces.push({
+            name: match[1],
+            signature: match[0],
+            description: extractInterfaceDescription(content, match[1])
+        });
+    }
+    return interfaces;
+}
+function extractTypes(content) {
+    const types = [];
+    const typeRegex = /(?:export\s+)?type\s+(\w+)\s*=\s*([^;]+)/g;
+    let match;
+    while ((match = typeRegex.exec(content)) !== null) {
+        types.push({
+            name: match[1],
+            signature: match[0],
+            description: extractTypeDescription(content, match[1])
+        });
+    }
+    return types;
+}
+function extractPurpose(content) {
+    // Extract purpose from comments or make an educated guess
+    const purposeMatch = content.match(/\/\*\*[^*]*\*[^*]*\*\/\s*(?:function|class|const)/s);
+    return purposeMatch ? "Documented purpose found in JSDoc" : "Purpose not explicitly documented";
+}
+function extractNotes(content) {
+    // Extract important notes from comments
+    return "No specific notes found";
+}
+function parseParameters(params) {
+    if (!params.trim())
+        return [];
+    return params.split(',').map(param => {
+        const [name, type] = param.trim().split(':').map(s => s.trim());
+        return { name: name || '', type: type || 'any', description: '' };
+    });
+}
+function extractFunctionDescription(content, functionName) {
+    // Extract JSDoc description for function
+    const jsdocMatch = content.match(new RegExp(`\\/\\*\\*[^*]*\\*[^*]*\\*\\/\\s*(?:async\\s+)?function\\s+${functionName}`, 's'));
+    return jsdocMatch ? "Function has JSDoc documentation" : "No documentation found";
+}
+function extractClassDescription(content, className) {
+    // Extract JSDoc description for class
+    const jsdocMatch = content.match(new RegExp(`\\/\\*\\*[^*]*\\*[^*]*\\*\\/\\s*class\\s+${className}`, 's'));
+    return jsdocMatch ? "Class has JSDoc documentation" : "No documentation found";
+}
+function extractMethods(classBody) {
+    // Extract methods from class body
+    return [];
+}
+function extractProperties(classBody) {
+    // Extract properties from class body
+    return [];
+}
+function extractInterfaceDescription(content, interfaceName) {
+    return "Interface description not available";
+}
+function extractTypeDescription(content, typeName) {
+    return "Type description not available";
+}
+function extractInvariants(content) {
+    // Extract invariants from comments and code
+    return [];
+}
+function extractConstraints(content) {
+    // Extract constraints from comments and code
+    return [];
+}
+function extractAssumptions(content) {
+    // Extract assumptions from comments and code
+    return [];
+}
+function extractStateManagement(content) {
+    return "State management analysis not implemented";
+}
+function extractErrorHandling(content) {
+    return "Error handling analysis not implemented";
+}
+function extractPerformanceConsiderations(content) {
+    return "Performance considerations not analyzed";
+}
+function extractSecurityConsiderations(content) {
+    return "Security considerations not analyzed";
+}
+function getFileTypeDescription(extension) {
+    const descriptions = {
+        '.ts': 'TypeScript source file',
+        '.js': 'JavaScript source file',
+        '.tsx': 'TypeScript React component',
+        '.jsx': 'JavaScript React component',
+        '.py': 'Python source file',
+        '.go': 'Go source file',
+        '.rs': 'Rust source file',
+        '.cpp': 'C++ source file',
+        '.c': 'C source file'
+    };
+    return descriptions[extension] || 'Unknown file type';
+}
+async function extractDependencies(content) {
+    // Extract dependency information from imports
+    return extractImports(content);
+}

package/dist/git-worktree.d.ts

@@ -0,0 +1,3 @@
+export declare function gitWorktreeTools(): {
+    [key: string]: any;
+};