@primitive.ai/prim 0.1.0-alpha.15 → 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,8 +1,12 @@
 #!/usr/bin/env node
 import {
-  getClient,
+  checkAffectedDecisions,
+  formatDecisionsWarning,
   getGitContext
-} from "../chunk-SHLF6OL2.js";
+} from "../chunk-S47B4VGC.js";
+import {
+  getClient
+} from "../chunk-6SIEWWUL.js";
 
 // src/hooks/pre-commit.ts
 import { execSync } from "child_process";
@@ -156,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) {

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

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import {
+  getClient
+} from "../chunk-6SIEWWUL.js";
+import {
+  daemonRequest
+} from "../chunk-UTKQTZHL.js";
+
+// src/hooks/pre-tool-use-scoring.ts
+import { isAbsolute, relative, sep } from "path";
+var VERDICT_SEVERITY = {
+  allow: 0,
+  warn: 1,
+  ask: 2,
+  deny: 3
+};
+function toRepoRelative(filePath, cwd) {
+  const rel = isAbsolute(filePath) ? relative(cwd, filePath) : filePath;
+  return sep === "/" ? rel : rel.split(sep).join("/");
+}
+function aggregateCheckResults(results) {
+  let worst = "allow";
+  for (const r of results) {
+    if (r.verdict !== "unavailable" && VERDICT_SEVERITY[r.verdict] > VERDICT_SEVERITY[worst]) {
+      worst = r.verdict;
+    }
+  }
+  return worst;
+}
+function anyUnverified(results) {
+  return results.some((r) => r.verdict === "unavailable" || r.truncated);
+}
+function unverifiedNote(results) {
+  const causes = [];
+  const unavailable = results.find((r) => r.verdict === "unavailable");
+  if (unavailable) {
+    causes.push(
+      unavailable.unavailable ? `decision check skipped \u2014 ${unavailable.unavailable}` : "decision check skipped \u2014 not verified"
+    );
+  }
+  if (results.some((r) => r.truncated)) {
+    causes.push("decision check partial \u2014 conflict set truncated (per-file cap hit)");
+  }
+  return causes.map((c) => `[primitive] ${c}`).join("\n");
+}
+function buildHookOutput(aggregate, results) {
+  if (aggregate === "deny") {
+    const reason = results.filter((r) => r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n") || "[primitive] conflict detected (no detail available)";
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: reason
+      }
+    };
+  }
+  if (aggregate === "ask") {
+    const reason = results.filter((r) => r.verdict === "ask" || r.verdict === "deny").map((r) => r.reason).filter((s) => s.length > 0).join("\n\n") || "[primitive] please confirm this edit";
+    const additionalContext = results.map((r) => r.additionalContext).filter((s) => s.length > 0).join("\n");
+    const out = {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "ask",
+        permissionDecisionReason: reason
+      }
+    };
+    if (additionalContext.length > 0) {
+      out.hookSpecificOutput.additionalContext = additionalContext;
+    }
+    return out;
+  }
+  const notes = [
+    ...results.map((r) => r.additionalContext).filter((s) => s.length > 0),
+    anyUnverified(results) ? unverifiedNote(results) : ""
+  ].filter((s) => s.length > 0).join("\n");
+  if (notes.length > 0) {
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        additionalContext: notes
+      }
+    };
+  }
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  };
+}
+function failOpenOutput() {
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow"
+    }
+  };
+}
+var SUPPORTED_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit"]);
+function extractFilePaths(toolName, toolInput) {
+  if (!SUPPORTED_TOOLS.has(toolName)) {
+    return [];
+  }
+  if (!toolInput || typeof toolInput !== "object") {
+    return [];
+  }
+  const input = toolInput;
+  if (typeof input.file_path === "string" && input.file_path.length > 0) {
+    return [input.file_path];
+  }
+  return [];
+}
+function readHookMode(env) {
+  if (env.PRIM_BYPASS === "1" || env.PRIM_BYPASS === "true") {
+    return "off";
+  }
+  const mode = env.PRIM_HOOK_MODE;
+  if (mode === "off" || mode === "warn") {
+    return mode;
+  }
+  return "block";
+}
+function demoteForMode(verdict, mode) {
+  if (mode === "off") {
+    return "allow";
+  }
+  if (mode === "warn" && (verdict === "ask" || verdict === "deny")) {
+    return "warn";
+  }
+  return verdict;
+}
+
+// src/hooks/pre-tool-use.ts
+var HOOK_TIMEOUT_MS = 4500;
+var STDIN_TIMEOUT_MS = 1e3;
+var DAEMON_TIMEOUT_MS = 250;
+async 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(output) {
+  process.stdout.write(`${JSON.stringify(output)}
+`);
+}
+async function checkOneFile(file) {
+  const fromDaemon = await daemonRequest(
+    "conflict_check",
+    { file },
+    { timeoutMs: DAEMON_TIMEOUT_MS }
+  );
+  if (fromDaemon) {
+    return fromDaemon;
+  }
+  const client = getClient();
+  return await client.post(
+    "/api/cli/decisions/conflict-check",
+    { file },
+    { signal: AbortSignal.timeout(HOOK_TIMEOUT_MS) }
+  );
+}
+async function main() {
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    emit(failOpenOutput());
+    return;
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(raw);
+  } catch {
+    emit(failOpenOutput());
+    return;
+  }
+  if (envelope.hook_event_name !== "PreToolUse") {
+    emit(failOpenOutput());
+    return;
+  }
+  const env = process.env;
+  const mode = readHookMode(env);
+  if (mode === "off") {
+    emit(failOpenOutput());
+    return;
+  }
+  const toolName = typeof envelope.tool_name === "string" ? envelope.tool_name : "";
+  const cwd = typeof envelope.cwd === "string" && envelope.cwd.length > 0 ? envelope.cwd : process.cwd();
+  const files = extractFilePaths(toolName, envelope.tool_input).map((f) => toRepoRelative(f, cwd));
+  if (files.length === 0) {
+    emit(failOpenOutput());
+    return;
+  }
+  let results;
+  try {
+    results = await Promise.all(files.map((f) => checkOneFile(f)));
+  } catch {
+    emit(failOpenOutput());
+    return;
+  }
+  const rawAggregate = aggregateCheckResults(results);
+  const aggregate = demoteForMode(rawAggregate, mode);
+  emit(buildHookOutput(aggregate, results));
+}
+main().catch(() => {
+  emit(failOpenOutput());
+});