astrocode-workflow 0.3.0 → 0.3.2

package/dist/test/integration/injection-metrics.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { injectChatPrompt } from '../../src/ui/inject';
+import { metrics } from '../../src/shared/metrics';
+describe('Injection Integration Tests', () => {
+    beforeEach(() => {
+        metrics.clear();
+    });
+    afterEach(() => {
+        metrics.clear();
+    });
+    it('should record successful injection metrics', async () => {
+        const mockCtx = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockResolvedValue(undefined)
+                }
+            },
+            sessionID: 'test-session-123'
+        };
+        await injectChatPrompt({
+            ctx: mockCtx,
+            sessionId: 'test-session-123',
+            text: 'Test message',
+            agent: 'TestAgent'
+        });
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(1);
+        expect(injectionStats.successful).toBe(1);
+        expect(injectionStats.failed).toBe(0);
+        expect(injectionStats.successRate).toBe(1);
+        expect(injectionStats.avgAttempts).toBe(1);
+        expect(injectionStats.avgDuration).toBeGreaterThan(0);
+    });
+    it('should record failed injection metrics', async () => {
+        const mockCtx = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockRejectedValue(new Error('API unavailable'))
+                }
+            },
+            sessionID: 'test-session-456'
+        };
+        await expect(injectChatPrompt({
+            ctx: mockCtx,
+            sessionId: 'test-session-456',
+            text: 'Test message that will fail',
+            agent: 'TestAgent'
+        })).rejects.toThrow('API unavailable');
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(1);
+        expect(injectionStats.successful).toBe(0);
+        expect(injectionStats.failed).toBe(1);
+        expect(injectionStats.successRate).toBe(0);
+    });
+    it('should handle per-session queuing correctly', async () => {
+        const mockCtx1 = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockResolvedValue(undefined)
+                }
+            },
+            sessionID: 'session-1'
+        };
+        const mockCtx2 = {
+            client: {
+                session: {
+                    prompt: vi.fn().mockResolvedValue(undefined)
+                }
+            },
+            sessionID: 'session-2'
+        };
+        // Start multiple injections for different sessions
+        const promise1 = injectChatPrompt({
+            ctx: mockCtx1,
+            sessionId: 'session-1',
+            text: 'Message 1',
+            agent: 'Agent1'
+        });
+        const promise2 = injectChatPrompt({
+            ctx: mockCtx2,
+            sessionId: 'session-2',
+            text: 'Message 2',
+            agent: 'Agent2'
+        });
+        const promise3 = injectChatPrompt({
+            ctx: mockCtx1,
+            sessionId: 'session-1',
+            text: 'Message 3',
+            agent: 'Agent1'
+        });
+        await Promise.all([promise1, promise2, promise3]);
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(3);
+        expect(injectionStats.successful).toBe(3);
+    });
+    it('should record errors for permanently failed injections', async () => {
+        const mockCtx = {
+            client: {
+                session: {
+                    prompt: vi.fn()
+                        .mockRejectedValueOnce(new Error('Attempt 1'))
+                        .mockRejectedValueOnce(new Error('Attempt 2'))
+                        .mockRejectedValueOnce(new Error('Attempt 3'))
+                        .mockRejectedValueOnce(new Error('Attempt 4'))
+                }
+            },
+            sessionID: 'failing-session'
+        };
+        await expect(injectChatPrompt({
+            ctx: mockCtx,
+            sessionId: 'failing-session',
+            text: 'This will fail permanently',
+            agent: 'FailingAgent'
+        })).rejects.toThrow();
+        const injectionStats = metrics.getInjectionStats();
+        expect(injectionStats).toBeTruthy();
+        expect(injectionStats.total).toBe(1);
+        expect(injectionStats.successful).toBe(0);
+        expect(injectionStats.failed).toBe(1);
+        expect(injectionStats.avgAttempts).toBe(4); // Should try 4 times
+        // Check that error was recorded
+        const systemMetrics = metrics.getMetrics();
+        expect(systemMetrics.errors.length).toBeGreaterThan(0);
+        expect(systemMetrics.errors.some(e => e.type === 'injection_failure')).toBe(true);
+    });
+});

package/dist/tools/health.d.ts

@@ -0,0 +1,8 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+export declare function createAstroHealthTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/tools/health.js

@@ -0,0 +1,119 @@
+// src/tools/health.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import { getSchemaVersion } from "../state/db";
+import { getActiveRun } from "../workflow/state-machine";
+import fs from "node:fs";
+import path from "node:path";
+export function createAstroHealthTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Check Astrocode health: DB status, locks, schema, active runs, recent events.",
+        args: {},
+        execute: async () => {
+            const lines = [];
+            const repoRoot = ctx.directory || process.cwd();
+            const dbPath = config.db?.path || ".astro/astro.db";
+            const fullDbPath = path.resolve(repoRoot, dbPath);
+            // System info
+            lines.push("# Astrocode Health Check");
+            lines.push(`- PID: ${process.pid || "unknown"}`);
+            lines.push(`- Repo: ${repoRoot}`);
+            lines.push(`- DB Path: ${fullDbPath}`);
+            // Lock status
+            const lockPath = `${repoRoot}/.astro/astro.lock`;
+            try {
+                if (fs.existsSync(lockPath)) {
+                    const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+                    const parts = lockContent.split(" ");
+                    if (parts.length >= 2) {
+                        const pid = parseInt(parts[0]);
+                        const startedAt = parts[1];
+                        // Check if PID is still running
+                        try {
+                            process.kill(pid, 0); // Signal 0 just checks if process exists
+                            lines.push(`- Lock: HELD by PID ${pid} (started ${startedAt})`);
+                        }
+                        catch {
+                            lines.push(`- Lock: STALE (PID ${pid} not running, started ${startedAt})`);
+                            lines.push(`  → Run: rm "${lockPath}"`);
+                        }
+                    }
+                    else {
+                        lines.push(`- Lock: MALFORMED (${lockContent})`);
+                    }
+                }
+                else {
+                    lines.push(`- Lock: NONE (no lock file)`);
+                }
+            }
+            catch (e) {
+                lines.push(`- Lock: ERROR (${String(e)})`);
+            }
+            // DB file status
+            const dbExists = fs.existsSync(fullDbPath);
+            const walExists = fs.existsSync(`${fullDbPath}-wal`);
+            const shmExists = fs.existsSync(`${fullDbPath}-shm`);
+            lines.push(`- DB Files:`);
+            lines.push(`  - Main: ${dbExists ? "EXISTS" : "MISSING"}`);
+            lines.push(`  - WAL: ${walExists ? "EXISTS" : "MISSING"}`);
+            lines.push(`  - SHM: ${shmExists ? "EXISTS" : "MISSING"}`);
+            if (!dbExists) {
+                lines.push(`- STATUS: DB MISSING - run astro_init first`);
+                return lines.join("\n");
+            }
+            // Schema version
+            try {
+                const schemaVersion = getSchemaVersion(db);
+                lines.push(`- Schema Version: ${schemaVersion}`);
+            }
+            catch (e) {
+                lines.push(`- Schema Version: ERROR (${String(e)})`);
+                lines.push(`- STATUS: DB CORRUPTED`);
+                return lines.join("\n");
+            }
+            // Active run
+            try {
+                const activeRun = getActiveRun(db);
+                if (activeRun) {
+                    lines.push(`- Active Run: ${activeRun.run_id} (${activeRun.status})`);
+                    lines.push(`  - Story: ${activeRun.story_key}`);
+                    lines.push(`  - Stage: ${activeRun.current_stage_key || "none"}`);
+                    lines.push(`  - Started: ${activeRun.started_at}`);
+                }
+                else {
+                    lines.push(`- Active Run: NONE`);
+                }
+            }
+            catch (e) {
+                lines.push(`- Active Run: ERROR (${String(e)})`);
+            }
+            // Recent events
+            try {
+                const events = db.prepare(`
+          SELECT event_id, run_id, stage_key, type, created_at
+          FROM events
+          ORDER BY created_at DESC
+          LIMIT 10
+        `).all();
+                lines.push(`- Recent Events (${events.length}):`);
+                for (const event of events) {
+                    const stage = event.stage_key ? `/${event.stage_key}` : "";
+                    lines.push(`  - ${event.created_at}: ${event.type} (${event.run_id || "global"}${stage})`);
+                }
+            }
+            catch (e) {
+                lines.push(`- Recent Events: ERROR (${String(e)})`);
+            }
+            // Status summary
+            lines.push(``);
+            lines.push(`## Status`);
+            lines.push(`✅ DB accessible`);
+            lines.push(`✅ Schema valid`);
+            lines.push(`✅ Lock file checked`);
+            if (walExists || shmExists) {
+                lines.push(`⚠️ WAL/SHM files present - indicates unclean shutdown or active transaction`);
+            }
+            return lines.join("\n");
+        },
+    });
+}

package/dist/tools/index.js

@@ -8,6 +8,9 @@ import { createAstroStageStartTool, createAstroStageCompleteTool, createAstroSta
 import { createAstroArtifactPutTool, createAstroArtifactListTool, createAstroArtifactGetTool } from "./artifacts";
 import { createAstroInjectPutTool, createAstroInjectListTool, createAstroInjectSearchTool, createAstroInjectGetTool, createAstroInjectEligibleTool, createAstroInjectDebugDueTool } from "./injects";
 import { createAstroRepairTool } from "./repair";
+import { createAstroHealthTool } from "./health";
+import { createAstroResetTool } from "./reset";
+import { createAstroMetricsTool } from "./metrics";
 export function createAstroTools(opts) {
     const { ctx, config, agents, runtime } = opts;
     const { db } = runtime;
@@ -16,6 +19,9 @@ export function createAstroTools(opts) {
     // Always available tools (work without database - guaranteed DB-independent)
     tools.astro_status = createAstroStatusTool({ ctx, config });
     tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
+    tools.astro_health = createAstroHealthTool({ ctx, config, db });
+    tools.astro_reset = createAstroResetTool({ ctx, config, db });
+    tools.astro_metrics = createAstroMetricsTool({ ctx, config });
     // Recovery tool - available even in limited mode to allow DB initialization
     tools.astro_init = createAstroInitTool({ ctx, config, runtime });
     // Database-dependent tools
@@ -74,6 +80,9 @@ export function createAstroTools(opts) {
         ["_astro_inject_eligible", "astro_inject_eligible"],
         ["_astro_inject_debug_due", "astro_inject_debug_due"],
         ["_astro_repair", "astro_repair"],
+        ["_astro_health", "astro_health"],
+        ["_astro_reset", "astro_reset"],
+        ["_astro_metrics", "astro_metrics"],
     ];
     // Only add aliases for tools that exist
     for (const [alias, target] of aliases) {

package/dist/tools/metrics.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+type CreateAstroMetricsToolOptions = {
+    ctx: any;
+    config: any;
+};
+export declare function createAstroMetricsTool(opts: CreateAstroMetricsToolOptions): ToolDefinition;
+export {};

package/dist/tools/metrics.js

@@ -0,0 +1,61 @@
+// src/tools/metrics.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import { metrics } from "../shared/metrics";
+export function createAstroMetricsTool(opts) {
+    return tool({
+        description: "Get performance metrics for Astrocode operations including transaction times, injection success rates, and error statistics.",
+        args: {},
+        execute: async () => {
+            return runMetricsTool();
+        },
+    });
+}
+function runMetricsTool() {
+    const stats = metrics.getMetrics();
+    const txStats = metrics.getTransactionStats();
+    const injectionStats = metrics.getInjectionStats();
+    let output = "# Astrocode Performance Metrics\n\n";
+    // Transaction Stats
+    if (txStats) {
+        output += "## Database Transactions\n\n";
+        output += `**Total:** ${txStats.total}\n`;
+        output += `**Success Rate:** ${(txStats.successRate * 100).toFixed(1)}% (${txStats.successful}/${txStats.total})\n`;
+        output += `**Average Duration:** ${txStats.avgDuration.toFixed(2)}ms\n`;
+        output += `**Duration Range:** ${txStats.minDuration}ms - ${txStats.maxDuration}ms\n`;
+        output += `**Average Nesting Depth:** ${txStats.avgNestedDepth.toFixed(1)}\n\n`;
+    }
+    else {
+        output += "## Database Transactions\n\nNo transaction data available.\n\n";
+    }
+    // Injection Stats
+    if (injectionStats) {
+        output += "## UI Injections\n\n";
+        output += `**Total:** ${injectionStats.total}\n`;
+        output += `**Success Rate:** ${(injectionStats.successRate * 100).toFixed(1)}% (${injectionStats.successful}/${injectionStats.total})\n`;
+        output += `**Average Attempts:** ${injectionStats.avgAttempts.toFixed(1)}\n`;
+        output += `**Total Retries:** ${injectionStats.totalRetries}\n`;
+        output += `**Average Duration:** ${injectionStats.avgDuration.toFixed(2)}ms\n\n`;
+    }
+    else {
+        output += "## UI Injections\n\nNo injection data available.\n\n";
+    }
+    // Recent Errors
+    if (stats.errors.length > 0) {
+        output += "## Recent Errors\n\n";
+        const recentErrors = stats.errors.slice(-10); // Last 10 errors
+        for (const error of recentErrors) {
+            const timestamp = new Date(error.timestamp).toISOString();
+            output += `- **[${error.type}]** ${timestamp}: ${error.message}\n`;
+        }
+        output += "\n";
+    }
+    else {
+        output += "## Recent Errors\n\nNo errors recorded.\n\n";
+    }
+    // Raw Data Summary
+    output += "## Data Summary\n\n";
+    output += `**Transactions Tracked:** ${stats.transactions.length}\n`;
+    output += `**Injections Tracked:** ${stats.injections.length}\n`;
+    output += `**Errors Recorded:** ${stats.errors.length}\n`;
+    return output;
+}

package/dist/tools/reset.d.ts

@@ -0,0 +1,8 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+export declare function createAstroResetTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/tools/reset.js

@@ -0,0 +1,92 @@
+// src/tools/reset.ts
+import { tool } from "@opencode-ai/plugin/tool";
+import fs from "node:fs";
+import path from "node:path";
+export function createAstroResetTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Reset Astrocode database: safely delete all DB files and WAL/SHM after killing concurrent processes.",
+        args: {
+            confirm: tool.schema.string().default("").describe("Type 'RESET' to confirm destructive operation"),
+        },
+        execute: async ({ confirm }) => {
+            if (confirm !== "RESET") {
+                return [
+                    "❌ Reset cancelled - confirmation required",
+                    "",
+                    "This operation will:",
+                    "- Delete .astro/astro.db",
+                    "- Delete .astro/astro.db-wal (if exists)",
+                    "- Delete .astro/astro.db-shm (if exists)",
+                    "- Lose all workflow data, stories, runs, artifacts",
+                    "",
+                    "To confirm: astro_reset(confirm=\"RESET\")",
+                ].join("\n");
+            }
+            const repoRoot = ctx.directory || process.cwd();
+            const dbPath = config.db?.path || ".astro/astro.db";
+            const fullDbPath = path.resolve(repoRoot, dbPath);
+            const lines = [];
+            lines.push("🗑️ Astrocode Database Reset");
+            lines.push(`- Repo: ${repoRoot}`);
+            lines.push(`- Target: ${fullDbPath}`);
+            // Check for lock file
+            const lockPath = `${repoRoot}/.astro/astro.lock`;
+            if (fs.existsSync(lockPath)) {
+                try {
+                    const lockContent = fs.readFileSync(lockPath, "utf8").trim();
+                    const pid = parseInt(lockContent.split(" ")[0]);
+                    lines.push(`- Lock file found for PID ${pid}`);
+                    // Try to kill the process
+                    try {
+                        process.kill(pid, 'SIGTERM');
+                        lines.push(`- Sent SIGTERM to PID ${pid}, waiting 2s...`);
+                        await new Promise(resolve => setTimeout(resolve, 2000));
+                    }
+                    catch (e) {
+                        lines.push(`- Could not kill PID ${pid}: ${String(e)}`);
+                    }
+                }
+                catch (e) {
+                    lines.push(`- Error reading lock file: ${String(e)}`);
+                }
+            }
+            // Delete DB files
+            const filesToDelete = [
+                fullDbPath,
+                `${fullDbPath}-wal`,
+                `${fullDbPath}-shm`,
+                lockPath,
+            ];
+            let deletedCount = 0;
+            for (const filePath of filesToDelete) {
+                try {
+                    if (fs.existsSync(filePath)) {
+                        fs.unlinkSync(filePath);
+                        lines.push(`- Deleted: ${path.relative(repoRoot, filePath)}`);
+                        deletedCount++;
+                    }
+                    else {
+                        lines.push(`- Skipped: ${path.relative(repoRoot, filePath)} (not found)`);
+                    }
+                }
+                catch (e) {
+                    lines.push(`- Failed to delete ${path.relative(repoRoot, filePath)}: ${String(e)}`);
+                }
+            }
+            lines.push(``);
+            if (deletedCount > 0) {
+                lines.push(`✅ Reset complete - ${deletedCount} files deleted`);
+                lines.push(``);
+                lines.push(`Next steps:`);
+                lines.push(`1. Run: astro_init`);
+                lines.push(`2. Run: astro_status`);
+                lines.push(`3. Import your stories and restart workflow`);
+            }
+            else {
+                lines.push(`ℹ️ No files found to delete`);
+            }
+            return lines.join("\n");
+        },
+    });
+}