@cjhyy/code-shell 0.1.0-alpha.2 → 0.1.5

package/dist/chunk-YUI524OE.cjs

@@ -0,0 +1,450 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+var _chunkKS3RYAYLcjs = require('./chunk-KS3RYAYL.cjs');
+
+// src/settings/manager.ts
+_chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
+
+
+
+
+
+
+
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+
+// src/settings/schema.ts
+_chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
+var _zod = require('zod');
+var SettingsSchema = _zod.z.object({
+  agent: _zod.z.object({
+    // Use z.string() instead of z.enum() to allow custom presets registered via registerPreset()
+    preset: _zod.z.string().default("terminal-coding"),
+    enabledBuiltinTools: _zod.z.array(_zod.z.string()).default([]),
+    disabledBuiltinTools: _zod.z.array(_zod.z.string()).default([]),
+    customSystemPrompt: _zod.z.string().optional(),
+    appendSystemPrompt: _zod.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: _zod.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: _zod.z.boolean().default(true),
+  model: _zod.z.object({
+    provider: _zod.z.string().default("openai"),
+    name: _zod.z.string().default("anthropic/claude-opus-4-6"),
+    apiKey: _zod.z.string().optional(),
+    baseUrl: _zod.z.string().default("https://openrouter.ai/api/v1"),
+    temperature: _zod.z.number().min(0).max(2).default(0.3),
+    maxTokens: _zod.z.number().default(8192)
+  }).default({}),
+  providers: _zod.z.array(
+    _zod.z.object({
+      key: _zod.z.string(),
+      label: _zod.z.string().optional(),
+      kind: _zod.z.enum([
+        "openai",
+        "anthropic",
+        "deepseek",
+        "xai",
+        "mistral",
+        "groq",
+        "google",
+        "openrouter",
+        "ollama",
+        "custom"
+      ]),
+      baseUrl: _zod.z.string(),
+      apiKey: _zod.z.string().optional(),
+      protocol: _zod.z.enum(["openai-compat", "anthropic-style"]).optional(),
+      modelsPath: _zod.z.string().optional()
+    })
+  ).default([]),
+  models: _zod.z.array(
+    _zod.z.object({
+      key: _zod.z.string(),
+      label: _zod.z.string().optional(),
+      providerKey: _zod.z.string().optional(),
+      model: _zod.z.string(),
+      maxOutputTokens: _zod.z.number().optional(),
+      maxContextTokens: _zod.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: _zod.z.string().optional(),
+      provider: _zod.z.string().optional(),
+      baseUrl: _zod.z.string().optional(),
+      apiKey: _zod.z.string().optional()
+    }).transform((m) => {
+      const effective = _nullishCoalesce(m.protocol, () => ( m.provider));
+      return {
+        ...m,
+        protocol: effective,
+        provider: effective
+      };
+    })
+  ).default([]),
+  permissions: _zod.z.object({
+    defaultMode: _zod.z.enum(["default", "acceptEdits", "dontAsk", "bypassPermissions", "auto", "plan"]).default("default"),
+    rules: _zod.z.array(
+      _zod.z.object({
+        tool: _zod.z.string(),
+        argsPattern: _zod.z.record(_zod.z.string()).optional(),
+        decision: _zod.z.enum(["allow", "deny", "ask"]),
+        reason: _zod.z.string().optional()
+      })
+    ).default([])
+  }).default({}),
+  context: _zod.z.object({
+    maxTokens: _zod.z.number().default(2e5),
+    compactAtRatio: _zod.z.number().default(0.6),
+    summarizeAtRatio: _zod.z.number().default(0.8)
+  }).default({}),
+  session: _zod.z.object({
+    storageDir: _zod.z.string().optional(),
+    maxHistory: _zod.z.number().default(100)
+  }).default({}),
+  mcpServers: _zod.z.record(
+    _zod.z.object({
+      name: _zod.z.string(),
+      command: _zod.z.string().optional(),
+      args: _zod.z.array(_zod.z.string()).optional(),
+      env: _zod.z.record(_zod.z.string()).optional(),
+      url: _zod.z.string().optional(),
+      transport: _zod.z.enum(["stdio", "sse", "streamable-http", "inprocess"]).optional(),
+      headers: _zod.z.record(_zod.z.string()).optional()
+    })
+  ).default({}),
+  instructions: _zod.z.object({
+    fileName: _zod.z.string().default("CODESHELL.md"),
+    scanDirs: _zod.z.array(_zod.z.string()).default([]),
+    compatFileNames: _zod.z.array(_zod.z.string()).default(["CLAUDE.md", "AGENTS.md"]),
+    ignoreGitBoundary: _zod.z.boolean().default(false)
+  }).default({}),
+  arena: _zod.z.object({
+    participants: _zod.z.array(
+      _zod.z.union([
+        // Short form: just a model pool key
+        _zod.z.string(),
+        // Full form: explicit config (backward compat)
+        _zod.z.object({
+          name: _zod.z.string(),
+          model: _zod.z.string(),
+          provider: _zod.z.string().optional(),
+          apiKey: _zod.z.string().optional(),
+          baseUrl: _zod.z.string().optional()
+        })
+      ])
+    ).default([])
+  }).default({}),
+  search: _zod.z.object({
+    provider: _zod.z.enum(["serper", "tavily", "searxng"]).default("serper"),
+    apiKey: _zod.z.string().optional(),
+    baseUrl: _zod.z.string().optional()
+  }).default({}),
+  output: _zod.z.object({
+    format: _zod.z.enum(["text", "json", "jsonl", "stream-json"]).default("text")
+  }).default({})
+}).passthrough();
+function validateSettings(raw) {
+  return SettingsSchema.parse(raw);
+}
+
+// src/cli/migrate-models.ts
+_chunkKS3RYAYLcjs.init_cjs_shims.call(void 0, );
+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 `${_nullishCoalesce(m.provider, () => ( ""))}|${_nullishCoalesce(m.baseUrl, () => ( ""))}|${_nullishCoalesce(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, (_nullishCoalesce(keyCounts.get(m.key), () => ( 0))) + 1);
+  const needsMigration = input.models.some(
+    (m) => !m.providerKey || (_nullishCoalesce(keyCounts.get(m.key), () => ( 0))) > 1
+  );
+  if (!needsMigration) {
+    return {
+      providers: input.providers,
+      models: input.models.map((m) => ({
+        key: m.key,
+        label: m.label,
+        providerKey: _nullishCoalesce(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}|${_nullishCoalesce(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 === (_nullishCoalesce(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: _nullishCoalesce(m.baseUrl, () => ( "")),
+      apiKey: m.apiKey
+    });
+  }
+  const usedModelKeys = /* @__PURE__ */ new Set();
+  const newModels = input.models.map((m) => {
+    const providerKey = fingerprintToKey.get(makeFingerprint(m));
+    const collides = (_nullishCoalesce(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 _nullishCoalesce(process.env.HOME, () => ( _os.homedir.call(void 0, )));
+}
+var SettingsManager = (_class = class {
+  constructor(cwd = process.cwd()) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.cwd = cwd;
+  }
+  __init() {this.sources = []}
+  __init2() {this.merged = null}
+  /**
+   * Load settings from all sources.
+   */
+  load(flagOverrides) {
+    this.sources = [];
+    this.loadJsonFile(_path.join.call(void 0, userHome(), ".code-shell", "settings.managed.json"), "managed", 0);
+    this.loadJsonFile(_path.join.call(void 0, userHome(), ".code-shell", "settings.json"), "user", 1);
+    this.loadJsonFile(_path.join.call(void 0, userHome(), ".claude", "settings.json"), "user", 1);
+    this.loadJsonFile(_path.join.call(void 0, this.cwd, ".code-shell", "settings.json"), "project", 2);
+    this.loadJsonFile(_path.join.call(void 0, this.cwd, ".claude", "settings.json"), "project", 2);
+    this.loadJsonFile(_path.join.call(void 0, this.cwd, ".code-shell", "settings.local.json"), "local", 3);
+    this.loadJsonFile(_path.join.call(void 0, 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 = _path.join.call(void 0, userHome(), ".code-shell", "settings.json");
+    if (_fs.existsSync.call(void 0, userPath)) {
+      try {
+        const userRaw = JSON.parse(_fs.readFileSync.call(void 0, userPath, "utf-8"));
+        const result = migrateModels({
+          providers: _nullishCoalesce(userRaw.providers, () => ( [])),
+          models: _nullishCoalesce(userRaw.models, () => ( []))
+        });
+        if (result.changed) {
+          _fs.copyFileSync.call(void 0, userPath, `${userPath}.bak`);
+          const migrated = {
+            ...userRaw,
+            providers: result.providers,
+            models: result.models
+          };
+          _fs.writeFileSync.call(void 0, 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 (e) {
+      }
+    }
+    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 = _path.join.call(void 0, userHome(), ".code-shell", "settings.json");
+    let current = {};
+    if (_fs.existsSync.call(void 0, path)) {
+      try {
+        const raw = _fs.readFileSync.call(void 0, path, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          current = parsed;
+        }
+      } catch (e2) {
+      }
+    }
+    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;
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, path), { recursive: true });
+    const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+    _fs.writeFileSync.call(void 0, tmp, JSON.stringify(current, null, 2), "utf-8");
+    _fs.renameSync.call(void 0, tmp, path);
+    this.invalidate();
+  }
+  loadJsonFile(path, name, priority) {
+    if (!_fs.existsSync.call(void 0, path)) return;
+    try {
+      const content = _fs.readFileSync.call(void 0, path, "utf-8");
+      const data = JSON.parse(content);
+      if (typeof data === "object" && data !== null) {
+        this.sources.push({ name, priority, data });
+      }
+    } catch (e3) {
+    }
+  }
+  deepMerge() {
+    let result = {};
+    for (const source of this.sources) {
+      result = merge(result, source.data);
+    }
+    return result;
+  }
+}, _class);
+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;
+}
+
+
+
+
+
+exports.SettingsSchema = SettingsSchema; exports.validateSettings = validateSettings; exports.SettingsManager = SettingsManager;

package/dist/{chunk-M2SVOKC6.js → chunk-ZBPSQCPU.js}

@@ -1,17 +1,17 @@
 import {
   LLMClientBase
-} from "./chunk-SCDKLTN3.js";
+} from "./chunk-6S4BJ65N.js";
 import {
   ContextLimitError,
   LLMError,
   LLMRateLimitError
-} from "./chunk-FUOKLKR2.js";
+} from "./chunk-SFXHZSRF.js";
 import {
   logger
-} from "./chunk-ZRVPCXI7.js";
+} from "./chunk-BXCY2FSE.js";
 import {
   init_esm_shims
-} from "./chunk-DI7RDLOS.js";
+} from "./chunk-MD32R22I.js";
 
 // src/llm/providers/anthropic.ts
 init_esm_shims();
@@ -87,7 +87,7 @@ var AnthropicClient = class extends LLMClientBase {
         cacheReadTokens: response.usage.cache_read_input_tokens,
         cacheCreationTokens: response.usage.cache_creation_input_tokens
       };
-      this.recordUsage(usage);
+      this.recordUsage(usage, options);
       return this.processResponse(response, usage);
     } catch (err) {
       this.handleApiError(err);
@@ -164,7 +164,7 @@ var AnthropicClient = class extends LLMClientBase {
         cacheReadTokens: finalMessage.usage.cache_read_input_tokens,
         cacheCreationTokens: finalMessage.usage.cache_creation_input_tokens
       };
-      this.recordUsage(usage);
+      this.recordUsage(usage, options);
       options.onChunk?.({ type: "stop", stopReason: finalMessage.stop_reason ?? void 0 });
       return this.processResponse(finalMessage, usage);
     } catch (err) {

package/dist/cli/commands/builtin/export-md.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Markdown renderer for `/export markdown`.
+ *
+ * Goals (versus the legacy one-JSON-line-per-turn dump):
+ *   • Every turn is numbered and role-tagged
+ *   • Reasoning blocks are collapsible (<details>) — present but not noisy
+ *   • tool_use shows tool name + truncated args inline
+ *   • tool_result over a threshold spills to a sidecar file alongside the md
+ *   • Long lines never exceed ~2 KB inline so editors stay responsive
+ */
+export interface Sidecar {
+    path: string;
+    content: string;
+}
+export interface RenderedSession {
+    md: string;
+    sidecars: Sidecar[];
+}
+export declare function renderSessionMarkdown(sessionId: string, events: unknown[], cwd: string): RenderedSession;

package/dist/cli/commands/builtin/init/detect.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Detection — what does the cwd already contain?
+ *
+ * Drives the four-way intent decision in pickIntent. Synchronous and bounded
+ * (≤ a handful of stat calls + one capped directory walk) so /init can pick a
+ * mode without spawning an LLM turn just for classification.
+ */
+export interface Detection {
+    hasCodeshell: boolean;
+    hasClaude: boolean;
+    hasAgents: boolean;
+    hasCursorRules: boolean;
+    hasCursorRulesDir: boolean;
+    hasWindsurfRules: boolean;
+    hasClinerules: boolean;
+    hasCopilotInstructions: boolean;
+    hasCodeshellRulesDir: boolean;
+    hasManifest: boolean;
+    hasSourceFiles: boolean;
+    hasReadme: boolean;
+}
+export type Intent = "improve" | "migrate" | "create" | "empty";
+export declare function detect(cwd: string): Detection;
+export declare function pickIntent(d: Detection): Intent;
+export declare function summarize(d: Detection): string;

package/dist/cli/commands/builtin/init/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `/init` — bootstrap CODESHELL.md for the current repo.
+ *
+ * Scope: documentation only. This command never writes to settings.json or
+ * settings.local.json — those belong to Code Shell's own onboarding/permission
+ * flows and must stay decoupled from arbitrary target repos.
+ *
+ * Four intents, picked from cwd state:
+ *   improve  — CODESHELL.md already exists; LLM edits in place with diffs.
+ *   migrate  — other AI configs (CLAUDE.md, .cursorrules, ...) exist; LLM
+ *              treats them as investigation sources and synthesizes.
+ *   create   — code present (manifest/source/README) but no AI config; LLM
+ *              surveys the repo and writes from scratch.
+ *   empty    — truly empty repo; LLM asks the user a few questions via the
+ *              AskUserQuestion tool, then writes (with TODO placeholders as
+ *              needed). Hard limit: ≤4 AskUserQuestion calls per prompt.
+ */
+import type { SlashCommand } from "../../registry.js";
+export declare const initCommand: SlashCommand;