@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/src/bot/swarm-event-log.ts

@@ -0,0 +1,57 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+
+export interface SwarmEvent {
+  id: number;
+  type: string;
+  timestamp: number;
+  data?: Record<string, unknown>;
+}
+
+/**
+ * Append-only event log for swarm-level events.
+ *
+ * Writes SwarmEvent objects to `.weaver/swarm-events.ndjson`.
+ * The platform tails this file via SSE to stream live dashboard updates.
+ * Decoupled from execution: the swarm controller writes, the UI reads, independently.
+ */
+export class SwarmEventLog {
+  private readonly filePath: string;
+  private nextId = 0;
+
+  constructor(projectDir: string) {
+    const dir = path.join(projectDir, '.weaver');
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    this.filePath = path.join(dir, 'swarm-events.ndjson');
+  }
+
+  /** Append a swarm event with auto-assigned sequential ID. */
+  emit(event: Omit<SwarmEvent, 'id'>): void {
+    const full: SwarmEvent = { ...event, id: this.nextId++ };
+    fs.appendFileSync(this.filePath, JSON.stringify(full) + '\n', 'utf-8');
+  }
+
+  /**
+   * Read events starting from offset (0-based event ID).
+   * For repeated polling, pass the last received id + 1 as offset.
+   */
+  tail(offset: number): SwarmEvent[] {
+    if (!fs.existsSync(this.filePath)) return [];
+    const events: SwarmEvent[] = [];
+    const lines = fs.readFileSync(this.filePath, 'utf-8').split('\n');
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const event = JSON.parse(line) as SwarmEvent;
+        if (event.id >= offset) events.push(event);
+      } catch { /* skip corrupt line */ }
+    }
+    return events;
+  }
+
+  /** Remove the event log file and reset the ID counter. */
+  clear(): void {
+    try { fs.unlinkSync(this.filePath); } catch { /* ok */ }
+    this.nextId = 0;
+  }
+}

package/src/bot/task-prompt-builder.ts

@@ -0,0 +1,309 @@
+/**
+ * Build AI prompt from task context with sliding window and 4,000 token cap.
+ *
+ * Prompt structure:
+ *   ## Task: {title}
+ *   {description}
+ *   ### Notes
+ *   ### Relevant Files
+ *   ### Previous Attempts  (last 3 full, older condensed)
+ *   ### Last Error
+ *   ### Parent Context     (title + description + sibling status)
+ *
+ * Truncation cascade when over budget:
+ *   1. Older summaries → one-liners only
+ *   2. File list → only files from last 2 runs
+ *   3. Parent context → title only
+ *   4. Notes → first 500 chars
+ */
+
+import type { Task, RunSummary } from './task-types.js';
+import type { ProfilePreferences } from './profile-types.js';
+
+const MAX_CONTEXT_TOKENS = 4000;
+const CHARS_PER_TOKEN = 4; // rough estimate
+const MAX_CONTEXT_CHARS = MAX_CONTEXT_TOKENS * CHARS_PER_TOKEN;
+const FULL_SUMMARY_COUNT = 3;
+
+export function buildTaskPrompt(
+  task: Task,
+  parentTask?: Task | null,
+  siblingTasks?: Task[],
+  preferences?: ProfilePreferences,
+): string {
+  // Build the full (un-truncated) prompt first
+  const prompt = buildFull(task, parentTask, siblingTasks, preferences);
+
+  if (prompt.length <= MAX_CONTEXT_CHARS) {
+    return prompt;
+  }
+
+  // Over budget — apply truncation cascade progressively
+  return truncatePrompt(task, parentTask, siblingTasks, preferences);
+}
+
+// ---------------------------------------------------------------------------
+// Full prompt builder (no truncation)
+// ---------------------------------------------------------------------------
+
+function buildFull(
+  task: Task,
+  parentTask?: Task | null,
+  siblingTasks?: Task[],
+  preferences?: ProfilePreferences,
+): string {
+  const sections: string[] = [];
+
+  // Always: title + description
+  sections.push(`## Task: ${task.title}\n\n${task.description}`);
+
+  // Notes
+  if (task.context.notes) {
+    sections.push(`### Notes\n${task.context.notes}`);
+  }
+
+  // Files
+  if (task.context.files.length > 0) {
+    sections.push(`### Relevant Files\n${task.context.files.join('\n')}`);
+  }
+
+  // Run summaries: last 3 in full, older condensed
+  const summaries = task.context.runSummaries;
+  if (summaries.length > 0) {
+    const lines: string[] = [];
+    const recentStart = Math.max(0, summaries.length - FULL_SUMMARY_COUNT);
+
+    // Condensed older summaries
+    for (let i = 0; i < recentStart; i++) {
+      lines.push(condenseSummary(summaries[i]!));
+    }
+
+    // Full recent summaries
+    for (let i = recentStart; i < summaries.length; i++) {
+      lines.push(fullSummary(summaries[i]!));
+    }
+
+    sections.push(`### Previous Attempts\n${lines.join('\n')}`);
+  }
+
+  // Last error
+  if (task.context.lastError) {
+    sections.push(`### Last Error\n${task.context.lastError}`);
+  }
+
+  // Execution preferences
+  if (preferences) {
+    sections.push(buildPreferencesSection(preferences));
+  }
+
+  // Parent context
+  if (parentTask) {
+    sections.push(buildParentSection(parentTask, siblingTasks));
+  }
+
+  return sections.join('\n\n');
+}
+
+// ---------------------------------------------------------------------------
+// Truncation cascade
+// ---------------------------------------------------------------------------
+
+function truncatePrompt(
+  task: Task,
+  parentTask?: Task | null,
+  siblingTasks?: Task[],
+  preferences?: ProfilePreferences,
+): string {
+  // Level 1: All summaries condensed to one-liners
+  let result = buildWithTruncation(task, parentTask, siblingTasks, {
+    allSummariesCondensed: true,
+    filesFromRecentRunsOnly: false,
+    parentTitleOnly: false,
+    notesCapped: false,
+  }, preferences);
+  if (result.length <= MAX_CONTEXT_CHARS) return result;
+
+  // Level 2: File list → only files from last 2 runs
+  result = buildWithTruncation(task, parentTask, siblingTasks, {
+    allSummariesCondensed: true,
+    filesFromRecentRunsOnly: true,
+    parentTitleOnly: false,
+    notesCapped: false,
+  }, preferences);
+  if (result.length <= MAX_CONTEXT_CHARS) return result;
+
+  // Level 3: Parent context → title only
+  result = buildWithTruncation(task, parentTask, siblingTasks, {
+    allSummariesCondensed: true,
+    filesFromRecentRunsOnly: true,
+    parentTitleOnly: true,
+    notesCapped: false,
+  }, preferences);
+  if (result.length <= MAX_CONTEXT_CHARS) return result;
+
+  // Level 4: Notes → first 500 chars
+  result = buildWithTruncation(task, parentTask, siblingTasks, {
+    allSummariesCondensed: true,
+    filesFromRecentRunsOnly: true,
+    parentTitleOnly: true,
+    notesCapped: true,
+  }, preferences);
+
+  // Hard-truncate if still over (shouldn't happen with reasonable data)
+  if (result.length > MAX_CONTEXT_CHARS) {
+    return result.slice(0, MAX_CONTEXT_CHARS);
+  }
+
+  return result;
+}
+
+interface TruncationFlags {
+  allSummariesCondensed: boolean;
+  filesFromRecentRunsOnly: boolean;
+  parentTitleOnly: boolean;
+  notesCapped: boolean;
+}
+
+function buildWithTruncation(
+  task: Task,
+  parentTask: Task | null | undefined,
+  siblingTasks: Task[] | undefined,
+  flags: TruncationFlags,
+  preferences?: ProfilePreferences,
+): string {
+  const sections: string[] = [];
+
+  // Always: title + description
+  sections.push(`## Task: ${task.title}\n\n${task.description}`);
+
+  // Notes (potentially capped)
+  if (task.context.notes) {
+    const notes =
+      flags.notesCapped && task.context.notes.length > 500
+        ? task.context.notes.slice(0, 500) + '...'
+        : task.context.notes;
+    sections.push(`### Notes\n${notes}`);
+  }
+
+  // Files (potentially only from recent runs)
+  if (flags.filesFromRecentRunsOnly) {
+    const recentFiles = new Set<string>();
+    for (const s of task.context.runSummaries.slice(-2)) {
+      for (const f of s.filesModified) recentFiles.add(f);
+    }
+    if (recentFiles.size > 0) {
+      sections.push(`### Relevant Files\n${[...recentFiles].join('\n')}`);
+    }
+  } else if (task.context.files.length > 0) {
+    sections.push(`### Relevant Files\n${task.context.files.join('\n')}`);
+  }
+
+  // All summaries condensed
+  if (task.context.runSummaries.length > 0) {
+    if (flags.allSummariesCondensed) {
+      const lines = task.context.runSummaries.map((s) => condenseSummary(s));
+      sections.push(`### Previous Attempts\n${lines.join('\n')}`);
+    } else {
+      // This path isn't used in truncation, but included for completeness
+      const lines: string[] = [];
+      const recentStart = Math.max(0, task.context.runSummaries.length - FULL_SUMMARY_COUNT);
+      for (let i = 0; i < recentStart; i++) {
+        lines.push(condenseSummary(task.context.runSummaries[i]!));
+      }
+      for (let i = recentStart; i < task.context.runSummaries.length; i++) {
+        lines.push(fullSummary(task.context.runSummaries[i]!));
+      }
+      sections.push(`### Previous Attempts\n${lines.join('\n')}`);
+    }
+  }
+
+  // Last error (truncated in aggressive mode)
+  if (task.context.lastError) {
+    const errorText = flags.notesCapped
+      ? task.context.lastError.slice(0, 300)
+      : task.context.lastError;
+    sections.push(`### Last Error\n${errorText}`);
+  }
+
+  // Execution preferences
+  if (preferences) {
+    sections.push(buildPreferencesSection(preferences));
+  }
+
+  // Parent context
+  if (parentTask) {
+    if (flags.parentTitleOnly) {
+      sections.push(`### Parent Context\nPart of: "${parentTask.title}"`);
+    } else {
+      sections.push(buildParentSection(parentTask, siblingTasks));
+    }
+  }
+
+  return sections.join('\n\n');
+}
+
+// ---------------------------------------------------------------------------
+// Formatting helpers
+// ---------------------------------------------------------------------------
+
+function condenseSummary(s: RunSummary): string {
+  return `- Run ${s.runId.slice(0, 8)} (${s.botId}): ${s.outcome} — ${s.summary.slice(0, 80)} (${Math.round(s.durationMs / 1000)}s, ${s.tokensUsed} tok)`;
+}
+
+function fullSummary(s: RunSummary): string {
+  const lines: string[] = [];
+  lines.push(`\n**Run ${s.runId.slice(0, 8)} (${s.botId}) — ${s.outcome}**`);
+  lines.push(s.summary);
+  if (s.filesModified.length > 0) lines.push(`Files: ${s.filesModified.join(', ')}`);
+  if (s.error) lines.push(`Error: ${s.error}`);
+  lines.push(
+    `Duration: ${Math.round(s.durationMs / 1000)}s · Tokens: ${s.tokensUsed} · Cost: $${s.cost.toFixed(3)}`,
+  );
+  return lines.join('\n');
+}
+
+function buildParentSection(
+  parentTask: Task,
+  siblingTasks?: Task[],
+): string {
+  let section = `### Parent Context\nPart of: "${parentTask.title}" — ${parentTask.description}`;
+  if (siblingTasks && siblingTasks.length > 0) {
+    const siblingLines = siblingTasks
+      .map(
+        (s) =>
+          `- ${statusIcon(s.status)} ${s.title} (${s.status})`,
+      )
+      .join('\n');
+    section += `\n\nSibling tasks:\n${siblingLines}`;
+  }
+  return section;
+}
+
+function buildPreferencesSection(preferences: ProfilePreferences): string {
+  const lines = ['## Execution Preferences'];
+  lines.push(`Cost strategy: ${preferences.costStrategy}`);
+  if (preferences.maxCostPerRun !== undefined) {
+    lines.push(`Max cost per run: $${preferences.maxCostPerRun.toFixed(2)}`);
+  }
+  if (preferences.maxCostPerTask !== undefined) {
+    lines.push(`Max cost per task: $${preferences.maxCostPerTask.toFixed(2)}`);
+  }
+  if (preferences.instructions) {
+    lines.push(`Instructions: ${preferences.instructions}`);
+  }
+  lines.push(`Approval required: ${preferences.requireApproval ? 'yes' : 'no'}`);
+  return lines.join('\n');
+}
+
+function statusIcon(status: string): string {
+  switch (status) {
+    case 'done':
+      return '\u2705';
+    case 'failed':
+      return '\u274C';
+    case 'in-progress':
+      return '\u25CF';
+    default:
+      return '\u25CB';
+  }
+}