jialing-code 1.1.0

package/dist/chunk-sdw2q69p.js

@@ -0,0 +1,227 @@
+// @bun
+import {
+  SAFE_ENV_VARS,
+  isProviderManagedEnvVar
+} from "./chunk-x8b7vft8.js";
+import {
+  notifyPermissionModeChanged,
+  notifySessionMetadataChanged
+} from "./chunk-n2avk1r2.js";
+import {
+  init_syncCache,
+  isRemoteManagedSettingsEligible
+} from "./chunk-ewsgsw9h.js";
+import {
+  clearApiKeyHelperCache,
+  clearAwsCredentialsCache,
+  clearGcpCredentialsCache,
+  getGlobalConfig,
+  getSettingsForSource,
+  getSettings_DEPRECATED,
+  init_PermissionMode,
+  init_auth,
+  init_config1 as init_config,
+  init_constants,
+  init_settings1 as init_settings,
+  isSettingSourceEnabled,
+  permissionModeFromString,
+  saveGlobalConfig,
+  toExternalPermissionMode,
+  updateSettingsForSource
+} from "./chunk-3f7rypmf.js";
+import {
+  clearCACertsCache,
+  clearMTLSCache,
+  clearProxyCache,
+  configureGlobalAgents,
+  init_caCerts,
+  init_mtls,
+  init_proxy
+} from "./chunk-1eapde8a.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-nxsh6de2.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-3r24h7t6.js";
+import {
+  init_state,
+  setMainLoopModelOverride
+} from "./chunk-qqfa0dqg.js";
+
+// src/utils/managedEnv.ts
+init_syncCache();
+init_caCerts();
+init_config();
+init_envUtils();
+init_mtls();
+init_proxy();
+init_constants();
+init_settings();
+function withoutSSHTunnelVars(env) {
+  if (!env || !process.env.ANTHROPIC_UNIX_SOCKET)
+    return env || {};
+  const {
+    ANTHROPIC_UNIX_SOCKET: _1,
+    ANTHROPIC_BASE_URL: _2,
+    ANTHROPIC_API_KEY: _3,
+    ANTHROPIC_AUTH_TOKEN: _4,
+    CLAUDE_CODE_OAUTH_TOKEN: _5,
+    ...rest
+  } = env;
+  return rest;
+}
+function withoutHostManagedProviderVars(env) {
+  if (!env)
+    return {};
+  if (!isEnvTruthy(process.env.CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST)) {
+    return env;
+  }
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!isProviderManagedEnvVar(key)) {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+var ccdSpawnEnvKeys;
+function withoutCcdSpawnEnvKeys(env) {
+  if (!env || !ccdSpawnEnvKeys)
+    return env || {};
+  const out = {};
+  for (const [key, value] of Object.entries(env)) {
+    if (!ccdSpawnEnvKeys.has(key))
+      out[key] = value;
+  }
+  return out;
+}
+function filterSettingsEnv(env) {
+  return withoutCcdSpawnEnvKeys(withoutHostManagedProviderVars(withoutSSHTunnelVars(env)));
+}
+var TRUSTED_SETTING_SOURCES = [
+  "userSettings",
+  "flagSettings",
+  "policySettings"
+];
+function applySafeConfigEnvironmentVariables() {
+  if (ccdSpawnEnvKeys === undefined) {
+    ccdSpawnEnvKeys = process.env.CLAUDE_CODE_ENTRYPOINT === "claude-desktop" ? new Set(Object.keys(process.env)) : null;
+  }
+  Object.assign(process.env, filterSettingsEnv(getGlobalConfig().env));
+  for (const source of TRUSTED_SETTING_SOURCES) {
+    if (source === "policySettings")
+      continue;
+    if (!isSettingSourceEnabled(source))
+      continue;
+    Object.assign(process.env, filterSettingsEnv(getSettingsForSource(source)?.env));
+  }
+  isRemoteManagedSettingsEligible();
+  Object.assign(process.env, filterSettingsEnv(getSettingsForSource("policySettings")?.env));
+  const settingsEnv = filterSettingsEnv(getSettings_DEPRECATED()?.env);
+  for (const [key, value] of Object.entries(settingsEnv)) {
+    if (SAFE_ENV_VARS.has(key.toUpperCase())) {
+      process.env[key] = value;
+    }
+  }
+}
+function applyConfigEnvironmentVariables() {
+  Object.assign(process.env, filterSettingsEnv(getGlobalConfig().env));
+  Object.assign(process.env, filterSettingsEnv(getSettings_DEPRECATED()?.env));
+  clearCACertsCache();
+  clearMTLSCache();
+  clearProxyCache();
+  configureGlobalAgents();
+}
+
+// src/state/onChangeAppState.ts
+init_state();
+init_auth();
+init_config();
+init_errors();
+init_log();
+init_PermissionMode();
+init_settings();
+function externalMetadataToAppState(metadata) {
+  return (prev) => ({
+    ...prev,
+    ...typeof metadata.permission_mode === "string" ? {
+      toolPermissionContext: {
+        ...prev.toolPermissionContext,
+        mode: permissionModeFromString(metadata.permission_mode)
+      }
+    } : {},
+    ...typeof metadata.is_ultraplan_mode === "boolean" ? { isUltraplanMode: metadata.is_ultraplan_mode } : {}
+  });
+}
+function onChangeAppState({
+  newState,
+  oldState
+}) {
+  const prevMode = oldState.toolPermissionContext.mode;
+  const newMode = newState.toolPermissionContext.mode;
+  if (prevMode !== newMode) {
+    const prevExternal = toExternalPermissionMode(prevMode);
+    const newExternal = toExternalPermissionMode(newMode);
+    if (prevExternal !== newExternal) {
+      const isUltraplan = newExternal === "plan" && newState.isUltraplanMode && !oldState.isUltraplanMode ? true : null;
+      notifySessionMetadataChanged({
+        permission_mode: newExternal,
+        is_ultraplan_mode: isUltraplan
+      });
+    }
+    notifyPermissionModeChanged(newMode);
+  }
+  if (newState.mainLoopModel !== oldState.mainLoopModel && newState.mainLoopModel === null) {
+    updateSettingsForSource("userSettings", { model: undefined });
+    setMainLoopModelOverride(null);
+  }
+  if (newState.mainLoopModel !== oldState.mainLoopModel && newState.mainLoopModel !== null) {
+    updateSettingsForSource("userSettings", { model: newState.mainLoopModel });
+    setMainLoopModelOverride(newState.mainLoopModel);
+  }
+  if (newState.expandedView !== oldState.expandedView) {
+    const showExpandedTodos = newState.expandedView === "tasks";
+    const showSpinnerTree = newState.expandedView === "teammates";
+    if (getGlobalConfig().showExpandedTodos !== showExpandedTodos || getGlobalConfig().showSpinnerTree !== showSpinnerTree) {
+      saveGlobalConfig((current) => ({
+        ...current,
+        showExpandedTodos,
+        showSpinnerTree
+      }));
+    }
+  }
+  if (newState.verbose !== oldState.verbose && getGlobalConfig().verbose !== newState.verbose) {
+    const verbose = newState.verbose;
+    saveGlobalConfig((current) => ({
+      ...current,
+      verbose
+    }));
+  }
+  if (process.env.USER_TYPE === "ant") {
+    if (newState.tungstenPanelVisible !== oldState.tungstenPanelVisible && newState.tungstenPanelVisible !== undefined && getGlobalConfig().tungstenPanelVisible !== newState.tungstenPanelVisible) {
+      const tungstenPanelVisible = newState.tungstenPanelVisible;
+      saveGlobalConfig((current) => ({ ...current, tungstenPanelVisible }));
+    }
+  }
+  if (newState.settings !== oldState.settings) {
+    try {
+      clearApiKeyHelperCache();
+      clearAwsCredentialsCache();
+      clearGcpCredentialsCache();
+      if (newState.settings.env !== oldState.settings.env) {
+        applyConfigEnvironmentVariables();
+      }
+    } catch (error) {
+      logError(toError(error));
+    }
+  }
+}
+
+export { applySafeConfigEnvironmentVariables, applyConfigEnvironmentVariables, externalMetadataToAppState, onChangeAppState };

package/dist/chunk-sfgp9cc0.js

@@ -0,0 +1,130 @@
+// @bun
+import {
+  asSystemPrompt,
+  extractTextContent,
+  init_claude,
+  init_messages1 as init_messages,
+  init_systemPromptType,
+  queryHaiku
+} from "./chunk-ewsgsw9h.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-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-spzrs4df.js

@@ -0,0 +1,73 @@
+// @bun
+import {
+  addHiddenPaneId,
+  cleanupSessionTeams,
+  cleanupTeamDirectories,
+  getTeamDir,
+  getTeamFilePath,
+  init_teamHelpers,
+  inputSchema,
+  readTeamFile,
+  readTeamFileAsync,
+  registerTeamForSessionCleanup,
+  removeHiddenPaneId,
+  removeMemberByAgentId,
+  removeMemberFromTeam,
+  removeTeammateFromTeamFile,
+  sanitizeAgentName,
+  sanitizeName,
+  setMemberActive,
+  setMemberMode,
+  setMultipleMemberModes,
+  syncTeammateMode,
+  unregisterTeamForSessionCleanup,
+  writeTeamFileAsync
+} from "./chunk-x679thag.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-v1kzp02e.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-qp2qdcda.js";
+init_teamHelpers();
+
+export {
+  writeTeamFileAsync,
+  unregisterTeamForSessionCleanup,
+  syncTeammateMode,
+  setMultipleMemberModes,
+  setMemberMode,
+  setMemberActive,
+  sanitizeName,
+  sanitizeAgentName,
+  removeTeammateFromTeamFile,
+  removeMemberFromTeam,
+  removeMemberByAgentId,
+  removeHiddenPaneId,
+  registerTeamForSessionCleanup,
+  readTeamFileAsync,
+  readTeamFile,
+  inputSchema,
+  getTeamFilePath,
+  getTeamDir,
+  cleanupTeamDirectories,
+  cleanupSessionTeams,
+  addHiddenPaneId
+};

package/dist/chunk-sxkr7k43.js

@@ -0,0 +1,55 @@
+// @bun
+import {
+  TOOL_SEARCH_TOOL_NAME,
+  formatDeferredToolLine,
+  getPrompt,
+  init_prompt,
+  isDeferredTool
+} from "./chunk-tw0q7ynt.js";
+import"./chunk-3f7rypmf.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.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-1eapde8a.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import"./chunk-f2mhrmww.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_prompt();
+
+export {
+  isDeferredTool,
+  getPrompt,
+  formatDeferredToolLine,
+  TOOL_SEARCH_TOOL_NAME
+};

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-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 };

package/dist/chunk-t1nnzjgg.js

@@ -0,0 +1,17 @@
+// @bun
+import {
+  fromTokenFile,
+  fromWebToken,
+  init_dist_es
+} from "./chunk-4z0jsrqg.js";
+import"./chunk-n0qaeaa5.js";
+import"./chunk-b4wg70y1.js";
+import"./chunk-hk9xz7gk.js";
+import"./chunk-xsq9ae7x.js";
+import"./chunk-qp2qdcda.js";
+init_dist_es();
+
+export {
+  fromWebToken,
+  fromTokenFile
+};