ctx-switch 2.0.4 → 2.0.5

package/dist/index.mjs

@@ -14,7 +14,7 @@ import path from "node:path";
 // src/types.ts
 var SUPPORTED_COMMANDS = ["continue", "doctor", "sessions"];
 var SUPPORTED_PROVIDERS = ["openrouter"];
-var SUPPORTED_TARGETS = ["generic", "codex", "cursor", "chatgpt"];
+var SUPPORTED_TARGETS = ["generic", "claude", "codex", "cursor", "chatgpt"];
 var SUPPORTED_SOURCES = ["claude", "codex", "opencode"];
 
 // src/args.ts
@@ -142,7 +142,7 @@ function getHelpText({ name, version }) {
     "  -o, --output <file>     Write the final prompt to a file",
     "      --source <name>     Session source: claude, codex, opencode (interactive if omitted)",
     "      --session <id|path> Use a specific session file or session id",
-    "      --target <name>     Prompt target: generic, codex, cursor, chatgpt",
+    "      --target <name>     Prompt target: generic, claude, codex, cursor, chatgpt",
     "  -n, --limit <count>     Limit rows for the sessions command (default: 10)",
     "",
     "Refinement (optional)",
@@ -160,6 +160,7 @@ function getHelpText({ name, version }) {
     "Examples",
     `  ${name}                              # interactive source picker`,
     `  ${name} --source claude               # use Claude Code sessions`,
+    `  ${name} --source codex --target claude`,
     `  ${name} --source codex --target codex`,
     `  ${name} --source opencode`,
     `  ${name} --refine --model openrouter/free`,
@@ -600,6 +601,60 @@ import path5 from "node:path";
 var CODEX_DIR = path5.join(os3.homedir(), ".codex");
 var CODEX_SESSIONS_DIR = path5.join(CODEX_DIR, "sessions");
 var CODEX_INDEX_PATH = path5.join(CODEX_DIR, "session_index.jsonl");
+function parseJsonRecord(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+function parseFunctionArguments(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function parseCustomToolInput(toolName, raw) {
+  if (!raw) return {};
+  if (typeof raw !== "string") return raw;
+  const trimmed = raw.trim();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object") {
+        return parsed;
+      }
+    } catch {
+    }
+  }
+  if (toolName === "apply_patch") {
+    return { patch: raw };
+  }
+  return { input: raw };
+}
+function parseToolOutput(raw) {
+  if (!raw) return { text: "" };
+  let text = raw;
+  let exitCode;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.output === "string") {
+      text = parsed.output;
+    }
+    if (typeof parsed.metadata?.exit_code === "number") {
+      exitCode = parsed.metadata.exit_code;
+    }
+  } catch {
+  }
+  const isError = exitCode !== void 0 ? exitCode !== 0 : /Process exited with code [^0]/.test(text) || /error|Error|ERROR/.test(text.slice(0, 200));
+  return {
+    text: text.slice(0, 1500),
+    isError: isError || void 0
+  };
+}
 function listSessionsForProject2(cwd) {
   if (!fs4.existsSync(CODEX_SESSIONS_DIR)) {
     return [];
@@ -680,12 +735,8 @@ function parseSession2(sessionPath) {
     }
   }
   for (const line of lines) {
-    let record;
-    try {
-      record = JSON.parse(line);
-    } catch {
-      continue;
-    }
+    const record = parseJsonRecord(line);
+    if (!record) continue;
     if (record.type === "session_meta") {
       const payload2 = record.payload;
       if (payload2.cwd) meta.cwd = payload2.cwd;
@@ -693,6 +744,21 @@ function parseSession2(sessionPath) {
       if (payload2.id) meta.sessionId = payload2.id;
       continue;
     }
+    if (record.type === "event_msg" && record.payload.type === "exec_command_end" && record.payload.call_id) {
+      const tc = pendingCalls.get(record.payload.call_id);
+      if (tc) {
+        if (Array.isArray(record.payload.parsed_cmd)) {
+          tc.input.parsed_cmd = record.payload.parsed_cmd;
+        }
+        if (typeof record.payload.aggregated_output === "string" && !tc.result) {
+          tc.result = record.payload.aggregated_output.slice(0, 1500);
+        }
+        if (typeof record.payload.exit_code === "number") {
+          tc.isError = record.payload.exit_code !== 0;
+        }
+      }
+      continue;
+    }
     if (record.type !== "response_item") continue;
     const payload = record.payload;
     const payloadType = payload.type;
@@ -718,11 +784,7 @@ function parseSession2(sessionPath) {
       continue;
     }
     if (payloadType === "function_call" && payload.name) {
-      let input = {};
-      try {
-        input = JSON.parse(payload.arguments || "{}");
-      } catch {
-      }
+      const input = parseFunctionArguments(payload.arguments);
       const tc = {
         id: payload.call_id || null,
         tool: payload.name,
@@ -734,12 +796,26 @@ function parseSession2(sessionPath) {
       }
       continue;
     }
-    if (payloadType === "function_call_output" && payload.call_id) {
+    if (payloadType === "custom_tool_call" && payload.name) {
+      const tc = {
+        id: payload.call_id || null,
+        tool: payload.name,
+        input: parseCustomToolInput(payload.name, payload.input)
+      };
+      currentToolCalls.push(tc);
+      if (payload.call_id) {
+        pendingCalls.set(payload.call_id, tc);
+      }
+      continue;
+    }
+    if ((payloadType === "function_call_output" || payloadType === "custom_tool_call_output") && payload.call_id) {
       const tc = pendingCalls.get(payload.call_id);
       if (tc) {
-        const output = payload.output || "";
-        tc.result = output.slice(0, 1500);
-        tc.isError = /Process exited with code [^0]/.test(output) || /error|Error|ERROR/.test(output.slice(0, 200));
+        const parsed = parseToolOutput(payload.output);
+        tc.result = parsed.text;
+        if (parsed.isError !== void 0) {
+          tc.isError = parsed.isError;
+        }
       }
       continue;
     }
@@ -950,6 +1026,20 @@ function extractCommand(input) {
   const value = input.command || input.cmd;
   return typeof value === "string" ? value : null;
 }
+function resolveSessionFilePath(filePath, cwd) {
+  return path7.isAbsolute(filePath) ? filePath : path7.resolve(cwd, filePath);
+}
+function extractPatchFilePaths(input, cwd) {
+  const patch = input.patch;
+  if (typeof patch !== "string") return [];
+  const matches = [...patch.matchAll(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/gm)];
+  return matches.map((match) => resolveSessionFilePath(match[1].trim(), cwd));
+}
+function extractParsedCommands(input) {
+  const parsed = input.parsed_cmd;
+  if (!Array.isArray(parsed)) return [];
+  return parsed.filter((entry) => Boolean(entry) && typeof entry === "object");
+}
 function buildSessionContext({
   messages,
   meta,
@@ -967,10 +1057,19 @@ function buildSessionContext({
         const toolName = String(toolCall.tool || "").toLowerCase();
         const filePath = extractFilePath(toolCall.input);
         const command = extractCommand(toolCall.input);
+        const patchPaths = extractPatchFilePaths(toolCall.input, cwd);
+        const parsedCommands = extractParsedCommands(toolCall.input);
         if (filePath && /(edit|write|create|multi_edit)/.test(toolName)) {
-          filesModified.add(filePath);
+          filesModified.add(resolveSessionFilePath(filePath, cwd));
         } else if (filePath && /(read|grep|glob|search)/.test(toolName)) {
-          filesRead.add(filePath);
+          filesRead.add(resolveSessionFilePath(filePath, cwd));
+        }
+        for (const patchPath of patchPaths) {
+          filesModified.add(patchPath);
+        }
+        for (const parsedCommand of parsedCommands) {
+          if (parsedCommand.type !== "read" || typeof parsedCommand.path !== "string") continue;
+          filesRead.add(resolveSessionFilePath(parsedCommand.path, cwd));
         }
         if (command && /(bash|command|run|exec_command)/.test(toolName)) {
           commands.push(command);
@@ -985,8 +1084,10 @@ function buildSessionContext({
       const toolSummary = message.toolCalls.map((toolCall) => {
         const filePath = extractFilePath(toolCall.input);
         const command = extractCommand(toolCall.input);
+        const patchPaths = extractPatchFilePaths(toolCall.input, cwd);
         let summary = "";
-        if (filePath) summary = `${toolCall.tool} ${filePath}`;
+        if (filePath) summary = `${toolCall.tool} ${resolveSessionFilePath(filePath, cwd)}`;
+        else if (patchPaths.length > 0) summary = `${toolCall.tool} ${patchPaths.join(", ")}`;
         else if (command) summary = `${toolCall.tool}: ${command}`;
         else summary = toolCall.tool;
         if (toolCall.isError && toolCall.result) {
@@ -1156,8 +1257,18 @@ function compactText(text, maxChars = 800) {
 function unique(list) {
   return [...new Set(list.filter(Boolean))];
 }
+function extractFilePath2(input) {
+  const value = input.file_path || input.path || input.target_file || input.filePath;
+  return typeof value === "string" ? value : null;
+}
+function extractCommand2(input) {
+  const value = input.command || input.cmd;
+  return typeof value === "string" ? value : null;
+}
 function buildTargetGuidance(target) {
   switch (target) {
+    case "claude":
+      return "The next agent is Claude Code. It should read the active files first, trust the current workspace and git diff over stale transcript details, and continue the implementation or debugging directly.";
     case "codex":
       return "The next agent is Codex. It should inspect the current files first, avoid redoing completed work, and finish any remaining implementation or verification.";
     case "cursor":
@@ -1165,19 +1276,20 @@ function buildTargetGuidance(target) {
     case "chatgpt":
       return "The next agent is ChatGPT. It should reason from the current workspace state, explain what remains, and provide explicit next actions.";
     default:
-      return "The next agent should continue the interrupted work from the current workspace state without redoing completed steps.";
+      return "The next agent should read the active files first, trust the current workspace and git diff over stale transcript details, continue the interrupted work directly, and avoid redoing completed steps.";
   }
 }
 function isNoiseMessage(text) {
   const trimmed = text.trim().toLowerCase();
+  const normalized = trimmed.replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
   if (trimmed.length < 5) return true;
   const noise = [
     "yes",
+    "yes please",
     "no",
     "ok",
     "okay",
     "try",
-    "try?",
     "sure",
     "do it",
     "go ahead",
@@ -1194,11 +1306,16 @@ function isNoiseMessage(text) {
     "try turn off thinking",
     "try without timeout"
   ];
-  if (noise.includes(trimmed)) return true;
-  if (/^(try|yes|ok|sure|test|run)\s/i.test(trimmed) && trimmed.length < 40) return true;
+  if (noise.includes(normalized)) return true;
+  if (/^(try|yes|ok|sure|test|run)\s/i.test(normalized) && normalized.length < 40) return true;
   if (trimmed.startsWith("[request interrupted")) return true;
   return false;
 }
+function isReferentialMessage(text) {
+  const normalized = text.trim().toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").replace(/\s+/g, " ").trim();
+  if (!normalized || normalized.length > 220) return false;
+  return /^(ok|okay|alright|now|so)\b/.test(normalized) || /\b(it|that|again|better|same|continue|still|also|another|more)\b/.test(normalized);
+}
 function filterUserMessages(messages) {
   const all = messages.filter((m) => m.role === "user" && m.content).map((m) => m.content.trim());
   if (all.length <= 2) return all;
@@ -1228,30 +1345,140 @@ function extractKeyDecisions(messages) {
   for (const msg of messages) {
     if (msg.role !== "assistant" || !msg.content) continue;
     const lower = msg.content.toLowerCase();
-    if (lower.includes("instead") || lower.includes("let me try") || lower.includes("switching to") || lower.includes("the issue is") || lower.includes("the problem is") || lower.includes("root cause")) {
+    if (/\b(handoff|prompt)\b/.test(lower) && /\b(good|bad|better|worse|quality)\b/.test(lower)) {
+      continue;
+    }
+    if (/\b(root cause|the issue is|the problem is|caused by|failed because|failing because|need to)\b/.test(lower) || /\b(exposed|revealed|showed)\b.*\b(gap|issue|problem|bug)\b/.test(lower) || /\bmissing\b/.test(lower)) {
       decisions.push(compactText(msg.content, 300));
     }
   }
   return decisions.slice(-5);
 }
+function findFocusedWindow(messages) {
+  if (messages.length === 0) {
+    return { messages, sessionAppearsComplete: false };
+  }
+  const substantiveUserIndexes = messages.map((message, index) => ({ message, index })).filter(({ message }) => message.role === "user" && message.content && !isNoiseMessage(message.content)).map(({ index }) => index);
+  if (substantiveUserIndexes.length === 0) {
+    return { messages, sessionAppearsComplete: false };
+  }
+  const lastToolIndex = messages.reduce(
+    (last, message, index) => message.role === "assistant" && message.toolCalls.length > 0 ? index : last,
+    -1
+  );
+  const postToolUsers = substantiveUserIndexes.filter((index) => index > lastToolIndex);
+  let startIndex = 0;
+  if (postToolUsers.length > 0) {
+    startIndex = postToolUsers[0];
+  } else if (lastToolIndex >= 0) {
+    startIndex = substantiveUserIndexes.filter((index) => index <= lastToolIndex).at(-1) ?? 0;
+  } else {
+    startIndex = substantiveUserIndexes.at(-1) ?? 0;
+  }
+  const startMessage = messages[startIndex];
+  if (startMessage?.role === "user" && isReferentialMessage(startMessage.content)) {
+    const previousSubstantive = substantiveUserIndexes.filter((index) => index < startIndex).at(-1);
+    if (typeof previousSubstantive === "number") {
+      startIndex = previousSubstantive;
+    }
+  }
+  const focused = messages.slice(startIndex);
+  const hasToolActivity = focused.some((message) => message.role === "assistant" && message.toolCalls.length > 0);
+  const lastMessage = focused.at(-1);
+  const sessionAppearsComplete = Boolean(lastMessage) && lastMessage.role === "assistant" && lastMessage.toolCalls.length === 0 && !hasToolActivity;
+  return { messages: focused, sessionAppearsComplete };
+}
+function extractWorkSummary(messages) {
+  const filesModified = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const message of messages) {
+    if (message.role !== "assistant" || message.toolCalls.length === 0) continue;
+    for (const toolCall of message.toolCalls) {
+      const toolName = String(toolCall.tool || "").toLowerCase();
+      const filePath = extractFilePath2(toolCall.input);
+      const command = extractCommand2(toolCall.input);
+      if (filePath && /(edit|write|create|multi_edit)/.test(toolName)) {
+        filesModified.add(filePath);
+      }
+      if (command && /(bash|command|run|exec_command)/.test(toolName)) {
+        commands.push(command);
+      }
+    }
+  }
+  return {
+    filesModified: [...filesModified],
+    commands
+  };
+}
+function extractLastAssistantAnswer(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message.role === "assistant" && message.content.trim()) {
+      return compactText(message.content, 500);
+    }
+  }
+  return null;
+}
+function summarizeCommand(command) {
+  return compactText(command.replace(/\s+/g, " ").trim(), 140);
+}
+function extractRecentCommands(commands) {
+  return unique(commands.map(summarizeCommand)).slice(-6);
+}
+function extractStatusPaths(status) {
+  if (!status) return [];
+  return status.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+    const renamed = line.includes(" -> ") ? line.split(" -> ").at(-1)?.trim() || "" : "";
+    if (renamed) {
+      return renamed.replace(/^(?:\?\?|[A-Z?!]{1,2})\s+/, "");
+    }
+    const match = line.match(/^(?:\?\?|[A-Z?!]{1,2})\s+(.*)$/);
+    return match?.[1]?.trim() || line;
+  }).filter(Boolean);
+}
+function extractFocusFiles(ctx, work) {
+  return unique([
+    ...work.filesModified,
+    ...extractStatusPaths(ctx.gitContext.status),
+    ...ctx.gitContext.untracked.map((file) => file.path)
+  ]).slice(0, 6);
+}
 function buildRawPrompt(ctx, options = {}) {
-  const userMessages = filterUserMessages(ctx.messages);
-  const errors = extractUnresolvedErrors(ctx.messages);
-  const decisions = extractKeyDecisions(ctx.messages);
+  const focused = findFocusedWindow(ctx.messages);
+  const userMessages = filterUserMessages(focused.messages);
+  const errors = extractUnresolvedErrors(focused.messages);
+  const decisions = extractKeyDecisions(focused.messages);
+  const work = extractWorkSummary(focused.messages);
+  const focusFiles = extractFocusFiles(ctx, work);
+  const recentCommands = extractRecentCommands(work.commands);
+  const lastAssistantAnswer = extractLastAssistantAnswer(focused.messages);
   let prompt = "";
   prompt += "# Task\n\n";
   prompt += `Project: \`${ctx.sessionCwd}\`
 `;
   if (ctx.branch) prompt += `Branch: \`${ctx.branch}\`
 `;
-  prompt += "\nThis is a continuation of an interrupted AI coding session. ";
-  prompt += "The previous agent was working on the task below. Pick up where it left off.\n\n";
-  prompt += "## What The User Asked (chronological)\n\n";
+  if (focused.sessionAppearsComplete) {
+    prompt += "\nThe latest exchange in this session appears complete. ";
+    prompt += "Use the focused context below only if the user wants to continue from that point.\n\n";
+  } else {
+    prompt += "\nThis is a continuation of an interrupted AI coding session. ";
+    prompt += "The previous agent was working on the task below. Pick up where it left off.\n\n";
+  }
+  prompt += `## What The User Asked (${focused.sessionAppearsComplete ? "recent focus" : "chronological"})
+
+`;
   for (const msg of userMessages) {
     prompt += `- ${compactText(msg, 500)}
 `;
   }
   prompt += "\n";
+  if (focused.sessionAppearsComplete && lastAssistantAnswer) {
+    prompt += "## Last Answer Already Given\n\n";
+    prompt += `- ${lastAssistantAnswer}
+
+`;
+  }
   if (errors.length > 0) {
     prompt += "## DO NOT REPEAT \u2014 Unresolved Errors\n\n";
     prompt += "These errors occurred and were NOT fixed. Avoid the same approaches.\n\n";
@@ -1269,27 +1496,45 @@ function buildRawPrompt(ctx, options = {}) {
     }
     prompt += "\n";
   }
-  prompt += "## Work Already Completed\n\n";
-  if (unique(ctx.filesModified).length > 0) {
+  if (work.filesModified.length > 0) {
+    prompt += "## Work Already Completed\n\n";
+  }
+  if (work.filesModified.length > 0) {
     prompt += "**Files modified:**\n";
-    for (const filePath of unique(ctx.filesModified)) {
+    for (const filePath of unique(work.filesModified)) {
       prompt += `- \`${filePath}\`
 `;
     }
     prompt += "\n";
   }
-  if (ctx.gitContext.recentCommits) {
+  if (!focused.sessionAppearsComplete && work.filesModified.length > 0 && ctx.gitContext.recentCommits) {
     prompt += "**Recent commits:**\n```\n";
     prompt += `${ctx.gitContext.recentCommits}
 `;
     prompt += "```\n\n";
   }
-  if (ctx.gitContext.committedDiff) {
+  if (!focused.sessionAppearsComplete && work.filesModified.length > 0 && ctx.gitContext.committedDiff) {
     prompt += "**Files changed in recent commits:**\n```\n";
     prompt += `${ctx.gitContext.committedDiff}
 `;
     prompt += "```\n\n";
   }
+  if (recentCommands.length > 0) {
+    prompt += "## Recent Commands / Checks\n\n";
+    for (const command of recentCommands) {
+      prompt += `- \`${command}\`
+`;
+    }
+    prompt += "\n";
+  }
+  if (focusFiles.length > 0) {
+    prompt += "## Read These Files First\n\n";
+    for (const filePath of focusFiles) {
+      prompt += `- \`${filePath}\`
+`;
+    }
+    prompt += "\n";
+  }
   const git = ctx.gitContext;
   if (git.isGitRepo && git.hasChanges) {
     prompt += "## Uncommitted Changes\n\n";
@@ -1317,19 +1562,28 @@ function buildRawPrompt(ctx, options = {}) {
     }
   }
   prompt += "## Your Instructions\n\n";
-  prompt += `${buildTargetGuidance(options.target)}
+  if (focused.sessionAppearsComplete) {
+    prompt += "The latest thread appears finished. Do not resume older tasks unless the user explicitly asks for them.\n\n";
+    prompt += "1. **Start from the recent focus above** \u2014 ignore stale history unless the user points back to it.\n";
+    prompt += "2. **Use the last answer as prior context** \u2014 avoid restating or redoing already completed work.\n";
+    prompt += `3. **Inspect the workspace only as needed** \u2014 respond to follow-up questions or new work from the current repo state${focusFiles.length > 0 ? `, starting with ${focusFiles.map((filePath) => `\`${filePath}\``).join(", ")}` : ""}.
+`;
+  } else {
+    prompt += `${buildTargetGuidance(options.target)}
 
 `;
-  prompt += "1. **Read modified files first** \u2014 verify their current state before changing anything.\n";
-  if (errors.length > 0) {
-    prompt += "2. **Check the errors above** \u2014 do NOT repeat failed approaches. Try a different strategy.\n";
-  }
-  prompt += `${errors.length > 0 ? "3" : "2"}. **Identify what's done vs what remains** \u2014 the commits and modified files above show completed work.
+    prompt += `1. **Read the active files first** \u2014 verify their current state before changing anything${focusFiles.length > 0 ? `: ${focusFiles.map((filePath) => `\`${filePath}\``).join(", ")}` : ""}.
 `;
-  prompt += `${errors.length > 0 ? "4" : "3"}. **Do the remaining work** \u2014 pick up exactly where the previous agent stopped.
+    if (errors.length > 0) {
+      prompt += "2. **Check the errors above** \u2014 do NOT repeat failed approaches. Try a different strategy.\n";
+    }
+    prompt += `${errors.length > 0 ? "3" : "2"}. **Identify what's done vs what remains** \u2014 use the recent commands, active files, and git state above as the source of truth for the current thread.
+`;
+    prompt += `${errors.length > 0 ? "4" : "3"}. **Do the remaining work** \u2014 pick up exactly where the previous agent stopped.
 `;
-  prompt += `${errors.length > 0 ? "5" : "4"}. **Verify** \u2014 run tests/builds to confirm everything works.
+    prompt += `${errors.length > 0 ? "5" : "4"}. **Verify** \u2014 rerun or extend the relevant commands/checks above to confirm everything works.
 `;
+  }
   return prompt;
 }
 function buildRefinementDump(ctx, options = {}) {
@@ -1828,7 +2082,7 @@ async function promptForSource() {
 }
 async function main(argv = process.argv.slice(2)) {
   const options = parseArgs(argv);
-  const pkgInfo = { name: "ctx-switch", version: "2.0.4" };
+  const pkgInfo = { name: "ctx-switch", version: "2.0.5" };
   const ui = createTheme(process.stderr);
   if (options.help) {
     process.stdout.write(`${getHelpText(pkgInfo)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ctx-switch",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Switch coding agents without losing context. Generate handoff prompts across Claude Code, Codex, and OpenCode.",
   "type": "module",
   "main": "./dist/index.mjs",