@cjhyy/code-shell 0.1.0-alpha.0

package/dist/chunk-R32DJSJE.cjs

@@ -0,0 +1,41 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkQHDYFC5Ucjs = require('./chunk-QHDYFC5U.cjs');
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// src/run/index.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+
+// src/run/factory.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _path = require('path');
+var _os = require('os');
+function createRunManager(options) {
+  const runsDir = _nullishCoalesce(options.runsDir, () => ( _path.join.call(void 0, _os.homedir.call(void 0, ), ".code-shell", "runs")));
+  const store = new (0, _chunkQHDYFC5Ucjs.FileRunStore)(runsDir);
+  return new (0, _chunkQHDYFC5Ucjs.RunManager)({
+    store,
+    executor: {
+      llm: options.llm,
+      maxTurns: _nullishCoalesce(options.maxTurns, () => ( 30)),
+      maxContextTokens: _nullishCoalesce(options.maxContextTokens, () => ( 2e5)),
+      permissionMode: _nullishCoalesce(options.permissionMode, () => ( "acceptEdits")),
+      sessionStorageDir: options.sessionStorageDir,
+      mcpServers: options.mcpServers,
+      enabledBuiltinTools: options.enabledBuiltinTools,
+      disabledBuiltinTools: options.disabledBuiltinTools,
+      customSystemPrompt: options.customSystemPrompt,
+      appendSystemPrompt: options.appendSystemPrompt
+    },
+    concurrency: _nullishCoalesce(options.concurrency, () => ( 1)),
+    runsDir,
+    evaluator: options.evaluator
+  });
+}
+
+
+
+exports.createRunManager = createRunManager;

package/dist/chunk-S74VVJBF.js

@@ -0,0 +1,285 @@
+import {
+  SessionError
+} from "./chunk-FUOKLKR2.js";
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/session/session-manager.ts
+init_esm_shims();
+import { mkdirSync as mkdirSync2, existsSync as existsSync2, readdirSync, readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { nanoid as nanoid2 } from "nanoid";
+
+// src/session/transcript.ts
+init_esm_shims();
+import { appendFileSync, readFileSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { nanoid } from "nanoid";
+var Transcript = class _Transcript {
+  events = [];
+  filePath;
+  currentTurn = 0;
+  getFilePath() {
+    return this.filePath;
+  }
+  constructor(filePath) {
+    this.filePath = filePath;
+    mkdirSync(dirname(filePath), { recursive: true });
+    if (!existsSync(filePath)) {
+      writeFileSync(filePath, "", "utf-8");
+    }
+  }
+  append(type, data) {
+    const event = {
+      id: nanoid(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: this.events[0]?.id,
+        tailEventId: this.events[this.events.length - 1]?.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}` : result ?? "(no output)"
+          };
+          if (lastMsg?.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 {
+      appendFileSync(this.filePath, JSON.stringify(event) + "\n", "utf-8");
+    } catch {
+    }
+  }
+  /**
+   * 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 (!existsSync(filePath)) return transcript;
+    const content = readFileSync(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 = event.data.turnNumber ?? transcript.currentTurn + 1;
+        }
+      } catch {
+      }
+    }
+    transcript.repairToolResultPairs();
+    return transcript;
+  }
+};
+
+// src/session/session-manager.ts
+var SessionManager = class {
+  sessionsDir;
+  constructor(storageDir) {
+    this.sessionsDir = storageDir ?? join(homedir(), ".code-shell", "sessions");
+    mkdirSync2(this.sessionsDir, { recursive: true });
+  }
+  create(cwd, model, provider) {
+    const sessionId = nanoid2(16);
+    const sessionDir = join(this.sessionsDir, sessionId);
+    mkdirSync2(sessionDir, { recursive: true });
+    const state = {
+      sessionId,
+      cwd,
+      startedAt: Date.now(),
+      model,
+      provider,
+      tokenUsage: { promptTokens: 0, completionTokens: 0, totalTokens: 0 },
+      turnCount: 0,
+      invokedSkills: [],
+      status: "active"
+    };
+    writeFileSync2(join(sessionDir, "state.json"), JSON.stringify(state, null, 2), "utf-8");
+    const transcript = new Transcript(join(sessionDir, "transcript.jsonl"));
+    transcript.append("session_meta", {
+      sessionId,
+      cwd,
+      model,
+      provider,
+      startedAt: state.startedAt
+    });
+    return { state, transcript };
+  }
+  resume(sessionId) {
+    const sessionDir = join(this.sessionsDir, sessionId);
+    if (!existsSync2(sessionDir)) {
+      throw new SessionError(`Session not found: ${sessionId}`);
+    }
+    const stateFile = join(sessionDir, "state.json");
+    if (!existsSync2(stateFile)) {
+      throw new SessionError(`Session state file not found: ${sessionId}`);
+    }
+    const state = JSON.parse(readFileSync2(stateFile, "utf-8"));
+    const transcriptFile = join(sessionDir, "transcript.jsonl");
+    const transcript = Transcript.loadFromFile(transcriptFile);
+    state.status = "active";
+    return { state, transcript };
+  }
+  saveState(state) {
+    const sessionDir = join(this.sessionsDir, state.sessionId);
+    mkdirSync2(sessionDir, { recursive: true });
+    const target = join(sessionDir, "state.json");
+    const tmp = `${target}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync2(tmp, JSON.stringify(state, null, 2), "utf-8");
+    renameSync(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 = 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 (!existsSync2(this.sessionsDir)) return [];
+    const dirs = readdirSync(this.sessionsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+    const sessions = [];
+    for (const dir of dirs) {
+      const stateFile = join(this.sessionsDir, dir, "state.json");
+      if (!existsSync2(stateFile)) continue;
+      try {
+        const state = JSON.parse(readFileSync2(stateFile, "utf-8"));
+        sessions.push(state);
+      } catch {
+      }
+    }
+    return sessions.sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
+  }
+};
+
+export {
+  Transcript,
+  SessionManager
+};

package/dist/chunk-SK62UVS6.js

@@ -0,0 +1,105 @@
+import {
+  init_esm_shims
+} from "./chunk-DI7RDLOS.js";
+
+// src/session/file-history.ts
+init_esm_shims();
+import { mkdirSync, existsSync, readFileSync, writeFileSync, copyFileSync } from "fs";
+import { join, resolve } from "path";
+import { createHash } from "crypto";
+var FileHistory = class _FileHistory {
+  historyDir;
+  snapshots = [];
+  constructor(sessionDir) {
+    this.historyDir = join(sessionDir, "file-history");
+    mkdirSync(this.historyDir, { recursive: true });
+  }
+  /**
+   * Save a snapshot of a file before it is modified.
+   * Returns the snapshot record, or null if the file doesn't exist.
+   */
+  saveSnapshot(filePath) {
+    const absPath = resolve(filePath);
+    if (!existsSync(absPath)) return null;
+    try {
+      const content = readFileSync(absPath);
+      const hash = createHash("md5").update(content).digest("hex");
+      const existing = this.snapshots.find(
+        (s) => s.filePath === absPath && s.hash === hash
+      );
+      if (existing) return existing;
+      const timestamp = Date.now();
+      const safeName = absPath.replace(/[/\\:]/g, "_").slice(-100);
+      const backupPath = join(this.historyDir, `${timestamp}_${safeName}`);
+      copyFileSync(absPath, backupPath);
+      const snapshot = {
+        filePath: absPath,
+        timestamp,
+        backupPath,
+        hash,
+        size: content.length
+      };
+      this.snapshots.push(snapshot);
+      this.saveIndex();
+      return snapshot;
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Get all snapshots for a specific file.
+   */
+  getSnapshots(filePath) {
+    const absPath = resolve(filePath);
+    return this.snapshots.filter((s) => s.filePath === absPath).sort((a, b) => b.timestamp - a.timestamp);
+  }
+  /**
+   * Restore a file to a specific snapshot.
+   */
+  restore(snapshot) {
+    try {
+      if (!existsSync(snapshot.backupPath)) return false;
+      this.saveSnapshot(snapshot.filePath);
+      copyFileSync(snapshot.backupPath, snapshot.filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Restore a file to its most recent snapshot.
+   */
+  restoreLatest(filePath) {
+    const snapshots = this.getSnapshots(filePath);
+    if (snapshots.length === 0) return false;
+    return this.restore(snapshots[0]);
+  }
+  /**
+   * Get all tracked files.
+   */
+  getTrackedFiles() {
+    return [...new Set(this.snapshots.map((s) => s.filePath))];
+  }
+  saveIndex() {
+    try {
+      const indexPath = join(this.historyDir, "index.json");
+      writeFileSync(indexPath, JSON.stringify(this.snapshots, null, 2), "utf-8");
+    } catch {
+    }
+  }
+  static loadFromDir(sessionDir) {
+    const history = new _FileHistory(sessionDir);
+    const indexPath = join(history.historyDir, "index.json");
+    if (existsSync(indexPath)) {
+      try {
+        history.snapshots = JSON.parse(readFileSync(indexPath, "utf-8"));
+      } catch {
+      }
+    }
+    return history;
+  }
+};
+
+export {
+  FileHistory
+};