astrocode-workflow 0.4.0 → 0.4.1

package/src/hooks/inject-provider.ts

@@ -9,6 +9,11 @@ type ChatMessageInput = {
   agent: string;
 };
 
+type ToolExecuteAfterInput = {
+  tool: string;
+  sessionID?: string;
+};
+
 type RuntimeState = {
   db: SqliteDb | null;
   limitedMode: boolean;
@@ -24,19 +29,30 @@ export function createInjectProvider(opts: {
   const { db } = runtime;
 
   // Cache to avoid re-injecting the same injects repeatedly
+  // Map of inject_id -> last injected timestamp
   const injectedCache = new Map<string, number>();
 
   function shouldSkipInject(injectId: string, nowMs: number): boolean {
     const lastInjected = injectedCache.get(injectId);
     if (!lastInjected) return false;
 
-    // Skip if injected within the last 5 minutes (configurable?)
-    const cooldownMs = 5 * 60 * 1000;
+    // REDUCED cooldown from 5 minutes to 1 minute
+    // This allows injects to appear more frequently during workflow
+    const cooldownMs = 1 * 60 * 1000;
     return nowMs - lastInjected < cooldownMs;
   }
 
   function markInjected(injectId: string, nowMs: number) {
     injectedCache.set(injectId, nowMs);
+
+    // Clean up old entries to prevent memory leak
+    // Remove entries older than 10 minutes
+    const tenMinutesAgo = nowMs - (10 * 60 * 1000);
+    for (const [id, timestamp] of injectedCache.entries()) {
+      if (timestamp < tenMinutesAgo) {
+        injectedCache.delete(id);
+      }
+    }
   }
 
   function getInjectionDiagnostics(nowIso: string, scopeAllowlist: string[], typeAllowlist: string[]): any {
@@ -89,7 +105,7 @@ export function createInjectProvider(opts: {
     };
   }
 
-  async function injectEligibleInjects(sessionId: string) {
+  async function injectEligibleInjects(sessionId: string, context?: string) {
     const now = nowISO();
     const nowMs = Date.now();
 
@@ -115,7 +131,7 @@ export function createInjectProvider(opts: {
       // Log when no injects are eligible
       if (EMIT_TELEMETRY) {
         // eslint-disable-next-line no-console
-        console.log(`[Astrocode:inject] ${now} selected=${diagnostics.selected_eligible} injected=0 skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:0}`);
+        console.log(`[Astrocode:inject] ${now} context=${context ?? 'unknown'} selected=0 injected=0 skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:0}`);
       }
       return;
     }
@@ -130,21 +146,68 @@ export function createInjectProvider(opts: {
       // Format as injection message
       const formattedText = `[Inject: ${inject.title}]\n\n${inject.body_md}`;
 
+      try {
+        await injectChatPrompt({
+          ctx,
+          sessionId,
+          text: formattedText,
+          agent: "Astrocode"
+        });
+
+        injected++;
+        markInjected(inject.inject_id, nowMs);
+      } catch (err) {
+        // Log injection failures but don't crash
+        // eslint-disable-next-line no-console
+        console.error(`[Astrocode:inject] Failed to inject ${inject.inject_id}:`, err);
+      }
+    }
+
+    // Log diagnostic summary
+    if (EMIT_TELEMETRY || injected > 0) {
+      // eslint-disable-next-line no-console
+      console.log(`[Astrocode:inject] ${now} context=${context ?? 'unknown'} selected=${diagnostics.selected_eligible} injected=${injected} skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:${skippedDeduped}}`);
+    }
+  }
+
+  // Workflow-related tools that should trigger inject + auto-approval
+  const WORKFLOW_TOOLS = new Set([
+    'astro_workflow_proceed',
+    'astro_story_queue',
+    'astro_story_approve',
+    'astro_stage_start',
+    'astro_stage_complete',
+    'astro_stage_fail',
+    'astro_run_abort',
+  ]);
+
+  // Auto-approve queued stories if enabled
+  async function maybeAutoApprove(sessionId: string) {
+    if (!config.inject?.auto_approve_queued_stories) return;
+
+    try {
+      // Get all queued stories
+      const queued = db.prepare("SELECT story_key, title FROM stories WHERE state='queued' ORDER BY priority DESC, created_at ASC").all() as Array<{ story_key: string; title: string }>;
+
+      if (queued.length === 0) return;
+
+      // Auto-approve the highest priority queued story
+      const story = queued[0];
+      db.prepare("UPDATE stories SET state='approved', updated_at=? WHERE story_key=?").run(nowISO(), story.story_key);
+
+      // eslint-disable-next-line no-console
+      console.log(`[Astrocode:inject] Auto-approved story ${story.story_key}: ${story.title}`);
+
+      // Inject a notification about the auto-approval
       await injectChatPrompt({
         ctx,
         sessionId,
-        text: formattedText,
+        text: `✅ Auto-approved story ${story.story_key}: ${story.title}`,
         agent: "Astrocode"
       });
-
-      injected++;
-      markInjected(inject.inject_id, nowMs);
-    }
-
-    // Log diagnostic summary
-    if (EMIT_TELEMETRY) {
+    } catch (err) {
       // eslint-disable-next-line no-console
-      console.log(`[Astrocode:inject] ${now} selected=${diagnostics.selected_eligible} injected=${injected} skipped={expired:${diagnostics.skipped.expired} scope:${diagnostics.skipped.scope} type:${diagnostics.skipped.type} deduped:${skippedDeduped}}`);
+      console.error(`[Astrocode:inject] Auto-approval failed:`, err);
     }
   }
 
@@ -154,7 +217,24 @@ export function createInjectProvider(opts: {
       if (!config.inject?.enabled) return;
 
       // Inject eligible injects before processing the user's message
-      await injectEligibleInjects(input.sessionID);
+      await injectEligibleInjects(input.sessionID, 'chat_message');
+    },
+
+    async onToolAfter(input: ToolExecuteAfterInput) {
+      if (!config.inject?.enabled) return;
+
+      // Only inject after workflow-related tools
+      if (!WORKFLOW_TOOLS.has(input.tool)) return;
+
+      // Extract sessionID (same pattern as continuation enforcer)
+      const sessionId = input.sessionID ?? (ctx as any).sessionID;
+      if (!sessionId) return;
+
+      // Auto-approve queued stories if enabled
+      await maybeAutoApprove(sessionId);
+
+      // Inject eligible injects after workflow tool execution
+      await injectEligibleInjects(sessionId, `tool_after:${input.tool}`);
     },
   };
 }

package/src/index.ts

@@ -24,6 +24,7 @@ type ContinuationEnforcer = {
 type ToolOutputTruncator = (input: any, output: any | null) => Promise<void>;
 type InjectProvider = {
   onChatMessage: (input: any) => Promise<void>;
+  onToolAfter: (input: any) => Promise<void>;
 };
 type ToastManager = {
   show: (toast: ToastOptions) => Promise<void>;
@@ -58,6 +59,13 @@ const Astrocode: Plugin = async (ctx) => {
   }
   const repoRoot = ctx.directory;
 
+  // NOTE: Repo locking is handled at the workflow level via workflowRepoLock.
+  // The workflow tool correctly acquires and holds the lock for the entire workflow execution.
+  // Plugin-level locking is unnecessary and architecturally incorrect since:
+  // - The lock would be held for the entire session lifecycle (too long)
+  // - Individual tools are designed to be called within workflow context where lock is held
+  // - Workflow-level locking with refcounting prevents lock churn during tool execution
+
   // Always load config first - this provides defaults even in limited mode
   let pluginConfig: AstrocodeConfig;
   try {
@@ -294,6 +302,11 @@ const Astrocode: Plugin = async (ctx) => {
     },
 
     "tool.execute.after": async (input: any, output: any) => {
+      // Inject eligible injects after tool execution (not just on chat messages)
+      if (injectProvider && hookEnabled("inject-provider")) {
+        await injectProvider.onToolAfter(input);
+      }
+
       // Truncate huge tool outputs to artifacts
       if (truncatorHook && hookEnabled("tool-output-truncator")) {
         await truncatorHook(input, output ?? null);
@@ -325,6 +338,7 @@ const Astrocode: Plugin = async (ctx) => {
 
     // Best-effort cleanup
     close: async () => {
+      // Close database connection
       if (db && typeof db.close === "function") {
         try {
           db.close();

package/src/shared/metrics.ts

@@ -0,0 +1,148 @@
+// src/shared/metrics.ts
+
+export interface TransactionMetrics {
+  startTime: number;
+  duration: number;
+  success: boolean;
+  nestedDepth: number;
+  operation?: string;
+}
+
+export interface InjectionMetrics {
+  sessionId: string;
+  attempts: number;
+  duration: number;
+  success: boolean;
+  agent?: string;
+}
+
+export interface SystemMetrics {
+  transactions: TransactionMetrics[];
+  injections: InjectionMetrics[];
+  errors: Array<{ type: string; message: string; timestamp: number }>;
+}
+
+class MetricsCollector {
+  private transactions: TransactionMetrics[] = [];
+  private injections: InjectionMetrics[] = [];
+  private errors: Array<{ type: string; message: string; timestamp: number }> = [];
+  private maxEntries = 1000; // Keep last 1000 entries per type
+
+  recordTransaction(metrics: TransactionMetrics) {
+    this.transactions.push(metrics);
+    if (this.transactions.length > this.maxEntries) {
+      this.transactions.shift();
+    }
+  }
+
+  recordInjection(metrics: InjectionMetrics) {
+    this.injections.push(metrics);
+    if (this.injections.length > this.maxEntries) {
+      this.injections.shift();
+    }
+  }
+
+  recordError(type: string, message: string) {
+    this.errors.push({ type, message, timestamp: Date.now() });
+    if (this.errors.length > this.maxEntries) {
+      this.errors.shift();
+    }
+  }
+
+  getMetrics(): SystemMetrics {
+    return {
+      transactions: [...this.transactions],
+      injections: [...this.injections],
+      errors: [...this.errors],
+    };
+  }
+
+  getTransactionStats() {
+    const txs = this.transactions;
+    if (txs.length === 0) return null;
+
+    const successful = txs.filter(t => t.success);
+    const failed = txs.filter(t => !t.success);
+
+    return {
+      total: txs.length,
+      successful: successful.length,
+      failed: failed.length,
+      successRate: successful.length / txs.length,
+      avgDuration: txs.reduce((sum, t) => sum + t.duration, 0) / txs.length,
+      avgNestedDepth: txs.reduce((sum, t) => sum + t.nestedDepth, 0) / txs.length,
+      minDuration: Math.min(...txs.map(t => t.duration)),
+      maxDuration: Math.max(...txs.map(t => t.duration)),
+    };
+  }
+
+  getInjectionStats() {
+    const injections = this.injections;
+    if (injections.length === 0) return null;
+
+    const successful = injections.filter(i => i.success);
+    const failed = injections.filter(i => !i.success);
+
+    return {
+      total: injections.length,
+      successful: successful.length,
+      failed: failed.length,
+      successRate: successful.length / injections.length,
+      avgAttempts: injections.reduce((sum, i) => sum + i.attempts, 0) / injections.length,
+      avgDuration: injections.reduce((sum, i) => sum + i.duration, 0) / injections.length,
+      totalRetries: injections.reduce((sum, i) => sum + Math.max(0, i.attempts - 1), 0),
+    };
+  }
+
+  clear() {
+    this.transactions = [];
+    this.injections = [];
+    this.errors = [];
+  }
+}
+
+// Global singleton
+export const metrics = new MetricsCollector();
+
+// Convenience functions
+export function recordTransaction(metricsData: Omit<TransactionMetrics, 'startTime' | 'duration' | 'success'>) {
+  return {
+    start() {
+      return {
+        ...metricsData,
+        startTime: Date.now(),
+      };
+    },
+    end(startData: ReturnType<ReturnType<typeof recordTransaction>['start']>, success: boolean) {
+      const duration = Date.now() - startData.startTime;
+      metrics.recordTransaction({
+        ...startData,
+        duration,
+        success,
+      });
+    },
+  };
+}
+
+export function recordInjection(metricsData: Omit<InjectionMetrics, 'duration' | 'success'>) {
+  return {
+    start() {
+      return {
+        ...metricsData,
+        startTime: Date.now(),
+      };
+    },
+    end(startData: any, success: boolean) {
+      const duration = Date.now() - startData.startTime;
+      metrics.recordInjection({
+        ...startData,
+        duration,
+        success,
+      });
+    },
+  };
+}
+
+export function recordError(type: string, message: string) {
+  metrics.recordError(type, message);
+}

package/src/state/db.ts

@@ -5,6 +5,7 @@ import { SCHEMA_SQL, SCHEMA_VERSION } from "./schema";
 import { nowISO } from "../shared/time";
 import { info, warn } from "../shared/log";
 import { createDatabaseAdapter, DatabaseConnection } from "./adapters";
+import { recordTransaction } from "../shared/metrics";
 
 export type SqliteDb = DatabaseConnection;
 
@@ -74,7 +75,7 @@ function savepointName(depth: number): string {
 }
 
 /** BEGIN IMMEDIATE transaction helper (re-entrant). */
-export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean }): T {
+export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean; operation?: string }): T {
   const adapter = createDatabaseAdapter();
   const available = adapter.isAvailable();
 
@@ -84,13 +85,17 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   }
 
   const depth = getDepth(db);
+  const isNested = depth > 0;
+  const txRecorder = recordTransaction({ nestedDepth: depth, operation: opts?.operation });
 
   if (depth === 0) {
+    const txStart = txRecorder.start();
     db.exec("BEGIN IMMEDIATE");
     setDepth(db, 1);
     try {
       const out = fn();
       db.exec("COMMIT");
+      txRecorder.end(txStart, true);
       return out;
     } catch (e) {
       try {
@@ -98,6 +103,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
       } catch {
         // ignore
       }
+      txRecorder.end(txStart, false);
       throw e;
     } finally {
       setDepth(db, 0);
@@ -107,6 +113,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   // Nested: use SAVEPOINT
   const nextDepth = depth + 1;
   const sp = savepointName(nextDepth);
+  const txStart = txRecorder.start();
 
   db.exec(`SAVEPOINT ${sp}`);
   setDepth(db, nextDepth);
@@ -114,6 +121,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
   try {
     const out = fn();
     db.exec(`RELEASE SAVEPOINT ${sp}`);
+    txRecorder.end(txStart, true);
     return out;
   } catch (e) {
     try {
@@ -126,6 +134,7 @@ export function withTx<T>(db: SqliteDb, fn: () => T, opts?: { require?: boolean
     } catch {
       // ignore
     }
+    txRecorder.end(txStart, false);
     throw e;
   } finally {
     setDepth(db, depth);