@redscope-ai/redscope 1.0.0

package/dist/chunk-7h7e5a7d.js

@@ -0,0 +1,25 @@
+// @bun
+import {
+  clearSkillIndexCache,
+  getSkillIndex,
+  init_localSearch,
+  searchSkills,
+  tokenize,
+  tokenizeAndStem
+} from "./chunk-g06pm4n9.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-hhsxm2yr.js";
+init_localSearch();
+
+export {
+  tokenizeAndStem,
+  tokenize,
+  searchSkills,
+  getSkillIndex,
+  clearSkillIndexCache
+};

package/dist/chunk-7m2cznwr.js

@@ -0,0 +1,40 @@
+// @bun
+import {
+  Login,
+  init_login
+} from "./chunk-yzet6xyr.js";
+import {
+  init_extra_usage_core,
+  runExtraUsage
+} from "./chunk-z8cqdcec.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-de0qnnf7.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/commands/extra-usage/extra-usage.tsx
+async function call(onDone, context) {
+  const result = await runExtraUsage();
+  if (result.type === "message") {
+    onDone(result.value);
+    return null;
+  }
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Login, {
+    startingMessage: "Starting new login following /extra-usage. Exit with Ctrl-C to use existing account.",
+    onDone: (success) => {
+      context.onChangeAPIKey();
+      onDone(success ? "Login successful" : "Login interrupted");
+    }
+  }, undefined, false, undefined, this);
+}
+var jsx_dev_runtime;
+var init_extra_usage = __esm(() => {
+  init_login();
+  init_extra_usage_core();
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+export { call, init_extra_usage };

package/dist/chunk-7nvday0n.js

@@ -0,0 +1,252 @@
+// @bun
+import {
+  MODEL_COSTS,
+  getAPIProvider,
+  getCanonicalName,
+  getEventMetadata,
+  getOrCreateUserID,
+  init_config,
+  init_config1 as init_config2,
+  init_metadata,
+  init_model,
+  init_modelCost,
+  init_providers,
+  isAnalyticsDisabled
+} from "./chunk-eemjb825.js";
+import {
+  init_log,
+  logError
+} from "./chunk-s3hafnk3.js";
+import {
+  init_memoize,
+  memoize_default
+} from "./chunk-9h9k5vz3.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-pecy49yr.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/services/analytics/datadog.ts
+import { createHash } from "crypto";
+function camelToSnakeCase(str) {
+  return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+async function flushLogs() {
+  if (logBatch.length === 0)
+    return;
+  const logsToSend = logBatch;
+  logBatch = [];
+  try {
+    await axios_default.post(DATADOG_LOGS_ENDPOINT, logsToSend, {
+      headers: {
+        "Content-Type": "application/json",
+        "DD-API-KEY": DATADOG_CLIENT_TOKEN
+      },
+      timeout: NETWORK_TIMEOUT_MS
+    });
+  } catch (error) {
+    logError(error);
+  }
+}
+function scheduleFlush() {
+  if (flushTimer)
+    return;
+  flushTimer = setTimeout(() => {
+    flushTimer = null;
+    flushLogs();
+  }, getFlushIntervalMs()).unref();
+}
+async function shutdownDatadog() {
+  if (flushTimer) {
+    clearTimeout(flushTimer);
+    flushTimer = null;
+  }
+  await flushLogs();
+}
+async function trackDatadogEvent(eventName, properties) {
+  if (true) {
+    return;
+  }
+  if (getAPIProvider() !== "firstParty") {
+    return;
+  }
+  let initialized = datadogInitialized;
+  if (initialized === null) {
+    initialized = await initializeDatadog();
+  }
+  if (!initialized || !DATADOG_ALLOWED_EVENTS.has(eventName)) {
+    return;
+  }
+  try {
+    const metadata = await getEventMetadata({
+      model: properties.model,
+      betas: properties.betas
+    });
+    const { envContext, ...restMetadata } = metadata;
+    const allData = {
+      ...restMetadata,
+      ...envContext,
+      ...properties,
+      userBucket: getUserBucket()
+    };
+    if (typeof allData.toolName === "string" && allData.toolName.startsWith("mcp__")) {
+      allData.toolName = "mcp";
+    }
+    if (process.env.USER_TYPE !== "ant" && typeof allData.model === "string") {
+      const shortName = getCanonicalName(allData.model.replace(/\[1m]$/i, ""));
+      allData.model = shortName in MODEL_COSTS ? shortName : "other";
+    }
+    if (typeof allData.version === "string") {
+      allData.version = allData.version.replace(/^(\d+\.\d+\.\d+-dev\.\d{8})\.t\d+\.sha[a-f0-9]+$/, "$1");
+    }
+    if (allData.status !== undefined && allData.status !== null) {
+      const statusCode = String(allData.status);
+      allData.http_status = statusCode;
+      const firstDigit = statusCode.charAt(0);
+      if (firstDigit >= "1" && firstDigit <= "5") {
+        allData.http_status_range = `${firstDigit}xx`;
+      }
+      delete allData.status;
+    }
+    const allDataRecord = allData;
+    const tags = [
+      `event:${eventName}`,
+      ...TAG_FIELDS.filter((field) => allDataRecord[field] !== undefined && allDataRecord[field] !== null).map((field) => `${camelToSnakeCase(field)}:${allDataRecord[field]}`)
+    ];
+    const log = {
+      ddsource: "nodejs",
+      ddtags: tags.join(","),
+      message: eventName,
+      service: "claude-code",
+      hostname: "claude-code",
+      env: process.env.USER_TYPE
+    };
+    for (const [key, value] of Object.entries(allData)) {
+      if (value !== undefined && value !== null) {
+        log[camelToSnakeCase(key)] = value;
+      }
+    }
+    logBatch.push(log);
+    if (logBatch.length >= MAX_BATCH_SIZE) {
+      if (flushTimer) {
+        clearTimeout(flushTimer);
+        flushTimer = null;
+      }
+      flushLogs();
+    } else {
+      scheduleFlush();
+    }
+  } catch (error) {
+    logError(error);
+  }
+}
+function getFlushIntervalMs() {
+  return parseInt(process.env.CLAUDE_CODE_DATADOG_FLUSH_INTERVAL_MS || "", 10) || DEFAULT_FLUSH_INTERVAL_MS;
+}
+var DATADOG_LOGS_ENDPOINT, DATADOG_CLIENT_TOKEN, DEFAULT_FLUSH_INTERVAL_MS = 15000, MAX_BATCH_SIZE = 100, NETWORK_TIMEOUT_MS = 5000, DATADOG_ALLOWED_EVENTS, TAG_FIELDS, logBatch, flushTimer = null, datadogInitialized = null, initializeDatadog, NUM_USER_BUCKETS = 30, getUserBucket;
+var init_datadog = __esm(() => {
+  init_axios();
+  init_memoize();
+  init_config2();
+  init_log();
+  init_model();
+  init_providers();
+  init_modelCost();
+  init_config();
+  init_metadata();
+  DATADOG_LOGS_ENDPOINT = process.env.DATADOG_LOGS_ENDPOINT ?? "";
+  DATADOG_CLIENT_TOKEN = process.env.DATADOG_API_KEY ?? "";
+  DATADOG_ALLOWED_EVENTS = new Set([
+    "chrome_bridge_connection_succeeded",
+    "chrome_bridge_connection_failed",
+    "chrome_bridge_disconnected",
+    "chrome_bridge_tool_call_completed",
+    "chrome_bridge_tool_call_error",
+    "chrome_bridge_tool_call_started",
+    "chrome_bridge_tool_call_timeout",
+    "tengu_api_error",
+    "tengu_api_success",
+    "tengu_brief_mode_enabled",
+    "tengu_brief_mode_toggled",
+    "tengu_brief_send",
+    "tengu_cancel",
+    "tengu_compact_failed",
+    "tengu_exit",
+    "tengu_flicker",
+    "tengu_init",
+    "tengu_model_fallback_triggered",
+    "tengu_oauth_error",
+    "tengu_oauth_success",
+    "tengu_oauth_token_refresh_failure",
+    "tengu_oauth_token_refresh_success",
+    "tengu_oauth_token_refresh_lock_acquiring",
+    "tengu_oauth_token_refresh_lock_acquired",
+    "tengu_oauth_token_refresh_starting",
+    "tengu_oauth_token_refresh_completed",
+    "tengu_oauth_token_refresh_lock_releasing",
+    "tengu_oauth_token_refresh_lock_released",
+    "tengu_query_error",
+    "tengu_session_file_read",
+    "tengu_started",
+    "tengu_tool_use_error",
+    "tengu_tool_use_granted_in_prompt_permanent",
+    "tengu_tool_use_granted_in_prompt_temporary",
+    "tengu_tool_use_rejected_in_prompt",
+    "tengu_tool_use_success",
+    "tengu_uncaught_exception",
+    "tengu_unhandled_rejection",
+    "tengu_voice_recording_started",
+    "tengu_voice_toggled",
+    "tengu_team_mem_sync_pull",
+    "tengu_team_mem_sync_push",
+    "tengu_team_mem_sync_started",
+    "tengu_team_mem_entries_capped"
+  ]);
+  TAG_FIELDS = [
+    "arch",
+    "clientType",
+    "errorType",
+    "http_status_range",
+    "http_status",
+    "kairosActive",
+    "model",
+    "platform",
+    "provider",
+    "skillMode",
+    "subscriptionType",
+    "toolName",
+    "userBucket",
+    "userType",
+    "version",
+    "versionBase"
+  ];
+  logBatch = [];
+  initializeDatadog = memoize_default(async () => {
+    if (isAnalyticsDisabled()) {
+      datadogInitialized = false;
+      return false;
+    }
+    if (!DATADOG_LOGS_ENDPOINT || !DATADOG_CLIENT_TOKEN) {
+      datadogInitialized = false;
+      return false;
+    }
+    try {
+      datadogInitialized = true;
+      return true;
+    } catch (error) {
+      logError(error);
+      datadogInitialized = false;
+      return false;
+    }
+  });
+  getUserBucket = memoize_default(() => {
+    const userId = getOrCreateUserID();
+    const hash = createHash("sha256").update(userId).digest("hex");
+    return parseInt(hash.slice(0, 8), 16) % NUM_USER_BUCKETS;
+  });
+});
+
+export { initializeDatadog, shutdownDatadog, trackDatadogEvent, init_datadog };

package/dist/chunk-7qey87th.js

@@ -0,0 +1,145 @@
+// @bun
+import {
+  ALLOWED_OFFICIAL_MARKETPLACE_NAMES,
+  getSettings_DEPRECATED,
+  init_schemas,
+  init_settings1 as init_settings
+} from "./chunk-eemjb825.js";
+import {
+  __esm
+} from "./chunk-hhsxm2yr.js";
+
+// src/plugins/builtinPlugins.ts
+function registerBuiltinPlugin(definition) {
+  BUILTIN_PLUGINS.set(definition.name, definition);
+}
+function isBuiltinPluginId(pluginId) {
+  return pluginId.endsWith(`@${BUILTIN_MARKETPLACE_NAME}`);
+}
+function getBuiltinPluginDefinition(name) {
+  return BUILTIN_PLUGINS.get(name);
+}
+function getBuiltinPlugins() {
+  const settings = getSettings_DEPRECATED();
+  const enabled = [];
+  const disabled = [];
+  for (const [name, definition] of BUILTIN_PLUGINS) {
+    if (definition.isAvailable && !definition.isAvailable()) {
+      continue;
+    }
+    const pluginId = `${name}@${BUILTIN_MARKETPLACE_NAME}`;
+    const userSetting = settings?.enabledPlugins?.[pluginId];
+    const isEnabled = userSetting !== undefined ? userSetting === true : definition.defaultEnabled ?? true;
+    const plugin = {
+      name,
+      manifest: {
+        name,
+        description: definition.description,
+        version: definition.version
+      },
+      path: BUILTIN_MARKETPLACE_NAME,
+      source: pluginId,
+      repository: pluginId,
+      enabled: isEnabled,
+      isBuiltin: true,
+      hooksConfig: definition.hooks,
+      mcpServers: definition.mcpServers
+    };
+    if (isEnabled) {
+      enabled.push(plugin);
+    } else {
+      disabled.push(plugin);
+    }
+  }
+  return { enabled, disabled };
+}
+function getBuiltinPluginSkillCommands() {
+  const { enabled } = getBuiltinPlugins();
+  const commands = [];
+  for (const plugin of enabled) {
+    const definition = BUILTIN_PLUGINS.get(plugin.name);
+    if (!definition?.skills)
+      continue;
+    for (const skill of definition.skills) {
+      commands.push(skillDefinitionToCommand(skill));
+    }
+  }
+  return commands;
+}
+function skillDefinitionToCommand(definition) {
+  return {
+    type: "prompt",
+    name: definition.name,
+    description: definition.description,
+    hasUserSpecifiedDescription: true,
+    allowedTools: definition.allowedTools ?? [],
+    argumentHint: definition.argumentHint,
+    whenToUse: definition.whenToUse,
+    model: definition.model,
+    disableModelInvocation: definition.disableModelInvocation ?? false,
+    userInvocable: definition.userInvocable ?? true,
+    contentLength: 0,
+    source: "bundled",
+    loadedFrom: "bundled",
+    hooks: definition.hooks,
+    context: definition.context,
+    agent: definition.agent,
+    isEnabled: definition.isEnabled ?? (() => true),
+    isHidden: !(definition.userInvocable ?? true),
+    progressMessage: "running",
+    getPromptForCommand: definition.getPromptForCommand
+  };
+}
+var BUILTIN_PLUGINS, BUILTIN_MARKETPLACE_NAME = "builtin";
+var init_builtinPlugins = __esm(() => {
+  init_settings();
+  BUILTIN_PLUGINS = new Map;
+});
+
+// src/utils/plugins/pluginIdentifier.ts
+function parsePluginIdentifier(plugin) {
+  if (plugin.includes("@")) {
+    const parts = plugin.split("@");
+    return { name: parts[0] || "", marketplace: parts[1] };
+  }
+  return { name: plugin };
+}
+function isOfficialMarketplaceName(marketplace) {
+  return marketplace !== undefined && ALLOWED_OFFICIAL_MARKETPLACE_NAMES.has(marketplace.toLowerCase());
+}
+function scopeToSettingSource(scope) {
+  if (scope === "managed") {
+    throw new Error("Cannot install plugins to managed scope");
+  }
+  return SCOPE_TO_EDITABLE_SOURCE[scope];
+}
+function settingSourceToScope(source) {
+  return SETTING_SOURCE_TO_SCOPE[source];
+}
+var SETTING_SOURCE_TO_SCOPE, SCOPE_TO_EDITABLE_SOURCE;
+var init_pluginIdentifier = __esm(() => {
+  init_schemas();
+  SETTING_SOURCE_TO_SCOPE = {
+    policySettings: "managed",
+    userSettings: "user",
+    projectSettings: "project",
+    localSettings: "local",
+    flagSettings: "flag"
+  };
+  SCOPE_TO_EDITABLE_SOURCE = {
+    user: "userSettings",
+    project: "projectSettings",
+    local: "localSettings"
+  };
+});
+
+// src/utils/xml.ts
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeXmlAttr(s) {
+  return escapeXml(s).replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+var init_xml = () => {};
+
+export { BUILTIN_MARKETPLACE_NAME, registerBuiltinPlugin, isBuiltinPluginId, getBuiltinPluginDefinition, getBuiltinPlugins, getBuiltinPluginSkillCommands, init_builtinPlugins, SETTING_SOURCE_TO_SCOPE, parsePluginIdentifier, isOfficialMarketplaceName, scopeToSettingSource, settingSourceToScope, init_pluginIdentifier, escapeXml, escapeXmlAttr, init_xml };