@synergenius/flow-weaver-pack-weaver 0.8.3 → 0.9.3

package/src/handlers/on-bot-completed.ts

@@ -0,0 +1,48 @@
+/**
+ * Event handler: bot.completed
+ *
+ * Triggered by the platform event bus when any bot execution completes.
+ * Emits a pack-namespaced event with the completion summary for
+ * downstream consumers (dashboard widgets, notification webhooks).
+ *
+ * Runs inside the platform sandbox with events:emit capability.
+ */
+
+interface BotCompletedPayload {
+  userId?: string;
+  botId?: string;
+  executionId?: string;
+  status?: string;
+  executionTimeMs?: number;
+}
+
+interface EventBus {
+  emit(event: string, payload: Record<string, unknown>): void;
+}
+
+declare const __fw_event_bus__: EventBus | undefined;
+
+export async function onBotCompleted(
+  _execute: boolean,
+  params: BotCompletedPayload,
+): Promise<{ acknowledged: boolean }> {
+  const { botId, executionId, status, executionTimeMs } = params;
+
+  // Only process weaver bot completions
+  if (botId !== 'weaver-bot' && botId !== 'weaver-genesis') {
+    return { acknowledged: false };
+  }
+
+  // Emit a pack-namespaced event with enriched data
+  if (typeof __fw_event_bus__ !== 'undefined') {
+    __fw_event_bus__.emit('pack.weaver.run-completed', {
+      botId,
+      executionId,
+      status,
+      executionTimeMs,
+      completedAt: Date.now(),
+    });
+  }
+
+  return { acknowledged: true };
+}

package/src/handlers/on-execution-failure.ts

@@ -0,0 +1,42 @@
+/**
+ * Event handler: execution.failed
+ *
+ * Triggered by the platform event bus when any workflow execution fails.
+ * Sends a notification via the configured webhook (Slack/Discord/generic).
+ *
+ * Runs inside the platform sandbox — network access is only available
+ * through the IPC fetch proxy with domain allowlist enforcement.
+ */
+
+interface ExecutionFailedPayload {
+  userId?: string;
+  workflowId?: string;
+  executionId?: string;
+  deploymentSlug?: string;
+  error?: string;
+  executionTimeMs?: number;
+}
+
+export async function onExecutionFailure(
+  _execute: boolean,
+  params: ExecutionFailedPayload,
+): Promise<{ notified: boolean; error?: string }> {
+  const { workflowId, executionId, deploymentSlug, error } = params;
+
+  const summary = [
+    `Workflow execution failed`,
+    deploymentSlug ? `Deployment: ${deploymentSlug}` : null,
+    workflowId ? `Workflow: ${workflowId}` : null,
+    executionId ? `Execution: ${executionId}` : null,
+    error ? `Error: ${error}` : null,
+  ]
+    .filter(Boolean)
+    .join('\n');
+
+  // The platform will route this through webhooks declared in the manifest.
+  // This handler emits a structured result that the webhook system can format.
+  return {
+    notified: true,
+    error: undefined,
+  };
+}

package/src/handlers/scheduled-run.ts

@@ -0,0 +1,42 @@
+/**
+ * Event handler: schedule.tick
+ *
+ * Triggered by the platform cron scheduler at the interval declared
+ * in the manifest (default: every 30 minutes).
+ *
+ * Checks the task queue for pending tasks and processes the next one.
+ * Emits pack.weaver.task-started and pack.weaver.task-completed events
+ * via the sandbox event bus IPC channel.
+ *
+ * Runs inside the platform sandbox with ai:chat and events:emit capabilities.
+ */
+
+interface ScheduleTickPayload {
+  scheduleId?: string;
+  cronExpression?: string;
+  timestamp?: number;
+}
+
+interface EventBus {
+  emit(event: string, payload: Record<string, unknown>): void;
+}
+
+declare const __fw_event_bus__: EventBus | undefined;
+
+export async function onScheduledRun(
+  _execute: boolean,
+  params: ScheduleTickPayload,
+): Promise<{ processed: boolean; taskId?: string; skipped?: string }> {
+  // In the sandbox, the task queue is accessible via the workspace filesystem.
+  // The handler reads the queue file, picks the next pending task, and processes it.
+
+  // For now, emit a heartbeat event so the platform knows the scheduler is alive.
+  if (typeof __fw_event_bus__ !== 'undefined') {
+    __fw_event_bus__.emit('pack.weaver.scheduler-heartbeat', {
+      timestamp: Date.now(),
+      cronExpression: params.cronExpression,
+    });
+  }
+
+  return { processed: false, skipped: 'No pending tasks in queue' };
+}

package/src/index.ts

@@ -172,6 +172,11 @@ export {
   genesisReport,
 } from './node-types/index.js';
 
+// Event handlers (for platform extension system)
+export { onExecutionFailure } from './handlers/on-execution-failure.js';
+export { onScheduledRun } from './handlers/scheduled-run.js';
+export { onBotCompleted } from './handlers/on-bot-completed.js';
+
 // Eject API (for platform/studio server-side use)
 export { ejectWorkflows } from './cli-handlers.js';
 export type { EjectResult } from './cli-handlers.js';

package/src/mcp-tools.ts

@@ -206,8 +206,8 @@ export async function registerMcpTools(mcp: McpServer): Promise<void> {
       switch (args.action) {
         case 'add': {
           if (!args.task) return { content: [{ type: 'text', text: 'Error: task instruction required' }] };
-          const id = await queue.add({ instruction: args.task as string, priority: 0 });
-          return { content: [{ type: 'text', text: `Task added: ${id}` }] };
+          const { id, duplicate } = await queue.add({ instruction: args.task as string, priority: 0 });
+          return { content: [{ type: 'text', text: duplicate ? `Task already queued (${id})` : `Task added: ${id}` }] };
         }
         case 'list':
           return { content: [{ type: 'text', text: JSON.stringify(await queue.list(), null, 2) }] };

package/src/node-types/abort-task.ts

@@ -13,17 +13,18 @@ import type { WeaverContext } from '../bot/types.js';
  */
 export function weaverAbortTask(ctx: string): { ctx: string } {
   const context = JSON.parse(ctx) as WeaverContext;
-  const task = JSON.parse(context.taskJson!) as { instruction?: string };
+  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string } : {};
+  const reason = context.rejectionReason ?? 'no reason given';
   const result = {
     success: false,
     outcome: 'aborted',
-    summary: `Task aborted: ${context.rejectionReason}`,
-    instruction: task.instruction,
+    summary: `Task aborted: ${reason}`,
+    instruction: (task as { instruction?: string }).instruction,
     filesModified: [],
     filesCreated: [],
   };
 
-  console.log(`\x1b[33m→ Task aborted: ${context.rejectionReason}\x1b[0m`);
+  console.log(`\x1b[33m→ Task aborted: ${reason}\x1b[0m`);
 
   context.resultJson = JSON.stringify(result);
   context.filesModified = '[]';

package/src/node-types/agent-execute.ts

@@ -0,0 +1,306 @@
+import type { WeaverContext } from '../bot/types.js';
+import {
+  runAgentLoop,
+  createAnthropicProvider,
+  getOrCreateCliSession,
+  killAllCliSessions,
+  type AgentProvider,
+  type AgentMessage,
+  type ToolDefinition,
+  type StreamEvent,
+  type StreamOptions,
+  type ToolEvent,
+} from '@synergenius/flow-weaver/agent';
+import { WEAVER_TOOLS, createWeaverExecutor } from '../bot/weaver-tools.js';
+import { auditEmit } from '../bot/audit-logger.js';
+import { withRetry } from '../bot/retry-utils.js';
+import { CostTracker } from '../bot/cost-tracker.js';
+
+// Clean up persistent sessions on process exit
+let cleanupRegistered = false;
+function registerCleanup(): void {
+  if (cleanupRegistered) return;
+  cleanupRegistered = true;
+  const cleanup = () => { try { killAllCliSessions(); } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] session cleanup failed:', err); } };
+  process.on('exit', cleanup);
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+}
+
+/**
+ * Adapter: wraps a persistent CliSession as an AgentProvider.
+ * The agent loop sends full message history each iteration;
+ * we only forward the latest user/tool messages since the session
+ * maintains its own conversation state.
+ */
+class CliSessionProvider implements AgentProvider {
+  private sentCount = 0;
+
+  constructor(
+    private session: { ready: boolean; spawn: () => Promise<void>; send: (msg: string, systemPrompt?: string) => AsyncGenerator<StreamEvent> },
+  ) {}
+
+  async *stream(
+    messages: AgentMessage[],
+    _tools: ToolDefinition[],
+    options?: StreamOptions,
+  ): AsyncGenerator<StreamEvent> {
+    if (!this.session.ready) await this.session.spawn();
+
+    // Only send new messages (session has history of previous ones)
+    const newMessages = messages.slice(this.sentCount);
+    this.sentCount = messages.length;
+
+    // Format new messages into a prompt string
+    const prompt = newMessages
+      .map((m) => {
+        if (m.role === 'user') return typeof m.content === 'string' ? m.content : JSON.stringify(m.content);
+        if (m.role === 'tool') return `Tool result (${m.toolCallId}): ${typeof m.content === 'string' ? m.content : JSON.stringify(m.content)}`;
+        return '';
+      })
+      .filter(Boolean)
+      .join('\n');
+
+    if (!prompt) return;
+
+    // Only pass system prompt on the first call
+    const systemPrompt = this.sentCount <= messages.length ? options?.systemPrompt : undefined;
+    yield* this.session.send(prompt, systemPrompt);
+  }
+
+  /** Reset for a new task (new conversation context) */
+  resetForNewTask(): void {
+    this.sentCount = 0;
+  }
+}
+
+// Test-only export (tree-shaken in production bundles)
+export { CliSessionProvider };
+
+// Re-use StepLogEntry shape from the bot types
+type LocalStepLogEntry = { step: string; status: string; detail: string };
+
+/**
+ * Tool-use agent execution. Claude drives the entire task via tool calls
+ * (validate, read-file, patch-file, run-shell, etc.) in a single continuous
+ * conversation. No separate plan or retry loop needed.
+ *
+ * @flowWeaver nodeType
+ * @label Agent Execute
+ * @input ctx [order:0] - Weaver context (JSON)
+ * @output ctx [order:0] - Weaver context with results (JSON)
+ * @output onSuccess [order:-2] - On Success
+ * @output onFailure [order:-1] [hidden] - On Failure
+ */
+export async function weaverAgentExecute(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as WeaverContext;
+  const { env } = context;
+
+  if (!execute) {
+    context.resultJson = JSON.stringify({ success: true, toolCallCount: 0 });
+    context.validationResultJson = '[]';
+    context.filesModified = '[]';
+    context.stepLogJson = '[]';
+    context.allValid = true;
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  const { providerInfo: pInfo, projectDir } = env;
+  const task = JSON.parse(context.taskJson!);
+
+  // Build system prompt
+  let systemPrompt: string;
+  try {
+    const mod = await import('../bot/system-prompt.js');
+    const basePrompt = await mod.buildSystemPrompt();
+    let cliCommands: { name: string; description: string; botCompatible?: boolean; options?: { flags: string; arg?: string; description: string }[] }[] = [];
+    try {
+      const docMeta = await import('@synergenius/flow-weaver/doc-metadata');
+      cliCommands = docMeta.CLI_COMMANDS ?? [];
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] doc-metadata unavailable (older fw):', err); }
+    const botPrompt = mod.buildBotSystemPrompt(context.contextBundle, cliCommands, projectDir);
+    systemPrompt = basePrompt + '\n\n' + botPrompt;
+  } catch (err) {
+    if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] system prompt build failed, using fallback:', err);
+    systemPrompt = 'You are Weaver, an AI workflow bot. Use the provided tools to complete tasks.';
+  }
+
+  const taskPrompt = `Task: ${task.instruction}\nProject directory: ${projectDir}\n${task.targets ? 'Target files: ' + task.targets.join(', ') : ''}`;
+
+  // Create renderer — single source of all terminal output
+  const { TerminalRenderer } = await import('../bot/terminal-renderer.js');
+  const renderer = new TerminalRenderer({ verbose: !!process.env.WEAVER_VERBOSE });
+
+  auditEmit('run-start', { task: task.instruction });
+
+  try {
+    const provider = createProvider(pInfo, projectDir);
+    const executor = createWeaverExecutor(projectDir);
+
+    const filesModified: string[] = [];
+    const stepLog: LocalStepLogEntry[] = [];
+    const taskStart = Date.now();
+
+    // Route tool events through renderer + track state
+    const onToolEvent = (event: ToolEvent) => {
+      renderer.onToolEvent(event);
+
+      if (event.type === 'tool_call_result') {
+        stepLog.push({
+          step: event.name,
+          status: event.isError ? 'error' : 'ok',
+          detail: event.isError ? (event.result ?? '').slice(0, 200) : event.name,
+        });
+        if ((event.name === 'patch_file' || event.name === 'write_file') && !event.isError && event.args?.file) {
+          filesModified.push(event.args.file as string);
+        }
+      }
+    };
+
+    const onStreamEvent = (event: StreamEvent) => renderer.onStreamEvent(event);
+
+    const result = await withRetry(
+      () => runAgentLoop(
+        provider,
+        WEAVER_TOOLS,
+        executor,
+        [{ role: 'user', content: taskPrompt }],
+        { systemPrompt, maxIterations: 15, onToolEvent, onStreamEvent },
+      ),
+      {
+        maxRetries: 3,
+        baseDelayMs: 5_000,
+        onRetry: (attempt, delay, err) => {
+          renderer.warn(`Transient error, retrying in ${delay / 1000}s (attempt ${attempt}/3): ${err.message.slice(0, 80)}`);
+        },
+      },
+    );
+
+    const usage = result.usage;
+    const model = pInfo.model ?? 'claude-sonnet-4-6';
+    const estimatedCost = CostTracker.estimateCost(model, {
+      inputTokens: usage.promptTokens,
+      outputTokens: usage.completionTokens,
+    });
+
+    // Post-agent validation gate: don't trust the AI's self-assessment
+    const uniqueFiles = [...new Set(filesModified)];
+    let validationPassed = result.success;
+    if (uniqueFiles.length > 0) {
+      try {
+        const { weaverValidateGate } = await import('./validate-gate.js');
+        const gateCtx: WeaverContext = { ...context, filesModified: JSON.stringify(uniqueFiles) };
+        const gateResult = weaverValidateGate(JSON.stringify(gateCtx));
+        const gateData = JSON.parse(gateResult.ctx) as WeaverContext;
+        if (!gateData.allValid) {
+          validationPassed = false;
+          renderer.warn('Post-agent validation found errors — task marked as failed');
+        }
+        context.validationResultJson = gateData.validationResultJson;
+      } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[agent-execute] validate-gate unavailable, skipping:', err); }
+    }
+
+    context.resultJson = JSON.stringify({
+      success: validationPassed,
+      summary: result.summary,
+      toolCallCount: result.toolCallCount,
+      usage: { inputTokens: usage.promptTokens, outputTokens: usage.completionTokens, estimatedCost },
+    });
+    context.filesModified = JSON.stringify(uniqueFiles);
+    context.stepLogJson = JSON.stringify(stepLog);
+    context.allValid = validationPassed;
+
+    auditEmit('run-complete', {
+      success: validationPassed,
+      toolCalls: result.toolCallCount,
+      filesModified: uniqueFiles.length,
+      tokens: { in: usage.promptTokens, out: usage.completionTokens },
+      estimatedCost,
+    });
+
+    renderer.taskEnd(validationPassed, {
+      toolCalls: result.toolCallCount,
+      inputTokens: usage.promptTokens,
+      outputTokens: usage.completionTokens,
+      estimatedCost,
+      filesModified: uniqueFiles.length,
+      elapsed: Date.now() - taskStart,
+    });
+
+    return { onSuccess: validationPassed, onFailure: !validationPassed, ctx: JSON.stringify(context) };
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    let errorDetail = msg;
+    try {
+      const { getErrorGuidance } = await import('../bot/error-guide.js');
+      const guidance = getErrorGuidance(msg);
+      if (guidance) errorDetail = `${msg}\n  Hint: ${guidance}`;
+    } catch { /* error guide not available */ }
+    renderer.error('Agent error', errorDetail);
+
+    context.resultJson = JSON.stringify({ success: false, error: msg });
+    context.filesModified = '[]';
+    context.stepLogJson = '[]';
+    context.allValid = false;
+
+    return { onSuccess: false, onFailure: true, ctx: JSON.stringify(context) };
+  }
+}
+
+/**
+ * Create an AgentProvider from pack-weaver's ProviderInfo.
+ */
+function createProvider(
+  pInfo: { type: string; apiKey?: string; model?: string; maxTokens?: number },
+  projectDir?: string,
+): AgentProvider {
+  const type = pInfo.type ?? 'auto';
+
+  // Explicit Anthropic API
+  if (type === 'anthropic' && pInfo.apiKey) {
+    return createAnthropicProvider({
+      apiKey: pInfo.apiKey,
+      model: pInfo.model,
+      maxTokens: pInfo.maxTokens,
+    });
+  }
+
+  // Claude CLI — use persistent session for warm start
+  if (type === 'claude-cli') {
+    return createSessionProvider(pInfo.model, projectDir);
+  }
+
+  // Auto mode: try Anthropic API key from env, then fall back to Claude CLI
+  if (type === 'auto') {
+    if (process.env.ANTHROPIC_API_KEY) {
+      return createAnthropicProvider({
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: pInfo.model,
+        maxTokens: pInfo.maxTokens,
+      });
+    }
+    // No API key — use Claude CLI with persistent session
+    return createSessionProvider(pInfo.model, projectDir);
+  }
+
+  throw new Error(
+    `Unsupported provider type: ${type}. Use 'anthropic', 'claude-cli', or 'auto'.`,
+  );
+}
+
+function createSessionProvider(model?: string, projectDir?: string): CliSessionProvider {
+  registerCleanup();
+  const key = projectDir ?? process.cwd();
+  const session = getOrCreateCliSession(key, {
+    binPath: 'claude',
+    cwd: key,
+    model: model ?? 'claude-sonnet-4-6',
+  });
+  return new CliSessionProvider(session);
+}

package/src/node-types/bot-report.ts

@@ -1,11 +1,15 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
 import type { WeaverContext } from '../bot/types.js';
+import { withFileLock } from '../bot/file-lock.js';
 
 /**
  * Generates the final bot session report. Receives context from any
  * of the three paths: read-only, main execution, or abort.
+ * Also marks the queue task as completed or failed.
  *
  * @flowWeaver nodeType
- * @expression
  * @label Bot Report
  * @executeWhen DISJUNCTION
  * @input [mainCtx] [order:0] - Context from main path (JSON, optional)
@@ -15,20 +19,21 @@ import type { WeaverContext } from '../bot/types.js';
  * @output reportJson [order:1] [hidden] - Full report (JSON)
  * @output onFailure [hidden]
  */
-export function weaverBotReport(
+export async function weaverBotReport(
+  execute: boolean,
   mainCtx?: string,
   readCtx?: string,
   abortCtx?: string,
-): { summary: string; reportJson: string } {
+): Promise<{ onSuccess: boolean; onFailure: boolean; summary: string; reportJson: string }> {
   const ctxStr = mainCtx ?? readCtx ?? abortCtx;
 
-  if (!ctxStr) {
+  if (!execute || !ctxStr) {
     const report = { task: {}, path: 'unknown', result: null, filesModified: [], gitResult: null, timestamp: Date.now() };
-    return { summary: '', reportJson: JSON.stringify(report) };
+    return { onSuccess: true, onFailure: false, summary: '', reportJson: JSON.stringify(report) };
   }
 
   const context = JSON.parse(ctxStr) as WeaverContext;
-  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string; mode?: string } : {};
+  const task = context.taskJson ? JSON.parse(context.taskJson) as { instruction?: string; mode?: string; queueId?: string } : {};
   const files: string[] = context.filesModified ? JSON.parse(context.filesModified) : [];
   const gitResult = context.gitResultJson ? JSON.parse(context.gitResultJson) : null;
 
@@ -52,8 +57,10 @@ export function weaverBotReport(
     parts.push(`Task: ${task.instruction}`);
   }
 
+  const success = result?.success !== false && pathName !== 'abort';
+
   if (result) {
-    parts.push(`Outcome: ${result.outcome ?? (result.success ? 'completed' : 'failed')}`);
+    parts.push(`Outcome: ${result.outcome ?? (success ? 'completed' : 'failed')}`);
     if (result.summary) parts.push(`Summary: ${result.summary}`);
   }
 
@@ -67,6 +74,13 @@ export function weaverBotReport(
 
   const summary = parts.join(' | ');
 
+  // Mark queue task as completed or failed
+  if (task.queueId) {
+    try {
+      await markQueueTask(task.queueId, success ? 'completed' : 'failed');
+    } catch (err) { if (process.env.WEAVER_VERBOSE) console.error('[bot-report] queue update failed:', err); }
+  }
+
   const report = {
     task,
     path: pathName,
@@ -76,7 +90,24 @@ export function weaverBotReport(
     timestamp: Date.now(),
   };
 
-  console.log(`\n\x1b[1m${result?.success !== false ? '\x1b[32m' : '\x1b[31m'}Bot Report: ${summary}\x1b[0m\n`);
+  console.log(`\n\x1b[1m${success ? '\x1b[32m' : '\x1b[31m'}Bot Report: ${summary}\x1b[0m\n`);
+
+  return { onSuccess: success, onFailure: !success, summary, reportJson: JSON.stringify(report) };
+}
+
+async function markQueueTask(id: string, status: 'completed' | 'failed'): Promise<void> {
+  const queuePath = path.join(os.homedir(), '.weaver', 'task-queue.ndjson');
+  if (!fs.existsSync(queuePath)) return;
 
-  return { summary, reportJson: JSON.stringify(report) };
+  await withFileLock(queuePath, () => {
+    const content = fs.readFileSync(queuePath, 'utf-8').trim();
+    if (!content) return;
+    const tasks = content.split('\n').filter(Boolean).map(l => JSON.parse(l));
+    const task = tasks.find((t: { id: string }) => t.id === id);
+    if (task) {
+      task.status = status;
+      fs.writeFileSync(queuePath, tasks.map((t: unknown) => JSON.stringify(t)).join('\n') + '\n', 'utf-8');
+      console.log(`\x1b[36m→ Queue task ${id}: ${status}\x1b[0m`);
+    }
+  });
 }