astrocode-workflow 0.4.0 → 0.4.2

package/dist/src/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/src/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/src/tools/repair.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 createAstroRepairTool(opts: {
+    ctx: any;
+    config: AstrocodeConfig;
+    db: SqliteDb;
+}): ToolDefinition;

package/dist/src/tools/repair.js

@@ -0,0 +1,26 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { withTx } from "../state/db";
+import { repairState, formatRepairReport } from "../workflow/repair";
+import { putArtifact } from "../workflow/artifacts";
+import { nowISO } from "../shared/time";
+export function createAstroRepairTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Repair Astrocode invariants and recover from inconsistent DB state. Writes a repair report artifact.",
+        args: {
+            write_report_artifact: tool.schema.boolean().default(true),
+        },
+        execute: async ({ write_report_artifact }) => {
+            const repoRoot = ctx.directory;
+            // Repair database state
+            const report = withTx(db, () => repairState(db, config));
+            const fullMd = formatRepairReport(report);
+            if (write_report_artifact) {
+                const rel = `.astro/repair/repair_${nowISO().replace(/[:.]/g, "-")}.md`;
+                const a = putArtifact({ repoRoot, db, run_id: null, stage_key: null, type: "log", rel_path: rel, content: fullMd, meta: { kind: "repair" } });
+                return fullMd + `\n\nReport saved: ${rel} (artifact=${a.artifact_id})`;
+            }
+            return fullMd;
+        },
+    });
+}

package/dist/src/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/src/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");
+        },
+    });
+}

package/dist/src/tools/run.d.ts

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

package/dist/src/tools/run.js

@@ -0,0 +1,54 @@
+import { tool } from "@opencode-ai/plugin/tool";
+import { abortRun, getActiveRun, getStageRuns, getStory } from "../workflow/state-machine";
+export function createAstroRunGetTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Get run details (and stage run statuses). Defaults to active run if run_id omitted.",
+        args: {
+            run_id: tool.schema.string().optional(),
+            include_stage_summaries: tool.schema.boolean().default(false),
+        },
+        execute: async ({ run_id, include_stage_summaries }) => {
+            const active = getActiveRun(db);
+            const rid = run_id ?? active?.run_id;
+            if (!rid)
+                return "No active run.";
+            const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(rid);
+            if (!run)
+                throw new Error(`Run not found: ${rid}`);
+            const story = getStory(db, run.story_key);
+            const stages = getStageRuns(db, rid);
+            const lines = [];
+            lines.push(`# Run ${rid}`);
+            lines.push(`- Status: **${run.status}**`);
+            lines.push(`- Story: \`${run.story_key}\` — ${story?.title ?? "(missing)"}`);
+            lines.push(`- Current stage: \`${run.current_stage_key ?? "?"}\``);
+            lines.push("", "## Stages");
+            for (const s of stages) {
+                lines.push(`- \`${s.stage_key}\` (${s.status})`);
+                if (include_stage_summaries && s.summary_md) {
+                    lines.push(`  - summary: ${s.summary_md.split("\n")[0].slice(0, 120)}${s.summary_md.length > 120 ? "…" : ""}`);
+                }
+            }
+            return lines.join("\n").trim();
+        },
+    });
+}
+export function createAstroRunAbortTool(opts) {
+    const { db } = opts;
+    return tool({
+        description: "Abort a run and unlock its story (returns story to approved). Defaults to active run if run_id omitted.",
+        args: {
+            run_id: tool.schema.string().optional(),
+            reason: tool.schema.string().default("aborted by user"),
+        },
+        execute: async ({ run_id, reason }) => {
+            const active = getActiveRun(db);
+            const rid = run_id ?? active?.run_id;
+            if (!rid)
+                return "No active run to abort.";
+            abortRun(db, rid, reason);
+            return `🛑 Aborted run ${rid}. Reason: ${reason}`;
+        },
+    });
+}

package/dist/src/tools/spec.d.ts

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

package/dist/src/tools/spec.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import { tool } from "@opencode-ai/plugin/tool";
+import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
+import { nowISO } from "../shared/time";
+import { sha256Hex } from "../shared/hash";
+export function createAstroSpecGetTool(opts) {
+    const { ctx, config } = opts;
+    return tool({
+        description: "Get current project spec stored at .astro/spec.md",
+        args: {},
+        execute: async () => {
+            const repoRoot = ctx.directory;
+            const paths = getAstroPaths(repoRoot, config.db.path);
+            ensureAstroDirs(paths);
+            if (!fs.existsSync(paths.specPath))
+                return "No spec found at .astro/spec.md (run astro_init or astro_spec_set).";
+            const md = fs.readFileSync(paths.specPath, "utf-8");
+            return md;
+        },
+    });
+}
+export function createAstroSpecSetTool(opts) {
+    const { ctx, config, db } = opts;
+    return tool({
+        description: "Set/replace the project spec at .astro/spec.md and record its hash in the DB.",
+        args: {
+            spec_md: tool.schema.string().min(1),
+        },
+        execute: async ({ spec_md }) => {
+            if (!db) {
+                return "❌ Database not available. Cannot track spec hash. Astrocode is running in limited mode.";
+            }
+            const repoRoot = ctx.directory;
+            const paths = getAstroPaths(repoRoot, config.db.path);
+            ensureAstroDirs(paths);
+            fs.writeFileSync(paths.specPath, spec_md);
+            const h = sha256Hex(spec_md);
+            const now = nowISO();
+            db.prepare("UPDATE repo_state SET spec_hash_after=?, updated_at=? WHERE id=1").run(h, now);
+            return `✅ Spec updated (${path.relative(repoRoot, paths.specPath)}). sha256=${h}`;
+        },
+    });
+}

package/dist/src/tools/stage.d.ts

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