@hraness/kb 0.17.1

package/dist/index-1vrd1rmn.js

@@ -0,0 +1,56 @@
+// @bun
+import {
+  defineWorkflow
+} from "./index-3v2z4f0q.js";
+import {
+  packUntrustedSearchContext
+} from "./index-zzhgcwyt.js";
+
+// src/workflows/decision-context.ts
+var decisionContextWorkflow = defineWorkflow({
+  id: "decision-context",
+  nodes: [
+    {
+      id: "search",
+      resource: "qmd",
+      run: ({ input, kb }) => kb.search({
+        query: input.query,
+        filters: input.filters ?? [],
+        tags: input.tags ?? [],
+        graph: { related: input.related ?? [] },
+        history: false,
+        ...input.resultLimit === undefined ? {} : { limit: input.resultLimit }
+      })
+    },
+    {
+      id: "history",
+      resource: "git",
+      needs: ["search"],
+      run: async ({ kb, result }) => {
+        const search = result("search");
+        return await kb.history(search.results.slice(0, 5).map(({ id }) => id), {
+          commitsPerNote: 3,
+          cochangedPathsPerCommit: 8
+        });
+      }
+    },
+    {
+      id: "pack",
+      needs: ["search", "history"],
+      run: ({ input, result }) => {
+        const search = result("search");
+        const enriched = {
+          ...search,
+          history: result("history")
+        };
+        const packed = packUntrustedSearchContext(enriched, {
+          ...input.maxBytes === undefined ? {} : { maxBytes: input.maxBytes }
+        });
+        return { context: packed.content, truncated: packed.truncated };
+      }
+    }
+  ],
+  output: "pack"
+});
+
+export { decisionContextWorkflow };

package/dist/index-1xxnjn0d.js

@@ -0,0 +1,171 @@
+// @bun
+// src/clip/terminal.ts
+var ESCAPE = 27;
+var BELL = 7;
+var STRING_TERMINATOR = 156;
+var MAX_PENDING_LENGTH = 64 * 1024;
+var MAX_PENDING_SEGMENTS = 4096;
+var CONTEXT_FREE_TERMINAL_CONTROLS = new RegExp(String.raw`[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u061c\u200e\u200f\u202a-\u202e\u2066-\u2069]`, "g");
+var CONTEXT_SENSITIVE_TERMINAL_CONTROLS = new RegExp(String.raw`[\u0009\u000d\u001b\u0090\u0098\u009b\u009d-\u009f\u2028\u2029]`);
+function chunkBuilder() {
+  const chunks = [];
+  let pending = [];
+  let pendingLength = 0;
+  const flush = () => {
+    if (pending.length === 0)
+      return;
+    chunks.push(pending.join(""));
+    pending = [];
+    pendingLength = 0;
+  };
+  return {
+    append: (value) => {
+      if (value === "")
+        return;
+      if (value.length >= MAX_PENDING_LENGTH) {
+        flush();
+        chunks.push(value);
+        return;
+      }
+      pending.push(value);
+      pendingLength += value.length;
+      if (pendingLength >= MAX_PENDING_LENGTH || pending.length >= MAX_PENDING_SEGMENTS)
+        flush();
+    },
+    finish: () => {
+      flush();
+      if (chunks.length === 0)
+        return "";
+      if (chunks.length === 1)
+        return chunks[0] ?? "";
+      return chunks.join("");
+    }
+  };
+}
+function isEscapeStringIntroducer(code) {
+  return code === 80 || code === 88 || code === 93 || code === 94 || code === 95;
+}
+function isC1StringIntroducer(code) {
+  return code === 144 || code === 152 || code === 157 || code === 158 || code === 159;
+}
+function controlStringEnd(value, start) {
+  for (let cursor = start;cursor < value.length; cursor += 1) {
+    const code = value.charCodeAt(cursor);
+    if (code === BELL || code === STRING_TERMINATOR)
+      return cursor + 1;
+    if (code === ESCAPE && value.charCodeAt(cursor + 1) === 92)
+      return cursor + 2;
+  }
+  return value.length;
+}
+function controlSequenceEnd(value, start) {
+  for (let cursor = start;cursor < value.length; cursor += 1) {
+    const code = value.charCodeAt(cursor);
+    if (code >= 64 && code <= 126)
+      return cursor + 1;
+  }
+  return value.length;
+}
+function escapeSequenceEnd(value, start) {
+  const introducer = value.charCodeAt(start + 1);
+  if (Number.isNaN(introducer))
+    return start + 1;
+  if (introducer === 91)
+    return controlSequenceEnd(value, start + 2);
+  if (isEscapeStringIntroducer(introducer)) {
+    return controlStringEnd(value, start + 2);
+  }
+  let cursor = start + 1;
+  while (cursor < value.length) {
+    const code = value.charCodeAt(cursor);
+    if (code >= 32 && code <= 47) {
+      cursor += 1;
+      continue;
+    }
+    return code >= 48 && code <= 126 ? cursor + 1 : start + 1;
+  }
+  return value.length;
+}
+function isBidiFormatControl(code) {
+  return code === 1564 || code === 8206 || code === 8207 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297;
+}
+function hasUnsafeTerminalCharacters(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code <= 9 || code >= 11 && code <= 31 || code >= 127 && code <= 159 || isBidiFormatControl(code))
+      return true;
+  }
+  return false;
+}
+function sanitizeTerminalText(value) {
+  if (!CONTEXT_SENSITIVE_TERMINAL_CONTROLS.test(value)) {
+    return value.replace(CONTEXT_FREE_TERMINAL_CONTROLS, "");
+  }
+  let builder = null;
+  let unchangedStart = 0;
+  const replace = (start, end, replacement = "") => {
+    builder ??= chunkBuilder();
+    builder.append(value.slice(unchangedStart, start));
+    builder.append(replacement);
+    unchangedStart = end;
+  };
+  for (let cursor = 0;cursor < value.length; ) {
+    const code = value.charCodeAt(cursor);
+    if (code === ESCAPE) {
+      const end = escapeSequenceEnd(value, cursor);
+      replace(cursor, end);
+      cursor = end;
+      continue;
+    }
+    if (code === 155) {
+      const end = controlSequenceEnd(value, cursor + 1);
+      replace(cursor, end);
+      cursor = end;
+      continue;
+    }
+    if (isC1StringIntroducer(code)) {
+      const end = controlStringEnd(value, cursor + 1);
+      replace(cursor, end);
+      cursor = end;
+      continue;
+    }
+    if (code === 13) {
+      const end = value.charCodeAt(cursor + 1) === 10 ? cursor + 2 : cursor + 1;
+      replace(cursor, end, `
+`);
+      cursor = end;
+      continue;
+    }
+    if (code === 10) {
+      cursor += 1;
+      continue;
+    }
+    if (code === 8232 || code === 8233) {
+      replace(cursor, cursor + 1, `
+`);
+      cursor += 1;
+      continue;
+    }
+    if (code === 9) {
+      replace(cursor, cursor + 1, "    ");
+      cursor += 1;
+      continue;
+    }
+    if (code <= 31 || code >= 127 && code <= 159 || isBidiFormatControl(code)) {
+      replace(cursor, cursor + 1);
+      cursor += 1;
+      continue;
+    }
+    cursor += 1;
+  }
+  const completedBuilder = builder;
+  if (completedBuilder === null)
+    return value;
+  completedBuilder.append(value.slice(unchangedStart));
+  return completedBuilder.finish();
+}
+function sanitizeTerminalLine(value) {
+  return sanitizeTerminalText(value).replace(/\n/g, " ");
+}
+
+export { hasUnsafeTerminalCharacters, sanitizeTerminalText, sanitizeTerminalLine };

package/dist/index-3rm7cz6h.js

@@ -0,0 +1,373 @@
+// @bun
+// src/note-lock.ts
+import { createHash, randomUUID } from "crypto";
+import { constants } from "fs";
+import {
+  link,
+  lstat,
+  mkdir,
+  open,
+  realpath,
+  rename,
+  unlink
+} from "fs/promises";
+import { homedir } from "os";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "path";
+var LOCK_SCHEMA_VERSION = 1;
+var MAX_LOCK_BYTES = 4 * 1024;
+var DEFAULT_STALE_AFTER_MS = 5 * 60 * 1000;
+var DEFAULT_HEARTBEAT_MS = 5000;
+var DEFAULT_POLL_INTERVAL_MS = 20;
+var DEFAULT_WAIT_TIMEOUT_MS = 30000;
+var MAX_RECLAIM_ATTEMPTS = 8;
+
+class NoteLockBusyError extends Error {
+  lockPath;
+  constructor(lockPath) {
+    super("this note is already being edited");
+    this.name = "NoteLockBusyError";
+    this.lockPath = lockPath;
+  }
+}
+
+class NoteLockLostError extends Error {
+  lockPath;
+  constructor(lockPath) {
+    super("the note lock is no longer owned by this process");
+    this.name = "NoteLockLostError";
+    this.lockPath = lockPath;
+  }
+}
+function isErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function sha256(value) {
+  return createHash("sha256").update(value, "utf8").digest("hex");
+}
+function within(root, candidate) {
+  const fromRoot = relative(root, candidate);
+  return fromRoot === "" || fromRoot !== ".." && !fromRoot.startsWith(`..${sep}`);
+}
+function defaultCacheHome() {
+  const configured = process.env.XDG_CACHE_HOME;
+  return configured !== undefined && isAbsolute(configured) ? configured : join(homedir(), ".cache");
+}
+function defaultDependencies() {
+  return {
+    pid: process.pid,
+    now: () => new Date,
+    monotonicNow: () => performance.now(),
+    token: () => randomUUID(),
+    isProcessAlive: (pid) => {
+      try {
+        process.kill(pid, 0);
+        return true;
+      } catch (error) {
+        return !isErrno(error, "ESRCH");
+      }
+    },
+    sleep: async (milliseconds) => {
+      await new Promise((resolveSleep) => {
+        setTimeout(resolveSleep, milliseconds);
+      });
+    },
+    staleAfterMs: DEFAULT_STALE_AFTER_MS,
+    heartbeatMs: DEFAULT_HEARTBEAT_MS,
+    pollIntervalMs: DEFAULT_POLL_INTERVAL_MS
+  };
+}
+function resolvedDependencies(overrides) {
+  const dependencies = { ...defaultDependencies(), ...overrides };
+  if (!Number.isSafeInteger(dependencies.pid) || dependencies.pid <= 0) {
+    throw new TypeError("a note lock requires a positive process ID");
+  }
+  for (const [label, value] of [
+    ["staleAfterMs", dependencies.staleAfterMs],
+    ["heartbeatMs", dependencies.heartbeatMs],
+    ["pollIntervalMs", dependencies.pollIntervalMs]
+  ]) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new TypeError(`${label} must be a positive finite duration`);
+    }
+  }
+  return dependencies;
+}
+async function lockPathFor(vaultRootInput, canonicalNoteId, cacheHomeInput) {
+  if (canonicalNoteId === "" || canonicalNoteId.includes("\x00") || canonicalNoteId.includes(`
+`) || canonicalNoteId.includes("\r")) {
+    throw new TypeError("a note lock requires a non-empty single-line note ID");
+  }
+  const vaultRoot = await realpath(resolve(vaultRootInput));
+  const cacheHome = resolve(cacheHomeInput ?? defaultCacheHome());
+  const requestedDirectory = join(cacheHome, "hraness-kb", "note-locks", sha256(vaultRoot));
+  await mkdir(requestedDirectory, { recursive: true, mode: 448 });
+  const requestedMetadata = await lstat(requestedDirectory);
+  if (!requestedMetadata.isDirectory() || requestedMetadata.isSymbolicLink()) {
+    throw new Error("the note lock root must be a real directory");
+  }
+  const lockDirectory = await realpath(requestedDirectory);
+  if (within(vaultRoot, lockDirectory)) {
+    throw new Error("the note lock root must remain outside the vault");
+  }
+  return join(lockDirectory, `${sha256(canonicalNoteId)}.lock`);
+}
+function parseOwner(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const record = value;
+  const version = record["version"];
+  const pid = record["pid"];
+  const token = record["token"];
+  const acquiredAt = record["acquiredAt"];
+  if (version !== LOCK_SCHEMA_VERSION || typeof pid !== "number" || !Number.isSafeInteger(pid) || pid <= 0 || typeof token !== "string" || !/^[0-9a-z-]{16,128}$/iu.test(token) || typeof acquiredAt !== "string" || Number.isNaN(Date.parse(acquiredAt))) {
+    return null;
+  }
+  return { version, pid, token, acquiredAt };
+}
+async function observeLock(path) {
+  let metadata;
+  try {
+    metadata = await lstat(path, { bigint: true });
+  } catch (error) {
+    if (isErrno(error, "ENOENT"))
+      return null;
+    throw error;
+  }
+  if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.nlink !== 1n || metadata.size > BigInt(MAX_LOCK_BYTES)) {
+    return { kind: "unsafe" };
+  }
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+  } catch (error) {
+    return isErrno(error, "ENOENT") ? null : { kind: "unsafe" };
+  }
+  try {
+    const opened = await handle.stat({ bigint: true });
+    if (!opened.isFile() || opened.nlink !== 1n || opened.dev !== metadata.dev || opened.ino !== metadata.ino || opened.size !== metadata.size || opened.size > BigInt(MAX_LOCK_BYTES)) {
+      return { kind: "unsafe" };
+    }
+    const bytes = new Uint8Array(Number(opened.size));
+    let offset = 0;
+    while (offset < bytes.byteLength) {
+      const result = await handle.read(bytes, offset, bytes.byteLength - offset, offset);
+      if (result.bytesRead === 0)
+        return { kind: "unsafe" };
+      offset += result.bytesRead;
+    }
+    const overflow = new Uint8Array(1);
+    if ((await handle.read(overflow, 0, 1, Number(opened.size))).bytesRead !== 0) {
+      return { kind: "unsafe" };
+    }
+    const finished = await handle.stat({ bigint: true });
+    let finalPath;
+    try {
+      finalPath = await lstat(path, { bigint: true });
+    } catch (error) {
+      if (isErrno(error, "ENOENT"))
+        return null;
+      throw error;
+    }
+    if (!finalPath.isFile() || finalPath.isSymbolicLink() || finalPath.nlink !== 1n || finalPath.dev !== opened.dev || finalPath.ino !== opened.ino || finalPath.size !== opened.size || finished.size !== opened.size || finished.mtimeNs !== opened.mtimeNs || finished.ctimeNs !== opened.ctimeNs) {
+      return { kind: "unsafe" };
+    }
+    let value;
+    try {
+      value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    } catch {
+      value = null;
+    }
+    return {
+      kind: "regular",
+      device: opened.dev,
+      inode: opened.ino,
+      modifiedAtMs: Number(opened.mtimeMs),
+      owner: parseOwner(value)
+    };
+  } finally {
+    await handle.close();
+  }
+}
+function sameIdentity(left, right) {
+  return left.device === right.device && left.inode === right.inode;
+}
+async function restoreUnexpectedLock(tombstone, lockPath) {
+  try {
+    await link(tombstone, lockPath);
+  } catch {
+    return;
+  }
+  try {
+    await unlink(tombstone);
+  } catch {}
+}
+async function reclaimObservedLock(lockPath, observed, token, dependencies) {
+  const tombstone = `${lockPath}.stale-${token}`;
+  try {
+    await rename(lockPath, tombstone);
+  } catch (error) {
+    if (isErrno(error, "ENOENT") || isErrno(error, "EEXIST"))
+      return false;
+    throw error;
+  }
+  await dependencies.afterTombstoneMove?.(tombstone, lockPath);
+  const moved = await observeLock(tombstone);
+  if (moved === null || moved.kind !== "regular" || !sameIdentity(observed, moved)) {
+    await restoreUnexpectedLock(tombstone, lockPath);
+    return false;
+  }
+  await unlink(tombstone);
+  return true;
+}
+async function releaseOwnedLock(lockPath, owner, dependencies) {
+  const tombstone = `${lockPath}.release-${owner.token}`;
+  try {
+    await rename(lockPath, tombstone);
+  } catch (error) {
+    if (isErrno(error, "ENOENT"))
+      return;
+    throw error;
+  }
+  await dependencies.afterTombstoneMove?.(tombstone, lockPath);
+  const moved = await observeLock(tombstone);
+  if (moved?.kind !== "regular" || moved.owner?.token !== owner.token) {
+    await restoreUnexpectedLock(tombstone, lockPath);
+    return;
+  }
+  await unlink(tombstone);
+}
+async function tryAcquire(lockPath, dependencies) {
+  for (let attempt = 0;attempt < MAX_RECLAIM_ATTEMPTS; attempt += 1) {
+    const owner = {
+      version: LOCK_SCHEMA_VERSION,
+      pid: dependencies.pid,
+      token: dependencies.token(),
+      acquiredAt: dependencies.now().toISOString()
+    };
+    let handle;
+    try {
+      handle = await open(lockPath, constants.O_CREAT | constants.O_EXCL | constants.O_RDWR | constants.O_NOFOLLOW, 384);
+    } catch (error) {
+      if (!isErrno(error, "EEXIST"))
+        throw error;
+      const observed = await observeLock(lockPath);
+      if (observed === null)
+        continue;
+      if (observed.kind === "unsafe")
+        throw new NoteLockBusyError(lockPath);
+      const ageMs = Math.max(0, dependencies.now().getTime() - observed.modifiedAtMs);
+      const ownerAlive = observed.owner !== null && dependencies.isProcessAlive(observed.owner.pid);
+      if (ownerAlive || observed.owner === null && ageMs <= dependencies.staleAfterMs) {
+        throw new NoteLockBusyError(lockPath);
+      }
+      if (await reclaimObservedLock(lockPath, observed, owner.token, dependencies)) {
+        continue;
+      }
+      continue;
+    }
+    try {
+      await handle.writeFile(`${JSON.stringify(owner)}
+`, { encoding: "utf8" });
+      await handle.sync();
+    } catch (error) {
+      await handle.close().catch(() => {
+        return;
+      });
+      const created = await observeLock(lockPath);
+      if (created?.kind === "regular") {
+        await reclaimObservedLock(lockPath, created, owner.token, dependencies).catch(() => {
+          return;
+        });
+      }
+      throw error;
+    }
+    let leaseOperationTail = Promise.resolve();
+    const runLeaseOperation = (operation) => {
+      const result = leaseOperationTail.then(operation);
+      leaseOperationTail = result.then(() => {
+        return;
+      }, () => {
+        return;
+      });
+      return result;
+    };
+    let heartbeatQueued = false;
+    let released = false;
+    let releasePromise;
+    const timer = setInterval(() => {
+      if (heartbeatQueued || releasePromise !== undefined)
+        return;
+      heartbeatQueued = true;
+      runLeaseOperation(async () => {
+        if (released)
+          return;
+        const now = dependencies.now();
+        await handle.utimes(now, now);
+      }).catch(() => {
+        return;
+      }).finally(() => {
+        heartbeatQueued = false;
+      });
+    }, dependencies.heartbeatMs);
+    timer.unref();
+    return {
+      path: lockPath,
+      assertOwned: () => runLeaseOperation(async () => {
+        if (released)
+          throw new NoteLockLostError(lockPath);
+        const observed = await observeLock(lockPath);
+        if (observed?.kind !== "regular" || observed.owner?.token !== owner.token) {
+          throw new NoteLockLostError(lockPath);
+        }
+      }),
+      release: async () => {
+        if (releasePromise !== undefined)
+          return releasePromise;
+        clearInterval(timer);
+        releasePromise = runLeaseOperation(async () => {
+          released = true;
+          await handle.close();
+          await releaseOwnedLock(lockPath, owner, dependencies);
+        });
+        return releasePromise;
+      }
+    };
+  }
+  throw new NoteLockBusyError(lockPath);
+}
+async function acquireNoteLock(vaultRoot, canonicalNoteId, options = {}) {
+  const lockPath = await lockPathFor(vaultRoot, canonicalNoteId, options.cacheHome);
+  return acquireFileLease(lockPath, options);
+}
+async function acquireFileLease(lockPathInput, options = {}) {
+  if (typeof lockPathInput !== "string" || lockPathInput.trim() === "") {
+    throw new TypeError("a file lease requires a non-empty path");
+  }
+  const lockPath = resolve(lockPathInput);
+  const requestedDirectory = dirname(lockPath);
+  const directory = await realpath(requestedDirectory);
+  const metadata = await lstat(directory);
+  if (directory !== requestedDirectory || !metadata.isDirectory() || metadata.isSymbolicLink() || dirname(lockPath) !== directory) {
+    throw new Error("the file lease parent must be one canonical real directory");
+  }
+  const dependencies = resolvedDependencies(options.dependencies);
+  const waitTimeoutMs = options.waitTimeoutMs ?? DEFAULT_WAIT_TIMEOUT_MS;
+  if (!Number.isFinite(waitTimeoutMs) || waitTimeoutMs < 0) {
+    throw new TypeError("waitTimeoutMs must be a non-negative finite duration");
+  }
+  const deadline = dependencies.monotonicNow() + waitTimeoutMs;
+  for (;; ) {
+    try {
+      return await tryAcquire(lockPath, dependencies);
+    } catch (error) {
+      if (!(error instanceof NoteLockBusyError))
+        throw error;
+      const remaining = deadline - dependencies.monotonicNow();
+      if (remaining <= 0)
+        throw error;
+      await dependencies.sleep(Math.min(dependencies.pollIntervalMs, remaining));
+    }
+  }
+}
+
+export { acquireNoteLock, acquireFileLease };