@primitive.ai/prim 0.1.0-alpha.14 → 0.1.0-alpha.16

package/dist/chunk-UTKQTZHL.js

@@ -0,0 +1,88 @@
+// src/daemon/client.ts
+import { createConnection } from "net";
+import { homedir } from "os";
+import { join } from "path";
+var SOCK_PATH = join(homedir(), ".config", "prim", "sock");
+var DEFAULT_TIMEOUT_MS = 250;
+var nextRequestId = 1;
+function daemonRequest(method, params = {}, opts = {}) {
+  const id = nextRequestId++;
+  const request = { id, method, params };
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    let socket;
+    let buffer = "";
+    const settle = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (socket) {
+        try {
+          socket.destroy();
+        } catch {
+        }
+      }
+      resolve(value);
+    };
+    const timer = setTimeout(() => settle(null), timeoutMs);
+    timer.unref();
+    try {
+      socket = createConnection(SOCK_PATH);
+    } catch {
+      clearTimeout(timer);
+      settle(null);
+      return;
+    }
+    socket.on("error", () => {
+      clearTimeout(timer);
+      settle(null);
+    });
+    socket.on("connect", () => {
+      try {
+        socket?.write(`${JSON.stringify(request)}
+`);
+      } catch {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString("utf-8");
+      const newlineIdx = buffer.indexOf("\n");
+      if (newlineIdx === -1) {
+        return;
+      }
+      const line = buffer.slice(0, newlineIdx);
+      try {
+        const res = JSON.parse(line);
+        if (res.id !== id) {
+          clearTimeout(timer);
+          settle(null);
+          return;
+        }
+        clearTimeout(timer);
+        settle(res.ok && res.result !== void 0 ? res.result : null);
+      } catch {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+    socket.on("end", () => {
+      if (!settled) {
+        clearTimeout(timer);
+        settle(null);
+      }
+    });
+  });
+}
+async function daemonIsLive(timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const result = await daemonRequest("ping", {}, { timeoutMs });
+  return result?.pong === true;
+}
+
+export {
+  daemonRequest,
+  daemonIsLive
+};

package/dist/daemon/server.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import {
+  getClient,
+  getTokenExpiresAt,
+  refreshToken
+} from "../chunk-6SIEWWUL.js";
+
+// src/daemon/server.ts
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { createServer } from "net";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".config", "prim");
+var SOCK_PATH = join(CONFIG_DIR, "sock");
+var PID_PATH = join(CONFIG_DIR, "daemon.pid");
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var TOKEN_CHECK_INTERVAL_MS = 6e4;
+var TOKEN_REFRESH_THRESHOLD_MS = 9e4;
+var PRESENCE_FRESH_WINDOW_MS = 9e4;
+var SOCKET_DIR_MODE = 448;
+var PID_FILE_MODE = 384;
+var EXIT_OK = 0;
+var EXIT_CRASH = 1;
+var startedAt = Date.now();
+var client = getClient();
+var activeSessionId = process.env.PRIM_DAEMON_SESSION_ID ?? `daemon-${process.pid}`;
+var lastHeartbeatAt;
+var lastOnlineCount;
+var lastOkAtLocal;
+var heartbeatTimer;
+var tokenCheckTimer;
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function takePidfile() {
+  if (existsSync(PID_PATH)) {
+    const existing = Number(readFileSync(PID_PATH, "utf-8").trim());
+    if (!Number.isNaN(existing) && processIsAlive(existing)) {
+      throw new Error(`daemon already running (pid=${existing})`);
+    }
+  }
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true, mode: SOCKET_DIR_MODE });
+  }
+  writeFileSync(PID_PATH, String(process.pid), { mode: PID_FILE_MODE });
+}
+function cleanup() {
+  try {
+    unlinkSync(SOCK_PATH);
+  } catch {
+  }
+  try {
+    unlinkSync(PID_PATH);
+  } catch {
+  }
+}
+async function sendHeartbeat() {
+  try {
+    const result = await client.post("/api/cli/presence/heartbeat", {
+      sessionId: activeSessionId
+    });
+    if (result.accepted) {
+      lastOkAtLocal = Date.now();
+      if (typeof result.lastHeartbeatAt === "number") {
+        lastHeartbeatAt = result.lastHeartbeatAt;
+      }
+      if (typeof result.onlineCount === "number") {
+        lastOnlineCount = result.onlineCount;
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[prim-daemon] heartbeat error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function ensureTokenFresh() {
+  const expiresAt = getTokenExpiresAt();
+  if (!expiresAt) {
+    return;
+  }
+  if (Date.now() >= expiresAt - TOKEN_REFRESH_THRESHOLD_MS) {
+    try {
+      await refreshToken();
+    } catch {
+    }
+  }
+}
+async function handleConflictCheck(params) {
+  if (typeof params.file !== "string") {
+    throw new Error("conflict_check requires `file: string`");
+  }
+  return await client.post("/api/cli/decisions/conflict-check", { file: params.file });
+}
+function handleStatusSnapshot() {
+  const presenceFresh = lastOkAtLocal !== void 0 && Date.now() - lastOkAtLocal < PRESENCE_FRESH_WINDOW_MS;
+  const presenceStale = lastOkAtLocal !== void 0 && !presenceFresh;
+  return {
+    pid: process.pid,
+    uptimeMs: Date.now() - startedAt,
+    sessionId: activeSessionId,
+    lastHeartbeatAt,
+    // Withhold a frozen count once it's no longer fresh; the statusline shows
+    // "presence: stale" rather than a confident, wrong "team: N".
+    onlineCount: presenceFresh ? lastOnlineCount : void 0,
+    presenceStale
+  };
+}
+async function dispatchRequest(req) {
+  const id = req.id;
+  try {
+    switch (req.method) {
+      case "conflict_check": {
+        const result = await handleConflictCheck(req.params ?? {});
+        return { id, ok: true, result };
+      }
+      case "session_start": {
+        const sid = req.params?.sessionId;
+        if (typeof sid === "string" && sid.length > 0) {
+          activeSessionId = sid;
+        }
+        await sendHeartbeat();
+        return { id, ok: true, result: { sessionId: activeSessionId } };
+      }
+      case "session_end": {
+        return { id, ok: true, result: { ack: true } };
+      }
+      case "status_snapshot":
+        return { id, ok: true, result: handleStatusSnapshot() };
+      case "ping":
+        return { id, ok: true, result: { pong: true } };
+      default:
+        return { id, ok: false, error: `unknown method: ${req.method}` };
+    }
+  } catch (err) {
+    return {
+      id,
+      ok: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function handleConnection(conn) {
+  let buffer = "";
+  conn.on("data", (chunk) => {
+    buffer += chunk.toString("utf-8");
+    let newlineIdx = buffer.indexOf("\n");
+    while (newlineIdx !== -1) {
+      const line = buffer.slice(0, newlineIdx);
+      buffer = buffer.slice(newlineIdx + 1);
+      if (line.length > 0) {
+        try {
+          const req = JSON.parse(line);
+          dispatchRequest(req).then(
+            (res) => {
+              conn.write(`${JSON.stringify(res)}
+`);
+            },
+            () => {
+            }
+          );
+        } catch {
+        }
+      }
+      newlineIdx = buffer.indexOf("\n");
+    }
+  });
+  conn.on("error", () => {
+  });
+}
+function startSocketServer() {
+  try {
+    unlinkSync(SOCK_PATH);
+  } catch {
+  }
+  const server = createServer(handleConnection);
+  server.on("error", (err) => {
+    process.stderr.write(`[prim-daemon] socket error: ${err.message}
+`);
+  });
+  server.listen(SOCK_PATH, () => {
+    process.stderr.write(`[prim-daemon] listening on ${SOCK_PATH}
+`);
+  });
+}
+function startTimers() {
+  void sendHeartbeat();
+  heartbeatTimer = setInterval(() => {
+    void sendHeartbeat();
+  }, HEARTBEAT_INTERVAL_MS);
+  tokenCheckTimer = setInterval(() => {
+    void ensureTokenFresh();
+  }, TOKEN_CHECK_INTERVAL_MS);
+}
+function stopTimers() {
+  if (heartbeatTimer) {
+    clearInterval(heartbeatTimer);
+  }
+  if (tokenCheckTimer) {
+    clearInterval(tokenCheckTimer);
+  }
+}
+function installSignalHandlers() {
+  for (const signal of ["SIGTERM", "SIGINT"]) {
+    process.on(signal, () => {
+      process.stderr.write(`[prim-daemon] ${signal}, shutting down (pid=${process.pid})
+`);
+      stopTimers();
+      cleanup();
+      process.exit(EXIT_OK);
+    });
+  }
+  process.on("uncaughtException", (err) => {
+    process.stderr.write(`[prim-daemon] uncaught: ${err.message}
+`);
+    stopTimers();
+    cleanup();
+    process.exit(EXIT_CRASH);
+  });
+}
+function main() {
+  try {
+    takePidfile();
+  } catch (err) {
+    process.stderr.write(`[prim-daemon] ${err instanceof Error ? err.message : String(err)}
+`);
+    process.exit(EXIT_CRASH);
+  }
+  installSignalHandlers();
+  startSocketServer();
+  startTimers();
+  process.stderr.write(`[prim-daemon] started (pid=${process.pid}, session=${activeSessionId})
+`);
+}
+main();

package/dist/hooks/post-tool-use.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+import {
+  bold,
+  color
+} from "../chunk-BEEGFDGU.js";
+import {
+  getClient
+} from "../chunk-6SIEWWUL.js";
+import {
+  scrubFromCwd,
+  toMove
+} from "../chunk-PTLXSXIY.js";
+
+// src/hooks/post-tool-use.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+
+// src/hooks/verdict-footer.ts
+function renderVerdictFooter(ctx) {
+  const successPrefix = color("\u2713 Conflict caught before merge", "green");
+  const savedCount = `${String(ctx.decisionsSaved)}${ctx.decisionsSavedTruncated ? "+" : ""}`;
+  const savedFragment = `${savedCount} decisions saved`;
+  const intentFragment = `${bold(ctx.author)}'s intent preserved`;
+  return `${successPrefix} \xB7 ${savedFragment} \xB7 ${intentFragment}`;
+}
+function isVerdictFooterContext(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const v = value;
+  return typeof v.author === "string" && typeof v.intent === "string" && typeof v.decisionsSaved === "number" && typeof v.decisionsSavedTruncated === "boolean" && typeof v.decisionId === "string";
+}
+
+// src/hooks/post-tool-use.ts
+var STDIN_TIMEOUT_MS = 1e3;
+var INGEST_TIMEOUT_MS = 4e3;
+var EDITING_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
+var here = dirname(fileURLToPath(import.meta.url));
+function resolveCliVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(here, "..", "..", "package.json"), "utf-8"));
+    return pkg.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const timer = setTimeout(() => {
+      reject(new Error("stdin read timeout"));
+    }, STDIN_TIMEOUT_MS);
+    process.stdin.on("data", (chunk) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      clearTimeout(timer);
+      resolve(Buffer.concat(chunks).toString("utf-8"));
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+function emit() {
+  process.stdout.write("{}\n");
+}
+function debug(msg) {
+  if (process.env.PRIM_HOOK_VERBOSE === "1") {
+    process.stderr.write(`[prim-post-tool-use] ${msg}
+`);
+  }
+}
+async function ingestMove(move) {
+  const client = getClient();
+  return await client.post(
+    "/api/cli/moves/ingest",
+    { batch: [move] },
+    { signal: AbortSignal.timeout(INGEST_TIMEOUT_MS) }
+  );
+}
+async function main() {
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    emit();
+    return;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    emit();
+    return;
+  }
+  const envelope = parsed;
+  if (envelope.hook_event_name !== "PostToolUse") {
+    emit();
+    return;
+  }
+  const toolName = typeof envelope.tool_name === "string" ? envelope.tool_name : "";
+  if (!EDITING_TOOLS.has(toolName)) {
+    emit();
+    return;
+  }
+  if (typeof envelope.session_id !== "string" || envelope.session_id.length === 0) {
+    emit();
+    return;
+  }
+  const cwd = parsed.cwd ?? process.cwd();
+  const base = toMove(parsed, resolveCliVersion());
+  const move = { ...base, payload: scrubFromCwd(parsed, cwd) };
+  try {
+    const result = await ingestMove(move);
+    debug(`ingested ${move.moveId} (${toolName})`);
+    if (isVerdictFooterContext(result.verdictFooter)) {
+      process.stderr.write(`${renderVerdictFooter(result.verdictFooter)}
+`);
+    }
+  } catch (err) {
+    debug(`ingest failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  emit();
+}
+main().catch(() => {
+  emit();
+});

package/dist/hooks/pre-commit.js

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
+import {
+  checkAffectedDecisions,
+  formatDecisionsWarning,
+  getGitContext
+} from "../chunk-S47B4VGC.js";
 import {
   getClient
-} from "../chunk-3APLWTLB.js";
+} from "../chunk-6SIEWWUL.js";
 
 // src/hooks/pre-commit.ts
 import { execSync } from "child_process";
@@ -47,7 +52,8 @@ var HOOK_TIMEOUT_MS = 1e4;
 var defaultDeps = {
   getClient,
   getStagedFiles,
-  getStagedDiff
+  getStagedDiff,
+  getGitContext
 };
 async function syncAffectedSpecs(deps = defaultDeps) {
   const stagedFiles = deps.getStagedFiles();
@@ -55,9 +61,18 @@ async function syncAffectedSpecs(deps = defaultDeps) {
     return [];
   }
   const client = deps.getClient();
+  const gitCtx = deps.getGitContext();
+  let mappingsUrl = "/api/cli/specs/mappings";
+  if (gitCtx.repoFullName && gitCtx.branch) {
+    const params = new URLSearchParams({
+      repoFullName: gitCtx.repoFullName,
+      branch: gitCtx.branch
+    });
+    mappingsUrl = `${mappingsUrl}?${params.toString()}`;
+  }
   let mappings = [];
   try {
-    mappings = await client.get("/api/cli/specs/mappings", {
+    mappings = await client.get(mappingsUrl, {
       signal: AbortSignal.timeout(HOOK_TIMEOUT_MS)
     });
   } catch {
@@ -66,6 +81,7 @@ async function syncAffectedSpecs(deps = defaultDeps) {
   if (mappings.length === 0) {
     return [];
   }
+  const specsById = new Map(mappings.map((s) => [s._id, s]));
   const affectedContexts = findAffectedContexts(stagedFiles, mappings);
   if (affectedContexts.size === 0) {
     return [];
@@ -90,20 +106,51 @@ async function syncAffectedSpecs(deps = defaultDeps) {
         console.log(`  [skip] ${contextId} \u2014 no diff content`);
         continue;
       }
-      const response = await client.post(
-        `/api/cli/contexts/${contextId}/sync-diff`,
-        { diffContent, affectedFiles: affected.matchedFiles },
-        { signal: AbortSignal.timeout(HOOK_TIMEOUT_MS) }
-      );
+      const body = {
+        diffContent,
+        affectedFiles: affected.matchedFiles
+      };
+      if (gitCtx.branch) body.branch = gitCtx.branch;
+      if (gitCtx.sha) body.sha = gitCtx.sha;
+      if (gitCtx.repoFullName) body.repoFullName = gitCtx.repoFullName;
+      if (gitCtx.prNumber !== null) body.prNumber = gitCtx.prNumber;
+      const response = await client.post(`/api/cli/contexts/${contextId}/sync-diff`, body, {
+        signal: AbortSignal.timeout(HOOK_TIMEOUT_MS)
+      });
       const name = ctx.name ?? "(unnamed)";
+      if (!response.analyzing && response.reason === "not_linked") {
+        console.log(
+          `  [skip] ${contextId} \u2014 ${name} \u2014 not linked to ${gitCtx.branch ?? "(no branch)"}`
+        );
+        continue;
+      }
+      const spec = specsById.get(contextId);
+      const link = spec?.linkedBranches?.find((l) => l.branch === gitCtx.branch);
+      let linkSuffix = "";
+      if (link) {
+        const prBits = link.prNumber ? ` #${String(link.prNumber)}${link.prState ? ` ${link.prState}` : ""}` : "";
+        linkSuffix = ` (linked to ${link.branch}${prBits})`;
+      } else if (gitCtx.branch && spec?.linkedBranches?.length === 0) {
+        linkSuffix = ` (auto-linking to ${gitCtx.branch})`;
+      }
+      const review = link?.latestReviewSummary;
+      let reviewSuffix = "";
+      if (review?.status === "completed") {
+        const n = review.findingsCount ?? 0;
+        const urlSuffix = review.prCommentUrl ? ` \u2192 ${review.prCommentUrl.replace(/^https?:\/\//, "")}` : "";
+        reviewSuffix = ` (reviewed: ${String(n)} finding${n === 1 ? "" : "s"}${urlSuffix})`;
+      } else if (review?.status === "failed") {
+        reviewSuffix = " (review failed)";
+      }
+      linkSuffix += reviewSuffix;
       if (response.truncated && response.sizeChars && response.limitChars) {
         const sizeKiB = Math.round(response.sizeChars / 1024);
         const limitKiB = Math.round(response.limitChars / 1024);
         console.log(
-          `  [synced] ${contextId} \u2014 ${name} (truncated: ${String(sizeKiB)} KiB \u2192 ${String(limitKiB)} KiB analyzed)`
+          `  [synced] ${contextId} \u2014 ${name} (truncated: ${String(sizeKiB)} KiB \u2192 ${String(limitKiB)} KiB analyzed)${linkSuffix}`
         );
       } else {
-        console.log(`  [synced] ${contextId} \u2014 ${name}`);
+        console.log(`  [synced] ${contextId} \u2014 ${name}${linkSuffix}`);
       }
       synced.push(contextId);
     } catch (error) {
@@ -113,8 +160,19 @@ async function syncAffectedSpecs(deps = defaultDeps) {
   }
   return synced;
 }
+async function runDecisionsCheck() {
+  const stagedFiles = getStagedFiles();
+  if (stagedFiles.length === 0) {
+    return { decisions: [], truncated: false };
+  }
+  return checkAffectedDecisions(stagedFiles);
+}
 async function main() {
-  await syncAffectedSpecs();
+  const [, decisionsResult] = await Promise.all([syncAffectedSpecs(), runDecisionsCheck()]);
+  const warning = formatDecisionsWarning(decisionsResult);
+  if (warning) {
+    console.error(warning);
+  }
   process.exit(0);
 }
 if (!process.env.VITEST) {