opencode-autognosis 2.0.5 → 2.3.0

package/dist/performance-optimization.js

@@ -8,6 +8,7 @@ import * as crypto from "node:crypto";
 import { getDb } from "./database.js";
 import { CHUNK_DIR, ensureChunkDir, calculateHash, calculateComplexity, parseFileAST, generateSummaryChunk, generateApiChunk, generateInvariantChunk, extractDependencies, extractSymbolsFromAST, extractSymbols } from "./chunk-cards.js";
 import { Logger } from "./services/logger.js";
+import { tui } from "./services/tui.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -606,7 +607,7 @@ async function getAllSourceFiles() {
     await scanDirectory(PROJECT_ROOT);
     return sourceFiles;
 }
-async function indexFile(filePath) {
+export async function indexFile(filePath) {
     try {
         const content = await fs.readFile(filePath, 'utf-8');
         await ensureChunkDir();
@@ -711,8 +712,11 @@ async function runBackgroundIndexing(taskId, indexingState) {
             processed++;
             // Update progress periodically
             if (processed % 5 === 0 || processed === total) {
-                task.progress = Math.round((processed / total) * 100);
+                const progress = Math.round((processed / total) * 100);
+                task.progress = progress;
                 await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+                // Stream to TUI
+                await tui.showProgress("Codebase Indexing", progress, `Processing: ${file}`);
             }
         }
         // Complete task
@@ -720,6 +724,7 @@ async function runBackgroundIndexing(taskId, indexingState) {
         task.completed_at = new Date().toISOString();
         task.progress = 100;
         await fs.writeFile(taskPath, JSON.stringify(task, null, 2));
+        await tui.showSuccess("Indexing Complete", `Processed ${total} files.`);
     }
     catch (error) {
         // Update task with error

package/dist/services/mlx.d.ts

@@ -0,0 +1,8 @@
+export declare const DEFAULT_MLX_MODEL = "sentence-transformers/all-MiniLM-L6-v2";
+export declare class MLXService {
+    private isAvailable;
+    checkAvailability(): Promise<boolean>;
+    setup(): Promise<string>;
+    getEmbedding(text: string, model?: string): Promise<number[]>;
+}
+export declare const mlxService: MLXService;

package/dist/services/mlx.js

@@ -0,0 +1,53 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Logger } from "./logger.js";
+const execAsync = promisify(exec);
+export const DEFAULT_MLX_MODEL = "sentence-transformers/all-MiniLM-L6-v2";
+export class MLXService {
+    isAvailable = null;
+    async checkAvailability() {
+        if (this.isAvailable !== null)
+            return this.isAvailable;
+        try {
+            await execAsync('python3 -c "import mlx.core; import sentence_transformers"');
+            this.isAvailable = true;
+        }
+        catch {
+            this.isAvailable = false;
+        }
+        return this.isAvailable;
+    }
+    async setup() {
+        try {
+            Logger.log("MLX", "Setting up MLX dependencies...");
+            await execAsync("pip3 install mlx sentence-transformers huggingface_hub");
+            this.isAvailable = true;
+            return "MLX and sentence-transformers installed successfully.";
+        }
+        catch (error) {
+            throw new Error(`MLX setup failed: ${error.message}`);
+        }
+    }
+    async getEmbedding(text, model = DEFAULT_MLX_MODEL) {
+        if (!text || !text.trim())
+            return [];
+        // Escape text for python string
+        const escapedText = text.replace(/"/g, '\\"').replace(/\n/g, ' ');
+        // MLX optimized sentence-transformers execution
+        const pyScript = "\nimport mlx.core as mx\nfrom sentence_transformers import SentenceTransformer\nimport json\nimport sys\n\ntry:\n    model = SentenceTransformer(\"${model}\")\n    # Move to GPU if available (MLX default)\n    embeddings = model.encode([\"${escapedText}\"])\n    print(json.dumps(embeddings[0].tolist()))\nexcept Exception as e:\n    print(json.dumps({\"error\": str(e)}))\n    sys.exit(1)\n";
+        try {
+            const { stdout } = await execAsync(`python3 -c '${pyScript}'`);
+            const result = JSON.parse(stdout);
+            if (result.error)
+                throw new Error(result.error);
+            return result;
+        }
+        catch (error) {
+            Logger.log("MLX", "Embedding failed", error);
+            return [];
+        }
+    }
+}
+export const mlxService = new MLXService();

package/dist/services/policy.d.ts

@@ -0,0 +1,12 @@
+export interface PolicyViolation {
+    file: string;
+    line: number;
+    message: string;
+    severity: "error" | "warning";
+}
+export declare class PolicyEngine {
+    private rules;
+    checkContent(file: string, content: string): PolicyViolation[];
+    checkDiff(diff: string): PolicyViolation[];
+}
+export declare const policyEngine: PolicyEngine;

package/dist/services/policy.js

@@ -0,0 +1,59 @@
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import { Logger } from "./logger.js";
+export class PolicyEngine {
+    rules = [
+        {
+            name: "No Debug Logs",
+            pattern: /console\.(log|debug|info)\(/,
+            message: "Direct console logging is forbidden in production code.",
+            severity: "error"
+        },
+        {
+            name: "No TODO Debt",
+            pattern: /\/\/\s*TODO/,
+            message: "New TODOs must be linked to a ticket ID.",
+            severity: "warning"
+        },
+        {
+            name: "Forbidden Eval",
+            pattern: /eval\(/,
+            message: "Use of 'eval' is strictly forbidden for security reasons.",
+            severity: "error"
+        }
+    ];
+    checkContent(file, content) {
+        const violations = [];
+        const lines = content.split('\n');
+        for (const rule of this.rules) {
+            lines.forEach((line, index) => {
+                if (rule.pattern.test(line)) {
+                    violations.push({
+                        file,
+                        line: index + 1,
+                        message: rule.message,
+                        severity: rule.severity
+                    });
+                }
+            });
+        }
+        return violations;
+    }
+    checkDiff(diff) {
+        // Check only added lines in diffs
+        const addedLines = diff.split('\n').filter(l => l.startsWith('+') && !l.startsWith('+++'));
+        const violations = [];
+        for (const rule of this.rules) {
+            if (rule.pattern.test(addedLines.join('\n'))) {
+                violations.push({
+                    file: "diff",
+                    line: 0,
+                    message: `[Policy: ${rule.name}] ${rule.message}`,
+                    severity: rule.severity
+                });
+            }
+        }
+        return violations;
+    }
+}
+export const policyEngine = new PolicyEngine();

package/dist/services/tui.d.ts

@@ -0,0 +1,8 @@
+export declare class TUIService {
+    private client;
+    setClient(client: any): void;
+    showProgress(title: string, progress: number, message: string): Promise<void>;
+    showSuccess(title: string, message: string): Promise<void>;
+    showError(title: string, message: string): Promise<void>;
+}
+export declare const tui: TUIService;

package/dist/services/tui.js

@@ -0,0 +1,43 @@
+export class TUIService {
+    client;
+    setClient(client) {
+        this.client = client;
+    }
+    async showProgress(title, progress, message) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.tui.showToast({
+                body: {
+                    title: `[${progress}%] ${title}`,
+                    message,
+                    variant: "info"
+                }
+            });
+        }
+        catch (e) {
+            // Ignore if TUI not available
+        }
+    }
+    async showSuccess(title, message) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.tui.showToast({
+                body: { title, message, variant: "success" }
+            });
+        }
+        catch (e) { }
+    }
+    async showError(title, message) {
+        if (!this.client)
+            return;
+        try {
+            await this.client.tui.showToast({
+                body: { title, message, variant: "error" }
+            });
+        }
+        catch (e) { }
+    }
+}
+export const tui = new TUIService();

package/dist/services/watcher.d.ts

@@ -0,0 +1,8 @@
+export declare class CodeWatcher {
+    private watcher;
+    start(): void;
+    stop(): void;
+    private handleFileChange;
+    private handleFileDelete;
+}
+export declare const codeWatcher: CodeWatcher;

package/dist/services/watcher.js

@@ -0,0 +1,50 @@
+import chokidar, { FSWatcher } from "chokidar";
+import * as path from "node:path";
+import { indexFile } from "../performance-optimization.js";
+import { Logger } from "./logger.js";
+const PROJECT_ROOT = process.cwd();
+export class CodeWatcher {
+    watcher = null;
+    start() {
+        if (this.watcher)
+            return;
+        Logger.log("Watcher", "Starting live codebase watcher...");
+        this.watcher = chokidar.watch(PROJECT_ROOT, {
+            ignored: [
+                "**/node_modules/**",
+                "**/dist/**",
+                "**/build/**",
+                "**/.opencode/**"
+            ],
+            persistent: true,
+            ignoreInitial: true
+        });
+        this.watcher
+            .on("add", (filePath) => this.handleFileChange("added", filePath))
+            .on("change", (filePath) => this.handleFileChange("changed", filePath))
+            .on("unlink", (filePath) => this.handleFileDelete(filePath));
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+    }
+    async handleFileChange(event, filePath) {
+        const ext = path.extname(filePath);
+        const supportedExts = [".ts", ".js", ".tsx", ".jsx", ".cpp", ".c", ".h", ".hpp", ".swift", ".py", ".go", ".rs"];
+        if (supportedExts.includes(ext)) {
+            Logger.log("Watcher", `File ${event}: ${filePath}`);
+            try {
+                await indexFile(filePath);
+            }
+            catch (e) {
+                Logger.log("Watcher", `Failed to index ${filePath}`, e);
+            }
+        }
+    }
+    handleFileDelete(filePath) {
+        Logger.log("Watcher", `File deleted: ${filePath}`);
+    }
+}
+export const codeWatcher = new CodeWatcher();

package/dist/system-tools.js

@@ -7,6 +7,7 @@ import { promisify } from "node:util";
 import * as crypto from "node:crypto";
 import { Logger } from "./services/logger.js";
 import { getDb } from "./database.js";
+import { tui } from "./services/tui.js";
 const execAsync = promisify(exec);
 const PROJECT_ROOT = process.cwd();
 const OPENCODE_DIR = path.join(PROJECT_ROOT, ".opencode");
@@ -305,10 +306,12 @@ export function systemTools() {
                 // Spawn background worker
                 (async () => {
                     getDb().updateJob(jobId, { status: "running", progress: 10 });
+                    await tui.showProgress("Patch Validation", 10, "Creating temporary worktree...");
                     const tempWorktree = path.join(PROJECT_ROOT, ".opencode", "temp-" + jobId);
                     try {
                         await runCmd(`git worktree add -d "${tempWorktree}"`);
                         getDb().updateJob(jobId, { progress: 30 });
+                        await tui.showProgress("Patch Validation", 30, "Applying diff...");
                         const content = await fs.readFile(patch_path, "utf-8");
                         const parts = content.split('\n\n');
                         const diffOnly = parts.length > 1 ? parts.slice(1).join('\n\n') : content;
@@ -318,6 +321,7 @@ export function systemTools() {
                         if (applyError)
                             throw new Error(`Apply failed: ${applyError.message}`);
                         getDb().updateJob(jobId, { progress: 60 });
+                        await tui.showProgress("Patch Validation", 60, "Running build verification...");
                         let buildStatus = "SKIPPED";
                         if (fsSync.existsSync(path.join(tempWorktree, "package.json"))) {
                             const { error: buildError } = await runCmd("npm run build", tempWorktree);
@@ -332,9 +336,11 @@ export function systemTools() {
                             progress: 100,
                             result: JSON.stringify({ apply: "OK", build: buildStatus })
                         });
+                        await tui.showSuccess("Validation Complete", `Apply: OK, Build: ${buildStatus}`);
                     }
                     catch (error) {
                         getDb().updateJob(jobId, { status: "failed", error: error.message });
+                        await tui.showError("Validation Failed", error.message);
                     }
                     finally {
                         try {