@primitive.ai/prim 0.1.0-alpha.8 → 0.1.0-alpha.80

package/dist/chunk-YWO7O6QG.js

@@ -0,0 +1,327 @@
+import {
+  getSiteUrl
+} from "./chunk-Z7YPFWAZ.js";
+import {
+  jwtOrganizationId,
+  primConfigDirectory,
+  resolveAuthCredential
+} from "./chunk-3EEFL6NJ.js";
+
+// src/journal.ts
+import {
+  appendFileSync,
+  closeSync,
+  existsSync,
+  fstatSync,
+  mkdirSync,
+  openSync,
+  opendirSync,
+  readFileSync,
+  readSync,
+  readdirSync
+} from "fs";
+import { dirname, join } from "path";
+var JOURNAL_DIR = join(primConfigDirectory(), "moves");
+var UNBOUND_BUCKET = "_unbound";
+var JOURNAL_BASENAME = "journal.ndjson";
+var JOURNAL_STATS_SAMPLE_BYTES = 64 * 1024;
+var PENDING_STATS_MAX_FILES = 128;
+function envSlug(apiUrl) {
+  const slug = apiUrl.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9._-]/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+  if (slug.length === 0 || slug === "." || slug === "..") {
+    return "default";
+  }
+  return slug;
+}
+function currentEnvDir() {
+  return join(JOURNAL_DIR, envSlug(getSiteUrl()));
+}
+var DIR_MODE = 448;
+var FILE_MODE = 384;
+var SAFE_BUCKET = /^[A-Za-z0-9_-]+$/;
+var RESERVED_BUCKETS = /* @__PURE__ */ new Set([UNBOUND_BUCKET, "_legacy"]);
+function appendMoveToPath(path, move) {
+  const dir = dirname(path);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true, mode: DIR_MODE });
+  }
+  appendFileSync(path, `${JSON.stringify(move)}
+`, { mode: FILE_MODE });
+}
+function bucketDir(orgId) {
+  const safe = orgId !== void 0 && SAFE_BUCKET.test(orgId) && !RESERVED_BUCKETS.has(orgId);
+  return join(currentEnvDir(), safe ? orgId : UNBOUND_BUCKET);
+}
+function journalPath(orgId) {
+  return join(bucketDir(orgId), JOURNAL_BASENAME);
+}
+function appendMove(move, orgId) {
+  appendMoveToPath(journalPath(orgId), move);
+}
+function parseMoves(content) {
+  const moves = [];
+  for (const line of content.split("\n")) {
+    if (line.length === 0) {
+      continue;
+    }
+    try {
+      moves.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return moves;
+}
+function readMovesFromPath(path) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  return parseMoves(readFileSync(path, "utf-8"));
+}
+function listBuckets() {
+  const out = [];
+  const envDir = currentEnvDir();
+  if (!existsSync(envDir)) {
+    return out;
+  }
+  for (const entry of readdirSync(envDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const path = join(envDir, entry.name, JOURNAL_BASENAME);
+    if (existsSync(path)) {
+      out.push({ bucket: entry.name, path });
+    }
+  }
+  return out;
+}
+var FLUSHING_PREFIX = `${JOURNAL_BASENAME}.flushing.`;
+function oldestCapturedAt(moves) {
+  let oldest;
+  for (const move of moves) {
+    if (!Number.isFinite(move.capturedAt)) {
+      continue;
+    }
+    oldest = oldest === void 0 ? move.capturedAt : Math.min(oldest, move.capturedAt);
+  }
+  return oldest;
+}
+function sampleJournalFile(path, maxBytes = JOURNAL_STATS_SAMPLE_BYTES) {
+  const fd = openSync(path, "r");
+  try {
+    const initial = fstatSync(fd);
+    const target = Math.min(initial.size, Math.max(0, maxBytes));
+    const buffer = Buffer.allocUnsafe(target);
+    let sampledBytes = 0;
+    while (sampledBytes < target) {
+      const count = readSync(fd, buffer, sampledBytes, target - sampledBytes, sampledBytes);
+      if (count === 0) {
+        break;
+      }
+      sampledBytes += count;
+    }
+    const stat = fstatSync(fd);
+    const sampled = stat.size > sampledBytes;
+    let content = buffer.subarray(0, sampledBytes).toString("utf-8");
+    if (sampled) {
+      const lastNewline = content.lastIndexOf("\n");
+      content = lastNewline === -1 ? "" : content.slice(0, lastNewline + 1);
+    }
+    const lines = content.split("\n").filter((line) => line.length > 0);
+    const moves = parseMoves(content);
+    return {
+      sizeBytes: stat.size,
+      mtimeMs: stat.mtimeMs,
+      lineCount: sampled && stat.size > 0 ? Math.max(1, lines.length) : lines.length,
+      oldestCapturedAt: oldestCapturedAt(moves),
+      sampled,
+      sampledBytes
+    };
+  } finally {
+    closeSync(fd);
+  }
+}
+function parseFlushingPid(name) {
+  const segments = name.slice(FLUSHING_PREFIX.length).split(".");
+  const last = segments.length >= 2 ? segments[segments.length - 1] : void 0;
+  if (last === void 0 || !/^[0-9]+$/.test(last)) return void 0;
+  const pid = Number(last);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+}
+function listFlushingInDir(dir, bucket, options = {}) {
+  if (!existsSync(dir)) {
+    return [];
+  }
+  const out = [];
+  let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  const entries = opendirSync(dir);
+  try {
+    let entry = entries.readSync();
+    while (entry && out.length < maxFiles) {
+      if (!entry.isFile() || !entry.name.startsWith(FLUSHING_PREFIX)) {
+        entry = entries.readSync();
+        continue;
+      }
+      const path = join(dir, entry.name);
+      let sample;
+      try {
+        sample = sampleJournalFile(path, remainingBytes);
+      } catch (err) {
+        if (err.code === "ENOENT") {
+          entry = entries.readSync();
+          continue;
+        }
+        throw err;
+      }
+      remainingBytes = Math.max(0, remainingBytes - sample.sampledBytes);
+      out.push({
+        bucket,
+        path,
+        pid: parseFlushingPid(entry.name),
+        ...sample
+      });
+      entry = entries.readSync();
+    }
+  } finally {
+    entries.closeSync();
+  }
+  return out;
+}
+function listFlushing(options = {}) {
+  const envDir = currentEnvDir();
+  if (!existsSync(envDir)) {
+    return [];
+  }
+  const out = [];
+  let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  for (const entry of readdirSync(envDir, { withFileTypes: true })) {
+    if (out.length >= maxFiles) {
+      break;
+    }
+    if (entry.isDirectory()) {
+      const found = listFlushingInDir(join(envDir, entry.name), entry.name, {
+        sampleBytes: remainingBytes,
+        maxFiles: maxFiles - out.length
+      });
+      out.push(...found);
+      remainingBytes = Math.max(
+        0,
+        remainingBytes - found.reduce((count, file) => count + file.sampledBytes, 0)
+      );
+    }
+  }
+  return out;
+}
+function bucketStats(options = {}) {
+  const out = [];
+  let remainingBytes = options.sampleBytes ?? JOURNAL_STATS_SAMPLE_BYTES;
+  const maxFiles = options.maxFiles ?? Number.POSITIVE_INFINITY;
+  for (const { bucket, path } of listBuckets()) {
+    if (out.length >= maxFiles) {
+      break;
+    }
+    let sample;
+    try {
+      sample = sampleJournalFile(path, remainingBytes);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        continue;
+      }
+      throw err;
+    }
+    remainingBytes = Math.max(0, remainingBytes - sample.sampledBytes);
+    out.push({
+      bucket,
+      path,
+      ...sample
+    });
+  }
+  return out;
+}
+function pendingJournalStats() {
+  const perKindBytes = Math.floor(JOURNAL_STATS_SAMPLE_BYTES / 2);
+  const perKindFiles = Math.floor(PENDING_STATS_MAX_FILES / 2);
+  const live = bucketStats({ sampleBytes: perKindBytes, maxFiles: perKindFiles });
+  const stranded = listFlushing({ sampleBytes: perKindBytes, maxFiles: perKindFiles });
+  const timestamps = [...live, ...stranded].map((entry) => entry.oldestCapturedAt).filter((value) => value !== void 0);
+  const liveSampled = live.some((entry) => entry.sampled) || live.length >= perKindFiles;
+  const strandedSampled = stranded.some((entry) => entry.sampled) || stranded.length >= perKindFiles;
+  return {
+    pendingCount: live.reduce((count, entry) => count + entry.lineCount, 0) + stranded.reduce((count, entry) => count + entry.lineCount, 0),
+    oldestPendingAt: timestamps.length > 0 ? Math.min(...timestamps) : void 0,
+    strandedCount: stranded.reduce((count, entry) => count + entry.lineCount, 0),
+    strandedFileCount: stranded.length,
+    sampled: liveSampled || strandedSampled,
+    strandedSampled
+  };
+}
+
+// src/binding.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var PRIM_CONFIG_DIR = primConfigDirectory();
+var SESSIONS_DIR = join2(PRIM_CONFIG_DIR, "sessions");
+var WORKSPACE_FILE = ".prim/workspace.json";
+function readJsonSafe(path) {
+  if (!existsSync2(path)) {
+    return;
+  }
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return;
+  }
+}
+function fromSessionMarker(sessionId) {
+  if (!sessionId) {
+    return;
+  }
+  const marker = readJsonSafe(join2(SESSIONS_DIR, `${sessionId}.json`));
+  return marker?.orgId;
+}
+function fromWorkspaceFile(startDir) {
+  let dir = startDir;
+  while (true) {
+    const config = readJsonSafe(join2(dir, WORKSPACE_FILE));
+    if (config?.orgId) {
+      return config.orgId;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) {
+      return;
+    }
+    dir = parent;
+  }
+}
+function fromDefaultOrg(_cwd) {
+  const credential = resolveAuthCredential();
+  return credential ? jwtOrganizationId(credential.token) : void 0;
+}
+function resolveOrg(args) {
+  const fromSession = fromSessionMarker(args.sessionId);
+  if (fromSession) {
+    return { orgId: fromSession, source: "session" };
+  }
+  const fromWorkspace = fromWorkspaceFile(args.cwd);
+  if (fromWorkspace) {
+    return { orgId: fromWorkspace, source: "workspace" };
+  }
+  const fromDefault = fromDefaultOrg(args.cwd);
+  if (fromDefault) {
+    return { orgId: fromDefault, source: "defaultOrg" };
+  }
+  return { orgId: void 0, source: "unbound" };
+}
+
+export {
+  JOURNAL_DIR,
+  appendMove,
+  readMovesFromPath,
+  listBuckets,
+  listFlushing,
+  bucketStats,
+  pendingJournalStats,
+  SESSIONS_DIR,
+  resolveOrg
+};