@ashx-j/lunr-dev 0.2.16-dev.9.1 → 0.2.21-dev.12.1

package/dist/node-runtime/{chunk-2QKLKMKC.js → chunk-LTXUQJI4.js}

@@ -1,7 +1,7 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   require_proper_lockfile
-} from "./chunk-AJX357CL.js";
+} from "./chunk-URD2SLIT.js";
 import {
   CONFIG_DIR_NAME,
   canonicalizePath,

package/dist/node-runtime/{chunk-YF63P5ZT.js → chunk-LTYWTR3V.js}

@@ -1,8 +1,4 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
-import {
-  CONFIG_DIR_NAME,
-  getAgentDir
-} from "./chunk-PCIGF2XK.js";
 
 // packages/coding-agent/dist/core/usage-adapters/shared.js
 async function fetchWithTimeout(url, init, timeoutMs = 1e4) {
@@ -435,430 +431,9 @@ function getUsageServiceBridge() {
   return globalThis[USAGE_SERVICE_BRIDGE_SYMBOL];
 }
 
-// packages/coding-agent/dist/core/rollback.js
-import { spawnSync } from "node:child_process";
-import { createHash, randomUUID } from "node:crypto";
-import { closeSync, cpSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, normalize, relative, resolve } from "node:path";
-var ROLLBACK_BASE = join(homedir(), ".lunr", "rollback"), contexts = /* @__PURE__ */ new Map(), lastSessionId, globalSettingsManager, warningHandler;
-function setRollbackWarningHandler(handler) {
-  warningHandler = handler;
-}
-function createContext(sessionId) {
-  return {
-    sessionId,
-    settingsManager: globalSettingsManager,
-    sessionForceEnabled: !1,
-    turns: [],
-    currentTurnIndex: -1,
-    repoWarningShown: !1,
-    externalModWarningShown: !1
-  };
-}
-function getContext(sessionId) {
-  let sid = sessionId ?? lastSessionId ?? "default", ctx = contexts.get(sid);
-  return ctx || (ctx = createContext(sid), contexts.set(sid, ctx)), ctx;
-}
-function initRollback(sm, sid) {
-  globalSettingsManager = sm, lastSessionId = sid, contexts.set(sid, createContext(sid));
-  let ctx = contexts.get(sid);
-  ctx.settingsManager = sm, loadPersistedTurns(ctx);
-}
-function isRollbackEnabled(sessionId) {
-  let ctx = getContext(sessionId);
-  return (ctx.settingsManager?.getRollbackEnabled() ?? !1) || ctx.sessionForceEnabled;
-}
-function isRollbackSessionForceEnabled(sessionId) {
-  return getContext(sessionId).sessionForceEnabled;
-}
-function enableRollbackForSession(sessionId) {
-  getContext(sessionId).sessionForceEnabled = !0;
-}
-function disableRollbackForSession(sessionId) {
-  getContext(sessionId).sessionForceEnabled = !1;
-}
-function pruneTurns(ctx) {
-  let maxTurns = ctx.settingsManager?.getRollbackTurns() ?? 2;
-  for (; ctx.turns.length > maxTurns; ) {
-    let old = ctx.turns.shift();
-    old && cleanupTurnFiles(ctx, old);
-  }
-}
-function beginTurn(cwd, sessionId) {
-  let ctx = getContext(sessionId);
-  if (!isRollbackEnabled(ctx.sessionId))
-    return;
-  cwd && (ctx.lastCwd = cwd), ctx.currentTurnIndex++;
-  let turn = { turnIndex: ctx.currentTurnIndex, cwd, files: /* @__PURE__ */ new Map() };
-  ctx.turns.push(turn), pruneTurns(ctx), cwd && ctx.settingsManager?.getRollbackScope() === "tree" && captureTreeBaseline(ctx, cwd);
-}
-function rollbackSnapshotBeforeWrite(absPath, sessionId) {
-  let ctx = getContext(sessionId);
-  if (!isRollbackEnabled(ctx.sessionId))
-    return;
-  (ctx.currentTurnIndex < 0 || ctx.turns.length === 0) && beginTurn(ctx.lastCwd, ctx.sessionId);
-  let turn = ctx.turns[ctx.turns.length - 1];
-  if (turn && !turn.files.has(absPath))
-    try {
-      let existed = existsSync(absPath), content;
-      existed && (content = readFileSync(absPath)), turn.files.set(absPath, {
-        existed,
-        content,
-        createdByTool: !0
-      }), persistSnapshot(ctx, turn, absPath);
-    } catch {
-    }
-}
-function captureTreeBaseline(ctx, cwd) {
-  let turn = ctx.turns[ctx.turns.length - 1];
-  if (!turn)
-    return;
-  let entries = gitPorcelain(ctx, cwd);
-  if (entries)
-    for (let { path } of entries) {
-      if (!path)
-        continue;
-      let abs = join(cwd, path);
-      if (!turn.files.has(abs))
-        try {
-          let existed = existsSync(abs);
-          turn.files.set(abs, {
-            existed,
-            content: existed ? readFileSync(abs) : void 0,
-            createdByTool: !1
-          }), persistSnapshot(ctx, turn, abs);
-        } catch {
-        }
-    }
-}
-function captureTreeChanges(cwd, sessionId) {
-  let ctx = getContext(sessionId);
-  if (!isRollbackEnabled(ctx.sessionId) || ctx.settingsManager?.getRollbackScope() !== "tree" || ctx.currentTurnIndex < 0 || ctx.turns.length === 0)
-    return;
-  let turn = ctx.turns[ctx.turns.length - 1];
-  if (!turn)
-    return;
-  let entries = gitPorcelain(ctx, cwd);
-  if (entries)
-    for (let { status, path, source } of entries) {
-      if (!path)
-        continue;
-      let abs = join(cwd, path);
-      if (!turn.files.has(abs))
-        try {
-          if (status === "??" || status.includes("R")) {
-            if (turn.files.set(abs, { existed: !1, createdByTool: !1 }), persistSnapshot(ctx, turn, abs), status.includes("R") && source) {
-              let sourceAbs = join(cwd, source);
-              if (!turn.files.has(sourceAbs)) {
-                let headSrc = spawnSync("git", ["show", `HEAD:${source}`], {
-                  cwd,
-                  timeout: 5e3,
-                  maxBuffer: 33554432
-                });
-                !headSrc.error && headSrc.status === 0 && headSrc.stdout && (turn.files.set(sourceAbs, {
-                  existed: !0,
-                  content: headSrc.stdout,
-                  createdByTool: !1
-                }), persistSnapshot(ctx, turn, sourceAbs));
-              }
-            }
-          } else {
-            let head = spawnSync("git", ["show", `HEAD:${path}`], {
-              cwd,
-              timeout: 5e3,
-              maxBuffer: 33554432
-            });
-            if (head.error || head.status !== 0 || !head.stdout)
-              continue;
-            turn.files.set(abs, {
-              existed: !0,
-              content: head.stdout,
-              createdByTool: !1
-            }), persistSnapshot(ctx, turn, abs);
-          }
-        } catch {
-        }
-    }
-}
-function gitPorcelain(ctx, cwd) {
-  try {
-    let result = spawnSync("git", ["status", "--porcelain", "-z"], { cwd, encoding: "utf8", timeout: 5e3 });
-    if (result.error || result.status !== 0) {
-      warnOnce(ctx, "Rollback tree scope: not a git repository (or git failed) \u2014 bash side-effects won't be captured.");
-      return;
-    }
-    let fields = (result.stdout ?? "").split("\0").filter((f) => f.length > 0), entries = [];
-    for (let i = 0; i < fields.length; i++) {
-      let field = fields[i], status = field.slice(0, 2), path = field.slice(3), source;
-      (status.includes("R") || status.includes("C")) && (source = fields[i + 1], i++), entries.push({ status, path, source });
-    }
-    return entries;
-  } catch {
-    warnOnce(ctx, "Rollback tree scope: not a git repository (or git failed) \u2014 bash side-effects won't be captured.");
-    return;
-  }
-}
-function warnOnce(ctx, message) {
-  if (!ctx.repoWarningShown) {
-    ctx.repoWarningShown = !0;
-    try {
-      warningHandler?.(message);
-    } catch {
-    }
-  }
-}
-function persistSnapshot(ctx, turn, absPath) {
-  try {
-    let snap = turn.files.get(absPath);
-    if (!snap)
-      return;
-    let turnDir = getTurnDir(ctx, turn.turnIndex);
-    mkdirSync(turnDir, { recursive: !0 });
-    let manifestPath = join(turnDir, "manifest.json"), manifest = readManifest(manifestPath), entry = { existed: snap.existed, createdByTool: snap.createdByTool };
-    if (snap.content) {
-      let snapFile = snapFileName(absPath);
-      writeFileSync(join(turnDir, snapFile), snap.content), entry.snapFile = snapFile;
-    }
-    manifest.files[absPath] = entry, turn.cwd && (manifest.cwd = turn.cwd), writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
-  } catch {
-  }
-}
-function readManifest(path) {
-  if (!existsSync(path))
-    return { files: {} };
-  try {
-    let parsed = JSON.parse(readFileSync(path, "utf-8"));
-    if (parsed && typeof parsed == "object" && !Array.isArray(parsed)) {
-      let files = parsed.files;
-      return {
-        cwd: typeof parsed.cwd == "string" ? parsed.cwd : void 0,
-        files: files && typeof files == "object" && !Array.isArray(files) ? files : {}
-      };
-    }
-    return { files: {} };
-  } catch {
-    return { files: {} };
-  }
-}
-function loadPersistedTurns(ctx) {
-  try {
-    let sessionDir = join(ROLLBACK_BASE, ctx.sessionId);
-    if (!existsSync(sessionDir))
-      return;
-    let loaded = [];
-    for (let dirName of readdirSync(sessionDir)) {
-      let match = /^turn-(\d+)$/.exec(dirName);
-      if (!match)
-        continue;
-      let turnIndex = Number(match[1]), turnDir = join(sessionDir, dirName), manifest = readManifest(join(turnDir, "manifest.json")), files = /* @__PURE__ */ new Map();
-      for (let [absPath, meta] of Object.entries(manifest.files)) {
-        let content;
-        if (meta.snapFile)
-          try {
-            content = readFileSync(join(turnDir, meta.snapFile));
-          } catch {
-            content = void 0;
-          }
-        files.set(absPath, { existed: meta.existed, content, createdByTool: meta.createdByTool });
-      }
-      loaded.push({ turnIndex, cwd: manifest.cwd, files });
-    }
-    loaded.sort((a, b) => a.turnIndex - b.turnIndex), ctx.turns = loaded, ctx.currentTurnIndex = loaded.length > 0 ? loaded[loaded.length - 1].turnIndex : -1, pruneTurns(ctx);
-  } catch {
-  }
-}
-function getTurnDir(ctx, turnIndex) {
-  return join(ROLLBACK_BASE, ctx.sessionId, `turn-${turnIndex}`);
-}
-function cleanupTurnFiles(ctx, turn) {
-  try {
-    let dir = getTurnDir(ctx, turn.turnIndex);
-    existsSync(dir) && rmSync(dir, { recursive: !0, force: !0 });
-  } catch {
-  }
-}
-function isPathUnderRoot(absPath, root) {
-  let normRoot = normalize(root).replace(/\\$/g, ""), normPath = normalize(absPath).replace(/\\$/g, "");
-  return process.platform === "win32" && (normRoot = normRoot.toLowerCase(), normPath = normPath.toLowerCase()), normPath === normRoot || normPath.startsWith(`${normRoot}/`) || normPath.startsWith(`${normRoot}\\`);
-}
-function getAllowedRoots(turn) {
-  return turn.cwd ? [
-    ROLLBACK_BASE,
-    join(homedir(), CONFIG_DIR_NAME),
-    join(dirname(getAgentDir()), "simple-memory"),
-    resolve(turn.cwd)
-  ] : [];
-}
-function findAllowedRoot(absPath, turn) {
-  return getAllowedRoots(turn).filter((root) => isPathUnderRoot(absPath, root)).sort((a, b) => b.length - a.length)[0];
-}
-function lstatIfPresent(path) {
-  try {
-    return lstatSync(path);
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return;
-    throw error;
-  }
-}
-function safeRestoreParent(absPath, turn) {
-  let allowedRoot = findAllowedRoot(absPath, turn);
-  if (turn.cwd && !allowedRoot || lstatIfPresent(absPath)?.isSymbolicLink())
-    return;
-  if (!allowedRoot)
-    return dirname(absPath);
-  let rootEntry = lstatIfPresent(allowedRoot);
-  if (!rootEntry || !rootEntry.isDirectory() || rootEntry.isSymbolicLink())
-    return;
-  let parent = dirname(absPath), relativeParent = relative(allowedRoot, parent);
-  if (relativeParent.startsWith("..") || !isPathUnderRoot(parent, allowedRoot))
-    return;
-  let current = allowedRoot;
-  for (let segment of relativeParent.split(/[\\/]/).filter(Boolean)) {
-    current = join(current, segment);
-    let entry = lstatIfPresent(current);
-    if (entry) {
-      if (entry.isSymbolicLink() || !entry.isDirectory())
-        return;
-    } else
-      mkdirSync(current);
-  }
-  let realRoot = realpathSync.native(allowedRoot), realParent = realpathSync.native(parent);
-  if (isPathUnderRoot(realParent, realRoot) && !lstatIfPresent(absPath)?.isSymbolicLink())
-    return parent;
-}
-function restoreFileAtomically(absPath, content, turn) {
-  let parent = safeRestoreParent(absPath, turn);
-  if (!parent)
-    return !1;
-  let tempPath = join(parent, `.lunr-rollback-${randomUUID()}.tmp`), fd;
-  try {
-    return fd = openSync(tempPath, "wx", 384), writeFileSync(fd, content), fsyncSync(fd), closeSync(fd), fd = void 0, safeRestoreParent(absPath, turn) ? (renameSync(tempPath, absPath), !0) : !1;
-  } finally {
-    fd !== void 0 && closeSync(fd), rmSync(tempPath, { force: !0 });
-  }
-}
-function warnExternalModification(ctx, message) {
-  if (!(ctx.externalModWarningShown || !warningHandler)) {
-    ctx.externalModWarningShown = !0;
-    try {
-      warningHandler(message);
-    } catch {
-    }
-  }
-}
-function peekRollbackTurnsConsumed(sessionId) {
-  let ctx = getContext(sessionId);
-  if (!isRollbackEnabled(ctx.sessionId) || ctx.turns.length === 0)
-    return 0;
-  let consumed = 0;
-  for (let i = ctx.turns.length - 1; i >= 0 && (consumed++, !(ctx.turns[i].files.size > 0)); i--)
-    ;
-  return consumed;
-}
-function rollbackLastTurn(sessionId) {
-  let ctx = getContext(sessionId), empty = { restored: [], deleted: [], turnsConsumed: 0 };
-  if (!isRollbackEnabled(ctx.sessionId))
-    return empty;
-  let turnsConsumed = 0;
-  for (; ctx.turns.length > 0 && ctx.turns[ctx.turns.length - 1].files.size === 0; ) {
-    let skipped = ctx.turns.pop();
-    skipped && (cleanupTurnFiles(ctx, skipped), turnsConsumed++);
-  }
-  if (ctx.turns.length === 0)
-    return empty;
-  turnsConsumed++;
-  let turn = ctx.turns[ctx.turns.length - 1], capture = ctx.settingsManager?.getRollbackCapture() ?? "copies", restored = [], deleted = [];
-  for (let [absPath, snap] of turn.files)
-    try {
-      if (turn.cwd && !findAllowedRoot(absPath, turn)) {
-        warnExternalModification(ctx, `Rollback skipped ${absPath}: outside the session working directory or lunR config dir.`);
-        continue;
-      }
-      if (snap.existed && snap.content) {
-        if (!snap.createdByTool && existsSync(absPath) && readFileSync(absPath).equals(snap.content))
-          continue;
-        if (!restoreFileAtomically(absPath, snap.content, turn)) {
-          warnExternalModification(ctx, `Rollback skipped ${absPath}: a symlink or junction made the path unsafe.`);
-          continue;
-        }
-        restored.push(absPath);
-      } else if (!snap.existed && (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && lstatIfPresent(absPath)) {
-        if (!safeRestoreParent(absPath, turn)) {
-          warnExternalModification(ctx, `Rollback skipped ${absPath}: a symlink or junction made the path unsafe.`);
-          continue;
-        }
-        unlinkSync(absPath), deleted.push(absPath);
-      }
-    } catch {
-    }
-  return cleanupTurnFiles(ctx, turn), ctx.turns.pop(), { restored, deleted, turnsConsumed };
-}
-function migrateRollbackSession(oldSessionId, newSessionId) {
-  if (oldSessionId === newSessionId)
-    return;
-  let ctx = contexts.get(oldSessionId);
-  ctx && (contexts.delete(oldSessionId), ctx.sessionId = newSessionId, contexts.set(newSessionId, ctx));
-  try {
-    let oldDir = join(ROLLBACK_BASE, oldSessionId), newDir = join(ROLLBACK_BASE, newSessionId);
-    if (existsSync(oldDir)) {
-      existsSync(newDir) && rmSync(newDir, { recursive: !0, force: !0 });
-      try {
-        renameSync(oldDir, newDir);
-      } catch {
-        cpSync(oldDir, newDir, { recursive: !0 }), rmSync(oldDir, { recursive: !0, force: !0 });
-      }
-    }
-  } catch {
-  }
-}
-function clearRollback(sessionId) {
-  if (sessionId === void 0) {
-    for (let ctx2 of contexts.values()) {
-      for (let turn of ctx2.turns)
-        cleanupTurnFiles(ctx2, turn);
-      try {
-        let sessionDir = join(ROLLBACK_BASE, ctx2.sessionId);
-        existsSync(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
-      } catch {
-      }
-    }
-    contexts.clear();
-    return;
-  }
-  let ctx = contexts.get(sessionId);
-  if (ctx) {
-    for (let turn of ctx.turns)
-      cleanupTurnFiles(ctx, turn);
-    try {
-      let sessionDir = join(ROLLBACK_BASE, sessionId);
-      existsSync(sessionDir) && rmSync(sessionDir, { recursive: !0, force: !0 });
-    } catch {
-    }
-    contexts.delete(sessionId);
-  }
-}
-function snapFileName(absPath) {
-  return `${createHash("sha1").update(absPath).digest("hex")}.snap`;
-}
-
 export {
   getAllPlanUsageResults,
   clearPlanUsageCache,
   registerUsageServiceBridge,
-  getUsageServiceBridge,
-  setRollbackWarningHandler,
-  initRollback,
-  isRollbackEnabled,
-  isRollbackSessionForceEnabled,
-  enableRollbackForSession,
-  disableRollbackForSession,
-  beginTurn,
-  rollbackSnapshotBeforeWrite,
-  captureTreeChanges,
-  peekRollbackTurnsConsumed,
-  rollbackLastTurn,
-  migrateRollbackSession,
-  clearRollback
+  getUsageServiceBridge
 };