@love-moon/conductor-cli 0.2.15 → 0.2.17

package/src/fire/history.js

@@ -1,716 +0,0 @@
-import fs from "node:fs";
-import { promises as fsp } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import readline from "node:readline";
-import enquirer from "enquirer";
-
-const { Select } = enquirer;
-
-const SUPPORTED_FROM_PROVIDERS = ["codex", "claude"];
-const DEFAULT_HISTORY_LIMIT = 50;
-const DEFAULT_SESSION_LIMIT = 20;
-
-export function parseFromSpec(rawFrom, rawProvider, defaultProvider) {
-  if (!rawFrom) {
-    return null;
-  }
-
-  const providerOverride = rawProvider ? String(rawProvider).trim().toLowerCase() : "";
-  if (providerOverride && !SUPPORTED_FROM_PROVIDERS.includes(providerOverride)) {
-    throw new Error(`Unsupported --from-provider: ${rawProvider}`);
-  }
-
-  if (rawFrom === true) {
-    const provider = providerOverride || defaultProvider;
-    if (!provider) {
-      throw new Error(
-        "Missing provider for --from. Use --from <provider>:<sessionId> or --from-provider <provider>."
-      );
-    }
-    return { provider, sessionId: "" };
-  }
-
-  const text = typeof rawFrom === "string" ? rawFrom.trim() : "";
-  if (!text) {
-    const provider = providerOverride || defaultProvider;
-    if (!provider) {
-      return null;
-    }
-    return { provider, sessionId: "" };
-  }
-
-  let provider = providerOverride || "";
-  let sessionId = text;
-
-  const colonIndex = text.indexOf(":");
-  if (colonIndex > 0) {
-    const maybeProvider = text.slice(0, colonIndex).trim().toLowerCase();
-    const maybeSession = text.slice(colonIndex + 1).trim();
-    if (SUPPORTED_FROM_PROVIDERS.includes(maybeProvider)) {
-      provider = maybeProvider;
-      sessionId = maybeSession;
-    }
-  }
-
-  if (!provider) {
-    provider = defaultProvider || "";
-  }
-
-  if (!provider) {
-    throw new Error(
-      "Missing provider for --from. Use --from <provider>:<sessionId> or --from-provider <provider>."
-    );
-  }
-
-  if (!sessionId) {
-    return { provider, sessionId: "" };
-  }
-
-  return { provider, sessionId };
-}
-
-export async function loadHistoryFromSpec(spec, options = {}) {
-  if (!spec) {
-    return { history: [], source: null, provider: null, sessionId: null };
-  }
-  const provider = spec.provider;
-  if (!SUPPORTED_FROM_PROVIDERS.includes(provider)) {
-    throw new Error(`Unsupported --from provider: ${provider}`);
-  }
-  if (provider === "codex") {
-    return loadCodexHistory(spec.sessionId, options);
-  }
-  return loadClaudeHistory(spec.sessionId, options);
-}
-
-export async function listHistorySessions(provider, options = {}) {
-  if (!SUPPORTED_FROM_PROVIDERS.includes(provider)) {
-    throw new Error(`Unsupported --from provider: ${provider}`);
-  }
-  if (provider === "codex") {
-    return listCodexSessions(options);
-  }
-  return listClaudeSessions(options);
-}
-
-export async function selectHistorySession(provider, options = {}) {
-  const sessions = await listHistorySessions(provider, options);
-  if (!sessions.length) {
-    return null;
-  }
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    throw new Error("Interactive --from requires a TTY.");
-  }
-
-  const choices = sessions.map((session) => ({
-    name: session.sessionId,
-    message: formatSessionLine(session),
-    value: session
-  }));
-  choices.push({
-    name: "__cancel__",
-    message: "Cancel",
-    value: null
-  });
-
-  const prompt = new Select({
-    name: "session",
-    message: `Select a ${provider} session to resume`,
-    choices,
-    initial: 0
-  });
-
-  const selected = await prompt.run();
-  return selected || null;
-}
-
-export async function findSessionPath(provider, sessionId, options = {}) {
-  const normalizedProvider = String(provider || "").trim().toLowerCase();
-  if (normalizedProvider === "codex") {
-    return findCodexSessionPath(sessionId, options);
-  }
-  if (normalizedProvider === "claude") {
-    return findClaudeSessionPath(sessionId, options);
-  }
-  if (normalizedProvider === "copilot") {
-    return findCopilotSessionPath(sessionId, options);
-  }
-  throw new Error(`Unsupported provider: ${provider}`);
-}
-
-export async function findCodexSessionPath(sessionId, options = {}) {
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  if (!normalizedSessionId) {
-    return null;
-  }
-  const homeDir = resolveHomeDir(options);
-  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
-  return findCodexSessionFile(sessionsDir, normalizedSessionId);
-}
-
-export async function findClaudeSessionPath(sessionId, options = {}) {
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  if (!normalizedSessionId) {
-    return null;
-  }
-
-  const homeDir = resolveHomeDir(options);
-  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
-  const sessionEntries = await findClaudeSessionEntries(projectsDir, normalizedSessionId);
-  if (sessionEntries.length > 0) {
-    return sessionEntries[0]?.source || null;
-  }
-
-  const tasksDir = options.claudeTasksDir || path.join(homeDir, ".claude", "tasks");
-  const directTaskDir = path.join(tasksDir, normalizedSessionId);
-  if (await pathExists(directTaskDir, "directory")) {
-    return directTaskDir;
-  }
-
-  return null;
-}
-
-export async function findCopilotSessionPath(sessionId, options = {}) {
-  const normalizedSessionId = normalizeSessionId(sessionId);
-  if (!normalizedSessionId) {
-    return null;
-  }
-
-  const homeDir = resolveHomeDir(options);
-  const sessionStateDir = options.copilotSessionStateDir || path.join(homeDir, ".copilot", "session-state");
-  const directJsonlPath = path.join(sessionStateDir, `${normalizedSessionId}.jsonl`);
-  if (await pathExists(directJsonlPath, "file")) {
-    return directJsonlPath;
-  }
-
-  const directSessionDir = path.join(sessionStateDir, normalizedSessionId);
-  if (await pathExists(directSessionDir, "directory")) {
-    return directSessionDir;
-  }
-
-  return findPathByName(sessionStateDir, normalizedSessionId);
-}
-
-function resolveHomeDir(options) {
-  if (options?.homeDir) {
-    return options.homeDir;
-  }
-  return os.homedir();
-}
-
-function normalizeSessionId(sessionId) {
-  return typeof sessionId === "string" ? sessionId.trim() : "";
-}
-
-function trimHistory(history, limit) {
-  const max = Number.isFinite(limit) ? Math.max(1, limit) : DEFAULT_HISTORY_LIMIT;
-  if (history.length <= max) {
-    return history;
-  }
-  return history.slice(history.length - max);
-}
-
-async function loadCodexHistory(sessionId, options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
-  const sessionFile = await findCodexSessionFile(sessionsDir, sessionId);
-
-  if (!sessionFile) {
-    return {
-      provider: "codex",
-      sessionId,
-      history: [],
-      source: null,
-      warning: `Codex session file not found for ${sessionId}`
-    };
-  }
-
-  const messages = [];
-  const rl = readline.createInterface({
-    input: fs.createReadStream(sessionFile),
-    crlfDelay: Infinity
-  });
-
-  for await (const line of rl) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(trimmed);
-    } catch {
-      continue;
-    }
-
-    if (entry.type === "event_msg" && entry.payload?.type === "user_message") {
-      const content = String(entry.payload.message || "").trim();
-      if (content) {
-        messages.push({
-          role: "user",
-          content,
-          timestamp: entry.timestamp || Date.now()
-        });
-      }
-      continue;
-    }
-
-    if (entry.type === "response_item" && entry.payload?.type === "message") {
-      const role = entry.payload.role || "assistant";
-      const textContent = extractCodexText(entry.payload.content);
-      if (!textContent || textContent.includes("<environment_context>")) {
-        continue;
-      }
-      if (textContent.trim()) {
-        messages.push({
-          role: role === "user" ? "user" : "assistant",
-          content: textContent.trim(),
-          timestamp: entry.timestamp || Date.now()
-        });
-      }
-    }
-  }
-
-  const history = trimHistory(
-    messages
-      .sort((a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0))
-      .map(({ role, content }) => ({ role, content })),
-    options.maxMessages
-  );
-
-  return {
-    provider: "codex",
-    sessionId,
-    history,
-    source: sessionFile
-  };
-}
-
-async function listCodexSessions(options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const sessionsDir = options.codexSessionsDir || path.join(homeDir, ".codex", "sessions");
-  const jsonlFiles = await findJsonlFiles(sessionsDir);
-  const sessions = [];
-
-  for (const filePath of jsonlFiles) {
-    const session = await parseCodexSessionFile(filePath);
-    if (session) {
-      sessions.push(session);
-    }
-  }
-
-  sessions.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
-  return sessions.slice(0, options.sessionLimit ?? DEFAULT_SESSION_LIMIT);
-}
-
-async function loadClaudeHistory(sessionId, options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
-  const sessionEntries = await findClaudeSessionEntries(projectsDir, sessionId);
-
-  if (!sessionEntries.length) {
-    return {
-      provider: "claude",
-      sessionId,
-      history: [],
-      source: null,
-      warning: `Claude session not found for ${sessionId}`
-    };
-  }
-
-  const history = [];
-  const sorted = sessionEntries.sort(
-    (a, b) => new Date(a.timestamp || 0) - new Date(b.timestamp || 0)
-  );
-
-  for (const entry of sorted) {
-    const message = entry.message;
-    if (!message || !message.role || !message.content) {
-      continue;
-    }
-    const role = String(message.role).toLowerCase();
-    if (role !== "user" && role !== "assistant") {
-      continue;
-    }
-    const content = extractClaudeText(message.content);
-    if (!content) {
-      continue;
-    }
-    if (shouldSkipClaudeMessage(content)) {
-      continue;
-    }
-    history.push({ role, content });
-  }
-
-  return {
-    provider: "claude",
-    sessionId,
-    history: trimHistory(history, options.maxMessages),
-    source: sessionEntries[0]?.source || null
-  };
-}
-
-async function listClaudeSessions(options = {}) {
-  const homeDir = resolveHomeDir(options);
-  const projectsDir = options.claudeProjectsDir || path.join(homeDir, ".claude", "projects");
-  const sessions = new Map();
-
-  let projectDirs = [];
-  try {
-    projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
-  } catch {
-    return [];
-  }
-
-  for (const projectDir of projectDirs) {
-    if (!projectDir.isDirectory()) {
-      continue;
-    }
-    const projectPath = path.join(projectsDir, projectDir.name);
-    let files = [];
-    try {
-      files = await fsp.readdir(projectPath, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const file of files) {
-      if (!file.isFile()) {
-        continue;
-      }
-      if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
-        continue;
-      }
-      const filePath = path.join(projectPath, file.name);
-      const rl = readline.createInterface({
-        input: fs.createReadStream(filePath),
-        crlfDelay: Infinity
-      });
-
-      for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          continue;
-        }
-        let entry;
-        try {
-          entry = JSON.parse(trimmed);
-        } catch {
-          continue;
-        }
-        if (!entry.sessionId) {
-          continue;
-        }
-        const sessionId = entry.sessionId;
-        const record = sessions.get(sessionId) || {
-          provider: "claude",
-          sessionId,
-          projectName: projectDir.name,
-          summary: "Claude Session",
-          lastActivity: null,
-          messageCount: 0,
-          source: filePath
-        };
-
-        if (entry.timestamp) {
-          record.lastActivity = entry.timestamp;
-        }
-
-        if (entry.message?.role && entry.message?.content) {
-          const content = extractClaudeText(entry.message.content);
-          if (content && !shouldSkipClaudeMessage(content)) {
-            record.messageCount += 1;
-            if (entry.message.role === "user") {
-              record.summary = truncateSummary(content);
-            } else if (record.summary === "Claude Session") {
-              record.summary = truncateSummary(content);
-            }
-          }
-        }
-
-        sessions.set(sessionId, record);
-      }
-    }
-  }
-
-  const list = Array.from(sessions.values());
-  list.sort((a, b) => new Date(b.lastActivity || 0) - new Date(a.lastActivity || 0));
-  return list.slice(0, options.sessionLimit ?? DEFAULT_SESSION_LIMIT);
-}
-
-async function findCodexSessionFile(rootDir, sessionId) {
-  const queue = [rootDir];
-  while (queue.length) {
-    const current = queue.pop();
-    let entries = [];
-    try {
-      entries = await fsp.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-      } else if (
-        entry.isFile() &&
-        entry.name.includes(sessionId) &&
-        entry.name.endsWith(".jsonl")
-      ) {
-        return fullPath;
-      }
-    }
-  }
-  return null;
-}
-
-async function findClaudeSessionEntries(projectsDir, sessionId) {
-  const entries = [];
-  let projectDirs = [];
-  try {
-    projectDirs = await fsp.readdir(projectsDir, { withFileTypes: true });
-  } catch {
-    return entries;
-  }
-
-  for (const projectDir of projectDirs) {
-    if (!projectDir.isDirectory()) {
-      continue;
-    }
-    const projectPath = path.join(projectsDir, projectDir.name);
-    let files = [];
-    try {
-      files = await fsp.readdir(projectPath, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-
-    for (const file of files) {
-      if (!file.isFile()) {
-        continue;
-      }
-      if (!file.name.endsWith(".jsonl") || file.name.startsWith("agent-")) {
-        continue;
-      }
-
-      const filePath = path.join(projectPath, file.name);
-      const rl = readline.createInterface({
-        input: fs.createReadStream(filePath),
-        crlfDelay: Infinity
-      });
-
-      for await (const line of rl) {
-        const trimmed = line.trim();
-        if (!trimmed) {
-          continue;
-        }
-        let entry;
-        try {
-          entry = JSON.parse(trimmed);
-        } catch {
-          continue;
-        }
-        if (entry.sessionId === sessionId) {
-          entries.push({ ...entry, source: filePath });
-        }
-      }
-    }
-  }
-
-  return entries;
-}
-
-async function findJsonlFiles(rootDir) {
-  const files = [];
-  const queue = [rootDir];
-  while (queue.length) {
-    const current = queue.pop();
-    let entries = [];
-    try {
-      entries = await fsp.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name);
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-
-async function findPathByName(rootDir, sessionId) {
-  const queue = [rootDir];
-  while (queue.length) {
-    const current = queue.pop();
-    let entries = [];
-    try {
-      entries = await fsp.readdir(current, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(current, entry.name);
-      if (entry.name.includes(sessionId)) {
-        return fullPath;
-      }
-      if (entry.isDirectory()) {
-        queue.push(fullPath);
-      }
-    }
-  }
-  return null;
-}
-
-async function pathExists(targetPath, expectedType) {
-  try {
-    const stats = await fsp.stat(targetPath);
-    if (expectedType === "file") {
-      return stats.isFile();
-    }
-    if (expectedType === "directory") {
-      return stats.isDirectory();
-    }
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function parseCodexSessionFile(filePath) {
-  const fileStream = fs.createReadStream(filePath);
-  const rl = readline.createInterface({
-    input: fileStream,
-    crlfDelay: Infinity
-  });
-
-  let sessionMeta = null;
-  let lastTimestamp = null;
-  let lastUserMessage = null;
-  let messageCount = 0;
-
-  for await (const line of rl) {
-    if (!line.trim()) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(line);
-    } catch {
-      continue;
-    }
-
-    if (entry.timestamp) {
-      lastTimestamp = entry.timestamp;
-    }
-
-    if (entry.type === "session_meta" && entry.payload) {
-      sessionMeta = {
-        id: entry.payload.id,
-        cwd: entry.payload.cwd,
-        model: entry.payload.model || entry.payload.model_provider,
-        timestamp: entry.timestamp
-      };
-    }
-
-    if (entry.type === "event_msg" && entry.payload?.type === "user_message") {
-      messageCount += 1;
-      if (entry.payload.message) {
-        lastUserMessage = entry.payload.message;
-      }
-    }
-
-    if (entry.type === "response_item" && entry.payload?.type === "message") {
-      messageCount += 1;
-    }
-  }
-
-  if (!sessionMeta?.id) {
-    return null;
-  }
-
-  return {
-    provider: "codex",
-    sessionId: sessionMeta.id,
-    summary: lastUserMessage ? truncateSummary(lastUserMessage) : "Codex Session",
-    lastActivity: lastTimestamp || sessionMeta.timestamp,
-    messageCount,
-    cwd: sessionMeta.cwd,
-    model: sessionMeta.model,
-    source: filePath
-  };
-}
-
-function extractCodexText(content) {
-  if (!Array.isArray(content)) {
-    return typeof content === "string" ? content : "";
-  }
-  return content
-    .map((item) => {
-      if (item?.type === "input_text" || item?.type === "output_text" || item?.type === "text") {
-        return item.text;
-      }
-      return "";
-    })
-    .filter(Boolean)
-    .join("\n");
-}
-
-function extractClaudeText(content) {
-  if (Array.isArray(content)) {
-    const parts = content
-      .map((part) => {
-        if (part?.type === "text") {
-          return part.text;
-        }
-        return "";
-      })
-      .filter(Boolean);
-    return parts.join("\n").trim();
-  }
-  if (typeof content === "string") {
-    return content.trim();
-  }
-  return String(content || "").trim();
-}
-
-function shouldSkipClaudeMessage(content) {
-  if (!content) {
-    return true;
-  }
-  const trimmed = content.trim();
-  return (
-    trimmed.startsWith("<command-name>") ||
-    trimmed.startsWith("<command-message>") ||
-    trimmed.startsWith("<command-args>") ||
-    trimmed.startsWith("<local-command-stdout>") ||
-    trimmed.startsWith("<system-reminder>") ||
-    trimmed.startsWith("Caveat:") ||
-    trimmed.startsWith("This session is being continued from a previous") ||
-    trimmed.startsWith("[Request interrupted")
-  );
-}
-
-function truncateSummary(value) {
-  const text = String(value || "").trim();
-  if (!text) {
-    return "";
-  }
-  return text.length > 60 ? `${text.slice(0, 60)}...` : text;
-}
-
-function formatSessionLine(session) {
-  const summary = session.summary || "Untitled session";
-  const when = session.lastActivity
-    ? new Date(session.lastActivity).toLocaleString("sv-SE", { timeZone: "Asia/Shanghai" })
-    : "unknown time";
-  const project = session.projectName ? ` · ${session.projectName}` : "";
-  return `${summary} (${session.sessionId}) · ${when}${project}`;
-}
-
-export { SUPPORTED_FROM_PROVIDERS };