@freesyntax/notch-cli 0.5.20 → 0.5.21

package/dist/chunk-MMBFNIKE.js

@@ -0,0 +1,509 @@
+import {
+  OLLAMA_CLOUD_BASE_URL,
+  OLLAMA_LOCAL_BASE_URL,
+  detectDaemon,
+  formatBytes,
+  isCloudBaseUrl,
+  isCloudModel,
+  listModels,
+  pullModel,
+  showModel
+} from "./chunk-GFVLHUSS.js";
+import {
+  clearOllamaCreds,
+  findByokProvider,
+  ollamaCredsPath,
+  readOllamaCreds,
+  writeOllamaCreds
+} from "./chunk-443G6HCC.js";
+
+// src/commands/ollama-launch.ts
+import fs from "fs/promises";
+import path from "path";
+import readline from "readline";
+import chalk from "chalk";
+var readCreds = readOllamaCreds;
+var writeCreds = writeOllamaCreds;
+var clearCreds = clearOllamaCreds;
+var credsPath = ollamaCredsPath;
+function parseFlags(argv) {
+  const out = { positional: [], cloud: false, yes: false, help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--cloud") out.cloud = true;
+    else if (a === "-y" || a === "--yes") out.yes = true;
+    else if (a === "--help" || a === "-h") out.help = true;
+    else if (a === "--model" || a === "-m") out.model = argv[++i];
+    else if (a.startsWith("--model=")) out.model = a.slice("--model=".length);
+    else if (a === "--host") out.host = argv[++i];
+    else if (a.startsWith("--host=")) out.host = a.slice("--host=".length);
+    else if (a === "--api-key") out.apiKey = argv[++i];
+    else if (a.startsWith("--api-key=")) out.apiKey = a.slice("--api-key=".length);
+    else if (a === "--compat") {
+      const v = argv[++i];
+      if (v === "openai" || v === "anthropic") out.compat = v;
+    } else if (a.startsWith("--compat=")) {
+      const v = a.slice("--compat=".length);
+      if (v === "openai" || v === "anthropic") out.compat = v;
+    } else if (!a.startsWith("-")) {
+      out.positional.push(a);
+    }
+  }
+  return out;
+}
+async function resolveEndpoint(flags) {
+  let baseUrl;
+  if (flags.host) {
+    baseUrl = flags.host;
+  } else if (flags.cloud) {
+    baseUrl = OLLAMA_CLOUD_BASE_URL;
+  } else if (process.env.OLLAMA_HOST) {
+    baseUrl = process.env.OLLAMA_HOST.startsWith("http") ? process.env.OLLAMA_HOST : `http://${process.env.OLLAMA_HOST}`;
+  } else {
+    baseUrl = OLLAMA_LOCAL_BASE_URL;
+  }
+  const mode = isCloudBaseUrl(baseUrl) ? "cloud" : "local";
+  let apiKey = flags.apiKey ?? process.env.OLLAMA_API_KEY ?? void 0;
+  if (!apiKey && mode === "cloud") {
+    const stored = await readCreds();
+    if (stored && stored.endpoint === baseUrl) {
+      apiKey = stored.apiKey;
+    }
+  }
+  return { baseUrl, apiKey, mode };
+}
+async function promptLine(prompt, opts = {}) {
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive prompt requested but stdin is not a TTY.");
+  }
+  if (!opts.mask) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const answer = await new Promise((resolve) => {
+      rl.question(prompt, (ans) => resolve(ans));
+    });
+    rl.close();
+    return answer.trim();
+  }
+  return new Promise((resolve, reject) => {
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    let buf = "";
+    const onData = (chunk) => {
+      for (const byte of chunk) {
+        if (byte === 3) {
+          cleanup();
+          process.stdout.write("\n");
+          reject(new Error("Cancelled"));
+          return;
+        }
+        if (byte === 13 || byte === 10) {
+          cleanup();
+          process.stdout.write("\n");
+          resolve(buf.trim());
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          if (buf.length > 0) {
+            buf = buf.slice(0, -1);
+            process.stdout.write("\b \b");
+          }
+          continue;
+        }
+        if (byte < 32) continue;
+        buf += String.fromCharCode(byte);
+        process.stdout.write("*");
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+    };
+    stdin.on("data", onData);
+  });
+}
+function pickFromList(items, title) {
+  if (items.length === 0) return Promise.resolve(null);
+  if (!process.stdin.isTTY) return Promise.resolve(items[0] ?? null);
+  return new Promise((resolve) => {
+    let cursor = 0;
+    const render = (first) => {
+      if (!first) process.stdout.write(`\x1B[${items.length + 2}A\x1B[J`);
+      process.stdout.write(chalk.gray(`  ${title} (\u2191\u2193 to move, Enter to select, Esc to cancel)
+
+`));
+      for (let i = 0; i < items.length; i++) {
+        const pointer = i === cursor ? chalk.cyan("\u276F") : " ";
+        const label = i === cursor ? chalk.bold(items[i]) : chalk.gray(items[i]);
+        process.stdout.write(`  ${pointer} ${label}
+`);
+      }
+    };
+    render(true);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+    const onKey = (key) => {
+      const s = key.toString();
+      if (s === "\x1B[A") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render(false);
+      } else if (s === "\x1B[B") {
+        cursor = (cursor + 1) % items.length;
+        render(false);
+      } else if (s === "\r" || s === "\n") {
+        cleanup();
+        resolve(items[cursor] ?? null);
+      } else if (s === "\x1B" || s === "") {
+        cleanup();
+        resolve(null);
+      }
+    };
+    const cleanup = () => {
+      stdin.removeListener("data", onKey);
+      stdin.setRawMode(wasRaw ?? false);
+      stdin.pause();
+    };
+    stdin.on("data", onKey);
+  });
+}
+function renderProgressLine(ev, lastStatus) {
+  if (ev.kind === "progress") {
+    const width = 30;
+    const filled = Math.max(0, Math.min(width, Math.round(ev.percent / 100 * width)));
+    const bar = `${"\u2588".repeat(filled)}${"\u2591".repeat(width - filled)}`;
+    const suffix = `${ev.percent.toFixed(1).padStart(5)}%  ${formatBytes(ev.completed)}/${formatBytes(ev.total)}`;
+    const label = ev.message || lastStatus.label;
+    lastStatus.label = label;
+    process.stdout.write(`\r  ${chalk.cyan(bar)}  ${chalk.gray(suffix)}  ${chalk.dim(label)}\x1B[K`);
+  } else if (ev.kind === "status") {
+    lastStatus.label = ev.message;
+    process.stdout.write(`\r  ${chalk.gray(ev.message)}\x1B[K`);
+  } else {
+    process.stdout.write("\n");
+  }
+}
+async function persistOllamaChoice(projectRoot, opts) {
+  const p = path.resolve(projectRoot, ".notch.json");
+  let current = {};
+  try {
+    const raw = await fs.readFile(p, "utf-8");
+    current = JSON.parse(raw);
+  } catch (err) {
+    const code = err.code;
+    if (code && code !== "ENOENT") throw err;
+  }
+  const byok = {
+    provider: opts.providerId,
+    model: opts.modelId
+  };
+  if (opts.baseUrl) byok.baseUrl = opts.baseUrl;
+  if (opts.apiShape) byok.apiShape = opts.apiShape;
+  current.byok = byok;
+  await fs.writeFile(p, JSON.stringify(current, null, 2) + "\n", "utf-8");
+}
+async function cmdList(flags) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  if (!ok) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  let rows;
+  try {
+    rows = await listModels(baseUrl, { apiKey });
+  } catch (err) {
+    console.error(chalk.red(`  ${err.message}`));
+    return 1;
+  }
+  if (rows.length === 0) {
+    console.log(chalk.gray(`
+  No models installed at ${baseUrl}.`));
+    console.log(chalk.gray(`  Pull one:  notch ollama pull llama3.2:latest
+`));
+    return 0;
+  }
+  const header = `  ${"name".padEnd(36)} ${"params".padEnd(8)} ${"quant".padEnd(10)} ${"size".padStart(8)}`;
+  console.log(chalk.gray(`
+  ${mode === "cloud" ? "Ollama Cloud" : "Ollama local"}  @  ${baseUrl}
+`));
+  console.log(chalk.gray(header));
+  console.log(chalk.gray(`  ${"-".repeat(header.length - 2)}`));
+  for (const r of rows) {
+    console.log(
+      `  ${chalk.white(r.name.padEnd(36))} ${chalk.gray(r.parameterSize.padEnd(8))} ${chalk.gray(r.quantization.padEnd(10))} ${chalk.gray(formatBytes(r.sizeBytes))}`
+    );
+  }
+  console.log("");
+  return 0;
+}
+async function cmdPull(flags) {
+  const modelName = flags.positional[0] ?? flags.model;
+  if (!modelName) {
+    console.error(chalk.red("  Usage: notch ollama pull <model>"));
+    return 2;
+  }
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  if (!ok) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  console.log(chalk.cyan(`
+  Pulling ${chalk.bold(modelName)} from ${baseUrl}...
+`));
+  const lastStatus = { label: "" };
+  try {
+    for await (const ev of pullModel(modelName, baseUrl, { apiKey })) {
+      renderProgressLine(ev, lastStatus);
+    }
+  } catch (err) {
+    process.stdout.write("\n");
+    console.error(chalk.red(`  Pull failed: ${err.message}`));
+    return 1;
+  }
+  console.log(chalk.green(`  \u2713 ${modelName} ready.
+`));
+  return 0;
+}
+async function cmdStatus(flags) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  console.log("");
+  console.log(chalk.gray("  Endpoint"), chalk.white(baseUrl));
+  console.log(chalk.gray("  Mode    "), chalk.white(mode));
+  console.log(chalk.gray("  Auth    "), apiKey ? chalk.green("yes (api key)") : chalk.yellow("none"));
+  console.log(chalk.gray("  Reach   "), ok ? chalk.green("ok") : chalk.red("unreachable"));
+  console.log("");
+  return ok ? 0 : 1;
+}
+async function cmdLogin(flags) {
+  const endpoint = flags.host ?? OLLAMA_CLOUD_BASE_URL;
+  console.log(chalk.cyan(`
+  Ollama login \u2014 paste your API key for ${endpoint}`));
+  console.log(chalk.gray(`  Get one at https://ollama.com/settings/keys
+`));
+  let apiKey = flags.apiKey;
+  if (!apiKey) {
+    apiKey = await promptLine("  API key: ", { mask: true });
+  }
+  if (!apiKey) {
+    console.error(chalk.red("  No key provided."));
+    return 2;
+  }
+  const reachable = await detectDaemon(endpoint, { apiKey, timeoutMs: 8e3 });
+  if (!reachable) {
+    console.error(chalk.red(`  Could not authenticate against ${endpoint} with the provided key.`));
+    return 1;
+  }
+  await writeCreds({ apiKey, endpoint, createdAt: Date.now() });
+  console.log(chalk.green(`  \u2713 Key stored at ${credsPath()}`));
+  console.log(chalk.gray(`  The CLI will auto-load it when you run \`notch ollama --cloud\`.
+`));
+  return 0;
+}
+async function cmdLogout(_flags) {
+  const existed = await readCreds();
+  await clearCreds();
+  if (existed) {
+    console.log(chalk.green(`
+  \u2713 Cleared Ollama credentials for ${existed.endpoint}
+`));
+  } else {
+    console.log(chalk.gray("\n  No stored Ollama credentials.\n"));
+  }
+  return 0;
+}
+async function cmdLaunch(flags, opts) {
+  const { baseUrl, apiKey, mode } = await resolveEndpoint(flags);
+  const ok = await detectDaemon(baseUrl, { apiKey });
+  if (!ok) {
+    printNotReachable(baseUrl, mode);
+    return 1;
+  }
+  let rows = [];
+  try {
+    rows = await listModels(baseUrl, { apiKey });
+  } catch (err) {
+    console.error(chalk.red(`  Could not list models: ${err.message}`));
+    return 1;
+  }
+  let chosen = flags.model;
+  if (!chosen) {
+    if (rows.length === 0) {
+      console.log(chalk.yellow(`
+  No models installed at ${baseUrl}.`));
+      const suggest = ["qwen3-coder:30b", "gpt-oss:20b", "llama3.2:latest"];
+      const pick = await pickFromList(
+        suggest,
+        "Pick one to pull"
+      );
+      if (!pick) return 0;
+      chosen = pick;
+      const pullCode = await cmdPull({ ...flags, positional: [chosen] });
+      if (pullCode !== 0) return pullCode;
+    } else {
+      const pick = await pickFromList(rows.map((r) => r.name), "Select a model");
+      if (!pick) return 0;
+      chosen = pick;
+    }
+  } else if (mode === "local" && !rows.some((r) => r.name === chosen) && !isCloudModel(chosen)) {
+    const consent = flags.yes ? true : (await promptLine(`  Model ${chosen} isn't installed. Pull now? [Y/n] `)).toLowerCase() !== "n";
+    if (consent) {
+      const pullCode = await cmdPull({ ...flags, positional: [chosen] });
+      if (pullCode !== 0) return pullCode;
+    } else {
+      console.error(chalk.red("  Aborted: model not installed."));
+      return 1;
+    }
+  }
+  if (mode === "local") {
+    try {
+      const info = await showModel(chosen, baseUrl, { apiKey });
+      if (typeof info.contextLength === "number" && info.contextLength < 64e3) {
+        console.warn(
+          chalk.yellow(
+            `  \u26A0 ${chosen} exposes only ${info.contextLength.toLocaleString()} tokens of context. Notch recommends \u226564,000 \u2014 agent loops will truncate aggressively.`
+          )
+        );
+      }
+    } catch {
+    }
+  }
+  const compat = flags.compat ?? "openai";
+  let providerId;
+  if (mode === "cloud") {
+    providerId = "ollama-cloud";
+    if (flags.compat === "anthropic") {
+      console.warn(chalk.yellow(
+        "  ! --compat anthropic is ignored for Ollama Cloud (only the local daemon exposes /v1/messages)."
+      ));
+    }
+  } else if (compat === "anthropic") {
+    providerId = "ollama-anthropic";
+  } else {
+    providerId = "ollama";
+  }
+  const providerInfo = findByokProvider(providerId);
+  if (!providerInfo) {
+    console.error(chalk.red(`  Internal: provider ${providerId} missing from catalog.`));
+    return 1;
+  }
+  try {
+    await persistOllamaChoice(opts.projectRoot, {
+      providerId,
+      modelId: chosen,
+      // Only persist baseUrl when it differs from the provider default
+      // — otherwise the catalog default carries forward and survives
+      // future CLI upgrades.
+      baseUrl: baseUrl === providerInfo.baseUrl || mode === "cloud" && baseUrl === OLLAMA_CLOUD_BASE_URL ? void 0 : baseUrl,
+      apiShape: providerInfo.apiShape
+    });
+  } catch (err) {
+    console.warn(chalk.yellow(`  ! Could not write .notch.json: ${err.message}`));
+  }
+  console.log("");
+  console.log(chalk.green(`  \u2713 Ollama configured.`));
+  console.log(chalk.gray("    provider "), chalk.white(providerId));
+  console.log(chalk.gray("    model    "), chalk.white(chosen));
+  console.log(chalk.gray("    endpoint "), chalk.white(baseUrl));
+  console.log(chalk.gray("    compat   "), chalk.white(providerInfo.apiShape ?? "openai"));
+  console.log("");
+  if (mode === "cloud" && apiKey && !process.env.OLLAMA_API_KEY) {
+    console.log(chalk.gray(`  Ollama Cloud key loaded from  ${credsPath()}`));
+  }
+  console.log(chalk.gray(`  Run:  notch  (the selection is saved in .notch.json)`));
+  console.log("");
+  return 0;
+}
+function printNotReachable(baseUrl, mode) {
+  console.error(chalk.red(`
+  Cannot reach Ollama at ${baseUrl}.`));
+  if (mode === "local") {
+    console.error(chalk.gray(`  Start the daemon:  ollama serve`));
+    console.error(chalk.gray(`  Or install:        https://ollama.com/download
+`));
+  } else {
+    console.error(chalk.gray(`  Check that OLLAMA_API_KEY is set (notch ollama login).
+`));
+  }
+}
+function printHelp() {
+  console.log(`
+  Notch CLI \u2014 Ollama integration
+
+  Usage:
+    notch ollama                 Interactive setup + launch
+    notch ollama launch          Same as above (explicit)
+    notch ollama list            List installed / cloud models
+    notch ollama pull <model>    Pull a model with a progress bar
+    notch ollama status          Show daemon reachability
+    notch ollama login           Store OLLAMA_API_KEY for Cloud
+    notch ollama logout          Clear stored Ollama credentials
+    notch ollama bench           Benchmark multiple models on a prompt
+
+  Flags (for every subcommand):
+    --cloud                      Use https://ollama.com (Ollama Cloud)
+    --host <url>                 Override the daemon base URL
+    --model, -m <name>           Model to use / pull / bench
+    --api-key <key>              API key override (env: OLLAMA_API_KEY)
+    --compat <openai|anthropic>  Wire protocol for local daemon
+    -y, --yes                    Auto-confirm destructive prompts
+
+  Examples:
+    notch ollama                 Detect daemon, pick a model, save to .notch.json
+    notch ollama --cloud         Target Ollama Cloud
+    notch ollama --compat anthropic --model qwen3-coder:30b
+    notch ollama pull llama3.2:latest
+    notch ollama bench "summarize this repo" --model llama3.2,qwen3-coder:30b
+`);
+}
+async function runOllamaCli(argv, cwd) {
+  const flags = parseFlags(argv);
+  if (flags.help && flags.positional.length === 0) {
+    printHelp();
+    return 0;
+  }
+  const sub = flags.positional[0] ?? "launch";
+  const subFlags = { ...flags, positional: flags.positional.slice(1) };
+  switch (sub) {
+    case "launch":
+    case void 0:
+      return cmdLaunch(subFlags, { projectRoot: cwd });
+    case "list":
+    case "ls":
+      return cmdList(subFlags);
+    case "pull":
+      return cmdPull(subFlags);
+    case "status":
+      return cmdStatus(subFlags);
+    case "login":
+      return cmdLogin(subFlags);
+    case "logout":
+      return cmdLogout(subFlags);
+    case "bench": {
+      const { runOllamaBench } = await import("./ollama-bench-QQHBIG2D.js");
+      return runOllamaBench(subFlags, { projectRoot: cwd });
+    }
+    case "help":
+      printHelp();
+      return 0;
+    default:
+      console.error(chalk.red(`  Unknown subcommand: ollama ${sub}`));
+      printHelp();
+      return 2;
+  }
+}
+
+export {
+  parseFlags,
+  resolveEndpoint,
+  renderProgressLine,
+  persistOllamaChoice,
+  printNotReachable,
+  runOllamaCli
+};

package/dist/chunk-OSWUX6TC.js

@@ -0,0 +1,167 @@
+import {
+  readIndex,
+  readRollout,
+  rolloutPath
+} from "./chunk-QKM27RHS.js";
+
+// src/session/session-index.ts
+import fsp from "fs/promises";
+import path from "path";
+import os from "os";
+var INDEX_PATH = path.join(os.homedir(), ".notch", "sessions.index.json");
+var INDEX_SCHEMA = 1;
+async function ensureDir() {
+  await fsp.mkdir(path.dirname(INDEX_PATH), { recursive: true });
+}
+async function readIndexFile() {
+  try {
+    const raw = await fsp.readFile(INDEX_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed.schema !== INDEX_SCHEMA) {
+      return { schema: INDEX_SCHEMA, updatedAt: Date.now(), entries: {} };
+    }
+    return parsed;
+  } catch {
+    return { schema: INDEX_SCHEMA, updatedAt: Date.now(), entries: {} };
+  }
+}
+async function writeIndexFile(file) {
+  await ensureDir();
+  file.updatedAt = Date.now();
+  const tmp = INDEX_PATH + ".tmp";
+  await fsp.writeFile(tmp, JSON.stringify(file, null, 2));
+  await fsp.rename(tmp, INDEX_PATH);
+}
+async function deriveEntryFromRollout(id) {
+  let records;
+  try {
+    records = await readRollout(id);
+  } catch {
+    return null;
+  }
+  if (records.length === 0) return null;
+  const header = records[0];
+  const rolloutIdx = await readIndex(id).catch(() => null);
+  let firstUser = "";
+  let forkSourceId;
+  let forkFromSeq;
+  let branches = 0;
+  let cwd;
+  {
+    const headerPayload = header.payload;
+    if (headerPayload?.cwd) cwd = headerPayload.cwd;
+    if (headerPayload?.forkSourceId) {
+      forkSourceId = headerPayload.forkSourceId;
+      forkFromSeq = headerPayload.forkFromSeq;
+    }
+  }
+  for (const r of records) {
+    if (r.type === "user-message" && !firstUser) {
+      const payload = r.payload;
+      firstUser = (payload?.content ?? "").slice(0, 160);
+    }
+    if (r.type === "branch-fork") {
+      branches++;
+    }
+  }
+  const lastRecord = records[records.length - 1];
+  const lastTurnAt = lastRecord && typeof lastRecord.ts === "number" ? lastRecord.ts : Date.now();
+  const createdAtIso = header.payload?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const createdAt = new Date(createdAtIso).getTime();
+  const turnCount = rolloutIdx?.messageCount ?? records.filter((r) => r.type === "user-message" || r.type === "assistant-message").length;
+  return {
+    id,
+    project: header.payload?.project,
+    model: header.payload?.model,
+    createdAt: Number.isFinite(createdAt) ? createdAt : Date.now(),
+    lastTurnAt,
+    turnCount,
+    preview: firstUser,
+    cwd,
+    branches,
+    forkSourceId,
+    forkFromSeq,
+    hasActiveStream: !!rolloutIdx?.activeStream
+  };
+}
+async function upsertSessionIndexEntry(id, patch) {
+  const file = await readIndexFile();
+  const derived = await deriveEntryFromRollout(id);
+  if (!derived) return;
+  file.entries[id] = { ...derived, ...patch ?? {} };
+  await writeIndexFile(file);
+}
+async function rebuildIndex() {
+  await ensureDir();
+  const rolloutDir = path.dirname(rolloutPath("placeholder"));
+  let files;
+  try {
+    files = (await fsp.readdir(rolloutDir)).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    files = [];
+  }
+  const entries = {};
+  let skipped = 0;
+  for (const f of files) {
+    const id = f.replace(/\.jsonl$/, "");
+    const entry = await deriveEntryFromRollout(id);
+    if (entry) entries[id] = entry;
+    else skipped++;
+  }
+  await writeIndexFile({ schema: INDEX_SCHEMA, updatedAt: Date.now(), entries });
+  return { indexed: Object.keys(entries).length, skipped };
+}
+async function querySessions(opts = {}) {
+  const file = await readIndexFile();
+  const all = Object.values(file.entries);
+  const since = opts.since ? typeof opts.since === "number" ? opts.since : new Date(opts.since).getTime() : 0;
+  const search = opts.search?.toLowerCase();
+  const filtered = all.filter((e) => {
+    if (opts.project && e.project !== opts.project) return false;
+    if (opts.model && e.model !== opts.model) return false;
+    if (opts.cwd && e.cwd !== opts.cwd) return false;
+    if (since && e.lastTurnAt < since) return false;
+    if (opts.nonEmptyOnly && e.turnCount === 0) return false;
+    if (opts.interruptedOnly && !e.hasActiveStream) return false;
+    if (search) {
+      const hay = `${e.preview ?? ""} ${e.project ?? ""} ${e.model ?? ""} ${e.id}`.toLowerCase();
+      if (!hay.includes(search)) return false;
+    }
+    return true;
+  });
+  filtered.sort((a, b) => b.lastTurnAt - a.lastTurnAt);
+  return opts.limit ? filtered.slice(0, opts.limit) : filtered;
+}
+async function getSession(id) {
+  const file = await readIndexFile();
+  return file.entries[id] ?? null;
+}
+async function forgetSession(id) {
+  const file = await readIndexFile();
+  if (id in file.entries) {
+    delete file.entries[id];
+    await writeIndexFile(file);
+  }
+}
+async function tagSession(id, tags) {
+  const file = await readIndexFile();
+  const existing = file.entries[id];
+  if (!existing) return;
+  const merged = Array.from(/* @__PURE__ */ new Set([...existing.tags ?? [], ...tags]));
+  file.entries[id] = { ...existing, tags: merged };
+  await writeIndexFile(file);
+}
+function indexFilePath() {
+  return INDEX_PATH;
+}
+
+export {
+  deriveEntryFromRollout,
+  upsertSessionIndexEntry,
+  rebuildIndex,
+  querySessions,
+  getSession,
+  forgetSession,
+  tagSession,
+  indexFilePath
+};