@kata-sh/pi-symphony-extension 0.1.0

package/src/commands.ts

@@ -0,0 +1,218 @@
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { KeyId } from "@earendil-works/pi-tui";
+import { assertLoopbackAttachUrl, resolveAttachUrl } from "./attach-url-policy.ts";
+import { closeActiveConsole, handleActiveConsoleShortcut, openConsole, type ConsoleShortcutAction } from "./console.ts";
+import { formatError, SymphonyExtensionError } from "./errors.ts";
+import { parseAttachArgs, parseDoctorArgs, parseInitArgs, parseStartArgs, parseSteerArgs } from "./command-args.ts";
+import { withSymphonyLoader, withSymphonyProgress } from "./progress.ts";
+import type { SymphonyRuntime } from "./runtime.ts";
+import { cleanupAbortedStart } from "./runtime-helpers.ts";
+import { resolveStartWorkflow } from "./workflow-resolver.ts";
+
+export function registerSymphonyCommands(pi: ExtensionAPI, runtime: SymphonyRuntime): void {
+  registerConsoleShortcuts(pi);
+
+  pi.registerCommand("symphony:help", {
+    description: "Show Symphony extension commands and current status",
+    handler: async (_args, ctx) => {
+      ctx.ui.notify(helpText(runtime), "info");
+    },
+  });
+
+  pi.registerCommand("symphony:init", {
+    description: "Run symphony init in the current Pi working directory",
+    handler: async (args, ctx) => runCommandHandler(ctx, async () => withSymphonyLoader(ctx, { message: "Initializing Symphony...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async (signal) => {
+      const parsed = parseInitArgs(args);
+      const binary = await runtime.resolveBinary(ctx);
+      const result = await pi.exec(binary, parsed.force ? ["init", "--force"] : ["init"], { cwd: ctx.cwd, signal });
+      if (result.code !== 0) throw new SymphonyExtensionError("command_failed", "symphony init failed", { cwd: ctx.cwd, code: result.code, stderr: result.stderr });
+      runtime.persist(pi);
+      ctx.ui.notify(result.stdout.trim() || "symphony init completed", "info");
+    })),
+  });
+
+  pi.registerCommand("symphony:doctor", {
+    description: "Run symphony doctor in the current Pi working directory",
+    handler: async (args, ctx) => runCommandHandler(ctx, async () => withSymphonyLoader(ctx, { message: "Running Symphony doctor...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async (signal) => {
+      const parsed = parseDoctorArgs(args);
+      const binary = await runtime.resolveBinary(ctx);
+      const commandArgs = parsed.workflow ? ["doctor", parsed.workflow] : ["doctor"];
+      const result = await pi.exec(binary, commandArgs, { cwd: ctx.cwd, signal });
+      if (result.code !== 0) throw new SymphonyExtensionError("command_failed", "symphony doctor failed", { cwd: ctx.cwd, code: result.code, stderr: result.stderr });
+      runtime.persist(pi);
+      ctx.ui.notify(result.stdout.trim() || "symphony doctor completed", "info");
+    })),
+  });
+
+  pi.registerCommand("symphony:start", {
+    description: "Start Symphony headlessly, attach to the HTTP API, and open the console",
+    handler: async (args, ctx) => runCommandHandler(ctx, async () => withSymphonyLoader(ctx, { message: "Starting Symphony...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async (signal) => {
+      let startedBaseUrl: string | undefined;
+      try {
+        const parsed = parseStartArgs(args);
+        const workflow = await resolveStartWorkflow(ctx.cwd, parsed.workflow);
+        const binary = await runtime.resolveBinary(ctx);
+        const started = await runtime.processManager.start({ binary, cwd: ctx.cwd, workflow, signal });
+        startedBaseUrl = started.baseUrl;
+        await runtime.attach(started.baseUrl, signal);
+        if (signal.aborted) {
+          await cleanupAbortedStart(runtime, startedBaseUrl);
+          runtime.persist(pi);
+          setSymphonyStatus(ctx, runtime);
+          return;
+        }
+        runtime.persist(pi);
+        setSymphonyStatus(ctx, runtime);
+        ctx.ui.notify(`Symphony started at ${started.baseUrl}`, "info");
+        await openConsole(ctx, runtime);
+      } catch (error) {
+        if (signal.aborted && startedBaseUrl) {
+          await cleanupAbortedStart(runtime, startedBaseUrl);
+          runtime.persist(pi);
+          setSymphonyStatus(ctx, runtime);
+        }
+        throw error;
+      }
+    })),
+  });
+
+  pi.registerCommand("symphony:attach", {
+    description: "Attach to an existing Symphony HTTP server, or the Pi-owned server when no URL is provided",
+    handler: async (args, ctx) => runCommandHandler(ctx, async () => withSymphonyProgress(ctx, { message: "Attaching to Symphony...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async () => {
+      const parsed = parseAttachArgs(args);
+      const url = resolveAttachUrl(parsed.url, runtime.state.ownedProcess);
+      assertLoopbackAttachUrl(url);
+      await runtime.attach(url);
+      runtime.persist(pi);
+      setSymphonyStatus(ctx, runtime);
+      ctx.ui.notify(`Attached to Symphony at ${runtime.state.attachedBaseUrl}`, "info");
+    })),
+  });
+
+  pi.registerCommand("symphony:console", {
+    description: "Open the Symphony console",
+    handler: async (_args, ctx) => runCommandHandler(ctx, async () => {
+      await openConsole(ctx, runtime);
+    }),
+  });
+
+  pi.registerCommand("symphony:detach", {
+    description: "Detach Pi from the current Symphony server without stopping it",
+    handler: async (_args, ctx) => runCommandHandler(ctx, async () => {
+      const attachedBaseUrl = runtime.state.attachedBaseUrl;
+      if (!attachedBaseUrl) {
+        ctx.ui.notify("No Symphony instance is attached.", "info");
+        return;
+      }
+
+      closeActiveConsole(ctx);
+      runtime.clearAttachment();
+      runtime.persist(pi);
+      setSymphonyStatus(ctx, runtime);
+      ctx.ui.notify(`Detached from Symphony at ${attachedBaseUrl}.`, "info");
+    }),
+  });
+
+  pi.registerCommand("symphony:status", {
+    description: "Show Symphony attachment and process status",
+    handler: async (_args, ctx) => runCommandHandler(ctx, async () => {
+      if (runtime.client) await runtime.refreshState();
+      runtime.persist(pi);
+      ctx.ui.notify(runtime.statusText(), "info");
+    }),
+  });
+
+  pi.registerCommand("symphony:refresh", {
+    description: "Request an immediate Symphony poll refresh",
+    handler: async (_args, ctx) => runCommandHandler(ctx, async () => withSymphonyProgress(ctx, { message: "Refreshing Symphony...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async () => {
+      await runtime.requestRefresh();
+      runtime.persist(pi);
+      ctx.ui.notify(`Symphony refresh requested; ${runtimeCountsText(runtime)}`, "info");
+    })),
+  });
+
+  pi.registerCommand("symphony:steer", {
+    description: "Send an operator instruction to a running Symphony worker",
+    handler: async (args, ctx) => runCommandHandler(ctx, async () => withSymphonyProgress(ctx, { message: "Sending steer instruction...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async (signal) => {
+      const parsed = parseSteerArgs(args);
+      const result = await runtime.steerWorker(parsed.issueIdentifier, parsed.instruction, signal);
+      runtime.persist(pi);
+      ctx.ui.notify(`Steer delivered to ${result.issueIdentifier}: ${result.instructionPreview}`, "info");
+    })),
+  });
+
+  pi.registerCommand("symphony:stop", {
+    description: "Stop a Symphony process started by this extension",
+    handler: async (_args, ctx) => runCommandHandler(ctx, async () => withSymphonyProgress(ctx, { message: "Stopping Symphony...", restoreStatus: (ctx) => setSymphonyStatus(ctx, runtime) }, async () => {
+      const ownedBaseUrl = runtime.state.ownedProcess?.baseUrl;
+      await runtime.processManager.stopOwned();
+      runtime.clearAttachmentIfBaseUrl(ownedBaseUrl);
+      runtime.persist(pi);
+      setSymphonyStatus(ctx, runtime);
+      ctx.ui.notify("Stopped owned Symphony process", "info");
+    })),
+  });
+}
+
+function registerConsoleShortcuts(pi: ExtensionAPI): void {
+  const shortcuts = [
+    { key: "ctrl+shift+up", action: "selectPrevious", description: "Select previous Symphony console item" },
+    { key: "ctrl+shift+down", action: "selectNext", description: "Select next Symphony console item" },
+    { key: "ctrl+shift+r", action: "refresh", description: "Refresh the Symphony console" },
+    { key: "ctrl+shift+t", action: "steer", description: "Steer the selected Symphony console worker" },
+    { key: "ctrl+shift+e", action: "respondEscalation", description: "Respond to the selected Symphony console escalation" },
+    { key: "ctrl+shift+i", action: "toggleDetails", description: "Toggle Symphony console item details" },
+    { key: "ctrl+shift+q", action: "close", description: "Close the Symphony console widget" },
+  ] as const satisfies ReadonlyArray<{ key: KeyId; action: ConsoleShortcutAction; description: string }>;
+
+  for (const shortcut of shortcuts) {
+    pi.registerShortcut(shortcut.key, {
+      description: shortcut.description,
+      handler: async (ctx) => {
+        await handleActiveConsoleShortcut(shortcut.action, ctx);
+      },
+    });
+  }
+}
+
+export function setSymphonyStatus(ctx: Pick<ExtensionContext, "ui">, runtime: SymphonyRuntime): void {
+  ctx.ui.setStatus("symphony", runtime.state.attachedBaseUrl ? `symphony ${runtime.state.attachedBaseUrl}` : "symphony detached");
+}
+
+async function runCommandHandler(ctx: ExtensionCommandContext, fn: () => Promise<void>): Promise<void> {
+  try {
+    await fn();
+  } catch (error) {
+    ctx.ui.notify(formatError(error), "error");
+  }
+}
+
+function runtimeCountsText(runtime: SymphonyRuntime): string {
+  const state = runtime.state.lastKnownState;
+  if (!state) return "state unavailable";
+  return `running ${state.runningCount}, retry ${state.retryCount}, blocked ${state.blockedCount}, completed ${state.completedCount}`;
+}
+
+function helpText(runtime: SymphonyRuntime): string {
+  return [
+    "Symphony Pi extension",
+    runtime.statusText(),
+    "",
+    "Commands:",
+    "/symphony:init [--force]",
+    "/symphony:doctor [workflow]",
+    "/symphony:start [workflow]",
+    "/symphony:attach [url]",
+    "/symphony:detach",
+    "/symphony:console",
+    "/symphony:status",
+    "/symphony:refresh",
+    "/symphony:steer <ISSUE> <instruction>",
+    "/symphony:stop",
+    "",
+    "Console keys:",
+    "↑/↓ select items",
+    "r refresh, s steer selected running worker, e respond to selected escalation",
+    "d details, q/Escape close",
+  ].join("\n");
+}

package/src/console-model.test.ts

@@ -0,0 +1,252 @@
+import { describe, expect, it } from "vitest";
+import { buildEscalationRows, buildIssueRows, buildWorkerRows, formatEventRows } from "./console-model.ts";
+import type { SymphonyEventEnvelope, SymphonyStateResponse } from "./http-client.ts";
+
+function stateFixture(): SymphonyStateResponse {
+  return {
+    tracker_project_url: "https://linear.app/kata-sh/project/symphony",
+    running: {
+      "issue-123": {
+        issue_id: "issue-123",
+        issue_identifier: "SIM-123",
+        issue_title: "Worker one",
+        attempt: 2,
+        workspace_path: "/tmp/symphony/issue-123",
+        started_at: "2026-05-14T12:00:00Z",
+        status: "running",
+        worker_host: "worker-a",
+        tracker_state: "In Progress",
+      },
+      "issue-777": {
+        issue_id: "issue-777",
+        issue_identifier: "SIM-777",
+        issue_title: "Worker two",
+        workspace_path: "/tmp/symphony/issue-777",
+        started_at: "2026-05-14T12:05:00Z",
+        status: "running",
+        error: "agent exited after a very long error message that needs to be shortened for the console",
+      },
+    },
+    running_sessions: {
+      "issue-123": { turn_count: 2, last_activity_at: "2026-05-14T12:03:00Z", last_event: "tool_call_completed", last_event_message: "running cargo test" },
+    },
+    running_session_info: {
+      "issue-123": { turn_count: 3, max_turns: 20, last_activity_ms: Date.parse("2026-05-14T12:04:00Z"), last_error: null },
+      "issue-777": { turn_count: 1, max_turns: 10, last_activity_ms: null, last_error: "usage limit" },
+    },
+    retry_queue: [],
+    blocked: [],
+    completed: [],
+    polling: { checking: false, next_poll_in_ms: 1000, poll_interval_ms: 30000 },
+    shared_context: { total_entries: 0, entries_by_scope: {}, oldest_entry_at: null, newest_entry_at: null },
+    supervisor: { active: true, steers_issued: 0, conflicts_detected: 0, patterns_detected: 0, escalations_created: 0 },
+    codex_totals: { input_tokens: 0, output_tokens: 0, total_tokens: 0, event_count: 0, seconds_running: 0 },
+    codex_rate_limits: null,
+  };
+}
+
+describe("console model", () => {
+  it("builds sorted worker rows with selected-worker detail fields", () => {
+    const rows = buildWorkerRows(stateFixture());
+
+    expect(rows.map((row) => row.issueIdentifier)).toEqual(["SIM-123", "SIM-777"]);
+    expect(rows[0]).toMatchObject({
+      issueId: "issue-123",
+      issueIdentifier: "SIM-123",
+      title: "Worker one",
+      trackerState: "In Progress",
+      attempt: "2",
+      turnCount: "3",
+      maxTurns: "20",
+      lastActivity: "2026-05-14T12:04:00.000Z",
+      workerHost: "worker-a",
+      workspacePath: "/tmp/symphony/issue-123",
+      errorPreview: "-",
+    });
+    expect(rows[1]?.attempt).toBe("1");
+    expect(rows[1]?.trackerState).toBe("-");
+    expect(rows[1]?.errorPreview).toBe("agent exited after a very long error message that needs to be shortened for the console");
+  });
+
+  it("builds issue rows across running, retry, blocked, and completed buckets", () => {
+    const state = stateFixture();
+    state.retry_queue = [
+      {
+        issue_id: "issue-retry",
+        identifier: "SIM-200",
+        attempt: 3,
+        due_in_ms: 90000,
+        error: "rate limit",
+        worker_host: "host-b",
+        workspace_path: "/tmp/retry",
+      },
+    ];
+    state.blocked = [
+      {
+        issue_id: "issue-blocked",
+        identifier: "SIM-300",
+        title: "Blocked work",
+        state: "Todo",
+        blocker_identifiers: ["SIM-100", "SIM-101"],
+      },
+    ];
+    state.completed = [
+      {
+        issue_id: "issue-done",
+        identifier: "SIM-400",
+        title: "Done work",
+        completed_at: "2026-05-14T13:00:00Z",
+      },
+    ];
+
+    const rows = buildIssueRows(state);
+
+    expect(rows.map((row) => `${row.kind}:${row.issueIdentifier}`)).toEqual([
+      "running:SIM-123",
+      "running:SIM-777",
+      "retry:SIM-200",
+      "blocked:SIM-300",
+      "completed:SIM-400",
+    ]);
+    expect(rows.find((row) => row.kind === "retry")).toMatchObject({
+      title: "rate limit",
+      status: "retry in 1m 30s",
+      attempt: "3",
+      workerHost: "host-b",
+      workspacePath: "/tmp/retry",
+      errorPreview: "rate limit",
+    });
+    expect(rows.find((row) => row.kind === "blocked")).toMatchObject({
+      status: "Todo",
+      blockers: "SIM-100, SIM-101",
+    });
+    expect(rows.find((row) => row.kind === "completed")).toMatchObject({
+      status: "completed",
+      completedAt: "2026-05-14T13:00:00Z",
+    });
+  });
+
+  it("rounds retry wait times up to the next second", () => {
+    const state = stateFixture();
+    state.retry_queue = [
+      {
+        issue_id: "issue-retry",
+        identifier: "SIM-200",
+        attempt: 1,
+        due_in_ms: 999,
+      },
+    ];
+
+    const retryRow = buildIssueRows(state).find((row) => row.kind === "retry");
+
+    expect(retryRow).toMatchObject({ status: "retry in 1s" });
+  });
+
+  it("preserves pending retry state when no retry error is present", () => {
+    const state = stateFixture();
+    state.retry_queue = [
+      {
+        issue_id: "issue-retry",
+        identifier: "SIM-200",
+        attempt: 1,
+        due_in_ms: 1000,
+      },
+    ];
+
+    const retryRow = buildIssueRows(state).find((row) => row.kind === "retry");
+
+    expect(retryRow).toMatchObject({
+      title: "pending retry",
+      trackerState: "retry",
+    });
+  });
+
+  it("builds escalation rows sorted by creation time and request id", () => {
+    const state = stateFixture();
+    state.pending_escalations = [
+      {
+        request_id: "esc-3",
+        issue_id: "issue-456",
+        issue_identifier: "SIM-456",
+        method: "approval",
+        preview: "Review matching timestamp command",
+        created_at: "2026-05-14T12:02:00Z",
+        timeout_ms: 30000,
+      },
+      {
+        request_id: "esc-2",
+        issue_id: "issue-777",
+        issue_identifier: "SIM-777",
+        method: "approval",
+        preview: "Review command",
+        created_at: "2026-05-14T12:02:00Z",
+        timeout_ms: 30000,
+      },
+      {
+        request_id: "esc-1",
+        issue_id: "issue-123",
+        issue_identifier: "SIM-123",
+        method: "approval",
+        preview: "Approve command",
+        created_at: "2026-05-14T12:01:00Z",
+        timeout_ms: 600000,
+      },
+    ];
+
+    const rows = buildEscalationRows(state);
+
+    expect(rows.map((row) => row.requestId)).toEqual(["esc-1", "esc-2", "esc-3"]);
+    expect(rows[0]).toMatchObject({
+      method: "approval",
+      preview: "Approve command",
+      timeout: "10m 0s",
+    });
+  });
+
+  it("formats escalation lifecycle events newest first", () => {
+    const events: SymphonyEventEnvelope[] = [
+      { version: "v1", sequence: 1, timestamp: "2026-05-14T12:00:00Z", kind: "escalation_created", severity: "info", issue: "SIM-123", event: "escalation_created", payload: { summary: "Approve command" } },
+      { version: "v1", sequence: 2, timestamp: "2026-05-14T12:01:00Z", kind: "escalation_responded", severity: "info", issue: "SIM-123", event: "escalation_responded", payload: { summary: "Approved" } },
+      { version: "v1", sequence: 3, timestamp: "2026-05-14T12:02:00Z", kind: "escalation_timed_out", severity: "warn", issue: "SIM-777", event: "escalation_timed_out", payload: { summary: "Timed out" } },
+    ];
+
+    expect(formatEventRows(events)).toEqual([
+      "2026-05-14T12:02:00Z warn escalation_timed_out SIM-777 escalation_timed_out Timed out",
+      "2026-05-14T12:01:00Z info escalation_responded SIM-123 escalation_responded Approved",
+      "2026-05-14T12:00:00Z info escalation_created SIM-123 escalation_created Approve command",
+    ]);
+  });
+
+  it("formats only recent worker and runtime events", () => {
+    const events: SymphonyEventEnvelope[] = [
+      { version: "v1", sequence: 1, timestamp: "2026-05-14T12:00:00Z", kind: "heartbeat", severity: "info", event: "heartbeat", payload: {} },
+      { version: "v1", sequence: 2, timestamp: "2026-05-14T12:01:00Z", kind: "runtime", severity: "info", event: "poll_completed", payload: { summary: "checked tracker" } },
+      { version: "v1", sequence: 3, timestamp: "2026-05-14T12:02:00Z", kind: "worker", severity: "error", issue: "SIM-123", event: "worker_failed", payload: { error_preview: "usage limit" } },
+    ];
+
+    expect(formatEventRows(events)).toEqual([
+      "2026-05-14T12:02:00Z error worker SIM-123 worker_failed usage limit",
+      "2026-05-14T12:01:00Z info runtime - poll_completed checked tracker",
+    ]);
+  });
+
+  it("includes worker failure errors and steer instructions in event summaries", () => {
+    const events: SymphonyEventEnvelope[] = [
+      { version: "v1", sequence: 1, timestamp: "2026-05-14T12:00:00Z", kind: "worker", severity: "error", issue: "SIM-123", event: "worker_failed", payload: { error: "agent exited with code 1" } },
+      { version: "v1", sequence: 2, timestamp: "2026-05-14T12:01:00Z", kind: "runtime", severity: "info", issue: "SIM-123", event: "steer_received", payload: { instruction_preview: "Focus on failing tests" } },
+    ];
+
+    expect(formatEventRows(events)).toEqual([
+      "2026-05-14T12:01:00Z info runtime SIM-123 steer_received Focus on failing tests",
+      "2026-05-14T12:00:00Z error worker SIM-123 worker_failed agent exited with code 1",
+    ]);
+  });
+
+  it("normalizes multiline event summaries to one row", () => {
+    const events: SymphonyEventEnvelope[] = [
+      { version: "v1", sequence: 1, timestamp: "2026-05-14T12:00:00Z", kind: "worker", severity: "error", issue: "SIM-123", event: "worker_failed", payload: { error: "first line\n\tsecond line" } },
+    ];
+
+    expect(formatEventRows(events)).toEqual(["2026-05-14T12:00:00Z error worker SIM-123 worker_failed first line second line"]);
+  });
+});