@redscope-ai/redscope 1.0.0

package/dist/chunk-49wv03ts.js

@@ -0,0 +1,232 @@
+// @bun
+import {
+  clearSessionCaches,
+  init_caches
+} from "./chunk-85tcn547.js";
+import {
+  asAgentId,
+  clearAllPlanSlugs,
+  clearSessionMetadata,
+  evictTaskOutput,
+  executeSessionEndHooks,
+  getAgentTranscriptPath,
+  getCurrentWorktreeSession,
+  getReplBridgeHandle,
+  getSessionEndHookTimeoutMs,
+  initTaskOutputAsSymlink,
+  init_LocalAgentTask,
+  init_Shell,
+  init_diskOutput,
+  init_guards,
+  init_hooks1 as init_hooks,
+  init_ids,
+  init_plans,
+  init_replBridgeHandle,
+  init_sessionStart,
+  init_sessionStorage,
+  init_types1 as init_types,
+  init_worktree,
+  isInProcessTeammateTask,
+  isLocalAgentTask,
+  isLocalShellTask,
+  processSessionStartHooks,
+  resetSessionFilePointer,
+  saveWorktreeState,
+  setCwd
+} from "./chunk-gmdy2w3z.js";
+import {
+  exports_proactive,
+  init_proactive
+} from "./chunk-nzxfj0gq.js";
+import {
+  createEmptyAttributionState,
+  init_commitAttribution
+} from "./chunk-w4p5t920.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import {
+  init_log,
+  logError
+} from "./chunk-s3hafnk3.js";
+import {
+  getLastMainRequestId,
+  getOriginalCwd,
+  getSessionId,
+  init_state,
+  regenerateSessionId,
+  resetCostState,
+  setLastAPIRequest,
+  setLastAPIRequestMessages,
+  setLastClassifierRequests
+} from "./chunk-9h9k5vz3.js";
+import {
+  __esm,
+  __toCommonJS
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/clear/conversation.ts
+import { randomUUID } from "crypto";
+function notifyRemoteConversationCleared() {
+  const handle = getReplBridgeHandle();
+  if (!handle)
+    return;
+  handle.markTranscriptReset?.();
+  const message = {
+    type: "status",
+    subtype: "status",
+    status: "conversation_cleared",
+    message: "conversation_cleared",
+    uuid: randomUUID()
+  };
+  handle.writeSdkMessages([message]);
+}
+async function clearConversation({
+  setMessages,
+  readFileState,
+  discoveredSkillNames,
+  loadedNestedMemoryPaths,
+  getAppState,
+  setAppState,
+  setConversationId
+}) {
+  const sessionEndTimeoutMs = getSessionEndHookTimeoutMs();
+  await executeSessionEndHooks("clear", {
+    getAppState,
+    setAppState,
+    signal: AbortSignal.timeout(sessionEndTimeoutMs),
+    timeoutMs: sessionEndTimeoutMs
+  });
+  const lastRequestId = getLastMainRequestId();
+  if (lastRequestId) {
+    logEvent("tengu_cache_eviction_hint", {
+      scope: "conversation_clear",
+      last_request_id: lastRequestId
+    });
+  }
+  const preservedAgentIds = new Set;
+  const preservedLocalAgents = [];
+  const shouldKillTask = (task) => ("isBackgrounded" in task) && task.isBackgrounded === false;
+  if (getAppState) {
+    for (const task of Object.values(getAppState().tasks)) {
+      if (shouldKillTask(task))
+        continue;
+      if (isLocalAgentTask(task)) {
+        preservedAgentIds.add(task.agentId);
+        preservedLocalAgents.push(task);
+      } else if (isInProcessTeammateTask(task)) {
+        preservedAgentIds.add(task.identity.agentId);
+      }
+    }
+  }
+  setMessages(() => []);
+  notifyRemoteConversationCleared();
+  if (true) {
+    const { setContextBlocked } = (init_proactive(), __toCommonJS(exports_proactive));
+    setContextBlocked(false);
+  }
+  if (setConversationId) {
+    setConversationId(randomUUID());
+  }
+  clearSessionCaches(preservedAgentIds);
+  setLastAPIRequest(null);
+  setLastAPIRequestMessages(null);
+  setLastClassifierRequests(null);
+  resetCostState();
+  setCwd(getOriginalCwd());
+  readFileState.clear();
+  discoveredSkillNames?.clear();
+  loadedNestedMemoryPaths?.clear();
+  if (setAppState) {
+    setAppState((prev) => {
+      const nextTasks = {};
+      for (const [taskId, task] of Object.entries(prev.tasks)) {
+        if (!shouldKillTask(task)) {
+          nextTasks[taskId] = task;
+          continue;
+        }
+        try {
+          if (task.status === "running") {
+            if (isLocalShellTask(task)) {
+              task.shellCommand?.kill();
+              task.shellCommand?.cleanup();
+              if (task.cleanupTimeoutId) {
+                clearTimeout(task.cleanupTimeoutId);
+              }
+            }
+            if ("abortController" in task) {
+              task.abortController?.abort();
+            }
+            if ("unregisterCleanup" in task) {
+              task.unregisterCleanup?.();
+            }
+          }
+        } catch (error) {
+          logError(error);
+        }
+        evictTaskOutput(taskId);
+      }
+      return {
+        ...prev,
+        tasks: nextTasks,
+        attribution: createEmptyAttributionState(),
+        standaloneAgentContext: undefined,
+        fileHistory: {
+          snapshots: [],
+          trackedFiles: new Set,
+          snapshotSequence: 0
+        },
+        mcp: {
+          clients: [],
+          tools: [],
+          commands: [],
+          resources: {},
+          pluginReconnectKey: prev.mcp.pluginReconnectKey
+        }
+      };
+    });
+  }
+  clearAllPlanSlugs();
+  clearSessionMetadata();
+  regenerateSessionId({ setCurrentAsParent: true });
+  if (process.env.USER_TYPE === "ant" && process.env.CLAUDE_CODE_SESSION_ID) {
+    process.env.CLAUDE_CODE_SESSION_ID = getSessionId();
+  }
+  await resetSessionFilePointer();
+  for (const task of preservedLocalAgents) {
+    if (task.status !== "running")
+      continue;
+    initTaskOutputAsSymlink(task.id, getAgentTranscriptPath(asAgentId(task.agentId)));
+  }
+  if (false) {}
+  const worktreeSession = getCurrentWorktreeSession();
+  if (worktreeSession) {
+    saveWorktreeState(worktreeSession);
+  }
+  const hookMessages = await processSessionStartHooks("clear");
+  if (hookMessages.length > 0) {
+    setMessages(() => hookMessages);
+  }
+}
+var init_conversation = __esm(() => {
+  init_replBridgeHandle();
+  init_state();
+  init_analytics();
+  init_types();
+  init_LocalAgentTask();
+  init_guards();
+  init_ids();
+  init_commitAttribution();
+  init_hooks();
+  init_log();
+  init_plans();
+  init_Shell();
+  init_sessionStart();
+  init_sessionStorage();
+  init_diskOutput();
+  init_worktree();
+  init_caches();
+});
+
+export { clearConversation, init_conversation };

package/dist/chunk-4a189mn2.js

@@ -0,0 +1,103 @@
+// @bun
+import {
+  AsyncDecompress,
+  AsyncDeflate,
+  AsyncGunzip,
+  AsyncGzip,
+  AsyncInflate,
+  AsyncUnzipInflate,
+  AsyncUnzlib,
+  AsyncZipDeflate,
+  AsyncZlib,
+  DecodeUTF8,
+  Decompress,
+  Deflate,
+  EncodeUTF8,
+  FlateErrorCode,
+  Gunzip,
+  Gzip,
+  Inflate,
+  Unzip,
+  UnzipInflate,
+  UnzipPassThrough,
+  Unzlib,
+  Zip,
+  ZipDeflate,
+  ZipPassThrough,
+  Zlib,
+  decompress,
+  decompressSync,
+  deflate,
+  deflateSync,
+  gunzip,
+  gunzipSync,
+  gzip,
+  gzipSync,
+  inflate,
+  inflateSync,
+  init_esm,
+  strFromU8,
+  strToU8,
+  unzip,
+  unzipSync,
+  unzlib,
+  unzlibSync,
+  zip,
+  zipSync,
+  zlib,
+  zlibSync
+} from "./chunk-xhj7g13b.js";
+import"./chunk-hhsxm2yr.js";
+init_esm();
+
+export {
+  zlibSync,
+  zlib,
+  zipSync,
+  zip,
+  unzlibSync,
+  unzlib,
+  unzipSync,
+  unzip,
+  strToU8,
+  strFromU8,
+  inflateSync,
+  inflate,
+  gzipSync,
+  gzip,
+  gunzipSync,
+  gunzip,
+  deflateSync,
+  deflate,
+  decompressSync,
+  decompress,
+  gzipSync as compressSync,
+  gzip as compress,
+  Zlib,
+  ZipPassThrough,
+  ZipDeflate,
+  Zip,
+  Unzlib,
+  UnzipPassThrough,
+  UnzipInflate,
+  Unzip,
+  Inflate,
+  Gzip,
+  Gunzip,
+  FlateErrorCode,
+  EncodeUTF8,
+  Deflate,
+  Decompress,
+  DecodeUTF8,
+  Gzip as Compress,
+  AsyncZlib,
+  AsyncZipDeflate,
+  AsyncUnzlib,
+  AsyncUnzipInflate,
+  AsyncInflate,
+  AsyncGzip,
+  AsyncGunzip,
+  AsyncDeflate,
+  AsyncDecompress,
+  AsyncGzip as AsyncCompress
+};

package/dist/chunk-4c4fmh7a.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/output-style/output-style.tsx
+async function call(onDone) {
+  onDone("/output-style has been deprecated. Use /config to change your output style, or set it in your settings file. Changes take effect on the next session.", { display: "system" });
+}
+var init_output_style = () => {};
+init_output_style();
+
+export {
+  call
+};

package/dist/chunk-4ct8dsj5.js

@@ -0,0 +1,49 @@
+// @bun
+import {
+  require_index_node_http,
+  require_src,
+  require_src1 as require_src2
+} from "./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-e3abfxpy.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.215.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/platform/node/OTLPTraceExporter.js
+var import_otlp_exporter_base, import_otlp_transformer, import_node_http, OTLPTraceExporter;
+var init_OTLPTraceExporter = __esm(() => {
+  import_otlp_exporter_base = __toESM(require_src(), 1);
+  import_otlp_transformer = __toESM(require_src2(), 1);
+  import_node_http = __toESM(require_index_node_http(), 1);
+  OTLPTraceExporter = class OTLPTraceExporter extends import_otlp_exporter_base.OTLPExporterBase {
+    constructor(config = {}) {
+      super(import_node_http.createOtlpHttpExportDelegate(import_node_http.convertLegacyHttpOptions(config, "TRACES", "v1/traces", {
+        "Content-Type": "application/x-protobuf"
+      }), import_otlp_transformer.ProtobufTraceSerializer));
+    }
+  };
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.215.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/platform/node/index.js
+var init_node = __esm(() => {
+  init_OTLPTraceExporter();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.215.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/platform/index.js
+var init_platform = __esm(() => {
+  init_node();
+});
+
+// node_modules/.bun/@opentelemetry+exporter-trace-otlp-proto@0.215.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-trace-otlp-proto/build/esm/index.js
+var init_esm = __esm(() => {
+  init_platform();
+});
+init_esm();
+
+export {
+  OTLPTraceExporter
+};

package/dist/chunk-4kqt1pm1.js

@@ -0,0 +1,100 @@
+// @bun
+import {
+  init_shellQuote,
+  quote
+} from "./chunk-rpmntgyh.js";
+import {
+  init_bundledMode,
+  isInBundledMode
+} from "./chunk-v4ypszbb.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/cliLaunch.ts
+import { spawn } from "child_process";
+function sanitizeExecArgv(raw) {
+  const result = [];
+  for (let i = 0;i < raw.length; i++) {
+    const arg = raw[i];
+    if (arg === "-d" || arg.startsWith("-d ") || arg.startsWith("-d\t")) {
+      result.push(arg);
+      if (arg === "-d" && i + 1 < raw.length) {
+        result.push(raw[++i]);
+      }
+      continue;
+    }
+    if (arg.startsWith("-d") && arg.includes(":")) {
+      result.push(arg);
+      continue;
+    }
+    if (arg === "--feature") {
+      result.push(arg);
+      if (i + 1 < raw.length) {
+        result.push(raw[++i]);
+      }
+      continue;
+    }
+    if (/^--inspect(-brk)?(=|$)/.test(arg)) {
+      result.push(arg);
+      continue;
+    }
+    if (arg.startsWith("--") && !arg.includes("=") && i + 1 < raw.length) {
+      if (isInBundledMode())
+        continue;
+      result.push(arg);
+      result.push(raw[++i]);
+      continue;
+    }
+    if (arg.startsWith("-") && !isInBundledMode()) {
+      result.push(arg);
+    }
+  }
+  return result;
+}
+function buildCliLaunch(cliArgs, opts) {
+  const baseEnv = opts?.env ?? process.env;
+  const args = isInBundledMode() || !SCRIPT_PATH ? [...BOOTSTRAP_ARGS, ...cliArgs] : [...BOOTSTRAP_ARGS, SCRIPT_PATH, ...cliArgs];
+  const env = { ...baseEnv };
+  if (IS_WINDOWS) {
+    if (process.env.CLAUDE_CODE_GIT_BASH_PATH && !env.CLAUDE_CODE_GIT_BASH_PATH) {
+      env.CLAUDE_CODE_GIT_BASH_PATH = process.env.CLAUDE_CODE_GIT_BASH_PATH;
+    }
+    if (process.env.SHELL && !env.SHELL) {
+      env.SHELL = process.env.SHELL;
+    }
+  }
+  return {
+    execPath: EXEC_PATH,
+    args,
+    env,
+    windowsHide: IS_WINDOWS
+  };
+}
+function spawnCli(spec, spawnOpts) {
+  return spawn(spec.execPath, spec.args, {
+    ...spawnOpts,
+    env: { ...spec.env, ...spawnOpts.env },
+    windowsHide: spec.windowsHide
+  });
+}
+function quoteCliLaunch(spec) {
+  return quote([spec.execPath, ...spec.args]);
+}
+function getBootstrapArgs() {
+  return BOOTSTRAP_ARGS;
+}
+function getScriptPath() {
+  return SCRIPT_PATH;
+}
+var BOOTSTRAP_ARGS, SCRIPT_PATH, EXEC_PATH, IS_WINDOWS;
+var init_cliLaunch = __esm(() => {
+  init_bundledMode();
+  init_shellQuote();
+  BOOTSTRAP_ARGS = Object.freeze(sanitizeExecArgv(process.execArgv));
+  SCRIPT_PATH = process.argv[1];
+  EXEC_PATH = process.execPath;
+  IS_WINDOWS = process.platform === "win32";
+});
+
+export { buildCliLaunch, spawnCli, quoteCliLaunch, getBootstrapArgs, getScriptPath, init_cliLaunch };