@theokit/sdk 4.24.0 → 4.26.0

package/dist/internal/persistence/index.js

@@ -1,85 +1,14 @@
-import { randomBytes } from 'crypto';
-import { open, rename, unlink, mkdir, readFile, statfs } from 'fs/promises';
-import { dirname, join } from 'path';
-import { readFileSync, mkdirSync, appendFileSync } from 'fs';
-import { homedir } from 'os';
-import { z } from 'zod';
+export { JsonlParseError, appendJsonl, loadJsonl, readJsonlIds } from '../../chunk-DUK5WMKJ.js';
+export { PersistenceSchema } from '../../chunk-CAH3G4IS.js';
+export { displayTheokitHome, getProfilesRoot, getTheokitHome, migrateSchema, readVersionedJson, writeVersionedJson } from '../../chunk-DGRZNMTU.js';
+export { applyWalWithFallback, containsCjk, isCorruptionError, openSqliteResilient, sanitizeFts5Query } from '../../chunk-77FOZCOT.js';
+export { withFileLock } from '../../chunk-HZQEDNF6.js';
+export { withCwdMutex } from '../../chunk-2XLKLVVR.js';
+export { atomicWriteJson, atomicWriteText, replaceFileAtomic } from '../../chunk-S2BBRVQX.js';
+import '../../chunk-WLKFWQSJ.js';
+import '../../chunk-JTFYYKDT.js';
+import { open } from 'fs/promises';
 
-// src/internal/persistence/atomic-write.ts
-var NETWORK_FS_MAGIC = /* @__PURE__ */ new Map([
-  [26985, "nfs"],
-  [20859, "smb"],
-  [4283649346, "cifs"],
-  [1702057286, "fuse"]
-]);
-function detectNetworkFsName(typeMagic) {
-  return NETWORK_FS_MAGIC.get(typeMagic) ?? null;
-}
-var warnedNfsDirs = /* @__PURE__ */ new Set();
-async function warnOnNetworkFsOnce(dirPath, label) {
-  const key = `${dirPath}\0${label}`;
-  if (warnedNfsDirs.has(key)) return;
-  warnedNfsDirs.add(key);
-  try {
-    const info = await statfs(dirPath);
-    const fsName = detectNetworkFsName(info.type);
-    if (fsName === null) return;
-    process.stderr.write(
-      `[theokit-sdk] ${label}: detected network fs (${fsName}) at ${dirPath} \u2014 rename() atomicity guarantees may be weaker than expected.
-`
-    );
-  } catch {
-  }
-}
-async function replaceFileAtomic(filePath, content) {
-  await warnOnNetworkFsOnce(dirname(filePath), "atomic-write");
-  const suffix = randomBytes(8).toString("hex");
-  const tmp = `${filePath}.${process.pid}.${suffix}.tmp`;
-  const handle = await open(tmp, "w", 384);
-  try {
-    await handle.writeFile(content, "utf8");
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  try {
-    await rename(tmp, filePath);
-  } catch (cause) {
-    await unlink(tmp).catch(() => void 0);
-    throw cause;
-  }
-}
-async function atomicWriteJson(filePath, data, options) {
-  const indent = options?.indent ?? 2;
-  const trailingNewline = options?.trailingNewline ?? true;
-  const json = JSON.stringify(data, null, indent);
-  if (json === void 0) {
-    throw new TypeError("atomicWriteJson: cannot serialize undefined");
-  }
-  const content = trailingNewline ? `${json}
-` : json;
-  await mkdir(dirname(filePath), { recursive: true });
-  await replaceFileAtomic(filePath, content);
-}
-async function atomicWriteText(filePath, content) {
-  await mkdir(dirname(filePath), { recursive: true });
-  await replaceFileAtomic(filePath, content);
-}
-
-// src/internal/persistence/cwd-mutex.ts
-var tails = /* @__PURE__ */ new Map();
-function withCwdMutex(key, fn) {
-  const prev = tails.get(key) ?? Promise.resolve();
-  const next = prev.then(fn, fn);
-  tails.set(
-    key,
-    next.then(
-      () => void 0,
-      () => void 0
-    )
-  );
-  return next;
-}
 async function createExclusive(path, data, options) {
   const mode = options?.mode ?? 384;
   try {
@@ -98,276 +27,6 @@ async function createExclusive(path, data, options) {
   }
 }
 
-// src/internal/persistence/file-lock.ts
-var cached;
-var warnedMissing = false;
-var warnedStructural = false;
-async function getProperLockfile() {
-  if (cached !== void 0) return cached;
-  try {
-    const mod = await import('proper-lockfile');
-    if (!validateLockModule(mod)) {
-      if (!warnedStructural) {
-        warnedStructural = true;
-        process.stderr.write(
-          "[theokit-sdk] proper-lockfile: imported module does NOT expose the expected `lock`/`unlock` API surface. This may indicate a supply-chain compromise or an incompatible major version. Falling back to in-process mutex (no cross-process safety). Reinstall with: pnpm add proper-lockfile@^11\n"
-        );
-      }
-      cached = null;
-      return cached;
-    }
-    cached = mod;
-  } catch {
-    cached = null;
-  }
-  return cached;
-}
-function validateLockModule(mod) {
-  if (mod === null || mod === void 0 || typeof mod !== "object") return false;
-  const m = mod;
-  return typeof m.lock === "function" && typeof m.unlock === "function";
-}
-async function withFileLock(path, fn, options) {
-  const lib = await getProperLockfile();
-  if (lib === null) {
-    if (!warnedMissing) {
-      warnedMissing = true;
-      process.stderr.write(
-        "[theokit-sdk] proper-lockfile not installed; cross-process file lock unavailable. Install with: pnpm add proper-lockfile\n"
-      );
-    }
-    return withCwdMutex(`file-lock:${path}`, fn);
-  }
-  return withCwdMutex(`file-lock:${path}`, async () => {
-    const release = await lib.lock(path, {
-      // EC-1: companion lockfile, target path may not exist yet.
-      lockfilePath: `${path}.lock`,
-      realpath: false,
-      stale: options?.stale ?? 3e4,
-      retries: {
-        retries: options?.retries ?? 5,
-        factor: options?.retryFactor ?? 1.5,
-        minTimeout: 100,
-        maxTimeout: 5e3
-      }
-    });
-    try {
-      return await fn();
-    } finally {
-      await release();
-    }
-  });
-}
-
-// src/internal/persistence/fts5-sanitize.ts
-var PHRASE_OPEN = "
";
-var PHRASE_CLOSE = "";
-function sanitizeFts5Query(query) {
-  if (query.length === 0) return query;
-  const phrases = [];
-  let text = query.replace(/"[^"]+"/g, (match) => {
-    phrases.push(match);
-    return `${PHRASE_OPEN}${phrases.length - 1}${PHRASE_CLOSE}`;
-  });
-  text = text.replace(/[[\]{}()"^]/g, " ");
-  text = text.replace(/\*+/g, "*");
-  text = text.replace(/^\s*(AND|OR|NOT)\s+/i, "");
-  text = text.replace(/\s+(AND|OR|NOT)\s*$/i, "");
-  text = text.replace(/\b\w+[-._]\w[\w\-._]*\b/g, (match) => `"${match}"`);
-  for (let i = 0; i < phrases.length; i += 1) {
-    text = text.replace(`${PHRASE_OPEN}${i}${PHRASE_CLOSE}`, phrases[i] ?? "");
-  }
-  return text.trim();
-}
-var CJK_RANGES = [
-  [12288, 12351],
-  // CJK Symbols and Punctuation
-  [12352, 12447],
-  // Hiragana
-  [12448, 12543],
-  // Katakana
-  [13312, 19903],
-  // CJK Unified Ideographs Extension A
-  [19968, 40959],
-  // CJK Unified Ideographs
-  [44032, 55215]
-  // Hangul Syllables
-];
-function containsCjk(text) {
-  for (const char of text) {
-    const cp = char.codePointAt(0);
-    if (cp === void 0) continue;
-    for (const [lo, hi] of CJK_RANGES) {
-      if (cp >= lo && cp <= hi) return true;
-    }
-  }
-  return false;
-}
-var JsonlParseError = class extends Error {
-  constructor(message, line) {
-    super(message);
-    this.line = line;
-    this.name = "JsonlParseError";
-  }
-  line;
-};
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function tryParseObjectLine(line) {
-  if (line.length === 0) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(line);
-  } catch {
-    return void 0;
-  }
-  return isPlainObject(parsed) ? parsed : void 0;
-}
-function loadJsonl(path, opts = {}) {
-  const text = readFileSync(path, "utf8");
-  const out = [];
-  let lineNumber = 0;
-  for (const rawLine of text.split("\n")) {
-    lineNumber += 1;
-    const line = rawLine.trim();
-    if (line.length === 0) continue;
-    let parsed;
-    try {
-      parsed = JSON.parse(line);
-    } catch {
-      throw new JsonlParseError(`line ${lineNumber}: invalid JSON`, lineNumber);
-    }
-    if (!isPlainObject(parsed)) {
-      throw new JsonlParseError(`line ${lineNumber}: not a JSON object`, lineNumber);
-    }
-    out.push(opts.map ? opts.map(parsed, lineNumber) : parsed);
-  }
-  return out;
-}
-function appendJsonl(path, record) {
-  mkdirSync(dirname(path), { recursive: true });
-  appendFileSync(path, `${JSON.stringify(record)}
-`);
-}
-function readJsonlIds(path, keyFn) {
-  const done = /* @__PURE__ */ new Set();
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch {
-    return done;
-  }
-  for (const rawLine of text.split("\n")) {
-    const parsed = tryParseObjectLine(rawLine.trim());
-    if (parsed === void 0) continue;
-    const key = keyFn(parsed);
-    if (typeof key === "string" && key.length > 0) done.add(key);
-  }
-  return done;
-}
-var THEOKIT_DIR_NAME = ".theokit";
-function getTheokitHome(cwd) {
-  const override = process.env.THEOKIT_HOME?.trim();
-  if (override !== void 0 && override.length > 0) {
-    return override;
-  }
-  return join(cwd, THEOKIT_DIR_NAME);
-}
-function getProfilesRoot() {
-  return join(homedir(), THEOKIT_DIR_NAME, "profiles");
-}
-function displayTheokitHome(cwd) {
-  const resolved = getTheokitHome(cwd);
-  const home = homedir();
-  if (resolved === home) return "~";
-  if (resolved.startsWith(`${home}/`)) {
-    return `~${resolved.slice(home.length)}`;
-  }
-  return resolved;
-}
-var PersistenceSchema = z.object({
-  backend: z.enum(["memory", "json"]),
-  dir: z.string().optional()
-}).refine((p) => p.backend !== "json" || typeof p.dir === "string" && p.dir.length > 0, {
-  message: 'persistence.dir is required when backend = "json"'
-}).optional();
-function migrateSchema(opts) {
-  const { db, currentVersion, migrations, label = "db" } = opts;
-  const storedRaw = db.pragma("user_version", { simple: true });
-  const stored = typeof storedRaw === "number" ? storedRaw : 0;
-  if (stored > currentVersion) {
-    throw new Error(
-      `[${label}] schema version ${stored} > current ${currentVersion}; did you downgrade the SDK? Forward-only migrations only.`
-    );
-  }
-  if (stored === currentVersion) {
-    return { from: stored, to: stored, ran: 0 };
-  }
-  const pending = [...migrations].sort((a, b) => a.toVersion - b.toVersion).filter((m) => m.toVersion > stored && m.toVersion <= currentVersion);
-  let ran = 0;
-  let lastApplied = stored;
-  db.transaction(() => {
-    for (const m of pending) {
-      m.up(db);
-      db.pragma(`user_version = ${m.toVersion}`);
-      lastApplied = m.toVersion;
-      ran += 1;
-    }
-  })();
-  return { from: stored, to: lastApplied, ran };
-}
-async function readVersionedJson(opts) {
-  const { path, currentVersion, migrate, defaultValue } = opts;
-  let raw;
-  try {
-    raw = await readFile(path, "utf-8");
-  } catch {
-    return defaultValue();
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    const asidePath = `${path}.corrupt.${Date.now()}`;
-    try {
-      await rename(path, asidePath);
-      process.stderr.write(
-        `[theokit-sdk] ${path} is corrupt; moved to ${asidePath}. Using default value.
-`
-      );
-    } catch {
-      process.stderr.write(`[theokit-sdk] ${path} is corrupt; using default value.
-`);
-    }
-    return defaultValue();
-  }
-  if (typeof parsed !== "object" || parsed === null) {
-    return defaultValue();
-  }
-  const file = parsed;
-  const storedRaw = file._schemaVersion;
-  const stored = typeof storedRaw === "number" ? storedRaw : 0;
-  if (stored === currentVersion) {
-    return file.data;
-  }
-  if (stored > currentVersion) {
-    process.stderr.write(
-      `[theokit-sdk] ${path} schema version ${stored} > current ${currentVersion}; using default value (forward-only).
-`
-    );
-    return defaultValue();
-  }
-  return migrate(parsed, stored);
-}
-async function writeVersionedJson(path, data, currentVersion) {
-  const file = {
-    _schemaVersion: currentVersion,
-    data
-  };
-  await atomicWriteJson(path, file);
-}
-
 // src/internal/persistence/sqlite-cas.ts
 function casUpdate(db, sql, params, expectedChanges = 1) {
   const stmt = db.prepare(sql);
@@ -375,143 +34,6 @@ function casUpdate(db, sql, params, expectedChanges = 1) {
   return result.changes === expectedChanges;
 }
 
-// src/errors.ts
-var TheokitAgentError = class extends Error {
-  name = "TheokitAgentError";
-  isRetryable;
-  code;
-  protoErrorCode;
-  metadata;
-  constructor(message, options = {}) {
-    super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
-    this.isRetryable = options.isRetryable ?? false;
-    if (options.code !== void 0) this.code = options.code;
-    if (options.protoErrorCode !== void 0) this.protoErrorCode = options.protoErrorCode;
-    if (options.metadata !== void 0) this.metadata = options.metadata;
-  }
-};
-var ConfigurationError = class extends TheokitAgentError {
-  name = "ConfigurationError";
-  constructor(message, options = {}) {
-    super(message, { ...options, isRetryable: false });
-  }
-};
-
-// src/internal/persistence/sqlite-wal.ts
-var warnedLabels = /* @__PURE__ */ new Set();
-function applyWalWithFallback(db, label) {
-  try {
-    const result = db.pragma("journal_mode = WAL", { simple: true });
-    if (typeof result === "string" && result.toLowerCase() === "wal") {
-      return { mode: "wal", fellBack: false };
-    }
-    logFallback(label, `got "${String(result)}" instead of "wal"`);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    logFallback(label, msg);
-  }
-  db.pragma("journal_mode = DELETE");
-  return { mode: "delete", fellBack: true };
-}
-function logFallback(label, reason) {
-  if (warnedLabels.has(label)) return;
-  warnedLabels.add(label);
-  process.stderr.write(
-    `[theokit-sdk] ${label}: WAL unavailable (${reason}); using DELETE journal mode. This is normal on NFS/SMB/FUSE; expect slightly slower concurrent access.
-`
-  );
-}
-
-// src/internal/persistence/sqlite-open.ts
-async function openSqliteResilient(options) {
-  await mkdir(dirname(options.filePath), { recursive: true });
-  try {
-    return await openConcrete(options);
-  } catch (cause) {
-    if (options.recoverCorrupt !== false && isCorruptionError(cause)) {
-      await renameAside(options.filePath, options.label ?? "sqlite");
-      return await openConcrete(options);
-    }
-    throw cause;
-  }
-}
-async function openConcrete(options) {
-  const db = await loadDriver(options.filePath);
-  applyWalWithFallback(db, options.label ?? "sqlite");
-  await options.onOpen?.(db);
-  return db;
-}
-var driverLoaderOverrides;
-function adaptNodeSqlite(db) {
-  const pragma = (statement, options) => {
-    const stmt = db.prepare(`PRAGMA ${statement}`);
-    const row = stmt.get();
-    if (options?.simple === true) {
-      return row === void 0 ? void 0 : Object.values(row)[0];
-    }
-    return row === void 0 ? [] : [row];
-  };
-  return new Proxy(db, {
-    get(target, prop, receiver) {
-      if (prop === "pragma") return pragma;
-      if (prop === "loadExtension" && typeof db.loadExtension !== "function") {
-        return () => {
-          throw new Error(
-            "SQLite extension loading is unavailable on the node:sqlite fallback \u2014 install better-sqlite3 for sqlite-vec"
-          );
-        };
-      }
-      const value = Reflect.get(target, prop, receiver);
-      return typeof value === "function" ? value.bind(target) : value;
-    }
-  });
-}
-async function loadDriver(filePath) {
-  let betterSqliteCause;
-  try {
-    const mod = await (driverLoaderOverrides?.betterSqlite3?.() ?? import('better-sqlite3'));
-    const Ctor = mod.default ?? mod;
-    if (typeof Ctor !== "function") {
-      throw new Error(`better-sqlite3 export is not a constructor (got ${typeof Ctor})`);
-    }
-    return new Ctor(filePath);
-  } catch (cause) {
-    betterSqliteCause = cause;
-  }
-  try {
-    const mod = await (driverLoaderOverrides?.nodeSqlite?.() ?? Promise.resolve(
-      process.getBuiltinModule?.(
-        "node:sqlite"
-      ) ?? (() => {
-        throw new Error("node:sqlite built-in unavailable (Node < 22.3)");
-      })()
-    ));
-    return adaptNodeSqlite(new mod.DatabaseSync(filePath));
-  } catch (nodeSqliteCause) {
-    const b = betterSqliteCause instanceof Error ? betterSqliteCause.message : String(betterSqliteCause);
-    const n = nodeSqliteCause instanceof Error ? nodeSqliteCause.message : String(nodeSqliteCause);
-    throw new ConfigurationError(
-      `Failed to load SQLite driver. Install \`better-sqlite3\` or run on Node 22.5+ for built-in \`node:sqlite\`. better-sqlite3: ${b}; node:sqlite: ${n}`,
-      { code: "sqlite_driver_unavailable", cause: nodeSqliteCause }
-    );
-  }
-}
-function isCorruptionError(cause) {
-  if (!(cause instanceof Error)) return false;
-  const msg = cause.message.toLowerCase();
-  return msg.includes("malformed") || msg.includes("not a database") || msg.includes("encrypted") || msg.includes("disk image is malformed");
-}
-async function renameAside(filePath, label) {
-  const asidePath = `${filePath}.corrupt-${Date.now()}`;
-  await rename(filePath, asidePath).catch(() => void 0);
-  await rename(`${filePath}-wal`, `${asidePath}-wal`).catch(() => void 0);
-  await rename(`${filePath}-shm`, `${asidePath}-shm`).catch(() => void 0);
-  process.stderr.write(
-    `[theokit-sdk] ${label} database corrupt; renamed aside to ${asidePath} and rebuilt schema
-`
-  );
-}
-
-export { JsonlParseError, PersistenceSchema, appendJsonl, applyWalWithFallback, atomicWriteJson, atomicWriteText, casUpdate, containsCjk, createExclusive, displayTheokitHome, getProfilesRoot, getTheokitHome, isCorruptionError, loadJsonl, migrateSchema, openSqliteResilient, readJsonlIds, readVersionedJson, replaceFileAtomic, sanitizeFts5Query, withCwdMutex, withFileLock, writeVersionedJson };
+export { casUpdate, createExclusive };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map