@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-DI7RDLOS.js

@@ -0,0 +1,47 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.8_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.8_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toCommonJS,
+  init_esm_shims
+};

package/dist/chunk-DICG4AB7.cjs

@@ -0,0 +1,73 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+
+
+var _chunkEL2RL5DGcjs = require('./chunk-EL2RL5DG.cjs');
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/llm/client-base.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var LLMClientBase = (_class = class {
+  constructor(config) {;_class.prototype.__init.call(this);
+    this.config = config;
+    this.provider = config.provider;
+    this.model = config.model;
+    this.temperature = _nullishCoalesce(config.temperature, () => ( 0.3));
+    this.maxTokens = _nullishCoalesce(config.maxTokens, () => ( 8192));
+    this.timeout = _nullishCoalesce(config.timeout, () => ( 12e4));
+    this.retryMaxAttempts = _nullishCoalesce(config.retryMaxAttempts, () => ( 3));
+    this.enableStreaming = _nullishCoalesce(config.enableStreaming, () => ( true));
+    this.initClient();
+  }
+  
+  
+  
+  
+  
+  
+  
+  __init() {this.usage = {
+    records: [],
+    totalPromptTokens: 0,
+    totalCompletionTokens: 0,
+    totalTokens: 0,
+    requestCount: 0
+  }}
+  recordUsage(usage) {
+    this.usage.records.push(usage);
+    this.usage.totalPromptTokens += usage.promptTokens;
+    this.usage.totalCompletionTokens += usage.completionTokens;
+    this.usage.totalTokens += usage.totalTokens;
+    this.usage.requestCount++;
+  }
+  getUsage() {
+    return { ...this.usage };
+  }
+  async withRetry(fn, maxAttempts) {
+    const attempts = _nullishCoalesce(maxAttempts, () => ( this.retryMaxAttempts));
+    let lastError;
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (err instanceof _chunkEL2RL5DGcjs.ContextLimitError) throw err;
+        if (err instanceof _chunkEL2RL5DGcjs.LLMRateLimitError) {
+          const waitMs = (_nullishCoalesce(err.retryAfter, () => ( attempt * 2))) * 1e3;
+          await new Promise((r) => setTimeout(r, waitMs));
+          continue;
+        }
+        if (attempt === attempts) break;
+        const backoff = Math.min(1e3 * Math.pow(2, attempt - 1), 3e4);
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+    }
+    throw _nullishCoalesce(lastError, () => ( new (0, _chunkEL2RL5DGcjs.LLMError)("Unknown LLM error")));
+  }
+}, _class);
+
+
+
+exports.LLMClientBase = LLMClientBase;

package/dist/chunk-EL2RL5DG.cjs

@@ -0,0 +1,101 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/exceptions.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var FrameworkError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "FrameworkError";
+  }
+};
+var LLMError = class extends FrameworkError {
+  constructor(message, provider, details) {
+    super(message, details);
+    this.provider = provider;
+    this.name = "LLMError";
+  }
+};
+var LLMRateLimitError = class extends LLMError {
+  constructor(provider, retryAfter) {
+    super(`Rate limit exceeded for ${provider}`, provider, { retryAfter });
+    this.retryAfter = retryAfter;
+    this.name = "LLMRateLimitError";
+  }
+};
+var ContextLimitError = class extends LLMError {
+  constructor(provider) {
+    super("Context limit exceeded", provider);
+    this.name = "ContextLimitError";
+  }
+};
+var ToolError = class extends FrameworkError {
+  constructor(message, toolName, details) {
+    super(message, details);
+    this.toolName = toolName;
+    this.name = "ToolError";
+  }
+};
+var ToolNotFoundError = class extends ToolError {
+  constructor(toolName) {
+    super(`Tool not found: ${toolName}`, toolName);
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolExecutionError = class extends ToolError {
+  constructor(toolName, cause) {
+    super(`Tool execution failed: ${toolName} - ${cause}`, toolName, { cause });
+    this.name = "ToolExecutionError";
+  }
+};
+var ToolTimeoutError = class extends ToolError {
+  constructor(toolName, timeoutMs) {
+    super(`Tool timed out after ${timeoutMs}ms: ${toolName}`, toolName, { timeoutMs });
+    this.timeoutMs = timeoutMs;
+    this.name = "ToolTimeoutError";
+  }
+};
+var PermissionDeniedError = class extends FrameworkError {
+  constructor(toolName, reason) {
+    super(`Permission denied for tool: ${toolName}${reason ? ` - ${reason}` : ""}`, {
+      toolName,
+      reason
+    });
+    this.name = "PermissionDeniedError";
+  }
+};
+var SessionError = class extends FrameworkError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "SessionError";
+  }
+};
+var TranscriptError = class extends FrameworkError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "TranscriptError";
+  }
+};
+var ConfigError = class extends FrameworkError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "ConfigError";
+  }
+};
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.FrameworkError = FrameworkError; exports.LLMError = LLMError; exports.LLMRateLimitError = LLMRateLimitError; exports.ContextLimitError = ContextLimitError; exports.ToolError = ToolError; exports.ToolNotFoundError = ToolNotFoundError; exports.ToolExecutionError = ToolExecutionError; exports.ToolTimeoutError = ToolTimeoutError; exports.PermissionDeniedError = PermissionDeniedError; exports.SessionError = SessionError; exports.TranscriptError = TranscriptError; exports.ConfigError = ConfigError;

package/dist/chunk-FGZGCFJX.cjs

@@ -0,0 +1,207 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class;
+
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/settings/schema.ts
+var _zod = require('zod');
+function validateSettings(raw) {
+  return SettingsSchema.parse(raw);
+}
+var SettingsSchema;
+var init_schema = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+  "src/settings/schema.ts"() {
+    "use strict";
+    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    SettingsSchema = exports.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()
+        })
+      ).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"]),
+        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();
+  }
+});
+
+// src/settings/manager.ts
+var manager_exports = {};
+_chunkIJSHQGMPcjs.__export.call(void 0, manager_exports, {
+  SettingsManager: () => SettingsManager
+});
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+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;
+}
+var SettingsManager;
+var init_manager = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+  "src/settings/manager.ts"() {
+    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    init_schema();
+    SettingsManager = exports.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;
+      }
+      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 (e) {
+        }
+      }
+      deepMerge() {
+        let result = {};
+        for (const source of this.sources) {
+          result = merge(result, source.data);
+        }
+        return result;
+      }
+    }, _class);
+  }
+});
+
+
+
+
+
+
+
+
+exports.SettingsSchema = SettingsSchema; exports.validateSettings = validateSettings; exports.init_schema = init_schema; exports.SettingsManager = SettingsManager; exports.manager_exports = manager_exports; exports.init_manager = init_manager;

package/dist/chunk-FUOKLKR2.js

@@ -0,0 +1,101 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/exceptions.ts
+init_esm_shims();
+var FrameworkError = class extends Error {
+  constructor(message, details) {
+    super(message);
+    this.details = details;
+    this.name = "FrameworkError";
+  }
+};
+var LLMError = class extends FrameworkError {
+  constructor(message, provider, details) {
+    super(message, details);
+    this.provider = provider;
+    this.name = "LLMError";
+  }
+};
+var LLMRateLimitError = class extends LLMError {
+  constructor(provider, retryAfter) {
+    super(`Rate limit exceeded for ${provider}`, provider, { retryAfter });
+    this.retryAfter = retryAfter;
+    this.name = "LLMRateLimitError";
+  }
+};
+var ContextLimitError = class extends LLMError {
+  constructor(provider) {
+    super("Context limit exceeded", provider);
+    this.name = "ContextLimitError";
+  }
+};
+var ToolError = class extends FrameworkError {
+  constructor(message, toolName, details) {
+    super(message, details);
+    this.toolName = toolName;
+    this.name = "ToolError";
+  }
+};
+var ToolNotFoundError = class extends ToolError {
+  constructor(toolName) {
+    super(`Tool not found: ${toolName}`, toolName);
+    this.name = "ToolNotFoundError";
+  }
+};
+var ToolExecutionError = class extends ToolError {
+  constructor(toolName, cause) {
+    super(`Tool execution failed: ${toolName} - ${cause}`, toolName, { cause });
+    this.name = "ToolExecutionError";
+  }
+};
+var ToolTimeoutError = class extends ToolError {
+  constructor(toolName, timeoutMs) {
+    super(`Tool timed out after ${timeoutMs}ms: ${toolName}`, toolName, { timeoutMs });
+    this.timeoutMs = timeoutMs;
+    this.name = "ToolTimeoutError";
+  }
+};
+var PermissionDeniedError = class extends FrameworkError {
+  constructor(toolName, reason) {
+    super(`Permission denied for tool: ${toolName}${reason ? ` - ${reason}` : ""}`, {
+      toolName,
+      reason
+    });
+    this.name = "PermissionDeniedError";
+  }
+};
+var SessionError = class extends FrameworkError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "SessionError";
+  }
+};
+var TranscriptError = class extends FrameworkError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "TranscriptError";
+  }
+};
+var ConfigError = class extends FrameworkError {
+  constructor(message, details) {
+    super(message, details);
+    this.name = "ConfigError";
+  }
+};
+
+export {
+  FrameworkError,
+  LLMError,
+  LLMRateLimitError,
+  ContextLimitError,
+  ToolError,
+  ToolNotFoundError,
+  ToolExecutionError,
+  ToolTimeoutError,
+  PermissionDeniedError,
+  SessionError,
+  TranscriptError,
+  ConfigError
+};