@primitive.ai/prim 0.1.0-alpha.9 → 0.1.0-alpha.91

package/dist/chunk-EZXEWFDG.js

@@ -0,0 +1,210 @@
+// src/lib/workspace-id.ts
+import { execFileSync } from "child_process";
+import { randomUUID } from "crypto";
+import {
+  constants,
+  chmodSync,
+  closeSync,
+  fchmodSync,
+  fsyncSync,
+  linkSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { dirname, isAbsolute, join, resolve } from "path";
+var WORKSPACE_ID_RELATIVE_PATH = join("prim", "workspace-id");
+var MAX_ANCESTORS = 64;
+var MAX_GIT_FILE_BYTES = 4096;
+var MAX_ID_FILE_BYTES = 128;
+var GIT_FALLBACK_TIMEOUT_MS = 250;
+var RACE_READ_ATTEMPTS = 5;
+var RACE_READ_DELAY_MS = 5;
+var CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var raceDelay = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+function isCanonicalWorkspaceId(value) {
+  return CANONICAL_UUID.test(value);
+}
+function inspectWorkspaceId(cwd = process.cwd()) {
+  const resolved = resolveWorkspaceIdPath(cwd);
+  if (resolved.status !== "resolved") return resolved;
+  return inspectPath(resolved.path);
+}
+function getOrCreateWorkspaceId(cwd = process.cwd()) {
+  const inspection = inspectWorkspaceId(cwd);
+  if (inspection.status !== "missing") return inspection;
+  return createWorkspaceId(inspection.path);
+}
+function resolveWorkspaceIdPath(cwd) {
+  if (!process.env.GIT_DIR && !process.env.GIT_WORK_TREE) {
+    const fromFilesystem = resolveFromFilesystem(cwd);
+    if (fromFilesystem) return { status: "resolved", path: fromFilesystem };
+  }
+  try {
+    const output = execFileSync(
+      "git",
+      ["rev-parse", "--is-inside-work-tree", "--git-path", WORKSPACE_ID_RELATIVE_PATH],
+      {
+        cwd,
+        encoding: "utf8",
+        maxBuffer: 4096,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: GIT_FALLBACK_TIMEOUT_MS,
+        windowsHide: true
+      }
+    );
+    const [insideWorktree, gitPath, ...extra] = output.trim().split(/\r?\n/);
+    if (insideWorktree !== "true" || !gitPath || extra.length > 0 || gitPath.includes("\0")) {
+      return { status: "not_git" };
+    }
+    return {
+      status: "resolved",
+      path: isAbsolute(gitPath) ? resolve(gitPath) : resolve(cwd, gitPath)
+    };
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ETIMEDOUT" || code === "EACCES" || code === "EPERM") {
+      return { status: "unavailable", operation: "resolve", errorCode: code };
+    }
+    return { status: "not_git" };
+  }
+}
+function resolveFromFilesystem(cwd) {
+  let current = resolve(cwd);
+  for (let depth = 0; depth < MAX_ANCESTORS; depth += 1) {
+    const dotGit = join(current, ".git");
+    try {
+      const stat = lstatSync(dotGit);
+      if (stat.isDirectory() && isGitDirectory(dotGit)) {
+        return join(dotGit, WORKSPACE_ID_RELATIVE_PATH);
+      }
+      if (stat.isFile() && stat.size <= MAX_GIT_FILE_BYTES) {
+        const contents = readFileSync(dotGit, "utf8");
+        const match = /^gitdir: (.+?)(?:\r?\n)?$/.exec(contents);
+        if (match?.[1]) {
+          const gitDirectory = isAbsolute(match[1]) ? resolve(match[1]) : resolve(current, match[1]);
+          if (isGitDirectory(gitDirectory)) {
+            return join(gitDirectory, WORKSPACE_ID_RELATIVE_PATH);
+          }
+        }
+      }
+      return null;
+    } catch (error) {
+      const code = errorCode(error);
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        return null;
+      }
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  return null;
+}
+function isGitDirectory(path) {
+  try {
+    return statSync(join(path, "HEAD")).isFile();
+  } catch {
+    return false;
+  }
+}
+function inspectPath(path) {
+  let stat;
+  try {
+    stat = lstatSync(path);
+  } catch (error) {
+    const code = errorCode(error);
+    if (code === "ENOENT" || code === "ENOTDIR") return { status: "missing", path };
+    return { status: "unavailable", path, operation: "read", errorCode: code };
+  }
+  if (!stat.isFile()) return { status: "corrupt", path, reason: "not_file" };
+  if (stat.size > MAX_ID_FILE_BYTES) {
+    return { status: "corrupt", path, reason: "invalid_content" };
+  }
+  try {
+    const contents = readFileSync(path, "utf8");
+    const workspaceId = contents.endsWith("\n") ? contents.slice(0, -1) : contents;
+    if ((contents === workspaceId || contents === `${workspaceId}
+`) && isCanonicalWorkspaceId(workspaceId)) {
+      return { status: "ready", workspaceId, path, created: false };
+    }
+    return { status: "corrupt", path, reason: "invalid_content" };
+  } catch (error) {
+    return {
+      status: "unavailable",
+      path,
+      operation: "read",
+      errorCode: errorCode(error)
+    };
+  }
+}
+function createWorkspaceId(path) {
+  const parent = dirname(path);
+  const workspaceId = randomUUID();
+  const temporaryPath = join(parent, `.workspace-id-${process.pid}-${randomUUID()}.tmp`);
+  let temporaryCreated = false;
+  let publishing = false;
+  try {
+    mkdirSync(parent, { recursive: true, mode: 448 });
+    chmodSync(parent, 448);
+    const fd = openSync(
+      temporaryPath,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+      384
+    );
+    temporaryCreated = true;
+    try {
+      writeFileSync(fd, `${workspaceId}
+`, "utf8");
+      fchmodSync(fd, 384);
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    publishing = true;
+    linkSync(temporaryPath, path);
+    return { status: "ready", workspaceId, path, created: true };
+  } catch (error) {
+    if (publishing && errorCode(error) === "EEXIST") return inspectAfterRace(path);
+    return {
+      status: "unavailable",
+      path,
+      operation: "create",
+      errorCode: errorCode(error)
+    };
+  } finally {
+    if (temporaryCreated) {
+      try {
+        unlinkSync(temporaryPath);
+      } catch {
+      }
+    }
+  }
+}
+function inspectAfterRace(path) {
+  let result = { status: "missing", path };
+  for (let attempt = 0; attempt < RACE_READ_ATTEMPTS; attempt += 1) {
+    result = inspectPath(path);
+    if (result.status === "ready") return result;
+    if (attempt + 1 < RACE_READ_ATTEMPTS) {
+      Atomics.wait(raceDelay, 0, 0, RACE_READ_DELAY_MS);
+    }
+  }
+  if (result.status === "missing") {
+    return { status: "unavailable", path, operation: "create", errorCode: "EEXIST" };
+  }
+  return result;
+}
+function errorCode(error) {
+  if (typeof error !== "object" || error === null || !("code" in error)) return void 0;
+  return typeof error.code === "string" ? error.code : void 0;
+}
+
+export {
+  isCanonicalWorkspaceId,
+  getOrCreateWorkspaceId
+};

package/dist/chunk-FBAYCS3X.js

@@ -0,0 +1,327 @@
+import {
+  getSiteUrl
+} from "./chunk-PCVGBE5B.js";
+import {
+  jwtOrganizationId,
+  primConfigDirectory,
+  resolveAuthCredential
+} from "./chunk-67VNLLBN.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
+};

package/dist/chunk-FKXFUUWJ.js

@@ -0,0 +1,36 @@
+import {
+  scheduleCollectScopeRefresh
+} from "./chunk-M6RIJVRE.js";
+
+// src/ingest-response.ts
+var IngestAcknowledgementError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IngestAcknowledgementError";
+  }
+};
+function requireDurableIngestAcknowledgement(value, expected, cwd = process.cwd()) {
+  if (typeof value !== "object" || value === null) {
+    throw new IngestAcknowledgementError("ingest response was not an object");
+  }
+  const response = value;
+  if (response.disposition !== "persisted") {
+    throw new IngestAcknowledgementError("ingest response did not confirm persistence");
+  }
+  if (response.acknowledged !== expected) {
+    throw new IngestAcknowledgementError(
+      `ingest acknowledged ${String(response.acknowledged)} of ${String(expected)} moves`
+    );
+  }
+  if (typeof response.collectScopeVersion === "number" && Number.isSafeInteger(response.collectScopeVersion) && response.collectScopeVersion >= 0) {
+    const roots = typeof cwd === "string" ? [cwd] : cwd;
+    for (const root of new Set(roots)) {
+      scheduleCollectScopeRefresh(root, response.collectScopeVersion);
+    }
+  }
+  return value;
+}
+
+export {
+  requireDurableIngestAcknowledgement
+};