@sooneocean/agw 1.4.0

package/src/store/db.ts

@@ -0,0 +1,137 @@
+import Database from 'better-sqlite3';
+import path from 'node:path';
+import fs from 'node:fs';
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS tasks (
+  task_id TEXT PRIMARY KEY,
+  prompt TEXT NOT NULL,
+  working_directory TEXT NOT NULL,
+  preferred_agent TEXT,
+  assigned_agent TEXT,
+  routing_reason TEXT,
+  status TEXT NOT NULL DEFAULT 'pending',
+  priority INTEGER NOT NULL DEFAULT 3,
+  exit_code INTEGER,
+  stdout TEXT,
+  stderr TEXT,
+  stdout_truncated INTEGER NOT NULL DEFAULT 0,
+  stderr_truncated INTEGER NOT NULL DEFAULT 0,
+  duration_ms INTEGER,
+  token_estimate INTEGER,
+  cost_estimate REAL,
+  created_at TEXT NOT NULL,
+  completed_at TEXT,
+  workflow_id TEXT,
+  step_index INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS agents (
+  id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  command TEXT NOT NULL,
+  args TEXT NOT NULL DEFAULT '[]',
+  health_check_command TEXT NOT NULL,
+  enabled INTEGER NOT NULL DEFAULT 1,
+  available INTEGER NOT NULL DEFAULT 0,
+  last_health_check TEXT
+);
+
+CREATE TABLE IF NOT EXISTS audit_log (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id TEXT,
+  event_type TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS workflows (
+  workflow_id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  steps TEXT NOT NULL,
+  mode TEXT NOT NULL DEFAULT 'sequential',
+  status TEXT NOT NULL DEFAULT 'pending',
+  task_ids TEXT NOT NULL DEFAULT '[]',
+  current_step INTEGER NOT NULL DEFAULT 0,
+  working_directory TEXT,
+  priority INTEGER NOT NULL DEFAULT 3,
+  created_at TEXT NOT NULL,
+  completed_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS cost_records (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  task_id TEXT NOT NULL,
+  agent_id TEXT NOT NULL,
+  cost REAL NOT NULL DEFAULT 0,
+  tokens INTEGER NOT NULL DEFAULT 0,
+  recorded_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_tasks_created_at ON tasks(created_at DESC);
+CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+CREATE INDEX IF NOT EXISTS idx_tasks_priority ON tasks(priority DESC, created_at ASC);
+CREATE INDEX IF NOT EXISTS idx_audit_task_id ON audit_log(task_id);
+CREATE INDEX IF NOT EXISTS idx_workflows_status ON workflows(status);
+CREATE TABLE IF NOT EXISTS combos (
+  combo_id TEXT PRIMARY KEY,
+  name TEXT NOT NULL,
+  pattern TEXT NOT NULL,
+  steps TEXT NOT NULL,
+  input TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'pending',
+  task_ids TEXT NOT NULL DEFAULT '[]',
+  step_results TEXT NOT NULL DEFAULT '{}',
+  final_output TEXT,
+  max_iterations INTEGER NOT NULL DEFAULT 3,
+  iterations INTEGER NOT NULL DEFAULT 0,
+  working_directory TEXT,
+  priority INTEGER NOT NULL DEFAULT 3,
+  created_at TEXT NOT NULL,
+  completed_at TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_cost_recorded_at ON cost_records(recorded_at);
+CREATE INDEX IF NOT EXISTS idx_cost_agent ON cost_records(agent_id);
+CREATE TABLE IF NOT EXISTS memory (
+  key TEXT PRIMARY KEY,
+  value TEXT NOT NULL,
+  scope TEXT NOT NULL DEFAULT 'global',
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_combos_status ON combos(status);
+CREATE INDEX IF NOT EXISTS idx_memory_scope ON memory(scope);
+`;
+
+const SEED_AGENTS = [
+  { id: 'claude', name: 'Claude Code', command: 'claude', args: '[]', healthCheckCommand: 'claude --version' },
+  { id: 'codex', name: 'Codex CLI', command: 'codex', args: '[]', healthCheckCommand: 'codex --version' },
+  { id: 'gemini', name: 'Gemini CLI', command: 'gemini', args: '[]', healthCheckCommand: 'gemini --version' },
+];
+
+export function createDatabase(dbPath: string): Database.Database {
+  const dir = path.dirname(dbPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+
+  const db = new Database(dbPath);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  db.exec(SCHEMA);
+
+  // Seed agents if table is empty
+  const count = db.prepare('SELECT COUNT(*) as cnt FROM agents').get() as { cnt: number };
+  if (count.cnt === 0) {
+    const insert = db.prepare(
+      'INSERT INTO agents (id, name, command, args, health_check_command) VALUES (?, ?, ?, ?, ?)'
+    );
+    for (const agent of SEED_AGENTS) {
+      insert.run(agent.id, agent.name, agent.command, agent.args, agent.healthCheckCommand);
+    }
+  }
+
+  return db;
+}

package/src/store/memory-repo.ts

@@ -0,0 +1,46 @@
+import type Database from 'better-sqlite3';
+
+export interface MemoryEntry {
+  key: string;
+  value: string;
+  scope: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export class MemoryRepo {
+  constructor(private db: Database.Database) {}
+
+  set(key: string, value: string, scope: string = 'global'): void {
+    const now = new Date().toISOString();
+    this.db.prepare(
+      `INSERT INTO memory (key, value, scope, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = ?, updated_at = ?`
+    ).run(key, value, scope, now, now, value, now);
+  }
+
+  get(key: string): string | undefined {
+    const row = this.db.prepare('SELECT value FROM memory WHERE key = ?').get(key) as { value: string } | undefined;
+    return row?.value;
+  }
+
+  getByScope(scope: string): MemoryEntry[] {
+    return this.db.prepare('SELECT * FROM memory WHERE scope = ? ORDER BY updated_at DESC').all(scope) as MemoryEntry[];
+  }
+
+  delete(key: string): boolean {
+    const result = this.db.prepare('DELETE FROM memory WHERE key = ?').run(key);
+    return result.changes > 0;
+  }
+
+  list(limit: number = 50): MemoryEntry[] {
+    return this.db.prepare('SELECT * FROM memory ORDER BY updated_at DESC LIMIT ?').all(limit) as MemoryEntry[];
+  }
+
+  search(query: string): MemoryEntry[] {
+    return this.db.prepare(
+      'SELECT * FROM memory WHERE key LIKE ? OR value LIKE ? ORDER BY updated_at DESC LIMIT 20'
+    ).all(`%${query}%`, `%${query}%`) as MemoryEntry[];
+  }
+}

package/src/store/task-repo.ts

@@ -0,0 +1,127 @@
+import type Database from 'better-sqlite3';
+import type { TaskDescriptor, TaskResult, TaskStatus } from '../types.js';
+
+interface TaskRow {
+  task_id: string;
+  prompt: string;
+  working_directory: string;
+  preferred_agent: string | null;
+  assigned_agent: string | null;
+  routing_reason: string | null;
+  status: string;
+  priority: number;
+  exit_code: number | null;
+  stdout: string | null;
+  stderr: string | null;
+  stdout_truncated: number;
+  stderr_truncated: number;
+  duration_ms: number | null;
+  token_estimate: number | null;
+  cost_estimate: number | null;
+  created_at: string;
+  completed_at: string | null;
+  workflow_id: string | null;
+  step_index: number | null;
+}
+
+function rowToTask(row: TaskRow): TaskDescriptor {
+  const task: TaskDescriptor = {
+    taskId: row.task_id,
+    prompt: row.prompt,
+    workingDirectory: row.working_directory,
+    status: row.status as TaskStatus,
+    priority: row.priority ?? 3,
+    createdAt: row.created_at,
+  };
+  if (row.preferred_agent) task.preferredAgent = row.preferred_agent;
+  if (row.assigned_agent) task.assignedAgent = row.assigned_agent;
+  if (row.routing_reason) task.routingReason = row.routing_reason;
+  if (row.completed_at) task.completedAt = row.completed_at;
+  if (row.workflow_id) task.workflowId = row.workflow_id;
+  if (row.step_index !== null) task.stepIndex = row.step_index;
+  if (row.exit_code !== null) {
+    task.result = {
+      exitCode: row.exit_code,
+      stdout: row.stdout ?? '',
+      stderr: row.stderr ?? '',
+      stdoutTruncated: row.stdout_truncated === 1,
+      stderrTruncated: row.stderr_truncated === 1,
+      durationMs: row.duration_ms ?? 0,
+      tokenEstimate: row.token_estimate ?? undefined,
+      costEstimate: row.cost_estimate ?? undefined,
+    };
+  }
+  return task;
+}
+
+export class TaskRepo {
+  constructor(private db: Database.Database) {}
+
+  create(task: Pick<TaskDescriptor, 'taskId' | 'prompt' | 'workingDirectory' | 'status' | 'createdAt' | 'preferredAgent' | 'priority' | 'workflowId' | 'stepIndex'>): void {
+    this.db.prepare(
+      `INSERT INTO tasks (task_id, prompt, working_directory, preferred_agent, status, priority, created_at, workflow_id, step_index)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(task.taskId, task.prompt, task.workingDirectory, task.preferredAgent ?? null, task.status, task.priority ?? 3, task.createdAt, task.workflowId ?? null, task.stepIndex ?? null);
+  }
+
+  listQueued(): TaskDescriptor[] {
+    const rows = this.db.prepare(
+      `SELECT * FROM tasks WHERE status = 'pending' ORDER BY priority DESC, created_at ASC`
+    ).all() as TaskRow[];
+    return rows.map(rowToTask);
+  }
+
+  countRunningByAgent(agentId: string): number {
+    const row = this.db.prepare(
+      `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_agent = ? AND status = 'running'`
+    ).get(agentId) as { cnt: number };
+    return row.cnt;
+  }
+
+  getById(taskId: string): TaskDescriptor | undefined {
+    const row = this.db.prepare('SELECT * FROM tasks WHERE task_id = ?').get(taskId) as TaskRow | undefined;
+    return row ? rowToTask(row) : undefined;
+  }
+
+  updateStatus(taskId: string, status: TaskStatus, assignedAgent?: string, routingReason?: string): void {
+    if (assignedAgent !== undefined) {
+      this.db.prepare(
+        'UPDATE tasks SET status = ?, assigned_agent = ?, routing_reason = ? WHERE task_id = ?'
+      ).run(status, assignedAgent, routingReason ?? null, taskId);
+    } else {
+      this.db.prepare('UPDATE tasks SET status = ? WHERE task_id = ?').run(status, taskId);
+    }
+  }
+
+  updateResult(taskId: string, result: TaskResult): void {
+    this.db.prepare(
+      `UPDATE tasks SET exit_code = ?, stdout = ?, stderr = ?,
+       stdout_truncated = ?, stderr_truncated = ?,
+       duration_ms = ?, token_estimate = ?, cost_estimate = ?,
+       completed_at = ?
+       WHERE task_id = ?`
+    ).run(
+      result.exitCode, result.stdout, result.stderr,
+      result.stdoutTruncated ? 1 : 0, result.stderrTruncated ? 1 : 0,
+      result.durationMs, result.tokenEstimate ?? null, result.costEstimate ?? null,
+      new Date().toISOString(),
+      taskId
+    );
+  }
+
+  list(limit: number = 20, offset: number = 0): TaskDescriptor[] {
+    const rows = this.db.prepare(
+      'SELECT * FROM tasks ORDER BY created_at DESC LIMIT ? OFFSET ?'
+    ).all(limit, offset) as TaskRow[];
+    return rows.map(rowToTask);
+  }
+
+  countByStatus(): Record<string, number> {
+    const rows = this.db.prepare(
+      'SELECT status, COUNT(*) as cnt FROM tasks GROUP BY status'
+    ).all() as { status: string; cnt: number }[];
+    const result: Record<string, number> = {};
+    for (const r of rows) result[r.status] = r.cnt;
+    return result;
+  }
+}

package/src/store/workflow-repo.ts

@@ -0,0 +1,69 @@
+import type Database from 'better-sqlite3';
+import type { WorkflowDescriptor, WorkflowStatus, WorkflowStep, StepMode } from '../types.js';
+
+interface WorkflowRow {
+  workflow_id: string;
+  name: string;
+  steps: string;
+  mode: string;
+  status: string;
+  task_ids: string;
+  current_step: number;
+  working_directory: string | null;
+  priority: number;
+  created_at: string;
+  completed_at: string | null;
+}
+
+function rowToWorkflow(row: WorkflowRow): WorkflowDescriptor {
+  return {
+    workflowId: row.workflow_id,
+    name: row.name,
+    steps: JSON.parse(row.steps) as WorkflowStep[],
+    mode: row.mode as StepMode,
+    status: row.status as WorkflowStatus,
+    taskIds: JSON.parse(row.task_ids) as string[],
+    currentStep: row.current_step,
+    createdAt: row.created_at,
+    completedAt: row.completed_at ?? undefined,
+  };
+}
+
+export class WorkflowRepo {
+  constructor(private db: Database.Database) {}
+
+  create(wf: Pick<WorkflowDescriptor, 'workflowId' | 'name' | 'steps' | 'mode' | 'status' | 'createdAt'> & { workingDirectory?: string; priority?: number }): void {
+    this.db.prepare(
+      `INSERT INTO workflows (workflow_id, name, steps, mode, status, working_directory, priority, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(wf.workflowId, wf.name, JSON.stringify(wf.steps), wf.mode, wf.status, wf.workingDirectory ?? null, wf.priority ?? 3, wf.createdAt);
+  }
+
+  getById(workflowId: string): WorkflowDescriptor | undefined {
+    const row = this.db.prepare('SELECT * FROM workflows WHERE workflow_id = ?').get(workflowId) as WorkflowRow | undefined;
+    return row ? rowToWorkflow(row) : undefined;
+  }
+
+  updateStatus(workflowId: string, status: WorkflowStatus): void {
+    const completedAt = status === 'completed' || status === 'failed' ? new Date().toISOString() : null;
+    this.db.prepare('UPDATE workflows SET status = ?, completed_at = ? WHERE workflow_id = ?').run(status, completedAt, workflowId);
+  }
+
+  updateStep(workflowId: string, currentStep: number): void {
+    this.db.prepare('UPDATE workflows SET current_step = ? WHERE workflow_id = ?').run(currentStep, workflowId);
+  }
+
+  addTaskId(workflowId: string, taskId: string): void {
+    // Atomic JSON array append — no read-modify-write race
+    this.db.prepare(
+      `UPDATE workflows SET task_ids = json_insert(task_ids, '$[#]', ?) WHERE workflow_id = ?`
+    ).run(taskId, workflowId);
+  }
+
+  list(limit: number = 20, offset: number = 0): WorkflowDescriptor[] {
+    const rows = this.db.prepare(
+      'SELECT * FROM workflows ORDER BY created_at DESC LIMIT ? OFFSET ?'
+    ).all(limit, offset) as WorkflowRow[];
+    return rows.map(rowToWorkflow);
+  }
+}

package/src/types.ts

@@ -0,0 +1,208 @@
+// Task types
+export type TaskStatus = 'pending' | 'routing' | 'running' | 'completed' | 'failed';
+
+export interface TaskResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  stdoutTruncated: boolean;
+  stderrTruncated: boolean;
+  durationMs: number;
+  tokenEstimate?: number;
+  costEstimate?: number;
+}
+
+export interface TaskDescriptor {
+  taskId: string;
+  prompt: string;
+  preferredAgent?: string;
+  workingDirectory: string;
+  status: TaskStatus;
+  assignedAgent?: string;
+  routingReason?: string;
+  priority: number;
+  createdAt: string;
+  completedAt?: string;
+  result?: TaskResult;
+  workflowId?: string;
+  stepIndex?: number;
+}
+
+export interface CreateTaskRequest {
+  prompt: string;
+  preferredAgent?: string;
+  workingDirectory?: string;
+  priority?: number;
+  workflowId?: string;
+  stepIndex?: number;
+}
+
+// Priority: 1 = lowest, 5 = highest, 3 = default
+export type TaskPriority = 1 | 2 | 3 | 4 | 5;
+
+// Agent types
+export interface AgentDescriptor {
+  id: string;
+  name: string;
+  command: string;
+  args: string[];
+  enabled: boolean;
+  available: boolean;
+  healthCheckCommand: string;
+  lastHealthCheck?: string;
+}
+
+export interface UnifiedAgent {
+  describe(): AgentDescriptor;
+  execute(task: TaskDescriptor): Promise<TaskResult>;
+  healthCheck(): Promise<boolean>;
+  on(event: string, listener: (...args: unknown[]) => void): this;
+  removeListener(event: string, listener: (...args: unknown[]) => void): this;
+}
+
+// Router types
+export interface RouteDecision {
+  agentId: string;
+  reason: string;
+  confidence: number;
+}
+
+// Audit types
+export type AuditEventType =
+  | 'task.created'
+  | 'task.routed'
+  | 'task.started'
+  | 'task.completed'
+  | 'task.failed'
+  | 'task.queued'
+  | 'agent.health'
+  | 'workflow.created'
+  | 'workflow.step'
+  | 'workflow.completed'
+  | 'workflow.failed'
+  | 'cost.quota_exceeded'
+  | 'combo.created'
+  | 'combo.step'
+  | 'combo.iteration'
+  | 'combo.completed'
+  | 'combo.failed';
+
+// Workflow types
+export type WorkflowStatus = 'pending' | 'running' | 'completed' | 'failed';
+export type StepMode = 'sequential' | 'parallel';
+
+export interface WorkflowStep {
+  prompt: string;
+  preferredAgent?: string;
+}
+
+export interface WorkflowDescriptor {
+  workflowId: string;
+  name: string;
+  steps: WorkflowStep[];
+  mode: StepMode;
+  status: WorkflowStatus;
+  taskIds: string[];
+  currentStep: number;
+  createdAt: string;
+  completedAt?: string;
+}
+
+export interface CreateWorkflowRequest {
+  name: string;
+  steps: WorkflowStep[];
+  mode?: StepMode;
+  workingDirectory?: string;
+  priority?: number;
+}
+
+// Combo types — multi-agent collaboration patterns
+export type ComboStatus = 'pending' | 'running' | 'completed' | 'failed';
+
+export type ComboPattern = 'pipeline' | 'map-reduce' | 'review-loop' | 'debate';
+
+export interface ComboStep {
+  /** Agent to use for this step */
+  agent: string;
+  /** Prompt template. Use {{prev}} for previous step output, {{step.N}} for specific step output, {{input}} for original input */
+  prompt: string;
+  /** Role label for this step (e.g., "analyzer", "reviewer", "synthesizer") */
+  role?: string;
+}
+
+export interface ComboDescriptor {
+  comboId: string;
+  name: string;
+  pattern: ComboPattern;
+  steps: ComboStep[];
+  input: string;
+  status: ComboStatus;
+  taskIds: string[];
+  stepResults: Record<number, string>; // step index → stdout
+  finalOutput?: string;
+  maxIterations?: number; // for review-loop
+  iterations?: number;
+  createdAt: string;
+  completedAt?: string;
+}
+
+export interface CreateComboRequest {
+  name: string;
+  pattern: ComboPattern;
+  steps: ComboStep[];
+  input: string;
+  workingDirectory?: string;
+  priority?: number;
+  maxIterations?: number; // for review-loop, default 3
+}
+
+// Built-in combo presets
+export interface ComboPreset {
+  id: string;
+  name: string;
+  description: string;
+  pattern: ComboPattern;
+  steps: ComboStep[];
+  maxIterations?: number;
+}
+
+// Cost types
+export interface CostSummary {
+  daily: number;
+  monthly: number;
+  allTime: number;
+  byAgent: Record<string, number>;
+  dailyLimit?: number;
+  monthlyLimit?: number;
+}
+
+export interface AuditEntry {
+  id?: number;
+  taskId?: string;
+  eventType: AuditEventType;
+  payload: Record<string, unknown>;
+  createdAt: string;
+}
+
+// Config types
+export interface AgentConfig {
+  enabled: boolean;
+  command: string;
+  args: string[];
+}
+
+export interface AppConfig {
+  version?: string;
+  port: number;
+  anthropicApiKey: string;
+  routerModel: string;
+  defaultTimeout: number;
+  authToken?: string;
+  maxConcurrencyPerAgent: number;
+  dailyCostLimit?: number;
+  monthlyCostLimit?: number;
+  allowedWorkspaces?: string[];
+  maxPromptLength: number;
+  maxWorkflowSteps: number;
+  agents: Record<string, AgentConfig>;
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "outDir": "dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true
+  },
+  "include": ["src/**/*", "bin/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}