@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-HD7MT5XU.cjs

@@ -0,0 +1,86 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/context/token-counter.ts
+function estimateStringTokens(text) {
+  if (!text) return 0;
+  const cjkChars = (_nullishCoalesce(text.match(/[\u4e00-\u9fff\u3040-\u309f\u30a0-\u30ff\uac00-\ud7af]/g), () => ( []))).length;
+  const cjkRatio = cjkChars / text.length;
+  if (cjkRatio > 0.3) {
+    const cjkTokens = cjkChars / RATIOS.cjk;
+    const otherChars = text.length - cjkChars;
+    const otherTokens = otherChars / RATIOS.english;
+    return Math.ceil(cjkTokens + otherTokens);
+  }
+  const codeIndicators = ["{", "}", "(", ")", ";", "=>", "import ", "function ", "class ", "const "];
+  const codeScore = codeIndicators.reduce((s, ind) => s + (text.includes(ind) ? 1 : 0), 0);
+  if (codeScore >= 3) return Math.ceil(text.length / RATIOS.code);
+  if (text.startsWith("{") || text.startsWith("[")) return Math.ceil(text.length / RATIOS.json);
+  return Math.ceil(text.length / RATIOS.english);
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    total += 4;
+    if (typeof msg.content === "string") {
+      total += estimateStringTokens(msg.content);
+    } else if (Array.isArray(msg.content)) {
+      for (const block of msg.content) {
+        total += estimateBlockTokens(block);
+      }
+    }
+  }
+  return total;
+}
+function estimateBlockTokens(block) {
+  let tokens = 2;
+  if (block.text) tokens += estimateStringTokens(block.text);
+  if (block.content && typeof block.content === "string") {
+    tokens += estimateStringTokens(block.content);
+  }
+  if (block.input) {
+    tokens += estimateStringTokens(JSON.stringify(block.input));
+  }
+  if (block.name) tokens += estimateStringTokens(block.name);
+  return tokens;
+}
+function calculateContextUsage(messages, systemPrompt, maxTokens) {
+  const systemPromptTokens = estimateStringTokens(systemPrompt);
+  const messagesTokens = estimateMessagesTokens(messages);
+  const usedTokens = systemPromptTokens + messagesTokens;
+  return {
+    usedTokens,
+    maxTokens,
+    usagePercent: usedTokens / maxTokens * 100,
+    systemPromptTokens,
+    messagesTokens,
+    headroom: maxTokens - usedTokens
+  };
+}
+var RATIOS;
+var init_token_counter = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+  "src/context/token-counter.ts"() {
+    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    RATIOS = {
+      english: 4,
+      // ~4 chars per token for English prose
+      code: 3.2,
+      // ~3.2 chars per token for code (more tokens per char)
+      json: 3.5,
+      // JSON structures
+      mixed: 3.6,
+      // Mixed content (typical for tool results)
+      cjk: 1.5
+      // CJK characters: ~1.5 chars per token
+    };
+  }
+});
+
+
+
+
+
+
+exports.estimateStringTokens = estimateStringTokens; exports.estimateMessagesTokens = estimateMessagesTokens; exports.calculateContextUsage = calculateContextUsage; exports.init_token_counter = init_token_counter;

package/dist/chunk-IJSHQGMP.cjs

@@ -0,0 +1,45 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});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/cjs_shims.js
+var init_cjs_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/cjs_shims.js"() {
+    "use strict";
+  }
+});
+
+
+
+
+
+
+
+
+exports.__require = __require; exports.__esm = __esm; exports.__commonJS = __commonJS; exports.__export = __export; exports.__toCommonJS = __toCommonJS; exports.init_cjs_shims = init_cjs_shims;

package/dist/chunk-IMMTBZ33.cjs

@@ -0,0 +1,63 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/logging/logger.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Logger = class {
+  
+  
+  
+  constructor() {
+    this.logDir = _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "logs");
+    this.minLevel = _nullishCoalesce(process.env.CODE_SHELL_LOG_LEVEL, () => ( "info"));
+    this.enabled = process.env.CODE_SHELL_LOG !== "0";
+  }
+  debug(msg, data) {
+    this.log("debug", msg, data);
+  }
+  info(msg, data) {
+    this.log("info", msg, data);
+  }
+  warn(msg, data) {
+    this.log("warn", msg, data);
+  }
+  error(msg, data) {
+    this.log("error", msg, data);
+  }
+  log(level, msg, data) {
+    if (!this.enabled) return;
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.minLevel]) return;
+    const now = /* @__PURE__ */ new Date();
+    const timestamp = now.toISOString();
+    const dateStr = timestamp.split("T")[0];
+    const entry = {
+      t: timestamp,
+      l: level,
+      msg
+    };
+    if (data) entry.d = data;
+    try {
+      if (!_fs.existsSync.call(void 0, this.logDir)) {
+        _fs.mkdirSync.call(void 0, this.logDir, { recursive: true });
+      }
+      const logFile = _path.join.call(void 0, this.logDir, `${dateStr}.log`);
+      _fs.appendFileSync.call(void 0, logFile, JSON.stringify(entry) + "\n", "utf-8");
+    } catch (e) {
+    }
+  }
+};
+var logger = new Logger();
+
+
+
+exports.logger = logger;

package/dist/chunk-J5XW6UYL.js

@@ -0,0 +1,291 @@
+import {
+  estimateMessagesTokens,
+  init_token_counter
+} from "./chunk-4RRUP4MM.js";
+import {
+  __esm,
+  __export,
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/context/compaction.ts
+var compaction_exports = {};
+__export(compaction_exports, {
+  adjustIndexToPreserveAPIInvariants: () => adjustIndexToPreserveAPIInvariants,
+  applySummaryCompaction: () => applySummaryCompaction,
+  applyToolResultBudget: () => applyToolResultBudget,
+  buildSummarizationPrompt: () => buildSummarizationPrompt,
+  dropOldestRounds: () => dropOldestRounds,
+  estimateTokens: () => estimateTokens,
+  extractReferencedFilePaths: () => extractReferencedFilePaths,
+  groupMessagesByApiRound: () => groupMessagesByApiRound,
+  microcompact: () => microcompact,
+  snipCompact: () => snipCompact,
+  truncateToolResult: () => truncateToolResult,
+  windowCompact: () => windowCompact
+});
+function estimateTokens(messages) {
+  return Math.ceil(estimateMessagesTokens(messages) * (4 / 3));
+}
+function adjustIndexToPreserveAPIInvariants(messages, startIndex) {
+  let adjusted = startIndex;
+  const neededToolUseIds = /* @__PURE__ */ new Set();
+  for (let i = adjusted; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_result" && block.tool_use_id) {
+        neededToolUseIds.add(block.tool_use_id);
+      }
+    }
+  }
+  for (let i = adjusted; i < messages.length; i++) {
+    const msg = messages[i];
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id) {
+        neededToolUseIds.delete(block.id);
+      }
+    }
+  }
+  if (neededToolUseIds.size === 0) return adjusted;
+  for (let i = adjusted - 1; i >= 0 && neededToolUseIds.size > 0; i--) {
+    const msg = messages[i];
+    if (msg.role !== "assistant" || !Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.id && neededToolUseIds.has(block.id)) {
+        neededToolUseIds.delete(block.id);
+        if (i < adjusted) adjusted = i;
+      }
+    }
+  }
+  return adjusted;
+}
+function snipCompact(messages, keepFirstN = 3, keepLastM = 8) {
+  if (messages.length <= keepFirstN + keepLastM + 1) return messages;
+  let lastStart = messages.length - keepLastM;
+  lastStart = adjustIndexToPreserveAPIInvariants(messages, lastStart);
+  if (lastStart <= keepFirstN) return messages;
+  const snippedCount = lastStart - keepFirstN;
+  const snipMarker = {
+    role: "user",
+    content: `<system-reminder>[${snippedCount} messages snipped to save context. Use the transcript file to review details if needed.]</system-reminder>`
+  };
+  return [
+    ...messages.slice(0, keepFirstN),
+    snipMarker,
+    ...messages.slice(lastStart)
+  ];
+}
+function windowCompact(messages, keepLastN) {
+  if (messages.length <= keepLastN + 1) return messages;
+  let startIndex = messages.length - keepLastN;
+  startIndex = adjustIndexToPreserveAPIInvariants(messages, startIndex);
+  if (startIndex <= 1) return messages;
+  return [messages[0], ...messages.slice(startIndex)];
+}
+function microcompact(messages, keepRecentN = 3) {
+  let toolResultCount = 0;
+  const indices = [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (Array.isArray(msg.content)) {
+      const hasToolResult = msg.content.some((b) => b.type === "tool_result");
+      if (hasToolResult) {
+        toolResultCount++;
+        if (toolResultCount > keepRecentN) {
+          indices.push(i);
+        }
+      }
+    }
+  }
+  if (indices.length === 0) return messages;
+  return messages.map((msg, i) => {
+    if (!indices.includes(i)) return msg;
+    if (!Array.isArray(msg.content)) return msg;
+    return {
+      ...msg,
+      content: msg.content.map((block) => {
+        if (block.type === "tool_result") {
+          return { ...block, content: "[Old tool result content cleared]" };
+        }
+        return block;
+      })
+    };
+  });
+}
+function applyToolResultBudget(messages, maxTotalChars = 1e5) {
+  return messages.map((msg) => {
+    if (!Array.isArray(msg.content)) return msg;
+    const resultBlocks = [];
+    let totalSize = 0;
+    for (let i = 0; i < msg.content.length; i++) {
+      const block = msg.content[i];
+      if (block.type === "tool_result" && typeof block.content === "string") {
+        const size = block.content.length;
+        resultBlocks.push({ index: i, size });
+        totalSize += size;
+      }
+    }
+    if (totalSize <= maxTotalChars || resultBlocks.length === 0) return msg;
+    resultBlocks.sort((a, b) => b.size - a.size);
+    let remaining = totalSize;
+    const toTruncate = /* @__PURE__ */ new Set();
+    for (const rb of resultBlocks) {
+      if (remaining <= maxTotalChars) break;
+      toTruncate.add(rb.index);
+      remaining -= rb.size;
+      remaining += 200;
+    }
+    if (toTruncate.size === 0) return msg;
+    const newContent = msg.content.map((block, i) => {
+      if (!toTruncate.has(i)) return block;
+      const preview = typeof block.content === "string" ? block.content.slice(0, 500) : "";
+      return {
+        ...block,
+        content: `Output too large (${(block.content.length / 1e3).toFixed(0)}KB). Full output saved to session transcript. Use Read tool to view the source file if needed.
+
+Preview (first 500 chars):
+${preview}`
+      };
+    });
+    return { ...msg, content: newContent };
+  });
+}
+function truncateToolResult(result, maxChars = 3e4) {
+  if (result.length <= maxChars) return result;
+  const headSize = Math.floor(maxChars * 0.7);
+  const tailSize = Math.floor(maxChars * 0.2);
+  const head = result.slice(0, headSize);
+  const tail = result.slice(-tailSize);
+  return head + `
+
+... [${result.length - headSize - tailSize} characters truncated] ...
+
+` + tail;
+}
+function buildSummarizationPrompt(messagesToSummarize) {
+  const parts = [];
+  for (const msg of messagesToSummarize) {
+    if (typeof msg.content === "string") {
+      parts.push(`[${msg.role}]: ${msg.content.slice(0, 3e3)}`);
+    } else {
+      for (const block of msg.content) {
+        if (block.type === "text" && block.text) {
+          parts.push(`[${msg.role}]: ${block.text.slice(0, 3e3)}`);
+        } else if (block.type === "tool_use") {
+          const args = JSON.stringify(block.input).slice(0, 500);
+          parts.push(`[tool_use]: ${block.name}(${args})`);
+        } else if (block.type === "tool_result") {
+          const content = typeof block.content === "string" ? block.content : "";
+          parts.push(`[tool_result]: ${content.slice(0, 1500)}`);
+        }
+      }
+    }
+  }
+  return "Summarize the following conversation into these sections. Be factual. Preserve file paths, function names, and error messages exactly.\n\n1. **Primary Request**: What the user originally asked for\n2. **Key Concepts**: Important technical terms, patterns, file paths\n3. **Files Referenced**: List of files read/edited with key content\n4. **Errors & Fixes**: Any errors encountered and how they were resolved\n5. **Actions Taken**: Tools used and their outcomes\n6. **User Messages**: All distinct user requests (verbatim if short)\n7. **Pending Tasks**: Anything started but not finished\n8. **Current State**: Where things stand right now\n9. **Next Steps**: What should happen next\n\nConversation:\n\n" + parts.join("\n");
+}
+function applySummaryCompaction(messages, summary, keepRecentN, transcriptPath) {
+  if (messages.length <= keepRecentN + 2) return messages;
+  let startIndex = messages.length - keepRecentN;
+  startIndex = adjustIndexToPreserveAPIInvariants(messages, startIndex);
+  if (startIndex <= 1) return messages;
+  const first = messages[0];
+  const compactedMessages = messages.slice(1, startIndex);
+  const recent = messages.slice(startIndex);
+  const referencedFiles = extractReferencedFilePaths(compactedMessages);
+  let body = `This session is being continued from a previous conversation that ran out of context. The summary below covers the earlier portion of the conversation.
+
+${summary}`;
+  if (transcriptPath) {
+    body += `
+
+If you need specific details from before compaction (like exact code snippets, error messages, or content you generated), read the full transcript at: ${transcriptPath}`;
+  }
+  if (referencedFiles.length > 0) {
+    body += `
+
+Files referenced before compaction (use Read tool if you need their current content):
+` + referencedFiles.map((f) => `- ${f}`).join("\n");
+  }
+  body += `
+
+Recent messages are preserved verbatim below. Continue from where you left off.`;
+  const summaryMsg = {
+    role: "user",
+    content: `<system-reminder>${body}</system-reminder>`
+  };
+  return [first, summaryMsg, ...recent];
+}
+function groupMessagesByApiRound(messages) {
+  const groups = [];
+  let current = [];
+  for (const msg of messages) {
+    if (msg.role === "assistant" && current.length > 0) {
+      groups.push(current);
+      current = [msg];
+    } else {
+      current.push(msg);
+    }
+  }
+  if (current.length > 0) groups.push(current);
+  return groups;
+}
+function dropOldestRounds(messages, roundsToDrop) {
+  const groups = groupMessagesByApiRound(messages);
+  if (groups.length <= roundsToDrop + 1) {
+    return groups[groups.length - 1];
+  }
+  const kept = groups.slice(roundsToDrop).flat();
+  const safeStart = adjustIndexToPreserveAPIInvariants(
+    kept,
+    0
+    // already sliced, just validate from start
+  );
+  const result = kept.slice(safeStart);
+  if (result.length > 0 && result[0].role === "assistant") {
+    result.unshift({
+      role: "user",
+      content: "<system-reminder>Earlier conversation context was removed to fit within the context window. Continue from the assistant's response below.</system-reminder>"
+    });
+  }
+  return result;
+}
+function extractReferencedFilePaths(messages) {
+  const paths = /* @__PURE__ */ new Set();
+  const FILE_TOOLS = /* @__PURE__ */ new Set(["Read", "Edit", "Write", "Glob", "Grep"]);
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "tool_use" && block.name && FILE_TOOLS.has(block.name) && block.input) {
+        const input = block.input;
+        const fp = input.file_path ?? input.path;
+        if (fp) paths.add(fp);
+      }
+    }
+  }
+  return [...paths];
+}
+var init_compaction = __esm({
+  "src/context/compaction.ts"() {
+    init_esm_shims();
+    init_token_counter();
+  }
+});
+
+export {
+  estimateTokens,
+  adjustIndexToPreserveAPIInvariants,
+  snipCompact,
+  windowCompact,
+  microcompact,
+  applyToolResultBudget,
+  truncateToolResult,
+  buildSummarizationPrompt,
+  applySummaryCompaction,
+  groupMessagesByApiRound,
+  dropOldestRounds,
+  extractReferencedFilePaths,
+  compaction_exports,
+  init_compaction
+};