astrocode-workflow 0.3.1 → 0.3.3

package/src/tools/health.ts

@@ -0,0 +1,128 @@
+// src/tools/health.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+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: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  const { ctx, config, db } = opts;
+
+  return tool({
+    description: "Check Astrocode health: DB status, locks, schema, active runs, recent events.",
+    args: {},
+    execute: async () => {
+      const lines: string[] = [];
+      const repoRoot = (ctx as any).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 as any).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 as any).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() as any[];
+
+        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/src/tools/index.ts

@@ -12,6 +12,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";
 
 import { AgentConfig } from "@opencode-ai/sdk";
 
@@ -35,9 +38,12 @@ export function createAstroTools(opts: CreateAstroToolsOptions): Record<string,
 
   const tools: Record<string, ToolDefinition> = {};
 
-   // Always available tools (work without database - guaranteed DB-independent)
-    tools.astro_status = createAstroStatusTool({ ctx, config });
-    tools.astro_spec_get = createAstroSpecGetTool({ ctx, config });
+    // 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 });
@@ -100,6 +106,9 @@ export function createAstroTools(opts: CreateAstroToolsOptions): Record<string,
     ["_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

package/src/tools/init.ts

@@ -8,6 +8,7 @@ import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
 
+
 type RuntimeState = {
   db: SqliteDb | null;
   limitedMode: boolean;
@@ -29,14 +30,14 @@ export function createAstroInitTool(opts: { ctx: any; config: AstrocodeConfig; r
     },
     execute: async ({ ensure_spec, spec_placeholder }) => {
       const repoRoot = ctx.directory as string;
-      const paths = getAstroPaths(repoRoot, config.db.path);
-      ensureAstroDirs(paths);
+          const paths = getAstroPaths(repoRoot, config.db.path);
+          ensureAstroDirs(paths);
 
-      const hadDbAlready = !!runtime.db;
-      let db: SqliteDb | null = runtime.db;
-      let publishedToRuntime = false;
+          const hadDbAlready = !!runtime.db;
+          let db: SqliteDb | null = runtime.db;
+          let publishedToRuntime = false;
 
-      try {
+          try {
         if (!db) {
           try {
             db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });

package/src/tools/metrics.ts

@@ -0,0 +1,71 @@
+// src/tools/metrics.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import { metrics } from "../shared/metrics";
+
+type CreateAstroMetricsToolOptions = {
+  ctx: any;
+  config: any;
+};
+
+export function createAstroMetricsTool(opts: CreateAstroMetricsToolOptions): ToolDefinition {
+  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(): string {
+  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/src/tools/repair.ts

@@ -6,6 +6,7 @@ import { repairState, formatRepairReport } from "../workflow/repair";
 import { putArtifact } from "../workflow/artifacts";
 import { nowISO } from "../shared/time";
 
+
 export function createAstroRepairTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { ctx, config, db } = opts;
 

package/src/tools/reset.ts

@@ -0,0 +1,100 @@
+// src/tools/reset.ts
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { AstrocodeConfig } from "../config/schema";
+import type { SqliteDb } from "../state/db";
+import fs from "node:fs";
+import path from "node:path";
+
+export function createAstroResetTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
+  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 as any).directory || process.cwd();
+      const dbPath = config.db?.path || ".astro/astro.db";
+      const fullDbPath = path.resolve(repoRoot, dbPath);
+
+      const lines: string[] = [];
+      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 as any).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");
+    },
+  });
+}

package/src/tools/stage.ts

@@ -14,6 +14,7 @@ import { failRun, getActiveRun, getStageRuns, startStage, completeRun } from "..
 import { newEventId, newId } from "../state/ids";
 import { insertStory } from "../workflow/story-helpers";
 
+
 function nextStageKey(pipeline: StageKey[], current: StageKey): StageKey | null {
   const i = pipeline.indexOf(current);
   if (i === -1) return null;

package/src/tools/status.ts

@@ -3,6 +3,7 @@ import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { decideNextAction, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
 
+
 function statusIcon(status: string): string {
   switch (status) {
     case "running":
@@ -36,7 +37,7 @@ function stageIcon(status: string): string {
 }
 
 export function createAstroStatusTool(opts: { ctx: any; config: AstrocodeConfig; db?: SqliteDb | null }): ToolDefinition {
-  const { config, db } = opts;
+  const { ctx, config, db } = opts;
 
   return tool({
     description: "Show a compact Astrocode status dashboard: active run/stage, pipeline, story board counts, and next action.",

package/src/tools/story.ts

@@ -8,6 +8,7 @@ import type { StoryState } from "../state/types";
 import { insertStory } from "../workflow/story-helpers";
 
 
+
 export function createAstroStoryQueueTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
   const { db } = opts;
 

package/src/tools/workflow.ts

@@ -1,5 +1,6 @@
 // src/tools/workflow.ts
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
+import path from "node:path";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
 import { withTx } from "../state/db";
@@ -19,9 +20,12 @@ import { buildStageDirective, directiveHash } from "../workflow/directives";
 import { injectChatPrompt } from "../ui/inject";
 import { nowISO } from "../shared/time";
 import { newEventId } from "../state/ids";
+
 import { debug } from "../shared/log";
 import { createToastManager } from "../ui/toasts";
 import type { AgentConfig } from "@opencode-ai/sdk";
+import { acquireRepoLock } from "../state/repo-lock";
+import { workflowRepoLock } from "../state/workflow-repo-lock";
 
 // Agent name mapping for case-sensitive resolution
 export const STAGE_TO_AGENT_MAP: Record<string, string> = {
@@ -184,8 +188,19 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       max_steps: tool.schema.number().int().positive().default(config.workflow.default_max_steps),
     },
     execute: async ({ mode, max_steps }) => {
+      const repoRoot = (ctx as any).directory as string;
+      const lockPath = path.join(repoRoot, ".astro", "astro.lock");
       const sessionId = (ctx as any).sessionID as string | undefined;
-      const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
+
+      return workflowRepoLock(
+        { acquireRepoLock },
+        {
+          lockPath,
+          repoRoot,
+          sessionId,
+          owner: "astro_workflow_proceed",
+          fn: async () => {
+        const steps = Math.min(max_steps, config.workflow.loop_max_steps_hard_cap);
 
       const actions: string[] = [];
       const warnings: string[] = [];
@@ -408,6 +423,8 @@ export function createAstroWorkflowProceedTool(opts: { ctx: any; config: Astroco
       }
 
       return lines.join("\n").trim();
+          },
+        });
     },
   });
 }

package/src/ui/inject.ts

@@ -1,4 +1,5 @@
 // src/ui/inject.ts
+import { recordInjection, recordError } from "../shared/metrics";
 type InjectionItem = {
   ctx: any;
   sessionId: string;
@@ -33,16 +34,26 @@ async function tryInjectOnce(item: InjectionItem): Promise<void> {
   const { ctx, sessionId, text, agent = "Astro" } = item;
   const prefixedText = `[${agent}]\n\n${text}`;
 
-  const { session, prompt } = getPromptInvoker(ctx);
+  const injectionRecorder = recordInjection({ sessionId, attempts: item.attempts + 1, agent });
+  const injectionStart = injectionRecorder.start();
 
-  // IMPORTANT: force correct `this` binding
-  await prompt.call(session, {
-    path: { id: sessionId },
-    body: {
-      parts: [{ type: "text", text: prefixedText }],
-      agent,
-    },
-  });
+  try {
+    const { session, prompt } = getPromptInvoker(ctx);
+
+    // IMPORTANT: force correct `this` binding
+    await prompt.call(session, {
+      path: { id: sessionId },
+      body: {
+        parts: [{ type: "text", text: prefixedText }],
+        agent,
+      },
+    });
+
+    injectionRecorder.end(injectionStart, true);
+  } catch (error) {
+    injectionRecorder.end(injectionStart, false);
+    throw error;
+  }
 }
 
 async function runSessionQueue(sessionId: string) {
@@ -69,6 +80,7 @@ async function runSessionQueue(sessionId: string) {
           console.warn(
             `[Astrocode] Injection failed permanently after ${item.attempts} attempts: ${msg}`
           );
+          recordError("injection_failure", `Injection failed after ${item.attempts} attempts: ${msg}`);
           item.reject(err);
           continue;
         }