@jdi-code/claude-code 1.0.3

package/dist/chunk-8440dz44.js

@@ -0,0 +1,266 @@
+// @bun
+import {
+  expandPastedTextRefs,
+  formatPastedTextRef,
+  generateTempFilePath,
+  getPastedTextRefNumLines,
+  init_history,
+  init_ide,
+  init_tempfile,
+  toIDEDisplayName
+} from "./chunk-5frcqxsv.js";
+import {
+  init_instances,
+  instances_default
+} from "./chunk-z72st5c8.js";
+import {
+  init_which,
+  whichSync
+} from "./chunk-hjhc4cpt.js";
+import {
+  execSync_DEPRECATED,
+  init_execSyncWrapper
+} from "./chunk-vyc0rjyx.js";
+import {
+  getFsImplementation,
+  init_debug,
+  init_fsOperations,
+  init_slowOperations,
+  logForDebugging,
+  writeFileSync_DEPRECATED
+} from "./chunk-nxsh6de2.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-hqmz36b3.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/editor.ts
+import {
+  spawn,
+  spawnSync
+} from "child_process";
+import { basename } from "path";
+function isCommandAvailable(command) {
+  return !!whichSync(command);
+}
+function classifyGuiEditor(editor) {
+  const base = basename(editor.split(" ")[0] ?? "");
+  return GUI_EDITORS.find((g) => base.includes(g));
+}
+function guiGotoArgv(guiFamily, filePath, line) {
+  if (!line)
+    return [filePath];
+  if (VSCODE_FAMILY.has(guiFamily))
+    return ["-g", `${filePath}:${line}`];
+  if (guiFamily === "subl")
+    return [`${filePath}:${line}`];
+  return [filePath];
+}
+function openFileInExternalEditor(filePath, line) {
+  const editor = getExternalEditor();
+  if (!editor)
+    return false;
+  const parts = editor.split(" ");
+  const base = parts[0] ?? editor;
+  const editorArgs = parts.slice(1);
+  const guiFamily = classifyGuiEditor(editor);
+  if (guiFamily) {
+    const gotoArgv = guiGotoArgv(guiFamily, filePath, line);
+    const detachedOpts = { detached: true, stdio: "ignore" };
+    let child;
+    if (process.platform === "win32") {
+      const gotoStr = gotoArgv.map((a) => `"${a}"`).join(" ");
+      child = spawn(`${editor} ${gotoStr}`, { ...detachedOpts, shell: true });
+    } else {
+      child = spawn(base, [...editorArgs, ...gotoArgv], detachedOpts);
+    }
+    child.on("error", (e) => logForDebugging(`editor spawn failed: ${e}`, { level: "error" }));
+    child.unref();
+    return true;
+  }
+  const inkInstance = instances_default.get(process.stdout);
+  if (!inkInstance)
+    return false;
+  const useGotoLine = line && PLUS_N_EDITORS.test(basename(base));
+  inkInstance.enterAlternateScreen();
+  try {
+    const syncOpts = { stdio: "inherit" };
+    let result;
+    if (process.platform === "win32") {
+      const lineArg = useGotoLine ? `+${line} ` : "";
+      result = spawnSync(`${editor} ${lineArg}"${filePath}"`, {
+        ...syncOpts,
+        shell: true
+      });
+    } else {
+      const args = [
+        ...editorArgs,
+        ...useGotoLine ? [`+${line}`, filePath] : [filePath]
+      ];
+      result = spawnSync(base, args, syncOpts);
+    }
+    if (result.error) {
+      logForDebugging(`editor spawn failed: ${result.error}`, {
+        level: "error"
+      });
+      return false;
+    }
+    return true;
+  } finally {
+    inkInstance.exitAlternateScreen();
+  }
+}
+var GUI_EDITORS, PLUS_N_EDITORS, VSCODE_FAMILY, getExternalEditor;
+var init_editor = __esm(() => {
+  init_memoize();
+  init_instances();
+  init_debug();
+  init_which();
+  GUI_EDITORS = [
+    "code",
+    "cursor",
+    "windsurf",
+    "codium",
+    "subl",
+    "atom",
+    "gedit",
+    "notepad++",
+    "notepad"
+  ];
+  PLUS_N_EDITORS = /\b(vi|vim|nvim|nano|emacs|pico|micro|helix|hx)\b/;
+  VSCODE_FAMILY = new Set(["code", "cursor", "windsurf", "codium"]);
+  getExternalEditor = memoize_default(() => {
+    if (process.env.VISUAL?.trim()) {
+      return process.env.VISUAL.trim();
+    }
+    if (process.env.EDITOR?.trim()) {
+      return process.env.EDITOR.trim();
+    }
+    if (process.platform === "win32") {
+      return "start /wait notepad";
+    }
+    const editors = ["code", "vi", "nano"];
+    return editors.find((command) => isCommandAvailable(command));
+  });
+});
+
+// src/utils/promptEditor.ts
+function isGuiEditor(editor) {
+  return classifyGuiEditor(editor) !== undefined;
+}
+function editFileInEditor(filePath) {
+  const fs = getFsImplementation();
+  const inkInstance = instances_default.get(process.stdout);
+  if (!inkInstance) {
+    throw new Error("Ink instance not found - cannot pause rendering");
+  }
+  const editor = getExternalEditor();
+  if (!editor) {
+    return { content: null };
+  }
+  try {
+    fs.statSync(filePath);
+  } catch {
+    return { content: null };
+  }
+  const useAlternateScreen = !isGuiEditor(editor);
+  if (useAlternateScreen) {
+    inkInstance.enterAlternateScreen();
+  } else {
+    inkInstance.pause();
+    inkInstance.suspendStdin();
+  }
+  try {
+    const editorCommand = EDITOR_OVERRIDES[editor] ?? editor;
+    execSync_DEPRECATED(`${editorCommand} "${filePath}"`, {
+      stdio: "inherit"
+    });
+    const editedContent = fs.readFileSync(filePath, { encoding: "utf-8" });
+    return { content: editedContent };
+  } catch (err) {
+    if (typeof err === "object" && err !== null && "status" in err && typeof err.status === "number") {
+      const status = err.status;
+      if (status !== 0) {
+        const editorName = toIDEDisplayName(editor);
+        return {
+          content: null,
+          error: `${editorName} exited with code ${status}`
+        };
+      }
+    }
+    return { content: null };
+  } finally {
+    if (useAlternateScreen) {
+      inkInstance.exitAlternateScreen();
+    } else {
+      inkInstance.resumeStdin();
+      inkInstance.resume();
+    }
+  }
+}
+function recollapsePastedContent(editedPrompt, originalPrompt, pastedContents) {
+  let collapsed = editedPrompt;
+  for (const [id, content] of Object.entries(pastedContents)) {
+    if (content.type === "text") {
+      const pasteId = parseInt(id);
+      const contentStr = content.content;
+      const contentIndex = collapsed.indexOf(contentStr);
+      if (contentIndex !== -1) {
+        const numLines = getPastedTextRefNumLines(contentStr);
+        const ref = formatPastedTextRef(pasteId, numLines);
+        collapsed = collapsed.slice(0, contentIndex) + ref + collapsed.slice(contentIndex + contentStr.length);
+      }
+    }
+  }
+  return collapsed;
+}
+function editPromptInEditor(currentPrompt, pastedContents) {
+  const fs = getFsImplementation();
+  const tempFile = generateTempFilePath();
+  try {
+    const expandedPrompt = pastedContents ? expandPastedTextRefs(currentPrompt, pastedContents) : currentPrompt;
+    writeFileSync_DEPRECATED(tempFile, expandedPrompt, {
+      encoding: "utf-8",
+      flush: true
+    });
+    const result = editFileInEditor(tempFile);
+    if (result.content === null) {
+      return result;
+    }
+    let finalContent = result.content;
+    if (finalContent.endsWith(`
+`) && !finalContent.endsWith(`
+
+`)) {
+      finalContent = finalContent.slice(0, -1);
+    }
+    if (pastedContents) {
+      finalContent = recollapsePastedContent(finalContent, currentPrompt, pastedContents);
+    }
+    return { content: finalContent };
+  } finally {
+    try {
+      fs.unlinkSync(tempFile);
+    } catch {}
+  }
+}
+var EDITOR_OVERRIDES;
+var init_promptEditor = __esm(() => {
+  init_history();
+  init_instances();
+  init_editor();
+  init_execSyncWrapper();
+  init_fsOperations();
+  init_ide();
+  init_slowOperations();
+  init_tempfile();
+  EDITOR_OVERRIDES = {
+    code: "code -w",
+    subl: "subl --wait"
+  };
+});
+
+export { openFileInExternalEditor, getExternalEditor, init_editor, editFileInEditor, editPromptInEditor, init_promptEditor };

package/dist/chunk-893mewv4.js

@@ -0,0 +1,98 @@
+// @bun
+import {
+  createUserMessage,
+  extractTextContent,
+  formatAPIError,
+  init_errorUtils,
+  init_forkedAgent,
+  init_messages1 as init_messages,
+  runForkedAgent
+} from "./chunk-5frcqxsv.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/sideQuestion.ts
+function findBtwTriggerPositions(text) {
+  const positions = [];
+  const matches = text.matchAll(BTW_PATTERN);
+  for (const match of matches) {
+    if (match.index !== undefined) {
+      positions.push({
+        word: match[0],
+        start: match.index,
+        end: match.index + match[0].length
+      });
+    }
+  }
+  return positions;
+}
+async function runSideQuestion({
+  question,
+  cacheSafeParams
+}) {
+  const wrappedQuestion = `<system-reminder>This is a side question from the user. You must answer this question directly in a single response.
+
+IMPORTANT CONTEXT:
+- You are a separate, lightweight agent spawned to answer this one question
+- The main agent is NOT interrupted - it continues working independently in the background
+- You share the conversation context but are a completely separate instance
+- Do NOT reference being interrupted or what you were "previously doing" - that framing is incorrect
+
+CRITICAL CONSTRAINTS:
+- You have NO tools available - you cannot read files, run commands, search, or take any actions
+- This is a one-off response - there will be no follow-up turns
+- You can ONLY provide information based on what you already know from the conversation context
+- NEVER say things like "Let me try...", "I'll now...", "Let me check...", or promise to take any action
+- If you don't know the answer, say so - do not offer to look it up or investigate
+
+Simply answer the question with the information you have.</system-reminder>
+
+${question}`;
+  const agentResult = await runForkedAgent({
+    promptMessages: [createUserMessage({ content: wrappedQuestion })],
+    cacheSafeParams,
+    canUseTool: async () => ({
+      behavior: "deny",
+      message: "Side questions cannot use tools",
+      decisionReason: { type: "other", reason: "side_question" }
+    }),
+    querySource: "side_question",
+    forkLabel: "side_question",
+    maxTurns: 1,
+    skipCacheWrite: true
+  });
+  return {
+    response: extractSideQuestionResponse(agentResult.messages),
+    usage: agentResult.totalUsage
+  };
+}
+function extractSideQuestionResponse(messages) {
+  const assistantBlocks = messages.flatMap((m) => m.type === "assistant" ? m.message.content : []);
+  if (assistantBlocks.length > 0) {
+    const text = extractTextContent(assistantBlocks, `
+
+`).trim();
+    if (text)
+      return text;
+    const toolUse = assistantBlocks.find((b) => b.type === "tool_use");
+    if (toolUse) {
+      const toolName = "name" in toolUse ? toolUse.name : "a tool";
+      return `(The model tried to call ${toolName} instead of answering directly. Try rephrasing or ask in the main conversation.)`;
+    }
+  }
+  const apiErr = messages.find((m) => m.type === "system" && ("subtype" in m) && m.subtype === "api_error");
+  if (apiErr) {
+    return `(API error: ${formatAPIError(apiErr.error)})`;
+  }
+  return null;
+}
+var BTW_PATTERN;
+var init_sideQuestion = __esm(() => {
+  init_errorUtils();
+  init_forkedAgent();
+  init_messages();
+  BTW_PATTERN = /^\/btw\b/gi;
+});
+
+export { findBtwTriggerPositions, runSideQuestion, init_sideQuestion };

package/dist/chunk-8bedvdm1.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  getCwdState,
+  getOriginalCwd,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/cwd.ts
+import { AsyncLocalStorage } from "async_hooks";
+function runWithCwdOverride(cwd, fn) {
+  return cwdOverrideStorage.run(cwd, fn);
+}
+function pwd() {
+  return cwdOverrideStorage.getStore() ?? getCwdState();
+}
+function getCwd() {
+  try {
+    return pwd();
+  } catch {
+    return getOriginalCwd();
+  }
+}
+var cwdOverrideStorage;
+var init_cwd = __esm(() => {
+  init_state();
+  cwdOverrideStorage = new AsyncLocalStorage;
+});
+
+export { runWithCwdOverride, pwd, getCwd, init_cwd };

package/dist/chunk-8bw3ft0x.js

@@ -0,0 +1,81 @@
+// @bun
+import {
+  require_dist_cjs as require_dist_cjs2
+} from "./chunk-n0qaeaa5.js";
+import {
+  require_client
+} from "./chunk-b4wg70y1.js";
+import {
+  require_dist_cjs
+} from "./chunk-hk9xz7gk.js";
+import {
+  __esm,
+  __require,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.27/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
+var fromWebToken = (init) => async (awsIdentityProperties) => {
+  init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
+  const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
+  let { roleAssumerWithWebIdentity } = init;
+  if (!roleAssumerWithWebIdentity) {
+    const { getDefaultRoleAssumerWithWebIdentity } = await import("./chunk-amhzxqj4.js").then((m)=>__toESM(m.default,1));
+    roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
+      ...init.clientConfig,
+      credentialProviderLogger: init.logger,
+      parentClientConfig: {
+        ...awsIdentityProperties?.callerClientConfig,
+        ...init.parentClientConfig
+      }
+    }, init.clientPlugins);
+  }
+  return roleAssumerWithWebIdentity({
+    RoleArn: roleArn,
+    RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
+    WebIdentityToken: webIdentityToken,
+    ProviderId: providerId,
+    PolicyArns: policyArns,
+    Policy: policy,
+    DurationSeconds: durationSeconds
+  });
+};
+var init_fromWebToken = () => {};
+
+// node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.27/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
+import { readFileSync } from "fs";
+var import_client, import_property_provider, import_shared_ini_file_loader, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE", ENV_ROLE_ARN = "AWS_ROLE_ARN", ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME", fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
+  init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
+  const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
+  const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
+  const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
+  if (!webIdentityTokenFile || !roleArn) {
+    throw new import_property_provider.CredentialsProviderError("Web identity configuration not specified", {
+      logger: init.logger
+    });
+  }
+  const credentials = await fromWebToken({
+    ...init,
+    webIdentityToken: import_shared_ini_file_loader.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync(webIdentityTokenFile, { encoding: "ascii" }),
+    roleArn,
+    roleSessionName
+  })(awsIdentityProperties);
+  if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
+    import_client.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
+  }
+  return credentials;
+};
+var init_fromTokenFile = __esm(() => {
+  init_fromWebToken();
+  import_client = __toESM(require_client(), 1);
+  import_property_provider = __toESM(require_dist_cjs(), 1);
+  import_shared_ini_file_loader = __toESM(require_dist_cjs2(), 1);
+});
+
+// node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.27/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/index.js
+var init_dist_es = __esm(() => {
+  init_fromTokenFile();
+  init_fromWebToken();
+});
+
+export { fromWebToken, fromTokenFile, init_dist_es };