@tryarcanist/cli 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/api.ts
-async function apiFetch(config, path, init) {
+async function apiRequest(config, path, init) {
   const res = await fetch(`${config.apiUrl}${path}`, {
     ...init,
     headers: {
@@ -20,8 +21,16 @@ async function apiFetch(config, path, init) {
     const body = await res.text().catch(() => "");
     throw new Error(`API error ${res.status}: ${body}`);
   }
+  return res;
+}
+async function apiFetch(config, path, init) {
+  const res = await apiRequest(config, path, init);
   return res.json();
 }
+async function apiFetchText(config, path, init) {
+  const res = await apiRequest(config, path, init);
+  return res.text();
+}
 
 // src/config.ts
 import { mkdirSync, readFileSync, writeFileSync } from "fs";
@@ -182,11 +191,541 @@ async function messageCommand(sessionId, prompt) {
   }
 }
 
+// src/commands/stop.ts
+async function stopCommand(sessionId) {
+  const config = requireConfig();
+  try {
+    await apiFetch(config, `/api/sessions/${sessionId}/stop`, {
+      method: "POST"
+    });
+    console.log(`Stop requested for session ${sessionId}.`);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/utils/session-output.ts
+function flattenSessionEvents(raw) {
+  const merged = [];
+  const textIndexById = /* @__PURE__ */ new Map();
+  const toolCallIndexById = /* @__PURE__ */ new Map();
+  for (const event of raw) {
+    const data = event.data ?? {};
+    if (event.type === "sandbox_compaction_start") {
+      merged.push({ type: "compaction_start", id: `cs-${data.timestamp ?? merged.length}` });
+      continue;
+    }
+    if (event.type === "sandbox_compaction_complete") {
+      merged.push({ type: "compaction_complete", id: `cc-${data.timestamp ?? merged.length}` });
+      continue;
+    }
+    if (event.type === "sandbox_context_fill_warning") {
+      merged.push({
+        type: "context_fill_warning",
+        id: `cfw-${data.timestamp ?? merged.length}`,
+        fillPercent: Number(data.fillPercent ?? 0)
+      });
+      continue;
+    }
+    if (event.type === "sandbox_tool_truncated") {
+      merged.push({
+        type: "tool_truncated",
+        id: String(data.callId ?? merged.length),
+        tool: String(data.tool ?? "")
+      });
+      continue;
+    }
+    if (event.type === "branch_changed") {
+      merged.push({ type: "branch_changed", id: `bc-${data.timestamp ?? merged.length}`, branch: String(data.branch ?? "") });
+      continue;
+    }
+    if (event.type === "session_error") {
+      merged.push({
+        type: "session_error",
+        id: String(data.id ?? `err-${merged.length}`),
+        error: String(data.error ?? "Unknown error"),
+        ...data.code ? { code: String(data.code) } : {}
+      });
+      continue;
+    }
+    if (event.type === "raw_opencode") {
+      merged.push({ type: "raw_opencode", id: String(data.id ?? `raw-${merged.length}`), data });
+      continue;
+    }
+    if (event.type === "reasoning") {
+      const id = String(data.id ?? `reasoning-${merged.length}`);
+      const text = String(data.text ?? "");
+      const existingIdx = textIndexById.get(id);
+      if (existingIdx !== void 0) {
+        const existing = merged[existingIdx];
+        if (existing.type === "reasoning") existing.text += text;
+      } else {
+        textIndexById.set(id, merged.length);
+        merged.push({ type: "reasoning", id, text });
+      }
+      continue;
+    }
+    if (event.type === "patch") {
+      const files = Array.isArray(data.files) ? data.files.filter((item) => typeof item === "string") : [];
+      if (files.length > 0) merged.push({ type: "patch", id: `patch-${merged.length}`, files });
+      continue;
+    }
+    if (event.type === "todo_update") {
+      const todos = Array.isArray(data.todos) ? data.todos : [];
+      if (todos.length > 0) {
+        for (let i = merged.length - 1; i >= 0; i--) {
+          const existing = merged[i];
+          if (existing.type === "tool_call" && existing.tool.toLowerCase() === "todowrite") {
+            existing.input = { ...existing.input, todos };
+            break;
+          }
+        }
+      }
+      continue;
+    }
+    if (event.type !== "text" && event.type !== "tool_call" && event.type !== "tool_update" && event.type !== "question") {
+      continue;
+    }
+    if (event.type === "text") {
+      const id = String(data.id ?? `text-${merged.length}`);
+      const text = String(data.text ?? "");
+      const existingIdx = textIndexById.get(id);
+      if (existingIdx !== void 0) {
+        const existing = merged[existingIdx];
+        if (existing.type === "text") existing.text += text;
+      } else {
+        textIndexById.set(id, merged.length);
+        merged.push({ type: "text", id, text });
+      }
+      continue;
+    }
+    if (event.type === "tool_call") {
+      const id = String(data.id ?? `tool-${merged.length}`);
+      const nextEvent = {
+        type: "tool_call",
+        id,
+        tool: String(data.tool ?? "unknown"),
+        summary: String(data.summary ?? ""),
+        ...data.input && typeof data.input === "object" ? { input: data.input } : {}
+      };
+      const existingIdx = toolCallIndexById.get(id);
+      if (existingIdx !== void 0) {
+        const prev = merged[existingIdx];
+        if (prev.type === "tool_call") merged[existingIdx] = { ...nextEvent, ...prev.toolStatus ? { toolStatus: prev.toolStatus } : {} };
+      } else {
+        toolCallIndexById.set(id, merged.length);
+        merged.push(nextEvent);
+      }
+      continue;
+    }
+    if (event.type === "tool_update") {
+      const id = String(data.id ?? "");
+      const existingIdx = toolCallIndexById.get(id);
+      if (existingIdx !== void 0) {
+        const prev = merged[existingIdx];
+        if (prev.type === "tool_call") {
+          merged[existingIdx] = { ...prev, ...data.status ? { toolStatus: String(data.status) } : {} };
+        }
+      }
+      continue;
+    }
+    merged.push({
+      type: "question",
+      id: String(data.id ?? `question-${merged.length}`),
+      question: String(data.question ?? ""),
+      answer: data.answer == null ? null : String(data.answer),
+      ...Array.isArray(data.options) ? { options: data.options } : {}
+    });
+  }
+  return merged;
+}
+function partitionEventsByPrompt(allEvents, promptIds) {
+  const promptSet = new Set(promptIds);
+  const buckets = new Map(promptIds.map((id) => [id, []]));
+  let currentPromptId = null;
+  for (const event of allEvents) {
+    if (event.type === "prompt_processing") {
+      const promptId = typeof event.data?.promptId === "string" ? event.data.promptId : null;
+      currentPromptId = promptId && promptSet.has(promptId) ? promptId : null;
+    }
+    if (currentPromptId) {
+      const bucket = buckets.get(currentPromptId);
+      if (bucket) bucket.push(event);
+    }
+  }
+  return buckets;
+}
+function formatDate(value) {
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC");
+}
+function renderTranscriptEvent(event) {
+  switch (event.type) {
+    case "text":
+      return event.text;
+    case "tool_call":
+      return `**Tool call:** ${event.tool}${event.summary ? ` - ${event.summary}` : ""}${event.toolStatus ? ` (${event.toolStatus})` : ""}
+`;
+    case "reasoning":
+      return `<details><summary>Reasoning</summary>
+
+${event.text}
+</details>
+`;
+    case "patch":
+      return `**Files changed:** ${event.files.join(", ")}
+`;
+    case "question":
+      return `**Question:** ${event.question}
+${event.answer ? `**Answer:** ${event.answer}
+` : ""}`;
+    case "compaction_start":
+      return "*[context compacted]*\n";
+    case "compaction_complete":
+      return "";
+    case "context_fill_warning":
+      return `*[context ${event.fillPercent}% full]*
+`;
+    case "tool_truncated":
+      return `*[${event.tool} output truncated]*
+`;
+    case "branch_changed":
+      return `*[switched to branch \`${event.branch}\`]*
+`;
+    case "session_error":
+      return `**Error:** ${event.error}
+`;
+    case "raw_opencode":
+      return "";
+  }
+}
+function formatNumber(value) {
+  return value.toLocaleString();
+}
+function renderSessionTranscript(exportData) {
+  const lines = [];
+  const promptIds = exportData.prompts.map((prompt) => prompt.id);
+  const eventBuckets = partitionEventsByPrompt(exportData.events, promptIds);
+  lines.push("# Session transcript\n");
+  if (exportData.session.repoUrl) lines.push(`**Repo:** ${exportData.session.repoUrl}  `);
+  lines.push(`**Session:** ${exportData.session.id.slice(0, 8)}  `);
+  lines.push(`**Created:** ${formatDate(exportData.session.createdAt)}  `);
+  lines.push(`**Status:** ${exportData.session.status}  `);
+  lines.push(`**Tokens:** ${formatNumber(exportData.tokens.inputTokens)} in / ${formatNumber(exportData.tokens.outputTokens)} out / ${formatNumber(exportData.tokens.totalTokens)} total`);
+  if (exportData.pr?.url) {
+    lines.push(`**PR:** ${exportData.pr.url}${exportData.pr.branch ? ` (${exportData.pr.branch})` : ""}`);
+  }
+  lines.push("");
+  for (let i = 0; i < exportData.prompts.length; i++) {
+    const prompt = exportData.prompts[i];
+    const rawEvents = eventBuckets.get(prompt.id) ?? [];
+    const events = flattenSessionEvents(rawEvents);
+    lines.push("---\n");
+    lines.push(`## Turn ${i + 1}
+`);
+    lines.push(`**Prompt ID:** ${prompt.id}  `);
+    lines.push(`**Prompt Status:** ${prompt.status}${prompt.error ? ` | ${prompt.error}` : ""}`);
+    lines.push("");
+    lines.push("**User:**\n");
+    lines.push(prompt.prompt);
+    lines.push("");
+    if (events.length > 0) {
+      lines.push("**Assistant:**\n");
+      let pendingText = "";
+      for (const event of events) {
+        const rendered = renderTranscriptEvent(event);
+        if (!rendered) continue;
+        if (event.type === "text") {
+          pendingText += rendered;
+        } else {
+          if (pendingText) {
+            lines.push(pendingText.trimEnd());
+            lines.push("");
+            pendingText = "";
+          }
+          lines.push(rendered);
+        }
+      }
+      if (pendingText) {
+        lines.push(pendingText.trimEnd());
+        lines.push("");
+      }
+    } else if (prompt.error) {
+      lines.push("**Assistant:**\n");
+      lines.push(`**Error:** ${prompt.error}`);
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+function parseSsePayload(payload) {
+  const messages = [];
+  let currentEvent = "message";
+  let currentId;
+  let currentData = [];
+  function flush() {
+    if (currentData.length === 0 && currentId === void 0 && currentEvent === "message") return;
+    messages.push({ event: currentEvent, ...currentId !== void 0 ? { id: currentId } : {}, data: currentData.join("\n") });
+    currentEvent = "message";
+    currentId = void 0;
+    currentData = [];
+  }
+  for (const rawLine of payload.split(/\r?\n/)) {
+    const line = rawLine.trimEnd();
+    if (line.length === 0) {
+      flush();
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      currentEvent = line.slice("event:".length).trim();
+      continue;
+    }
+    if (line.startsWith("id:")) {
+      const parsed = Number.parseInt(line.slice("id:".length).trim(), 10);
+      currentId = Number.isFinite(parsed) ? parsed : void 0;
+      continue;
+    }
+    if (line.startsWith("data:")) {
+      currentData.push(line.slice("data:".length).trimStart());
+    }
+  }
+  flush();
+  let status = null;
+  const events = [];
+  for (const message of messages) {
+    const data = message.data ? parseJsonObject(message.data) : {};
+    if (message.event === "status") {
+      status = {
+        status: typeof data.status === "string" ? data.status : "unknown",
+        ...typeof data.title === "string" ? { title: data.title } : {},
+        ...typeof data.spawnDurationMs === "number" || data.spawnDurationMs === null ? { spawnDurationMs: data.spawnDurationMs } : {}
+      };
+      continue;
+    }
+    events.push({
+      type: message.event,
+      ...message.id !== void 0 ? { id: message.id } : {},
+      data
+    });
+  }
+  return { status, events };
+}
+function parseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch (err) {
+    throw new Error(`Malformed SSE JSON payload: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+function formatPromptLabel(promptId, promptLabels) {
+  if (!promptId) return "";
+  const prompt = promptLabels.get(promptId);
+  return prompt ? ` - ${prompt}` : "";
+}
+function buildPromptLabelMap(prompts) {
+  const labels = /* @__PURE__ */ new Map();
+  for (const prompt of prompts) {
+    labels.set(prompt.promptId, prompt.prompt.replace(/\s+/g, " ").trim().slice(0, 80));
+  }
+  return labels;
+}
+function renderWatchEvent(event, state) {
+  const data = event.data;
+  switch (event.type) {
+    case "text":
+      return { kind: "text", text: String(data.text ?? "") };
+    case "prompt_enqueued": {
+      const promptId = typeof data.promptId === "string" ? data.promptId : void 0;
+      return { kind: "line", line: `[queued] ${promptId ?? "unknown"}${formatPromptLabel(promptId, state.promptLabels)}` };
+    }
+    case "prompt_processing": {
+      const promptId = typeof data.promptId === "string" ? data.promptId : void 0;
+      return { kind: "line", line: `[prompt] ${promptId ?? "unknown"} started${formatPromptLabel(promptId, state.promptLabels)}` };
+    }
+    case "prompt_completed": {
+      const promptId = typeof data.promptId === "string" ? data.promptId : void 0;
+      return { kind: "line", line: `[prompt] ${promptId ?? "unknown"} completed` };
+    }
+    case "prompt_failed": {
+      const promptId = typeof data.promptId === "string" ? data.promptId : void 0;
+      const error = typeof data.error === "string" ? data.error : "unknown error";
+      return { kind: "line", line: `[prompt] ${promptId ?? "unknown"} failed: ${error}` };
+    }
+    case "tool_call": {
+      const toolId = String(data.id ?? "");
+      const tool = String(data.tool ?? "unknown");
+      const summary = String(data.summary ?? "");
+      state.toolCalls.set(toolId, { tool, summary });
+      return { kind: "line", line: `[tool] ${tool}${summary ? ` - ${summary}` : ""}` };
+    }
+    case "tool_update": {
+      const toolId = String(data.id ?? "");
+      const status = typeof data.status === "string" ? data.status : null;
+      if (!status) return null;
+      const tool = state.toolCalls.get(toolId);
+      if (!tool) return { kind: "line", line: `[tool] ${toolId} ${status}` };
+      return { kind: "line", line: `[tool ${status}] ${tool.tool}${tool.summary ? ` - ${tool.summary}` : ""}` };
+    }
+    case "question":
+      return { kind: "line", line: `[question] ${String(data.question ?? "")}` };
+    case "patch": {
+      const files = Array.isArray(data.files) ? data.files.filter((item) => typeof item === "string") : [];
+      return { kind: "line", line: `[patch] ${files.join(", ")}` };
+    }
+    case "branch_changed":
+      return { kind: "line", line: `[branch] ${String(data.branch ?? "")}` };
+    case "session_error":
+      return { kind: "line", line: `[error] ${String(data.error ?? "Unknown error")}` };
+    case "pr_created":
+    case "pr_updated":
+      return { kind: "line", line: `[pr] ${String(data.prUrl ?? "")}` };
+    case "pr_failed":
+      return { kind: "line", line: `[pr error] ${String(data.error ?? "Unknown error")}` };
+    case "similar_sessions_searching":
+      return { kind: "line", line: "[similar] searching for related sessions" };
+    case "similar_sessions_found":
+      return { kind: "line", line: `[similar] found ${String(data.count ?? 0)} related sessions` };
+    case "similar_sessions_none":
+      return { kind: "line", line: "[similar] no related sessions found" };
+    case "session_idle":
+      return { kind: "line", line: "[idle] waiting for next prompt" };
+    default:
+      return null;
+  }
+}
+
+// src/commands/transcript.ts
+async function transcriptCommand(sessionId, options) {
+  const config = requireConfig();
+  try {
+    const exportData = await apiFetch(config, `/api/sessions/${sessionId}/export`);
+    if (options.json) {
+      console.log(JSON.stringify(exportData, null, 2));
+      return;
+    }
+    console.log(renderSessionTranscript(exportData));
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+}
+
+// src/constants/watch.ts
+var DEFAULT_WATCH_POLL_INTERVAL_MS = 1e3;
+var WATCH_REPLAY_PAGE_SIZE = 200;
+var WATCH_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["idle", "archived"]);
+
+// src/commands/watch.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function parsePollInterval(raw) {
+  if (!raw) return DEFAULT_WATCH_POLL_INTERVAL_MS;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new Error("Polling interval must be a non-negative integer.");
+  }
+  return parsed;
+}
+function formatStatusLine(status) {
+  const details = [];
+  if (status.title) details.push(status.title);
+  if (status.spawnDurationMs != null) details.push(`spawn ${(status.spawnDurationMs / 1e3).toFixed(1)}s`);
+  return details.length > 0 ? `[status] ${status.status} | ${details.join(" | ")}` : `[status] ${status.status}`;
+}
+async function fetchPromptLabels(config, sessionId) {
+  const data = await apiFetch(config, `/api/sessions/${sessionId}/prompts`);
+  return buildPromptLabelMap(data.prompts);
+}
+async function watchCommand(sessionId, options) {
+  const config = requireConfig();
+  let pollIntervalMs;
+  try {
+    pollIntervalMs = parsePollInterval(options.pollInterval);
+  } catch (err) {
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  let promptLabels = /* @__PURE__ */ new Map();
+  try {
+    promptLabels = await fetchPromptLabels(config, sessionId);
+  } catch (err) {
+    console.error(`Warning: failed to fetch prompt labels for session ${sessionId}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const renderState = {
+    promptLabels,
+    toolCalls: /* @__PURE__ */ new Map()
+  };
+  let afterSequence = 0;
+  let lastStatusLine = null;
+  let textOpen = false;
+  console.log(`Watching session ${sessionId}...`);
+  try {
+    while (true) {
+      const query = new URLSearchParams({
+        afterSequence: String(afterSequence),
+        limit: String(WATCH_REPLAY_PAGE_SIZE)
+      });
+      const payload = await apiFetchText(config, `/api/sessions/${sessionId}/events?${query.toString()}`);
+      const parsed = parseSsePayload(payload);
+      const receivedFullPage = parsed.events.length >= WATCH_REPLAY_PAGE_SIZE;
+      if (parsed.status) {
+        const nextStatusLine = formatStatusLine(parsed.status);
+        if (nextStatusLine !== lastStatusLine) {
+          if (textOpen) {
+            process.stdout.write("\n");
+            textOpen = false;
+          }
+          console.log(nextStatusLine);
+          lastStatusLine = nextStatusLine;
+        }
+      }
+      for (const event of parsed.events) {
+        if (typeof event.id === "number" && event.id > afterSequence) afterSequence = event.id;
+        const rendered = renderWatchEvent(event, renderState);
+        if (!rendered) continue;
+        if (rendered.kind === "text") {
+          if (!rendered.text) continue;
+          if (!textOpen) {
+            process.stdout.write("assistant> ");
+            textOpen = true;
+          }
+          process.stdout.write(rendered.text);
+          continue;
+        }
+        if (textOpen) {
+          process.stdout.write("\n");
+          textOpen = false;
+        }
+        console.log(rendered.line);
+      }
+      if (receivedFullPage) continue;
+      if (parsed.status?.status && WATCH_TERMINAL_STATUSES.has(parsed.status.status)) break;
+      if (pollIntervalMs > 0) {
+        await sleep(pollIntervalMs);
+      }
+    }
+  } catch (err) {
+    if (textOpen) process.stdout.write("\n");
+    console.error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  if (textOpen) process.stdout.write("\n");
+}
+
 // src/index.ts
-var program = new Command().name("arcanist").description("Arcanist CLI").version("0.1.0");
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command().name("arcanist").description("Arcanist CLI").version(version);
 program.command("login").description("Authenticate with a personal access token").option("--token-stdin", "Read token from stdin instead of interactive prompt").option("--api-url <url>", "Set custom API URL").action(loginCommand);
 program.command("create").description("Create a session and send a prompt").argument("<repo-url>", "Repository URL").argument("<prompt>", "Prompt to send").option("--model <model>", "Model to use").action(createCommand);
 program.command("message").description("Send a message to an existing session").argument("<session-id>", "Session ID").argument("<prompt>", "Message to send").action(messageCommand);
+program.command("stop").description("Stop the active run for a session").argument("<session-id>", "Session ID").action(stopCommand);
+program.command("transcript").description("Render a session transcript").argument("<session-id>", "Session ID").option("--json", "Output raw session export JSON").action(transcriptCommand);
+program.command("watch").description("Watch session activity until it becomes idle").argument("<session-id>", "Session ID").option("--poll-interval <ms>", "Polling interval in milliseconds", String(DEFAULT_WATCH_POLL_INTERVAL_MS)).action(watchCommand);
 async function main() {
   try {
     await program.parseAsync(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tryarcanist/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "CLI for Arcanist — create and manage coding agent sessions",
   "type": "module",
   "bin": {
@@ -27,6 +27,7 @@
     "commander": "^12.1.0"
   },
   "devDependencies": {
-    "tsup": "^8.0.0"
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
   }
 }