astrocode-workflow 0.1.58 → 0.2.0

package/src/state/db.ts

@@ -1,3 +1,4 @@
+// src/state/db.ts
 import fs from "node:fs";
 import path from "node:path";
 import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
@@ -13,22 +14,34 @@ function ensureParentDir(filePath: string) {
   fs.mkdirSync(dir, { recursive: true });
 }
 
+function tableExists(db: SqliteDb, tableName: string): boolean {
+  try {
+    const row = db
+      .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?")
+      .get(tableName) as { name?: string } | undefined;
+    return row?.name === tableName;
+  } catch {
+    return false;
+  }
+}
+
 export function openSqlite(dbPath: string, opts?: { busyTimeoutMs?: number }): SqliteDb {
   ensureParentDir(dbPath);
   const adapter = createDatabaseAdapter();
-  const db = adapter.open(dbPath, opts);
-  return db;
+  if (!adapter.isAvailable()) {
+    throw new Error("No SQLite driver available (adapter unavailable).");
+  }
+  return adapter.open(dbPath, opts);
 }
 
-export function configurePragmas(
-  db: SqliteDb,
-  pragmas: {
-    journal_mode?: "WAL" | "DELETE";
-    synchronous?: "NORMAL" | "FULL" | "OFF";
-    foreign_keys?: boolean;
-    temp_store?: "DEFAULT" | "MEMORY" | "FILE";
+export function configurePragmas(db: SqliteDb, pragmas: Record<string, any>) {
+  if (!pragmas || typeof pragmas !== "object") return;
+
+  const known = new Set(["journal_mode", "synchronous", "foreign_keys", "temp_store"]);
+  for (const k of Object.keys(pragmas)) {
+    if (!known.has(k)) warn(`[Astrocode] Unknown pragma ignored: ${k}`);
   }
-) {
+
   if (pragmas.journal_mode) db.pragma(`journal_mode = ${pragmas.journal_mode}`);
   if (pragmas.synchronous) db.pragma(`synchronous = ${pragmas.synchronous}`);
   if (typeof pragmas.foreign_keys === "boolean") db.pragma(`foreign_keys = ${pragmas.foreign_keys ? "ON" : "OFF"}`);
@@ -36,10 +49,12 @@ export function configurePragmas(
 }
 
 /** BEGIN IMMEDIATE transaction helper. */
-export function withTx<T>(db: SqliteDb, fn: () => T): T {
+export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean }): T {
   const adapter = createDatabaseAdapter();
-  if (!adapter.isAvailable()) {
-    // No database available, just run the function
+  const available = adapter.isAvailable();
+
+  if (!available) {
+    if (opts?.require) throw new Error("Database adapter unavailable; transaction required.");
     return fn();
   }
 
@@ -58,61 +73,102 @@ export function withTx<T>(db: SqliteDb, fn: () => T): T {
   }
 }
 
-export function ensureSchema(db: SqliteDb, opts?: { allowAutoMigrate?: boolean; failOnDowngrade?: boolean }) {
-  const adapter = createDatabaseAdapter();
-  if (!adapter.isAvailable()) {
-    // Silent skip for mock adapter
-    return;
+export function getSchemaVersion(db: SqliteDb): number {
+  try {
+    const row = db
+      .prepare("SELECT schema_version FROM repo_state WHERE id = 1")
+      .get() as { schema_version?: number } | undefined;
+    return row?.schema_version ?? 0;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("no such table")) return 0;
+    throw new Error(`Failed to read schema version: ${msg}`);
   }
+}
 
+function migrateStageRunsCreatedAt(db: SqliteDb) {
+  // v2 requires stage_runs.created_at to be meaningful; never write ''.
+  // This migration is best-effort and does not assume constraint rewrite support.
   try {
-    db.exec(SCHEMA_SQL);
+    const cols = db.prepare("PRAGMA table_info(stage_runs)").all() as Array<{ name: string }>;
+    const hasCreatedAt = cols.some((c) => c.name === "created_at");
+    if (hasCreatedAt) return;
 
-    // Migrations for existing databases
-    // Add created_at to stage_runs if missing (introduced in schema version 2)
-    try {
-      const columns = db.prepare("PRAGMA table_info(stage_runs)").all() as { name: string }[];
-      const hasCreatedAt = columns.some(col => col.name === 'created_at');
-      if (!hasCreatedAt) {
-        db.exec("ALTER TABLE stage_runs ADD COLUMN created_at TEXT NOT NULL DEFAULT ''");
-        info("[Astrocode] Added created_at column to stage_runs table");
-      }
-    } catch (e) {
-      // Column might already exist or table doesn't exist, ignore
-    }
+    // Add nullable column first (avoid poison defaults).
+    db.exec("ALTER TABLE stage_runs ADD COLUMN created_at TEXT");
 
-    const row = db.prepare("SELECT schema_version FROM repo_state WHERE id = 1").get() as { schema_version?: number } | undefined;
+    const now = nowISO();
 
-    if (!row) {
-      const now = nowISO();
-      db.prepare(
-        "INSERT INTO repo_state (id, schema_version, created_at, updated_at) VALUES (1, ?, ?, ?)"
-      ).run(SCHEMA_VERSION, now, now);
-      // Initialize story key seq
-      db.prepare("INSERT OR IGNORE INTO story_keyseq (id, next_story_num) VALUES (1, 1)").run();
-      return;
-    }
+    // Backfill using best available timestamp fields, falling back to now.
+    db.prepare(`
+      UPDATE stage_runs
+      SET created_at =
+        COALESCE(
+          NULLIF(created_at, ''),
+          NULLIF(updated_at, ''),
+          NULLIF(started_at, ''),
+          ?
+        )
+      WHERE created_at IS NULL OR created_at = ''
+    `).run(now);
 
-    const currentVersion = row.schema_version ?? 0;
+    info("[Astrocode] Added created_at column to stage_runs table (backfilled)");
+  } catch (e) {
+    // Ignore: table may not exist yet, or migration already applied.
+  }
+}
 
-    if (currentVersion === SCHEMA_VERSION) return;
+export function ensureSchema(db: SqliteDb, opts?: { allowAutoMigrate?: boolean; silent?: boolean }) {
+  try {
+    return withTx(
+      db,
+      () => {
+        db.exec(SCHEMA_SQL);
 
-    if (currentVersion > SCHEMA_VERSION && (opts?.failOnDowngrade ?? true)) {
-      throw new Error(
-        `Astrocode DB schema_version ${currentVersion} is newer than this plugin (${SCHEMA_VERSION}). Refusing to downgrade.`
-      );
-    }
+        // Deterministic assertions: if these fail, bootstrap is broken.
+        if (!tableExists(db, "repo_state")) throw new Error("Schema missing required table repo_state after SCHEMA_SQL");
+        if (!tableExists(db, "story_keyseq")) throw new Error("Schema missing required table story_keyseq after SCHEMA_SQL");
 
-    if (currentVersion < SCHEMA_VERSION) {
-      if (!(opts?.allowAutoMigrate ?? true)) {
-        throw new Error(
-          `Astrocode DB schema_version ${currentVersion} is older than required (${SCHEMA_VERSION}). Auto-migrate disabled.`
-        );
-      }
-      // Additive schema: SCHEMA_SQL already created new tables/indexes if missing.
-      db.prepare("UPDATE repo_state SET schema_version = ?, updated_at = ? WHERE id = 1").run(SCHEMA_VERSION, nowISO());
-    }
+        // Ensure required singleton rows exist.
+        db.prepare("INSERT OR IGNORE INTO story_keyseq (id, next_story_num) VALUES (1, 1)").run();
+
+        // Migrations for existing DBs.
+        migrateStageRunsCreatedAt(db);
+
+        const row = db
+          .prepare("SELECT schema_version FROM repo_state WHERE id = 1")
+          .get() as { schema_version?: number } | undefined;
+
+        if (!row) {
+          const now = nowISO();
+          db.prepare("INSERT INTO repo_state (id, schema_version, created_at, updated_at) VALUES (1, ?, ?, ?)").run(
+            SCHEMA_VERSION,
+            now,
+            now
+          );
+          return;
+        }
+
+        const currentVersion = row.schema_version ?? 0;
+
+        if (currentVersion === SCHEMA_VERSION) return;
+
+        if (currentVersion > SCHEMA_VERSION) {
+          // Newer schema - no action (policy enforcement elsewhere).
+          return;
+        }
+
+        if (currentVersion < SCHEMA_VERSION) {
+          if (opts?.allowAutoMigrate ?? true) {
+            db.prepare("UPDATE repo_state SET schema_version = ?, updated_at = ? WHERE id = 1").run(SCHEMA_VERSION, nowISO());
+          }
+        }
+      },
+      { require: true }
+    );
   } catch (e) {
-    // Schema operations might fail on mock adapter, silently ignore
+    if (opts?.silent) return;
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new Error(`Schema initialization failed: ${msg}`);
   }
 }

package/src/tools/index.ts

@@ -15,22 +15,40 @@ import { createAstroRepairTool } from "./repair";
 
 import { AgentConfig } from "@opencode-ai/sdk";
 
-export function createAstroTools(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb; agents?: Record<string, AgentConfig> }): Record<string, ToolDefinition> {
-  const { ctx, config, db, agents } = opts;
-  const hasDatabase = !!db;
+type RuntimeState = {
+  db: SqliteDb | null;
+  limitedMode: boolean;
+  limitedModeReason: null | { code: "db_init_failed"|"schema_too_old"|"schema_downgrade"|"schema_migration_failed"; details: any };
+};
+
+type CreateAstroToolsOptions = {
+  ctx: any;
+  config: AstrocodeConfig;
+  agents?: Record<string, AgentConfig>;
+  runtime: RuntimeState;
+};
+
+export function createAstroTools(opts: CreateAstroToolsOptions): Record<string, ToolDefinition> {
+  const { ctx, config, agents, runtime } = opts;
+  const { db } = runtime;
+  const hasDatabase = db !== null; // Source of truth: DB availability
 
   const tools: Record<string, ToolDefinition> = {};
 
-  // Always available tools
-  tools.astro_status = createAstroStatusTool({ ctx, config, db });
+   // 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)
-  tools.astro_status = createAstroStatusTool({ ctx, config, db });
-  tools.astro_spec_get = createAstroSpecGetTool({ ctx, config, db });
+   // Recovery tool - available even in limited mode to allow DB initialization
+   tools.astro_init = createAstroInitTool({ ctx, config, runtime });
 
   // Database-dependent tools
   if (hasDatabase) {
-    tools.astro_init = createAstroInitTool({ ctx, config, db });
+    // Ensure agents are available for workflow tools that require them
+    if (!agents) {
+      throw new Error("astro_workflow_proceed requires agents to be provided in normal mode.");
+    }
+
     tools.astro_story_queue = createAstroStoryQueueTool({ ctx, config, db });
     tools.astro_story_approve = createAstroStoryApproveTool({ ctx, config, db });
     tools.astro_story_board = createAstroStoryBoardTool({ ctx, config, db });
@@ -53,28 +71,6 @@ export function createAstroTools(opts: { ctx: any; config: AstrocodeConfig; db:
     tools.astro_inject_eligible = createAstroInjectEligibleTool({ ctx, config, db });
     tools.astro_inject_debug_due = createAstroInjectDebugDueTool({ ctx, config, db });
     tools.astro_repair = createAstroRepairTool({ ctx, config, db });
-  } else {
-    // Limited mode tools - provide helpful messages instead of failing
-    tools.astro_init = {
-      description: "Initialize Astrocode (requires database - currently unavailable)",
-      args: {},
-      execute: async () => "❌ Database not available. Astrocode is running in limited mode."
-    };
-    tools.astro_story_queue = {
-      description: "Queue a story (requires database - currently unavailable)",
-      args: {},
-      execute: async () => "❌ Database not available. Astrocode is running in limited mode."
-    };
-    tools.astro_spec_set = {
-      description: "Set project spec (requires database for hash tracking - currently unavailable)",
-      args: {},
-      execute: async () => "❌ Database not available. Astrocode is running in limited mode."
-    };
-    tools.astro_workflow_proceed = {
-      description: "Advance workflow (requires database - currently unavailable)",
-      args: {},
-      execute: async () => "❌ Database not available. Astrocode is running in limited mode."
-    };
   }
 
   // Create aliases for backward compatibility
@@ -101,6 +97,8 @@ export function createAstroTools(opts: { ctx: any; config: AstrocodeConfig; db:
     ["_astro_inject_list", "astro_inject_list"],
     ["_astro_inject_search", "astro_inject_search"],
     ["_astro_inject_get", "astro_inject_get"],
+    ["_astro_inject_eligible", "astro_inject_eligible"],
+    ["_astro_inject_debug_due", "astro_inject_debug_due"],
     ["_astro_repair", "astro_repair"],
   ];
 

package/src/tools/init.ts

@@ -3,13 +3,22 @@ import path from "node:path";
 import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
 import type { AstrocodeConfig } from "../config/schema";
 import type { SqliteDb } from "../state/db";
-import { ensureSchema } from "../state/db";
+import { ensureSchema, openSqlite, configurePragmas } from "../state/db";
 import { getAstroPaths, ensureAstroDirs } from "../shared/paths";
 import { nowISO } from "../shared/time";
 import { sha256Hex } from "../shared/hash";
 
-export function createAstroInitTool(opts: { ctx: any; config: AstrocodeConfig; db: SqliteDb }): ToolDefinition {
-  const { ctx, config, db } = opts;
+type RuntimeState = {
+  db: SqliteDb | null;
+  limitedMode: boolean;
+  limitedModeReason: null | {
+    code: "db_init_failed" | "schema_too_old" | "schema_downgrade" | "schema_migration_failed";
+    details: any;
+  };
+};
+
+export function createAstroInitTool(opts: { ctx: any; config: AstrocodeConfig; runtime: RuntimeState }): ToolDefinition {
+  const { ctx, config, runtime } = opts;
 
   return tool({
     description:
@@ -23,28 +32,88 @@ export function createAstroInitTool(opts: { ctx: any; config: AstrocodeConfig; d
       const paths = getAstroPaths(repoRoot, config.db.path);
       ensureAstroDirs(paths);
 
-      ensureSchema(db, { allowAutoMigrate: config.db.allow_auto_migrate, failOnDowngrade: config.db.fail_on_downgrade });
+      const hadDbAlready = !!runtime.db;
+      let db: SqliteDb | null = runtime.db;
+      let publishedToRuntime = false;
+
+      try {
+        if (!db) {
+          try {
+            db = openSqlite(paths.dbPath, { busyTimeoutMs: config.db.busy_timeout_ms });
+            configurePragmas(db, config.db.pragmas);
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(
+              `❌ Failed to open database at ${paths.dbPath}: ${msg}. Install a SQLite driver (better-sqlite3/bun:sqlite) and check file permissions.`
+            );
+          }
+        }
+
+        // Source-of-truth for schema + repo_state invariants.
+        ensureSchema(db, { allowAutoMigrate: config.db.allow_auto_migrate });
+
+        // Postcondition: repo_state must exist after ensureSchema.
+        try {
+          db.prepare("SELECT schema_version FROM repo_state WHERE id = 1").get();
+        } catch (e) {
+          const msg = e instanceof Error ? e.message : String(e);
+          throw new Error(`❌ Schema initialization incomplete: repo_state missing/unreadable after ensureSchema (${msg})`);
+        }
+
+        if (ensure_spec) {
+          if (!fs.existsSync(paths.specPath)) {
+            fs.writeFileSync(paths.specPath, spec_placeholder);
+          }
 
-      if (ensure_spec) {
-        if (!fs.existsSync(paths.specPath)) {
-          fs.writeFileSync(paths.specPath, spec_placeholder);
-          const specHash = sha256Hex(spec_placeholder);
+          const content = fs.readFileSync(paths.specPath, "utf8");
+          const specHash = sha256Hex(content);
           const now = nowISO();
-          db.prepare("UPDATE repo_state SET spec_hash_after=?, updated_at=? WHERE id=1").run(specHash, now);
+
+          // Update hash; fail with a clear error if schema is mismatched.
+          try {
+            db.prepare(
+              `
+              UPDATE repo_state
+              SET spec_hash_after = ?, updated_at = ?
+              WHERE id = 1
+            `
+            ).run(specHash, now);
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            throw new Error(`❌ Failed to update repo_state spec hash (schema mismatch?): ${msg}`);
+          }
+        }
+
+        // Best-effort: if we recovered DB in-process, publish it so the harness can use it immediately.
+        // (If your harness reads runtime at creation-time only, this still helps future tool calls.)
+        if (!hadDbAlready && db) {
+          runtime.db = db;
+          runtime.limitedMode = false;
+          runtime.limitedModeReason = null;
+          publishedToRuntime = true;
         }
-      }
 
-      const stat = db.prepare("SELECT schema_version, created_at, updated_at FROM repo_state WHERE id=1").get() as any;
-
-      return [
-        `✅ Astrocode initialized.`,
-        ``,
-        `- Repo: ${repoRoot}`,
-        `- DB: ${path.relative(repoRoot, paths.dbPath)} (schema_version=${stat?.schema_version ?? "?"})`,
-        `- Spec: ${path.relative(repoRoot, paths.specPath)}`,
-        ``,
-        `Next: queue a story (astro_story_queue) and approve it (astro_story_approve), or run /astro-status.`,
-      ].join("\n");
+        const stat = db.prepare("SELECT schema_version, created_at, updated_at FROM repo_state WHERE id=1").get() as any;
+
+        return [
+          `✅ Astrocode initialized.`,
+          ``,
+          `- Repo: ${repoRoot}`,
+          `- DB: ${path.relative(repoRoot, paths.dbPath)} (schema_version=${stat?.schema_version ?? "?"})`,
+          `- Spec: ${path.relative(repoRoot, paths.specPath)}`,
+          ``,
+          publishedToRuntime
+            ? `Next: run /astro-status. (DB recovered in-process.)`
+            : `Next: restart the agent/runtime if Astrocode is still in Limited Mode, then run /astro-status.`,
+        ].join("\n");
+      } finally {
+        // Only close if this tool opened it AND we did not publish it for ongoing use.
+        if (!hadDbAlready && !publishedToRuntime && db && typeof db.close === "function") {
+          try {
+            db.close();
+          } catch {}
+        }
+      }
     },
   });
-}
+}