@cjhyy/code-shell 0.1.0-alpha.3 → 0.1.6

package/dist/chunk-3SBSUOWZ.js

@@ -0,0 +1,447 @@
+import {
+  init_esm_shims
+} from "./chunk-MD32R22I.js";
+
+// src/settings/manager.ts
+init_esm_shims();
+import {
+  readFileSync,
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  renameSync,
+  copyFileSync
+} from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+
+// src/settings/schema.ts
+init_esm_shims();
+import { z } from "zod";
+var SettingsSchema = z.object({
+  agent: z.object({
+    // Use z.string() instead of z.enum() to allow custom presets registered via registerPreset()
+    preset: z.string().default("terminal-coding"),
+    enabledBuiltinTools: z.array(z.string()).default([]),
+    disabledBuiltinTools: z.array(z.string()).default([]),
+    customSystemPrompt: z.string().optional(),
+    appendSystemPrompt: z.string().optional()
+  }).default({}),
+  /**
+   * Primary source of truth for the active model is settings.activeKey
+   * (points at models[].key). settings.model is a derived mirror of that
+   * entry kept in sync for legacy boot paths (cli/main.ts, repl.ts, etc.)
+   * which read provider/name/apiKey/baseUrl directly. Writers must update
+   * both — appendOnboardingResult does this in one shot.
+   */
+  activeKey: z.string().optional(),
+  /**
+   * Toggle background auto-update. When true (default), code-shell checks
+   * npm for newer versions and — if the npm global prefix is writable —
+   * installs the update in the background on process exit so the next
+   * launch picks it up.
+   * Can also be disabled via env var `DISABLE_AUTOUPDATER=1`.
+   */
+  autoUpdates: z.boolean().default(true),
+  model: z.object({
+    provider: z.string().default("openai"),
+    name: z.string().default("anthropic/claude-opus-4-6"),
+    apiKey: z.string().optional(),
+    baseUrl: z.string().default("https://openrouter.ai/api/v1"),
+    temperature: z.number().min(0).max(2).default(0.3),
+    maxTokens: z.number().default(8192)
+  }).default({}),
+  providers: z.array(
+    z.object({
+      key: z.string(),
+      label: z.string().optional(),
+      kind: z.enum([
+        "openai",
+        "anthropic",
+        "deepseek",
+        "xai",
+        "mistral",
+        "groq",
+        "google",
+        "openrouter",
+        "ollama",
+        "custom"
+      ]),
+      baseUrl: z.string(),
+      apiKey: z.string().optional(),
+      protocol: z.enum(["openai-compat", "anthropic-style"]).optional(),
+      modelsPath: z.string().optional()
+    })
+  ).default([]),
+  models: z.array(
+    z.object({
+      key: z.string(),
+      label: z.string().optional(),
+      providerKey: z.string().optional(),
+      model: z.string(),
+      maxOutputTokens: z.number().optional(),
+      maxContextTokens: z.number().optional(),
+      /**
+       * Which LLM client to use ("openai" or "anthropic"). New name —
+       * the legacy field is `provider`, which we still accept and
+       * fold into `protocol` below so old configs keep working.
+       * NOT the brand/vendor — that's providerKey above.
+       */
+      protocol: z.string().optional(),
+      provider: z.string().optional(),
+      baseUrl: z.string().optional(),
+      apiKey: z.string().optional()
+    }).transform((m) => {
+      const effective = m.protocol ?? m.provider;
+      return {
+        ...m,
+        protocol: effective,
+        provider: effective
+      };
+    })
+  ).default([]),
+  permissions: z.object({
+    defaultMode: z.enum(["default", "acceptEdits", "dontAsk", "bypassPermissions", "auto", "plan"]).default("default"),
+    rules: z.array(
+      z.object({
+        tool: z.string(),
+        argsPattern: z.record(z.string()).optional(),
+        decision: z.enum(["allow", "deny", "ask"]),
+        reason: z.string().optional()
+      })
+    ).default([])
+  }).default({}),
+  context: z.object({
+    maxTokens: z.number().default(2e5),
+    compactAtRatio: z.number().default(0.6),
+    summarizeAtRatio: z.number().default(0.8)
+  }).default({}),
+  session: z.object({
+    storageDir: z.string().optional(),
+    maxHistory: z.number().default(100)
+  }).default({}),
+  mcpServers: z.record(
+    z.object({
+      name: z.string(),
+      command: z.string().optional(),
+      args: z.array(z.string()).optional(),
+      env: z.record(z.string()).optional(),
+      url: z.string().optional(),
+      transport: z.enum(["stdio", "sse", "streamable-http", "inprocess"]).optional(),
+      headers: z.record(z.string()).optional()
+    })
+  ).default({}),
+  instructions: z.object({
+    fileName: z.string().default("CODESHELL.md"),
+    scanDirs: z.array(z.string()).default([]),
+    compatFileNames: z.array(z.string()).default(["CLAUDE.md", "AGENTS.md"]),
+    ignoreGitBoundary: z.boolean().default(false)
+  }).default({}),
+  arena: z.object({
+    participants: z.array(
+      z.union([
+        // Short form: just a model pool key
+        z.string(),
+        // Full form: explicit config (backward compat)
+        z.object({
+          name: z.string(),
+          model: z.string(),
+          provider: z.string().optional(),
+          apiKey: z.string().optional(),
+          baseUrl: z.string().optional()
+        })
+      ])
+    ).default([])
+  }).default({}),
+  search: z.object({
+    provider: z.enum(["serper", "tavily", "searxng"]).default("serper"),
+    apiKey: z.string().optional(),
+    baseUrl: z.string().optional()
+  }).default({}),
+  output: z.object({
+    format: z.enum(["text", "json", "jsonl", "stream-json"]).default("text")
+  }).default({})
+}).passthrough();
+function validateSettings(raw) {
+  return SettingsSchema.parse(raw);
+}
+
+// src/cli/migrate-models.ts
+init_esm_shims();
+var BASEURL_KIND_PATTERNS = [
+  [/deepseek\.com/i, "deepseek"],
+  [/anthropic\.com/i, "anthropic"],
+  [/openai\.com/i, "openai"],
+  [/x\.ai/i, "xai"],
+  [/mistral\.ai/i, "mistral"],
+  [/groq\.com/i, "groq"],
+  [/generativelanguage\.googleapis/i, "google"],
+  [/openrouter\.ai/i, "openrouter"],
+  [/localhost:11434|127\.0\.0\.1:11434/i, "ollama"]
+];
+function inferKind(baseUrl) {
+  if (!baseUrl) return "custom";
+  for (const [re, kind] of BASEURL_KIND_PATTERNS) {
+    if (re.test(baseUrl)) return kind;
+  }
+  return "custom";
+}
+function makeFingerprint(m) {
+  return `${m.provider ?? ""}|${m.baseUrl ?? ""}|${m.apiKey ?? ""}`;
+}
+function deriveKey(base, used) {
+  if (!used.has(base)) return base;
+  for (let i = 2; ; i++) {
+    const candidate = `${base}-${i}`;
+    if (!used.has(candidate)) return candidate;
+  }
+}
+function deriveProviderModelKey(providerKind, modelId, used) {
+  const slash = modelId.lastIndexOf("/");
+  const base = slash >= 0 ? modelId.slice(slash + 1) : modelId;
+  const prefix = providerKind.toLowerCase();
+  const candidate = base.toLowerCase().startsWith(`${prefix}-`) ? base : `${prefix}-${base}`;
+  if (!used.has(candidate)) return candidate;
+  for (let i = 2; ; i++) {
+    const k = `${candidate}-${i}`;
+    if (!used.has(k)) return k;
+  }
+}
+function migrateModels(input) {
+  if (input.models.length === 0) {
+    return {
+      providers: input.providers,
+      models: [],
+      changed: false
+    };
+  }
+  const hasProvidersSection = input.providers.length > 0;
+  const keyCounts = /* @__PURE__ */ new Map();
+  for (const m of input.models) keyCounts.set(m.key, (keyCounts.get(m.key) ?? 0) + 1);
+  const needsMigration = input.models.some(
+    (m) => !m.providerKey || (keyCounts.get(m.key) ?? 0) > 1
+  );
+  if (!needsMigration) {
+    return {
+      providers: input.providers,
+      models: input.models.map((m) => ({
+        key: m.key,
+        label: m.label,
+        providerKey: m.providerKey ?? "",
+        model: m.model,
+        maxOutputTokens: m.maxOutputTokens,
+        maxContextTokens: m.maxContextTokens,
+        provider: m.provider,
+        baseUrl: m.baseUrl,
+        apiKey: m.apiKey
+      })),
+      changed: false
+    };
+  }
+  const fingerprintToKey = /* @__PURE__ */ new Map();
+  const newProviders = [];
+  const usedProviderKeys = new Set(input.providers.map((p) => p.key));
+  for (const p of input.providers) {
+    const fp = `${""}|${p.baseUrl}|${p.apiKey ?? ""}`;
+    fingerprintToKey.set(fp, p.key);
+  }
+  for (const m of input.models) {
+    const fp = makeFingerprint(m);
+    const existingByUrl = input.providers.find((p) => p.baseUrl === (m.baseUrl ?? ""));
+    if (existingByUrl) {
+      fingerprintToKey.set(fp, existingByUrl.key);
+      continue;
+    }
+    if (fingerprintToKey.has(fp)) continue;
+    const kind = inferKind(m.baseUrl);
+    const key = deriveKey(kind, usedProviderKeys);
+    usedProviderKeys.add(key);
+    fingerprintToKey.set(fp, key);
+    newProviders.push({
+      key,
+      kind,
+      baseUrl: m.baseUrl ?? "",
+      apiKey: m.apiKey
+    });
+  }
+  const usedModelKeys = /* @__PURE__ */ new Set();
+  const newModels = input.models.map((m) => {
+    const providerKey = fingerprintToKey.get(makeFingerprint(m));
+    const collides = (keyCounts.get(m.key) ?? 0) > 1;
+    let key = m.key;
+    if (collides) {
+      const kind = inferKind(m.baseUrl);
+      key = deriveProviderModelKey(kind, m.model, usedModelKeys);
+    }
+    if (usedModelKeys.has(key)) {
+      const kind = inferKind(m.baseUrl);
+      key = deriveProviderModelKey(kind, m.model, usedModelKeys);
+    }
+    usedModelKeys.add(key);
+    return {
+      key,
+      label: m.label,
+      providerKey,
+      provider: m.provider,
+      model: m.model,
+      baseUrl: m.baseUrl,
+      apiKey: m.apiKey,
+      maxOutputTokens: m.maxOutputTokens,
+      maxContextTokens: m.maxContextTokens
+    };
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = newModels.filter((m) => {
+    const fp = `${m.key}|${m.model}`;
+    if (seen.has(fp)) return false;
+    seen.add(fp);
+    return true;
+  });
+  return {
+    providers: hasProvidersSection ? [...input.providers, ...newProviders] : newProviders,
+    models: deduped,
+    changed: true
+  };
+}
+
+// src/settings/manager.ts
+function userHome() {
+  return process.env.HOME ?? homedir();
+}
+var SettingsManager = class {
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  sources = [];
+  merged = null;
+  /**
+   * Load settings from all sources.
+   */
+  load(flagOverrides) {
+    this.sources = [];
+    this.loadJsonFile(join(userHome(), ".code-shell", "settings.managed.json"), "managed", 0);
+    this.loadJsonFile(join(userHome(), ".code-shell", "settings.json"), "user", 1);
+    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.json"), "project", 2);
+    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.local.json"), "local", 3);
+    if (flagOverrides && Object.keys(flagOverrides).length > 0) {
+      this.sources.push({ name: "flag", priority: 4, data: flagOverrides });
+    }
+    this.sources.sort((a, b) => a.priority - b.priority);
+    const raw = this.deepMerge();
+    const userPath = join(userHome(), ".code-shell", "settings.json");
+    if (existsSync(userPath)) {
+      try {
+        const userRaw = JSON.parse(readFileSync(userPath, "utf-8"));
+        const result = migrateModels({
+          providers: userRaw.providers ?? [],
+          models: userRaw.models ?? []
+        });
+        if (result.changed) {
+          copyFileSync(userPath, `${userPath}.bak`);
+          const migrated = {
+            ...userRaw,
+            providers: result.providers,
+            models: result.models
+          };
+          writeFileSync(userPath, JSON.stringify(migrated, null, 2), "utf-8");
+          const userSource = this.sources.find((s) => s.name === "user");
+          if (userSource) userSource.data = migrated;
+          const remerged = this.deepMerge();
+          this.merged = validateSettings(remerged);
+          return this.merged;
+        }
+      } catch {
+      }
+    }
+    this.merged = validateSettings(raw);
+    return this.merged;
+  }
+  /**
+   * Get current effective settings.
+   */
+  get() {
+    if (!this.merged) return this.load();
+    return this.merged;
+  }
+  /**
+   * Invalidate cached merge.
+   */
+  invalidate() {
+    this.merged = null;
+  }
+  /**
+   * Persist a single setting (dotted key path) to the user-level config file
+   * at ~/.code-shell/settings.json. Other sources (project / local /
+   * managed) are intentionally untouched: writing back to project/local
+   * would surprise version control, and managed is read-only.
+   *
+   * The merged cache is invalidated so the next get() picks up the change.
+   */
+  saveUserSetting(key, value) {
+    const path = join(userHome(), ".code-shell", "settings.json");
+    let current = {};
+    if (existsSync(path)) {
+      try {
+        const raw = readFileSync(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          current = parsed;
+        }
+      } catch {
+      }
+    }
+    const parts = key.split(".");
+    let target = current;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const seg = parts[i];
+      const next = target[seg];
+      if (!next || typeof next !== "object" || Array.isArray(next)) {
+        target[seg] = {};
+      }
+      target = target[seg];
+    }
+    target[parts[parts.length - 1]] = value;
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(current, null, 2), "utf-8");
+    renameSync(tmp, path);
+    this.invalidate();
+  }
+  loadJsonFile(path, name, priority) {
+    if (!existsSync(path)) return;
+    try {
+      const content = readFileSync(path, "utf-8");
+      const data = JSON.parse(content);
+      if (typeof data === "object" && data !== null) {
+        this.sources.push({ name, priority, data });
+      }
+    } catch {
+    }
+  }
+  deepMerge() {
+    let result = {};
+    for (const source of this.sources) {
+      result = merge(result, source.data);
+    }
+    return result;
+  }
+};
+function merge(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === null) {
+      delete result[key];
+    } else if (typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && !Array.isArray(result[key]) && result[key] !== null) {
+      result[key] = merge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
+export {
+  SettingsSchema,
+  validateSettings,
+  SettingsManager
+};

package/dist/chunk-52LGZKT3.cjs

@@ -0,0 +1,47 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkKS3RYAYLcjs = require('./chunk-KS3RYAYL.cjs');
+
+// src/llm/model-cache.ts
+_chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('path');
+var TTL_MS = 7 * 24 * 3600 * 1e3;
+function readCache(cacheDir, providerKey) {
+  const path = _path.join.call(void 0, cacheDir, `${providerKey}.json`);
+  if (!_fs.existsSync.call(void 0, path)) return void 0;
+  try {
+    const raw = _fs.readFileSync.call(void 0, path, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.models)) return void 0;
+    return parsed;
+  } catch (e) {
+    return void 0;
+  }
+}
+function writeCache(cacheDir, providerKey, models) {
+  if (!_fs.existsSync.call(void 0, cacheDir)) _fs.mkdirSync.call(void 0, cacheDir, { recursive: true });
+  const payload = {
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    providerKey,
+    models
+  };
+  _fs.writeFileSync.call(void 0, _path.join.call(void 0, cacheDir, `${providerKey}.json`), JSON.stringify(payload, null, 2), "utf-8");
+  return payload;
+}
+function isStale(file, now = Date.now()) {
+  const ts = Date.parse(file.fetchedAt);
+  if (!Number.isFinite(ts)) return true;
+  return now - ts > TTL_MS;
+}
+function defaultCacheDir() {
+  return _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "cache", "models");
+}
+
+
+
+
+
+
+exports.readCache = readCache; exports.writeCache = writeCache; exports.isStale = isStale; exports.defaultCacheDir = defaultCacheDir;

package/dist/{chunk-KOGV6PDQ.cjs → chunk-55XGPMAP.cjs}

@@ -1,9 +1,12 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
 
-var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+var _chunk52LGZKT3cjs = require('./chunk-52LGZKT3.cjs');
+
+
+var _chunkKS3RYAYLcjs = require('./chunk-KS3RYAYL.cjs');
 
 // src/llm/model-pool.ts
-_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+_chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
 var BUILTIN_CONTEXT_WINDOWS = [
   // DeepSeek V4 family — 1M context (api-docs.deepseek.com)
   [/^deepseek-v4(?:-|$)/i, 1e6],
@@ -18,6 +21,32 @@ function lookupBuiltinContextWindow(model) {
 var ModelPool = (_class = class {
   __init() {this.models = /* @__PURE__ */ new Map()}
   
+  
+  
+  setProviderCatalog(cat) {
+    this.providerCatalog = cat;
+  }
+  setCacheDir(dir) {
+    this.cacheDir = dir;
+  }
+  /**
+   * For each entry in the pool that lacks an explicit maxContextTokens
+   * but has a providerKey, look up the contextLength from the cached
+   * model list and patch it in.
+   */
+  reloadCachedContextWindows() {
+    if (!this.cacheDir) return;
+    for (const [key, entry] of this.models) {
+      if (entry.maxContextTokens != null) continue;
+      if (!entry.providerKey) continue;
+      const file = _chunk52LGZKT3cjs.readCache.call(void 0, this.cacheDir, entry.providerKey);
+      if (!file) continue;
+      const match = file.models.find((m) => m.id === entry.model);
+      if (_optionalChain([match, 'optionalAccess', _ => _.contextLength])) {
+        this.models.set(key, { ...entry, maxContextTokens: match.contextLength });
+      }
+    }
+  }
   /**
    * Build a pool from an array of model entries.
    * The first entry (or the one matching `defaultKey`) becomes active.
@@ -30,7 +59,7 @@ var ModelPool = (_class = class {
     }
     if (defaultKey && this.models.has(defaultKey)) {
       this.activeKey = defaultKey;
-    } else if (_optionalChain([entries, 'optionalAccess', _ => _.length])) {
+    } else if (_optionalChain([entries, 'optionalAccess', _2 => _2.length])) {
       this.activeKey = entries[0].key;
     }
   }
@@ -85,14 +114,20 @@ var ModelPool = (_class = class {
    * (inherits apiKey, baseUrl, etc. from the base if not set on the entry).
    */
   toLLMConfig(entry, base) {
+    const fromCat = entry.providerKey && this.providerCatalog ? this.providerCatalog.get(entry.providerKey) : void 0;
+    const kindToClientProvider = (kind) => {
+      if (!kind) return "openai";
+      if (kind === "anthropic") return "anthropic";
+      return "openai";
+    };
     return {
-      provider: entry.provider,
+      provider: entry.provider || kindToClientProvider(_optionalChain([fromCat, 'optionalAccess', _3 => _3.kind])) || "openai",
       model: entry.model,
-      apiKey: _nullishCoalesce(entry.apiKey, () => ( _optionalChain([base, 'optionalAccess', _2 => _2.apiKey]))),
-      baseUrl: _nullishCoalesce(entry.baseUrl, () => ( _optionalChain([base, 'optionalAccess', _3 => _3.baseUrl]))),
-      temperature: _nullishCoalesce(_optionalChain([base, 'optionalAccess', _4 => _4.temperature]), () => ( 0.3)),
-      maxTokens: _nullishCoalesce(_nullishCoalesce(entry.maxOutputTokens, () => ( _optionalChain([base, 'optionalAccess', _5 => _5.maxTokens]))), () => ( 8192)),
-      enableStreaming: _nullishCoalesce(_optionalChain([base, 'optionalAccess', _6 => _6.enableStreaming]), () => ( true))
+      apiKey: _nullishCoalesce(_nullishCoalesce(entry.apiKey, () => ( _optionalChain([fromCat, 'optionalAccess', _4 => _4.apiKey]))), () => ( _optionalChain([base, 'optionalAccess', _5 => _5.apiKey]))),
+      baseUrl: _nullishCoalesce(_nullishCoalesce(entry.baseUrl, () => ( _optionalChain([fromCat, 'optionalAccess', _6 => _6.baseUrl]))), () => ( _optionalChain([base, 'optionalAccess', _7 => _7.baseUrl]))),
+      temperature: _nullishCoalesce(_optionalChain([base, 'optionalAccess', _8 => _8.temperature]), () => ( 0.3)),
+      maxTokens: _nullishCoalesce(_nullishCoalesce(entry.maxOutputTokens, () => ( _optionalChain([base, 'optionalAccess', _9 => _9.maxTokens]))), () => ( 8192)),
+      enableStreaming: _nullishCoalesce(_optionalChain([base, 'optionalAccess', _10 => _10.enableStreaming]), () => ( true))
     };
   }
   /**