@primitive.ai/prim 0.1.0-alpha.15 → 0.1.0-alpha.17

package/dist/chunk-TPQ3X244.js

@@ -0,0 +1,151 @@
+import {
+  getClient
+} from "./chunk-6SIEWWUL.js";
+import {
+  daemonRequest
+} from "./chunk-UTKQTZHL.js";
+
+// src/daemon/proxy.ts
+var DAEMON_HTTP_TIMEOUT_MS = 1e4;
+var DAEMON_PROBE_TIMEOUT_MS = 250;
+async function daemonOrDirect(method, params, direct) {
+  const fromDaemon = await daemonRequest(method, params, {
+    timeoutMs: DAEMON_PROBE_TIMEOUT_MS
+  });
+  if (fromDaemon !== null) {
+    return fromDaemon;
+  }
+  return await direct();
+}
+async function daemonOrDirectGet(method, path, client, timeoutMs = DAEMON_HTTP_TIMEOUT_MS) {
+  return await daemonOrDirect(
+    method,
+    { path },
+    async () => await client.get(path, {
+      signal: AbortSignal.timeout(timeoutMs)
+    })
+  );
+}
+
+// src/hooks/decisions-check.ts
+var DECISIONS_CHECK_TIMEOUT_MS = 1e4;
+var MAX_FILES_PER_REQUEST = 25;
+var defaultDeps = { getClient };
+function chunk(items, size) {
+  const out = [];
+  for (let i = 0; i < items.length; i += size) {
+    out.push(items.slice(i, i + size));
+  }
+  return out;
+}
+async function fetchAffecting(client, batch) {
+  const params = new URLSearchParams();
+  for (const file of batch) {
+    params.append("files", file);
+  }
+  try {
+    return await daemonOrDirectGet(
+      "decisions_affecting",
+      `/api/cli/decisions/affecting?${params.toString()}`,
+      client,
+      DECISIONS_CHECK_TIMEOUT_MS
+    );
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return { decisions: [], truncated: false, unavailable: `decision check failed: ${detail}` };
+  }
+}
+async function checkAffectedDecisions(filePaths, deps = defaultDeps) {
+  if (filePaths.length === 0) {
+    return { decisions: [], truncated: false };
+  }
+  const client = deps.getClient();
+  const responses = await Promise.all(
+    chunk(filePaths, MAX_FILES_PER_REQUEST).map((batch) => fetchAffecting(client, batch))
+  );
+  const byId = /* @__PURE__ */ new Map();
+  let truncated = false;
+  let unavailable;
+  for (const res of responses) {
+    if (res.unavailable !== void 0 && unavailable === void 0) {
+      unavailable = res.unavailable;
+    }
+    truncated ||= res.truncated === true;
+    for (const d of res.decisions) {
+      const existing = byId.get(d.id);
+      if (existing) {
+        existing.matchedFiles = [.../* @__PURE__ */ new Set([...existing.matchedFiles, ...d.matchedFiles])];
+      } else {
+        byId.set(d.id, { ...d, matchedFiles: [...d.matchedFiles] });
+      }
+    }
+  }
+  const result = { decisions: [...byId.values()], truncated };
+  if (unavailable !== void 0) {
+    result.unavailable = unavailable;
+  }
+  return result;
+}
+var FILES_PREVIEW_LIMIT = 3;
+function formatDecisionsWarning(result) {
+  const lines = [];
+  if (result.unavailable !== void 0) {
+    lines.push(`[prim] decision check not verified \u2014 ${result.unavailable}`);
+  }
+  if (result.decisions.length > 0) {
+    lines.push(
+      `[prim] ${String(result.decisions.length)} active decision(s) reference staged files:`
+    );
+    for (const d of result.decisions) {
+      const statusMark = d.status === "under_review" ? " (under review)" : "";
+      const preview = d.matchedFiles.slice(0, FILES_PREVIEW_LIMIT).join(", ");
+      const overflow = d.matchedFiles.length > FILES_PREVIEW_LIMIT ? ` (+${String(d.matchedFiles.length - FILES_PREVIEW_LIMIT)} more)` : "";
+      lines.push(`  \xB7 ${d.intent}${statusMark}`);
+      lines.push(`    files: ${preview}${overflow}`);
+      if (d.rationale) {
+        lines.push(`    rationale: ${d.rationale}`);
+      }
+    }
+  }
+  if (result.truncated) {
+    lines.push(
+      "[prim] result truncated \u2014 more files than the server checks per request; not all decisions shown"
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/utils/git.ts
+import { execSync } from "child_process";
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch {
+    return null;
+  }
+}
+function parseRepoFullName(remoteUrl) {
+  const match = remoteUrl.match(/(?:github\.com[:/])([^/]+)\/([^/]+?)(?:\.git)?\/?$/);
+  return match ? `${match[1]}/${match[2]}` : null;
+}
+function getGitContext() {
+  const branchRaw = safeExec("git rev-parse --abbrev-ref HEAD");
+  const branch = branchRaw && branchRaw !== "HEAD" ? branchRaw : null;
+  const sha = safeExec("git rev-parse HEAD");
+  const remoteUrl = safeExec("git remote get-url origin");
+  const repoFullName = remoteUrl ? parseRepoFullName(remoteUrl) : null;
+  let prNumber = null;
+  if (safeExec("command -v gh")) {
+    const raw = safeExec("gh pr view --json number -q .number");
+    const n = raw ? Number.parseInt(raw, 10) : Number.NaN;
+    if (Number.isFinite(n)) prNumber = n;
+  }
+  return { branch, sha, repoFullName, prNumber };
+}
+
+export {
+  daemonOrDirectGet,
+  checkAffectedDecisions,
+  formatDecisionsWarning,
+  getGitContext
+};

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,274 @@
+#!/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 HTTP_PROXY_TIMEOUT_MS = 1e4;
+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 pathParam(params) {
+  if (typeof params.path !== "string" || !params.path.startsWith("/api/cli/")) {
+    throw new Error("proxy request requires `path: string` under /api/cli/");
+  }
+  return params.path;
+}
+function assertEndpointPath(path, endpoint) {
+  if (path !== endpoint && !path.startsWith(`${endpoint}?`)) {
+    throw new Error(`proxy path must be ${endpoint} or ${endpoint}?...`);
+  }
+}
+async function proxyGet(params, allowedPrefix) {
+  const path = pathParam(params);
+  assertEndpointPath(path, allowedPrefix);
+  return await client.get(path, { signal: AbortSignal.timeout(HTTP_PROXY_TIMEOUT_MS) });
+}
+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 "decisions_recent": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/recent");
+        return { id, ok: true, result };
+      }
+      case "decisions_show": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/show");
+        return { id, ok: true, result };
+      }
+      case "decisions_cascade": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/cascade");
+        return { id, ok: true, result };
+      }
+      case "decisions_affecting": {
+        const result = await proxyGet(req.params ?? {}, "/api/cli/decisions/affecting");
+        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,134 @@
+#!/usr/bin/env node
+import {
+  bold,
+  color
+} from "../chunk-BEEGFDGU.js";
+import {
+  getClient
+} from "../chunk-6SIEWWUL.js";
+import {
+  scrubFromCwd,
+  toMove
+} from "../chunk-LCC66K45.js";
+import {
+  parseAgent
+} from "../chunk-7YRBACIE.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 CODEX_EDITING_TOOLS = /* @__PURE__ */ new Set(["apply_patch"]);
+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 : "";
+  const agent = parseAgent(process.argv);
+  const editingTools = agent === "codex" ? CODEX_EDITING_TOOLS : EDITING_TOOLS;
+  if (!editingTools.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(), agent);
+  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,8 +1,13 @@
 #!/usr/bin/env node
 import {
-  getClient,
+  checkAffectedDecisions,
+  formatDecisionsWarning,
   getGitContext
-} from "../chunk-SHLF6OL2.js";
+} from "../chunk-TPQ3X244.js";
+import {
+  getClient
+} from "../chunk-6SIEWWUL.js";
+import "../chunk-UTKQTZHL.js";
 
 // src/hooks/pre-commit.ts
 import { execSync } from "child_process";
@@ -156,8 +161,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) {