jialing-code 1.1.0

package/dist/chunk-waa00cvb.js

@@ -0,0 +1,301 @@
+// @bun
+import {
+  init_useMainLoopModel,
+  useMainLoopModel
+} from "./chunk-f6yjan38.js";
+import {
+  getDisplayedEffortLevel,
+  getEffortEnvOverride,
+  getEffortValueDescription,
+  init_AppState,
+  init_effort,
+  isEffortLevel,
+  toPersistableEffort,
+  useAppState,
+  useSetAppState
+} from "./chunk-ewsgsw9h.js";
+import"./chunk-z1zj044v.js";
+import"./chunk-t0rgmccj.js";
+import"./chunk-key6jr7p.js";
+import"./chunk-0m2861gw.js";
+import"./chunk-0x9b2nmd.js";
+import"./chunk-89e1v45e.js";
+import"./chunk-2gzv8nrw.js";
+import"./chunk-ehtwnxpg.js";
+import"./chunk-3be7ka25.js";
+import"./chunk-x679thag.js";
+import"./chunk-cgfdkzhb.js";
+import"./chunk-bhdt6k7w.js";
+import"./chunk-45kxdsp8.js";
+import"./chunk-5dbk24zg.js";
+import"./chunk-msjfc5ba.js";
+import"./chunk-7zsapntc.js";
+import"./chunk-0rg6yrhy.js";
+import"./chunk-9gbamk79.js";
+import"./chunk-x0mwzt38.js";
+import"./chunk-9e2kqv5g.js";
+import"./chunk-1qakq4sn.js";
+import {
+  require_compiler_runtime
+} from "./chunk-s9mesaw0.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-tw0q7ynt.js";
+import"./chunk-xe9cc860.js";
+import"./chunk-m06q12hg.js";
+import"./chunk-ygbf0ezx.js";
+import"./chunk-spqaamnc.js";
+import"./chunk-4jm600zv.js";
+import"./chunk-qz2x630m.js";
+import"./chunk-7sb5axvf.js";
+import"./chunk-v9smspw2.js";
+import {
+  init_settings1 as init_settings,
+  updateSettingsForSource
+} from "./chunk-3f7rypmf.js";
+import"./chunk-e3g8q4cn.js";
+import"./chunk-ctw5jwcd.js";
+import"./chunk-0e1xsncc.js";
+import"./chunk-vratq94g.js";
+import"./chunk-g0j0t6qk.js";
+import"./chunk-6kpbgc5w.js";
+import"./chunk-3c25bcsw.js";
+import"./chunk-tjaqa99q.js";
+import"./chunk-55wgxwa9.js";
+import"./chunk-w2z5pqd3.js";
+import"./chunk-7ymfj7m3.js";
+import"./chunk-f5ma3nh5.js";
+import"./chunk-v1kzp02e.js";
+import"./chunk-1eapde8a.js";
+import"./chunk-p2816w9z.js";
+import"./chunk-0vkfrmqm.js";
+import"./chunk-0xjaqda8.js";
+import"./chunk-1rvz0433.js";
+import"./chunk-cdz5yb0r.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-f2mhrmww.js";
+import"./chunk-7z8j9qfn.js";
+import"./chunk-hrzerbfw.js";
+import"./chunk-d18z9pna.js";
+import"./chunk-qnfx3qtx.js";
+import"./chunk-hjhc4cpt.js";
+import"./chunk-vyc0rjyx.js";
+import"./chunk-hx2tr4ep.js";
+import"./chunk-p7g7pf3f.js";
+import"./chunk-8tnsngw2.js";
+import"./chunk-8bedvdm1.js";
+import"./chunk-7wm5s02e.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.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-wb0qm4es.js

@@ -0,0 +1,155 @@
+// @bun
+import {
+  init_pluginOperations,
+  updatePluginOp
+} from "./chunk-z7ycmrb3.js";
+import {
+  getDeclaredMarketplaces,
+  init_installedPluginsManager,
+  init_marketplaceManager,
+  init_pluginIdentifier,
+  isInstallationRelevantToCurrentProject,
+  loadInstalledPluginsFromDisk,
+  loadKnownMarketplacesConfig,
+  parsePluginIdentifier,
+  refreshMarketplace
+} from "./chunk-ewsgsw9h.js";
+import {
+  init_config1 as init_config,
+  init_schemas,
+  isMarketplaceAutoUpdate,
+  shouldSkipPluginAutoupdate
+} from "./chunk-3f7rypmf.js";
+import {
+  init_log,
+  logError
+} from "./chunk-p7g7pf3f.js";
+import {
+  errorMessage,
+  init_debug,
+  init_errors,
+  logForDebugging
+} from "./chunk-nxsh6de2.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/utils/plugins/pluginAutoupdate.ts
+function onPluginsAutoUpdated(callback) {
+  pluginUpdateCallback = callback;
+  if (pendingNotification !== null && pendingNotification.length > 0) {
+    callback(pendingNotification);
+    pendingNotification = null;
+  }
+  return () => {
+    pluginUpdateCallback = null;
+  };
+}
+async function getAutoUpdateEnabledMarketplaces() {
+  const config = await loadKnownMarketplacesConfig();
+  const declared = getDeclaredMarketplaces();
+  const enabled = new Set;
+  for (const [name, entry] of Object.entries(config)) {
+    const declaredAutoUpdate = declared[name]?.autoUpdate;
+    const autoUpdate = declaredAutoUpdate !== undefined ? declaredAutoUpdate : isMarketplaceAutoUpdate(name, entry);
+    if (autoUpdate) {
+      enabled.add(name.toLowerCase());
+    }
+  }
+  return enabled;
+}
+async function updatePlugin(pluginId, installations) {
+  let wasUpdated = false;
+  for (const { scope } of installations) {
+    try {
+      const result = await updatePluginOp(pluginId, scope);
+      if (result.success && !result.alreadyUpToDate) {
+        wasUpdated = true;
+        logForDebugging(`Plugin autoupdate: updated ${pluginId} from ${result.oldVersion} to ${result.newVersion}`);
+      } else if (!result.alreadyUpToDate) {
+        logForDebugging(`Plugin autoupdate: failed to update ${pluginId}: ${result.message}`, { level: "warn" });
+      }
+    } catch (error) {
+      logForDebugging(`Plugin autoupdate: error updating ${pluginId}: ${errorMessage(error)}`, { level: "warn" });
+    }
+  }
+  return wasUpdated ? pluginId : null;
+}
+async function updatePluginsForMarketplaces(marketplaceNames) {
+  const installedPlugins = loadInstalledPluginsFromDisk();
+  const pluginIds = Object.keys(installedPlugins.plugins);
+  if (pluginIds.length === 0) {
+    return [];
+  }
+  const results = await Promise.allSettled(pluginIds.map(async (pluginId) => {
+    const { marketplace } = parsePluginIdentifier(pluginId);
+    if (!marketplace || !marketplaceNames.has(marketplace.toLowerCase())) {
+      return null;
+    }
+    const allInstallations = installedPlugins.plugins[pluginId];
+    if (!allInstallations || allInstallations.length === 0) {
+      return null;
+    }
+    const relevantInstallations = allInstallations.filter(isInstallationRelevantToCurrentProject);
+    if (relevantInstallations.length === 0) {
+      return null;
+    }
+    return updatePlugin(pluginId, relevantInstallations);
+  }));
+  return results.filter((r) => r.status === "fulfilled" && r.value !== null).map((r) => r.value);
+}
+async function updatePlugins(autoUpdateEnabledMarketplaces) {
+  return updatePluginsForMarketplaces(autoUpdateEnabledMarketplaces);
+}
+function autoUpdateMarketplacesAndPluginsInBackground() {
+  (async () => {
+    if (shouldSkipPluginAutoupdate()) {
+      logForDebugging("Plugin autoupdate: skipped (auto-updater disabled)");
+      return;
+    }
+    try {
+      const autoUpdateEnabledMarketplaces = await getAutoUpdateEnabledMarketplaces();
+      if (autoUpdateEnabledMarketplaces.size === 0) {
+        return;
+      }
+      const refreshResults = await Promise.allSettled(Array.from(autoUpdateEnabledMarketplaces).map(async (name) => {
+        try {
+          await refreshMarketplace(name, undefined, {
+            disableCredentialHelper: true
+          });
+        } catch (error) {
+          logForDebugging(`Plugin autoupdate: failed to refresh marketplace ${name}: ${errorMessage(error)}`, { level: "warn" });
+        }
+      }));
+      const failures = refreshResults.filter((r) => r.status === "rejected");
+      if (failures.length > 0) {
+        logForDebugging(`Plugin autoupdate: ${failures.length} marketplace refresh(es) failed`, { level: "warn" });
+      }
+      logForDebugging("Plugin autoupdate: checking installed plugins");
+      const updatedPlugins = await updatePlugins(autoUpdateEnabledMarketplaces);
+      if (updatedPlugins.length > 0) {
+        if (pluginUpdateCallback) {
+          pluginUpdateCallback(updatedPlugins);
+        } else {
+          pendingNotification = updatedPlugins;
+        }
+      }
+    } catch (error) {
+      logError(error);
+    }
+  })();
+}
+var pluginUpdateCallback = null, pendingNotification = null;
+var init_pluginAutoupdate = __esm(() => {
+  init_pluginOperations();
+  init_config();
+  init_debug();
+  init_errors();
+  init_log();
+  init_installedPluginsManager();
+  init_marketplaceManager();
+  init_pluginIdentifier();
+  init_schemas();
+});
+
+export { onPluginsAutoUpdated, updatePluginsForMarketplaces, autoUpdateMarketplacesAndPluginsInBackground, init_pluginAutoupdate };

package/dist/chunk-wbkahkdc.js

@@ -0,0 +1,27 @@
+// @bun
+import {
+  PARSE_ABORTED,
+  ensureInitialized,
+  extractCommandArguments,
+  init_parser,
+  parseCommand,
+  parseCommandRaw
+} from "./chunk-7sb5axvf.js";
+import"./chunk-f2mhrmww.js";
+import"./chunk-nxsh6de2.js";
+import"./chunk-fbv4apne.js";
+import"./chunk-3r24h7t6.js";
+import"./chunk-qqfa0dqg.js";
+import"./chunk-hqmz36b3.js";
+import"./chunk-4g3v8y12.js";
+import"./chunk-7739pg2c.js";
+import"./chunk-qp2qdcda.js";
+init_parser();
+
+export {
+  parseCommandRaw,
+  parseCommand,
+  extractCommandArguments,
+  ensureInitialized,
+  PARSE_ABORTED
+};