@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-5LHVI777.cjs

@@ -0,0 +1,246 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } var _class;
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/cli/cost-tracker.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _chalk = require('chalk'); var _chalk2 = _interopRequireDefault(_chalk);
+function pricing(input, output) {
+  return { input, output, cacheRead: input * 0.1, cacheWrite: input * 1.25 };
+}
+var MODEL_PRICING = {
+  // Anthropic (per 1M tokens, USD)
+  "claude-opus-4.6": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4-6": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  // alias
+  "claude-opus-4.5": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4.1": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-opus-4": { input: 15, output: 75, cacheRead: 1.5, cacheWrite: 18.75 },
+  "claude-sonnet-4.6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4-6": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  // alias
+  "claude-sonnet-4.5": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-sonnet-4": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3.7-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3-7-sonnet": { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
+  "claude-3.5-haiku": { input: 0.8, output: 4, cacheRead: 0.08, cacheWrite: 1 },
+  "claude-haiku-4.5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  "claude-haiku-4-5": { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
+  // alias
+  // OpenAI
+  "gpt-5.4": pricing(5, 20),
+  "gpt-5.4-mini": pricing(1.5, 6),
+  "gpt-5.4-pro": pricing(10, 40),
+  "gpt-5": pricing(5, 20),
+  "gpt-4o": pricing(2.5, 10),
+  "gpt-4o-mini": pricing(0.15, 0.6),
+  "gpt-4.1": pricing(2, 8),
+  "gpt-4.1-mini": pricing(0.4, 1.6),
+  "o4-mini": pricing(1.1, 4.4),
+  "o3": pricing(10, 40),
+  "o3-mini": pricing(1.1, 4.4),
+  // Google
+  "gemini-2.5-pro": pricing(1.25, 10),
+  "gemini-2.5-pro-preview": pricing(1.25, 10),
+  "gemini-2.5-flash": pricing(0.15, 0.6),
+  "gemini-3.1-pro-preview": pricing(2, 10),
+  "gemini-3-flash-preview": pricing(0.15, 0.6),
+  "gemini-2.0-flash": pricing(0.1, 0.4),
+  // DeepSeek
+  "deepseek-v3.2": pricing(0.14, 0.28),
+  "deepseek-chat": pricing(0.14, 0.28),
+  "deepseek-r1": pricing(0.55, 2.19),
+  "deepseek-reasoner": pricing(0.55, 2.19),
+  // Qwen
+  "qwen3-coder": pricing(0.3, 0.6),
+  "qwen3-235b-a22b": pricing(0.3, 1.2),
+  "qwen3-30b-a3b": pricing(0.1, 0.3),
+  "qwen3-max": pricing(0.5, 2),
+  // Meta
+  "llama-4-maverick": pricing(0.2, 0.8),
+  "llama-4-scout": pricing(0.15, 0.4),
+  // Mistral
+  "devstral-medium": pricing(0.5, 1.5),
+  "mistral-large": pricing(2, 6),
+  "devstral-small": pricing(0.1, 0.3)
+};
+var DEFAULT_PRICING = pricing(3, 15);
+function getCanonicalName(model) {
+  const slashIdx = model.lastIndexOf("/");
+  const base = slashIdx >= 0 ? model.slice(slashIdx + 1) : model;
+  return base.replace(/-\d{8}$/, "");
+}
+var CostTracker = (_class = class {constructor() { _class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this); }
+  __init() {this.records = []}
+  __init2() {this.sessionStart = Date.now()}
+  __init3() {this._hasUnknownModel = false}
+  record(model, promptTokens, completionTokens, isSubAgent = false, cacheReadTokens = 0, cacheWriteTokens = 0) {
+    const canonical = getCanonicalName(model);
+    if (!MODEL_PRICING[canonical] && !MODEL_PRICING[model]) {
+      this._hasUnknownModel = true;
+    }
+    this.records.push({
+      model: canonical,
+      promptTokens,
+      completionTokens,
+      cacheReadTokens,
+      cacheWriteTokens,
+      totalTokens: promptTokens + completionTokens,
+      timestamp: Date.now(),
+      isSubAgent
+    });
+  }
+  getTotalTokens() {
+    let prompt = 0;
+    let completion = 0;
+    for (const r of this.records) {
+      prompt += r.promptTokens;
+      completion += r.completionTokens;
+    }
+    return { prompt, completion, total: prompt + completion };
+  }
+  getEstimatedCost() {
+    let totalCost = 0;
+    for (const r of this.records) {
+      const p = _nullishCoalesce(MODEL_PRICING[r.model], () => ( DEFAULT_PRICING));
+      const uncachedInput = Math.max(0, r.promptTokens - r.cacheReadTokens - r.cacheWriteTokens);
+      totalCost += uncachedInput / 1e6 * p.input;
+      totalCost += r.completionTokens / 1e6 * p.output;
+      totalCost += r.cacheReadTokens / 1e6 * p.cacheRead;
+      totalCost += r.cacheWriteTokens / 1e6 * p.cacheWrite;
+    }
+    return totalCost;
+  }
+  getRequestCount() {
+    return this.records.length;
+  }
+  getSessionDuration() {
+    return Date.now() - this.sessionStart;
+  }
+  /** Estimate cost for a specific set of tokens without recording them. */
+  estimateForTokens(model, promptTokens, completionTokens, cacheReadTokens = 0, cacheWriteTokens = 0) {
+    const canonical = getCanonicalName(model);
+    const p = _nullishCoalesce(_nullishCoalesce(MODEL_PRICING[canonical], () => ( MODEL_PRICING[model])), () => ( DEFAULT_PRICING));
+    const uncachedInput = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+    return uncachedInput / 1e6 * p.input + completionTokens / 1e6 * p.output + cacheReadTokens / 1e6 * p.cacheRead + cacheWriteTokens / 1e6 * p.cacheWrite;
+  }
+  /**
+   * Get total cache token counts.
+   */
+  getCacheTokens() {
+    let cacheRead = 0;
+    let cacheWrite = 0;
+    for (const r of this.records) {
+      cacheRead += r.cacheReadTokens;
+      cacheWrite += r.cacheWriteTokens;
+    }
+    return { cacheRead, cacheWrite };
+  }
+  /**
+   * Format a styled cost summary for terminal display.
+   */
+  formatSummary() {
+    const tokens = this.getTotalTokens();
+    const cache = this.getCacheTokens();
+    const cost = this.getEstimatedCost();
+    const requests = this.getRequestCount();
+    const duration = this.getSessionDuration();
+    const lines = [];
+    lines.push(`  ${_chalk2.default.bold.cyan("Cost Summary")}`);
+    lines.push(_chalk2.default.dim("  \u2500".repeat(25)));
+    lines.push(`    ${_chalk2.default.dim("Requests:")}      ${_chalk2.default.white(String(requests))}`);
+    lines.push(`    ${_chalk2.default.dim("Input tokens:")}  ${_chalk2.default.white(formatNumber(tokens.prompt))}`);
+    lines.push(`    ${_chalk2.default.dim("Output tokens:")} ${_chalk2.default.white(formatNumber(tokens.completion))}`);
+    if (cache.cacheRead > 0 || cache.cacheWrite > 0) {
+      lines.push(`    ${_chalk2.default.dim("Cache read:")}    ${_chalk2.default.white(formatNumber(cache.cacheRead))}`);
+      lines.push(`    ${_chalk2.default.dim("Cache write:")}   ${_chalk2.default.white(formatNumber(cache.cacheWrite))}`);
+    }
+    lines.push(`    ${_chalk2.default.dim("Total cost:")}    ${_chalk2.default.green(formatCost(cost))}`);
+    lines.push(`    ${_chalk2.default.dim("Duration:")}      ${_chalk2.default.white(formatDuration(duration))}`);
+    const modelMap = /* @__PURE__ */ new Map();
+    for (const r of this.records) {
+      const existing = _nullishCoalesce(modelMap.get(r.model), () => ( { prompt: 0, completion: 0, cacheRead: 0, cacheWrite: 0, count: 0 }));
+      existing.prompt += r.promptTokens;
+      existing.completion += r.completionTokens;
+      existing.cacheRead += r.cacheReadTokens;
+      existing.cacheWrite += r.cacheWriteTokens;
+      existing.count++;
+      modelMap.set(r.model, existing);
+    }
+    if (modelMap.size >= 1) {
+      lines.push("");
+      lines.push(`    ${_chalk2.default.dim("By model:")}`);
+      for (const [model, stats] of modelMap) {
+        const p = _nullishCoalesce(MODEL_PRICING[model], () => ( DEFAULT_PRICING));
+        const uncachedInput = Math.max(0, stats.prompt - stats.cacheRead - stats.cacheWrite);
+        const modelCost = uncachedInput / 1e6 * p.input + stats.completion / 1e6 * p.output + stats.cacheRead / 1e6 * p.cacheRead + stats.cacheWrite / 1e6 * p.cacheWrite;
+        const tokenDetail = `${formatNumber(stats.prompt)} in, ${formatNumber(stats.completion)} out` + (stats.cacheRead > 0 ? `, ${formatNumber(stats.cacheRead)} cache` : "");
+        lines.push(
+          `      ${_chalk2.default.dim(model)} \u2014 ${tokenDetail}, ${formatCost(modelCost)} (${stats.count} reqs)`
+        );
+      }
+    }
+    if (this._hasUnknownModel) {
+      lines.push("");
+      lines.push(_chalk2.default.dim("    (costs may be inaccurate due to usage of unknown models)"));
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Format a compact one-line cost display for the prompt footer.
+   */
+  formatCompact() {
+    const tokens = this.getTotalTokens();
+    const cost = this.getEstimatedCost();
+    return _chalk2.default.dim(
+      `tokens: ${formatNumber(tokens.total)} | cost: ${formatCost(cost)}`
+    );
+  }
+  reset() {
+    this.records = [];
+    this.sessionStart = Date.now();
+  }
+  /** Serialize cost state for session persistence. */
+  serialize() {
+    const tokens = this.getTotalTokens();
+    return {
+      records: this.records,
+      sessionStart: this.sessionStart,
+      totalPromptTokens: tokens.prompt,
+      totalCompletionTokens: tokens.completion,
+      estimatedCost: this.getEstimatedCost()
+    };
+  }
+  /** Restore cost state from a previous session. */
+  restore(state) {
+    this.records = _nullishCoalesce(state.records, () => ( []));
+    this.sessionStart = _nullishCoalesce(state.sessionStart, () => ( Date.now()));
+  }
+}, _class);
+function formatCost(cost) {
+  if (cost >= 0.5) return `$${Math.round(cost * 100) / 100}`;
+  if (cost >= 0.01) return `$${cost.toFixed(4)}`;
+  if (cost > 0) return `$${cost.toFixed(6)}`;
+  return "$0.00";
+}
+function formatNumber(n) {
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  if (n >= 1e3) return (n / 1e3).toFixed(1) + "K";
+  return String(n);
+}
+function formatDuration(ms) {
+  const s = Math.floor(ms / 1e3);
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  const rs = s % 60;
+  if (m < 60) return `${m}m ${rs}s`;
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return `${h}h ${rm}m`;
+}
+var costTracker = new CostTracker();
+
+
+
+
+exports.CostTracker = CostTracker; exports.costTracker = costTracker;

package/dist/chunk-6JOOLG6F.js

@@ -0,0 +1,104 @@
+import {
+  CompositeEvaluator,
+  FileRunStore,
+  NoopEvaluator,
+  RunManager,
+  registerPreset
+} from "./chunk-7RMAR2Y3.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/product/index.ts
+init_esm_shims();
+
+// src/product/define.ts
+init_esm_shims();
+import { join } from "path";
+import { homedir } from "os";
+function defineProduct(definition, runtime) {
+  const { preset: presetDef, adapter, contract } = definition;
+  const presetName = presetDef.name;
+  const baseTools = [
+    "Read",
+    "Write",
+    "Edit",
+    "Glob",
+    "Grep",
+    "Bash",
+    "AskUserQuestion",
+    "Agent",
+    "ToolSearch",
+    "TaskCreate",
+    "TaskList",
+    "TaskUpdate",
+    "TaskGet"
+  ];
+  const enabledSet = /* @__PURE__ */ new Set([...baseTools, ...adapter?.enableTools ?? []]);
+  for (const t of adapter?.disableTools ?? []) {
+    enabledSet.delete(t);
+  }
+  const permissionRules = [
+    // Default safe rules
+    { tool: "Read", decision: "allow" },
+    { tool: "Glob", decision: "allow" },
+    { tool: "Grep", decision: "allow" },
+    { tool: "AskUserQuestion", decision: "allow" },
+    { tool: "ToolSearch", decision: "allow" },
+    { tool: "TaskCreate", decision: "allow" },
+    { tool: "TaskList", decision: "allow" },
+    { tool: "TaskUpdate", decision: "allow" },
+    { tool: "TaskGet", decision: "allow" },
+    // Product-specific rules (higher priority)
+    ...adapter?.permissionRules ?? []
+  ];
+  const agentPreset = {
+    name: presetName,
+    label: presetDef.label,
+    description: presetDef.description,
+    promptSections: presetDef.sections ?? ["base", "orchestration"],
+    injectGitStatus: presetDef.injectGitStatus ?? false,
+    builtinTools: [...enabledSet],
+    defaultPermissionRules: permissionRules
+  };
+  registerPreset(agentPreset);
+  let evaluator;
+  if (!contract?.evaluator) {
+    evaluator = new NoopEvaluator();
+  } else if (Array.isArray(contract.evaluator)) {
+    evaluator = new CompositeEvaluator(contract.evaluator);
+  } else {
+    evaluator = contract.evaluator;
+  }
+  const customTools = adapter?.tools ?? [];
+  const customToolEntries = customTools.map((ct) => ({
+    definition: ct.definition,
+    execute: ct.execute
+  }));
+  const runsDir = runtime.runsDir ?? join(homedir(), ".code-shell", "runs");
+  const store = new FileRunStore(runsDir);
+  const manager = new RunManager({
+    store,
+    executor: {
+      llm: runtime.llm,
+      maxTurns: contract?.maxTurns ?? 30,
+      maxContextTokens: contract?.maxContextTokens ?? 2e5,
+      permissionMode: runtime.permissionMode ?? "acceptEdits",
+      sessionStorageDir: runtime.sessionStorageDir,
+      mcpServers: adapter?.mcpServers,
+      enabledBuiltinTools: [...enabledSet],
+      disabledBuiltinTools: adapter?.disableTools,
+      customSystemPrompt: presetDef.customPrompt,
+      appendSystemPrompt: presetDef.appendPrompt,
+      customTools: customToolEntries.length > 0 ? customToolEntries : void 0
+    },
+    concurrency: contract?.concurrency ?? 1,
+    runsDir,
+    evaluator
+  });
+  return { manager, preset: agentPreset, customTools };
+}
+
+export {
+  defineProduct
+};

package/dist/chunk-6ZIROYXX.js

@@ -0,0 +1,207 @@
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/settings/schema.ts
+import { z } from "zod";
+function validateSettings(raw) {
+  return SettingsSchema.parse(raw);
+}
+var SettingsSchema;
+var init_schema = __esm({
+  "src/settings/schema.ts"() {
+    "use strict";
+    init_esm_shims();
+    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({}),
+      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({}),
+      models: z.array(
+        z.object({
+          key: z.string(),
+          label: z.string().optional(),
+          provider: z.string(),
+          model: z.string(),
+          baseUrl: z.string().optional(),
+          apiKey: z.string().optional(),
+          maxOutputTokens: z.number().optional()
+        })
+      ).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"]),
+        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();
+  }
+});
+
+// src/settings/manager.ts
+var manager_exports = {};
+__export(manager_exports, {
+  SettingsManager: () => SettingsManager
+});
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "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 = __esm({
+  "src/settings/manager.ts"() {
+    init_esm_shims();
+    init_schema();
+    SettingsManager = class {
+      constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+      }
+      sources = [];
+      merged = null;
+      /**
+       * Load settings from all sources.
+       */
+      load(flagOverrides) {
+        this.sources = [];
+        this.loadJsonFile(join(homedir(), ".code-shell", "settings.managed.json"), "managed", 0);
+        this.loadJsonFile(join(homedir(), ".code-shell", "settings.json"), "user", 1);
+        this.loadJsonFile(join(homedir(), ".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();
+        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 (!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;
+      }
+    };
+  }
+});
+
+export {
+  SettingsSchema,
+  validateSettings,
+  init_schema,
+  SettingsManager,
+  manager_exports,
+  init_manager
+};