@redscope-ai/redscope 1.0.0

package/dist/chunk-3h59ttr5.js

@@ -0,0 +1,32 @@
+// @bun
+import {
+  init_partition,
+  partition_default
+} from "./chunk-ryqjc943.js";
+import {
+  init_tools,
+  init_uniqBy,
+  init_utils,
+  isMcpTool,
+  uniqBy_default
+} from "./chunk-gmdy2w3z.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/toolPool.ts
+function mergeAndFilterTools(initialTools, assembled, mode) {
+  const [mcp, builtIn] = partition_default(uniqBy_default([...initialTools, ...assembled], "name"), isMcpTool);
+  const byName = (a, b) => a.name.localeCompare(b.name);
+  const tools = [...builtIn.sort(byName), ...mcp.sort(byName)];
+  if (false) {}
+  return tools;
+}
+var init_toolPool = __esm(() => {
+  init_partition();
+  init_uniqBy();
+  init_tools();
+  init_utils();
+});
+
+export { mergeAndFilterTools, init_toolPool };

package/dist/chunk-3nk9q8dr.js

@@ -0,0 +1,154 @@
+// @bun
+import {
+  __esm,
+  __export
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/supports-color@10.2.2/node_modules/supports-color/index.js
+var exports_supports_color = {};
+__export(exports_supports_color, {
+  default: () => supports_color_default,
+  createSupportsColor: () => createSupportsColor
+});
+import process from "process";
+import os from "os";
+import tty from "tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+function envForceColor() {
+  if (!("FORCE_COLOR" in env)) {
+    return;
+  }
+  if (env.FORCE_COLOR === "true") {
+    return 1;
+  }
+  if (env.FORCE_COLOR === "false") {
+    return 0;
+  }
+  if (env.FORCE_COLOR.length === 0) {
+    return 1;
+  }
+  const level = Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+  if (![0, 1, 2, 3].includes(level)) {
+    return;
+  }
+  return level;
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
+  }
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
+    }
+    if (hasFlag("color=256")) {
+      return 2;
+    }
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process.platform === "win32") {
+    const osRelease = os.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+    }
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
+    }
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
+    }
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var env, flagForceColor, supportsColor, supports_color_default;
+var init_supports_color = __esm(() => {
+  ({ env } = process);
+  if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+    flagForceColor = 0;
+  } else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+    flagForceColor = 1;
+  }
+  supportsColor = {
+    stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+    stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+  };
+  supports_color_default = supportsColor;
+});
+
+export { createSupportsColor, exports_supports_color, init_supports_color };

package/dist/chunk-3prrxevm.js

@@ -0,0 +1,224 @@
+// @bun
+import {
+  Select,
+  init_CustomSelect
+} 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 {
+  init_settings1 as init_settings,
+  setLegacyClaudeSettingsCompatibility
+} from "./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 {
+  Dialog,
+  ThemedBox_default,
+  ThemedText,
+  init_src
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  init_analytics,
+  logEvent
+} from "./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"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./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 {
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/components/LegacyClaudeCompatibilityDialog.tsx
+init_analytics();
+init_src();
+init_settings();
+init_CustomSelect();
+var import_react = __toESM(require_react(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function LegacyClaudeCompatibilityDialog({ onDone }) {
+  const [error, setError] = import_react.default.useState(null);
+  import_react.default.useEffect(() => {
+    logEvent("tengu_legacy_claude_config_dialog_shown", {});
+  }, []);
+  function persistDecision(enabled) {
+    const { error: writeError } = setLegacyClaudeSettingsCompatibility(enabled, "user");
+    if (writeError) {
+      setError(writeError.message);
+      return;
+    }
+    logEvent("tengu_legacy_claude_config_dialog_decision", {
+      enabled
+    });
+    onDone();
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Set up RedScope configuration",
+    color: "warning",
+    onCancel: () => persistDecision(false),
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: "RedScope can either reuse your existing Claude settings, or stay separate and ask for RedScope API configuration during first-time setup."
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: [
+            "Reuse reads files such as ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              children: "~/.claude/settings.json"
+            }, undefined, false, undefined, this),
+            ",",
+            " ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              children: ".claude/settings.json"
+            }, undefined, false, undefined, this),
+            ", and ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              children: "CLAUDE.md"
+            }, undefined, false, undefined, this),
+            ". RedScope settings still take precedence. You can change this later with ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              children: "redscope config legacy-claude enable"
+            }, undefined, false, undefined, this),
+            " or",
+            " ",
+            /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+              bold: true,
+              children: "redscope config legacy-claude disable"
+            }, undefined, false, undefined, this),
+            "."
+          ]
+        }, undefined, true, undefined, this),
+        error && /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          color: "error",
+          children: [
+            "Failed to save setting: ",
+            error
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+          defaultValue: "disable",
+          defaultFocusValue: "disable",
+          options: [
+            {
+              label: "Configure RedScope separately",
+              value: "disable"
+            },
+            {
+              label: "Reuse existing Claude config",
+              value: "enable"
+            }
+          ],
+          onChange: (value) => persistDecision(value === "enable"),
+          onCancel: () => persistDecision(false)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+export {
+  LegacyClaudeCompatibilityDialog
+};

package/dist/chunk-3tv8p9xw.js

@@ -0,0 +1,127 @@
+// @bun
+import {
+  buildCliLaunch,
+  init_cliLaunch,
+  spawnCli
+} from "./chunk-4kqt1pm1.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/cli/bg/tail.ts
+import {
+  openSync,
+  readSync,
+  closeSync,
+  statSync,
+  watchFile,
+  unwatchFile,
+  createReadStream
+} from "fs";
+import { createInterface } from "readline";
+async function tailLog(logPath) {
+  let position = 0;
+  try {
+    const stat = statSync(logPath);
+    position = stat.size;
+    if (position > 0) {
+      const stream = createReadStream(logPath, { start: 0, end: position - 1 });
+      const rl = createInterface({ input: stream });
+      for await (const line of rl) {
+        process.stdout.write(line + `
+`);
+      }
+    }
+  } catch {}
+  console.log(`
+[tail] Watching for new output... (Ctrl+C to detach)
+`);
+  return new Promise((resolve) => {
+    const onSignal = () => {
+      unwatchFile(logPath);
+      process.removeListener("SIGINT", onSignal);
+      console.log(`
+[tail] Detached from session.`);
+      resolve();
+    };
+    process.on("SIGINT", onSignal);
+    watchFile(logPath, { interval: 300 }, () => {
+      try {
+        const stat = statSync(logPath);
+        if (stat.size <= position)
+          return;
+        const fd = openSync(logPath, "r");
+        try {
+          const buf = Buffer.alloc(stat.size - position);
+          readSync(fd, buf, 0, buf.length, position);
+          process.stdout.write(buf);
+          position = stat.size;
+        } finally {
+          closeSync(fd);
+        }
+      } catch {}
+    });
+  });
+}
+var init_tail = () => {};
+
+// src/cli/bg/engines/detached.ts
+import { closeSync as closeSync2, mkdirSync, openSync as openSync2 } from "fs";
+import { dirname } from "path";
+
+class DetachedEngine {
+  name = "detached";
+  supportsInteractiveInput = false;
+  async available() {
+    return true;
+  }
+  async start(opts) {
+    mkdirSync(dirname(opts.logPath), { recursive: true });
+    const logFd = openSync2(opts.logPath, "a");
+    const launch = buildCliLaunch(opts.args, {
+      env: {
+        ...opts.env,
+        CLAUDE_CODE_SESSION_KIND: "bg",
+        CLAUDE_CODE_SESSION_NAME: opts.sessionName,
+        CLAUDE_CODE_SESSION_LOG: opts.logPath
+      }
+    });
+    const child = spawnCli(launch, {
+      detached: true,
+      stdio: ["ignore", logFd, logFd],
+      cwd: opts.cwd
+    });
+    child.unref();
+    closeSync2(logFd);
+    const pid = child.pid ?? 0;
+    return {
+      pid,
+      sessionName: opts.sessionName,
+      logPath: opts.logPath,
+      engineUsed: "detached"
+    };
+  }
+  async attach(session) {
+    if (!session.logPath) {
+      throw new Error(`Session ${session.sessionId} has no log path.`);
+    }
+    await tailLog(session.logPath);
+  }
+}
+var init_detached = __esm(() => {
+  init_cliLaunch();
+  init_tail();
+});
+init_detached();
+
+export {
+  DetachedEngine
+};

package/dist/chunk-3txyekes.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  DANGEROUS_uncachedSystemPromptSection,
+  clearSystemPromptSections,
+  init_systemPromptSections,
+  resolveSystemPromptSections,
+  systemPromptSection
+} from "./chunk-2kcgxnvp.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-hhsxm2yr.js";
+init_systemPromptSections();
+
+export {
+  systemPromptSection,
+  resolveSystemPromptSections,
+  clearSystemPromptSections,
+  DANGEROUS_uncachedSystemPromptSection
+};

package/dist/chunk-3vfxjn7g.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  exitWithError,
+  init_process,
+  peekForStdinData,
+  registerProcessOutputErrorHandlers,
+  writeToStderr,
+  writeToStdout
+} from "./chunk-kb3758f7.js";
+import"./chunk-hhsxm2yr.js";
+init_process();
+
+export {
+  writeToStdout,
+  writeToStderr,
+  registerProcessOutputErrorHandlers,
+  peekForStdinData,
+  exitWithError
+};

package/dist/chunk-3w9sye8h.js

@@ -0,0 +1,81 @@
+// @bun
+import {
+  getRepoClassCached,
+  init_commitAttribution
+} from "./chunk-w4p5t920.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config
+} from "./chunk-eemjb825.js";
+import {
+  init_envUtils,
+  isEnvTruthy
+} from "./chunk-s3hafnk3.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/undercover.ts
+function isUndercover() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.CLAUDE_CODE_UNDERCOVER))
+      return true;
+    return getRepoClassCached() !== "internal";
+  }
+  return false;
+}
+function getUndercoverInstructions() {
+  if (process.env.USER_TYPE === "ant") {
+    return `## UNDERCOVER MODE \u2014 CRITICAL
+
+You are operating UNDERCOVER in a PUBLIC/OPEN-SOURCE repository. Your commit
+messages, PR titles, and PR bodies MUST NOT contain ANY Anthropic-internal
+information. Do not blow your cover.
+
+NEVER include in commit messages or PR descriptions:
+- Internal model codenames (animal names like Capybara, Tengu, etc.)
+- Unreleased model version numbers (e.g., sonnet-4-8)
+- Internal repo or project names (e.g., claude-cli-internal, anthropics/\u2026)
+- Internal tooling, Slack channels, or short links (e.g., go/cc, #claude-code-\u2026)
+- The phrase "RedScope AI" or any mention that you are an AI
+- Any hint of what model or version you are
+- Co-Authored-By lines or any other attribution
+
+Write commit messages as a human developer would \u2014 describe only what the code
+change does.
+
+GOOD:
+- "Fix race condition in file watcher initialization"
+- "Add support for custom key bindings"
+- "Refactor parser for better error messages"
+
+BAD (never write these):
+- "Fix bug found while testing with Claude Capybara"
+- "1-shotted by claude-opus-4-6"
+- "1-shotted by claude-opus-4-7"
+- "Generated with RedScope AI"
+- "Co-Authored-By: Claude Opus 4.6 <\u2026>"
+- "Co-Authored-By: Claude Opus 4.7 <\u2026>"
+`;
+  }
+  return "";
+}
+function shouldShowUndercoverAutoNotice() {
+  if (process.env.USER_TYPE === "ant") {
+    if (isEnvTruthy(process.env.CLAUDE_CODE_UNDERCOVER))
+      return false;
+    if (!isUndercover())
+      return false;
+    if (getGlobalConfig().hasSeenUndercoverAutoNotice)
+      return false;
+    return true;
+  }
+  return false;
+}
+var init_undercover = __esm(() => {
+  init_commitAttribution();
+  init_config();
+  init_envUtils();
+});
+
+export { isUndercover, getUndercoverInstructions, shouldShowUndercoverAutoNotice, init_undercover };

package/dist/chunk-3y69j7y8.js

@@ -0,0 +1,24 @@
+// @bun
+import {
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/context/modalContext.tsx
+function useIsInsideModal() {
+  return import_react.useContext(ModalContext) !== null;
+}
+function useModalOrTerminalSize(fallback) {
+  const ctx = import_react.useContext(ModalContext);
+  return ctx ? { rows: ctx.rows, columns: ctx.columns } : fallback;
+}
+var import_react, ModalContext;
+var init_modalContext = __esm(() => {
+  import_react = __toESM(require_react(), 1);
+  ModalContext = import_react.createContext(null);
+});
+
+export { ModalContext, useIsInsideModal, useModalOrTerminalSize, init_modalContext };