@caspian2026/agent-sdk 0.0.2

package/dist/chunk-ysanv95x.js

@@ -0,0 +1,225 @@
+// @bun
+import {
+  gt,
+  init_semver
+} from "./chunk-ps49ymvj.js";
+import {
+  getGlobalConfig,
+  init_config,
+  saveGlobalConfig
+} from "./chunk-tp2jxmcx.js";
+import {
+  require_semver
+} from "./chunk-0vkfrmqm.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-1nk93fqz.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-phd1qfpc.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-jaaxk89e.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-k8vp0atq.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-55raexh7.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 = "2.1.888") {
+  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 = "2.1.888") {
+  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-yvtzznds.js

@@ -0,0 +1,63 @@
+// @bun
+import {
+  TMUX_COMMAND,
+  init_constants
+} from "./chunk-4jm600zv.js";
+import {
+  env,
+  init_env
+} from "./chunk-s3hsqf80.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-70eey1nh.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-yyex5gsf.js

@@ -0,0 +1,269 @@
+// @bun
+import {
+  AlternateScreen,
+  Ansi,
+  Box_default,
+  Button_default,
+  Byline,
+  CLEAR_ITERM2_PROGRESS,
+  CLEAR_TAB_STATUS,
+  CLEAR_TERMINAL_TITLE,
+  ClickEvent,
+  DBP,
+  DFE,
+  DISABLE_KITTY_KEYBOARD,
+  DISABLE_MODIFY_OTHER_KEYS,
+  DISABLE_MOUSE_TRACKING,
+  DOUBLE_PRESS_TIMEOUT_MS,
+  Dialog,
+  Divider,
+  ENABLE_MOUSE_TRACKING,
+  ENTER_ALT_SCREEN,
+  EXIT_ALT_SCREEN,
+  Event,
+  EventEmitter,
+  FocusEvent,
+  FocusManager,
+  FuzzyPicker,
+  HIDE_CURSOR,
+  Ink,
+  InputEvent,
+  KeybindingProvider,
+  KeybindingSetup,
+  KeyboardEvent,
+  KeyboardShortcutHint,
+  Link,
+  ListItem,
+  LoadingState,
+  Newline,
+  NoSelect,
+  Pane,
+  ProgressBar,
+  Ratchet,
+  RawAnsi,
+  SHOW_CURSOR,
+  ScrollBox_default,
+  SearchBox,
+  Spacer,
+  StatusIcon,
+  Tab,
+  Tabs,
+  TerminalFocusEvent,
+  TerminalSizeContext,
+  TerminalWriteProvider,
+  Text,
+  TextHoverColorContext,
+  ThemeProvider,
+  ThemedBox_default,
+  ThemedText,
+  applyColor,
+  applyTextStyles,
+  chordToDisplayString,
+  chordToString,
+  clamp,
+  color,
+  colorize,
+  createRoot,
+  getBindingDisplayText,
+  getClipboardPath,
+  getKeyName,
+  getTerminalFocusState,
+  getTerminalFocused,
+  hasCursorUpViewportYankBug,
+  init_src,
+  instances_default,
+  isSynchronizedOutputSupported,
+  isXtermJs,
+  keystrokeToDisplayString,
+  keystrokeToString,
+  keystrokesEqual,
+  matchesBinding,
+  matchesKeystroke,
+  measure_element_default,
+  parseBindings,
+  parseChord,
+  parseKeystroke,
+  renderSync,
+  render_border_default,
+  resolveKey,
+  resolveKeyWithChordState,
+  root_default,
+  setClipboard,
+  stringWidth,
+  styles_default,
+  subscribeTerminalFocus,
+  supportsHyperlinks,
+  supportsTabStatus,
+  useAnimationFrame,
+  useAnimationTimer,
+  useDeclaredCursor,
+  useDoublePress,
+  useHasSelection,
+  useInterval1 as useInterval,
+  useKeybinding,
+  useKeybindingContext,
+  useKeybindings,
+  useMinDisplayTime,
+  useOptionalKeybindingContext,
+  usePreviewTheme,
+  useRegisterKeybindingContext,
+  useSearchHighlight,
+  useSelection,
+  useTabHeaderFocus,
+  useTabStatus,
+  useTabsWidth,
+  useTerminalFocus,
+  useTerminalNotification,
+  useTerminalSize,
+  useTerminalTitle,
+  useTerminalViewport,
+  useTheme,
+  useThemeSetting,
+  useTimeout,
+  use_app_default,
+  use_input_default,
+  use_stdin_default,
+  wrapAnsi,
+  wrapForMultiplexer,
+  wrapText,
+  writeDiffToTerminal
+} from "./chunk-c7jwbe76.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-7sgtxrsc.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-qajrkk97.js";
+import"./chunk-07069jq1.js";
+import"./chunk-d4mdda98.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-netzwgv1.js";
+import"./chunk-qp2qdcda.js";
+init_src();
+
+export {
+  writeDiffToTerminal,
+  root_default as wrappedRender,
+  wrapText,
+  wrapForMultiplexer,
+  wrapAnsi,
+  useTimeout,
+  useThemeSetting,
+  useTheme,
+  useTerminalViewport,
+  useTerminalTitle,
+  useTerminalSize,
+  useTerminalNotification,
+  useTerminalFocus,
+  useTabsWidth,
+  useTabStatus,
+  useTabHeaderFocus,
+  use_stdin_default as useStdin,
+  useSelection,
+  useSearchHighlight,
+  useRegisterKeybindingContext,
+  usePreviewTheme,
+  useOptionalKeybindingContext,
+  useMinDisplayTime,
+  useKeybindings,
+  useKeybindingContext,
+  useKeybinding,
+  useInterval,
+  use_input_default as useInput,
+  useHasSelection,
+  useDoublePress,
+  useDeclaredCursor,
+  use_app_default as useApp,
+  useAnimationTimer,
+  useAnimationFrame,
+  supportsTabStatus,
+  supportsHyperlinks,
+  subscribeTerminalFocus,
+  styles_default as styles,
+  stringWidth,
+  setClipboard,
+  resolveKeyWithChordState,
+  resolveKey,
+  renderSync,
+  render_border_default as renderBorder,
+  parseKeystroke,
+  parseChord,
+  parseBindings,
+  measure_element_default as measureElement,
+  matchesKeystroke,
+  matchesBinding,
+  keystrokesEqual,
+  keystrokeToString,
+  keystrokeToDisplayString,
+  isXtermJs,
+  isSynchronizedOutputSupported,
+  instances_default as instances,
+  hasCursorUpViewportYankBug,
+  getTerminalFocused,
+  getTerminalFocusState,
+  getKeyName,
+  getClipboardPath,
+  getBindingDisplayText,
+  createRoot,
+  colorize,
+  color,
+  clamp,
+  chordToString,
+  chordToDisplayString,
+  applyTextStyles,
+  applyColor,
+  ThemeProvider,
+  TextHoverColorContext,
+  ThemedText as Text,
+  TerminalWriteProvider,
+  TerminalSizeContext,
+  TerminalFocusEvent,
+  Tabs,
+  Tab,
+  StatusIcon,
+  Spacer,
+  SearchBox,
+  ScrollBox_default as ScrollBox,
+  SHOW_CURSOR,
+  RawAnsi,
+  Ratchet,
+  ProgressBar,
+  Pane,
+  NoSelect,
+  Newline,
+  LoadingState,
+  ListItem,
+  Link,
+  KeyboardShortcutHint,
+  KeyboardEvent,
+  KeybindingSetup,
+  KeybindingProvider,
+  InputEvent,
+  Ink,
+  HIDE_CURSOR,
+  FuzzyPicker,
+  FocusManager,
+  FocusEvent,
+  EventEmitter,
+  Event,
+  EXIT_ALT_SCREEN,
+  ENTER_ALT_SCREEN,
+  ENABLE_MOUSE_TRACKING,
+  Divider,
+  Dialog,
+  DOUBLE_PRESS_TIMEOUT_MS,
+  DISABLE_MOUSE_TRACKING,
+  DISABLE_MODIFY_OTHER_KEYS,
+  DISABLE_KITTY_KEYBOARD,
+  DFE,
+  DBP,
+  ClickEvent,
+  CLEAR_TERMINAL_TITLE,
+  CLEAR_TAB_STATUS,
+  CLEAR_ITERM2_PROGRESS,
+  Byline,
+  Button_default as Button,
+  ThemedBox_default as Box,
+  Text as BaseText,
+  Box_default as BaseBox,
+  Ansi,
+  AlternateScreen
+};