@jayjiang/open-cc 0.2.1

package/dist/chunk-xm3ed3zn.js

@@ -0,0 +1,300 @@
+// @bun
+import {
+  init_useMainLoopModel,
+  useMainLoopModel
+} from "./chunk-khmz14d4.js";
+import {
+  getDisplayedEffortLevel,
+  getEffortEnvOverride,
+  getEffortValueDescription,
+  init_AppState,
+  init_effort,
+  isEffortLevel,
+  toPersistableEffort,
+  useAppState,
+  useSetAppState
+} from "./chunk-2y54j9ew.js";
+import"./chunk-1yzc16qa.js";
+import"./chunk-s10vyjz4.js";
+import"./chunk-1k4j1xcf.js";
+import"./chunk-3c4qja3e.js";
+import"./chunk-rc5bbzx4.js";
+import"./chunk-e6rrwzv0.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-743znc5c.js";
+import"./chunk-5p2ssw3d.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-6wkdqk81.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-bda3gxxz.js";
+import"./chunk-zxhezavg.js";
+import"./chunk-x8eg216f.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-t175chdd.js";
+import"./chunk-7rjyn5d3.js";
+import"./chunk-6q2x8zeg.js";
+import {
+  require_compiler_runtime
+} from "./chunk-0yb4dz9c.js";
+import"./chunk-7m2nd8da.js";
+import"./chunk-ps49ymvj.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-g338npwr.js";
+import"./chunk-zk2wsm7d.js";
+import"./chunk-eh474zhj.js";
+import"./chunk-ga5faygf.js";
+import"./chunk-e7c8ypwc.js";
+import"./chunk-g6qddbvf.js";
+import"./chunk-b1s11z4y.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-yxmz5k16.js";
+import"./chunk-v9smspw2.js";
+import"./chunk-qz2x630m.js";
+import {
+  init_settings1 as init_settings,
+  updateSettingsForSource
+} from "./chunk-30chpfyc.js";
+import"./chunk-84k64e4a.js";
+import"./chunk-y3py9g5d.js";
+import"./chunk-7pemewz2.js";
+import"./chunk-s4w01jsb.js";
+import"./chunk-c8vn3ynx.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-mzdtkccs.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-5k2gdxnr.js";
+import"./chunk-2qhs9n36.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-mr9df5v8.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import"./chunk-10fdxge0.js";
+import"./chunk-r1v8d6da.js";
+import"./chunk-d3v2fbay.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-f2zhqnb6.js";
+import"./chunk-cvp5vayb.js";
+import"./chunk-b5b7h81y.js";
+import"./chunk-nm2cncrq.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-0rkbrabt.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-rwagvxh5.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-0fkqze0v.js";
+import"./chunk-2zcaw1jd.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-xszk7n10.js";
+import"./chunk-sdj9b9wh.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/commands/effort/effort.tsx
+function setEffortValue(effortValue) {
+  const persistable = toPersistableEffort(effortValue);
+  if (persistable !== undefined) {
+    const result = updateSettingsForSource("userSettings", {
+      effortLevel: persistable
+    });
+    if (result.error) {
+      return {
+        message: `Failed to set effort level: ${result.error.message}`
+      };
+    }
+  }
+  logEvent("tengu_effort_command", {
+    effort: effortValue
+  });
+  const envOverride = getEffortEnvOverride();
+  if (envOverride !== undefined && envOverride !== effortValue) {
+    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+    if (persistable === undefined) {
+      return {
+        message: `Not applied: CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides effort this session, and ${effortValue} is session-only (nothing saved)`,
+        effortUpdate: {
+          value: effortValue
+        }
+      };
+    }
+    return {
+      message: `CLAUDE_CODE_EFFORT_LEVEL=${envRaw} overrides this session \u2014 clear it and ${effortValue} takes over`,
+      effortUpdate: {
+        value: effortValue
+      }
+    };
+  }
+  const description = getEffortValueDescription(effortValue);
+  const suffix = persistable !== undefined ? "" : " (this session only)";
+  return {
+    message: `Set effort level to ${effortValue}${suffix}: ${description}`,
+    effortUpdate: {
+      value: effortValue
+    }
+  };
+}
+function showCurrentEffort(appStateEffort, model) {
+  const envOverride = getEffortEnvOverride();
+  const effectiveValue = envOverride === null ? undefined : envOverride ?? appStateEffort;
+  if (effectiveValue === undefined) {
+    const level = getDisplayedEffortLevel(model, appStateEffort);
+    return {
+      message: `Effort level: auto (currently ${level})`
+    };
+  }
+  const description = getEffortValueDescription(effectiveValue);
+  return {
+    message: `Current effort level: ${effectiveValue} (${description})`
+  };
+}
+function unsetEffortLevel() {
+  const result = updateSettingsForSource("userSettings", {
+    effortLevel: undefined
+  });
+  if (result.error) {
+    return {
+      message: `Failed to set effort level: ${result.error.message}`
+    };
+  }
+  logEvent("tengu_effort_command", {
+    effort: "auto"
+  });
+  const envOverride = getEffortEnvOverride();
+  if (envOverride !== undefined && envOverride !== null) {
+    const envRaw = process.env.CLAUDE_CODE_EFFORT_LEVEL;
+    return {
+      message: `Cleared effort from settings, but CLAUDE_CODE_EFFORT_LEVEL=${envRaw} still controls this session`,
+      effortUpdate: {
+        value: undefined
+      }
+    };
+  }
+  return {
+    message: "Effort level set to auto",
+    effortUpdate: {
+      value: undefined
+    }
+  };
+}
+function executeEffort(args) {
+  const normalized = args.toLowerCase();
+  if (normalized === "auto" || normalized === "unset") {
+    return unsetEffortLevel();
+  }
+  if (!isEffortLevel(normalized)) {
+    return {
+      message: `Invalid argument: ${args}. Valid options are: low, medium, high, max, auto`
+    };
+  }
+  return setEffortValue(normalized);
+}
+function ShowCurrentEffort(t0) {
+  const {
+    onDone
+  } = t0;
+  const effortValue = useAppState(_temp);
+  const model = useMainLoopModel();
+  const {
+    message
+  } = showCurrentEffort(effortValue, model);
+  onDone(message);
+  return null;
+}
+function _temp(s) {
+  return s.effortValue;
+}
+function ApplyEffortAndClose(t0) {
+  const $ = import_compiler_runtime.c(6);
+  const {
+    result,
+    onDone
+  } = t0;
+  const setAppState = useSetAppState();
+  const {
+    effortUpdate,
+    message
+  } = result;
+  let t1;
+  let t2;
+  if ($[0] !== effortUpdate || $[1] !== message || $[2] !== onDone || $[3] !== setAppState) {
+    t1 = () => {
+      if (effortUpdate) {
+        setAppState((prev) => ({
+          ...prev,
+          effortValue: effortUpdate.value
+        }));
+      }
+      onDone(message);
+    };
+    t2 = [setAppState, effortUpdate, message, onDone];
+    $[0] = effortUpdate;
+    $[1] = message;
+    $[2] = onDone;
+    $[3] = setAppState;
+    $[4] = t1;
+    $[5] = t2;
+  } else {
+    t1 = $[4];
+    t2 = $[5];
+  }
+  React.useEffect(t1, t2);
+  return null;
+}
+async function call(onDone, _context, args) {
+  args = args?.trim() || "";
+  if (COMMON_HELP_ARGS.includes(args)) {
+    onDone(`Usage: /effort [low|medium|high|max|auto]
+
+Effort levels:
+- low: Quick, straightforward implementation
+- medium: Balanced approach with standard testing
+- high: Comprehensive implementation with extensive testing
+- max: Maximum capability with deepest reasoning (Opus 4.6 only)
+- auto: Use the default effort level for your model`);
+    return;
+  }
+  if (!args || args === "current" || args === "status") {
+    return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ShowCurrentEffort, {
+      onDone
+    }, undefined, false, undefined, this);
+  }
+  const result = executeEffort(args);
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ApplyEffortAndClose, {
+    result,
+    onDone
+  }, undefined, false, undefined, this);
+}
+var import_compiler_runtime, React, jsx_dev_runtime, COMMON_HELP_ARGS;
+var init_effort2 = __esm(() => {
+  init_useMainLoopModel();
+  init_analytics();
+  init_AppState();
+  init_effort();
+  init_settings();
+  import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+  React = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+  COMMON_HELP_ARGS = ["help", "-h", "--help"];
+});
+init_effort2();
+
+export {
+  showCurrentEffort,
+  executeEffort,
+  call
+};

package/dist/chunk-xpm4ebhz.js

@@ -0,0 +1,87 @@
+// @bun
+import {
+  createDisabledBypassPermissionsContext,
+  init_AppState,
+  init_permissionSetup,
+  shouldDisableBypassPermissions,
+  useAppState,
+  useAppStateStore,
+  useSetAppState
+} from "./chunk-2y54j9ew.js";
+import {
+  require_react
+} from "./chunk-g338npwr.js";
+import {
+  getIsRemoteMode,
+  init_state
+} from "./chunk-2zcaw1jd.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/permissions/bypassPermissionsKillswitch.ts
+async function checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState) {
+  if (bypassPermissionsCheckRan) {
+    return;
+  }
+  bypassPermissionsCheckRan = true;
+  if (!toolPermissionContext.isBypassPermissionsModeAvailable) {
+    return;
+  }
+  const shouldDisable = await shouldDisableBypassPermissions();
+  if (!shouldDisable) {
+    return;
+  }
+  setAppState((prev) => {
+    return {
+      ...prev,
+      toolPermissionContext: createDisabledBypassPermissionsContext(prev.toolPermissionContext)
+    };
+  });
+}
+function resetBypassPermissionsCheck() {
+  bypassPermissionsCheckRan = false;
+}
+function useKickOffCheckAndDisableBypassPermissionsIfNeeded() {
+  const toolPermissionContext = useAppState((s) => s.toolPermissionContext);
+  const setAppState = useSetAppState();
+  import_react.useEffect(() => {
+    if (getIsRemoteMode())
+      return;
+    checkAndDisableBypassPermissionsIfNeeded(toolPermissionContext, setAppState);
+  }, []);
+}
+async function checkAndDisableAutoModeIfNeeded(toolPermissionContext, setAppState, fastMode) {
+  if (false) {}
+}
+function resetAutoModeGateCheck() {
+  autoModeCheckRan = false;
+}
+function useKickOffCheckAndDisableAutoModeIfNeeded() {
+  const mainLoopModel = useAppState((s) => s.mainLoopModel);
+  const mainLoopModelForSession = useAppState((s) => s.mainLoopModelForSession);
+  const fastMode = useAppState((s) => s.fastMode);
+  const setAppState = useSetAppState();
+  const store = useAppStateStore();
+  const isFirstRunRef = import_react.useRef(true);
+  import_react.useEffect(() => {
+    if (getIsRemoteMode())
+      return;
+    if (isFirstRunRef.current) {
+      isFirstRunRef.current = false;
+    } else {
+      resetAutoModeGateCheck();
+    }
+    checkAndDisableAutoModeIfNeeded(store.getState().toolPermissionContext, setAppState, fastMode);
+  }, [mainLoopModel, mainLoopModelForSession, fastMode]);
+}
+var import_react, bypassPermissionsCheckRan = false, autoModeCheckRan = false;
+var init_bypassPermissionsKillswitch = __esm(() => {
+  init_AppState();
+  init_state();
+  init_permissionSetup();
+  import_react = __toESM(require_react(), 1);
+});
+
+export { checkAndDisableBypassPermissionsIfNeeded, resetBypassPermissionsCheck, useKickOffCheckAndDisableBypassPermissionsIfNeeded, useKickOffCheckAndDisableAutoModeIfNeeded, init_bypassPermissionsKillswitch };

package/dist/chunk-xr6yfttj.js

@@ -0,0 +1,43 @@
+// @bun
+import {
+  require_src as require_src2
+} from "./chunk-6tq2v3rk.js";
+import {
+  require_src as require_src3
+} from "./chunk-c3z7ptb2.js";
+import {
+  require_src1 as require_src
+} from "./chunk-90wp6wez.js";
+import"./chunk-a8ejc632.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-p2816w9z.js";
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/OTLPMetricExporter.js
+var require_OTLPMetricExporter = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var exporter_metrics_otlp_http_1 = require_src2();
+  var otlp_grpc_exporter_base_1 = require_src3();
+  var otlp_transformer_1 = require_src();
+
+  class OTLPMetricExporter extends exporter_metrics_otlp_http_1.OTLPMetricExporterBase {
+    constructor(config) {
+      super((0, otlp_grpc_exporter_base_1.createOtlpGrpcExportDelegate)((0, otlp_grpc_exporter_base_1.convertLegacyOtlpGrpcOptions)(config ?? {}, "METRICS"), otlp_transformer_1.ProtobufMetricsSerializer, "MetricsExportService", "/opentelemetry.proto.collector.metrics.v1.MetricsService/Export"), config);
+    }
+  }
+  exports.OTLPMetricExporter = OTLPMetricExporter;
+});
+
+// node_modules/.bun/@opentelemetry+exporter-metrics-otlp-grpc@0.214.0+e40b0dfdd726a224/node_modules/@opentelemetry/exporter-metrics-otlp-grpc/build/src/index.js
+var require_src4 = __commonJS((exports) => {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.OTLPMetricExporter = undefined;
+  var OTLPMetricExporter_1 = require_OTLPMetricExporter();
+  Object.defineProperty(exports, "OTLPMetricExporter", { enumerable: true, get: function() {
+    return OTLPMetricExporter_1.OTLPMetricExporter;
+  } });
+});
+export default require_src4();

package/dist/chunk-xsq9ae7x.js

@@ -0,0 +1,90 @@
+// @bun
+import {
+  __commonJS
+} from "./chunk-qp2qdcda.js";
+
+// node_modules/.bun/@smithy+types@4.13.1/node_modules/@smithy/types/dist-cjs/index.js
+var require_dist_cjs = __commonJS((exports) => {
+  exports.HttpAuthLocation = undefined;
+  (function(HttpAuthLocation) {
+    HttpAuthLocation["HEADER"] = "header";
+    HttpAuthLocation["QUERY"] = "query";
+  })(exports.HttpAuthLocation || (exports.HttpAuthLocation = {}));
+  exports.HttpApiKeyAuthLocation = undefined;
+  (function(HttpApiKeyAuthLocation) {
+    HttpApiKeyAuthLocation["HEADER"] = "header";
+    HttpApiKeyAuthLocation["QUERY"] = "query";
+  })(exports.HttpApiKeyAuthLocation || (exports.HttpApiKeyAuthLocation = {}));
+  exports.EndpointURLScheme = undefined;
+  (function(EndpointURLScheme) {
+    EndpointURLScheme["HTTP"] = "http";
+    EndpointURLScheme["HTTPS"] = "https";
+  })(exports.EndpointURLScheme || (exports.EndpointURLScheme = {}));
+  exports.AlgorithmId = undefined;
+  (function(AlgorithmId) {
+    AlgorithmId["MD5"] = "md5";
+    AlgorithmId["CRC32"] = "crc32";
+    AlgorithmId["CRC32C"] = "crc32c";
+    AlgorithmId["SHA1"] = "sha1";
+    AlgorithmId["SHA256"] = "sha256";
+  })(exports.AlgorithmId || (exports.AlgorithmId = {}));
+  var getChecksumConfiguration = (runtimeConfig) => {
+    const checksumAlgorithms = [];
+    if (runtimeConfig.sha256 !== undefined) {
+      checksumAlgorithms.push({
+        algorithmId: () => exports.AlgorithmId.SHA256,
+        checksumConstructor: () => runtimeConfig.sha256
+      });
+    }
+    if (runtimeConfig.md5 != null) {
+      checksumAlgorithms.push({
+        algorithmId: () => exports.AlgorithmId.MD5,
+        checksumConstructor: () => runtimeConfig.md5
+      });
+    }
+    return {
+      addChecksumAlgorithm(algo) {
+        checksumAlgorithms.push(algo);
+      },
+      checksumAlgorithms() {
+        return checksumAlgorithms;
+      }
+    };
+  };
+  var resolveChecksumRuntimeConfig = (clientConfig) => {
+    const runtimeConfig = {};
+    clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
+      runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
+    });
+    return runtimeConfig;
+  };
+  var getDefaultClientConfiguration = (runtimeConfig) => {
+    return getChecksumConfiguration(runtimeConfig);
+  };
+  var resolveDefaultRuntimeConfig = (config) => {
+    return resolveChecksumRuntimeConfig(config);
+  };
+  exports.FieldPosition = undefined;
+  (function(FieldPosition) {
+    FieldPosition[FieldPosition["HEADER"] = 0] = "HEADER";
+    FieldPosition[FieldPosition["TRAILER"] = 1] = "TRAILER";
+  })(exports.FieldPosition || (exports.FieldPosition = {}));
+  var SMITHY_CONTEXT_KEY = "__smithy_context";
+  exports.IniSectionType = undefined;
+  (function(IniSectionType) {
+    IniSectionType["PROFILE"] = "profile";
+    IniSectionType["SSO_SESSION"] = "sso-session";
+    IniSectionType["SERVICES"] = "services";
+  })(exports.IniSectionType || (exports.IniSectionType = {}));
+  exports.RequestHandlerProtocol = undefined;
+  (function(RequestHandlerProtocol) {
+    RequestHandlerProtocol["HTTP_0_9"] = "http/0.9";
+    RequestHandlerProtocol["HTTP_1_0"] = "http/1.0";
+    RequestHandlerProtocol["TDS_8_0"] = "tds/8.0";
+  })(exports.RequestHandlerProtocol || (exports.RequestHandlerProtocol = {}));
+  exports.SMITHY_CONTEXT_KEY = SMITHY_CONTEXT_KEY;
+  exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
+  exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
+});
+
+export { require_dist_cjs };