@sns-myagent/cli 0.2.0 → 0.3.1

package/src/async/task-runner.ts

@@ -0,0 +1,175 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Runner — background execution engine
+// ═══════════════════════════════════════════════════════════════════════════
+
+import type { AsyncTask, TaskExecutionResult, TaskRunnerOptions, NotifyCallback } from "./types";
+import { TaskStore, getTaskStore } from "./task-store";
+
+export type TaskExecutor = (task: AsyncTask) => Promise<TaskExecutionResult>;
+
+export class TaskRunner {
+  #store: TaskStore;
+  #running: Map<string, AbortController> = new Map();
+  #executors: Map<string, TaskExecutor> = new Map();
+  #notifyCallbacks: NotifyCallback[] = [];
+  #maxConcurrent: number;
+  #defaultTimeoutMs: number;
+  #pollTimer: ReturnType<typeof setInterval> | null = null;
+  #destroyed = false;
+
+  constructor(store: TaskStore, options: TaskRunnerOptions = {}) {
+    this.#store = store;
+    this.#maxConcurrent = options.maxConcurrent ?? 3;
+    this.#defaultTimeoutMs = options.defaultTimeoutMs ?? 5 * 60 * 1000; // 5 min default
+  }
+
+  /** Register an executor for a task type */
+  registerExecutor(taskType: string, executor: TaskExecutor): void {
+    this.#executors.set(taskType, executor);
+  }
+
+  /** Register notification callback */
+  onNotify(callback: NotifyCallback): void {
+    this.#notifyCallbacks.push(callback);
+  }
+
+  /** Start the polling loop */
+  start(pollIntervalMs = 5000): void {
+    if (this.#pollTimer) return;
+    this.#pollTimer = setInterval(() => this.#tick(), pollIntervalMs);
+  }
+
+  /** Stop polling */
+  stop(): void {
+    if (this.#pollTimer) {
+      clearInterval(this.#pollTimer);
+      this.#pollTimer = null;
+    }
+  }
+
+  /** Submit a task for background execution */
+  async submit(task: AsyncTask): Promise<void> {
+    if (this.#running.size >= this.#maxConcurrent) {
+      // Will be picked up by poll when a slot opens
+      return;
+    }
+    this.#executeTask(task);
+  }
+
+  /** Cancel a running task */
+  cancel(taskId: string): boolean {
+    const controller = this.#running.get(taskId);
+    if (controller) {
+      controller.abort();
+      this.#running.delete(taskId);
+      this.#store.updateStatus(taskId, "cancelled");
+      return true;
+    }
+    // Maybe it's still pending
+    const task = this.#store.getById(taskId);
+    if (task && task.status === "pending") {
+      this.#store.updateStatus(taskId, "cancelled");
+      return true;
+    }
+    return false;
+  }
+
+  /** Get running task count */
+  get runningCount(): number {
+    return this.#running.size;
+  }
+
+  /** Check if a task is currently running */
+  isRunning(taskId: string): boolean {
+    return this.#running.has(taskId);
+  }
+
+  /** Destroy the runner — cancel all running tasks */
+  destroy(): void {
+    this.#destroyed = true;
+    this.stop();
+    for (const [id, controller] of this.#running) {
+      controller.abort();
+      this.#store.updateStatus(id, "cancelled");
+    }
+    this.#running.clear();
+  }
+
+  // ─── Internal ──────────────────────────────────────────────────────────
+
+  async #tick(): Promise<void> {
+    if (this.#destroyed) return;
+    if (this.#running.size >= this.#maxConcurrent) return;
+
+    const pending = this.#store.listPending(this.#maxConcurrent - this.#running.size);
+    for (const task of pending) {
+      if (this.#running.size >= this.#maxConcurrent) break;
+      this.#executeTask(task);
+    }
+  }
+
+  async #executeTask(task: AsyncTask): Promise<void> {
+    if (this.#destroyed || this.#running.has(task.id)) return;
+
+    const executor = this.#executors.get(task.taskType);
+    if (!executor) {
+      this.#store.updateStatus(task.id, "failed", {
+        error: `No executor registered for task type: ${task.taskType}`,
+      });
+      this.#notify(task);
+      return;
+    }
+
+    const controller = new AbortController();
+    this.#running.set(task.id, controller);
+    this.#store.updateStatus(task.id, "running");
+
+    // Timeout
+    const timeout = setTimeout(() => {
+      controller.abort();
+    }, this.#defaultTimeoutMs);
+
+    try {
+      const result = await executor(task);
+      clearTimeout(timeout);
+
+      if (this.#destroyed) return;
+
+      if (result.success) {
+        this.#store.updateStatus(task.id, "completed", { result: result.result });
+      } else {
+        this.#store.updateStatus(task.id, "failed", { error: result.error ?? "Unknown error" });
+      }
+    } catch (err) {
+      clearTimeout(timeout);
+      if (this.#destroyed) return;
+      const errorMsg = err instanceof Error ? err.message : String(err);
+      this.#store.updateStatus(task.id, "failed", { error: errorMsg });
+    } finally {
+      this.#running.delete(task.id);
+      // Refresh task from store for notification
+      const updated = this.#store.getById(task.id);
+      if (updated) this.#notify(updated);
+    }
+  }
+
+  async #notify(task: AsyncTask): Promise<void> {
+    for (const cb of this.#notifyCallbacks) {
+      try {
+        await cb(task, "cli");
+      } catch {
+        // Don't let notification errors bubble
+      }
+    }
+  }
+}
+
+/** Singleton accessor */
+let _instance: TaskRunner | null = null;
+
+export function getTaskRunner(store?: TaskStore, options?: TaskRunnerOptions): TaskRunner {
+  if (!_instance) {
+    _instance = new TaskRunner(store ?? getTaskStore(), options);
+  }
+  return _instance;
+}

package/src/async/task-store.ts

@@ -0,0 +1,170 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Task Store — SQLite persistence
+// Pattern: mirrors src/cron/cron-store.ts
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import type { AsyncTask, AsyncTaskRow, TaskStatus, CreateTaskOptions } from "./types";
+
+const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS async_tasks (
+  id TEXT PRIMARY KEY,
+  status TEXT NOT NULL DEFAULT 'pending',
+  task_type TEXT NOT NULL DEFAULT 'prompt',
+  description TEXT NOT NULL,
+  result TEXT,
+  error TEXT,
+  created_at INTEGER NOT NULL,
+  started_at INTEGER,
+  completed_at INTEGER,
+  metadata TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_async_tasks_status ON async_tasks(status);
+CREATE INDEX IF NOT EXISTS idx_async_tasks_created ON async_tasks(created_at);
+`;
+
+function rowToTask(row: AsyncTaskRow): AsyncTask {
+  return {
+    id: row.id,
+    status: row.status as TaskStatus,
+    taskType: row.task_type as AsyncTask["taskType"],
+    description: row.description,
+    result: row.result,
+    error: row.error,
+    createdAt: row.created_at,
+    startedAt: row.started_at,
+    completedAt: row.completed_at,
+    metadata: row.metadata ? JSON.parse(row.metadata) : null,
+  };
+}
+
+export class TaskStore {
+  #db: Database;
+
+  constructor(dbPath: string) {
+    mkdirSync(dirname(dbPath), { recursive: true });
+    this.#db = new Database(dbPath);
+    this.#db.exec("PRAGMA journal_mode = WAL");
+    this.#db.exec("PRAGMA foreign_keys = ON");
+    this.#db.exec(SCHEMA_SQL);
+  }
+
+  create(opts: CreateTaskOptions): AsyncTask {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const taskType = opts.taskType ?? "prompt";
+
+    this.#db.run(
+      `INSERT INTO async_tasks (id, status, task_type, description, created_at, metadata)
+       VALUES (?, 'pending', ?, ?, ?, ?)`,
+      [id, taskType, opts.description, now, opts.metadata ? JSON.stringify(opts.metadata) : null],
+    );
+
+    return this.getById(id)!;
+  }
+
+  getById(id: string): AsyncTask | null {
+    const row = this.#db.query<AsyncTaskRow, [string]>(
+      "SELECT * FROM async_tasks WHERE id = ?",
+    ).get(id);
+    return row ? rowToTask(row) : null;
+  }
+
+  list(status?: TaskStatus, limit = 50): AsyncTask[] {
+    const rows = status
+      ? this.#db.query<AsyncTaskRow, [string, number]>(
+          "SELECT * FROM async_tasks WHERE status = ? ORDER BY created_at DESC LIMIT ?",
+        ).all(status, limit)
+      : this.#db.query<AsyncTaskRow, [number]>(
+          "SELECT * FROM async_tasks ORDER BY created_at DESC LIMIT ?",
+        ).all(limit);
+    return rows.map(rowToTask);
+  }
+
+  listPending(limit = 20): AsyncTask[] {
+    return this.list("pending", limit);
+  }
+
+  listRunning(): AsyncTask[] {
+    return this.list("running");
+  }
+
+  updateStatus(id: string, status: TaskStatus, extra?: { result?: string; error?: string }): boolean {
+    const now = Date.now();
+    let sql: string;
+    let params: (string | number | null)[];
+
+    switch (status) {
+      case "running":
+        sql = "UPDATE async_tasks SET status = ?, started_at = ? WHERE id = ?";
+        params = [status, now, id];
+        break;
+      case "completed":
+        sql = "UPDATE async_tasks SET status = ?, completed_at = ?, result = ? WHERE id = ?";
+        params = [status, now, extra?.result ?? null, id];
+        break;
+      case "failed":
+        sql = "UPDATE async_tasks SET status = ?, completed_at = ?, error = ? WHERE id = ?";
+        params = [status, now, extra?.error ?? null, id];
+        break;
+      case "cancelled":
+        sql = "UPDATE async_tasks SET status = ?, completed_at = ? WHERE id = ?";
+        params = [status, now, id];
+        break;
+      default:
+        sql = "UPDATE async_tasks SET status = ? WHERE id = ?";
+        params = [status, id];
+    }
+
+    const stmt = this.#db.prepare(sql);
+    const result = stmt.run(...params);
+    return result.changes > 0;
+  }
+
+  delete(id: string): boolean {
+    const result = this.#db.run("DELETE FROM async_tasks WHERE id = ?", [id]);
+    return result.changes > 0;
+  }
+
+  /** Clean up completed/failed tasks older than maxAgeMs */
+  cleanup(maxAgeMs: number = 7 * 24 * 60 * 60 * 1000): number {
+    const cutoff = Date.now() - maxAgeMs;
+    const result = this.#db.run(
+      "DELETE FROM async_tasks WHERE status IN ('completed', 'failed', 'cancelled') AND completed_at < ?",
+      [cutoff],
+    );
+    return result.changes;
+  }
+
+  count(): { total: number; pending: number; running: number; completed: number; failed: number } {
+    const row = this.#db
+      .prepare(
+        `SELECT
+          COUNT(*) as total,
+          SUM(CASE WHEN status = 'pending' THEN 1 ELSE 0 END) as pending,
+          SUM(CASE WHEN status = 'running' THEN 1 ELSE 0 END) as running,
+          SUM(CASE WHEN status = 'completed' THEN 1 ELSE 0 END) as completed,
+          SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) as failed
+        FROM async_tasks`,
+      )
+      .get() as { total: number; pending: number; running: number; completed: number; failed: number } | null;
+    return row ?? { total: 0, pending: 0, running: 0, completed: 0, failed: 0 };
+  }
+
+  close(): void {
+    this.#db.close();
+  }
+}
+
+/** Singleton accessor */
+let _instance: TaskStore | null = null;
+
+export function getTaskStore(agentDir?: string): TaskStore {
+  if (!_instance) {
+    const dir = agentDir ?? `${process.env.HOME ?? "/tmp"}/.sns-myagent`;
+    _instance = new TaskStore(`${dir}/async/tasks.db`);
+  }
+  return _instance;
+}

package/src/async/types.ts

@@ -0,0 +1,70 @@
+// ═══════════════════════════════════════════════════════════════════════════
+// Async Workflow Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** Task execution status */
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+
+/** Task action type */
+export type TaskActionType = "prompt" | "shell" | "skill";
+
+/** Task action — what to execute */
+export type TaskAction =
+  | { type: "prompt"; prompt: string }
+  | { type: "shell"; command: string }
+  | { type: "skill"; skillName: string; args?: string };
+
+/** Stored async task — domain model (camelCase) */
+export interface AsyncTask {
+  id: string;
+  status: TaskStatus;
+  taskType: TaskActionType;
+  description: string;
+  result: string | null;
+  error: string | null;
+  createdAt: number;
+  startedAt: number | null;
+  completedAt: number | null;
+  metadata: Record<string, unknown> | null;
+}
+
+/** Row shape coming out of SQLite (snake_case) */
+export interface AsyncTaskRow {
+  id: string;
+  status: string;
+  task_type: string;
+  description: string;
+  result: string | null;
+  error: string | null;
+  created_at: number;
+  started_at: number | null;
+  completed_at: number | null;
+  metadata: string | null;
+}
+
+/** Options for creating a new task */
+export interface CreateTaskOptions {
+  description: string;
+  taskType?: TaskActionType;
+  metadata?: Record<string, unknown>;
+}
+
+/** Task execution result */
+export interface TaskExecutionResult {
+  success: boolean;
+  result?: string;
+  error?: string;
+}
+
+/** Notification channel */
+export type NotifyChannel = "cli" | "telegram";
+
+/** Notification callback */
+export type NotifyCallback = (task: AsyncTask, channel: NotifyChannel) => void | Promise<void>;
+
+/** Task runner options */
+export interface TaskRunnerOptions {
+  maxConcurrent?: number;
+  defaultTimeoutMs?: number;
+  pollIntervalMs?: number;
+}

package/src/cli/entry.ts

@@ -13,9 +13,11 @@ const head = argv[0];
 
 // Auto-boot the Telegram polling adapter when a token is present and the
 // user is not explicitly running a different subcommand. Disable with
-// SNS_TELEGRAM_AUTOSTART=0.
+// SNS_TELEGRAM_AUTOSTART=0. Skip for "launch" which starts the full agent
+// session and will wire the adapter after the session is ready.
 function maybeAutostartTelegram(): void {
 	if (head === "telegram") return; // explicit start/stop handles its own lifecycle
+	if (head === "launch") return; // defer to runInteractiveMode in main.ts
 	if (process.env.SNS_TELEGRAM_AUTOSTART === "0") return;
 	const token = process.env.SNS_TELEGRAM_BOT_TOKEN;
 	if (!token) return;

package/src/cli/index.ts

@@ -15,6 +15,7 @@ import { loadConfig, saveConfig, configPath, ensureConfig } from "../config/load
 import type { Config } from "../config/schema.js";
 import { defaultConfigFn } from "../config/loader.js";
 import { startTelegramAdapter, stopTelegramAdapter } from "../adapters/telegram/index.js";
+import { createForwardToAgent, resetChatSession, getBridgeStats } from "../adapters/telegram/bridge.js";
 
 // ---------- package version (single source of truth) ----------
 
@@ -33,7 +34,11 @@ import { fileURLToPath } from "node:url";
 function readPackageVersion(): string {
 	const fromDefine = process.env.PKG_VERSION;
 	if (typeof fromDefine === "string" && fromDefine.length > 0) {
-		return fromDefine;
+		// Bun's --define injects the literal value as written. When the value
+		// is a JSON string (e.g. --define process.env.PKG_VERSION='"0.3.0"'),
+		// the surrounding quotes leak into process.env. Strip them.
+		const stripped = fromDefine.replace(/^["']|["']$/g, "");
+		if (stripped.length > 0) return stripped;
 	}
 	try {
 		const here = dirname(fileURLToPath(import.meta.url));
@@ -74,63 +79,19 @@ function cmdInit(): number {
 	}
 }
 
-function cmdChat(args: string[]): number {
-	const stub = args.includes("--stub");
-	process.stdout.write("snscoder chat — interactive mode\n");
-	if (stub) {
-		process.stdout.write("(stub mode: memory wiring arrives in Phase 2B)\n");
-	}
+async function cmdChat(_args: string[]): Promise<number> {
 	const cfg = loadConfig();
-	if (!cfg) {
-		process.stdout.write("! no config found, run `snscoder init` first\n");
-		process.stdout.write("  starting with in-memory defaults for this session\n");
-	} else {
-		process.stdout.write(`model: ${cfg.model.provider}/${cfg.model.model}\n`);
-		process.stdout.write("type 'exit' to quit\n");
-	}
-	// Readline-style loop using readline from Node built-ins.
-	return runReadlineLoop(cfg);
+	const { runEchoChat } = await import("../tui/chat-ui.js");
+	await runEchoChat({
+		model: cfg?.model.model,
+		provider: cfg?.model.provider,
+		version: PKG_VERSION,
+		agentName: cfg?.agentName ?? "SnsCoder",
+	});
+	return 0;
 }
 
-async function readLine(prompt: string): Promise<string> {
-	const { createInterface } = await import("node:readline/promises");
-	const { stdin, stdout } = await import("node:process");
-	const rl = createInterface({ input: stdin, output: stdout });
-	try {
-		const answer = await rl.question(prompt);
-		return answer;
-	} finally {
-		rl.close();
-	}
-}
 
-function runReadlineLoop(cfg: Config | null): number {
-	// Synchronous-ish loop using readline question/await via deasync-free path.
-	// Keep it simple: each turn re-creates the interface so SIGINT cleanly closes it.
-	const modelLabel = cfg ? `${cfg.model.provider}/${cfg.model.model}` : "defaults";
-	process.stdout.write(`[${modelLabel}] ready.\n`);
-	void (async () => {
-		while (true) {
-			let line: string;
-			try {
-				line = await readLine("you> ");
-			} catch {
-				process.stdout.write("\n");
-				break;
-			}
-			const trimmed = line.trim();
-			if (trimmed === "" || trimmed === "exit" || trimmed === "quit") {
-				process.stdout.write("bye.\n");
-				break;
-			}
-			process.stdout.write(`echo: ${trimmed}\n`);
-		}
-		// Explicit exit so the process actually terminates.
-		process.exit(0);
-	})();
-	// Return a non-zero so Node keeps the event loop alive until readline ends.
-	return 0;
-}
 
 function cmdConfigShow(cfg: Config): number {
 	process.stdout.write(JSON.stringify(cfg, null, 2) + "\n");
@@ -268,7 +229,19 @@ async function cmdTelegram(args: string[]): Promise<number> {
 			process.stderr.write(`✗ telegram start: ${probe.error}\n`);
 			return 1;
 		}
-		const bot = startTelegramAdapter(token, { autostart: true });
+
+		// Wire the agent bridge — per-chat sessions via createAgentSession()
+		const agentForwarder = createForwardToAgent();
+		// Adapt 3-arg bridge to 2-arg handler signature: (text, sessionKey) → string
+		const forwardToAgent = (text: string, sessionKey: string) =>
+			agentForwarder(sessionKey, "telegram", text);
+
+		const bot = startTelegramAdapter(token, {
+			autostart: true,
+			forwardToAgent,
+			resetChatSession,
+			getBridgeStats,
+		});
 		if (!bot) {
 			process.stderr.write("✗ autostart refused by adapter\n");
 			return 1;
@@ -366,10 +339,12 @@ Commands:
   version                     print package version
   init                        create .sns-myagent/config.json (defaults)
   chat [--stub]               start interactive chat (stub for Phase 2B)
+  launch                      start full agent interactive mode
   config show                 print current config
   config get <key>            read a dot-path value (e.g. model.provider)
   config set <key> <value>    update a dot-path value
   telegram start|stop|status  manage the Telegram polling adapter
+  orchestrate <prompt>        multi-agent ensemble run (Phase 5)
   help                        print this help
 `;
 
@@ -394,6 +369,10 @@ export async function runCliAsync(argv: string[]): Promise<number> {
 			return cmdConfig(rest);
 		case "telegram":
 			return cmdTelegram(rest);
+		case "launch":
+			return cmdLaunch(rest);
+		case "orchestrate":
+			return cmdOrchestrate(rest);
 		default:
 			process.stderr.write(`✗ unknown command: ${cmd}\n`);
 			process.stderr.write(HELP);
@@ -401,6 +380,46 @@ export async function runCliAsync(argv: string[]): Promise<number> {
 	}
 }
 
+async function cmdOrchestrate(args: string[]): Promise<number> {
+	if (args.length === 0) {
+		process.stderr.write("✗ orchestrate requires a prompt\n");
+		process.stderr.write("  usage: snscoder orchestrate <prompt>\n");
+		process.stderr.write("  flags:  --strategy consensus|critic|best_of_n\n");
+		process.stderr.write("          --agents role1,role2\n");
+		process.stderr.write("          --ensemble <name>   (from agents.yaml)\n");
+		return 1;
+	}
+	const prompt = args.join(" ");
+	const opts: Record<string, unknown> = {};
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
+		if (a === "--strategy") opts.strategy = args[++i];
+		else if (a === "--agents") opts.agents = (args[++i] ?? "").split(",").filter(Boolean);
+		else if (a === "--ensemble") opts.ensemble = args[++i];
+	}
+	void prompt; void opts; // parsed for future executor wiring (Task 5.1d)
+	try {
+		// CLI wrapper: no real LLM executor yet (Phase 5 stub).
+		// Until agent invocation is wired, surface a clear message instead of silently failing.
+		process.stderr.write(
+			"✗ orchestrate: agent executor not wired in CLI yet.\n" +
+				"  Phase 5 ships the orchestrator module; the CLI integration lands once\n" +
+				"  the LLM agent executor (src/agents/executor.ts) is implemented.\n" +
+				"  For now use the ensemble module directly: import { executeEnsemble } from \"../agents/ensemble.js\".\n",
+		);
+		return 2;
+	} catch (err) {
+		process.stderr.write(`✗ orchestrate failed: ${(err as Error).message}\n`);
+		return 1;
+	}
+}
+
+async function cmdLaunch(args: string[]): Promise<number> {
+	const { main } = await import("../main.js");
+	await main(args);
+	return 0;
+}
+
 export function runCli(argv: string[]): Promise<number> {
 	return runCliAsync(argv);
 }

package/src/config/index.ts

@@ -8,7 +8,7 @@
 
 import * as fs from "node:fs";
 import * as path from "node:path";
-import yaml from "js-yaml";
+import * as yaml from "js-yaml";
 import {
 	type SnsConfig,
 	ensureConfigDir,

package/src/debug/index.ts

@@ -435,7 +435,7 @@ export class DebugSelectorComponent extends Container {
 		if (!suppressed) {
 			const sessionName = this.ctx.sessionManager.getSessionName();
 			const notification: TerminalNotification = {
-				title: sessionName || "Oh My Pi",
+				title: sessionName || "SnsCoder",
 				body: "Terminal protocol test",
 				type: "test",
 				actions: "focus",

package/src/internal-urls/docs-index.generated.txt

@@ -1,2 +0,0 @@
-["configuration.md","faq.md","installation.md","memory.md","tbm.md","terminal-ui.md","troubleshooting.md"]
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