@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-LRAY5IYC.cjs

@@ -0,0 +1,291 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkHD7MT5XUcjs = require('./chunk-HD7MT5XU.cjs');
+
+
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/context/compaction.ts
+var compaction_exports = {};
+_chunkIJSHQGMPcjs.__export.call(void 0, 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(_chunkHD7MT5XUcjs.estimateMessagesTokens.call(void 0, 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 = _nullishCoalesce(input.file_path, () => ( input.path));
+        if (fp) paths.add(fp);
+      }
+    }
+  }
+  return [...paths];
+}
+var init_compaction = _chunkIJSHQGMPcjs.__esm.call(void 0, {
+  "src/context/compaction.ts"() {
+    _chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+    _chunkHD7MT5XUcjs.init_token_counter.call(void 0, );
+  }
+});
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.estimateTokens = estimateTokens; exports.adjustIndexToPreserveAPIInvariants = adjustIndexToPreserveAPIInvariants; exports.snipCompact = snipCompact; exports.windowCompact = windowCompact; exports.microcompact = microcompact; exports.applyToolResultBudget = applyToolResultBudget; exports.truncateToolResult = truncateToolResult; exports.buildSummarizationPrompt = buildSummarizationPrompt; exports.applySummaryCompaction = applySummaryCompaction; exports.groupMessagesByApiRound = groupMessagesByApiRound; exports.dropOldestRounds = dropOldestRounds; exports.extractReferencedFilePaths = extractReferencedFilePaths; exports.compaction_exports = compaction_exports; exports.init_compaction = init_compaction;

package/dist/chunk-NG73UR3L.cjs

@@ -0,0 +1,285 @@
+"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 _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/session/session-manager.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _fs = require('fs');
+var _path = require('path');
+var _os = require('os');
+var _nanoid = require('nanoid');
+
+// src/session/transcript.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+
+
+
+var Transcript = (_class = class _Transcript {
+  __init() {this.events = []}
+  
+  __init2() {this.currentTurn = 0}
+  getFilePath() {
+    return this.filePath;
+  }
+  constructor(filePath) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
+    this.filePath = filePath;
+    _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, filePath), { recursive: true });
+    if (!_fs.existsSync.call(void 0, filePath)) {
+      _fs.writeFileSync.call(void 0, filePath, "", "utf-8");
+    }
+  }
+  append(type, data) {
+    const event = {
+      id: _nanoid.nanoid.call(void 0, 12),
+      type,
+      timestamp: Date.now(),
+      turnNumber: this.currentTurn,
+      data
+    };
+    this.events.push(event);
+    this.flush(event);
+    return event;
+  }
+  appendMessage(role, content) {
+    return this.append("message", { role, content });
+  }
+  appendToolUse(toolName, toolCallId, args) {
+    return this.append("tool_use", { toolName, toolCallId, args });
+  }
+  appendToolResult(toolCallId, toolName, result, error) {
+    return this.append("tool_result", { toolCallId, toolName, result, error });
+  }
+  appendTurnBoundary() {
+    this.currentTurn++;
+    return this.append("turn_boundary", { turnNumber: this.currentTurn });
+  }
+  appendSummary(summary, compactedRange) {
+    return this.append("summary", {
+      summary,
+      trigger: "auto",
+      compactedRange,
+      preservedSegment: {
+        headEventId: _optionalChain([this, 'access', _ => _.events, 'access', _2 => _2[0], 'optionalAccess', _3 => _3.id]),
+        tailEventId: _optionalChain([this, 'access', _4 => _4.events, 'access', _5 => _5[this.events.length - 1], 'optionalAccess', _6 => _6.id])
+      }
+    });
+  }
+  appendError(error, details) {
+    return this.append("error", { error, ...details });
+  }
+  /**
+   * Derive Message[] from transcript events for sending to the LLM.
+   * This is the critical boundary: the LLM never sees the event log directly.
+   */
+  toMessages() {
+    const messages = [];
+    for (const event of this.events) {
+      switch (event.type) {
+        case "message": {
+          const { role, content } = event.data;
+          messages.push({ role, content });
+          break;
+        }
+        case "tool_use": {
+          break;
+        }
+        case "tool_result": {
+          const { toolCallId, result, error } = event.data;
+          const lastMsg = messages[messages.length - 1];
+          const block = {
+            type: "tool_result",
+            tool_use_id: toolCallId,
+            content: error ? `Error: ${error}` : _nullishCoalesce(result, () => ( "(no output)"))
+          };
+          if (_optionalChain([lastMsg, 'optionalAccess', _7 => _7.role]) === "user" && Array.isArray(lastMsg.content)) {
+            lastMsg.content.push(block);
+          } else {
+            messages.push({ role: "user", content: [block] });
+          }
+          break;
+        }
+        case "summary": {
+          const { summary } = event.data;
+          messages.push({
+            role: "user",
+            content: `<system-reminder>Previous conversation was summarized:
+${summary}</system-reminder>`
+          });
+          break;
+        }
+      }
+    }
+    return messages;
+  }
+  getEvents(type) {
+    if (!type) return [...this.events];
+    return this.events.filter((e) => e.type === type);
+  }
+  get turnNumber() {
+    return this.currentTurn;
+  }
+  get eventCount() {
+    return this.events.length;
+  }
+  flush(event) {
+    try {
+      _fs.appendFileSync.call(void 0, this.filePath, JSON.stringify(event) + "\n", "utf-8");
+    } catch (e2) {
+    }
+  }
+  /**
+   * Repair tool_result pairing issues:
+   * - Orphaned tool_results (no matching tool_use) get removed
+   * - Missing tool_results (tool_use with no result) get synthetic error results
+   */
+  repairToolResultPairs() {
+    const toolUseIds = /* @__PURE__ */ new Set();
+    const toolResultIds = /* @__PURE__ */ new Set();
+    for (const event of this.events) {
+      if (event.type === "tool_use") {
+        toolUseIds.add(event.data.toolCallId);
+      } else if (event.type === "tool_result") {
+        toolResultIds.add(event.data.toolCallId);
+      }
+    }
+    for (const id of toolUseIds) {
+      if (!toolResultIds.has(id)) {
+        this.append("tool_result", {
+          toolCallId: id,
+          toolName: "unknown",
+          error: "[Tool result missing due to interrupted session]"
+        });
+      }
+    }
+    this.events = this.events.filter((event) => {
+      if (event.type === "tool_result") {
+        const id = event.data.toolCallId;
+        return toolUseIds.has(id);
+      }
+      return true;
+    });
+  }
+  static loadFromFile(filePath) {
+    const transcript = new _Transcript(filePath);
+    if (!_fs.existsSync.call(void 0, filePath)) return transcript;
+    const content = _fs.readFileSync.call(void 0, filePath, "utf-8");
+    const lines = content.split("\n").filter((l) => l.trim());
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line);
+        transcript.events.push(event);
+        if (event.type === "turn_boundary") {
+          transcript.currentTurn = _nullishCoalesce(event.data.turnNumber, () => ( transcript.currentTurn + 1));
+        }
+      } catch (e3) {
+      }
+    }
+    transcript.repairToolResultPairs();
+    return transcript;
+  }
+}, _class);
+
+// src/session/session-manager.ts
+var SessionManager = class {
+  
+  constructor(storageDir) {
+    this.sessionsDir = _nullishCoalesce(storageDir, () => ( _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "sessions")));
+    _fs.mkdirSync.call(void 0, this.sessionsDir, { recursive: true });
+  }
+  create(cwd, model, provider) {
+    const sessionId = _nanoid.nanoid.call(void 0, 16);
+    const sessionDir = _path.join.call(void 0, this.sessionsDir, sessionId);
+    _fs.mkdirSync.call(void 0, sessionDir, { recursive: true });
+    const state = {
+      sessionId,
+      cwd,
+      startedAt: Date.now(),
+      model,
+      provider,
+      tokenUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      turnCount: 0,
+      invokedSkills: [],
+      status: "active"
+    };
+    _fs.writeFileSync.call(void 0, _path.join.call(void 0, sessionDir, "state.json"), JSON.stringify(state, null, 2), "utf-8");
+    const transcript = new Transcript(_path.join.call(void 0, sessionDir, "transcript.jsonl"));
+    transcript.append("session_meta", {
+      sessionId,
+      cwd,
+      model,
+      provider,
+      startedAt: state.startedAt
+    });
+    return { state, transcript };
+  }
+  resume(sessionId) {
+    const sessionDir = _path.join.call(void 0, this.sessionsDir, sessionId);
+    if (!_fs.existsSync.call(void 0, sessionDir)) {
+      throw new (0, _chunkEL2RL5DGcjs.SessionError)(`Session not found: ${sessionId}`);
+    }
+    const stateFile = _path.join.call(void 0, sessionDir, "state.json");
+    if (!_fs.existsSync.call(void 0, stateFile)) {
+      throw new (0, _chunkEL2RL5DGcjs.SessionError)(`Session state file not found: ${sessionId}`);
+    }
+    const state = JSON.parse(_fs.readFileSync.call(void 0, stateFile, "utf-8"));
+    const transcriptFile = _path.join.call(void 0, sessionDir, "transcript.jsonl");
+    const transcript = Transcript.loadFromFile(transcriptFile);
+    state.status = "active";
+    return { state, transcript };
+  }
+  saveState(state) {
+    const sessionDir = _path.join.call(void 0, this.sessionsDir, state.sessionId);
+    _fs.mkdirSync.call(void 0, sessionDir, { recursive: true });
+    const target = _path.join.call(void 0, sessionDir, "state.json");
+    const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    _fs.writeFileSync.call(void 0, tmp, JSON.stringify(state, null, 2), "utf-8");
+    _fs.renameSync.call(void 0, tmp, target);
+  }
+  /**
+   * Fork a session from a specific point.
+   * Creates a new session that shares events up to the given turn,
+   * then diverges independently.
+   */
+  fork(sourceSessionId, forkAtTurn) {
+    const source = this.resume(sourceSessionId);
+    const events = source.transcript.getEvents();
+    const forkTurn = _nullishCoalesce(forkAtTurn, () => ( source.state.turnCount));
+    const newBundle = this.create(
+      source.state.cwd,
+      source.state.model,
+      source.state.provider
+    );
+    newBundle.state.parentSessionId = sourceSessionId;
+    for (const event of events) {
+      if (event.type === "turn_boundary" && event.data.turnNumber > forkTurn) {
+        break;
+      }
+      newBundle.transcript.append(event.type, event.data);
+    }
+    this.saveState(newBundle.state);
+    return newBundle;
+  }
+  list(limit = 20) {
+    if (!_fs.existsSync.call(void 0, this.sessionsDir)) return [];
+    const dirs = _fs.readdirSync.call(void 0, this.sessionsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const sessions = [];
+    for (const dir of dirs) {
+      const stateFile = _path.join.call(void 0, this.sessionsDir, dir, "state.json");
+      if (!_fs.existsSync.call(void 0, stateFile)) continue;
+      try {
+        const state = JSON.parse(_fs.readFileSync.call(void 0, stateFile, "utf-8"));
+        sessions.push(state);
+      } catch (e4) {
+      }
+    }
+    return sessions.sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
+  }
+};
+
+
+
+
+exports.Transcript = Transcript; exports.SessionManager = SessionManager;