@freesyntax/notch-cli 0.5.20 → 0.5.22

package/dist/{apply-patch-D5PDUXUC.js → apply-patch-U6K67CMT.js}

@@ -5,6 +5,7 @@ import {
   applyPatchTool,
   parsePatch
 } from "./chunk-C4CPDDMN.js";
+import "./chunk-KFQGP6VL.js";
 export {
   PatchApplyError,
   PatchParseError,

package/dist/auth-UAMMP5IJ.js

@@ -0,0 +1,29 @@
+import {
+  clearCredentials,
+  getByokSyncPath,
+  getConfigDir,
+  getCredentialsPath,
+  init_auth,
+  invalidateSyncedKeysCache,
+  loadCredentials,
+  loadSyncedByokKeys,
+  loadSyncedByokKeysSync,
+  login,
+  saveCredentials,
+  syncByokKeys
+} from "./chunk-PPEBWOMJ.js";
+import "./chunk-KFQGP6VL.js";
+init_auth();
+export {
+  clearCredentials,
+  getByokSyncPath,
+  getConfigDir,
+  getCredentialsPath,
+  invalidateSyncedKeysCache,
+  loadCredentials,
+  loadSyncedByokKeys,
+  loadSyncedByokKeysSync,
+  login,
+  saveCredentials,
+  syncByokKeys
+};

package/dist/chunk-4HPRBCSY.js

@@ -0,0 +1,167 @@
+import {
+  readIndex,
+  readRollout,
+  rolloutPath
+} from "./chunk-6NKRMZTX.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
+};

package/dist/chunk-6NKRMZTX.js

@@ -0,0 +1,198 @@
+// src/session/rollout.ts
+import fsp from "fs/promises";
+import path from "path";
+import os from "os";
+import crypto from "crypto";
+var ROLLOUT_DIR = path.join(os.homedir(), ".notch", "rollouts");
+async function ensureDir() {
+  await fsp.mkdir(ROLLOUT_DIR, { recursive: true });
+}
+function rolloutPath(id) {
+  return path.join(ROLLOUT_DIR, `${id}.jsonl`);
+}
+function indexPath(id) {
+  return path.join(ROLLOUT_DIR, `${id}.idx.json`);
+}
+function generateSessionId() {
+  const d = /* @__PURE__ */ new Date();
+  const stamp = d.toISOString().slice(0, 10).replace(/-/g, "") + "-" + d.toISOString().slice(11, 16).replace(":", "");
+  const rand = crypto.randomBytes(3).toString("hex");
+  return `${stamp}-${rand}`;
+}
+var Rollout = class {
+  constructor(id) {
+    this.id = id;
+  }
+  id;
+  fd = null;
+  seq = 0;
+  idx = {
+    lastSeq: -1,
+    messageCount: 0,
+    branches: {},
+    activeStream: null
+  };
+  async openNew(header) {
+    await ensureDir();
+    this.fd = await fsp.open(rolloutPath(this.id), "a");
+    await this.writeRecord({
+      type: "header",
+      payload: { id: this.id, project: header.project, model: header.model, createdAt: (/* @__PURE__ */ new Date()).toISOString(), schema: 1 }
+    });
+  }
+  async openExisting() {
+    await ensureDir();
+    this.idx = await readIndex(this.id);
+    this.seq = this.idx.lastSeq + 1;
+    this.fd = await fsp.open(rolloutPath(this.id), "a");
+  }
+  async close() {
+    await this.saveIndex();
+    if (this.fd) {
+      await this.fd.close();
+      this.fd = null;
+    }
+    try {
+      const { upsertSessionIndexEntry } = await import("./session-index-7FWEVP6E.js");
+      await upsertSessionIndexEntry(this.id);
+    } catch {
+    }
+  }
+  async writeRecord(partial) {
+    if (!this.fd) throw new Error("rollout not open");
+    const rec = { seq: this.seq++, ts: Date.now(), ...partial };
+    const line = JSON.stringify(rec) + "\n";
+    await this.fd.write(line);
+    this.idx.lastSeq = rec.seq;
+    if (rec.type === "user-message" || rec.type === "assistant-message") {
+      this.idx.messageCount++;
+      if (rec.parent && rec.msgId) {
+        (this.idx.branches[rec.parent] ??= []).push(rec.msgId);
+      }
+    }
+    if (rec.type === "active-stream") {
+      this.idx.activeStream = rec.streamId ?? null;
+    } else if (rec.type === "turn-end" || rec.type === "error") {
+      this.idx.activeStream = null;
+    }
+    return rec;
+  }
+  append(record) {
+    return this.writeRecord(record);
+  }
+  async flush() {
+    if (this.fd) await this.fd.sync();
+    await this.saveIndex();
+  }
+  async saveIndex() {
+    await fsp.writeFile(indexPath(this.id), JSON.stringify(this.idx, null, 2));
+  }
+  get activeStream() {
+    return this.idx.activeStream;
+  }
+  get index() {
+    return this.idx;
+  }
+};
+async function readRollout(id) {
+  const raw = await fsp.readFile(rolloutPath(id), "utf-8");
+  const out = [];
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return out;
+}
+async function readIndex(id) {
+  try {
+    const raw = await fsp.readFile(indexPath(id), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    const records = await readRollout(id);
+    const idx = { lastSeq: -1, messageCount: 0, branches: {}, activeStream: null };
+    for (const r of records) {
+      idx.lastSeq = r.seq;
+      if (r.type === "user-message" || r.type === "assistant-message") {
+        idx.messageCount++;
+        if (r.parent && r.msgId) (idx.branches[r.parent] ??= []).push(r.msgId);
+      }
+      if (r.type === "active-stream") idx.activeStream = r.streamId ?? null;
+      else if (r.type === "turn-end" || r.type === "error") idx.activeStream = null;
+    }
+    await fsp.writeFile(indexPath(id), JSON.stringify(idx, null, 2)).catch(() => {
+    });
+    return idx;
+  }
+}
+async function listRollouts() {
+  try {
+    const entries = await fsp.readdir(ROLLOUT_DIR);
+    const files = entries.filter((e) => e.endsWith(".jsonl"));
+    const out = [];
+    for (const f of files) {
+      const id = f.replace(/\.jsonl$/, "");
+      const stat = await fsp.stat(path.join(ROLLOUT_DIR, f));
+      const idx = await readIndex(id).catch(() => ({ messageCount: 0 }));
+      let project;
+      let model;
+      try {
+        const first = (await fsp.readFile(path.join(ROLLOUT_DIR, f), "utf-8")).split("\n", 1)[0];
+        if (first) {
+          const header = JSON.parse(first);
+          project = header.payload?.project;
+          model = header.payload?.model;
+        }
+      } catch {
+      }
+      out.push({ id, updated: stat.mtimeMs, messageCount: idx.messageCount, project, model });
+    }
+    return out.sort((a, b) => b.updated - a.updated);
+  } catch {
+    return [];
+  }
+}
+function rebuildMessagesFromRollout(records) {
+  const msgs = [];
+  let current = null;
+  for (const r of records) {
+    if (r.type === "user-message") {
+      if (current) {
+        msgs.push(current);
+        current = null;
+      }
+      msgs.push({ role: "user", content: r.payload?.content ?? "" });
+    } else if (r.type === "text-delta") {
+      const delta = r.payload?.content ?? "";
+      if (!current) current = { role: "assistant", content: "" };
+      current.content += delta;
+    } else if (r.type === "assistant-message") {
+      if (current) {
+        msgs.push(current);
+        current = null;
+      }
+      msgs.push({ role: "assistant", content: r.payload?.content ?? "" });
+    } else if (r.type === "turn-end" && current) {
+      msgs.push(current);
+      current = null;
+    }
+  }
+  if (current) msgs.push(current);
+  return msgs;
+}
+function hasActiveStream(idx) {
+  return !!idx.activeStream;
+}
+
+export {
+  rolloutPath,
+  generateSessionId,
+  Rollout,
+  readRollout,
+  readIndex,
+  listRollouts,
+  rebuildMessagesFromRollout,
+  hasActiveStream
+};