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

package/src/bot/task-decomposer.ts

@@ -0,0 +1,100 @@
+/**
+ * Auto task decomposition — splits broad tasks into per-file tasks.
+ *
+ * When a task says "fix all templates" or "validate everything",
+ * decompose it into one task per file. This gives the AI focused
+ * context and prevents one failure from blocking all files.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export interface DecomposableTask {
+  id: string;
+  instruction: string;
+  mode?: string;
+  targets?: string[];
+  priority?: number;
+}
+
+export interface DecomposedResult {
+  decomposed: boolean;
+  tasks: DecomposableTask[];
+}
+
+// Patterns that suggest a broad task targeting multiple files
+const BROAD_PATTERNS = [
+  /\b(all|every|each)\b.*\b(template|workflow|file|node.?type)s?\b/i,
+  /\bfix\b.*\bin\s+src\/(templates|node-types|workflows)\/?$/i,
+  /\bvalidat(e|ion)\b.*\b(all|every|each|src\/)\b/i,
+];
+
+/**
+ * Check if a task should be decomposed into per-file tasks.
+ * Returns the original task unchanged if no decomposition is needed.
+ */
+export function decomposeTask(
+  task: DecomposableTask,
+  projectDir: string,
+): DecomposedResult {
+  const instruction = task.instruction;
+
+  // Already has specific targets — don't decompose
+  if (task.targets && task.targets.length === 1) {
+    return { decomposed: false, tasks: [task] };
+  }
+
+  // Check if instruction matches broad patterns
+  const isBroad = BROAD_PATTERNS.some(p => p.test(instruction));
+  if (!isBroad) {
+    return { decomposed: false, tasks: [task] };
+  }
+
+  // Determine which directory to scan
+  let targetDir: string | undefined;
+  if (instruction.match(/template/i)) targetDir = 'src/templates';
+  else if (instruction.match(/node.?type/i)) targetDir = 'src/node-types';
+  else if (instruction.match(/workflow/i)) targetDir = 'src/workflows';
+
+  if (!targetDir) {
+    return { decomposed: false, tasks: [task] };
+  }
+
+  const absDir = path.resolve(projectDir, targetDir);
+  if (!fs.existsSync(absDir)) {
+    return { decomposed: false, tasks: [task] };
+  }
+
+  // List .ts files in the directory — only files that actually exist
+  let files: string[];
+  try {
+    files = fs.readdirSync(absDir)
+      .filter(f => f.endsWith('.ts') && !f.startsWith('index'))
+      .filter(f => fs.existsSync(path.resolve(absDir, f))) // verify file exists
+      .sort();
+  } catch {
+    return { decomposed: false, tasks: [task] };
+  }
+
+  if (files.length === 0 || files.length > 50) {
+    return { decomposed: false, tasks: [task] };
+  }
+
+  // Extract the verb from the original instruction for clean per-file instructions
+  const verb = instruction.match(/^(Fix|Validate|Add|Update|Review|Run|Check|Test|Improve)/i)?.[0] ?? 'Process';
+
+  // Create per-file tasks with clean, grammatical instructions
+  const tasks: DecomposableTask[] = files.map((file, i) => {
+    const filePath = path.join(targetDir!, file);
+
+    return {
+      id: `${task.id}-${i + 1}`,
+      instruction: `${verb} ${filePath}`,
+      mode: task.mode ?? 'modify',
+      targets: [filePath],
+      priority: task.priority ?? 0,
+    };
+  });
+
+  return { decomposed: true, tasks };
+}

package/src/bot/task-queue.ts

@@ -13,19 +13,67 @@ export interface QueuedTask {
   options?: Record<string, unknown>;
   priority: number;
   addedAt: number;
-  status: 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+  status: 'pending' | 'running' | 'completed' | 'no-op' | 'failed' | 'cancelled';
+  /** Error reason (set on failure) */
+  failureReason?: string;
+}
+
+export interface AddResult {
+  id: string;
+  duplicate: boolean;
+}
+
+/** Max pending tasks before queue rejects new additions. */
+const MAX_PENDING = 200;
+/** Don't re-queue tasks completed within this window (ms). */
+const CYCLE_DEDUP_WINDOW = 3600_000; // 1 hour
+
+/**
+ * Hash a project directory path into a short filesystem-safe string.
+ * Used for per-project queue isolation.
+ */
+function hashDir(dir: string): string {
+  return crypto.createHash('sha256').update(dir).digest('hex').slice(0, 8);
 }
 
 export class TaskQueue {
-  private filePath: string;
+  readonly filePath: string;
 
   constructor(dir?: string) {
-    const base = dir ?? path.join(os.homedir(), '.weaver');
+    // Priority: explicit dir > env var > project-scoped > global fallback
+    const projectDir = process.env.WEAVER_PROJECT_DIR;
+    const base = dir
+      ?? process.env.WEAVER_QUEUE_DIR
+      ?? (projectDir
+        ? path.join(os.homedir(), '.weaver', 'projects', hashDir(projectDir))
+        : path.join(os.homedir(), '.weaver'));
     this.filePath = path.join(base, 'task-queue.ndjson');
   }
 
-  async add(task: Omit<QueuedTask, 'id' | 'addedAt' | 'status'>): Promise<string> {
+  async add(task: Omit<QueuedTask, 'id' | 'addedAt' | 'status'>): Promise<AddResult> {
     return withFileLock(this.filePath, () => {
+      const existing = this.readAll();
+
+      // Dedup: skip if a pending task with the same instruction exists
+      const pendingDup = existing.find(
+        t => t.status === 'pending' && t.instruction === task.instruction,
+      );
+      if (pendingDup) return { id: pendingDup.id, duplicate: true };
+
+      // Cycle-aware dedup: skip if same instruction was completed recently
+      const recentDup = existing.find(
+        t => (t.status === 'completed' || t.status === 'no-op')
+          && t.instruction === task.instruction
+          && Date.now() - t.addedAt < CYCLE_DEDUP_WINDOW,
+      );
+      if (recentDup) return { id: recentDup.id, duplicate: true };
+
+      // Queue size cap
+      const pendingCount = existing.filter(t => t.status === 'pending').length;
+      if (pendingCount >= MAX_PENDING) {
+        throw new Error(`Queue full (${MAX_PENDING} pending tasks). Clear or process existing tasks first.`);
+      }
+
       const entry: QueuedTask = {
         ...task,
         id: crypto.randomUUID().slice(0, 8),
@@ -35,7 +83,7 @@ export class TaskQueue {
       const dir = path.dirname(this.filePath);
       if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
       fs.appendFileSync(this.filePath, JSON.stringify(entry) + '\n', 'utf-8');
-      return entry.id;
+      return { id: entry.id, duplicate: false };
     });
   }
 
@@ -78,8 +126,66 @@ export class TaskQueue {
     await this.updateStatus(id, 'completed');
   }
 
-  async markFailed(id: string): Promise<void> {
-    await this.updateStatus(id, 'failed');
+  async markNoOp(id: string): Promise<void> {
+    await this.updateStatus(id, 'no-op');
+  }
+
+  async markFailed(id: string, reason?: string): Promise<void> {
+    return withFileLock(this.filePath, () => {
+      const tasks = this.readAll();
+      const task = tasks.find(t => t.id === id);
+      if (task) {
+        task.status = 'failed';
+        if (reason) task.failureReason = reason.slice(0, 500);
+        this.writeAll(tasks);
+      }
+    });
+  }
+
+  /** Reset a failed or running task back to pending. */
+  async retry(id: string): Promise<boolean> {
+    return withFileLock(this.filePath, () => {
+      const tasks = this.readAll();
+      const task = tasks.find(t => t.id === id && (t.status === 'failed' || t.status === 'running'));
+      if (!task) return false;
+      task.status = 'pending';
+      task.failureReason = undefined;
+      this.writeAll(tasks);
+      return true;
+    });
+  }
+
+  /** Reset ALL failed tasks back to pending. Returns count reset. */
+  async retryAll(): Promise<number> {
+    return withFileLock(this.filePath, () => {
+      const tasks = this.readAll();
+      let count = 0;
+      for (const t of tasks) {
+        if (t.status === 'failed') {
+          t.status = 'pending';
+          t.failureReason = undefined;
+          count++;
+        }
+      }
+      if (count > 0) this.writeAll(tasks);
+      return count;
+    });
+  }
+
+  /** Reset orphaned "running" tasks to pending (crash recovery). */
+  async recoverOrphans(): Promise<number> {
+    return withFileLock(this.filePath, () => {
+      const tasks = this.readAll();
+      let count = 0;
+      for (const t of tasks) {
+        if (t.status === 'running') {
+          t.status = 'pending';
+          count++;
+        }
+      }
+      if (count > 0) this.writeAll(tasks);
+      return count;
+    });
   }
 
   private async updateStatus(id: string, status: QueuedTask['status']): Promise<void> {

package/src/bot/terminal-renderer.ts

@@ -0,0 +1,241 @@
+/**
+ * Terminal renderer — centralizes all weaver CLI output through
+ * a consistent visual grammar. Pipe-safe (stderr only for decoration).
+ *
+ * Icons: ✓ success · ✗ error · ⚠ warning · ◆ action · ● running
+ * Colors: green/red/yellow/cyan/dim/bold — strict assignments
+ */
+
+import type { StreamEvent, ToolEvent } from '@synergenius/flow-weaver/agent';
+
+// ANSI helpers
+const isTTY = process.stderr.isTTY ?? false;
+const c = {
+  green: (s: string) => `\x1b[32m${s}\x1b[0m`,
+  red: (s: string) => `\x1b[31m${s}\x1b[0m`,
+  yellow: (s: string) => `\x1b[33m${s}\x1b[0m`,
+  cyan: (s: string) => `\x1b[36m${s}\x1b[0m`,
+  dim: (s: string) => `\x1b[2m${s}\x1b[0m`,
+  bold: (s: string) => `\x1b[1m${s}\x1b[0m`,
+  redBold: (s: string) => `\x1b[1;31m${s}\x1b[0m`,
+};
+
+export interface RendererOptions {
+  verbose?: boolean;
+  quiet?: boolean;
+  noColor?: boolean;
+  /** Override stderr writer (for testing) */
+  write?: (s: string) => void;
+}
+
+export interface TaskEndStats {
+  toolCalls: number;
+  inputTokens: number;
+  outputTokens: number;
+  estimatedCost: number;
+  filesModified: number;
+  elapsed: number;
+  gitMessage?: string;
+}
+
+export interface SessionEndStats {
+  tasks: number;
+  completed: number;
+  failed: number;
+  totalInputTokens: number;
+  totalOutputTokens: number;
+  totalCost: number;
+  elapsed: number;
+}
+
+export class TerminalRenderer {
+  private verbose: boolean;
+  private quiet: boolean;
+  private out: (s: string) => void;
+  private taskStartTime = 0;
+  private lastToolStartTime = 0;
+  private textBuffer = '';
+  private hasActiveText = false;
+
+  constructor(opts: RendererOptions = {}) {
+    this.verbose = opts.verbose ?? false;
+    this.quiet = opts.quiet ?? false;
+    if (opts.noColor) {
+      // Strip all color functions
+      for (const key of Object.keys(c) as (keyof typeof c)[]) {
+        (c as Record<string, (s: string) => string>)[key] = (s: string) => s;
+      }
+    }
+    this.out = opts.write ?? ((s: string) => process.stderr.write(s));
+  }
+
+  // --- Session lifecycle ---
+
+  sessionStart(info: { provider: string; parallel?: number; deadline?: string }): void {
+    if (this.quiet) return;
+    this.out(`${c.bold('[weaver]')} Session started ${c.dim('(Ctrl+C to stop)')}\n`);
+    const parts = [`Provider: ${info.provider}`];
+    if (info.parallel && info.parallel > 1) parts.push(`Parallel: ${info.parallel}`);
+    if (info.deadline) parts.push(`Deadline: ${info.deadline}`);
+    this.out(`${c.bold('[weaver]')} ${c.dim(parts.join(' · '))}\n`);
+  }
+
+  sessionEnd(stats: SessionEndStats): void {
+    if (this.quiet) return;
+    this.out('\n');
+    const parts: string[] = [];
+    parts.push(`${stats.tasks} task${stats.tasks === 1 ? '' : 's'}`);
+    if (stats.completed > 0) parts.push(c.green(`${stats.completed} completed`));
+    if (stats.failed > 0) parts.push(c.red(`${stats.failed} failed`));
+    const skipped = stats.tasks - stats.completed - stats.failed;
+    if (skipped > 0) parts.push(c.yellow(`${skipped} skipped`));
+    this.out(`${c.bold('[weaver]')} Session complete: ${parts.join(' · ')}\n`);
+
+    const totalTokens = stats.totalInputTokens + stats.totalOutputTokens;
+    if (totalTokens > 0) {
+      this.out(`${c.bold('[weaver]')} ${c.dim(`Total: ${formatTokens(totalTokens)} tokens · $${stats.totalCost.toFixed(3)} · ${formatElapsed(stats.elapsed)}`)}\n`);
+    }
+  }
+
+  // --- Task lifecycle ---
+
+  taskStart(index: number, instruction: string): void {
+    if (this.quiet) return;
+    this.taskStartTime = Date.now();
+    this.hasActiveText = false;
+    this.textBuffer = '';
+    const label = instruction.length > 70 ? instruction.slice(0, 67) + '...' : instruction;
+    this.out(`\n${c.cyan('◆')} ${c.bold(`Task ${index}:`)} ${label}\n`);
+  }
+
+  taskEnd(success: boolean, stats: TaskEndStats): void {
+    if (this.quiet) return;
+    // Flush any remaining text
+    this.flushText();
+
+    const elapsed = formatElapsed(stats.elapsed);
+    const icon = success ? c.green('✓') : c.red('✗');
+    const status = success ? 'completed' : 'failed';
+    this.out(`${icon} Task ${status} ${c.dim(elapsed)}\n`);
+
+    // Summary line
+    const parts: string[] = [];
+    if (stats.toolCalls > 0) parts.push(`${stats.toolCalls} tool calls`);
+    const totalTokens = stats.inputTokens + stats.outputTokens;
+    if (totalTokens > 0) parts.push(`${formatTokens(totalTokens)} tokens`);
+    if (stats.estimatedCost > 0) parts.push(`$${stats.estimatedCost.toFixed(3)}`);
+    if (stats.filesModified > 0) parts.push(`${stats.filesModified} file${stats.filesModified === 1 ? '' : 's'} modified`);
+    if (parts.length > 0) {
+      this.out(`  ${c.dim(parts.join(' · '))}\n`);
+    }
+
+    if (stats.gitMessage) {
+      this.out(`  ${c.dim('→ Git: ' + stats.gitMessage)}\n`);
+    }
+  }
+
+  // --- Stream event handling ---
+
+  onStreamEvent(event: StreamEvent): void {
+    if (this.quiet) return;
+
+    switch (event.type) {
+      case 'thinking_delta':
+        if (this.verbose) {
+          // In verbose mode, stream thinking as dim text
+          this.flushText();
+          this.out(`  ${c.dim(event.text.replace(/\n/g, '\n  '))}`);
+        }
+        // In normal mode, thinking is completely hidden
+        break;
+
+      case 'text_delta':
+        if (this.verbose) {
+          this.flushText();
+          this.out(event.text);
+          this.hasActiveText = true;
+        }
+        // In normal mode, AI text is hidden (tool calls tell the story)
+        break;
+
+      case 'tool_result':
+        // CLI internal tool result — show as result line
+        break;
+
+      default:
+        break;
+    }
+  }
+
+  onToolEvent(event: ToolEvent): void {
+    if (this.quiet) return;
+
+    if (event.type === 'tool_call_start') {
+      this.flushText();
+      this.lastToolStartTime = Date.now();
+      const args = event.args ?? {};
+      const preview = toolPreview(event.name, args);
+      this.out(`  ${c.cyan('◆')} ${event.name}${preview ? c.dim(`(${preview})`) : ''}\n`);
+    }
+
+    if (event.type === 'tool_call_result') {
+      const elapsed = Date.now() - this.lastToolStartTime;
+      const result = (event.result ?? '').replace(/\n/g, ' ').slice(0, 120);
+      const icon = event.isError ? c.red('✗') : c.dim('→');
+      this.out(`  ${icon} ${result} ${c.dim(formatElapsed(elapsed))}\n`);
+    }
+  }
+
+  // --- Direct messages ---
+
+  info(msg: string): void {
+    if (!this.quiet) this.out(`${c.bold('[weaver]')} ${msg}\n`);
+  }
+
+  warn(msg: string): void {
+    if (!this.quiet) this.out(`${c.yellow('⚠')} ${msg}\n`);
+  }
+
+  error(title: string, detail?: string): void {
+    this.out(`${c.redBold('✗')} ${c.red(title)}\n`);
+    if (detail) this.out(`  ${c.red(detail)}\n`);
+  }
+
+  // --- Private ---
+
+  private flushText(): void {
+    if (this.hasActiveText) {
+      this.out('\n');
+      this.hasActiveText = false;
+    }
+  }
+}
+
+// --- Formatting helpers ---
+
+export function formatTokens(n: number): string {
+  if (n < 1000) return String(n);
+  if (n < 1_000_000) return (n / 1000).toFixed(1).replace(/\.0$/, '') + 'k';
+  return (n / 1_000_000).toFixed(1).replace(/\.0$/, '') + 'M';
+}
+
+export function formatElapsed(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60_000) return `${(ms / 1000).toFixed(1)}s`;
+  const m = Math.floor(ms / 60_000);
+  const s = Math.round((ms % 60_000) / 1000);
+  return s > 0 ? `${m}m ${s}s` : `${m}m`;
+}
+
+function toolPreview(name: string, args: Record<string, unknown>): string {
+  if (args.file) return String(args.file).split('/').pop() ?? '';
+  if (args.command) return String(args.command).slice(0, 50);
+  if (args.directory) return String(args.directory).split('/').pop() ?? '';
+  // For patch_file, show file + patch count
+  if (name === 'patch_file' && args.patches) {
+    const file = String(args.file ?? '').split('/').pop() ?? '';
+    const count = Array.isArray(args.patches) ? args.patches.length : '?';
+    return `${file}, ${count} patches`;
+  }
+  return '';
+}

package/src/bot/types.ts

@@ -171,6 +171,12 @@ export interface WorkflowResult {
 
 export type RunOutcome = 'completed' | 'failed' | 'error' | 'skipped';
 
+export interface StepLogEntry {
+  step: string;
+  status: 'ok' | 'blocked' | 'error';
+  detail?: string;
+}
+
 export interface RunRecord {
   id: string;
   workflowFile: string;
@@ -187,6 +193,7 @@ export interface RunRecord {
   provider?: string;
   pipelineName?: string;
   stageName?: string;
+  stepLog?: StepLogEntry[];
 }
 
 export interface RunFilter {
@@ -494,6 +501,7 @@ export interface WeaverContext {
   resultJson?: string;
   validationResultJson?: string;
   filesModified?: string;
+  stepLogJson?: string;
   allValid?: boolean;
   gitResultJson?: string;
 }