@aion0/forge 0.4.16 → 0.5.0

package/lib/workspace/types.ts

@@ -0,0 +1,231 @@
+/**
+ * Workspace Agent types — core interfaces for the multi-agent workspace system.
+ */
+
+import type { ProviderName, TaskLogEntry } from '@/src/types';
+
+// ─── Agent Config ────────────────────────────────────────
+
+export interface WorkspaceAgentConfig {
+  id: string;
+  label: string;
+  icon: string;
+  // Node type: 'agent' (default) or 'input' (user-provided requirements)
+  type?: 'agent' | 'input';
+  // Input node: append-only entries (latest is active, older are history)
+  content?: string;                    // legacy single content (migrated to entries)
+  entries?: InputEntry[];              // incremental input history
+  role: string;                      // system prompt / role description
+  backend: AgentBackendType;
+  // CLI mode
+  agentId?: string;                  // 'claude' | 'codex' | 'aider'
+  // API mode
+  provider?: ProviderName;
+  model?: string;                    // e.g. 'claude-sonnet-4-6'
+  // Dependencies (replaces inputPaths matching)
+  dependsOn: string[];               // upstream agent IDs to wait for
+  // Working directory (relative to project root, default './' = root)
+  workDir?: string;                  // e.g. 'docs/prd' — where this agent runs
+  // Declared outputs (files or dirs this agent produces)
+  outputs: string[];                 // e.g. ['docs/prd/v1.0.md']
+  // Multi-step execution (user-defined, preset templates provide defaults)
+  steps: AgentStep[];
+  // Approval gate
+  requiresApproval?: boolean;
+  // Watch: autonomous periodic monitoring
+  watch?: WatchConfig;
+}
+
+// ─── Watch Config ─────────────────────────────────────────
+
+export interface WatchTarget {
+  type: 'directory' | 'git' | 'agent_output' | 'command';
+  path?: string;           // directory: relative path; agent_output: agent ID
+  pattern?: string;        // glob for directory, stdout pattern for command
+  cmd?: string;            // shell command (type='command' only)
+}
+
+export type WatchAction = 'log' | 'analyze' | 'approve';
+
+export interface WatchConfig {
+  enabled: boolean;
+  interval: number;        // check interval in seconds (default 60)
+  targets: WatchTarget[];
+  action: WatchAction;     // log=report only, analyze=auto-execute, approve=pending user approval
+  prompt?: string;         // custom prompt for analyze action (default: "Analyze the following changes...")
+}
+
+export type AgentBackendType = 'api' | 'cli';
+
+export interface InputEntry {
+  content: string;
+  timestamp: number;
+}
+
+export interface AgentStep {
+  id: string;
+  label: string;                     // e.g. "Analyze requirements"
+  prompt: string;                    // instruction for this step
+}
+
+// ─── Agent State (Two-Layer Model) ───────────────────────
+
+/** Smith layer: daemon lifecycle */
+export type SmithStatus = 'down' | 'active';
+
+/** Task layer: current work execution */
+export type TaskStatus = 'idle' | 'running' | 'done' | 'failed';
+
+/** Agent execution mode */
+export type AgentMode = 'auto' | 'manual';
+
+/** @deprecated Use SmithStatus + TaskStatus instead */
+export type AgentStatus = SmithStatus | TaskStatus | 'paused' | 'waiting_approval' | 'listening' | 'interrupted';
+
+export interface AgentState {
+  // ─── Smith layer (daemon lifecycle) ─────
+  smithStatus: SmithStatus;           // down=not started, active=listening on bus
+  mode: AgentMode;                    // auto=respond to messages, manual=user in terminal
+
+  // ─── Task layer (current work) ──────────
+  taskStatus: TaskStatus;             // idle/running/done/failed
+
+  // ─── Execution details ──────────────────
+  currentStep?: number;
+  history: TaskLogEntry[];
+  artifacts: Artifact[];
+  logFile?: string;
+  lastCheckpoint?: number;
+  cliSessionId?: string;
+  currentMessageId?: string;          // bus message that triggered current/last task execution
+  tmuxSession?: string;               // tmux session name for manual terminal reattach
+  startedAt?: number;
+  completedAt?: number;
+  error?: string;
+  daemonIteration?: number;           // how many times re-executed after initial steps
+}
+
+// ─── Daemon Wake Reason ──────────────────────────────────
+
+export type DaemonWakeReason =
+  | { type: 'abort' }
+  | { type: 'bus_message'; messages: TaskLogEntry[] }
+  | { type: 'upstream_changed'; agentId: string; files: string[] }
+  | { type: 'input_changed'; content: string }
+  | { type: 'user_message'; content: string };
+
+// ─── Artifact ────────────────────────────────────────────
+
+export interface Artifact {
+  type: 'file' | 'text';
+  path?: string;
+  summary?: string;
+}
+
+// ─── Bus Message ─────────────────────────────────────────
+
+export type MessageCategory = 'notification' | 'ticket';
+
+export type TicketStatus = 'open' | 'in_progress' | 'fixed' | 'verified' | 'closed';
+
+export interface BusMessage {
+  id: string;
+  from: string;                      // source agent ID
+  to: string;                        // target agent ID (no broadcast)
+  type: 'notify' | 'request' | 'response' | 'artifact' | 'ack';
+  payload: {
+    action: string;                  // 'task_complete' | 'step_complete' | 'question' | 'fix_request' | ...
+    content?: string;                // natural language message
+    files?: string[];                // related file paths
+    replyTo?: string;                // reply to which message ID
+  };
+  timestamp: number;
+  // Delivery tracking
+  status?: 'pending' | 'running' | 'done' | 'failed';
+  retries?: number;
+  // Message classification
+  category?: MessageCategory;        // 'notification' (default, follows DAG) | 'ticket' (1-to-1, ignores DAG)
+  // Causal chain — which inbox message triggered this outbox message
+  causedBy?: {
+    messageId: string;               // the inbox message being processed
+    from: string;                    // who sent that inbox message
+    to: string;                      // who received it (this agent)
+  };
+  // Ticket lifecycle (only for category='ticket')
+  ticketStatus?: TicketStatus;
+  ticketRetries?: number;            // how many times this ticket has been retried
+  maxRetries?: number;               // configurable limit (default 3)
+}
+
+// ─── Agent Heartbeat ─────────────────────────────────────
+
+export type AgentLiveness = 'alive' | 'busy' | 'down';
+
+export interface AgentHeartbeat {
+  agentId: string;
+  liveness: AgentLiveness;
+  lastSeen: number;
+  currentStep?: string;
+}
+
+// ─── Workspace State (persistence) ───────────────────────
+
+export interface WorkspaceState {
+  id: string;
+  projectPath: string;
+  projectName: string;
+  agents: WorkspaceAgentConfig[];
+  agentStates: Record<string, AgentState>;
+  nodePositions: Record<string, { x: number; y: number }>;
+  busLog: BusMessage[];
+  busOutbox?: Record<string, BusMessage[]>; // agentId → undelivered messages
+  createdAt: number;
+  updatedAt: number;
+}
+
+// ─── Backend Interface ───────────────────────────────────
+
+export interface StepExecutionParams {
+  config: WorkspaceAgentConfig;
+  step: AgentStep;
+  stepIndex: number;
+  history: TaskLogEntry[];           // accumulated context from prior steps
+  projectPath: string;
+  upstreamContext?: string;          // injected context from upstream agents
+  onLog?: (entry: TaskLogEntry) => void;
+  abortSignal?: AbortSignal;
+  // Bus communication callbacks (injected by orchestrator)
+  onBusSend?: (to: string, content: string) => void;
+  onBusRequest?: (to: string, question: string) => Promise<string>;
+  /** List of other agent IDs in the workspace (for communication tools) */
+  peerAgentIds?: string[];
+  /** Workspace ID — injected as env var for forge skills */
+  workspaceId?: string;
+}
+
+export interface StepExecutionResult {
+  response: string;
+  artifacts: Artifact[];
+  sessionId?: string;                // CLI: conversation ID for --resume
+  inputTokens?: number;
+  outputTokens?: number;
+}
+
+export interface AgentBackend {
+  /** Execute a single step */
+  executeStep(params: StepExecutionParams): Promise<StepExecutionResult>;
+  /** Abort a running step */
+  abort(): void;
+}
+
+// ─── Worker Events ───────────────────────────────────────
+
+export type WorkerEvent =
+  | { type: 'smith_status'; agentId: string; smithStatus: SmithStatus; mode: AgentMode }
+  | { type: 'task_status'; agentId: string; taskStatus: TaskStatus; error?: string }
+  | { type: 'log'; agentId: string; entry: TaskLogEntry }
+  | { type: 'step'; agentId: string; stepIndex: number; stepLabel: string }
+  | { type: 'artifact'; agentId: string; artifact: Artifact }
+  | { type: 'agents_changed'; agents: WorkspaceAgentConfig[]; agentStates?: Record<string, AgentState> }
+  | { type: 'done'; agentId: string; summary: string }
+  | { type: 'error'; agentId: string; error: string };

package/lib/workspace/watch-manager.ts

@@ -0,0 +1,288 @@
+/**
+ * WatchManager — autonomous periodic monitoring for workspace agents.
+ *
+ * Fully independent from message bus / worker / state management.
+ * Detects file changes, git diffs, agent outputs, or custom commands.
+ * Writes results to agent log + emits SSE events. Never sends messages.
+ */
+
+import { EventEmitter } from 'node:events';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { execSync } from 'node:child_process';
+import type { WorkspaceAgentConfig, WatchTarget, WatchConfig } from './types';
+import { appendAgentLog } from './persistence';
+
+// ─── Snapshot types ──────────────────────────────────────
+
+interface WatchSnapshot {
+  lastCheckTime: number;   // timestamp ms — only files modified after this are "changed"
+  gitHash?: string;
+  commandOutput?: string;
+}
+
+interface WatchChange {
+  targetType: WatchTarget['type'];
+  description: string;
+  files: string[];
+}
+
+// ─── Detection functions ─────────────────────────────────
+
+/** Find files modified after `since` timestamp in a directory */
+function findModifiedFiles(dir: string, since: number, pattern?: string, maxDepth = 3): string[] {
+  const modified: string[] = [];
+  if (!existsSync(dir)) return modified;
+
+  const globMatch = pattern
+    ? (name: string) => {
+        if (pattern.startsWith('*.')) return name.endsWith(pattern.slice(1));
+        return name.includes(pattern);
+      }
+    : () => true;
+
+  function walk(current: string, depth: number) {
+    if (depth > maxDepth) return;
+    try {
+      for (const entry of readdirSync(current)) {
+        if (entry.startsWith('.') || entry === 'node_modules') continue;
+        const full = join(current, entry);
+        try {
+          const st = statSync(full);
+          if (st.isDirectory()) {
+            walk(full, depth + 1);
+          } else if (globMatch(entry) && st.mtimeMs > since) {
+            modified.push(relative(dir, full));
+          }
+        } catch {}
+      }
+    } catch {}
+  }
+
+  walk(dir, 0);
+  return modified;
+}
+
+function detectDirectoryChanges(projectPath: string, target: WatchTarget, since: number): { changes: WatchChange | null } {
+  const dir = join(projectPath, target.path || '.');
+  const files = findModifiedFiles(dir, since, target.pattern);
+
+  if (files.length === 0) return { changes: null };
+
+  return {
+    changes: {
+      targetType: 'directory',
+      description: `${target.path || '.'}: ${files.length} file(s) changed`,
+      files: files.slice(0, 20),
+    },
+  };
+}
+
+function detectGitChanges(projectPath: string, prevHash?: string): { changes: WatchChange | null; gitHash: string } {
+  try {
+    const hash = execSync('git rev-parse HEAD', { cwd: projectPath, timeout: 5000 }).toString().trim();
+    if (hash === prevHash) return { changes: null, gitHash: hash };
+
+    // Get diff summary
+    let diffStat = '';
+    try {
+      const cmd = prevHash ? `git diff --stat ${prevHash}..${hash}` : 'git diff --stat HEAD~1';
+      diffStat = execSync(cmd, { cwd: projectPath, timeout: 5000 }).toString().trim();
+    } catch {}
+
+    const files = diffStat.split('\n')
+      .filter(l => l.includes('|'))
+      .map(l => l.trim().split(/\s+\|/)[0].trim())
+      .slice(0, 20);
+
+    return {
+      changes: {
+        targetType: 'git',
+        description: `New commit ${hash.slice(0, 8)}${files.length ? `: ${files.length} files changed` : ''}`,
+        files,
+      },
+      gitHash: hash,
+    };
+  } catch {
+    return { changes: null, gitHash: prevHash || '' };
+  }
+}
+
+function detectCommandChanges(projectPath: string, target: WatchTarget, prevOutput?: string): { changes: WatchChange | null; commandOutput: string } {
+  if (!target.cmd) return { changes: null, commandOutput: prevOutput || '' };
+  try {
+    const output = execSync(target.cmd, { cwd: projectPath, timeout: 30000 }).toString().trim();
+    if (output === prevOutput) return { changes: null, commandOutput: output };
+
+    // Check pattern match if specified
+    if (target.pattern && !output.includes(target.pattern)) {
+      return { changes: null, commandOutput: output };
+    }
+
+    return {
+      changes: {
+        targetType: 'command',
+        description: `Command "${target.cmd.slice(0, 40)}": output changed`,
+        files: [],
+      },
+      commandOutput: output,
+    };
+  } catch {
+    return { changes: null, commandOutput: prevOutput || '' };
+  }
+}
+
+// ─── WatchManager class ──────────────────────────────────
+
+export class WatchManager extends EventEmitter {
+  private timers = new Map<string, NodeJS.Timeout>();
+  private snapshots = new Map<string, WatchSnapshot>();
+
+  constructor(
+    private workspaceId: string,
+    private projectPath: string,
+    private getAgents: () => Map<string, { config: WorkspaceAgentConfig; state: { smithStatus: string; taskStatus: string; mode: string } }>,
+  ) {
+    super();
+  }
+
+  /** Start watch loops for all agents with watch config */
+  start(): void {
+    for (const [id, entry] of this.getAgents()) {
+      if (entry.config.watch?.enabled) {
+        this.startWatch(id, entry.config);
+      }
+    }
+  }
+
+  /** Stop all watch loops */
+  stop(): void {
+    for (const [id, timer] of this.timers) {
+      clearInterval(timer);
+    }
+    this.timers.clear();
+    console.log(`[watch] All watch loops stopped`);
+  }
+
+  /** Start/restart watch for a specific agent */
+  startWatch(agentId: string, config: WorkspaceAgentConfig): void {
+    this.stopWatch(agentId);
+    if (!config.watch?.enabled || config.watch.targets.length === 0) return;
+
+    const interval = Math.max(config.watch.interval || 60, 10) * 1000; // min 10s
+    console.log(`[watch] ${config.label}: started (interval=${interval / 1000}s, targets=${config.watch.targets.length})`);
+
+    // Initialize snapshot on first run (don't alert on existing state)
+    this.runCheck(agentId, config, true);
+
+    const timer = setInterval(() => {
+      const agents = this.getAgents();
+      const entry = agents.get(agentId);
+      if (!entry || entry.state.smithStatus !== 'active') return;
+      // Skip if agent is busy
+      if (entry.state.taskStatus === 'running') return;
+
+      this.runCheck(agentId, config, false);
+    }, interval);
+
+    timer.unref();
+    this.timers.set(agentId, timer);
+  }
+
+  /** Stop watch for a specific agent */
+  stopWatch(agentId: string): void {
+    const timer = this.timers.get(agentId);
+    if (timer) {
+      clearInterval(timer);
+      this.timers.delete(agentId);
+    }
+  }
+
+  /** Run a single check cycle */
+  private runCheck(agentId: string, config: WorkspaceAgentConfig, initialRun: boolean): void {
+    const now = Date.now();
+    const prev = this.snapshots.get(agentId) || { lastCheckTime: now };
+    const allChanges: WatchChange[] = [];
+    const newSnapshot: WatchSnapshot = { lastCheckTime: now };
+
+    for (const target of config.watch!.targets) {
+      switch (target.type) {
+        case 'directory': {
+          const { changes } = detectDirectoryChanges(this.projectPath, target, prev.lastCheckTime);
+          if (changes) allChanges.push(changes);
+          break;
+        }
+        case 'git': {
+          const { changes, gitHash } = detectGitChanges(this.projectPath, prev.gitHash);
+          newSnapshot.gitHash = gitHash;
+          if (changes) allChanges.push(changes);
+          break;
+        }
+        case 'agent_output': {
+          const agents = this.getAgents();
+          const targetAgent = target.path ? agents.get(target.path) : null;
+          if (targetAgent) {
+            for (const outputPath of targetAgent.config.outputs) {
+              const { changes } = detectDirectoryChanges(this.projectPath, { ...target, path: outputPath }, prev.lastCheckTime);
+              if (changes) allChanges.push({ ...changes, targetType: 'agent_output', description: `${targetAgent.config.label} output: ${changes.description}` });
+            }
+          }
+          break;
+        }
+        case 'command': {
+          const { changes, commandOutput } = detectCommandChanges(this.projectPath, target, prev.commandOutput);
+          newSnapshot.commandOutput = commandOutput;
+          if (changes) allChanges.push(changes);
+          break;
+        }
+      }
+    }
+
+    this.snapshots.set(agentId, newSnapshot);
+
+    if (initialRun) {
+      console.log(`[watch] ${config.label}: baseline set (checkTime=${new Date(now).toLocaleTimeString()})`);
+      return;
+    }
+
+    if (allChanges.length === 0) {
+      console.log(`[watch] ${config.label}: checked — no changes`);
+      // Heartbeat: only log to console, don't write to logs.jsonl or agent history
+      // (prevents disk/memory bloat from frequent no-change checks)
+      return;
+    }
+
+    // Build report
+    const summary = allChanges.map(c =>
+      `[${c.targetType}] ${c.description}${c.files.length ? '\n  ' + c.files.join('\n  ') : ''}`
+    ).join('\n');
+
+    console.log(`[watch] ${config.label}: detected ${allChanges.length} change(s)`);
+
+    const entry = { type: 'system' as const, subtype: 'watch_detected', content: `🔍 Watch detected changes:\n${summary}`, timestamp: new Date().toISOString() };
+    appendAgentLog(this.workspaceId, agentId, entry).catch(() => {});
+
+    // Emit SSE event for UI
+    this.emit('watch_alert', {
+      type: 'watch_alert',
+      agentId,
+      entry,
+      changes: allChanges,
+      summary,
+      timestamp: Date.now(),
+    });
+  }
+
+  /** Manual trigger: run check now and return results */
+  triggerCheck(agentId: string): { changes: WatchChange[] } | null {
+    const agents = this.getAgents();
+    const entry = agents.get(agentId);
+    if (!entry?.config.watch?.enabled) return null;
+
+    const prev = this.snapshots.get(agentId) || { files: {} };
+    const allChanges: WatchChange[] = [];
+    // Reuse runCheck logic but capture results
+    this.runCheck(agentId, entry.config, false);
+    return { changes: allChanges };
+  }
+}