@sns-myagent/cli 0.2.0 → 0.3.0

package/src/agents/strategies/types.ts

@@ -0,0 +1,68 @@
+/**
+ * Ensemble base types — SNS-MyAgent Phase 5.3
+ *
+ * Shared types for consensus, critic, and best-of-N strategies.
+ */
+
+export interface AgentResponse {
+  /** Agent role that produced this */
+  role: string;
+  /** Model used */
+  model: string;
+  /** Response text */
+  content: string;
+  /** Token usage */
+  tokens?: { input: number; output: number };
+  /** Time taken in ms */
+  timeMs: number;
+  /** Quality score 0-1 (assigned by judge/critic) */
+  score?: number;
+}
+
+export interface EnsembleResult {
+  /** Final selected/merged response */
+  final: string;
+  /** All individual responses */
+  responses: AgentResponse[];
+  /** Strategy used */
+  strategy: string;
+  /** Total rounds executed */
+  rounds: number;
+  /** Total time in ms */
+  totalTimeMs: number;
+  /** Total tokens across all agents */
+  totalTokens: { input: number; output: number };
+  /** Agent that won/produced the final (for best_of_n/consensus) */
+  winner?: string;
+}
+
+export interface EnsembleStrategy {
+  /** Strategy name */
+  readonly name: string;
+  /**
+   * Execute the ensemble strategy.
+   *
+   * @param prompt - The user prompt to send to all agents
+   * @param agents - Available agent role configs
+   * @param executeAgent - Function to spawn an agent and get its response
+   * @returns Final ensemble result
+   */
+  execute(
+    prompt: string,
+    agents: string[],
+    executeAgent: (role: string, prompt: string) => Promise<AgentResponse>,
+  ): Promise<EnsembleResult>;
+}
+
+/**
+ * Aggregate token usage across responses.
+ */
+export function aggregateTokens(responses: AgentResponse[]): { input: number; output: number } {
+  return responses.reduce(
+    (acc, r) => ({
+      input: acc.input + (r.tokens?.input ?? 0),
+      output: acc.output + (r.tokens?.output ?? 0),
+    }),
+    { input: 0, output: 0 },
+  );
+}

package/src/async/__tests__/task-runner.test.ts

@@ -0,0 +1,162 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Runner — Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { TaskStore } from "../task-store";
+import { TaskRunner } from "../task-runner";
+import type { AsyncTask, TaskExecutionResult } from "../types";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let store: TaskStore;
+let runner: TaskRunner;
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "async-runner-test-"));
+  store = new TaskStore(join(tempDir, "test.db"));
+  runner = new TaskRunner(store, { maxConcurrent: 2, defaultTimeoutMs: 5000 });
+});
+
+afterEach(() => {
+  runner.destroy();
+  store.close();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("TaskRunner", () => {
+  it("executes task with registered executor", async () => {
+    runner.registerExecutor("prompt", async (task: AsyncTask): Promise<TaskExecutionResult> => {
+      return { success: true, result: `Done: ${task.description}` };
+    });
+
+    const task = store.create({ description: "test exec" });
+    let notified = false;
+    runner.onNotify((t) => {
+      if (t.id === task.id && t.status === "completed") notified = true;
+    });
+
+    await runner.submit(task);
+    // Wait for async execution
+    await new Promise((r) => setTimeout(r, 100));
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("completed");
+    expect(updated!.result).toBe("Done: test exec");
+    expect(notified).toBe(true);
+  });
+
+  it("fails task when executor throws", async () => {
+    runner.registerExecutor("prompt", async () => {
+      throw new Error("boom");
+    });
+
+    const task = store.create({ description: "fail exec" });
+    await runner.submit(task);
+    await new Promise((r) => setTimeout(r, 100));
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("failed");
+    expect(updated!.error).toBe("boom");
+  });
+
+  it("fails task when no executor registered", async () => {
+    const task = store.create({ description: "no executor", taskType: "shell" });
+    await runner.submit(task);
+    await new Promise((r) => setTimeout(r, 100));
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("failed");
+    expect(updated!.error).toContain("No executor registered");
+  });
+
+  it("cancels running task", async () => {
+    runner.registerExecutor("prompt", async () => {
+      await new Promise((r) => setTimeout(r, 10000));
+      return { success: true };
+    });
+
+    const task = store.create({ description: "long task" });
+    await runner.submit(task);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(runner.isRunning(task.id)).toBe(true);
+    const cancelled = runner.cancel(task.id);
+    expect(cancelled).toBe(true);
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("cancelled");
+  });
+
+  it("cancels pending task", () => {
+    const task = store.create({ description: "pending" });
+    const cancelled = runner.cancel(task.id);
+    expect(cancelled).toBe(true);
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("cancelled");
+  });
+
+  it("respects maxConcurrent limit", async () => {
+    const executionOrder: number[] = [];
+    runner.registerExecutor("prompt", async (task) => {
+      const num = parseInt(task.description);
+      executionOrder.push(num);
+      await new Promise((r) => setTimeout(r, 50));
+      return { success: true, result: `${num}` };
+    });
+
+    const tasks = [
+      store.create({ description: "1" }),
+      store.create({ description: "2" }),
+      store.create({ description: "3" }),
+    ];
+
+    // Submit all at once — first 2 run immediately, 3rd waits for slot
+    for (const t of tasks) {
+      await runner.submit(t);
+    }
+    // Start poll to pick up the 3rd task after a slot opens
+    runner.start(50);
+    await new Promise((r) => setTimeout(r, 500));
+    runner.stop();
+
+    expect(runner.runningCount).toBe(0);
+    for (const t of tasks) {
+      expect(store.getById(t.id)!.status).toBe("completed");
+    }
+  });
+
+  it("destroy cancels all running tasks", async () => {
+    runner.registerExecutor("prompt", async () => {
+      await new Promise((r) => setTimeout(r, 10000));
+      return { success: true };
+    });
+
+    const task = store.create({ description: "destroy me" });
+    await runner.submit(task);
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(runner.runningCount).toBe(1);
+    runner.destroy();
+    expect(runner.runningCount).toBe(0);
+  });
+
+  it("polling picks up pending tasks", async () => {
+    runner.registerExecutor("prompt", async (task) => {
+      return { success: true, result: `polled: ${task.description}` };
+    });
+
+    const task = store.create({ description: "polled task" });
+    // Don't submit — let poll pick it up
+    runner.start(50);
+    await new Promise((r) => setTimeout(r, 200));
+    runner.stop();
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("completed");
+    expect(updated!.result).toBe("polled: polled task");
+  });
+});

package/src/async/__tests__/task-store.test.ts

@@ -0,0 +1,146 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Store — Tests
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { TaskStore } from "../task-store";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+let store: TaskStore;
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), "async-test-"));
+  store = new TaskStore(join(tempDir, "test.db"));
+});
+
+afterEach(() => {
+  store.close();
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+describe("TaskStore", () => {
+  it("creates a task with defaults", () => {
+    const task = store.create({ description: "test task" });
+    expect(task.id).toBeTruthy();
+    expect(task.status).toBe("pending");
+    expect(task.taskType).toBe("prompt");
+    expect(task.description).toBe("test task");
+    expect(task.result).toBeNull();
+    expect(task.error).toBeNull();
+    expect(task.createdAt).toBeGreaterThan(0);
+    expect(task.startedAt).toBeNull();
+    expect(task.completedAt).toBeNull();
+  });
+
+  it("creates a task with custom type and metadata", () => {
+    const task = store.create({
+      description: "shell task",
+      taskType: "shell",
+      metadata: { key: "value" },
+    });
+    expect(task.taskType).toBe("shell");
+    expect(task.metadata).toEqual({ key: "value" });
+  });
+
+  it("getById returns task", () => {
+    const created = store.create({ description: "findable" });
+    const found = store.getById(created.id);
+    expect(found).toBeTruthy();
+    expect(found!.description).toBe("findable");
+  });
+
+  it("getById returns null for missing", () => {
+    expect(store.getById("nonexistent")).toBeNull();
+  });
+
+  it("lists tasks by status", () => {
+    store.create({ description: "a" });
+    store.create({ description: "b" });
+    const task = store.create({ description: "c" });
+    store.updateStatus(task.id, "completed", { result: "done" });
+
+    expect(store.list("pending")).toHaveLength(2);
+    expect(store.list("completed")).toHaveLength(1);
+    expect(store.list()).toHaveLength(3);
+  });
+
+  it("transitions to running", () => {
+    const task = store.create({ description: "run me" });
+    const ok = store.updateStatus(task.id, "running");
+    expect(ok).toBe(true);
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("running");
+    expect(updated!.startedAt).toBeGreaterThan(0);
+  });
+
+  it("transitions to completed with result", () => {
+    const task = store.create({ description: "complete me" });
+    store.updateStatus(task.id, "running");
+    store.updateStatus(task.id, "completed", { result: "all done" });
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("completed");
+    expect(updated!.result).toBe("all done");
+    expect(updated!.completedAt).toBeGreaterThan(0);
+  });
+
+  it("transitions to failed with error", () => {
+    const task = store.create({ description: "fail me" });
+    store.updateStatus(task.id, "running");
+    store.updateStatus(task.id, "failed", { error: "boom" });
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("failed");
+    expect(updated!.error).toBe("boom");
+  });
+
+  it("transitions to cancelled", () => {
+    const task = store.create({ description: "cancel me" });
+    store.updateStatus(task.id, "cancelled");
+
+    const updated = store.getById(task.id);
+    expect(updated!.status).toBe("cancelled");
+  });
+
+  it("delete removes task", () => {
+    const task = store.create({ description: "delete me" });
+    expect(store.delete(task.id)).toBe(true);
+    expect(store.getById(task.id)).toBeNull();
+  });
+
+  it("count returns correct totals", () => {
+    store.create({ description: "a" });
+    store.create({ description: "b" });
+    const c = store.create({ description: "c" });
+    store.updateStatus(c.id, "completed", { result: "ok" });
+
+    const counts = store.count();
+    expect(counts.total).toBe(3);
+    expect(counts.pending).toBe(2);
+    expect(counts.completed).toBe(1);
+    expect(counts.running).toBe(0);
+    expect(counts.failed).toBe(0);
+  });
+
+  it("listPending returns only pending tasks", () => {
+    store.create({ description: "a" });
+    const b = store.create({ description: "b" });
+    store.updateStatus(b.id, "running");
+
+    expect(store.listPending()).toHaveLength(1);
+  });
+
+  it("cleanup removes old completed tasks", () => {
+    const task = store.create({ description: "old" });
+    store.updateStatus(task.id, "completed", { result: "done" });
+
+    // With maxAge=0, everything should be cleaned
+    const cleaned = store.cleanup(0);
+    expect(cleaned).toBe(1);
+    expect(store.getById(task.id)).toBeNull();
+  });
+});

package/src/async/index.ts

@@ -1 +1,28 @@
-export * from "./job-manager";
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Workflow — barrel export
+// ═══════════════════════════════════════════════════════════════════════════
+
+export { TaskStore, getTaskStore } from "./task-store";
+export { TaskRunner, getTaskRunner } from "./task-runner";
+export type { TaskExecutor } from "./task-runner";
+export { AsyncJobManager } from "./job-manager";
+export type {
+	AsyncJob,
+	AsyncJobManagerOptions,
+	AsyncJobDeliveryState,
+	AsyncJobRegisterOptions,
+	AsyncJobFilter,
+} from "./job-manager";
+export { cliNotify, formatTelegramNotify, formatTaskList, formatTaskStatus } from "./notifier";
+export type {
+	AsyncTask,
+	AsyncTaskRow,
+	TaskStatus,
+	TaskActionType,
+	TaskAction,
+	CreateTaskOptions,
+	TaskExecutionResult,
+	NotifyChannel,
+	NotifyCallback,
+	TaskRunnerOptions,
+} from "./types";

package/src/async/notifier.ts

@@ -0,0 +1,133 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Notifier — notification dispatch (CLI + Telegram)
+// ═══════════════════════════════════════════════════════════════════════════
+
+import type { AsyncTask, NotifyCallback, NotifyChannel } from "./types";
+import chalk from "chalk";
+import gradient from "gradient-string";
+
+const STATUS_COLORS: Record<string, (text: string) => string> = {
+  completed: (t) => chalk.green(t),
+  failed: (t) => chalk.red(t),
+  cancelled: (t) => chalk.yellow(t),
+  running: (t) => chalk.cyan(t),
+  pending: (t) => chalk.dim(t),
+};
+
+const STATUS_EMOJI: Record<string, string> = {
+  completed: "✅",
+  failed: "❌",
+  cancelled: "🚫",
+  running: "⏳",
+  pending: "⏸️",
+};
+
+function truncate(text: string | null, maxLen = 200): string {
+  if (!text) return "(no output)";
+  return text.length > maxLen ? text.slice(0, maxLen) + "..." : text;
+}
+
+function formatDuration(startMs: number | null, endMs: number | null): string {
+  if (!startMs) return "";
+  const end = endMs ?? Date.now();
+  const duration = end - startMs;
+  if (duration < 1000) return `${duration}ms`;
+  if (duration < 60000) return `${(duration / 1000).toFixed(1)}s`;
+  return `${Math.floor(duration / 60000)}m ${Math.round((duration % 60000) / 1000)}s`;
+}
+
+/** CLI notification — renders styled block in terminal */
+export const cliNotify: NotifyCallback = (task: AsyncTask, _channel: NotifyChannel) => {
+  const emoji = STATUS_EMOJI[task.status] ?? "❓";
+  const colorFn = STATUS_COLORS[task.status] ?? chalk.white;
+  const duration = formatDuration(task.startedAt, task.completedAt);
+
+  const header = `${emoji} Task ${task.id.slice(0, 8)} — ${colorFn(task.status.toUpperCase())}`;
+  const desc = `   ${chalk.dim("Description:")} ${task.description}`;
+  const time = duration ? `   ${chalk.dim("Duration:")} ${duration}` : "";
+
+  console.log("");
+  console.log(chalk.bold(header));
+  console.log(desc);
+  if (time) console.log(time);
+
+  if (task.status === "completed" && task.result) {
+    console.log(`   ${chalk.dim("Result:")} ${truncate(task.result)}`);
+  }
+  if (task.status === "failed" && task.error) {
+    console.log(`   ${chalk.dim("Error:")} ${chalk.red(truncate(task.error))}`);
+  }
+  console.log("");
+};
+
+/** Telegram notification — formats message for MarkdownV2 */
+export function formatTelegramNotify(task: AsyncTask): string {
+  const emoji = STATUS_EMOJI[task.status] ?? "❓";
+  const duration = formatDuration(task.startedAt, task.completedAt);
+
+  let msg = `${emoji} *Task ${task.id.slice(0, 8)}* — ${task.status.toUpperCase()}\n`;
+  msg += `📋 ${task.description}\n`;
+  if (duration) msg += `⏱ ${duration}\n`;
+
+  if (task.status === "completed" && task.result) {
+    msg += `\n📄 Result:\n\`\`\`\n${truncate(task.result, 500)}\n\`\`\``;
+  }
+  if (task.status === "failed" && task.error) {
+    msg += `\n❌ Error: ${truncate(task.error, 300)}`;
+  }
+
+  return msg;
+}
+
+/** Format task list for display */
+export function formatTaskList(tasks: AsyncTask[]): string {
+  if (tasks.length === 0) return chalk.dim("No tasks found.");
+
+  const lines = [chalk.bold("Async Tasks:"), ""];
+
+  for (const task of tasks) {
+    const emoji = STATUS_EMOJI[task.status] ?? "❓";
+    const colorFn = STATUS_COLORS[task.status] ?? chalk.white;
+    const duration = formatDuration(task.startedAt, task.completedAt);
+    const age = formatAge(task.createdAt);
+
+    lines.push(
+      `  ${emoji} ${chalk.bold(task.id.slice(0, 8))} ${colorFn(task.status.padEnd(10))} ${age} ${duration ? chalk.dim(`(${duration})`) : ""}`,
+    );
+    lines.push(`     ${task.description}`);
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+/** Format single task status */
+export function formatTaskStatus(task: AsyncTask): string {
+  const emoji = STATUS_EMOJI[task.status] ?? "❓";
+  const colorFn = STATUS_COLORS[task.status] ?? chalk.white;
+  const duration = formatDuration(task.startedAt, task.completedAt);
+
+  const lines = [
+    chalk.bold(`${emoji} Task ${task.id}`),
+    `  Status:      ${colorFn(task.status)}`,
+    `  Description: ${task.description}`,
+    `  Type:        ${task.taskType}`,
+    `  Created:     ${new Date(task.createdAt).toISOString()}`,
+  ];
+
+  if (task.startedAt) lines.push(`  Started:     ${new Date(task.startedAt).toISOString()}`);
+  if (task.completedAt) lines.push(`  Completed:   ${new Date(task.completedAt).toISOString()}`);
+  if (duration) lines.push(`  Duration:    ${duration}`);
+  if (task.result) lines.push(`  Result:      ${truncate(task.result, 300)}`);
+  if (task.error) lines.push(`  Error:       ${chalk.red(truncate(task.error, 300))}`);
+
+  return lines.join("\n");
+}
+
+function formatAge(createdAt: number): string {
+  const diff = Date.now() - createdAt;
+  if (diff < 60000) return "just now";
+  if (diff < 3600000) return `${Math.floor(diff / 60000)}m ago`;
+  if (diff < 86400000) return `${Math.floor(diff / 3600000)}h ago`;
+  return `${Math.floor(diff / 86400000)}d ago`;
+}