@hydra-acp/cli 0.1.15 → 0.1.17

package/dist/index.js

@@ -966,6 +966,12 @@ function extractHydraMeta(meta) {
   if (typeof obj.currentMode === "string") {
     out.currentMode = obj.currentMode;
   }
+  if (obj.currentUsage) {
+    const parsed = SessionListUsage.safeParse(obj.currentUsage);
+    if (parsed.success) {
+      out.currentUsage = parsed.data;
+    }
+  }
   if (typeof obj.turnStartedAt === "number" && obj.turnStartedAt > 0) {
     out.turnStartedAt = obj.turnStartedAt;
   }
@@ -1470,6 +1476,9 @@ var HYDRA_SESSION_PREFIX = "hydra_session_";
 function generateMessageId() {
   return `m_${generateHydraId()}`;
 }
+function stripHydraSessionPrefix(id) {
+  return id.startsWith(HYDRA_SESSION_PREFIX) ? id.slice(HYDRA_SESSION_PREFIX.length) : id;
+}
 var DEFAULT_HISTORY_MAX_ENTRIES = 1e3;
 var Session = class {
   sessionId;
@@ -1721,21 +1730,126 @@ var Session = class {
     }
     this.clients.set(client.clientId, client);
     this.updatedAt = Date.now();
-    if (historyPolicy === "none" || historyPolicy === "pending_only") {
+    if (historyPolicy === "none") {
       return Promise.resolve({ entries: [], appliedPolicy: historyPolicy });
     }
+    if (historyPolicy === "pending_only") {
+      return Promise.resolve({
+        entries: this.buildStateSnapshotReplay(),
+        appliedPolicy: historyPolicy
+      });
+    }
     return this.loadReplay(historyPolicy, opts);
   }
   async loadReplay(historyPolicy, opts) {
     const all = await this.getHistorySnapshot();
+    const state = this.buildStateSnapshotReplay();
     if (historyPolicy === "after_message") {
       const cutoff = opts.afterMessageId ? findMessageIdIndex(all, opts.afterMessageId) : -1;
       if (cutoff < 0) {
-        return { entries: all, appliedPolicy: "full" };
+        return { entries: [...state, ...all], appliedPolicy: "full" };
+      }
+      return {
+        entries: [...state, ...all.slice(cutoff + 1)],
+        appliedPolicy: "after_message"
+      };
+    }
+    return { entries: [...state, ...all], appliedPolicy: "full" };
+  }
+  // Synthesizes one session/update notification per cached STATE_UPDATE_KIND
+  // so an attaching client receives the current snapshot through the
+  // standard ACP event channel. Without this, third-party clients would
+  // never see current_model/mode/usage/info/commands on resume — they're
+  // filtered out of recorded history (canonical state lives in meta.json
+  // and is *also* surfaced via the attach response _meta, but third-party
+  // clients can't read hydra's namespaced meta).
+  buildStateSnapshotReplay() {
+    const out = [];
+    const sessionId = this.sessionId;
+    const recordedAt = Date.now();
+    if (this.title !== void 0 && this.title.length > 0) {
+      out.push({
+        method: "session/update",
+        params: {
+          sessionId,
+          update: {
+            sessionUpdate: "session_info_update",
+            title: this.title
+          }
+        },
+        recordedAt
+      });
+    }
+    if (this.currentModel !== void 0 && this.currentModel.length > 0) {
+      out.push({
+        method: "session/update",
+        params: {
+          sessionId,
+          update: {
+            sessionUpdate: "current_model_update",
+            currentModel: this.currentModel
+          }
+        },
+        recordedAt
+      });
+    }
+    if (this.currentMode !== void 0 && this.currentMode.length > 0) {
+      out.push({
+        method: "session/update",
+        params: {
+          sessionId,
+          update: {
+            sessionUpdate: "current_mode_update",
+            currentMode: this.currentMode
+          }
+        },
+        recordedAt
+      });
+    }
+    const cmds = this.mergedAvailableCommands();
+    if (cmds.length > 0) {
+      out.push({
+        method: "session/update",
+        params: {
+          sessionId,
+          update: {
+            sessionUpdate: "available_commands_update",
+            availableCommands: cmds
+          }
+        },
+        recordedAt
+      });
+    }
+    if (this.currentUsage !== void 0) {
+      const u = this.currentUsage;
+      const update = {
+        sessionUpdate: "usage_update"
+      };
+      if (typeof u.used === "number") {
+        update.used = u.used;
+      }
+      if (typeof u.size === "number") {
+        update.size = u.size;
+      }
+      if (typeof u.costAmount === "number" || typeof u.costCurrency === "string") {
+        const cost = {};
+        if (typeof u.costAmount === "number") {
+          cost.amount = u.costAmount;
+        }
+        if (typeof u.costCurrency === "string") {
+          cost.currency = u.costCurrency;
+        }
+        update.cost = cost;
+      }
+      if (Object.keys(update).length > 1) {
+        out.push({
+          method: "session/update",
+          params: { sessionId, update },
+          recordedAt
+        });
       }
-      return { entries: all.slice(cutoff + 1), appliedPolicy: "after_message" };
     }
-    return { entries: all, appliedPolicy: "full" };
+    return out;
   }
   // Dispatch in-flight permission requests to a freshly-attached
   // client. Called by the daemon's WS handler *after* it finishes
@@ -4512,6 +4626,533 @@ function decodeBundle(raw) {
   return Bundle.parse(raw);
 }
 
+// src/core/render-update.ts
+import stripAnsi from "strip-ansi";
+var STRIP_CONTROLS = /[\x00-\x08\x0b-\x1f\x7f]/g;
+function sanitizeWireText(text) {
+  return stripAnsi(text).replace(STRIP_CONTROLS, "");
+}
+function sanitizeSingleLine(text) {
+  return sanitizeWireText(text).replace(/[\n\t]+/g, " ").replace(/  +/g, " ").trim();
+}
+function mapUpdate(update) {
+  if (!update || typeof update !== "object") {
+    return null;
+  }
+  const u = update;
+  const tag = u.sessionUpdate ?? u.kind;
+  if (typeof tag !== "string") {
+    return null;
+  }
+  switch (tag) {
+    case "agent_message_chunk":
+      return mapAgentText(u);
+    case "agent_thought_chunk":
+    case "agent_thought":
+      return mapAgentThought(u);
+    case "user_message_chunk":
+      return mapUserText(u);
+    case "prompt_received":
+      return mapPromptReceived(u);
+    case "tool_call":
+      return mapToolCall(u);
+    case "tool_call_update":
+      return mapToolCallUpdate(u);
+    case "plan":
+      return mapPlan(u);
+    case "current_mode_update":
+      return mapMode(u);
+    case "current_model_update":
+      return mapModel(u);
+    case "turn_complete":
+      return mapTurnComplete(u);
+    case "usage_update":
+      return mapUsage(u);
+    case "available_commands_update":
+      return mapAvailableCommands(u);
+    case "session_info_update":
+      return mapSessionInfo(u);
+    default:
+      return { kind: "unknown", sessionUpdate: tag, raw: update };
+  }
+}
+function mapSessionInfo(u) {
+  const rawTitle = readString(u, "title");
+  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
+  const meta = u._meta;
+  let agentId;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const ns = meta["hydra-acp"];
+    if (ns && typeof ns === "object" && !Array.isArray(ns)) {
+      const candidate = ns.agentId;
+      if (typeof candidate === "string") {
+        agentId = candidate;
+      }
+    }
+  }
+  if (title === void 0 && agentId === void 0) {
+    return null;
+  }
+  const event = { kind: "session-info" };
+  if (title !== void 0) {
+    event.title = title;
+  }
+  if (agentId !== void 0) {
+    event.agentId = agentId;
+  }
+  return event;
+}
+function normalizeAdvertisedCommands(list) {
+  if (!Array.isArray(list)) {
+    return [];
+  }
+  const out = [];
+  for (const raw of list) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const c = raw;
+    if (typeof c.name !== "string" || c.name.length === 0) {
+      continue;
+    }
+    const rawName = c.name.startsWith("/") ? c.name : `/${c.name}`;
+    const cmd = { name: sanitizeSingleLine(rawName) };
+    if (typeof c.description === "string") {
+      cmd.description = sanitizeSingleLine(c.description);
+    }
+    out.push(cmd);
+  }
+  return out;
+}
+function mapAvailableCommands(u) {
+  const list = u.availableCommands ?? u.commands;
+  if (!Array.isArray(list)) {
+    return null;
+  }
+  return { kind: "available-commands", commands: normalizeAdvertisedCommands(list) };
+}
+function mapUsage(u) {
+  const event = { kind: "usage-update" };
+  if (typeof u.used === "number") {
+    event.used = u.used;
+  }
+  if (typeof u.size === "number") {
+    event.size = u.size;
+  }
+  if (u.cost && typeof u.cost === "object") {
+    const cost = u.cost;
+    if (typeof cost.amount === "number") {
+      event.costAmount = cost.amount;
+    }
+    if (typeof cost.currency === "string") {
+      event.costCurrency = cost.currency;
+    }
+  }
+  return event;
+}
+function mapAgentText(u) {
+  const text = extractContentText(u.content);
+  if (text === null) {
+    return null;
+  }
+  return { kind: "agent-text", text };
+}
+function mapAgentThought(u) {
+  const text = typeof u.text === "string" ? sanitizeWireText(u.text) : extractContentText(u.content);
+  if (text === null) {
+    return null;
+  }
+  return { kind: "agent-thought", text };
+}
+function mapUserText(u) {
+  const meta = u._meta;
+  if (meta && typeof meta === "object" && !Array.isArray(meta)) {
+    const hydra = meta["hydra-acp"];
+    if (hydra && typeof hydra === "object" && !Array.isArray(hydra) && hydra.compatFor === "prompt_received") {
+      return null;
+    }
+  }
+  const text = extractContentText(u.content);
+  if (text === null) {
+    return null;
+  }
+  return { kind: "user-text", text };
+}
+function mapPromptReceived(u) {
+  const promptText = extractPromptText2(u.prompt);
+  if (promptText === null) {
+    return null;
+  }
+  return { kind: "user-text", text: promptText };
+}
+function mapToolCall(u) {
+  const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
+  if (!toolCallId) {
+    return null;
+  }
+  const rawTitle = readString(u, "title") ?? readString(u, "name") ?? readString(u, "label") ?? "tool call";
+  const title = sanitizeSingleLine(rawTitle);
+  const status = readString(u, "status");
+  const rawKind = readString(u, "kind");
+  const event = { kind: "tool-call", toolCallId, title };
+  if (status !== void 0) {
+    event.status = status;
+  }
+  if (rawKind !== void 0) {
+    event.rawKind = rawKind;
+  }
+  return event;
+}
+function mapToolCallUpdate(u) {
+  const toolCallId = readString(u, "toolCallId") ?? readString(u, "id");
+  if (!toolCallId) {
+    return null;
+  }
+  const rawTitle = readString(u, "title");
+  const title = rawTitle !== void 0 ? sanitizeSingleLine(rawTitle) : void 0;
+  const status = readString(u, "status");
+  const meaningful = title !== void 0 || status === "completed" || status === "failed" || status === "rejected" || status === "cancelled";
+  if (!meaningful) {
+    return null;
+  }
+  const event = { kind: "tool-call-update", toolCallId };
+  if (title !== void 0) {
+    event.title = title;
+  }
+  if (status !== void 0) {
+    event.status = status;
+  }
+  return event;
+}
+function mapPlan(u) {
+  const entries = u.entries;
+  if (!Array.isArray(entries)) {
+    return null;
+  }
+  const normalized = [];
+  for (const raw of entries) {
+    if (!raw || typeof raw !== "object") {
+      continue;
+    }
+    const e = raw;
+    const content = typeof e.content === "string" ? sanitizeSingleLine(e.content) : void 0;
+    if (!content) {
+      continue;
+    }
+    const entry = { content };
+    if (typeof e.status === "string") {
+      entry.status = e.status;
+    }
+    if (typeof e.priority === "string") {
+      entry.priority = e.priority;
+    }
+    normalized.push(entry);
+  }
+  return { kind: "plan", entries: normalized };
+}
+function mapMode(u) {
+  const mode = readString(u, "currentMode") ?? readString(u, "mode");
+  if (!mode) {
+    return null;
+  }
+  return { kind: "mode-changed", mode: sanitizeSingleLine(mode) };
+}
+function mapModel(u) {
+  const model = readString(u, "currentModel") ?? readString(u, "model");
+  if (!model) {
+    return null;
+  }
+  return { kind: "model-changed", model: sanitizeSingleLine(model) };
+}
+function mapTurnComplete(u) {
+  const stopReason = readString(u, "stopReason");
+  return stopReason !== void 0 ? { kind: "turn-complete", stopReason } : { kind: "turn-complete" };
+}
+function extractContentText(content) {
+  if (typeof content === "string") {
+    return sanitizeWireText(content);
+  }
+  if (!content || typeof content !== "object") {
+    return null;
+  }
+  const c = content;
+  if (c.type === "text" && typeof c.text === "string") {
+    return sanitizeWireText(c.text);
+  }
+  if (typeof c.text === "string") {
+    return sanitizeWireText(c.text);
+  }
+  return null;
+}
+function extractPromptText2(prompt) {
+  if (!Array.isArray(prompt)) {
+    return null;
+  }
+  const parts = [];
+  for (const block of prompt) {
+    const text = extractContentText(block);
+    if (text !== null) {
+      parts.push(text);
+    }
+  }
+  if (parts.length === 0) {
+    return null;
+  }
+  return parts.join("");
+}
+function readString(u, key) {
+  const v = u[key];
+  return typeof v === "string" ? v : void 0;
+}
+
+// src/core/transcript.ts
+function bundleToMarkdown(bundle) {
+  const events = collectEvents(bundle);
+  const toolFinalStates = collectToolFinalStates(events);
+  const out = [];
+  emitHeader(out, bundle);
+  emitBody(out, events, toolFinalStates);
+  let text = out.join("\n");
+  if (!text.endsWith("\n")) {
+    text += "\n";
+  }
+  return text;
+}
+function collectEvents(bundle) {
+  const out = [];
+  for (const entry of bundle.history) {
+    if (entry.method !== "session/update") {
+      continue;
+    }
+    const params = entry.params;
+    if (!params || typeof params !== "object") {
+      continue;
+    }
+    const event = mapUpdate(params.update);
+    if (event === null) {
+      continue;
+    }
+    out.push({ event, recordedAt: entry.recordedAt });
+  }
+  return out;
+}
+function collectToolFinalStates(events) {
+  const out = /* @__PURE__ */ new Map();
+  for (const { event } of events) {
+    if (event.kind === "tool-call") {
+      const existing = out.get(event.toolCallId);
+      out.set(event.toolCallId, {
+        title: event.title,
+        status: event.status ?? existing?.status ?? "pending"
+      });
+      continue;
+    }
+    if (event.kind === "tool-call-update") {
+      const existing = out.get(event.toolCallId) ?? {
+        title: "tool call",
+        status: "pending"
+      };
+      out.set(event.toolCallId, {
+        title: event.title ?? existing.title,
+        status: event.status ?? existing.status
+      });
+    }
+  }
+  return out;
+}
+function emitHeader(out, bundle) {
+  const session = bundle.session;
+  const shortId = stripHydraSessionPrefix(session.sessionId);
+  const title = session.title?.trim() || `Hydra session ${shortId}`;
+  out.push(`# ${escapeInline(title)}`);
+  out.push("");
+  const lines = [];
+  lines.push(`- **Session:** \`${shortId}\` (lineage \`${session.lineageId}\`)`);
+  const agentBits = [session.agentId];
+  if (session.currentModel) {
+    agentBits.push(`model: ${session.currentModel}`);
+  }
+  if (session.currentMode) {
+    agentBits.push(`mode: ${session.currentMode}`);
+  }
+  lines.push(`- **Agent:** ${agentBits.filter(Boolean).join(" \xB7 ")}`);
+  lines.push(`- **Cwd:** ${session.cwd}`);
+  lines.push(
+    `- **Exported:** ${bundle.exportedAt} from ${bundle.exportedFrom.machine} (hydra ${bundle.exportedFrom.hydraVersion})`
+  );
+  const usage = session.currentUsage;
+  if (usage && (usage.used !== void 0 || usage.costAmount !== void 0)) {
+    const usageBits = [];
+    if (usage.used !== void 0) {
+      const denom = usage.size !== void 0 ? `${formatNumber(usage.size)}` : void 0;
+      usageBits.push(
+        denom ? `${formatNumber(usage.used)} / ${denom} tokens` : `${formatNumber(usage.used)} tokens`
+      );
+    }
+    if (usage.costAmount !== void 0) {
+      const currency = usage.costCurrency ?? "USD";
+      usageBits.push(`$${usage.costAmount.toFixed(2)} ${currency}`);
+    }
+    lines.push(`- **Usage:** ${usageBits.join(" \xB7 ")}`);
+  }
+  out.push(lines.join("\n"));
+  out.push("");
+}
+function emitBody(out, events, toolFinalStates) {
+  if (!events.some((e) => isVisible(e.event))) {
+    out.push("_No conversation history recorded._");
+    out.push("");
+    return;
+  }
+  const seenToolIds = /* @__PURE__ */ new Set();
+  let turn = 0;
+  let agentBuffer = "";
+  let inTurn = false;
+  const flushAgent = () => {
+    if (agentBuffer.length === 0) {
+      return;
+    }
+    out.push(agentBuffer.trimEnd());
+    out.push("");
+    agentBuffer = "";
+  };
+  const startTurnIfNeeded = () => {
+    if (inTurn) {
+      return;
+    }
+    turn += 1;
+    out.push("---");
+    out.push("");
+    out.push(`## Turn ${turn}`);
+    out.push("");
+    inTurn = true;
+  };
+  for (const { event } of events) {
+    switch (event.kind) {
+      case "user-text": {
+        flushAgent();
+        turn += 1;
+        out.push("---");
+        out.push("");
+        out.push(`## Turn ${turn}`);
+        out.push("");
+        out.push("**User:**");
+        out.push("");
+        for (const line of event.text.split("\n")) {
+          out.push(`> ${escapeInline(line)}`);
+        }
+        out.push("");
+        out.push("**Assistant:**");
+        out.push("");
+        inTurn = true;
+        break;
+      }
+      case "agent-text":
+        startTurnIfNeeded();
+        agentBuffer += event.text;
+        break;
+      case "agent-thought": {
+        startTurnIfNeeded();
+        flushAgent();
+        const lines = event.text.split("\n");
+        for (const line of lines) {
+          out.push(`> _${escapeInline(line)}_`);
+        }
+        out.push("");
+        break;
+      }
+      case "tool-call": {
+        startTurnIfNeeded();
+        flushAgent();
+        if (seenToolIds.has(event.toolCallId)) {
+          break;
+        }
+        seenToolIds.add(event.toolCallId);
+        const final = toolFinalStates.get(event.toolCallId) ?? {
+          title: event.title,
+          status: event.status ?? "pending"
+        };
+        out.push(`- ${statusGlyph(final.status)} ${formatToolLine(final)}`);
+        out.push("");
+        break;
+      }
+      case "tool-call-update":
+        break;
+      case "plan": {
+        startTurnIfNeeded();
+        flushAgent();
+        out.push("**Plan:**");
+        out.push("");
+        for (const entry of event.entries) {
+          const checked = entry.status === "completed" ? "[x]" : "[ ]";
+          out.push(`- ${checked} ${escapeInline(entry.content)}`);
+        }
+        out.push("");
+        break;
+      }
+      case "mode-changed":
+        startTurnIfNeeded();
+        flushAgent();
+        out.push(`_mode: ${escapeInline(event.mode)}_`);
+        out.push("");
+        break;
+      case "model-changed":
+        startTurnIfNeeded();
+        flushAgent();
+        out.push(`_model: ${escapeInline(event.model)}_`);
+        out.push("");
+        break;
+      case "turn-complete":
+        flushAgent();
+        break;
+      case "usage-update":
+      case "available-commands":
+      case "session-info":
+      case "unknown":
+        break;
+    }
+  }
+  flushAgent();
+}
+function isVisible(event) {
+  switch (event.kind) {
+    case "usage-update":
+    case "available-commands":
+    case "session-info":
+    case "unknown":
+    case "turn-complete":
+      return false;
+    default:
+      return true;
+  }
+}
+function formatToolLine(state) {
+  const status = state.status;
+  const suffix = status === "completed" || status === void 0 ? "" : ` _(${status})_`;
+  return `${escapeInline(state.title)}${suffix}`;
+}
+function statusGlyph(status) {
+  switch (status) {
+    case "completed":
+      return "\u2713";
+    case "failed":
+      return "\u2717";
+    case "cancelled":
+    case "rejected":
+      return "\u2298";
+    case "in_progress":
+      return "\u21BB";
+    default:
+      return "\xB7";
+  }
+}
+function escapeInline(text) {
+  return text.replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function formatNumber(n) {
+  return n.toLocaleString("en-US");
+}
+
 // src/daemon/routes/sessions.ts
 function registerSessionRoutes(app, manager, defaults) {
   app.get("/v1/sessions", async (request) => {
@@ -4592,6 +5233,24 @@ function registerSessionRoutes(app, manager, defaults) {
     );
     reply.code(200).send(bundle);
   });
+  app.get("/v1/sessions/:id/transcript", async (request, reply) => {
+    const raw = request.params.id;
+    const id = await manager.resolveCanonicalId(raw) ?? raw;
+    const exported = await manager.exportBundle(id);
+    if (!exported) {
+      reply.code(404).send({ error: "session not found" });
+      return;
+    }
+    const bundle = encodeBundle({
+      record: exported.record,
+      history: exported.history,
+      promptHistory: exported.promptHistory.length > 0 ? exported.promptHistory : void 0,
+      hydraVersion: HYDRA_VERSION,
+      machine: os3.hostname()
+    });
+    reply.header("Content-Type", "text/markdown; charset=utf-8");
+    reply.code(200).send(bundleToMarkdown(bundle));
+  });
   app.post("/v1/sessions/import", async (request, reply) => {
     const body = request.body ?? {};
     if (body.bundle === void 0) {
@@ -4975,11 +5634,18 @@ function registerAcpWsEndpoint(app, deps) {
         model: hydraMeta.model
       });
       const client = bindClientToSession(connection, session, state);
-      await session.attach(client, "full");
+      const { entries: replay } = await session.attach(client, "full");
       state.attached.set(session.sessionId, {
         sessionId: session.sessionId,
         clientId: client.clientId
       });
+      setImmediate(() => {
+        void (async () => {
+          for (const note of replay) {
+            await connection.notify(note.method, note.params).catch(() => void 0);
+          }
+        })();
+      });
       return {
         sessionId: session.sessionId,
         _meta: buildResponseMeta(session)
@@ -5193,6 +5859,9 @@ function buildResponseMeta(session) {
   if (session.currentMode !== void 0) {
     ours.currentMode = session.currentMode;
   }
+  if (session.currentUsage !== void 0) {
+    ours.currentUsage = session.currentUsage;
+  }
   const commands = session.mergedAvailableCommands();
   if (commands.length > 0) {
     ours.availableCommands = commands;