astrocode-workflow 0.1.59 → 0.3.0

package/src/ui/inject.ts

@@ -1,62 +1,107 @@
+// src/ui/inject.ts
+
 let isInjecting = false;
+
 const injectionQueue: Array<{
   ctx: any;
-  sessionId: string;
+  sessionId?: string;
   text: string;
   agent?: string;
+  toast?: { title: string; message: string; variant?: "info" | "success" | "warning" | "error"; durationMs?: number };
+  retry?: { maxAttempts?: number; baseDelayMs?: number };
 }> = [];
 
-async function processQueue() {
-  if (isInjecting || injectionQueue.length === 0) return;
+function sleep(ms: number) {
+  return new Promise((r) => setTimeout(r, ms));
+}
 
-  isInjecting = true;
-  const opts = injectionQueue.shift();
+function resolveSessionId(ctx: any, sessionId?: string): string | null {
+  if (sessionId) return sessionId;
+  const direct = (ctx as any)?.sessionID ?? (ctx as any)?.sessionId ?? (ctx as any)?.session?.id;
+  if (typeof direct === "string" && direct.length > 0) return direct;
+  return null;
+}
 
-  if (!opts) {
-    isInjecting = false;
-    return;
+async function tryInjectOnce(opts: { ctx: any; sessionId: string; text: string; agent: string }): Promise<void> {
+  const { ctx, sessionId, text, agent } = opts;
+
+  // Prefer explicit chat prompt API
+  const promptApi = (ctx as any)?.client?.session?.prompt;
+  if (!promptApi) {
+    throw new Error("API not available (ctx.client.session.prompt)");
   }
 
+  const prefixedText = `[${agent}]\n\n${text}`;
+
+  // Some hosts reject unknown fields; keep body minimal and stable.
+  await promptApi({
+    path: { id: sessionId },
+    body: {
+      parts: [{ type: "text", text: prefixedText }],
+    },
+  });
+}
+
+async function processQueue() {
+  if (isInjecting) return;
+  if (injectionQueue.length === 0) return;
+
+  isInjecting = true;
+
   try {
-    const { ctx, sessionId, text, agent = "Astro" } = opts;
-    const prefixedText = `[${agent}]\n\n${text}`;
+    while (injectionQueue.length > 0) {
+      const item = injectionQueue.shift();
+      if (!item) continue;
 
-    // Basic validation
-    if (!sessionId) {
-      console.warn("[Astrocode] Skipping injection: No sessionId provided");
-      return;
-    }
+      const { ctx, text, agent = "Astro" } = item;
+      const sessionId = resolveSessionId(ctx, item.sessionId);
 
-    if (!ctx?.client?.session?.prompt) {
-      console.warn("[Astrocode] Skipping injection: API not available (ctx.client.session.prompt)");
-      return;
-    }
+      if (!sessionId) {
+        // Drop on floor: we cannot recover without a session id.
+        // Keep draining the queue so we don't stall.
+        // eslint-disable-next-line no-console
+        console.warn("[Astrocode] Injection skipped: no sessionId");
+        continue;
+      }
+
+      const maxAttempts = item.retry?.maxAttempts ?? 4;
+      const baseDelayMs = item.retry?.baseDelayMs ?? 250;
+
+      let lastErr: any = null;
+
+      for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+          await tryInjectOnce({ ctx, sessionId, text, agent });
+          lastErr = null;
+          break;
+        } catch (e) {
+          lastErr = e;
+          const delay = baseDelayMs * Math.pow(2, attempt - 1); // 250, 500, 1000, 2000
+          // eslint-disable-next-line no-console
+          console.warn(`[Astrocode] Injection attempt ${attempt}/${maxAttempts} failed: ${String(e)}; retrying in ${delay}ms`);
+          await sleep(delay);
+        }
+      }
 
-    await ctx.client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        parts: [{ type: "text", text: prefixedText }],
-        // Pass agent context for systems that support it
-        agent: agent,
-      },
-    });
-  } catch (error) {
-    console.warn(`[Astrocode] Injection failed: ${error}`);
+      if (lastErr) {
+        // eslint-disable-next-line no-console
+        console.warn(`[Astrocode] Injection failed permanently after ${maxAttempts} attempts: ${String(lastErr)}`);
+      }
+    }
   } finally {
     isInjecting = false;
-    // Process next item immediately
-    if (injectionQueue.length > 0) {
-      setImmediate(processQueue);
-    }
   }
 }
 
-export async function injectChatPrompt(opts: {
-  ctx: any;
-  sessionId: string;
-  text: string;
-  agent?: string;
-}) {
-  injectionQueue.push(opts);
-  processQueue();
+export async function injectChatPrompt(opts: { ctx: any; sessionId?: string; text: string; agent?: string }) {
+  injectionQueue.push({
+    ctx: opts.ctx,
+    sessionId: opts.sessionId,
+    text: opts.text,
+    agent: opts.agent ?? "Astro",
+    retry: { maxAttempts: 4, baseDelayMs: 250 },
+  });
+
+  // Fire-and-forget; queue drain is serialized by isInjecting.
+  void processQueue();
 }

package/src/workflow/state-machine.ts

@@ -7,6 +7,9 @@ import { nowISO } from "../shared/time";
 import { newEventId, newRunId, newStageRunId } from "../state/ids";
 import { warn } from "../shared/log";
 import { sha256Hex } from "../shared/hash";
+import { SCHEMA_VERSION } from "../state/schema";
+import type { ToastOptions } from "../ui/toasts";
+import { injectChatPrompt } from "../ui/inject";
 
 export const EVENT_TYPES = {
   RUN_STARTED: "run.started",
@@ -19,24 +22,65 @@ export const EVENT_TYPES = {
 } as const;
 
 /**
- * PLANNING-FIRST REDESIGN
- * ----------------------
- * Old behavior: mutate an approved story into a planning/decomposition instruction.
- * New behavior: NEVER mutate story title/body.
- *
- * Planning-first is a run-scoped directive stored in `injects` (scope = run:<run_id>).
- *
- * Deterministic trigger (config-driven):
- * - config.workflow.genesis_planning:
- *    - "off"             => never attach directive
- *    - "first_story_only"=> attach only when story_key === "S-0001"
- *    - "always"          => attach for every run
+ * UI HOOKS
+ * --------
+ * This workflow module is DB-first. UI emission is optional and happens AFTER the DB tx commits.
  *
- * Contract: DB is already initialized before workflow is used:
- * - schema tables exist
- * - repo_state singleton row (id=1) exists
+ * Contract:
+ * - If you pass ui.ctx + ui.sessionId, we will inject a visible chat message deterministically.
+ * - If you pass ui.toast, we will also toast (throttling is handled by the toast manager).
  */
+export type WorkflowUi = {
+  ctx: any;
+  sessionId: string;
+  agentName?: string; // label for injected chat messages
+  toast?: (t: ToastOptions) => Promise<void>;
+};
+
+async function emitUi(ui: WorkflowUi | undefined, text: string, toast?: ToastOptions): Promise<void> {
+  if (!ui) return;
+
+  // Prefer toast (if provided) AND also inject chat (for audit trail / visibility).
+  // If you want toast-only, pass a toast function and omit ctx/sessionId.
+  if (toast && ui.toast) {
+    try {
+      await ui.toast(toast);
+    } catch {
+      // non-fatal
+    }
+  }
+
+  try {
+    await injectChatPrompt({
+      ctx: ui.ctx,
+      sessionId: ui.sessionId,
+      text,
+      agent: ui.agentName ?? "Astro",
+    });
+  } catch {
+    // non-fatal (workflow correctness is DB-based)
+  }
+}
 
+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;
+  }
+}
+
+/**
+ * PLANNING-FIRST REDESIGN
+ * ----------------------
+ * - Never mutate story title/body.
+ * - Planning-first becomes a run-scoped inject stored in `injects` (scope = run:<run_id>).
+ * - Trigger is deterministic via config.workflow.genesis_planning:
+ *    - "off" | "first_story_only" | "always"
+ */
 export type NextAction =
   | { kind: "idle"; reason: "no_approved_stories" }
   | { kind: "start_run"; story_key: string }
@@ -97,7 +141,7 @@ export function decideNextAction(db: SqliteDb, config: AstrocodeConfig): NextAct
     return { kind: "failed", run_id: activeRun.run_id, stage_key: current.stage_key, error_text: current.error_text ?? "stage failed" };
   }
 
-  warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.stage_key });
+  warn("Unexpected stage status in decideNextAction", { status: current.status, stage_key: current.status });
   return { kind: "await_stage_completion", run_id: activeRun.run_id, stage_key: current.stage_key, stage_run_id: current.stage_run_id };
 }
 
@@ -114,7 +158,7 @@ type GenesisPlanningMode = "off" | "first_story_only" | "always";
 function getGenesisPlanningMode(config: AstrocodeConfig): GenesisPlanningMode {
   const raw = (config as any)?.workflow?.genesis_planning;
   if (raw === "off" || raw === "first_story_only" || raw === "always") return raw;
-  if (raw != null) warn(`Invalid workflow.genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
+  warn(`Invalid genesis_planning config: ${String(raw)}. Using default "first_story_only".`);
   return "first_story_only";
 }
 
@@ -126,6 +170,8 @@ function shouldAttachPlanningDirective(config: AstrocodeConfig, story: StoryRow)
 }
 
 function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow, pipeline: StageKey[]) {
+  if (!tableExists(db, "injects")) return;
+
   const now = nowISO();
   const injectId = `inj_${runId}_genesis_plan`;
 
@@ -145,16 +191,9 @@ function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow
     ``,
   ].join("\n");
 
-  let hash: string | null = null;
-  try {
-    hash = sha256Hex(body);
-  } catch {
-    // Hash is optional; directive must never be blocked by hashing.
-    hash = null;
-  }
+  const hash = sha256Hex(body);
 
   try {
-    // Do not clobber user edits. If it exists, we leave it.
     db.prepare(
       `
       INSERT OR IGNORE INTO injects (
@@ -169,39 +208,12 @@ function attachRunPlanningDirective(db: SqliteDb, runId: string, story: StoryRow
 
     db.prepare(
       "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)"
-    ).run(
-      newEventId(),
-      runId,
-      EVENT_TYPES.RUN_GENESIS_PLANNING_ATTACHED,
-      JSON.stringify({ story_key: story.story_key, inject_id: injectId }),
-      now
-    );
+    ).run(newEventId(), runId, EVENT_TYPES.RUN_GENESIS_PLANNING_ATTACHED, JSON.stringify({ story_key: story.story_key, inject_id: injectId }), now);
   } catch (e) {
-    // Helpful, never required for correctness.
     warn("Failed to attach genesis planning inject", { run_id: runId, story_key: story.story_key, err: e });
   }
 }
 
-function updateRepoStateLastEvent(db: SqliteDb, now: string, fields: { last_run_id?: string; last_story_key?: string }) {
-  // Contract: repo_state row exists. If not, fail deterministically (don’t “bootstrap” here).
-  const res = db
-    .prepare(
-      `
-      UPDATE repo_state
-      SET last_run_id = COALESCE(?, last_run_id),
-          last_story_key = COALESCE(?, last_story_key),
-          last_event_at = ?,
-          updated_at = ?
-      WHERE id = 1
-    `
-    )
-    .run(fields.last_run_id ?? null, fields.last_story_key ?? null, now, now);
-
-  if (!res || res.changes === 0) {
-    throw new Error("repo_state missing (id=1). Database not initialized; run init must be performed before workflow.");
-  }
-}
-
 export function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKey: string): { run_id: string } {
   return withTx(db, () => {
     const story = getStory(db, storyKey);
@@ -235,19 +247,31 @@ export function createRunForStory(db: SqliteDb, config: AstrocodeConfig, storyKe
       attachRunPlanningDirective(db, run_id, story, pipeline);
     }
 
-    updateRepoStateLastEvent(db, now, { last_run_id: run_id, last_story_key: storyKey });
+    db.prepare(`
+      INSERT INTO repo_state (id, schema_version, created_at, updated_at, last_run_id, last_story_key, last_event_at)
+      VALUES (1, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        last_run_id=excluded.last_run_id,
+        last_story_key=excluded.last_story_key,
+        last_event_at=excluded.last_event_at,
+        updated_at=excluded.updated_at
+    `).run(SCHEMA_VERSION, now, now, run_id, storyKey, now);
 
     return { run_id };
   });
 }
 
-export function startStage(
+/**
+ * STAGE MOVEMENT (START) — now async so UI injection is deterministic.
+ */
+export async function startStage(
   db: SqliteDb,
   runId: string,
   stageKey: StageKey,
-  meta?: { subagent_type?: string; subagent_session_id?: string }
-) {
-  return withTx(db, () => {
+  meta?: { subagent_type?: string; subagent_session_id?: string; ui?: WorkflowUi }
+): Promise<void> {
+  // Do DB work inside tx, capture what we need for UI outside.
+  const payload = withTx(db, () => {
     const now = nowISO();
 
     const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
@@ -268,12 +292,40 @@ export function startStage(
       "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)"
     ).run(newEventId(), runId, stageKey, EVENT_TYPES.STAGE_STARTED, JSON.stringify({ subagent_type: meta?.subagent_type ?? null }), now);
 
-    updateRepoStateLastEvent(db, now, {});
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+
+    const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key) as any;
+
+    return {
+      now,
+      story_key: run.story_key,
+      story_title: story?.title ?? "",
+    };
   });
+
+  // Deterministic UI emission AFTER commit (never inside tx).
+  await emitUi(
+    meta?.ui,
+    [
+      `🟦 Stage started`,
+      `- Run: \`${runId}\``,
+      `- Stage: \`${stageKey}\``,
+      `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
+    ].join("\n"),
+    {
+      title: "Stage started",
+      message: `${stageKey} (${payload.story_key})`,
+      variant: "info",
+      durationMs: 2500,
+    }
+  );
 }
 
-export function completeRun(db: SqliteDb, runId: string) {
-  return withTx(db, () => {
+/**
+ * STAGE CLOSED (RUN COMPLETED) — now async so UI injection is deterministic.
+ */
+export async function completeRun(db: SqliteDb, runId: string, ui?: WorkflowUi): Promise<void> {
+  const payload = withTx(db, () => {
     const now = nowISO();
 
     const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
@@ -294,12 +346,34 @@ export function completeRun(db: SqliteDb, runId: string) {
       "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)"
     ).run(newEventId(), runId, EVENT_TYPES.RUN_COMPLETED, JSON.stringify({ story_key: run.story_key }), now);
 
-    updateRepoStateLastEvent(db, now, {});
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+
+    const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key) as any;
+
+    return { now, story_key: run.story_key, story_title: story?.title ?? "" };
   });
+
+  await emitUi(
+    ui,
+    [
+      `✅ Run completed`,
+      `- Run: \`${runId}\``,
+      `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
+    ].join("\n"),
+    {
+      title: "Run completed",
+      message: `${payload.story_key} — done`,
+      variant: "success",
+      durationMs: 3000,
+    }
+  );
 }
 
-export function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string) {
-  return withTx(db, () => {
+/**
+ * STAGE CLOSED (RUN FAILED) — now async so UI injection is deterministic.
+ */
+export async function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorText: string, ui?: WorkflowUi): Promise<void> {
+  const payload = withTx(db, () => {
     const now = nowISO();
 
     const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
@@ -315,14 +389,34 @@ export function failRun(db: SqliteDb, runId: string, stageKey: StageKey, errorTe
       "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, ?, ?, ?, ?)"
     ).run(newEventId(), runId, stageKey, EVENT_TYPES.RUN_FAILED, JSON.stringify({ error_text: errorText }), now);
 
-    updateRepoStateLastEvent(db, now, {});
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
+
+    const story = db.prepare("SELECT story_key, title FROM stories WHERE story_key=?").get(run.story_key) as any;
+
+    return { now, story_key: run.story_key, story_title: story?.title ?? "" };
   });
+
+  await emitUi(
+    ui,
+    [
+      `⛔ Run failed`,
+      `- Run: \`${runId}\``,
+      `- Stage: \`${stageKey}\``,
+      `- Story: \`${payload.story_key}\` — ${payload.story_title || "(untitled)"}`,
+      `- Error: ${errorText}`,
+    ].join("\n"),
+    {
+      title: "Run failed",
+      message: `${stageKey}: ${errorText}`,
+      variant: "error",
+      durationMs: 4500,
+    }
+  );
 }
 
 export function abortRun(db: SqliteDb, runId: string, reason: string) {
   return withTx(db, () => {
     const now = nowISO();
-
     const run = db.prepare("SELECT * FROM runs WHERE run_id=?").get(runId) as RunRow | undefined;
     if (!run) throw new Error(`Run not found: ${runId}`);
 
@@ -336,6 +430,6 @@ export function abortRun(db: SqliteDb, runId: string, reason: string) {
       "INSERT INTO events (event_id, run_id, stage_key, type, body_json, created_at) VALUES (?, ?, NULL, ?, ?, ?)"
     ).run(newEventId(), runId, EVENT_TYPES.RUN_ABORTED, JSON.stringify({ reason }), now);
 
-    updateRepoStateLastEvent(db, now, {});
+    db.prepare("UPDATE repo_state SET last_event_at=?, updated_at=? WHERE id=1").run(now, now);
   });
 }