@synergenius/flow-weaver-pack-weaver 0.9.96 → 0.9.98

package/src/node-types/review-result.ts

@@ -0,0 +1,207 @@
+import type { WeaverContext } from '../bot/types.js';
+import {
+  runAgentLoop,
+  createAnthropicProvider,
+  getOrCreateCliSession,
+  type AgentProvider,
+  type StreamEvent,
+} from '@synergenius/flow-weaver/agent';
+
+/**
+ * LLM-powered task completion reviewer.
+ * Makes a single judgment call: did the bot accomplish the assigned task?
+ *
+ * @flowWeaver nodeType
+ * @label Review Result
+ * @icon spellcheck
+ * @color green
+ * @input ctx [order:0] - Weaver context with results (JSON)
+ * @output ctx [order:0] - Weaver context with review (JSON)
+ * @output onSuccess [order:-2] - Review passed
+ * @output onFailure [order:-1] [hidden] - Review failed
+ */
+export async function weaverReviewResult(
+  execute: boolean,
+  ctx: string,
+): Promise<{
+  onSuccess: boolean; onFailure: boolean;
+  ctx: string;
+}> {
+  const context = JSON.parse(ctx) as WeaverContext;
+
+  if (!execute) {
+    context.reviewJson = JSON.stringify({ pass: true, reason: 'Dry run' });
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+
+  // Extract task info
+  let taskTitle = 'Unknown task';
+  let taskDescription = '';
+  try {
+    const task = JSON.parse(context.taskJson ?? '{}');
+    const instruction = task.instruction ?? '';
+    const titleMatch = instruction.match(/^##\s*Task:\s*(.+)/m);
+    taskTitle = titleMatch ? titleMatch[1].trim() : (instruction.split('\n')[0] || 'Unknown task');
+    // Description is everything after the title line until the next ## heading
+    const descMatch = instruction.match(/^##\s*Task:[^\n]*\n\n([\s\S]*?)(?=\n##|\n*$)/m);
+    taskDescription = descMatch ? descMatch[1].trim() : '';
+  } catch { /* use defaults */ }
+
+  // Extract evidence
+  let toolCalls = 'none';
+  try {
+    const steps = JSON.parse(context.stepLogJson ?? '[]') as Array<{ step: string; status: string }>;
+    if (steps.length > 0) {
+      toolCalls = steps.map(s => `${s.step} (${s.status})`).join(', ');
+    }
+  } catch { /* use default */ }
+
+  let filesModified = 'none';
+  try {
+    const files = JSON.parse(context.filesModified ?? '[]') as string[];
+    if (files.length > 0) filesModified = files.join(', ');
+  } catch { /* use default */ }
+
+  let agentSummary = 'No summary available';
+  try {
+    const result = JSON.parse(context.resultJson ?? '{}');
+    if (result.summary) agentSummary = result.summary;
+  } catch { /* use default */ }
+
+  const prompt = `You are reviewing whether a bot completed its assigned task.
+
+## Task
+${taskTitle}
+${taskDescription}
+
+## What the bot did
+Tool calls: ${toolCalls}
+Files modified: ${filesModified}
+Bot's summary: ${agentSummary}
+
+Did the bot accomplish the task? Judge based on what was asked vs what was done.
+
+Respond with exactly: {"pass": true/false, "reason": "one sentence"}`;
+
+  try {
+    const { env } = context;
+    const pInfo = env.providerInfo;
+    const provider = await createReviewProvider(pInfo, env.projectDir);
+
+    const result = await runAgentLoop(
+      provider,
+      [], // no tools needed — just a judgment call
+      async () => ({ result: '', isError: true }), // no-op executor
+      [{ role: 'user', content: prompt }],
+      { maxIterations: 1 },
+    );
+
+    // Parse the response
+    let pass = true;
+    let reason = 'Review completed';
+    const jsonMatch = result.summary.match(/\{[\s\S]*"pass"[\s\S]*\}/);
+    if (jsonMatch) {
+      try {
+        const parsed = JSON.parse(jsonMatch[0]);
+        pass = parsed.pass === true;
+        reason = parsed.reason ?? reason;
+      } catch {
+        // JSON-like but unparseable — check for fail signal in matched text
+        if (jsonMatch[0].includes('"pass": false') || jsonMatch[0].includes('"pass":false')) {
+          pass = false;
+          reason = result.summary.slice(0, 200);
+        }
+      }
+    } else {
+      // No JSON found — check for obvious fail signals in raw text
+      const lower = result.summary.toLowerCase();
+      if (lower.includes('"pass": false') || lower.includes('"pass":false')) {
+        pass = false;
+        reason = result.summary.slice(0, 200);
+      }
+    }
+
+    context.reviewJson = JSON.stringify({ pass, reason });
+
+    if (!pass) {
+      console.log(`\x1b[33m→ Review FAILED: ${reason}\x1b[0m`);
+    } else {
+      console.log(`\x1b[32m→ Review passed: ${reason}\x1b[0m`);
+    }
+
+    return { onSuccess: pass, onFailure: !pass, ctx: JSON.stringify(context) };
+  } catch (err) {
+    // Review failure is non-fatal — don't block the pipeline
+    const msg = err instanceof Error ? err.message : String(err);
+    console.log(`\x1b[33m→ Review skipped (error): ${msg}\x1b[0m`);
+    context.reviewJson = JSON.stringify({ pass: true, reason: `Review skipped: ${msg}` });
+    return { onSuccess: true, onFailure: false, ctx: JSON.stringify(context) };
+  }
+}
+
+/**
+ * Create a provider for the review call — same logic as agent-execute.
+ */
+async function createReviewProvider(
+  pInfo: { type: string; apiKey?: string; model?: string; maxTokens?: number },
+  projectDir?: string,
+): Promise<AgentProvider> {
+  const type = pInfo.type ?? 'auto';
+
+  if (type === 'anthropic' && pInfo.apiKey) {
+    return createAnthropicProvider({
+      apiKey: pInfo.apiKey,
+      model: pInfo.model,
+      maxTokens: 256,
+    });
+  }
+
+  if (type === 'claude-cli') {
+    const key = projectDir ?? process.cwd();
+    const session = getOrCreateCliSession(`${key}:reviewer`, {
+      binPath: 'claude',
+      cwd: key,
+      model: pInfo.model ?? 'claude-sonnet-4-6',
+    });
+    return new CliReviewProvider(session);
+  }
+
+  if (type === 'auto') {
+    if (process.env.ANTHROPIC_API_KEY) {
+      return createAnthropicProvider({
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: pInfo.model,
+        maxTokens: 256,
+      });
+    }
+    const key = projectDir ?? process.cwd();
+    const session = getOrCreateCliSession(`${key}:reviewer`, {
+      binPath: 'claude',
+      cwd: key,
+      model: pInfo.model ?? 'claude-sonnet-4-6',
+    });
+    return new CliReviewProvider(session);
+  }
+
+  throw new Error(`Unsupported provider type: ${type}`);
+}
+
+class CliReviewProvider implements AgentProvider {
+  constructor(
+    private session: { ready: boolean; spawn: () => Promise<void>; send: (msg: string) => AsyncGenerator<StreamEvent> },
+  ) {}
+
+  async *stream(
+    messages: import('@synergenius/flow-weaver/agent').AgentMessage[],
+    _tools: import('@synergenius/flow-weaver/agent').ToolDefinition[],
+    _options?: import('@synergenius/flow-weaver/agent').StreamOptions,
+  ): AsyncGenerator<StreamEvent> {
+    if (!this.session.ready) await this.session.spawn();
+    const prompt = messages
+      .map(m => typeof m.content === 'string' ? m.content : JSON.stringify(m.content))
+      .filter(Boolean)
+      .join('\n');
+    if (!prompt) return;
+    yield* this.session.send(prompt);
+  }
+}

package/src/node-types/validate-gate.ts

@@ -9,7 +9,7 @@ import type { WeaverContext } from '../bot/types.js';
  * @flowWeaver nodeType
  * @expression
  * @label Validate Gate
- * @icon check
+ * @icon checkCircle
  * @color green
  * @input ctx [order:0] - Weaver context (JSON)
  * @output ctx [order:0] - Weaver context with validation result (JSON)

package/src/node-types/validate-result.ts

@@ -8,7 +8,7 @@ import { validateFiles } from '../bot/file-validator.js';
  * @flowWeaver nodeType
  * @expression
  * @label Validate Result
- * @icon check
+ * @icon checkCircle
  * @color green
  * @input env [order:0] - Weaver environment bundle
  * @input executionResultJson [order:1] - Execution result (JSON)

package/src/workflows/weaver-bot.ts

@@ -11,6 +11,7 @@ import { weaverPlanTask } from '../node-types/plan-task.js';
 import { weaverApprovalGate } from '../node-types/approval-gate.js';
 import { weaverAbortTask } from '../node-types/abort-task.js';
 import { weaverExecValidateRetry } from '../node-types/exec-validate-retry.js';
+import { weaverReviewResult } from '../node-types/review-result.js';
 import { weaverGitOps } from '../node-types/git-ops.js';
 import { weaverSendNotify } from '../node-types/send-notify.js';
 import { weaverBotReport } from '../node-types/bot-report.js';
@@ -37,21 +38,24 @@ declare const __flowWeaverDebugger__: TDebugger | undefined;
  * @node approve weaverApprovalGate [color: "orange"] [icon: "send"] [position: 1400 200]
  * @node abort weaverAbortTask [color: "red"] [icon: "code"] [position: 1600 450]
  * @node execRetry weaverExecValidateRetry [color: "purple"] [icon: "code"] [position: 1600 200]
- * @node gitOps weaverGitOps [color: "green"] [icon: "code"] [position: 1800 100]
- * @node notify weaverSendNotify [color: "yellow"] [icon: "send"] [position: 1800 300] [suppress: "UNUSED_OUTPUT_PORT"]
- * @node report weaverBotReport [color: "green"] [icon: "description"] [position: 2000 200] [suppress: "UNUSED_OUTPUT_PORT", "DESIGN_ASYNC_NO_ERROR_PATH"]
- * @path Start -> cfg -> detect -> receive -> route -> context -> plan -> approve -> execRetry -> gitOps -> report -> Exit
+ * @node review weaverReviewResult [color: "green"] [icon: "spellcheck"] [position: 1700 200]
+ * @node gitOps weaverGitOps [color: "green"] [icon: "code"] [position: 1900 100]
+ * @node notify weaverSendNotify [color: "yellow"] [icon: "send"] [position: 1900 300] [suppress: "UNUSED_OUTPUT_PORT"]
+ * @node report weaverBotReport [color: "green"] [icon: "description"] [position: 2100 200] [suppress: "UNUSED_OUTPUT_PORT", "DESIGN_ASYNC_NO_ERROR_PATH"]
+ * @path Start -> cfg -> detect -> receive -> route -> context -> plan -> approve -> execRetry -> review -> gitOps -> report -> Exit
  * @path execRetry -> notify
  * @path route:fail -> readWf
  * @path approve:fail -> abort
  * @path receive:fail -> report
  * @path plan:fail -> report
  * @path execRetry:fail -> report
+ * @path review:fail -> report
  * @position Start 0 200
- * @position Exit 2200 200
+ * @position Exit 2300 200
  * @connect readWf.onSuccess -> report.execute
  * @connect abort.onSuccess -> report.execute
  * @connect notify.onSuccess -> report.execute
+ * @connect review.ctx -> gitOps.ctx
  * @connect gitOps.ctx -> report.mainCtx
  * @connect readWf.ctx -> report.readCtx
  * @connect abort.ctx -> report.abortCtx