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

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());
+});

package/dist/hooks/prim-hook.js

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import {
+  appendMove,
+  resolveOrg
+} from "../chunk-JZGWQDM5.js";
+import {
+  scrubFromCwd,
+  shouldFlushAfter,
+  toMove
+} from "../chunk-PTLXSXIY.js";
+
+// src/hooks/prim-hook.ts
+import { spawn } from "child_process";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+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 spawnBackgroundFlush() {
+  const entry = join(here, "..", "index.js");
+  spawn(process.execPath, [entry, "moves", "flush"], {
+    detached: true,
+    stdio: "ignore"
+  }).unref();
+}
+try {
+  const raw = readFileSync(0, "utf-8");
+  const parsed = JSON.parse(raw);
+  const cwd = parsed.cwd ?? process.cwd();
+  const base = toMove(parsed, resolveCliVersion());
+  const move = { ...base, payload: scrubFromCwd(parsed, cwd) };
+  const { orgId } = resolveOrg({ sessionId: move.sessionId, cwd: move.env.cwd });
+  appendMove(move, orgId);
+  if (shouldFlushAfter(move.eventType)) {
+    spawnBackgroundFlush();
+  }
+} catch (err) {
+  if (process.env.PRIM_HOOK_DEBUG) {
+    const detail = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[prim-hook] capture failed: ${detail}
+`);
+  }
+}
+process.exit(0);

package/dist/hooks/session-end.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import {
+  daemonRequest
+} from "../chunk-UTKQTZHL.js";
+
+// src/hooks/session-end.ts
+var STDIN_TIMEOUT_MS = 1e3;
+var DAEMON_TIMEOUT_MS = 250;
+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");
+}
+async function main() {
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    emit();
+    return;
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(raw);
+  } catch {
+    emit();
+    return;
+  }
+  if (envelope.hook_event_name !== "SessionEnd") {
+    emit();
+    return;
+  }
+  if (typeof envelope.session_id !== "string" || envelope.session_id.length === 0) {
+    emit();
+    return;
+  }
+  await daemonRequest(
+    "session_end",
+    { sessionId: envelope.session_id },
+    { timeoutMs: DAEMON_TIMEOUT_MS }
+  );
+  emit();
+}
+main().catch(() => {
+  emit();
+});

package/dist/hooks/session-start.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import {
+  daemonRequest
+} from "../chunk-UTKQTZHL.js";
+
+// src/hooks/session-start.ts
+var STDIN_TIMEOUT_MS = 1e3;
+var DAEMON_TIMEOUT_MS = 250;
+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");
+}
+async function main() {
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    emit();
+    return;
+  }
+  let envelope;
+  try {
+    envelope = JSON.parse(raw);
+  } catch {
+    emit();
+    return;
+  }
+  if (envelope.hook_event_name !== "SessionStart") {
+    emit();
+    return;
+  }
+  if (typeof envelope.session_id !== "string" || envelope.session_id.length === 0) {
+    emit();
+    return;
+  }
+  await daemonRequest(
+    "session_start",
+    { sessionId: envelope.session_id },
+    { timeoutMs: DAEMON_TIMEOUT_MS }
+  );
+  emit();
+}
+main().catch(() => {
+  emit();
+});