@cjhyy/code-shell 0.1.5 → 0.1.7

package/dist/chunk-5ECBT4YA.js

@@ -1,450 +0,0 @@
-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(userHome(), ".claude", "settings.json"), "user", 1);
-    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.json"), "project", 2);
-    this.loadJsonFile(join(this.cwd, ".claude", "settings.json"), "project", 2);
-    this.loadJsonFile(join(this.cwd, ".code-shell", "settings.local.json"), "local", 3);
-    this.loadJsonFile(join(this.cwd, ".claude", "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
-};