@zyycn/claudex 1.0.3-fork.1453470

package/dist/chunk-7cgwfdew.js

@@ -0,0 +1,225 @@
+// @bun
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-3tqnjgfx.js";
+import {
+  require_semver
+} from "./chunk-0vkfrmqm.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-yysj6sxt.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-sbbj6ta3.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-raqgs410.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-qqfa0dqg.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-xszk7n10.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/releaseNotes.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+function getChangelogCachePath() {
+  return join(getClaudeConfigHomeDir(), "cache", "changelog.md");
+}
+async function migrateChangelogFromConfig() {
+  const config = getGlobalConfig();
+  if (!config.cachedChangelog) {
+    return;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, config.cachedChangelog, {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+  } catch {}
+  saveGlobalConfig(({ cachedChangelog: _, ...rest }) => rest);
+}
+async function fetchAndStoreChangelog() {
+  if (getIsNonInteractiveSession()) {
+    return;
+  }
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  const response = await axios_default.get(RAW_CHANGELOG_URL);
+  if (response.status === 200) {
+    const changelogContent = response.data;
+    if (changelogContent === changelogMemoryCache) {
+      return;
+    }
+    const cachePath = getChangelogCachePath();
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, changelogContent, { encoding: "utf-8" });
+    changelogMemoryCache = changelogContent;
+    const changelogLastFetched = Date.now();
+    saveGlobalConfig((current) => ({
+      ...current,
+      changelogLastFetched
+    }));
+  }
+}
+async function getStoredChangelog() {
+  if (changelogMemoryCache !== null) {
+    return changelogMemoryCache;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    changelogMemoryCache = content;
+    return content;
+  } catch {
+    changelogMemoryCache = "";
+    return "";
+  }
+}
+function getStoredChangelogFromMemory() {
+  return changelogMemoryCache ?? "";
+}
+function parseChangelog(content) {
+  try {
+    if (!content)
+      return {};
+    const releaseNotes = {};
+    const sections = content.split(/^## /gm).slice(1);
+    for (const section of sections) {
+      const lines = section.trim().split(`
+`);
+      if (lines.length === 0)
+        continue;
+      const versionLine = lines[0];
+      if (!versionLine)
+        continue;
+      const version = versionLine.split(" - ")[0]?.trim() || "";
+      if (!version)
+        continue;
+      const notes = lines.slice(1).filter((line) => line.trim().startsWith("- ")).map((line) => line.trim().substring(2).trim()).filter(Boolean);
+      if (notes.length > 0) {
+        releaseNotes[version] = notes;
+      }
+    }
+    return releaseNotes;
+  } catch (error) {
+    logError(toError(error));
+    return {};
+  }
+}
+function getRecentReleaseNotes(currentVersion, previousVersion, changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const baseCurrentVersion = import_semver.coerce(currentVersion);
+    const basePreviousVersion = previousVersion ? import_semver.coerce(previousVersion) : null;
+    if (!basePreviousVersion || baseCurrentVersion && gt(baseCurrentVersion.version, basePreviousVersion.version)) {
+      return Object.entries(releaseNotes).filter(([version]) => !basePreviousVersion || gt(version, basePreviousVersion.version)).sort(([versionA], [versionB]) => gt(versionA, versionB) ? -1 : 1).flatMap(([_, notes]) => notes).filter(Boolean).slice(0, MAX_RELEASE_NOTES_SHOWN);
+    }
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+  return [];
+}
+function getAllReleaseNotes(changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const sortedVersions = Object.keys(releaseNotes).sort((a, b) => gt(a, b) ? 1 : -1);
+    return sortedVersions.map((version) => {
+      const versionNotes = releaseNotes[version];
+      if (!versionNotes || versionNotes.length === 0)
+        return null;
+      const notes = versionNotes.filter(Boolean);
+      if (notes.length === 0)
+        return null;
+      return [version, notes];
+    }).filter((item) => item !== null);
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+}
+async function checkForReleaseNotes(lastSeenVersion, currentVersion = "1.0.3-fork.1453470") {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = "";
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const cachedChangelog = await getStoredChangelog();
+  if (lastSeenVersion !== currentVersion || !cachedChangelog) {
+    fetchAndStoreChangelog().catch((error) => logError(toError(error)));
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion, cachedChangelog);
+  const hasReleaseNotes = releaseNotes.length > 0;
+  return {
+    hasReleaseNotes,
+    releaseNotes
+  };
+}
+function checkForReleaseNotesSync(lastSeenVersion, currentVersion = "1.0.3-fork.1453470") {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = "";
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion);
+  return {
+    hasReleaseNotes: releaseNotes.length > 0,
+    releaseNotes
+  };
+}
+var import_semver, MAX_RELEASE_NOTES_SHOWN = 5, CHANGELOG_URL = "https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md", RAW_CHANGELOG_URL = "https://raw.githubusercontent.com/anthropics/claude-code/refs/heads/main/CHANGELOG.md", changelogMemoryCache = null;
+var init_releaseNotes = __esm(() => {
+  init_axios();
+  init_state();
+  init_config();
+  init_envUtils();
+  init_errors();
+  init_log();
+  init_privacyLevel();
+  init_semver();
+  import_semver = __toESM(require_semver(), 1);
+});
+
+export { CHANGELOG_URL, migrateChangelogFromConfig, fetchAndStoreChangelog, getStoredChangelog, getStoredChangelogFromMemory, parseChangelog, getAllReleaseNotes, checkForReleaseNotes, checkForReleaseNotesSync, init_releaseNotes };

package/dist/chunk-7e0f3syh.js

@@ -0,0 +1,458 @@
+// @bun
+import {
+  renameRecordingForSession
+} from "./chunk-bvp4dgm4.js";
+import {
+  TODO_WRITE_TOOL_NAME,
+  TodoListSchema,
+  adoptResumedSessionFile,
+  asSessionId,
+  clearCommandMemoizationCaches,
+  clearCommandsCache,
+  clearMemoryFileCaches,
+  clearSkillCaches,
+  executeConfigChangeHooks,
+  fileHistoryRestoreStateFromLog,
+  getActiveAgentsFromList,
+  getAgentDefinitionsWithOverrides,
+  getCurrentWorktreeSession,
+  getPlansDirectory,
+  getSkillsPath,
+  hasBlockingResult,
+  init_Shell,
+  init_attachments,
+  init_claudemd,
+  init_commands1 as init_commands,
+  init_concurrentSessions,
+  init_constants4 as init_constants,
+  init_cost_tracker,
+  init_fileHistory,
+  init_hooks1 as init_hooks,
+  init_ids,
+  init_loadAgentsDir,
+  init_loadSkillsDir,
+  init_messages1 as init_messages,
+  init_plans,
+  init_sessionStorage,
+  init_types3 as init_types,
+  init_worktree,
+  onDynamicSkillsLoaded,
+  recordContentReplacement,
+  resetSentSkillNames,
+  resetSessionFilePointer,
+  restoreCostStateForSession,
+  restoreSessionMetadata,
+  restoreWorktreeSession,
+  saveWorktreeState,
+  setCwd,
+  updateSessionName
+} from "./chunk-730qrdey.js";
+import {
+  clearSystemPromptSections,
+  init_systemPromptSections
+} from "./chunk-t0rgmccj.js";
+import {
+  chokidar_default,
+  init_chokidar
+} from "./chunk-ehtwnxpg.js";
+import {
+  init_commitAttribution
+} from "./chunk-n8326eqb.js";
+import {
+  init_tasks,
+  isTodoV2Enabled
+} from "./chunk-ps540063.js";
+import {
+  init_model,
+  parseUserSpecifiedModel
+} from "./chunk-3tqnjgfx.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-h0rbjg6x.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-8bedvdm1.js";
+import {
+  getFsImplementation,
+  init_cleanupRegistry,
+  init_debug,
+  init_fsOperations,
+  logForDebugging,
+  registerCleanup
+} from "./chunk-sbbj6ta3.js";
+import {
+  createSignal,
+  getAdditionalDirectoriesForClaudeMd,
+  getMainLoopModelOverride,
+  getSessionId,
+  init_signal,
+  init_state,
+  setMainLoopModelOverride,
+  setMainThreadAgentType,
+  setOriginalCwd,
+  switchSession
+} from "./chunk-qqfa0dqg.js";
+
+// src/utils/skills/skillChangeDetector.ts
+init_chokidar();
+init_state();
+init_commands();
+init_analytics();
+init_loadSkillsDir();
+init_attachments();
+init_cleanupRegistry();
+init_debug();
+init_fsOperations();
+init_hooks();
+init_signal();
+import * as platformPath from "path";
+var FILE_STABILITY_THRESHOLD_MS = 1000;
+var FILE_STABILITY_POLL_INTERVAL_MS = 500;
+var RELOAD_DEBOUNCE_MS = 300;
+var POLLING_INTERVAL_MS = 2000;
+var USE_POLLING = typeof Bun !== "undefined";
+var watcher = null;
+var reloadTimer = null;
+var pendingChangedPaths = new Set;
+var initialized = false;
+var disposed = false;
+var dynamicSkillsCallbackRegistered = false;
+var unregisterCleanup = null;
+var skillsChanged = createSignal();
+var testOverrides = null;
+async function initialize() {
+  if (initialized || disposed)
+    return;
+  initialized = true;
+  if (!dynamicSkillsCallbackRegistered) {
+    dynamicSkillsCallbackRegistered = true;
+    onDynamicSkillsLoaded(() => {
+      clearCommandMemoizationCaches();
+      skillsChanged.emit();
+    });
+  }
+  const paths = await getWatchablePaths();
+  if (paths.length === 0)
+    return;
+  logForDebugging(`Watching for changes in skill/command directories: ${paths.join(", ")}...`);
+  watcher = chokidar_default.watch(paths, {
+    persistent: true,
+    ignoreInitial: true,
+    depth: 2,
+    awaitWriteFinish: {
+      stabilityThreshold: testOverrides?.stabilityThreshold ?? FILE_STABILITY_THRESHOLD_MS,
+      pollInterval: testOverrides?.pollInterval ?? FILE_STABILITY_POLL_INTERVAL_MS
+    },
+    ignored: (path, stats) => {
+      if (stats && !stats.isFile() && !stats.isDirectory())
+        return true;
+      return path.split(platformPath.sep).some((dir) => dir === ".git");
+    },
+    ignorePermissionErrors: true,
+    usePolling: USE_POLLING,
+    interval: testOverrides?.chokidarInterval ?? POLLING_INTERVAL_MS,
+    atomic: true
+  });
+  watcher.on("add", handleChange);
+  watcher.on("change", handleChange);
+  watcher.on("unlink", handleChange);
+  unregisterCleanup = registerCleanup(async () => {
+    await dispose();
+  });
+}
+function dispose() {
+  disposed = true;
+  if (unregisterCleanup) {
+    unregisterCleanup();
+    unregisterCleanup = null;
+  }
+  let closePromise = Promise.resolve();
+  if (watcher) {
+    closePromise = watcher.close();
+    watcher = null;
+  }
+  if (reloadTimer) {
+    clearTimeout(reloadTimer);
+    reloadTimer = null;
+  }
+  pendingChangedPaths.clear();
+  skillsChanged.clear();
+  return closePromise;
+}
+var subscribe = skillsChanged.subscribe;
+async function getWatchablePaths() {
+  const fs = getFsImplementation();
+  const paths = [];
+  const userSkillsPath = getSkillsPath("userSettings", "skills");
+  if (userSkillsPath) {
+    try {
+      await fs.stat(userSkillsPath);
+      paths.push(userSkillsPath);
+    } catch {}
+  }
+  const userCommandsPath = getSkillsPath("userSettings", "commands");
+  if (userCommandsPath) {
+    try {
+      await fs.stat(userCommandsPath);
+      paths.push(userCommandsPath);
+    } catch {}
+  }
+  const projectSkillsPath = getSkillsPath("projectSettings", "skills");
+  if (projectSkillsPath) {
+    try {
+      const absolutePath = platformPath.resolve(projectSkillsPath);
+      await fs.stat(absolutePath);
+      paths.push(absolutePath);
+    } catch {}
+  }
+  const projectCommandsPath = getSkillsPath("projectSettings", "commands");
+  if (projectCommandsPath) {
+    try {
+      const absolutePath = platformPath.resolve(projectCommandsPath);
+      await fs.stat(absolutePath);
+      paths.push(absolutePath);
+    } catch {}
+  }
+  for (const dir of getAdditionalDirectoriesForClaudeMd()) {
+    const additionalSkillsPath = platformPath.join(dir, ".claude", "skills");
+    try {
+      await fs.stat(additionalSkillsPath);
+      paths.push(additionalSkillsPath);
+    } catch {}
+  }
+  return paths;
+}
+function handleChange(path) {
+  logForDebugging(`Detected skill change: ${path}`);
+  logEvent("tengu_skill_file_changed", {
+    source: "chokidar"
+  });
+  scheduleReload(path);
+}
+function scheduleReload(changedPath) {
+  pendingChangedPaths.add(changedPath);
+  if (reloadTimer)
+    clearTimeout(reloadTimer);
+  reloadTimer = setTimeout(async () => {
+    reloadTimer = null;
+    const paths = [...pendingChangedPaths];
+    pendingChangedPaths.clear();
+    const results = await executeConfigChangeHooks("skills", paths[0]);
+    if (hasBlockingResult(results)) {
+      logForDebugging(`ConfigChange hook blocked skill reload (${paths.length} paths)`);
+      return;
+    }
+    clearSkillCaches();
+    clearCommandsCache();
+    resetSentSkillNames();
+    skillsChanged.emit();
+  }, testOverrides?.reloadDebounce ?? RELOAD_DEBOUNCE_MS);
+}
+async function resetForTesting(overrides) {
+  if (watcher) {
+    await watcher.close();
+    watcher = null;
+  }
+  if (reloadTimer) {
+    clearTimeout(reloadTimer);
+    reloadTimer = null;
+  }
+  pendingChangedPaths.clear();
+  skillsChanged.clear();
+  initialized = false;
+  disposed = false;
+  testOverrides = overrides ?? null;
+}
+var skillChangeDetector = {
+  initialize,
+  dispose,
+  subscribe,
+  resetForTesting
+};
+
+// src/utils/sessionRestore.ts
+init_state();
+init_systemPromptSections();
+init_cost_tracker();
+init_loadAgentsDir();
+init_constants();
+init_ids();
+import { dirname } from "path";
+init_claudemd();
+init_commitAttribution();
+init_concurrentSessions();
+init_cwd();
+init_debug();
+init_fileHistory();
+init_messages();
+init_model();
+init_plans();
+init_Shell();
+init_sessionStorage();
+init_tasks();
+init_types();
+init_worktree();
+function extractTodosFromTranscript(messages) {
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg?.type !== "assistant")
+      continue;
+    const toolUse = msg.message.content.find((block) => block.type === "tool_use" && block.name === TODO_WRITE_TOOL_NAME);
+    if (!toolUse || toolUse.type !== "tool_use")
+      continue;
+    const input = toolUse.input;
+    if (input === null || typeof input !== "object")
+      return [];
+    const parsed = TodoListSchema().safeParse(input.todos);
+    return parsed.success ? parsed.data : [];
+  }
+  return [];
+}
+function restoreSessionStateFromLog(result, setAppState) {
+  if (result.fileHistorySnapshots && result.fileHistorySnapshots.length > 0) {
+    fileHistoryRestoreStateFromLog(result.fileHistorySnapshots, (newState) => {
+      setAppState((prev) => ({ ...prev, fileHistory: newState }));
+    });
+  }
+  if (false) {}
+  if (false) {}
+  if (!isTodoV2Enabled() && result.messages && result.messages.length > 0) {
+    const todos = extractTodosFromTranscript(result.messages);
+    if (todos.length > 0) {
+      const agentId = getSessionId();
+      setAppState((prev) => ({
+        ...prev,
+        todos: { ...prev.todos, [agentId]: todos }
+      }));
+    }
+  }
+}
+function computeRestoredAttributionState(result) {
+  if (false) {}
+  return;
+}
+function computeStandaloneAgentContext(agentName, agentColor) {
+  if (!agentName && !agentColor) {
+    return;
+  }
+  return {
+    name: agentName ?? "",
+    color: agentColor === "default" ? undefined : agentColor
+  };
+}
+function restoreAgentFromSession(agentSetting, currentAgentDefinition, agentDefinitions) {
+  if (currentAgentDefinition) {
+    return { agentDefinition: currentAgentDefinition, agentType: undefined };
+  }
+  if (!agentSetting) {
+    setMainThreadAgentType(undefined);
+    return { agentDefinition: undefined, agentType: undefined };
+  }
+  const resumedAgent = agentDefinitions.activeAgents.find((agent) => agent.agentType === agentSetting);
+  if (!resumedAgent) {
+    logForDebugging(`Resumed session had agent "${agentSetting}" but it is no longer available. Using default behavior.`);
+    setMainThreadAgentType(undefined);
+    return { agentDefinition: undefined, agentType: undefined };
+  }
+  setMainThreadAgentType(resumedAgent.agentType);
+  if (!getMainLoopModelOverride() && resumedAgent.model && resumedAgent.model !== "inherit") {
+    setMainLoopModelOverride(parseUserSpecifiedModel(resumedAgent.model));
+  }
+  return { agentDefinition: resumedAgent, agentType: resumedAgent.agentType };
+}
+async function refreshAgentDefinitionsForModeSwitch(modeWasSwitched, currentCwd, cliAgents, currentAgentDefinitions) {
+  if (true) {
+    return currentAgentDefinitions;
+  }
+  getAgentDefinitionsWithOverrides.cache.clear?.();
+  const freshAgentDefs = await getAgentDefinitionsWithOverrides(currentCwd);
+  const freshAllAgents = [...freshAgentDefs.allAgents, ...cliAgents];
+  return {
+    ...freshAgentDefs,
+    allAgents: freshAllAgents,
+    activeAgents: getActiveAgentsFromList(freshAllAgents)
+  };
+}
+function restoreWorktreeForResume(worktreeSession) {
+  const fresh = getCurrentWorktreeSession();
+  if (fresh) {
+    saveWorktreeState(fresh);
+    return;
+  }
+  if (!worktreeSession)
+    return;
+  try {
+    process.chdir(worktreeSession.worktreePath);
+  } catch {
+    saveWorktreeState(null);
+    return;
+  }
+  setCwd(worktreeSession.worktreePath);
+  setOriginalCwd(getCwd());
+  restoreWorktreeSession(worktreeSession);
+  clearMemoryFileCaches();
+  clearSystemPromptSections();
+  getPlansDirectory.cache.clear?.();
+}
+function exitRestoredWorktree() {
+  const current = getCurrentWorktreeSession();
+  if (!current)
+    return;
+  restoreWorktreeSession(null);
+  clearMemoryFileCaches();
+  clearSystemPromptSections();
+  getPlansDirectory.cache.clear?.();
+  try {
+    process.chdir(current.originalCwd);
+  } catch {
+    return;
+  }
+  setCwd(current.originalCwd);
+  setOriginalCwd(getCwd());
+}
+async function processResumedConversation(result, opts, context) {
+  let modeWarning;
+  if (false) {}
+  if (!opts.forkSession) {
+    const sid = opts.sessionIdOverride ?? result.sessionId;
+    if (sid) {
+      switchSession(asSessionId(sid), opts.transcriptPath ? dirname(opts.transcriptPath) : null);
+      await renameRecordingForSession();
+      await resetSessionFilePointer();
+      restoreCostStateForSession(sid);
+    }
+  } else if (result.contentReplacements?.length) {
+    await recordContentReplacement(result.contentReplacements);
+  }
+  restoreSessionMetadata(opts.forkSession ? { ...result, worktreeSession: undefined } : result);
+  if (!opts.forkSession) {
+    restoreWorktreeForResume(result.worktreeSession);
+    adoptResumedSessionFile();
+  }
+  if (false) {}
+  const { agentDefinition: restoredAgent, agentType: resumedAgentType } = restoreAgentFromSession(result.agentSetting, context.mainThreadAgentDefinition, context.agentDefinitions);
+  if (false) {}
+  const restoredAttribution = opts.includeAttribution ? computeRestoredAttributionState(result) : undefined;
+  const standaloneAgentContext = computeStandaloneAgentContext(result.agentName, result.agentColor);
+  updateSessionName(result.agentName);
+  const refreshedAgentDefs = await refreshAgentDefinitionsForModeSwitch(!!modeWarning, context.currentCwd, context.cliAgents, context.agentDefinitions);
+  return {
+    messages: result.messages,
+    fileHistorySnapshots: result.fileHistorySnapshots,
+    contentReplacements: result.contentReplacements,
+    agentName: result.agentName,
+    agentColor: result.agentColor === "default" ? undefined : result.agentColor,
+    restoredAgentDef: restoredAgent,
+    initialState: {
+      ...context.initialState,
+      ...resumedAgentType && { agent: resumedAgentType },
+      ...restoredAttribution && { attribution: restoredAttribution },
+      ...standaloneAgentContext && { standaloneAgentContext },
+      agentDefinitions: refreshedAgentDefs
+    }
+  };
+}
+
+export { skillChangeDetector, restoreSessionStateFromLog, computeStandaloneAgentContext, restoreAgentFromSession, restoreWorktreeForResume, exitRestoredWorktree, processResumedConversation };