@cjhyy/code-shell 0.1.6 → 0.2.0

package/dist/chunk-76HYEPDM.js

@@ -1,307 +0,0 @@
-import {
-  SessionError
-} from "./chunk-SFXHZSRF.js";
-import {
-  init_esm_shims
-} from "./chunk-MD32R22I.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"));
-        const transcriptFile = join(this.sessionsDir, dir, "transcript.jsonl");
-        const preview = readFirstUserMessage(transcriptFile);
-        sessions.push({ ...state, preview });
-      } catch {
-      }
-    }
-    return sessions.sort((a, b) => b.startedAt - a.startedAt).slice(0, limit);
-  }
-};
-function readFirstUserMessage(transcriptFile) {
-  if (!existsSync2(transcriptFile)) return void 0;
-  const raw = readFileSync2(transcriptFile, "utf-8");
-  for (const line of raw.split("\n")) {
-    if (!line) continue;
-    let event;
-    try {
-      event = JSON.parse(line);
-    } catch {
-      continue;
-    }
-    if (event.type !== "message") continue;
-    if (event.data?.role !== "user") continue;
-    const content = event.data.content;
-    const text = typeof content === "string" ? content : Array.isArray(content) ? content.find((b) => b.type === "text")?.text ?? "" : "";
-    if (!text.trim()) continue;
-    return text.replace(/\s+/g, " ").trim();
-  }
-  return void 0;
-}
-
-export {
-  Transcript,
-  SessionManager
-};