@love-moon/conductor-cli 0.1.0

package/src/fire/history.js

@@ -0,0 +1,605 @@
+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;
+}
+
+function resolveHomeDir(options) {
+  if (options?.homeDir) {
+    return options.homeDir;
+  }
+  return os.homedir();
+}
+
+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 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() : "unknown time";
+  const project = session.projectName ? ` · ${session.projectName}` : "";
+  return `${summary} (${session.sessionId}) · ${when}${project}`;
+}
+
+export { SUPPORTED_FROM_PROVIDERS };