@jdi-code/claude-code 1.0.3

package/dist/chunk-se7v9emp.js

@@ -0,0 +1,130 @@
+// @bun
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-5frcqxsv.js";
+import {
+  init_json,
+  safeParseJSON
+} from "./chunk-e3g8q4cn.js";
+import {
+  init_v4
+} from "./chunk-g0j0t6qk.js";
+import {
+  exports_external,
+  init_lazySchema,
+  lazySchema
+} from "./chunk-55wgxwa9.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import {
+  init_debug,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/sessionTitle.ts
+function extractConversationText(messages) {
+  const parts = [];
+  for (const msg of messages) {
+    if (msg.type !== "user" && msg.type !== "assistant")
+      continue;
+    if ("isMeta" in msg && msg.isMeta)
+      continue;
+    if ("origin" in msg && msg.origin && msg.origin.kind !== "human")
+      continue;
+    const content = msg.message.content;
+    if (typeof content === "string") {
+      parts.push(content);
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if ("type" in block && block.type === "text" && "text" in block) {
+          parts.push(block.text);
+        }
+      }
+    }
+  }
+  const text = parts.join(`
+`);
+  return text.length > MAX_CONVERSATION_TEXT ? text.slice(-MAX_CONVERSATION_TEXT) : text;
+}
+async function generateSessionTitle(description, signal) {
+  const trimmed = description.trim();
+  if (!trimmed)
+    return null;
+  try {
+    const result = await queryHaiku({
+      systemPrompt: asSystemPrompt([SESSION_TITLE_PROMPT]),
+      userPrompt: trimmed,
+      outputFormat: {
+        type: "json_schema",
+        schema: {
+          type: "object",
+          properties: {
+            title: { type: "string" }
+          },
+          required: ["title"],
+          additionalProperties: false
+        }
+      },
+      signal,
+      options: {
+        querySource: "generate_session_title",
+        agents: [],
+        isNonInteractiveSession: getIsNonInteractiveSession(),
+        hasAppendSystemPrompt: false,
+        mcpTools: []
+      }
+    });
+    const text = extractTextContent(result.message.content);
+    const parsed = titleSchema().safeParse(safeParseJSON(text));
+    const title = parsed.success ? parsed.data.title.trim() || null : null;
+    logEvent("tengu_session_title_generated", { success: title !== null });
+    return title;
+  } catch (error) {
+    logForDebugging(`generateSessionTitle failed: ${error}`, {
+      level: "error"
+    });
+    logEvent("tengu_session_title_generated", { success: false });
+    return null;
+  }
+}
+var MAX_CONVERSATION_TEXT = 1000, SESSION_TITLE_PROMPT = `Generate a concise, sentence-case title (3-7 words) that captures the main topic or goal of this coding session. The title should be clear enough that the user recognizes the session in a list. Use sentence case: capitalize only the first word and proper nouns.
+
+Return JSON with a single "title" field.
+
+Good examples:
+{"title": "Fix login button on mobile"}
+{"title": "Add OAuth authentication"}
+{"title": "Debug failing CI tests"}
+{"title": "Refactor API client error handling"}
+
+Bad (too vague): {"title": "Code changes"}
+Bad (too long): {"title": "Investigate and fix the issue where the login button does not respond on mobile devices"}
+Bad (wrong case): {"title": "Fix Login Button On Mobile"}`, titleSchema;
+var init_sessionTitle = __esm(() => {
+  init_v4();
+  init_state();
+  init_analytics();
+  init_claude();
+  init_debug();
+  init_json();
+  init_lazySchema();
+  init_messages();
+  init_systemPromptType();
+  titleSchema = lazySchema(() => exports_external.object({ title: exports_external.string() }));
+});
+
+export { extractConversationText, generateSessionTitle, init_sessionTitle };

package/dist/chunk-sfq65q9w.js

@@ -0,0 +1,117 @@
+// @bun
+import {
+  Messages,
+  init_Messages
+} from "./chunk-drrw55jr.js";
+import {
+  init_staticRender,
+  renderToAnsiString
+} from "./chunk-4589pec2.js";
+import {
+  AppStateProvider,
+  init_AppState,
+  init_loadUserBindings,
+  loadKeybindingsSyncWithWarnings
+} from "./chunk-5frcqxsv.js";
+import {
+  KeybindingProvider,
+  init_KeybindingContext
+} from "./chunk-g653q217.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  init_strip_ansi,
+  stripAnsi
+} from "./chunk-1rvz0433.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/exportRenderer.tsx
+function StaticKeybindingProvider({
+  children
+}) {
+  const {
+    bindings
+  } = loadKeybindingsSyncWithWarnings();
+  const pendingChordRef = import_react.useRef(null);
+  const handlerRegistryRef = import_react.useRef(new Map);
+  const activeContexts = import_react.useRef(new Set).current;
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(KeybindingProvider, {
+    bindings,
+    pendingChordRef,
+    pendingChord: null,
+    setPendingChord: () => {},
+    activeContexts,
+    registerActiveContext: () => {},
+    unregisterActiveContext: () => {},
+    handlerRegistryRef,
+    children
+  }, undefined, false, undefined, this);
+}
+function normalizedUpperBound(m) {
+  if (!("message" in m))
+    return 1;
+  const c = m.message.content;
+  return Array.isArray(c) ? c.length : 1;
+}
+async function streamRenderedMessages(messages, tools, sink, {
+  columns,
+  verbose = false,
+  chunkSize = 40,
+  onProgress
+} = {}) {
+  const renderChunk = (range) => renderToAnsiString(/* @__PURE__ */ jsx_dev_runtime.jsxDEV(AppStateProvider, {
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(StaticKeybindingProvider, {
+      children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Messages, {
+        messages,
+        tools,
+        commands: [],
+        verbose,
+        toolJSX: null,
+        toolUseConfirmQueue: [],
+        inProgressToolUseIDs: new Set,
+        isMessageSelectorVisible: false,
+        conversationId: "export",
+        screen: "prompt",
+        streamingToolUses: [],
+        showAllInTranscript: true,
+        isLoading: false,
+        renderRange: range
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this), columns);
+  let ceiling = chunkSize;
+  for (const m of messages)
+    ceiling += normalizedUpperBound(m);
+  for (let offset = 0;offset < ceiling; offset += chunkSize) {
+    const ansi = await renderChunk([offset, offset + chunkSize]);
+    if (stripAnsi(ansi).trim() === "")
+      break;
+    await sink(ansi);
+    onProgress?.(offset + chunkSize);
+  }
+}
+async function renderMessagesToPlainText(messages, tools = [], columns) {
+  const parts = [];
+  await streamRenderedMessages(messages, tools, (chunk) => void parts.push(stripAnsi(chunk)), {
+    columns
+  });
+  return parts.join("");
+}
+var import_react, jsx_dev_runtime;
+var init_exportRenderer = __esm(() => {
+  init_strip_ansi();
+  init_Messages();
+  init_KeybindingContext();
+  init_loadUserBindings();
+  init_AppState();
+  init_staticRender();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { renderMessagesToPlainText, init_exportRenderer };

package/dist/chunk-spde0bf5.js

@@ -0,0 +1,71 @@
+// @bun
+import {
+  init_datadog,
+  trackDatadogEvent
+} from "./chunk-pxrffn0w.js";
+import {
+  checkStatsigFeatureGate_CACHED_MAY_BE_STALE,
+  init_firstPartyEventLogger,
+  init_growthbook,
+  init_sinkKillswitch,
+  isSinkKilled,
+  logEventTo1P,
+  shouldSampleEvent
+} from "./chunk-53nbpp47.js";
+import {
+  attachAnalyticsSink,
+  init_analytics,
+  stripProtoFields
+} from "./chunk-f2mhrmww.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/analytics/sink.ts
+function shouldTrackDatadog() {
+  if (isSinkKilled("datadog")) {
+    return false;
+  }
+  if (isDatadogGateEnabled !== undefined) {
+    return isDatadogGateEnabled;
+  }
+  try {
+    return checkStatsigFeatureGate_CACHED_MAY_BE_STALE(DATADOG_GATE_NAME);
+  } catch {
+    return false;
+  }
+}
+function logEventImpl(eventName, metadata) {
+  const sampleResult = shouldSampleEvent(eventName);
+  if (sampleResult === 0) {
+    return;
+  }
+  const metadataWithSampleRate = sampleResult !== null ? { ...metadata, sample_rate: sampleResult } : metadata;
+  if (shouldTrackDatadog()) {
+    trackDatadogEvent(eventName, stripProtoFields(metadataWithSampleRate));
+  }
+  logEventTo1P(eventName, metadataWithSampleRate);
+}
+function logEventAsyncImpl(eventName, metadata) {
+  logEventImpl(eventName, metadata);
+  return Promise.resolve();
+}
+function initializeAnalyticsGates() {
+  isDatadogGateEnabled = checkStatsigFeatureGate_CACHED_MAY_BE_STALE(DATADOG_GATE_NAME);
+}
+function initializeAnalyticsSink() {
+  attachAnalyticsSink({
+    logEvent: logEventImpl,
+    logEventAsync: logEventAsyncImpl
+  });
+}
+var DATADOG_GATE_NAME = "tengu_log_datadog_events", isDatadogGateEnabled = undefined;
+var init_sink = __esm(() => {
+  init_datadog();
+  init_firstPartyEventLogger();
+  init_growthbook();
+  init_analytics();
+  init_sinkKillswitch();
+});
+
+export { initializeAnalyticsGates, initializeAnalyticsSink, init_sink };

package/dist/chunk-spqaamnc.js

@@ -0,0 +1,63 @@
+// @bun
+import {
+  TMUX_COMMAND,
+  init_constants
+} from "./chunk-4jm600zv.js";
+import {
+  env,
+  init_env
+} from "./chunk-w2z5pqd3.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-hx2tr4ep.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/swarm/backends/detection.ts
+function isInsideTmuxSync() {
+  return !!ORIGINAL_USER_TMUX;
+}
+async function isInsideTmux() {
+  if (isInsideTmuxCached !== null) {
+    return isInsideTmuxCached;
+  }
+  isInsideTmuxCached = !!ORIGINAL_USER_TMUX;
+  return isInsideTmuxCached;
+}
+function getLeaderPaneId() {
+  return ORIGINAL_TMUX_PANE || null;
+}
+async function isTmuxAvailable() {
+  const result = await execFileNoThrow(TMUX_COMMAND, ["-V"]);
+  return result.code === 0;
+}
+function isInITerm2() {
+  if (isInITerm2Cached !== null) {
+    return isInITerm2Cached;
+  }
+  const termProgram = process.env.TERM_PROGRAM;
+  const hasItermSessionId = !!process.env.ITERM_SESSION_ID;
+  const terminalIsITerm = env.terminal === "iTerm.app";
+  isInITerm2Cached = termProgram === "iTerm.app" || hasItermSessionId || terminalIsITerm;
+  return isInITerm2Cached;
+}
+async function isIt2CliAvailable() {
+  const result = await execFileNoThrow(IT2_COMMAND, ["session", "list"]);
+  return result.code === 0;
+}
+function resetDetectionCache() {
+  isInsideTmuxCached = null;
+  isInITerm2Cached = null;
+}
+var ORIGINAL_USER_TMUX, ORIGINAL_TMUX_PANE, isInsideTmuxCached = null, isInITerm2Cached = null, IT2_COMMAND = "it2";
+var init_detection = __esm(() => {
+  init_env();
+  init_execFileNoThrow();
+  init_constants();
+  ORIGINAL_USER_TMUX = process.env.TMUX;
+  ORIGINAL_TMUX_PANE = process.env.TMUX_PANE;
+});
+
+export { isInsideTmuxSync, isInsideTmux, getLeaderPaneId, isTmuxAvailable, isInITerm2, IT2_COMMAND, isIt2CliAvailable, resetDetectionCache, init_detection };

package/dist/chunk-src9fqj8.js

@@ -0,0 +1,60 @@
+// @bun
+import {
+  getAuthHeaders,
+  getClaudeAIOAuthTokens,
+  getClaudeCodeUserAgent,
+  hasProfileScope,
+  init_auth,
+  init_client,
+  init_http,
+  init_userAgent,
+  isClaudeAISubscriber,
+  isOAuthTokenExpired
+} from "./chunk-53nbpp47.js";
+import {
+  getOauthConfig,
+  init_oauth
+} from "./chunk-7ymfj7m3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/api/usage.ts
+async function fetchUtilization() {
+  if (!isClaudeAISubscriber() || !hasProfileScope()) {
+    return {};
+  }
+  const tokens = getClaudeAIOAuthTokens();
+  if (tokens && isOAuthTokenExpired(tokens.expiresAt)) {
+    return null;
+  }
+  const authResult = getAuthHeaders();
+  if (authResult.error) {
+    throw new Error(`Auth error: ${authResult.error}`);
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    "User-Agent": getClaudeCodeUserAgent(),
+    ...authResult.headers
+  };
+  const url = `${getOauthConfig().BASE_API_URL}/api/oauth/usage`;
+  const response = await axios_default.get(url, {
+    headers,
+    timeout: 5000
+  });
+  return response.data;
+}
+var init_usage = __esm(() => {
+  init_axios();
+  init_oauth();
+  init_auth();
+  init_http();
+  init_userAgent();
+  init_client();
+});
+
+export { fetchUtilization, init_usage };

package/dist/chunk-szj5wvdy.js

@@ -0,0 +1,28 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/compact/cachedMicrocompact.ts
+var isCachedMicrocompactEnabled = () => false, isModelSupportedForCacheEditing = () => false, getCachedMCConfig = () => ({ triggerThreshold: 0, keepRecent: 0 }), createCachedMCState = () => ({
+  registeredTools: new Set,
+  toolOrder: [],
+  deletedRefs: new Set,
+  pinnedEdits: [],
+  toolsSentToAPI: false
+}), markToolsSentToAPI = () => {}, resetCachedMCState = () => {}, registerToolResult = () => {}, registerToolMessage = () => {}, getToolResultsToDelete = () => [], createCacheEditsBlock = () => null;
+var init_cachedMicrocompact = () => {};
+init_cachedMicrocompact();
+
+export {
+  resetCachedMCState,
+  registerToolResult,
+  registerToolMessage,
+  markToolsSentToAPI,
+  isModelSupportedForCacheEditing,
+  isCachedMicrocompactEnabled,
+  getToolResultsToDelete,
+  getCachedMCConfig,
+  createCachedMCState,
+  createCacheEditsBlock
+};

package/dist/chunk-t0mnk0qp.js

@@ -0,0 +1,105 @@
+// @bun
+import {
+  archiveRemoteSession,
+  checkOutTeleportedSessionBranch,
+  init_teleport,
+  pollRemoteSessionEvents,
+  processMessagesForTeleportResume,
+  teleportFromSessionsAPI,
+  teleportResumeCodeSession,
+  teleportToRemote,
+  teleportToRemoteWithErrorHandling,
+  validateGitState,
+  validateSessionRepository
+} from "./chunk-5frcqxsv.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-gb2q3nvc.js";
+import"./chunk-neh2frnn.js";
+import"./chunk-q6b51yc5.js";
+import"./chunk-gfkppe34.js";
+import"./chunk-kqd0e3xj.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-xe6z85xc.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-pxrffn0w.js";
+import"./chunk-0nt9md2b.js";
+import"./chunk-rn4kqfvd.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-n8sjmqba.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-g653q217.js";
+import"./chunk-z72st5c8.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import"./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-35x3tjnr.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-40b8p5em.js";
+import"./chunk-s0xfxkys.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-53nbpp47.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-fw49pe3p.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import"./chunk-qp2qdcda.js";
+init_teleport();
+
+export {
+  validateSessionRepository,
+  validateGitState,
+  teleportToRemoteWithErrorHandling,
+  teleportToRemote,
+  teleportResumeCodeSession,
+  teleportFromSessionsAPI,
+  processMessagesForTeleportResume,
+  pollRemoteSessionEvents,
+  checkOutTeleportedSessionBranch,
+  archiveRemoteSession
+};

package/dist/chunk-t0rgmccj.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  clearBetaHeaderLatches,
+  clearSystemPromptSectionState,
+  getSystemPromptSectionCache,
+  init_state,
+  setSystemPromptSectionCacheEntry
+} from "./chunk-qqfa0dqg.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/constants/systemPromptSections.ts
+function systemPromptSection(name, compute) {
+  return { name, compute, cacheBreak: false };
+}
+function DANGEROUS_uncachedSystemPromptSection(name, compute, _reason) {
+  return { name, compute, cacheBreak: true };
+}
+async function resolveSystemPromptSections(sections) {
+  const cache = getSystemPromptSectionCache();
+  return Promise.all(sections.map(async (s) => {
+    if (!s.cacheBreak && cache.has(s.name)) {
+      return cache.get(s.name) ?? null;
+    }
+    const value = await s.compute();
+    setSystemPromptSectionCacheEntry(s.name, value);
+    return value;
+  }));
+}
+function clearSystemPromptSections() {
+  clearSystemPromptSectionState();
+  clearBetaHeaderLatches();
+}
+var init_systemPromptSections = __esm(() => {
+  init_state();
+});
+
+export { systemPromptSection, DANGEROUS_uncachedSystemPromptSection, resolveSystemPromptSections, clearSystemPromptSections, init_systemPromptSections };