linkshell-cli 0.3.8 → 0.3.10

package/src/runtime/acp/claude-sessions.ts

@@ -18,10 +18,38 @@ export interface ClaudeStoredSession {
 export interface StoredAgentTimelineItem {
   id: string;
   conversationId: string;
-  type: "message";
-  role: "user" | "assistant" | "system";
-  content: Array<{ type: "text"; text: string }>;
-  text: string;
+  type: "message" | "tool_call";
+  kind?: "tool_activity" | "command_execution" | "file_change";
+  itemId?: string;
+  role?: "user" | "assistant" | "system";
+  content?: Array<{ type: "text"; text: string }>;
+  text?: string;
+  toolCall?: {
+    id: string;
+    name: string;
+    input?: string;
+    output?: string;
+    createdAt?: number;
+    status: "pending" | "running" | "completed" | "failed";
+  };
+  commandExecution?: {
+    command?: string;
+    cwd?: string;
+    output?: string;
+    exitCode?: number | null;
+    status?: "pending" | "running" | "completed" | "failed";
+  };
+  fileChange?: {
+    entries: Array<{
+      path: string;
+      kind?: string;
+      added?: number;
+      removed?: number;
+    }>;
+    diff?: string;
+    summary?: string;
+    status?: "pending" | "running" | "completed" | "failed";
+  };
   createdAt: number;
   updatedAt?: number;
   metadata?: Record<string, unknown>;
@@ -110,6 +138,35 @@ function extractHistoryText(value: unknown): string | undefined {
   return extractHistoryText(record.content ?? record.text ?? record.message);
 }
 
+function extractVisibleClaudeText(value: unknown): string | undefined {
+  if (!Array.isArray(value)) return extractHistoryText(value);
+  const text = value
+    .map((part) => {
+      if (typeof part === "string") return part;
+      const record = asRecord(part);
+      if (!record || record.type === "tool_use" || record.type === "tool_result") return "";
+      return typeof record.text === "string"
+        ? record.text
+        : typeof record.content === "string"
+        ? record.content
+        : "";
+    })
+    .filter(Boolean)
+    .join("\n")
+    .trim();
+  return text || undefined;
+}
+
+function stringifyHistoryValue(value: unknown): string | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value, null, 2);
+  } catch {
+    return String(value);
+  }
+}
+
 function guessCwdFromProjectDir(projectDirName: string, fallbackCwd: string): string {
   const trimmed = projectDirName.replace(/^-+/, "");
   if (!trimmed) return resolve(fallbackCwd);
@@ -292,6 +349,127 @@ function historyMessage(
   };
 }
 
+function claudeToolName(name: string | undefined): string {
+  if (!name) return "工具";
+  if (name === "Bash") return "命令";
+  if (isClaudeFileTool(name)) return "文件修改";
+  return name;
+}
+
+function isClaudeFileTool(name: string | undefined): boolean {
+  return name === "Edit" || name === "MultiEdit" || name === "Write" || name === "NotebookEdit";
+}
+
+function claudeToolKind(name: string | undefined): "tool_activity" | "command_execution" | "file_change" {
+  if (name === "Bash") return "command_execution";
+  if (isClaudeFileTool(name)) return "file_change";
+  return "tool_activity";
+}
+
+function claudeFileEntry(name: string | undefined, input: Record<string, unknown> | undefined): StoredAgentTimelineItem["fileChange"] | undefined {
+  if (!isClaudeFileTool(name) || !input) return undefined;
+  const rawPath = input.file_path ?? input.path ?? input.notebook_path;
+  if (typeof rawPath !== "string" || !rawPath.trim()) return undefined;
+  const path = rawPath.trim();
+  const kind = name === "Write" ? "create" : "update";
+  const added = typeof input.new_string === "string"
+    ? input.new_string.split(/\r?\n/).filter((line) => line.length > 0).length
+    : typeof input.content === "string"
+    ? input.content.split(/\r?\n/).filter((line) => line.length > 0).length
+    : Array.isArray(input.edits)
+    ? input.edits.length
+    : undefined;
+  const removed = typeof input.old_string === "string"
+    ? input.old_string.split(/\r?\n/).filter((line) => line.length > 0).length
+    : undefined;
+  const entry: NonNullable<StoredAgentTimelineItem["fileChange"]>["entries"][number] = { path, kind };
+  if (added && added > 0) entry.added = added;
+  if (removed && removed > 0) entry.removed = removed;
+  return {
+    entries: [entry],
+    summary: [kind, path].filter(Boolean).join(" "),
+    status: "running",
+  };
+}
+
+function claudeCommandExecution(input: Record<string, unknown> | undefined): StoredAgentTimelineItem["commandExecution"] | undefined {
+  if (!input) return undefined;
+  const command = typeof input.command === "string" ? input.command : undefined;
+  const cwd = typeof input.cwd === "string" ? input.cwd : undefined;
+  if (!command && !cwd) return undefined;
+  return { command, cwd, status: "running" };
+}
+
+function createClaudeToolItem(
+  conversationId: string,
+  toolUseId: string,
+  name: string | undefined,
+  input: Record<string, unknown> | undefined,
+  createdAt: number,
+): StoredAgentTimelineItem {
+  const kind = claudeToolKind(name);
+  const inputText = stringifyHistoryValue(input);
+  const fileChange = claudeFileEntry(name, input);
+  return {
+    id: `history-tool:${toolUseId}`,
+    conversationId,
+    type: "tool_call",
+    kind,
+    itemId: toolUseId,
+    toolCall: {
+      id: toolUseId,
+      name: claudeToolName(name),
+      input: inputText,
+      createdAt,
+      status: "running",
+    },
+    commandExecution: name === "Bash" ? claudeCommandExecution(input) : undefined,
+    fileChange,
+    text: fileChange ? `已编辑 ${fileChange.entries.length} 个文件` : undefined,
+    createdAt,
+    updatedAt: createdAt,
+    metadata: { source: "device-history", provider: "claude", toolName: name },
+  };
+}
+
+function completeClaudeToolItem(
+  itemsById: Map<string, StoredAgentTimelineItem>,
+  conversationId: string,
+  toolUseId: string,
+  output: string | undefined,
+  failed: boolean,
+  createdAt: number,
+): void {
+  const id = `history-tool:${toolUseId}`;
+  const existing = itemsById.get(id);
+  const status = failed ? "failed" : "completed";
+  itemsById.set(id, {
+    id,
+    conversationId,
+    type: "tool_call",
+    kind: existing?.kind ?? "tool_activity",
+    itemId: toolUseId,
+    toolCall: {
+      id: toolUseId,
+      name: existing?.toolCall?.name ?? "工具",
+      input: existing?.toolCall?.input,
+      output,
+      createdAt: existing?.toolCall?.createdAt ?? createdAt,
+      status,
+    },
+    commandExecution: existing?.commandExecution
+      ? { ...existing.commandExecution, output, status }
+      : undefined,
+    fileChange: existing?.fileChange
+      ? { ...existing.fileChange, summary: output ?? existing.fileChange.summary, status }
+      : undefined,
+    text: existing?.text,
+    createdAt: existing?.createdAt ?? createdAt,
+    updatedAt: createdAt,
+    metadata: existing?.metadata ?? { source: "device-history", provider: "claude" },
+  });
+}
+
 export function loadClaudeStoredTimeline(
   sessionId: string,
   conversationId: string,
@@ -308,7 +486,7 @@ export function loadClaudeStoredTimeline(
     return { items: [] };
   }
 
-  const items: StoredAgentTimelineItem[] = [];
+  const itemsById = new Map<string, StoredAgentTimelineItem>();
   let index = 0;
   for (const line of readHistorySample(filePath, statSize).split(/\r?\n/)) {
     const trimmed = line.trim();
@@ -326,20 +504,50 @@ export function loadClaudeStoredTimeline(
         : undefined;
       const role = rawRole === "assistant" ? "assistant" : rawRole === "user" ? "user" : undefined;
       if (!role) continue;
-      const text = extractHistoryText(message?.content ?? record.content ?? record.text);
-      if (!text) continue;
       const createdAt =
         parseTimestamp(record.timestamp ?? record.createdAt ?? record.created_at) ??
         statMtime + index;
-      items.push(historyMessage(conversationId, index, role, text, createdAt, sessionId));
-      index += 1;
+      const content = message?.content ?? record.content ?? record.text;
+      const text = extractVisibleClaudeText(content);
+      if (text) {
+        itemsById.set(
+          `history:${sessionId}:${index}`,
+          historyMessage(conversationId, index, role, text, createdAt, sessionId),
+        );
+        index += 1;
+      }
+      if (Array.isArray(content)) {
+        for (const part of content) {
+          const block = asRecord(part);
+          if (!block) continue;
+          if (role === "assistant" && block.type === "tool_use") {
+            const toolUseId = typeof block.id === "string" ? block.id : undefined;
+            if (!toolUseId) continue;
+            const name = typeof block.name === "string" ? block.name : undefined;
+            const input = asRecord(block.input);
+            const item = createClaudeToolItem(conversationId, toolUseId, name, input, createdAt);
+            itemsById.set(item.id, item);
+          } else if (role === "user" && block.type === "tool_result") {
+            const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : undefined;
+            if (!toolUseId) continue;
+            completeClaudeToolItem(
+              itemsById,
+              conversationId,
+              toolUseId,
+              extractHistoryText(block.content),
+              block.is_error === true,
+              createdAt,
+            );
+          }
+        }
+      }
     } catch {
       // Ignore malformed or partial JSONL lines in the history window.
     }
   }
 
   return {
-    items: items
+    items: [...itemsById.values()]
       .sort((a, b) => a.createdAt - b.createdAt)
       .slice(-MAX_HISTORY_ITEMS),
   };