@primitive.ai/prim 0.1.0-alpha.40 → 0.1.0-alpha.42

package/dist/chunk-NDIK4FBF.js

@@ -0,0 +1,184 @@
+import {
+  getClient
+} from "./chunk-W6PAKEDO.js";
+
+// src/decisions/feedback.ts
+var FEEDBACK_PROTOCOL_VERSION = 1;
+var FEEDBACK_DEADLINE_MS = 3e3;
+var MAX_FEEDBACK_EVENTS = 40;
+var MAX_FEEDBACK_MESSAGE_CODE_POINTS = 8e3;
+var MAX_FEEDBACK_INTENT_CODE_POINTS = 180;
+var LEASE_PATH = "/api/cli/decisions/feedback/lease";
+var ACK_PATH = "/api/cli/decisions/feedback/ack";
+var STATUS_PATH = "/api/cli/decisions/feedback/status";
+var SHORT_ID = /^[0-9a-f]{8}$/u;
+var MAX_EVENT_ID_CHARS = 128;
+var MAX_RAW_INTENT_CODE_UNITS = 512;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isUnsafeControl(point) {
+  const c0OrC1 = point <= 31 || point >= 127 && point <= 159;
+  const bidiControl = point === 1564 || point === 8206 || point === 8207 || point >= 8234 && point <= 8238 || point >= 8294 && point <= 8297;
+  return c0OrC1 || bidiControl;
+}
+function replaceIsolatedSurrogates(value) {
+  let out = "";
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        out += value[index] + value[index + 1];
+        index += 1;
+      } else {
+        out += "\uFFFD";
+      }
+    } else if (unit >= 56320 && unit <= 57343) {
+      out += "\uFFFD";
+    } else {
+      out += value[index];
+    }
+  }
+  return out;
+}
+function normalizeFeedbackIntent(value) {
+  const safeUnicode = replaceIsolatedSurrogates(value);
+  const whitespace = safeUnicode.replace(/\s+/gu, " ");
+  const withoutControls = Array.from(whitespace).filter((character) => !isUnsafeControl(character.codePointAt(0) ?? 0)).join("").replace(/\s+/gu, " ").trim();
+  const points = Array.from(withoutControls);
+  if (points.length <= MAX_FEEDBACK_INTENT_CODE_POINTS) {
+    return withoutControls;
+  }
+  return `${points.slice(0, MAX_FEEDBACK_INTENT_CODE_POINTS - 1).join("")}\u2026`;
+}
+function parseEvent(value) {
+  if (!isRecord(value)) return void 0;
+  if (typeof value.eventId !== "string" || value.eventId.length === 0 || value.eventId.length > MAX_EVENT_ID_CHARS || Array.from(value.eventId).some((character) => isUnsafeControl(character.codePointAt(0) ?? 0))) {
+    return void 0;
+  }
+  if (!Number.isSafeInteger(value.leaseVersion) || Number(value.leaseVersion) < 1) {
+    return void 0;
+  }
+  if (typeof value.shortId !== "string" || !SHORT_ID.test(value.shortId)) {
+    return void 0;
+  }
+  if (typeof value.intent !== "string" || value.intent.length > MAX_RAW_INTENT_CODE_UNITS) {
+    return void 0;
+  }
+  const intent = normalizeFeedbackIntent(value.intent);
+  if (!intent) return void 0;
+  return {
+    eventId: value.eventId,
+    leaseVersion: Number(value.leaseVersion),
+    shortId: value.shortId,
+    intent
+  };
+}
+function parseFeedbackLease(value) {
+  if (!isRecord(value) || value.protocolVersion !== FEEDBACK_PROTOCOL_VERSION) return void 0;
+  if (value.status === "empty") {
+    return value.hasMore === false ? { events: [], hasMore: false } : void 0;
+  }
+  if (value.status === "unavailable") {
+    return value.reason === "organization_unbound" ? { events: [], hasMore: false } : void 0;
+  }
+  if (value.status !== "leased" || typeof value.hasMore !== "boolean") return void 0;
+  if (!Array.isArray(value.events) || value.events.length === 0 || value.events.length > MAX_FEEDBACK_EVENTS) {
+    return void 0;
+  }
+  const events = value.events.map(parseEvent);
+  if (events.some((event) => event === void 0)) return void 0;
+  const parsedEvents = events;
+  if (new Set(parsedEvents.map((event) => event.eventId)).size !== parsedEvents.length) {
+    return void 0;
+  }
+  return { events: parsedEvents, hasMore: value.hasMore };
+}
+function renderFeedback(lease) {
+  const lines = [];
+  const deliveries = [];
+  let pointCount = 0;
+  for (const event of lease.events) {
+    const line = `[prim] response \u2192 created Decision (dec_${event.shortId}): ${event.intent}`;
+    const extra = Array.from(line).length + (lines.length === 0 ? 0 : 1);
+    if (pointCount + extra > MAX_FEEDBACK_MESSAGE_CODE_POINTS) break;
+    lines.push(line);
+    deliveries.push({ eventId: event.eventId, leaseVersion: event.leaseVersion });
+    pointCount += extra;
+  }
+  if (lines.length === 0) return void 0;
+  return { systemMessage: lines.join("\n"), deliveries };
+}
+async function leaseDecisionFeedback(input, dependencies = {}) {
+  try {
+    const response = await (dependencies.client ?? getClient()).post(
+      LEASE_PATH,
+      {
+        protocolVersion: FEEDBACK_PROTOCOL_VERSION,
+        workspaceId: input.workspaceId,
+        currentSessionId: input.currentSessionId
+      },
+      { signal: input.signal, quietRefresh: true }
+    );
+    const parsed = parseFeedbackLease(response);
+    if (!parsed) {
+      dependencies.onError?.(
+        new Error("server returned an unsupported decision-feedback contract")
+      );
+    }
+    return parsed;
+  } catch (error) {
+    dependencies.onError?.(error);
+    return void 0;
+  }
+}
+async function acknowledgeDecisionFeedback(input, dependencies = {}) {
+  if (input.deliveries.length === 0 || input.deliveries.length > MAX_FEEDBACK_EVENTS) return false;
+  try {
+    const response = await (dependencies.client ?? getClient()).post(
+      ACK_PATH,
+      {
+        protocolVersion: FEEDBACK_PROTOCOL_VERSION,
+        workspaceId: input.workspaceId,
+        deliveries: input.deliveries
+      },
+      { signal: input.signal, quietRefresh: true }
+    );
+    const acknowledgedEventIds = isRecord(response) ? response.acknowledgedEventIds : void 0;
+    const expectedEventIds = new Set(input.deliveries.map((delivery) => delivery.eventId));
+    const valid = isRecord(response) && response.protocolVersion === FEEDBACK_PROTOCOL_VERSION && response.status === "acked" && Array.isArray(acknowledgedEventIds) && acknowledgedEventIds.length <= input.deliveries.length && acknowledgedEventIds.every(
+      (id) => typeof id === "string" && id.length > 0 && id.length <= MAX_EVENT_ID_CHARS && expectedEventIds.has(id)
+    ) && new Set(acknowledgedEventIds).size === acknowledgedEventIds.length;
+    if (!valid) {
+      dependencies.onError?.(
+        new Error("server returned an unsupported decision-feedback acknowledgement")
+      );
+    }
+    return valid;
+  } catch (error) {
+    dependencies.onError?.(error);
+    return false;
+  }
+}
+function parseFeedbackCapability(value) {
+  if (!isRecord(value) || value.protocolVersion !== FEEDBACK_PROTOCOL_VERSION) return void 0;
+  if (value.status === "available") return { status: "available" };
+  if (value.status === "unavailable" && value.reason === "organization_unbound") {
+    return { status: "unavailable", reason: "organization_unbound" };
+  }
+  return void 0;
+}
+async function fetchFeedbackCapability(signal, client = getClient()) {
+  const result = parseFeedbackCapability(await client.get(STATUS_PATH, { signal }));
+  if (!result) throw new Error("server returned an unsupported decision-feedback contract");
+  return result;
+}
+
+export {
+  FEEDBACK_DEADLINE_MS,
+  renderFeedback,
+  leaseDecisionFeedback,
+  acknowledgeDecisionFeedback,
+  fetchFeedbackCapability
+};

package/dist/{chunk-H4OR42TJ.js → chunk-OKUXEBPT.js}

@@ -1,21 +1,27 @@
 import {
   getSiteUrl
-} from "./chunk-26VA3ADF.js";
+} from "./chunk-W6PAKEDO.js";
 
 // src/journal.ts
 import {
   appendFileSync,
+  closeSync,
   existsSync,
+  fstatSync,
   mkdirSync,
+  openSync,
+  opendirSync,
   readFileSync,
-  readdirSync,
-  statSync
+  readSync,
+  readdirSync
 } from "fs";
 import { homedir } from "os";
 import { dirname, join } from "path";
 var JOURNAL_DIR = join(homedir(), ".config", "prim", "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 === "..") {
@@ -48,11 +54,7 @@ function journalPath(orgId) {
 function appendMove(move, orgId) {
   appendMoveToPath(journalPath(orgId), move);
 }
-function readMovesFromPath(path) {
-  if (!existsSync(path)) {
-    return [];
-  }
-  const content = readFileSync(path, "utf-8");
+function parseMoves(content) {
   const moves = [];
   for (const line of content.split("\n")) {
     if (line.length === 0) {
@@ -65,6 +67,12 @@ function readMovesFromPath(path) {
   }
   return moves;
 }
+function readMovesFromPath(path) {
+  if (!existsSync(path)) {
+    return [];
+  }
+  return parseMoves(readFileSync(path, "utf-8"));
+}
 function listBuckets() {
   const out = [];
   const envDir = currentEnvDir();
@@ -83,60 +91,164 @@ function listBuckets() {
   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;
   return last !== void 0 && /^[0-9]+$/.test(last) ? Number(last) : void 0;
 }
-function listFlushingInDir(dir, bucket) {
+function listFlushingInDir(dir, bucket, options = {}) {
   if (!existsSync(dir)) {
     return [];
   }
   const out = [];
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isFile() || !entry.name.startsWith(FLUSHING_PREFIX)) {
-      continue;
+  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();
     }
-    const path = join(dir, entry.name);
-    const stat = statSync(path);
-    const lineCount = readFileSync(path, "utf-8").split("\n").filter((l) => l.length > 0).length;
-    out.push({
-      bucket,
-      path,
-      pid: parseFlushingPid(entry.name),
-      sizeBytes: stat.size,
-      mtimeMs: stat.mtimeMs,
-      lineCount
-    });
+  } finally {
+    entries.closeSync();
   }
   return out;
 }
-function listFlushing() {
+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()) {
-      out.push(...listFlushingInDir(join(envDir, entry.name), entry.name));
+      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() {
-  return listBuckets().map(({ bucket, path }) => {
-    const stat = statSync(path);
-    const content = readFileSync(path, "utf-8");
-    const lineCount = content.split("\n").filter((l) => l.length > 0).length;
-    return {
+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,
-      sizeBytes: stat.size,
-      mtimeMs: stat.mtimeMs,
-      lineCount
-    };
-  });
+      ...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
@@ -248,6 +360,7 @@ export {
   listBuckets,
   listFlushing,
   bucketStats,
+  pendingJournalStats,
   SESSIONS_DIR,
   resolveOrg
 };

package/dist/{chunk-AAGJFO7C.js → chunk-QY75BQMF.js}

@@ -68,11 +68,35 @@ function stripAnsi(text) {
   return text.replace(/\u001b\[[0-9;]*m/g, "");
 }
 
+// src/ingest-response.ts
+var IngestAcknowledgementError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "IngestAcknowledgementError";
+  }
+};
+function requireDurableIngestAcknowledgement(value, expected) {
+  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`
+    );
+  }
+  return value;
+}
+
 export {
   color,
   dim,
   bold,
   colorForArea,
   stripControlChars,
-  stripAnsi
+  stripAnsi,
+  requireDurableIngestAcknowledgement
 };

package/dist/chunk-S5NUHFAD.js

@@ -0,0 +1,55 @@
+// src/hooks/decision-feedback-core.ts
+function buildHookOutput(options) {
+  const output = {};
+  if (options.systemMessage) output.systemMessage = options.systemMessage;
+  if (options.additionalContext) {
+    output.hookSpecificOutput = {
+      hookEventName: "SessionStart",
+      additionalContext: options.additionalContext
+    };
+  }
+  return output;
+}
+function writeHookOutput(output, stream = process.stdout) {
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (ok, retainErrorListener = false) => {
+      if (settled) return;
+      settled = true;
+      if (!retainErrorListener) stream.off("error", onError);
+      resolve(ok);
+    };
+    const onError = () => {
+      if (settled) {
+        stream.off("error", onError);
+        return;
+      }
+      finish(false);
+    };
+    stream.once("error", onError);
+    try {
+      stream.write(
+        `${JSON.stringify(output)}
+`,
+        (error) => error ? finish(false, true) : finish(true)
+      );
+    } catch {
+      finish(false);
+    }
+  });
+}
+async function handoffHookOutput(output, acknowledge, stream = process.stdout) {
+  const handedOff = await writeHookOutput(output, stream);
+  if (handedOff && acknowledge) {
+    try {
+      await acknowledge();
+    } catch {
+    }
+  }
+  return handedOff;
+}
+
+export {
+  buildHookOutput,
+  handoffHookOutput
+};

package/dist/{chunk-26VA3ADF.js → chunk-W6PAKEDO.js}

@@ -79,7 +79,7 @@ function getSiteUrl() {
   }
   return DEFAULT_API_URL;
 }
-async function refreshToken() {
+async function performTokenRefresh(options = {}) {
   if (!existsSync(REFRESH_TOKEN_PATH)) {
     return void 0;
   }
@@ -91,9 +91,11 @@ async function refreshToken() {
   const response = await fetch(`${siteUrl}/mcp/broker/refresh`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ refresh_token: refreshTokenValue })
+    body: JSON.stringify({ refresh_token: refreshTokenValue }),
+    signal: options.signal
   });
   if (!response.ok) {
+    if (options.quiet) return void 0;
     const detail = (await response.text().catch(() => "")).slice(0, 200);
     process.stderr.write(
       `[prim] token refresh rejected by broker: ${response.status} ${response.statusText}${detail ? ` \u2014 ${detail}` : ""}
@@ -112,6 +114,24 @@ async function refreshToken() {
   saveTokenExpiry(data.access_token, data.expires_in);
   return data.access_token;
 }
+var _refreshInFlight;
+function refreshToken(options = {}) {
+  if (_refreshInFlight) {
+    return _refreshInFlight;
+  }
+  const attempt = performTokenRefresh(options).then((token) => {
+    if (token) {
+      _cachedToken = token;
+    }
+    return token;
+  }).finally(() => {
+    if (_refreshInFlight === attempt) {
+      _refreshInFlight = void 0;
+    }
+  });
+  _refreshInFlight = attempt;
+  return attempt;
+}
 var HttpError = class extends Error {
   status;
   constructor(status, message) {
@@ -128,7 +148,10 @@ async function request(method, path, body, options) {
     _cachedToken = getAuthToken();
   }
   if (_cachedToken && isTokenExpiringSoon()) {
-    const newToken = await refreshToken();
+    const newToken = await refreshToken({
+      signal: options?.signal,
+      quiet: options?.quietRefresh
+    });
     if (newToken) {
       _cachedToken = newToken;
     }
@@ -147,9 +170,13 @@ async function request(method, path, body, options) {
       signal: options?.signal
     });
   };
-  let res = await doFetch(_cachedToken);
+  const tokenUsed = _cachedToken;
+  let res = await doFetch(tokenUsed);
   if (res.status === 401) {
-    const newToken = await refreshToken();
+    const newToken = _cachedToken && _cachedToken !== tokenUsed ? _cachedToken : await refreshToken({
+      signal: options?.signal,
+      quiet: options?.quietRefresh
+    });
     if (newToken) {
       _cachedToken = newToken;
       res = await doFetch(newToken);
@@ -179,7 +206,6 @@ export {
   getTokenExpiresAt,
   getAuthToken,
   getSiteUrl,
-  refreshToken,
   HttpError,
   getClient
 };