@ashx-j/lunr-dev 0.2.19-dev.10.1 → 0.2.21-dev.12.1

package/dist/node-runtime/{chunk-OTT6JMPU.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,373 +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 } from "node:crypto";
-import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join, normalize, 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 isWithinAllowedRoots(absPath, turn) {
-  return turn.cwd ? [
-    ROLLBACK_BASE,
-    join(homedir(), CONFIG_DIR_NAME),
-    // lunr: agent settings / cron jobs.json live under the config dir
-    // lunr: simple-memory lives next to the lunr agent dir (~/.lunr/simple-memory)
-    join(dirname(getAgentDir()), "simple-memory"),
-    resolve(turn.cwd)
-  ].some((root) => isPathUnderRoot(absPath, root)) : !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 (!isWithinAllowedRoots(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;
-        mkdirSync(dirname(absPath), { recursive: !0 }), writeFileSync(absPath, snap.content), restored.push(absPath);
-      } else snap.existed || (snap.createdByTool || capture === "hybrid" || capture === "shadow-git") && existsSync(absPath) && (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
 };

package/dist/node-runtime/{chunk-5Q45AVQG.js → chunk-MW2XJZIK.js}

@@ -3,7 +3,7 @@ import {
   applyExifOrientation,
   formatDimensionNote,
   resizeImage
-} from "./chunk-ZSEZY3II.js";
+} from "./chunk-VTPM5V35.js";
 import {
   loadPhoton
 } from "./chunk-RQ2Q5IYR.js";