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

package/dist/chunk-FV2ARONZ.cjs

@@ -0,0 +1,224 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/settings/manager.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+
+// src/settings/schema.ts
+_chunkIJSHQGMPcjs.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({}),
+  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({}),
+  models: _zod.z.array(
+    _zod.z.object({
+      key: _zod.z.string(),
+      label: _zod.z.string().optional(),
+      provider: _zod.z.string(),
+      model: _zod.z.string(),
+      baseUrl: _zod.z.string().optional(),
+      apiKey: _zod.z.string().optional(),
+      maxOutputTokens: _zod.z.number().optional(),
+      maxContextTokens: _zod.z.number().optional()
+    })
+  ).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/settings/manager.ts
+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, _os.homedir.call(void 0, ), ".code-shell", "settings.managed.json"), "managed", 0);
+    this.loadJsonFile(_path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "settings.json"), "user", 1);
+    this.loadJsonFile(_path.join.call(void 0, _os.homedir.call(void 0, ), ".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();
+    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, _os.homedir.call(void 0, ), ".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 (e) {
+      }
+    }
+    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 (e2) {
+    }
+  }
+  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-DICG4AB7.cjs → chunk-GZBD6QRS.cjs}

@@ -1,15 +1,18 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+"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 _chunkEL2RL5DGcjs = require('./chunk-EL2RL5DG.cjs');
 
 
+var _chunkJHNCK7JPcjs = require('./chunk-JHNCK7JP.cjs');
+
+
 var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
 
 // src/llm/client-base.ts
 _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
-var LLMClientBase = (_class = class {
+var LLMClientBase = (_class = class _LLMClientBase {
   constructor(config) {;_class.prototype.__init.call(this);
     this.config = config;
     this.provider = config.provider;
@@ -28,6 +31,13 @@ var LLMClientBase = (_class = class {
   
   
   
+  /**
+   * Process-wide hook fired on every LLM response. The CLI installs this in
+   * main.ts to feed the cost tracker; lives on the base class so every code
+   * path (REPL, run, arena, sub-agents) reports through one funnel without
+   * each call site needing to remember.
+   */
+  
   __init() {this.usage = {
     records: [],
     totalPromptTokens: 0,
@@ -41,6 +51,7 @@ var LLMClientBase = (_class = class {
     this.usage.totalCompletionTokens += usage.completionTokens;
     this.usage.totalTokens += usage.totalTokens;
     this.usage.requestCount++;
+    _optionalChain([_LLMClientBase, 'access', _ => _.onUsage, 'optionalCall', _2 => _2(this.model, usage)]);
   }
   getUsage() {
     return { ...this.usage };
@@ -56,11 +67,39 @@ var LLMClientBase = (_class = class {
         if (err instanceof _chunkEL2RL5DGcjs.ContextLimitError) throw err;
         if (err instanceof _chunkEL2RL5DGcjs.LLMRateLimitError) {
           const waitMs = (_nullishCoalesce(err.retryAfter, () => ( attempt * 2))) * 1e3;
+          _chunkJHNCK7JPcjs.logger.warn("llm.retry", {
+            cat: "llm",
+            provider: this.provider,
+            model: this.model,
+            attempt,
+            of: attempts,
+            reason: "rate_limit",
+            waitMs
+          });
           await new Promise((r) => setTimeout(r, waitMs));
           continue;
         }
-        if (attempt === attempts) break;
+        if (attempt === attempts) {
+          _chunkJHNCK7JPcjs.logger.error("llm.exhausted", {
+            cat: "llm",
+            provider: this.provider,
+            model: this.model,
+            attempts,
+            error: err.message
+          });
+          break;
+        }
         const backoff = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
+        _chunkJHNCK7JPcjs.logger.warn("llm.retry", {
+          cat: "llm",
+          provider: this.provider,
+          model: this.model,
+          attempt,
+          of: attempts,
+          reason: "error",
+          error: err.message,
+          backoffMs: backoff
+        });
         await new Promise((r) => setTimeout(r, backoff));
       }
     }