@iowarp/clio-coder 0.3.0

package/dist/chunk-UGYAX5YI.js

@@ -0,0 +1,565 @@
+import {
+  assertSafeId
+} from "./chunk-5N2FG33Q.js";
+import {
+  fsyncDirectory,
+  safeResourceWrite
+} from "./chunk-VPAWTYLY.js";
+import {
+  clioStateDir,
+  stateRootRemoved
+} from "./chunk-X3NE4WVW.js";
+import {
+  readClioVersion,
+  readPiMonoVersion
+} from "./chunk-DXQNI4PC.js";
+
+// src/engine/session.ts
+import { createHash, randomBytes } from "node:crypto";
+import {
+  closeSync,
+  existsSync,
+  constants as fsConstants,
+  fstatSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  readSync,
+  renameSync,
+  statSync,
+  writeSync
+} from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+var CURRENT_SESSION_FORMAT_VERSION = 3;
+function cwdHash(cwd) {
+  const normalized = resolve(cwd);
+  return createHash("sha256").update(normalized).digest("hex").slice(0, 16);
+}
+function sessionPaths(meta) {
+  const dir = join(clioStateDir(), "sessions", meta.cwdHash, meta.id);
+  mkdirSync(dir, { recursive: true });
+  return {
+    current: join(dir, "current.jsonl"),
+    tree: join(dir, "tree.json"),
+    meta: join(dir, "meta.json")
+  };
+}
+function atomicWrite(targetPath, contents) {
+  safeResourceWrite(targetPath, contents);
+}
+var reportedSessionJsonlWarnings = /* @__PURE__ */ new Set();
+var REPORTED_SESSION_JSONL_WARNING_LIMIT = 1e3;
+function defaultSessionJsonlWarning(warning) {
+  const key = `${warning.path}:${warning.line}:${warning.message}`;
+  if (reportedSessionJsonlWarnings.has(key)) return;
+  if (reportedSessionJsonlWarnings.size >= REPORTED_SESSION_JSONL_WARNING_LIMIT) reportedSessionJsonlWarnings.clear();
+  reportedSessionJsonlWarnings.add(key);
+  process.stderr.write(`[clio:session] ${warning.path}:${warning.line}: ${warning.message}
+`);
+}
+function serializeJsonl(entries) {
+  if (entries.length === 0) return "";
+  const lines = entries.map((entry, index) => {
+    const serialized = JSON.stringify(entry);
+    if (serialized === void 0) {
+      throw new Error(`session JSONL entry ${index + 1} is not serializable`);
+    }
+    return serialized;
+  });
+  return `${lines.join("\n")}
+`;
+}
+function writeJsonlFileAtomic(targetPath, entries, options = {}) {
+  const dir = dirname(targetPath);
+  mkdirSync(dir, { recursive: true });
+  const body = serializeJsonl(entries);
+  const tmp = `${targetPath}.tmp`;
+  const fd = openSync(tmp, "w");
+  try {
+    writeSync(fd, body);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  options.beforeRename?.(tmp, targetPath);
+  renameSync(tmp, targetPath);
+  fsyncDirectory(dir);
+}
+function recoverJsonlTargetIfMissing(targetPath) {
+  if (existsSync(targetPath)) return targetPath;
+  const tmp = `${targetPath}.tmp`;
+  try {
+    if (!statSync(tmp).isFile()) return null;
+    renameSync(tmp, targetPath);
+    fsyncDirectory(dirname(targetPath));
+    return targetPath;
+  } catch {
+    return existsSync(targetPath) ? targetPath : existsSync(tmp) ? tmp : null;
+  }
+}
+var SESSION_JSONL_READ_CHUNK_BYTES = 64 * 1024;
+function parseSessionJsonlLine(line, lineNumber, readPath, entries, warn) {
+  if (line.trim().length === 0) return;
+  try {
+    entries.push(JSON.parse(line));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    warn({ path: readPath, line: lineNumber, message: `invalid JSON skipped: ${message}` });
+  }
+}
+function readSessionFileEntries(path, options = {}) {
+  const readPath = recoverJsonlTargetIfMissing(path);
+  if (readPath === null) return [];
+  const entries = [];
+  const warn = options.onWarning ?? defaultSessionJsonlWarning;
+  const fd = openSync(readPath, "r");
+  const buffer = Buffer.allocUnsafe(SESSION_JSONL_READ_CHUNK_BYTES);
+  const decoder = new StringDecoder("utf8");
+  let pending = "";
+  let lineNumber = 0;
+  try {
+    for (; ; ) {
+      const bytesRead = readSync(fd, buffer, 0, buffer.length, null);
+      if (bytesRead === 0) break;
+      pending += decoder.write(buffer.subarray(0, bytesRead));
+      for (; ; ) {
+        const newlineIndex = pending.indexOf("\n");
+        if (newlineIndex < 0) break;
+        const line = pending.slice(0, newlineIndex);
+        pending = pending.slice(newlineIndex + 1);
+        lineNumber += 1;
+        parseSessionJsonlLine(line, lineNumber, readPath, entries, warn);
+      }
+    }
+    pending += decoder.end();
+    if (pending.length > 0) {
+      lineNumber += 1;
+      parseSessionJsonlLine(pending, lineNumber, readPath, entries, warn);
+    }
+  } finally {
+    closeSync(fd);
+  }
+  return entries;
+}
+function readExactAt(fd, buffer, position, length) {
+  let read = 0;
+  while (read < length) {
+    const got = readSync(fd, buffer, read, length - read, position + read);
+    if (got === 0) break;
+    read += got;
+  }
+}
+function readSessionFileTailEntries(path, maxEntries, options = {}) {
+  const readPath = recoverJsonlTargetIfMissing(path);
+  if (readPath === null) return { entries: [], linesParsed: 0, reachedStart: true };
+  const warn = options.onWarning ?? defaultSessionJsonlWarning;
+  const bound = Number.isFinite(maxEntries) && maxEntries > 0 ? Math.floor(maxEntries) : 1;
+  const chunkBytes = options.chunkBytes !== void 0 && options.chunkBytes > 0 ? Math.floor(options.chunkBytes) : SESSION_JSONL_READ_CHUNK_BYTES;
+  const fd = openSync(readPath, "r");
+  try {
+    const size = fstatSync(fd).size;
+    if (size === 0) return { entries: [], linesParsed: 0, reachedStart: true };
+    let windowBytes = Math.min(size, chunkBytes);
+    for (; ; ) {
+      const offset = Math.max(0, size - windowBytes);
+      const length = size - offset;
+      const buffer = Buffer.allocUnsafe(length);
+      readExactAt(fd, buffer, offset, length);
+      const decoder = new StringDecoder("utf8");
+      const text = decoder.write(buffer) + decoder.end();
+      const reachedStart = offset === 0;
+      const lines = text.split("\n");
+      const candidate = reachedStart ? lines : lines.slice(1);
+      const nonEmpty = candidate.filter((line) => line.trim().length > 0);
+      if (nonEmpty.length >= bound || reachedStart) {
+        const tail = nonEmpty.slice(Math.max(0, nonEmpty.length - bound));
+        const entries = [];
+        let lineNumber = 0;
+        for (const line of tail) {
+          lineNumber += 1;
+          parseSessionJsonlLine(line, lineNumber, readPath, entries, warn);
+        }
+        return { entries, linesParsed: tail.length, reachedStart };
+      }
+      if (windowBytes >= size) return { entries: [], linesParsed: 0, reachedStart: true };
+      windowBytes = Math.min(size, windowBytes * 2);
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+function readSessionTailTurns(id, maxTurns) {
+  const currentPath = sessionCurrentPath(id);
+  const result = readSessionFileTailEntries(currentPath, maxTurns + 1);
+  const turns = result.entries.filter((entry) => !isSessionJsonlHeader(entry));
+  return {
+    entries: turns.slice(Math.max(0, turns.length - maxTurns)),
+    linesParsed: result.linesParsed,
+    reachedStart: result.reachedStart
+  };
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isOptionalString(value) {
+  return value === void 0 || typeof value === "string";
+}
+function isSessionJsonlHeader(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return v.type === "session" && isPositiveInteger(v.version) && typeof v.id === "string" && typeof v.timestamp === "string" && typeof v.cwd === "string" && isOptionalString(v.parentSession) && isOptionalString(v.parentTurnId);
+}
+function sessionHeaderFromMeta(meta, options = {}) {
+  const header = {
+    type: "session",
+    version: CURRENT_SESSION_FORMAT_VERSION,
+    id: meta.id,
+    timestamp: meta.createdAt,
+    cwd: meta.cwd
+  };
+  if (options.parentSession !== void 0) header.parentSession = options.parentSession;
+  if (options.parentTurnId !== void 0) header.parentTurnId = options.parentTurnId;
+  return header;
+}
+function ensureSessionHeader(meta, entries, options = {}) {
+  const first = entries[0];
+  if (isSessionJsonlHeader(first)) return [...entries];
+  return [sessionHeaderFromMeta(meta, options), ...entries];
+}
+function recordFromTurn(turn) {
+  const entry = {
+    kind: "message",
+    turnId: turn.id,
+    parentTurnId: turn.parentId,
+    timestamp: turn.at,
+    role: turn.kind,
+    payload: turn.payload
+  };
+  return entry;
+}
+function newTurnId() {
+  const n = BigInt(`0x${randomBytes(8).toString("hex")}`);
+  const raw = n.toString(36);
+  if (raw.length >= 12) return raw.slice(0, 12);
+  return raw.padStart(12, "0");
+}
+function buildMeta(input) {
+  const resolvedCwd = resolve(input.cwd);
+  return {
+    id: newTurnId(),
+    cwd: resolvedCwd,
+    cwdHash: cwdHash(resolvedCwd),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    endedAt: null,
+    model: input.model ?? null,
+    target: input.target ?? null,
+    clioVersion: readClioVersion(),
+    piMonoVersion: readPiMonoVersion(),
+    platform: process.platform,
+    nodeVersion: process.version,
+    sessionFormatVersion: CURRENT_SESSION_FORMAT_VERSION
+  };
+}
+function readMetaFile(path) {
+  const raw = readFileSync(path, "utf8");
+  return JSON.parse(raw);
+}
+var TURN_KINDS = [
+  "user",
+  "assistant",
+  "tool_call",
+  "tool_result",
+  "system",
+  "checkpoint"
+];
+function isTurnKind(value) {
+  return typeof value === "string" && TURN_KINDS.includes(value);
+}
+function nullableString(value) {
+  return value === null || typeof value === "string";
+}
+function isSessionTreeNode(value) {
+  if (!value || typeof value !== "object") return false;
+  const node = value;
+  return typeof node.id === "string" && nullableString(node.parentId) && typeof node.at === "string" && isTurnKind(node.kind);
+}
+function readTreeFile(path) {
+  if (!existsSync(path)) return [];
+  try {
+    const raw = readFileSync(path, "utf8");
+    if (raw.trim().length === 0) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(isSessionTreeNode);
+  } catch {
+    return [];
+  }
+}
+function treeNodeFromFileEntry(entry) {
+  if (!entry || typeof entry !== "object" || isSessionJsonlHeader(entry)) return null;
+  const value = entry;
+  if (value.kind === "message" && typeof value.turnId === "string" && nullableString(value.parentTurnId) && typeof value.timestamp === "string" && isTurnKind(value.role) && Object.hasOwn(value, "payload")) {
+    return { id: value.turnId, parentId: value.parentTurnId, at: value.timestamp, kind: value.role };
+  }
+  return null;
+}
+function treeFromFileEntries(fileEntries) {
+  const nodes = [];
+  for (const entry of fileEntries) {
+    const node = treeNodeFromFileEntry(entry);
+    if (node) nodes.push(node);
+  }
+  return nodes;
+}
+function sameTreeNode(a, b) {
+  return !!a && a.id === b.id && a.parentId === b.parentId && a.at === b.at && a.kind === b.kind;
+}
+function sameTree(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const left = a[i];
+    const right = b[i];
+    if (!left || !right || !sameTreeNode(left, right)) return false;
+  }
+  return true;
+}
+function recoverTreeFromJsonl(diskTree, fileEntries) {
+  const recovered = treeFromFileEntries(fileEntries);
+  if (recovered.length === 0) return diskTree;
+  return sameTree(diskTree, recovered) ? diskTree : recovered;
+}
+function sessionCurrentPath(id) {
+  return join(findSessionDir(id), "current.jsonl");
+}
+function findSessionDir(id) {
+  assertSafeId(id, "session");
+  const sessionsRoot = join(clioStateDir(), "sessions");
+  if (!existsSync(sessionsRoot)) {
+    throw new Error(`session not found: ${id}`);
+  }
+  for (const entry of readdirSync(sessionsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const candidate = join(sessionsRoot, entry.name, id);
+    if (existsSync(candidate) && statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+  }
+  throw new Error(`session not found: ${id}`);
+}
+function readSessionMeta(id) {
+  return readMetaFile(join(findSessionDir(id), "meta.json"));
+}
+var APPEND_FSYNC_DEBOUNCE_MS = 500;
+function endsWithNewline(path) {
+  let size;
+  try {
+    size = statSync(path).size;
+  } catch {
+    return true;
+  }
+  if (size === 0) return true;
+  const fd = openSync(path, "r");
+  try {
+    const buf = Buffer.alloc(1);
+    readSync(fd, buf, 0, 1, size - 1);
+    return buf[0] === 10;
+  } finally {
+    closeSync(fd);
+  }
+}
+function appendSessionFileEntry(targetPath, entry) {
+  const appendPath = recoverJsonlTargetIfMissing(targetPath);
+  if (appendPath === null) throw new Error(`session JSONL file not found: ${targetPath}`);
+  const serialized = JSON.stringify(entry);
+  if (serialized === void 0) throw new Error("session JSONL entry is not serializable");
+  const line = Buffer.from(`${endsWithNewline(appendPath) ? "" : "\n"}${serialized}
+`, "utf8");
+  const fd = openSync(appendPath, fsConstants.O_WRONLY | fsConstants.O_APPEND);
+  try {
+    const written = writeSync(fd, line);
+    if (written !== line.length) {
+      throw new Error(`short session JSONL append: wrote ${written} of ${line.length} bytes`);
+    }
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+function createWriter(meta, initialTree, initialFileEntries, headerOptions = {}) {
+  const paths = sessionPaths(meta);
+  const tree = [...initialTree];
+  const fileEntries = ensureSessionHeader(meta, initialFileEntries, headerOptions);
+  let closed = false;
+  let appendFd = null;
+  let fsyncTimer = null;
+  if (!isSessionJsonlHeader(initialFileEntries[0])) {
+    writeJsonlFileAtomic(paths.current, fileEntries);
+  }
+  function openAppendFd() {
+    if (appendFd !== null) return appendFd;
+    const tornTail = !endsWithNewline(paths.current);
+    appendFd = openSync(paths.current, "a");
+    if (tornTail) writeSync(appendFd, "\n");
+    return appendFd;
+  }
+  function scheduleFsync() {
+    if (fsyncTimer !== null) return;
+    fsyncTimer = setTimeout(() => {
+      fsyncTimer = null;
+      if (appendFd === null) return;
+      try {
+        fsyncSync(appendFd);
+      } catch {
+      }
+    }, APPEND_FSYNC_DEBOUNCE_MS);
+    fsyncTimer.unref?.();
+  }
+  function closeAppendFd(opts) {
+    if (fsyncTimer !== null) {
+      clearTimeout(fsyncTimer);
+      fsyncTimer = null;
+    }
+    if (appendFd === null) return;
+    try {
+      if (opts.flush) fsyncSync(appendFd);
+    } finally {
+      closeSync(appendFd);
+      appendFd = null;
+    }
+  }
+  function appendLine(entry) {
+    const serialized = JSON.stringify(entry);
+    if (serialized === void 0) {
+      throw new Error("session JSONL entry is not serializable");
+    }
+    writeSync(openAppendFd(), `${serialized}
+`);
+    scheduleFsync();
+  }
+  return {
+    append(turn) {
+      if (closed) throw new Error("session writer closed");
+      const record = recordFromTurn(turn);
+      appendLine(record);
+      fileEntries.push(record);
+      tree.push({
+        id: turn.id,
+        parentId: turn.parentId,
+        at: turn.at,
+        kind: turn.kind
+      });
+    },
+    appendEntry(entry, opts) {
+      if (closed) throw new Error("session writer closed");
+      appendLine(entry);
+      fileEntries.push(entry);
+      if (opts?.treeNode) tree.push(opts.treeNode);
+    },
+    replaceEntries(entries) {
+      if (closed) throw new Error("session writer closed");
+      closeAppendFd({ flush: false });
+      const existingHeader = fileEntries.find(isSessionJsonlHeader);
+      const body = entries.filter((entry) => !isSessionJsonlHeader(entry));
+      const nextEntries = existingHeader ? [existingHeader, ...body] : ensureSessionHeader(meta, body, headerOptions);
+      writeJsonlFileAtomic(paths.current, nextEntries);
+      fileEntries.length = 0;
+      fileEntries.push(...nextEntries);
+      const recoveredTree = treeFromFileEntries(nextEntries);
+      if (recoveredTree.length > 0) {
+        tree.length = 0;
+        tree.push(...recoveredTree);
+      }
+    },
+    async persistTree() {
+      if (appendFd !== null) fsyncSync(appendFd);
+      if (stateRootRemoved()) return;
+      atomicWrite(paths.tree, JSON.stringify(tree, null, 2));
+    },
+    flushAppends() {
+      if (appendFd !== null) fsyncSync(appendFd);
+    },
+    async close() {
+      if (closed) return;
+      closeAppendFd({ flush: true });
+      closed = true;
+      if (stateRootRemoved()) return;
+      atomicWrite(paths.tree, JSON.stringify(tree, null, 2));
+      const ended = { ...meta, endedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      atomicWrite(paths.meta, JSON.stringify(ended, null, 2));
+      meta.endedAt = ended.endedAt;
+    }
+  };
+}
+function createSession(input) {
+  const meta = buildMeta(input);
+  const paths = sessionPaths(meta);
+  atomicWrite(paths.meta, JSON.stringify(meta, null, 2));
+  const headerOptions = {};
+  if (input.parentSession !== void 0) headerOptions.parentSession = input.parentSession;
+  if (input.parentTurnId !== void 0) headerOptions.parentTurnId = input.parentTurnId;
+  const initialEntries = ensureSessionHeader(meta, input.initialEntries ?? [], headerOptions);
+  const initialTree = [...input.initialTree ?? []];
+  writeJsonlFileAtomic(paths.current, initialEntries);
+  atomicWrite(paths.tree, JSON.stringify(initialTree, null, 2));
+  const writer = createWriter(meta, initialTree, initialEntries, headerOptions);
+  return { meta, writer };
+}
+function openSession(id) {
+  const dir = findSessionDir(id);
+  const metaPath = join(dir, "meta.json");
+  const meta = readMetaFile(metaPath);
+  const currentPath = join(dir, "current.jsonl");
+  const fileEntries = readSessionFileEntries(currentPath);
+  const turns = fileEntries.filter((entry) => !isSessionJsonlHeader(entry));
+  const header = fileEntries.find(isSessionJsonlHeader) ?? null;
+  const tree = recoverTreeFromJsonl(readTreeFile(join(dir, "tree.json")), fileEntries);
+  return {
+    meta() {
+      return meta;
+    },
+    turns() {
+      return turns;
+    },
+    fileEntries() {
+      return fileEntries;
+    },
+    header() {
+      return header;
+    },
+    tree() {
+      return tree;
+    }
+  };
+}
+function resumeSession(id) {
+  const dir = findSessionDir(id);
+  const metaPath = join(dir, "meta.json");
+  const meta = readMetaFile(metaPath);
+  if (meta.endedAt !== null) {
+    meta.endedAt = null;
+    atomicWrite(metaPath, JSON.stringify(meta, null, 2));
+  }
+  const existingFileEntries = readSessionFileEntries(join(dir, "current.jsonl"));
+  const existingTree = recoverTreeFromJsonl(readTreeFile(join(dir, "tree.json")), existingFileEntries);
+  const writer = createWriter(meta, existingTree, existingFileEntries);
+  return { meta, writer, tree: existingTree };
+}
+
+export {
+  CURRENT_SESSION_FORMAT_VERSION,
+  cwdHash,
+  sessionPaths,
+  atomicWrite,
+  readSessionFileEntries,
+  readSessionTailTurns,
+  sessionCurrentPath,
+  readSessionMeta,
+  appendSessionFileEntry,
+  createSession,
+  openSession,
+  resumeSession
+};
+//# sourceMappingURL=chunk-UGYAX5YI.js.map