@redscope-ai/redscope 1.0.0

package/dist/chunk-td2gsz7s.js

@@ -0,0 +1,225 @@
+// @bun
+import {
+  gt,
+  init_semver
+} from "./chunk-4spgkgr3.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-eemjb825.js";
+import {
+  require_semver
+} from "./chunk-6x35ffpx.js";
+import {
+  getPreferredUserConfigChildPath,
+  getUserConfigChildPaths,
+  init_errors,
+  init_log,
+  init_privacyLevel,
+  init_redscopeCompat,
+  isEssentialTrafficOnly,
+  logError,
+  toError
+} from "./chunk-s3hafnk3.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-9h9k5vz3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-pecy49yr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/releaseNotes.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+function getChangelogCachePath() {
+  return getPreferredUserConfigChildPath("cache", "changelog.md");
+}
+function getChangelogCachePaths() {
+  return getUserConfigChildPaths("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;
+  }
+  for (const cachePath of getChangelogCachePaths()) {
+    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.0") {
+  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.0") {
+  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_errors();
+  init_log();
+  init_privacyLevel();
+  init_redscopeCompat();
+  init_semver();
+  import_semver = __toESM(require_semver(), 1);
+});
+
+export { CHANGELOG_URL, migrateChangelogFromConfig, fetchAndStoreChangelog, getStoredChangelog, getStoredChangelogFromMemory, parseChangelog, getAllReleaseNotes, checkForReleaseNotes, checkForReleaseNotesSync, init_releaseNotes };

package/dist/chunk-tenvxbyh.js

@@ -0,0 +1,20 @@
+// @bun
+import {
+  credentialsTreatedAsExpired,
+  credentialsWillNeedRefresh,
+  defaultProvider,
+  init_dist_es
+} from "./chunk-mjnr5erm.js";
+import"./chunk-62fjkf5q.js";
+import"./chunk-rp8whpb3.js";
+import"./chunk-ees8xdhd.js";
+import"./chunk-1aer7c78.js";
+import"./chunk-qgzn3qps.js";
+import"./chunk-hhsxm2yr.js";
+init_dist_es();
+
+export {
+  defaultProvider,
+  credentialsWillNeedRefresh,
+  credentialsTreatedAsExpired
+};

package/dist/chunk-texg4qqt.js

@@ -0,0 +1,317 @@
+// @bun
+import {
+  ERROR_MESSAGE_INCOMPLETE_RESPONSE,
+  ERROR_MESSAGE_NOT_ENOUGH_MESSAGES,
+  ERROR_MESSAGE_USER_ABORT,
+  buildEffectiveSystemPrompt,
+  compactConversation,
+  executePreCompactHooks,
+  getMessagesAfterCompactBoundary,
+  getShortcutDisplay,
+  getSystemContext,
+  getSystemPrompt,
+  getUpgradeMessage,
+  getUserContext,
+  init_compact,
+  init_compactWarningState,
+  init_context,
+  init_contextWindowUpgradeCheck,
+  init_hooks1 as init_hooks,
+  init_messages1 as init_messages,
+  init_microCompact,
+  init_postCompactCleanup,
+  init_promptCacheBreakDetection,
+  init_prompts1 as init_prompts,
+  init_sessionMemoryCompact,
+  init_sessionMemoryUtils,
+  init_shortcutFormat,
+  init_systemPrompt,
+  mergeHookInstructions,
+  microcompactMessages,
+  notifyCompaction,
+  runPostCompactCleanup,
+  setLastSummarizedMessageId,
+  suppressCompactWarning,
+  trySessionMemoryCompaction
+} from "./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import"./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import {
+  init_source,
+  source_default
+} from "./chunk-2g0ytd9d.js";
+import"./chunk-de0qnnf7.js";
+import"./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import"./chunk-hzmzwte2.js";
+import"./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import {
+  hasExactErrorMessage,
+  init_errors,
+  init_log,
+  logError
+} from "./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import {
+  init_state,
+  markPostCompaction
+} from "./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/compact/compact.ts
+async function compactViaReactive(messages, context, customInstructions, reactive) {
+  context.onCompactProgress?.({
+    type: "hooks_start",
+    hookType: "pre_compact"
+  });
+  context.setSDKStatus?.("compacting");
+  try {
+    const [hookResult, cacheSafeParams] = await Promise.all([
+      executePreCompactHooks({ trigger: "manual", customInstructions: customInstructions || null }, context.abortController.signal),
+      getCacheSharingParams(context, messages)
+    ]);
+    const mergedInstructions = mergeHookInstructions(customInstructions, hookResult.newCustomInstructions);
+    context.setStreamMode?.("requesting");
+    context.setResponseLength?.(() => 0);
+    context.onCompactProgress?.({ type: "compact_start" });
+    const outcome = await reactive.reactiveCompactOnPromptTooLong(messages, cacheSafeParams, { customInstructions: mergedInstructions, trigger: "manual" });
+    if (!outcome.ok) {
+      switch (outcome.reason) {
+        case "too_few_groups":
+          throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
+        case "aborted":
+          throw new Error(ERROR_MESSAGE_USER_ABORT);
+        case "exhausted":
+        case "error":
+        case "media_unstrippable":
+          throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE);
+      }
+    }
+    setLastSummarizedMessageId(undefined);
+    runPostCompactCleanup();
+    suppressCompactWarning();
+    getUserContext.cache.clear?.();
+    const combinedMessage = [hookResult.userDisplayMessage, outcome.result.userDisplayMessage].filter(Boolean).join(`
+`) || undefined;
+    return {
+      type: "compact",
+      compactionResult: {
+        ...outcome.result,
+        userDisplayMessage: combinedMessage
+      },
+      displayText: buildDisplayText(context, combinedMessage)
+    };
+  } finally {
+    context.setStreamMode?.("requesting");
+    context.setResponseLength?.(() => 0);
+    context.onCompactProgress?.({ type: "compact_end" });
+    context.setSDKStatus?.("");
+  }
+}
+function buildDisplayText(context, userDisplayMessage) {
+  const upgradeMessage = getUpgradeMessage("tip");
+  const expandShortcut = getShortcutDisplay("app:toggleTranscript", "Global", "ctrl+o");
+  const dimmed = [
+    ...context.options.verbose ? [] : [`(${expandShortcut} to see full summary)`],
+    ...userDisplayMessage ? [userDisplayMessage] : [],
+    ...upgradeMessage ? [upgradeMessage] : []
+  ];
+  return source_default.dim("Compacted " + dimmed.join(`
+`));
+}
+async function getCacheSharingParams(context, forkContextMessages) {
+  const appState = context.getAppState();
+  const defaultSysPrompt = await getSystemPrompt(context.options.tools, context.options.mainLoopModel, Array.from(appState.toolPermissionContext.additionalWorkingDirectories.keys()), context.options.mcpClients);
+  const systemPrompt = buildEffectiveSystemPrompt({
+    mainThreadAgentDefinition: undefined,
+    toolUseContext: context,
+    customSystemPrompt: context.options.customSystemPrompt,
+    defaultSystemPrompt: defaultSysPrompt,
+    appendSystemPrompt: context.options.appendSystemPrompt
+  });
+  const [userContext, systemContext] = await Promise.all([
+    getUserContext(),
+    getSystemContext()
+  ]);
+  return {
+    systemPrompt,
+    userContext,
+    systemContext,
+    toolUseContext: context,
+    forkContextMessages
+  };
+}
+var reactiveCompact = null, call = async (args, context) => {
+  const { abortController } = context;
+  let { messages } = context;
+  messages = getMessagesAfterCompactBoundary(messages);
+  if (messages.length === 0) {
+    throw new Error("No messages to compact");
+  }
+  const customInstructions = args.trim();
+  try {
+    if (!customInstructions) {
+      const sessionMemoryResult = await trySessionMemoryCompaction(messages, context.agentId);
+      if (sessionMemoryResult) {
+        getUserContext.cache.clear?.();
+        runPostCompactCleanup();
+        if (true) {
+          notifyCompaction(context.options.querySource ?? "compact", context.agentId);
+        }
+        markPostCompaction();
+        suppressCompactWarning();
+        return {
+          type: "compact",
+          compactionResult: sessionMemoryResult,
+          displayText: buildDisplayText(context)
+        };
+      }
+    }
+    if (reactiveCompact?.isReactiveOnlyMode()) {
+      return await compactViaReactive(messages, context, customInstructions, reactiveCompact);
+    }
+    const microcompactResult = await microcompactMessages(messages, context);
+    const messagesForCompact = microcompactResult.messages;
+    const result = await compactConversation(messagesForCompact, context, await getCacheSharingParams(context, messagesForCompact), false, customInstructions, false);
+    setLastSummarizedMessageId(undefined);
+    suppressCompactWarning();
+    getUserContext.cache.clear?.();
+    runPostCompactCleanup();
+    return {
+      type: "compact",
+      compactionResult: result,
+      displayText: buildDisplayText(context, result.userDisplayMessage)
+    };
+  } catch (error) {
+    if (abortController.signal.aborted) {
+      throw new Error("Compaction canceled.");
+    } else if (hasExactErrorMessage(error, ERROR_MESSAGE_NOT_ENOUGH_MESSAGES)) {
+      throw new Error(ERROR_MESSAGE_NOT_ENOUGH_MESSAGES);
+    } else if (hasExactErrorMessage(error, ERROR_MESSAGE_INCOMPLETE_RESPONSE)) {
+      throw new Error(ERROR_MESSAGE_INCOMPLETE_RESPONSE);
+    } else {
+      logError(error);
+      throw new Error(`Error during compaction: ${error}`);
+    }
+  }
+};
+var init_compact2 = __esm(() => {
+  init_source();
+  init_state();
+  init_prompts();
+  init_context();
+  init_shortcutFormat();
+  init_promptCacheBreakDetection();
+  init_compact();
+  init_compactWarningState();
+  init_microCompact();
+  init_postCompactCleanup();
+  init_sessionMemoryCompact();
+  init_sessionMemoryUtils();
+  init_errors();
+  init_hooks();
+  init_log();
+  init_messages();
+  init_contextWindowUpgradeCheck();
+  init_systemPrompt();
+});
+init_compact2();
+
+export {
+  call
+};