@zaly/agent 0.0.3

package/dist/session/claude.mjs

@@ -0,0 +1,455 @@
+import { t as JsonlReader } from "../jsonl-Dw_VBp46.mjs";
+import { normPath } from "@zaly/shared";
+//#region src/session/claude.ts
+async function loadClaudeSession(path, opts = {}) {
+	path = normPath(path);
+	const convert = defaultConvertTool;
+	const chain = opts.walk === "all" ? await collectAll(path) : await walkChainLazy(path);
+	const toolCalls = collectToolCalls(chain, convert);
+	const messages = [];
+	for (const rec of chain) {
+		const msg = toZalyMessage(rec, toolCalls);
+		if (!msg) continue;
+		if (msg.role === "assistant") {
+			const usage = recordUsage(rec);
+			if (usage) msg.meta = {
+				...msg.meta,
+				usage
+			};
+		}
+		messages.push(msg);
+	}
+	messages.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+	dedupCallIds(messages);
+	return { messages };
+}
+/** Build a `Usage` from a Claude record's `message.usage` block.
+*  Returns undefined when no usage info is present (user messages,
+*  tool results). The caller stamps it onto `message.meta.usage`. */
+function recordUsage(rec) {
+	const u = rec.message?.usage;
+	if (!u) return void 0;
+	const usage = {
+		input: u.input_tokens ?? 0,
+		output: u.output_tokens ?? 0
+	};
+	if (u.cache_read_input_tokens !== void 0) usage.cacheRead = u.cache_read_input_tokens;
+	if (u.cache_creation_input_tokens !== void 0) usage.cacheWrite = u.cache_creation_input_tokens;
+	return usage;
+}
+/** Walk the parentUuid chain backward from the most recent on-chain
+*  user/assistant message and return the chronologically-ordered
+*  conversation. Reads the file lazily (backward in chunks) — only the
+*  chunks containing the active chain get pulled from disk.
+*
+*  Subtlety: Claude Code interleaves non-message records (`attachment`,
+*  `system`, `file-history-snapshot`, ...) into the parent chain — an
+*  assistant message's `parentUuid` may point at an `attachment`, whose
+*  `parentUuid` then points at the prior user message. We step *through*
+*  those records (using a uuid → ANY record map), collecting only the
+*  user/assistant messages we encounter. Sidechain messages are skipped.
+*
+*  For long-running sessions with multiple compactions, the active chain
+*  typically lives in the file's most recent chunks — so a 300MB session
+*  loads from a few hundred KB rather than reading the whole file. */
+async function walkChainLazy(path) {
+	const reader = new JsonlReader(path);
+	const byUuid = /* @__PURE__ */ new Map();
+	try {
+		let lastOnChain;
+		let value;
+		while ((value = await reader.next()) !== void 0) {
+			if (value.uuid !== void 0) byUuid.set(value.uuid, value);
+			if (isMessageRecord(value) && value.isSidechain !== true) {
+				lastOnChain = value.uuid;
+				break;
+			}
+		}
+		if (lastOnChain === void 0) return [];
+		const chain = [];
+		let cursor = lastOnChain;
+		while (cursor !== void 0) {
+			let rec = byUuid.get(cursor);
+			if (!rec) while ((value = await reader.next()) !== void 0) {
+				if (value.uuid !== void 0) byUuid.set(value.uuid, value);
+				if (value.uuid === cursor) {
+					rec = value;
+					break;
+				}
+			}
+			if (!rec) break;
+			if (rec.isCompactSummary === true) {
+				chain.push(rec);
+				break;
+			}
+			if (isMessageRecord(rec) && rec.isSidechain !== true) chain.push(rec);
+			cursor = rec.parentUuid;
+		}
+		return chain.toReversed();
+	} finally {
+		await reader.close();
+	}
+}
+function isMessageRecord(rec) {
+	return rec.type === "user" || rec.type === "assistant";
+}
+/** Every user/assistant message in file order, ignoring branches and
+*  compaction boundaries. Sidechain messages are still skipped — those
+*  belong to subagent loops and would scramble the main chain.
+*
+*  This mode reads the entire file (necessary to find every record),
+*  but uses chunked I/O via `JsonlReader` instead of slurping the
+*  whole string at once. */
+async function collectAll(path) {
+	const reader = new JsonlReader(path);
+	const records = [];
+	try {
+		let value;
+		while ((value = await reader.next()) !== void 0) if (isMessageRecord(value) && value.isSidechain !== true) records.push(value);
+	} finally {
+		await reader.close();
+	}
+	return records.toReversed();
+}
+/** Build a `tool_use_id → { name, params }` map from the assistant
+*  tool_use blocks in the chain, applying `convert` to remap names and
+*  params into zaly's tool shapes. Used both to render the converted
+*  `tool-call` parts on the assistant side and to fill in the (missing)
+*  `name` on Claude `tool_result` blocks at result-conversion time. */
+function collectToolCalls(chain, convert) {
+	const out = /* @__PURE__ */ new Map();
+	for (const rec of chain) {
+		if (rec.type !== "assistant") continue;
+		const content = rec.message?.content;
+		if (!Array.isArray(content)) continue;
+		for (const block of content) if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+			const zaly = convert({
+				input: block.input,
+				name: block.name
+			}) ?? {
+				name: block.name,
+				params: block.input
+			};
+			out.set(block.id, zaly);
+		}
+	}
+	return out;
+}
+/** Default `convertTool` mapping. Handles the standard Claude Code
+*  toolbox; everything else falls through to a lowercased name with
+*  params untouched. Composable: custom converters can call this for
+*  unhandled cases. */
+function defaultConvertTool(call) {
+	const input = call.input ?? {};
+	switch (call.name) {
+		case "Read": return {
+			name: "read",
+			params: renameKey(input, "file_path", "path")
+		};
+		case "Write": return {
+			name: "write",
+			params: renameKey(input, "file_path", "path")
+		};
+		case "Edit": {
+			const { file_path, old_string, new_string, replace_all, ...rest } = input;
+			return {
+				name: "edit",
+				params: {
+					edits: [{
+						newText: new_string,
+						oldText: old_string,
+						replaceAll: replace_all
+					}],
+					path: file_path,
+					...rest
+				}
+			};
+		}
+		case "MultiEdit": {
+			const { file_path, edits, ...rest } = input;
+			return {
+				name: "edit",
+				params: {
+					edits: Array.isArray(edits) ? edits.map((e) => ({
+						newText: e.new_string,
+						oldText: e.old_string,
+						replaceAll: e.replace_all
+					})) : [],
+					path: file_path,
+					...rest
+				}
+			};
+		}
+		case "Bash": return {
+			name: "bash",
+			params: input
+		};
+		default: return {
+			name: call.name.toLowerCase(),
+			params: input
+		};
+	}
+}
+function renameKey(obj, from, to) {
+	if (!(from in obj)) return obj;
+	const { [from]: value, ...rest } = obj;
+	return {
+		[to]: value,
+		...rest
+	};
+}
+/** Walk messages in chronological order; when a tool-call id reappears,
+*  rename the duplicate (and the corresponding tool-result) to a fresh
+*  id. Pairs are matched FIFO per-id: each duplicate call's pending
+*  rename gets consumed by the next tool-result with that original id.
+*  Mutates the message parts in place. */
+function dedupCallIds(messages) {
+	const seen = /* @__PURE__ */ new Set();
+	const pending = /* @__PURE__ */ new Map();
+	let counter = 0;
+	for (const m of messages) if (m.role === "assistant" && Array.isArray(m.content)) for (const p of m.content) {
+		if (p.type !== "tool-call") continue;
+		if (!seen.has(p.id)) {
+			seen.add(p.id);
+			continue;
+		}
+		const newId = `${p.id}-${++counter}`;
+		const list = pending.get(p.id) ?? [];
+		list.push(newId);
+		pending.set(p.id, list);
+		p.id = newId;
+	}
+	else if (m.role === "tool") for (const p of m.content) {
+		const origId = p.id;
+		const list = pending.get(origId);
+		if (!list || list.length === 0) continue;
+		p.id = list.shift();
+		if (list.length === 0) pending.delete(origId);
+	}
+}
+function toZalyMessage(rec, toolCalls) {
+	const inner = rec.message;
+	if (!inner) return void 0;
+	let m;
+	if (rec.type === "user") m = toUserMessage(inner, toolCalls, rec.toolUseResult);
+	else if (rec.type === "assistant") m = toAssistantMessage(inner, toolCalls);
+	if (!m) return void 0;
+	if (rec.timestamp) {
+		const ts = Date.parse(rec.timestamp);
+		if (!Number.isNaN(ts)) m = {
+			...m,
+			ts
+		};
+	}
+	if (rec.uuid) m = {
+		...m,
+		id: rec.uuid
+	};
+	return m;
+}
+function toUserMessage(inner, toolCalls, toolUseResult) {
+	const content = inner.content;
+	if (typeof content === "string") return {
+		content,
+		role: "user"
+	};
+	if (!Array.isArray(content) || content.length === 0) return void 0;
+	if (content.every((b) => b.type === "tool_result")) {
+		const parts = content.map((b) => toToolResultPart(b, toolCalls, toolUseResult)).filter((p) => p !== void 0);
+		if (parts.length === 0) return void 0;
+		return {
+			content: parts,
+			role: "tool"
+		};
+	}
+	const parts = content.map((b) => toUserPart(b)).filter((p) => p !== void 0);
+	if (parts.length === 0) return void 0;
+	return {
+		content: parts,
+		role: "user"
+	};
+}
+function toToolResultPart(block, toolCalls, toolUseResult) {
+	if (typeof block.tool_use_id !== "string") return void 0;
+	const name = toolCalls.get(block.tool_use_id)?.name ?? "";
+	const meta = toolUseResultMeta(name, toolUseResult);
+	return {
+		content: toToolResultContent(block.content),
+		id: block.tool_use_id,
+		isError: block.is_error === true,
+		name,
+		type: "tool-result",
+		...meta !== void 0 ? { meta } : {}
+	};
+}
+/** Map Claude Code's per-tool `toolUseResult` shape onto our flat
+*  `meta` schema. mtime is unknown at import time — we set 0 so any
+*  later `assertFresh` check forces the agent to re-read before
+*  mutating, rather than trusting potentially-stale bytes. */
+function toolUseResultMeta(name, result) {
+	if (result === void 0 || typeof result === "string") return void 0;
+	switch (name) {
+		case "read": {
+			const file = result.file;
+			if (!file?.filePath) return void 0;
+			return {
+				full: file.totalLines !== void 0 && file.numLines === file.totalLines,
+				kind: "read",
+				limit: file.numLines,
+				mtime: 0,
+				offset: file.startLine,
+				path: file.filePath
+			};
+		}
+		case "write":
+			if (!result.filePath) return void 0;
+			return {
+				full: true,
+				kind: "write",
+				mtime: 0,
+				original: result.originalFile,
+				path: result.filePath
+			};
+		case "edit": {
+			if (!result.filePath) return void 0;
+			const originalFile = typeof result.originalFile === "string" && result.originalFile.length > 0 ? result.originalFile : void 0;
+			let original = originalFile ?? "";
+			let content = "";
+			if (typeof result.content === "string") content = result.content;
+			else if (typeof result.oldString === "string" && typeof result.newString === "string") {
+				const { newString, oldString } = result;
+				const applied = applyClaudeEdit(originalFile, oldString, newString, result.replaceAll);
+				if (applied !== void 0) content = applied;
+				else {
+					const synth = synthesizeFromStructuredPatch(result.structuredPatch);
+					if (synth !== void 0) {
+						original = synth.original;
+						content = synth.modified;
+					} else {
+						original = oldString;
+						content = newString;
+					}
+				}
+			}
+			return {
+				content,
+				kind: "edit",
+				mtime: 0,
+				original,
+				path: result.filePath
+			};
+		}
+		default: return;
+	}
+}
+/** Apply a Claude single-Edit swap to the pre-edit content. Returns
+*  `undefined` when the edit can't be applied (no original file recorded
+*  or the search string doesn't appear in it) — caller falls back to
+*  showing just the swap. */
+function applyClaudeEdit(original, oldString, newString, replaceAll) {
+	if (original === void 0 || !original.includes(oldString)) return void 0;
+	return replaceAll === true ? original.split(oldString).join(newString) : original.replace(oldString, newString);
+}
+/** Reconstruct synthetic pre/post strings from a Claude `structuredPatch`.
+*  Hunks are placed at their real line numbers (`oldStart`/`newStart`)
+*  with empty-line padding outside, so the diff widget's gutter shows
+*  accurate file line numbers — same effect as Claude Code's UI. Lines
+*  prefixed " "/" -" go to the original, " "/" +" go to modified. */
+function synthesizeFromStructuredPatch(patch) {
+	if (!Array.isArray(patch) || patch.length === 0) return void 0;
+	const origLines = [];
+	const modLines = [];
+	for (const h of patch) {
+		padTo(origLines, h.oldStart);
+		padTo(modLines, h.newStart);
+		for (const raw of h.lines) {
+			const tag = raw[0];
+			const body = raw.slice(1);
+			if (tag === "-") origLines.push(body);
+			else if (tag === "+") modLines.push(body);
+			else {
+				origLines.push(body);
+				modLines.push(body);
+			}
+		}
+	}
+	return {
+		modified: modLines.join("\n"),
+		original: origLines.join("\n")
+	};
+}
+/** 1-based line indexing in the patch; pad with empty strings up to
+*  the target line so subsequent pushes land at the right index. */
+function padTo(arr, idx) {
+	while (arr.length < idx - 1) arr.push("");
+}
+/** Tool result content: Claude allows string OR an array of text/image
+*  blocks. Map both into zaly's `Content` shape. */
+function toToolResultContent(content) {
+	if (content === void 0) return "";
+	if (typeof content === "string") return content;
+	const parts = content.map((b) => toUserPart(b)).filter((p) => p !== void 0);
+	return parts.length > 0 ? parts : "";
+}
+function toUserPart(block) {
+	if (block.type === "text" && typeof block.text === "string") return {
+		text: block.text,
+		type: "text"
+	};
+	if (block.type === "image") return toImagePart(block);
+}
+function toImagePart(block) {
+	const src = block.source;
+	if (src.type === "base64") {
+		const mime = src.media_type;
+		if (mime !== "image/png" && mime !== "image/jpeg" && mime !== "image/webp") return void 0;
+		return {
+			mime,
+			source: {
+				data: src.data,
+				type: "base64"
+			},
+			type: "image"
+		};
+	}
+}
+function toAssistantMessage(inner, toolCalls) {
+	const content = inner.content;
+	if (typeof content === "string") return {
+		content,
+		role: "assistant"
+	};
+	if (!Array.isArray(content)) return void 0;
+	const parts = [];
+	for (const block of content) {
+		const part = toAssistantPart(block, toolCalls);
+		if (part) parts.push(part);
+	}
+	if (parts.length === 0) return void 0;
+	return {
+		content: parts,
+		role: "assistant"
+	};
+}
+function toAssistantPart(block, toolCalls) {
+	if (block.type === "text" && typeof block.text === "string") return {
+		text: block.text,
+		type: "text"
+	};
+	if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+		const call = toolCalls.get(block.id) ?? {
+			name: block.name,
+			params: block.input
+		};
+		return {
+			id: block.id,
+			name: call.name,
+			params: call.params,
+			type: "tool-call"
+		};
+	}
+}
+//#endregion
+export { loadClaudeSession };
+
+//# sourceMappingURL=claude.mjs.map

package/dist/session/claude.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude.mjs","names":[],"sources":["../../src/session/claude.ts"],"sourcesContent":["import type {\n  Attachment,\n  ImagePart,\n  Message,\n  ReasoningPart,\n  TextPart,\n  ToolCallPart,\n  ToolResultPart,\n  Usage,\n} from \"@zaly/ai\"\n\nimport { normPath } from \"@zaly/shared\"\nimport { JsonlReader } from \"./jsonl.ts\"\n\n/**\n * Read a Claude Code session file (`.jsonl` from `~/.claude/projects/...`)\n * and return its active conversation chain as zaly `Message[]` — pass\n * the result to `Agent.load({ messages, ... })` to seed a fresh agent\n * with the imported history.\n *\n * Claude Code stores its conversation as one JSON record per line. The\n * active chain is reconstructed by walking `parentUuid` backward from the\n * most recent on-chain user/assistant message. Non-message records\n * (`permission-mode`, `attachment`, `system`, `summary`, `file-history-\n * snapshot`, ...), sidechain branches (`isSidechain: true`), and orphan\n * lines outside the chain are skipped.\n *\n * Format mapping:\n *\n * - **User message, string content** → zaly `role: \"user\"`, content\n *   passed through verbatim.\n * - **User message, array content with `tool_result` blocks** → zaly\n *   `role: \"tool\"`. Anthropic's wire format puts tool results in a\n *   user message; zaly splits them into a dedicated `tool` role. The\n *   tool name (which Claude doesn't store on the result) is resolved\n *   from the matching `tool_use` block earlier in the chain.\n * - **User message, array content with text/image blocks** → zaly\n *   `role: \"user\"` with the parts converted (text passes through,\n *   images become `ImagePart`).\n * - **Assistant message** → zaly `role: \"assistant\"` with each block\n *   mapped: `text` → `TextPart`, `tool_use` → `ToolCallPart` (the\n *   block's `input` becomes `params`). `thinking` / `redacted_thinking`\n *   blocks are intentionally dropped on import — Anthropic requires\n *   them to round-trip with the exact original `signature` or the next\n *   request 400s, and any intermediate processing risks corrupting it.\n *   The visible conversation state survives without them.\n *\n * Lossy by design — tokens, finish reasons, model swaps, and timing\n * info from Claude's records are dropped because zaly's `Session.add`\n * doesn't expose those for arbitrary imports. The returned messages\n * carry no `path` association; pass `session: { path: \"...\" }` to\n * `Agent.load` alongside them if you want to start persisting the\n * imported chain in zaly format.\n */\nexport interface ClaudeSessionOptions {\n  /** Which messages to import:\n   *    - `\"active\"` (default) — walks `parentUuid` back from the most\n   *      recent on-chain message. Returns the conversation as the model\n   *      currently sees it: branches not on the active head are skipped,\n   *      pre-compact history (parented to a summary record) is dropped.\n   *    - `\"all\"` — every user/assistant message in the file, in\n   *      chronological order, regardless of branch or compaction. Useful\n   *      for analytics, fixtures, or recovering pre-compact context. */\n  walk?: \"active\" | \"all\"\n}\n\ntype ConvertTool = (call: ClaudeToolCall) => ZalyToolCall | undefined\ninterface ClaudeToolCall {\n  name: string\n  input: unknown\n}\ninterface ZalyToolCall {\n  name: string\n  params: unknown\n}\n\nexport async function loadClaudeSession(\n  path: string,\n  opts: ClaudeSessionOptions = {}\n): Promise<{ messages: Message[] }> {\n  // Honor `~` and relative shorthands — config-file / env paths often\n  // include them and Node's fs APIs don't expand `~` natively.\n  path = normPath(path)\n  const convert = defaultConvertTool\n  const chain = opts.walk === \"all\" ? await collectAll(path) : await walkChainLazy(path)\n  const toolCalls = collectToolCalls(chain, convert)\n\n  const messages: Message[] = []\n  for (const rec of chain) {\n    const msg = toZalyMessage(rec, toolCalls)\n    if (!msg) continue\n    if (msg.role === \"assistant\") {\n      const usage = recordUsage(rec)\n      if (usage) msg.meta = { ...msg.meta, usage }\n    }\n    messages.push(msg)\n  }\n  messages.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0))\n  // De-duplicate tool_use ids. Claude Code branching / sidechain replay\n  // can emit the same tool_use_id across multiple assistant messages\n  // (especially with `walk: \"all\"`); downstream consumers like the\n  // masker or any (id → call) lookup expect uniqueness.\n  dedupCallIds(messages)\n  return { messages }\n}\n\n/** Build a `Usage` from a Claude record's `message.usage` block.\n *  Returns undefined when no usage info is present (user messages,\n *  tool results). The caller stamps it onto `message.meta.usage`. */\nfunction recordUsage(rec: ClaudeRecord): Usage | undefined {\n  const u = rec.message?.usage\n  if (!u) return undefined\n  const usage: Usage = {\n    input: u.input_tokens ?? 0,\n    output: u.output_tokens ?? 0,\n  }\n  if (u.cache_read_input_tokens !== undefined) usage.cacheRead = u.cache_read_input_tokens\n  if (u.cache_creation_input_tokens !== undefined) usage.cacheWrite = u.cache_creation_input_tokens\n  return usage\n}\n\n// ── Parsing ──────────────────────────────────────────────────────────────\n\ninterface ClaudeRecord {\n  type: string\n  uuid?: string\n  parentUuid?: string\n  isSidechain?: boolean\n  /** Set on the synthetic user-role record Claude Code writes for a\n   *  `/compact`. The record's content is the summary text; chronologically\n   *  it sits where the compaction happened, with its `parentUuid` still\n   *  pointing into pre-compaction history. The active conversation is\n   *  this summary plus everything after — pre-compaction messages are\n   *  unreachable from the live agent. */\n  isCompactSummary?: boolean\n  message?: ClaudeMessage\n  /** Wall-clock time the original Claude session recorded the message,\n   *  ISO 8601 string. Preserved onto `Message.ts` so age-based logic\n   *  (masker `maxAge`, freshness, replay) sees realistic timestamps\n   *  rather than the import time. */\n  timestamp?: string\n  /** Claude Code attaches structured per-tool result info here, alongside\n   *  the model-visible `tool_result` block. Shape varies by tool:\n   *    - read   → `{ type: \"text\"|\"image\", file: { filePath, ... } }`\n   *    - write  → `{ type: \"create\", filePath, content, originalFile, ... }`\n   *    - edit   → `{ type: \"update\", filePath, content, originalFile, ... }`\n   *    - bash   → `{ stdout, stderr, interrupted, ... }`\n   *  We mine this for `meta` to populate on imported `ToolResultPart`s.\n   */\n  toolUseResult?: ClaudeToolUseResult\n}\n\ntype ClaudeToolUseResult =\n  | string\n  | {\n      type?: \"text\" | \"image\" | \"create\" | \"update\" | \"file_unchanged\"\n      file?: {\n        filePath?: string\n        content?: string\n        numLines?: number\n        startLine?: number\n        totalLines?: number\n      }\n      filePath?: string\n      /** Set on MultiEdit / Write results — post-state file content. */\n      content?: string\n      /** Set on Edit results (single replacement). The post-state must\n       *  be derived by applying `oldString` → `newString` to\n       *  `originalFile`. */\n      oldString?: string\n      newString?: string\n      replaceAll?: boolean\n      originalFile?: string\n      structuredPatch?: ClaudeStructuredHunk[]\n      [key: string]: unknown\n    }\n\ninterface ClaudeStructuredHunk {\n  oldStart: number\n  oldLines: number\n  newStart: number\n  newLines: number\n  lines: string[]\n}\n\ninterface ClaudeMessage {\n  role?: \"user\" | \"assistant\"\n  content?: string | ClaudeBlock[]\n  model?: string\n  usage?: ClaudeUsage\n  stop_reason?: string\n}\n\ninterface ClaudeUsage {\n  input_tokens?: number\n  output_tokens?: number\n  cache_read_input_tokens?: number\n  cache_creation_input_tokens?: number\n}\n\ntype ClaudeBlock =\n  | { type: \"text\"; text: string }\n  | { type: \"thinking\"; thinking: string; signature?: string }\n  | { type: \"tool_use\"; id: string; name: string; input: unknown }\n  | {\n      type: \"tool_result\"\n      tool_use_id: string\n      content?: string | ClaudeBlock[]\n      is_error?: boolean\n    }\n  | {\n      type: \"image\"\n      source: { type: \"base64\"; media_type: string; data: string } | { type: \"url\"; url: string }\n    }\n  | { type: string; [key: string]: unknown } // unknown block — falls through to a placeholder\n\n// ── Chain walk ───────────────────────────────────────────────────────────\n\n/** Walk the parentUuid chain backward from the most recent on-chain\n *  user/assistant message and return the chronologically-ordered\n *  conversation. Reads the file lazily (backward in chunks) — only the\n *  chunks containing the active chain get pulled from disk.\n *\n *  Subtlety: Claude Code interleaves non-message records (`attachment`,\n *  `system`, `file-history-snapshot`, ...) into the parent chain — an\n *  assistant message's `parentUuid` may point at an `attachment`, whose\n *  `parentUuid` then points at the prior user message. We step *through*\n *  those records (using a uuid → ANY record map), collecting only the\n *  user/assistant messages we encounter. Sidechain messages are skipped.\n *\n *  For long-running sessions with multiple compactions, the active chain\n *  typically lives in the file's most recent chunks — so a 300MB session\n *  loads from a few hundred KB rather than reading the whole file. */\nasync function walkChainLazy(path: string): Promise<ClaudeRecord[]> {\n  const reader = new JsonlReader<ClaudeRecord>(path)\n  const byUuid = new Map<string, ClaudeRecord>()\n  try {\n    // Phase 1: read backward until we find the most recent on-chain\n    // (non-sidechain) user/assistant message.\n    let lastOnChain: string | undefined\n    let value: ClaudeRecord | undefined\n    // eslint-disable-next-line no-await-in-loop\n    while ((value = await reader.next()) !== undefined) {\n      if (value.uuid !== undefined) byUuid.set(value.uuid, value)\n      if (isMessageRecord(value) && value.isSidechain !== true) {\n        lastOnChain = value.uuid\n        break\n      }\n    }\n    if (lastOnChain === undefined) return []\n\n    // Phase 2: walk parentUuid backward, fetching more records lazily\n    // as needed to resolve each cursor. A `summary` record is a HARD\n    // boundary — Claude Code compactions create a summary node and\n    // anything before it is unreachable in the live conversation, so\n    // we must not walk past it (would otherwise pull pre-compaction\n    // history that the model can no longer see).\n    const chain: ClaudeRecord[] = []\n    let cursor: string | undefined = lastOnChain\n    while (cursor !== undefined) {\n      let rec = byUuid.get(cursor)\n      if (!rec) {\n        // Pull more records from the reader until we find this uuid\n        // (or run out). Records pulled along the way get cached for\n        // later cursor lookups.\n        // eslint-disable-next-line no-await-in-loop\n        while ((value = await reader.next()) !== undefined) {\n          if (value.uuid !== undefined) byUuid.set(value.uuid, value)\n          if (value.uuid === cursor) {\n            rec = value\n            break\n          }\n        }\n      }\n      if (!rec) break\n      // Compaction boundary — Claude writes the synthetic summary as a\n      // user-role record flagged `isCompactSummary`. Include it (it IS\n      // the visible context for the resumed conversation) and stop —\n      // anything older than this is unreachable from the live agent.\n      if (rec.isCompactSummary === true) {\n        chain.push(rec)\n        break\n      }\n      if (isMessageRecord(rec) && rec.isSidechain !== true) chain.push(rec)\n      cursor = rec.parentUuid\n    }\n    return chain.toReversed()\n  } finally {\n    await reader.close()\n  }\n}\n\nfunction isMessageRecord(rec: ClaudeRecord): boolean {\n  return rec.type === \"user\" || rec.type === \"assistant\"\n}\n\n/** Every user/assistant message in file order, ignoring branches and\n *  compaction boundaries. Sidechain messages are still skipped — those\n *  belong to subagent loops and would scramble the main chain.\n *\n *  This mode reads the entire file (necessary to find every record),\n *  but uses chunked I/O via `JsonlReader` instead of slurping the\n *  whole string at once. */\nasync function collectAll(path: string): Promise<ClaudeRecord[]> {\n  const reader = new JsonlReader<ClaudeRecord>(path)\n  const records: ClaudeRecord[] = []\n  try {\n    let value: ClaudeRecord | undefined\n    // eslint-disable-next-line no-await-in-loop\n    while ((value = await reader.next()) !== undefined) {\n      if (isMessageRecord(value) && value.isSidechain !== true) records.push(value)\n    }\n  } finally {\n    await reader.close()\n  }\n  // Reader yields newest-first; flip to chronological.\n  return records.toReversed()\n}\n\n/** Build a `tool_use_id → { name, params }` map from the assistant\n *  tool_use blocks in the chain, applying `convert` to remap names and\n *  params into zaly's tool shapes. Used both to render the converted\n *  `tool-call` parts on the assistant side and to fill in the (missing)\n *  `name` on Claude `tool_result` blocks at result-conversion time. */\nfunction collectToolCalls(\n  chain: readonly ClaudeRecord[],\n  convert: ConvertTool\n): Map<string, ZalyToolCall> {\n  const out = new Map<string, ZalyToolCall>()\n  for (const rec of chain) {\n    if (rec.type !== \"assistant\") continue\n    const content = rec.message?.content\n    if (!Array.isArray(content)) continue\n    for (const block of content) {\n      if (\n        block.type === \"tool_use\" &&\n        typeof block.id === \"string\" &&\n        typeof block.name === \"string\"\n      ) {\n        const claude = { input: block.input, name: block.name }\n        const zaly = convert(claude) ?? { name: block.name, params: block.input }\n        out.set(block.id, zaly)\n      }\n    }\n  }\n  return out\n}\n\n/** Default `convertTool` mapping. Handles the standard Claude Code\n *  toolbox; everything else falls through to a lowercased name with\n *  params untouched. Composable: custom converters can call this for\n *  unhandled cases. */\nfunction defaultConvertTool(call: ClaudeToolCall): ZalyToolCall {\n  const input = (call.input ?? {}) as Record<string, unknown>\n  switch (call.name) {\n    case \"Read\": {\n      return { name: \"read\", params: renameKey(input, \"file_path\", \"path\") }\n    }\n    case \"Write\": {\n      return { name: \"write\", params: renameKey(input, \"file_path\", \"path\") }\n    }\n    case \"Edit\": {\n      const { file_path, old_string, new_string, replace_all, ...rest } = input\n      return {\n        name: \"edit\",\n        params: {\n          edits: [{ newText: new_string, oldText: old_string, replaceAll: replace_all }],\n          path: file_path,\n          ...rest,\n        },\n      }\n    }\n    case \"MultiEdit\": {\n      const { file_path, edits, ...rest } = input\n      const mapped = Array.isArray(edits)\n        ? edits.map((e: Record<string, unknown>) => ({\n            newText: e.new_string,\n            oldText: e.old_string,\n            replaceAll: e.replace_all,\n          }))\n        : []\n      return { name: \"edit\", params: { edits: mapped, path: file_path, ...rest } }\n    }\n    case \"Bash\": {\n      return { name: \"bash\", params: input }\n    }\n    default: {\n      return { name: call.name.toLowerCase(), params: input }\n    }\n  }\n}\n\nfunction renameKey(\n  obj: Record<string, unknown>,\n  from: string,\n  to: string\n): Record<string, unknown> {\n  if (!(from in obj)) return obj\n  const { [from]: value, ...rest } = obj\n  return { [to]: value, ...rest }\n}\n\n/** Walk messages in chronological order; when a tool-call id reappears,\n *  rename the duplicate (and the corresponding tool-result) to a fresh\n *  id. Pairs are matched FIFO per-id: each duplicate call's pending\n *  rename gets consumed by the next tool-result with that original id.\n *  Mutates the message parts in place. */\nfunction dedupCallIds(messages: readonly Message[]): void {\n  const seen = new Set<string>()\n  // Per-id queue of renames awaiting their tool-result.\n  const pending = new Map<string, string[]>()\n  let counter = 0\n  for (const m of messages) {\n    if (m.role === \"assistant\" && Array.isArray(m.content)) {\n      for (const p of m.content) {\n        if (p.type !== \"tool-call\") continue\n        if (!seen.has(p.id)) {\n          seen.add(p.id)\n          continue\n        }\n        const newId = `${p.id}-${++counter}`\n        const list = pending.get(p.id) ?? []\n        list.push(newId)\n        pending.set(p.id, list)\n        p.id = newId\n      }\n    } else if (m.role === \"tool\") {\n      for (const p of m.content) {\n        const origId = p.id\n        const list = pending.get(origId)\n        if (!list || list.length === 0) continue\n        p.id = list.shift()!\n        if (list.length === 0) pending.delete(origId)\n      }\n    }\n  }\n}\n\n// ── Conversion ───────────────────────────────────────────────────────────\n\nfunction toZalyMessage(\n  rec: ClaudeRecord,\n  toolCalls: Map<string, ZalyToolCall>\n): Message | undefined {\n  const inner = rec.message\n  if (!inner) return undefined\n\n  let m: Message | undefined\n  if (rec.type === \"user\") m = toUserMessage(inner, toolCalls, rec.toolUseResult)\n  else if (rec.type === \"assistant\") m = toAssistantMessage(inner, toolCalls)\n  if (!m) return undefined\n\n  // Preserve the original Claude timestamp so age-based logic (masker\n  // `maxAge`, freshness checks, replay) sees realistic times instead\n  // of when the import ran.\n  if (rec.timestamp) {\n    const ts = Date.parse(rec.timestamp)\n    if (!Number.isNaN(ts)) m = { ...m, ts }\n  }\n  // Carry the record's uuid as the message id so the imported message\n  // can be referenced by the session DAG (and so per-message meta lifted\n  // off the same record can be looked up back here).\n  if (rec.uuid) m = { ...m, id: rec.uuid }\n  return m\n}\n\nfunction toUserMessage(\n  inner: ClaudeMessage,\n  toolCalls: Map<string, ZalyToolCall>,\n  toolUseResult: ClaudeToolUseResult | undefined\n): Message | undefined {\n  const content = inner.content\n  if (typeof content === \"string\") {\n    return { content, role: \"user\" }\n  }\n  if (!Array.isArray(content) || content.length === 0) return undefined\n\n  // If every block is a tool_result, this is a zaly tool message.\n  if (content.every((b) => b.type === \"tool_result\")) {\n    const parts = content\n      .map((b) =>\n        toToolResultPart(\n          b as Extract<ClaudeBlock, { type: \"tool_result\" }>,\n          toolCalls,\n          toolUseResult\n        )\n      )\n      .filter((p): p is ToolResultPart => p !== undefined)\n    if (parts.length === 0) return undefined\n    return { content: parts, role: \"tool\" }\n  }\n\n  // Otherwise treat as a user message with text / image parts. Mixed\n  // arrays carrying a tool_result alongside text are rare; we drop the\n  // tool_result here (it would belong on its own message) and keep the\n  // visible content.\n  const parts = content\n    .map((b) => toUserPart(b))\n    .filter((p): p is TextPart | Attachment => p !== undefined)\n  if (parts.length === 0) return undefined\n  return { content: parts, role: \"user\" }\n}\n\nfunction toToolResultPart(\n  block: Extract<ClaudeBlock, { type: \"tool_result\" }>,\n  toolCalls: Map<string, ZalyToolCall>,\n  toolUseResult: ClaudeToolUseResult | undefined\n): ToolResultPart | undefined {\n  if (typeof block.tool_use_id !== \"string\") return undefined\n  const name = toolCalls.get(block.tool_use_id)?.name ?? \"\"\n  const meta = toolUseResultMeta(name, toolUseResult)\n  return {\n    content: toToolResultContent(block.content),\n    id: block.tool_use_id,\n    isError: block.is_error === true,\n    name,\n    type: \"tool-result\",\n    ...(meta !== undefined ? { meta } : {}),\n  }\n}\n\n/** Map Claude Code's per-tool `toolUseResult` shape onto our flat\n *  `meta` schema. mtime is unknown at import time — we set 0 so any\n *  later `assertFresh` check forces the agent to re-read before\n *  mutating, rather than trusting potentially-stale bytes. */\nfunction toolUseResultMeta(\n  name: string,\n  result: ClaudeToolUseResult | undefined\n): Record<string, unknown> | undefined {\n  if (result === undefined || typeof result === \"string\") return undefined\n  switch (name) {\n    case \"read\": {\n      const file = result.file\n      if (!file?.filePath) return undefined\n      return {\n        full: file.totalLines !== undefined && file.numLines === file.totalLines,\n        kind: \"read\",\n        limit: file.numLines,\n        mtime: 0,\n        offset: file.startLine,\n        path: file.filePath,\n      }\n    }\n    case \"write\": {\n      if (!result.filePath) return undefined\n      // Post-write content lives on the original tool call's\n      // `params.content`; we only stash `original` (pre-write).\n      return {\n        full: true,\n        kind: \"write\",\n        mtime: 0,\n        original: result.originalFile,\n        path: result.filePath,\n      }\n    }\n    case \"edit\": {\n      if (!result.filePath) return undefined\n      // Several Claude Code shapes to handle:\n      //  1. MultiEdit / older Edit: `content` (post-state) is provided\n      //     directly alongside `originalFile` (pre-state).\n      //  2. Single Edit with full pre-state: `oldString`/`newString`\n      //     swap on top of a populated `originalFile`. Derive content\n      //     by applying the swap.\n      //  3. Single Edit without pre-state but with `structuredPatch`:\n      //     reconstruct synthetic pre/post strings from the patch hunks\n      //     (Claude Code's UI does the same trick — the patch carries\n      //     context + line numbers). The diff widget then renders with\n      //     the real file line numbers in the gutter.\n      //  4. None of the above: fall back to showing just the swap.\n      const originalFile =\n        typeof result.originalFile === \"string\" && result.originalFile.length > 0\n          ? result.originalFile\n          : undefined\n      let original = originalFile ?? \"\"\n      let content = \"\"\n\n      if (typeof result.content === \"string\") {\n        content = result.content\n      } else if (typeof result.oldString === \"string\" && typeof result.newString === \"string\") {\n        const { newString, oldString } = result\n        const applied = applyClaudeEdit(originalFile, oldString, newString, result.replaceAll)\n        if (applied !== undefined) {\n          content = applied\n        } else {\n          const synth = synthesizeFromStructuredPatch(result.structuredPatch)\n          if (synth !== undefined) {\n            original = synth.original\n            content = synth.modified\n          } else {\n            original = oldString\n            content = newString\n          }\n        }\n      }\n      return { content, kind: \"edit\", mtime: 0, original, path: result.filePath }\n    }\n    default: {\n      return undefined\n    }\n  }\n}\n\n/** Apply a Claude single-Edit swap to the pre-edit content. Returns\n *  `undefined` when the edit can't be applied (no original file recorded\n *  or the search string doesn't appear in it) — caller falls back to\n *  showing just the swap. */\nfunction applyClaudeEdit(\n  original: string | undefined,\n  oldString: string,\n  newString: string,\n  replaceAll: boolean | undefined\n): string | undefined {\n  if (original === undefined || !original.includes(oldString)) return undefined\n  return replaceAll === true\n    ? original.split(oldString).join(newString)\n    : original.replace(oldString, newString)\n}\n\n/** Reconstruct synthetic pre/post strings from a Claude `structuredPatch`.\n *  Hunks are placed at their real line numbers (`oldStart`/`newStart`)\n *  with empty-line padding outside, so the diff widget's gutter shows\n *  accurate file line numbers — same effect as Claude Code's UI. Lines\n *  prefixed \" \"/\" -\" go to the original, \" \"/\" +\" go to modified. */\nfunction synthesizeFromStructuredPatch(\n  patch: ClaudeStructuredHunk[] | undefined\n): { original: string; modified: string } | undefined {\n  if (!Array.isArray(patch) || patch.length === 0) return undefined\n  const origLines: string[] = []\n  const modLines: string[] = []\n  for (const h of patch) {\n    padTo(origLines, h.oldStart)\n    padTo(modLines, h.newStart)\n    for (const raw of h.lines) {\n      // Each entry is a unified-diff row: \" ctx\", \"-removed\", \"+added\".\n      const tag = raw[0]\n      const body = raw.slice(1)\n      if (tag === \"-\") origLines.push(body)\n      else if (tag === \"+\") modLines.push(body)\n      else {\n        origLines.push(body)\n        modLines.push(body)\n      }\n    }\n  }\n  return { modified: modLines.join(\"\\n\"), original: origLines.join(\"\\n\") }\n}\n\n/** 1-based line indexing in the patch; pad with empty strings up to\n *  the target line so subsequent pushes land at the right index. */\nfunction padTo(arr: string[], idx: number): void {\n  while (arr.length < idx - 1) arr.push(\"\")\n}\n\n/** Tool result content: Claude allows string OR an array of text/image\n *  blocks. Map both into zaly's `Content` shape. */\nfunction toToolResultContent(\n  content: string | ClaudeBlock[] | undefined\n): ToolResultPart[\"content\"] {\n  if (content === undefined) return \"\"\n  if (typeof content === \"string\") return content\n  const parts = content\n    .map((b) => toUserPart(b))\n    .filter((p): p is TextPart | Attachment => p !== undefined)\n  return parts.length > 0 ? parts : \"\"\n}\n\nfunction toUserPart(block: ClaudeBlock): TextPart | Attachment | undefined {\n  if (block.type === \"text\" && typeof block.text === \"string\") {\n    return { text: block.text, type: \"text\" }\n  }\n  if (block.type === \"image\") {\n    return toImagePart(block as Extract<ClaudeBlock, { type: \"image\" }>)\n  }\n  return undefined\n}\n\nfunction toImagePart(block: Extract<ClaudeBlock, { type: \"image\" }>): ImagePart | undefined {\n  const src = block.source\n  if (src.type === \"base64\") {\n    const mime = src.media_type\n    if (mime !== \"image/png\" && mime !== \"image/jpeg\" && mime !== \"image/webp\") return undefined\n    return { mime, source: { data: src.data, type: \"base64\" }, type: \"image\" }\n  }\n  // url-source images: zaly's ImagePart only types png/jpeg/webp mimes,\n  // and we don't know the mime from a bare URL here. Skip — the model\n  // already saw it in the original Claude session; losing it on import\n  // is less bad than fabricating a wrong mime.\n  return undefined\n}\n\nfunction toAssistantMessage(\n  inner: ClaudeMessage,\n  toolCalls: Map<string, ZalyToolCall>\n): Message | undefined {\n  const content = inner.content\n  if (typeof content === \"string\") {\n    return { content, role: \"assistant\" }\n  }\n  if (!Array.isArray(content)) return undefined\n\n  const parts: (TextPart | ReasoningPart | ToolCallPart)[] = []\n  for (const block of content) {\n    const part = toAssistantPart(block, toolCalls)\n    if (part) parts.push(part)\n  }\n  if (parts.length === 0) return undefined\n  return { content: parts, role: \"assistant\" }\n}\n\nfunction toAssistantPart(\n  block: ClaudeBlock,\n  toolCalls: Map<string, ZalyToolCall>\n): TextPart | ReasoningPart | ToolCallPart | undefined {\n  if (block.type === \"text\" && typeof block.text === \"string\") {\n    return { text: block.text, type: \"text\" }\n  }\n  // Reasoning / thinking blocks are intentionally dropped on import.\n  // Anthropic requires them to round-trip with the exact original\n  // `signature`, and any intermediate processing (truncation, reorder,\n  // even just a different request shape) trips a 400 in the next turn.\n  // The visible text and tool calls carry the conversation's effective\n  // state; thinking is recoverable from re-running, so dropping it is\n  // strictly safer than risking signature mismatch errors.\n  if (block.type === \"tool_use\" && typeof block.id === \"string\" && typeof block.name === \"string\") {\n    const call = toolCalls.get(block.id) ?? { name: block.name, params: block.input }\n    return { id: block.id, name: call.name, params: call.params, type: \"tool-call\" }\n  }\n  return undefined\n}\n"],"mappings":"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"}