@primitive.ai/prim 0.1.0-alpha.7 → 0.1.0-alpha.70

package/dist/hooks/session-end.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import {
+  normalizeEnvelope,
+  parseAgent
+} from "../chunk-WB7AUZ4C.js";
+import {
+  daemonRequest
+} from "../chunk-CUE2LKLR.js";
+import "../chunk-3EEFL6NJ.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() {
+  const agent = parseAgent(process.argv);
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    emit();
+    return;
+  }
+  let envelope;
+  try {
+    envelope = normalizeEnvelope(
+      JSON.parse(raw),
+      agent
+    );
+  } 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,271 @@
+#!/usr/bin/env node
+import {
+  bindRepository,
+  ensureEffectivePostCommitHook,
+  ensureEffectivePostRewriteHook,
+  hasUsableCodexGuidance,
+  refreshClaudePlugins,
+  warmBinCache
+} from "../chunk-2KW7DVFJ.js";
+import {
+  buildHookOutput,
+  handoffHookOutput
+} from "../chunk-4GLVJLEQ.js";
+import {
+  FEEDBACK_DEADLINE_MS,
+  acknowledgeDecisionFeedback,
+  leaseDecisionFeedback,
+  renderFeedback
+} from "../chunk-LMRYZL3D.js";
+import {
+  getOrCreateWorkspaceId
+} from "../chunk-UVIWZWM6.js";
+import {
+  prepareCodexContext
+} from "../chunk-KKP2NYZ3.js";
+import {
+  binFile
+} from "../chunk-4A2XB2PC.js";
+import {
+  gitToplevel,
+  isRepoActiveForCapture,
+  repoActiveFlag,
+  setRepoActive
+} from "../chunk-TJTVHDJ5.js";
+import {
+  getSiteUrl,
+  isSessionEnded
+} from "../chunk-Z7YPFWAZ.js";
+import {
+  normalizeEnvelope,
+  parseAgent
+} from "../chunk-WB7AUZ4C.js";
+import {
+  daemonRequest
+} from "../chunk-CUE2LKLR.js";
+import "../chunk-3EEFL6NJ.js";
+
+// src/daemon/self-heal.ts
+import { spawn } from "child_process";
+function kickDaemonEnsure(options = {}) {
+  const primEntry = options.primEntry === void 0 ? binFile("prim") : options.primEntry;
+  if (!primEntry) {
+    return false;
+  }
+  try {
+    const args = [primEntry, "daemon", "ensure"];
+    if ((options.platform ?? process.platform) === "darwin") {
+      args.push("--latest-bootstrap");
+    }
+    const child = (options.spawnProcess ?? spawn)(
+      options.nodeEntry ?? process.execPath,
+      args,
+      { detached: true, stdio: "ignore" }
+    );
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/hooks/reauth-notice.ts
+var REAUTH_NOTICE = "[prim] authentication ended \u2014 run `prim auth login` to resume decision capture";
+function reauthNoticeFields(agent) {
+  if (agent === "claude_code") return { systemMessage: REAUTH_NOTICE };
+  return;
+}
+
+// src/hooks/session-start-core.ts
+var DAEMON_TIMEOUT_MS = 250;
+var REPOSITORY_BIND_TIMEOUT_MS = 1e3;
+var PRIM_TRIGGER = "When this task chooses between plausible approaches or establishes or changes a lasting goal, priority, constraint, invariant, default, commitment, tradeoff, exception, or shared instruction";
+var PRIM_EXCLUSIONS = "Never invoke `prim` for routine implementation that merely follows an existing decision made before this task or for temporary tactics; they never qualify, including for evaluation.";
+function primReminder(action, rationaleAction) {
+  return `Primitive is active in this repository. ${PRIM_TRIGGER}, ${action} before finishing. ${PRIM_EXCLUSIONS} When a direct request replaces one lasting default with another but supplies no rationale, complete the work, ${rationaleAction}, and ask one concise rationale question at the task boundary, even if the user requested only implementation or recording fails.`;
+}
+var PRIM_SKILL_REMINDER = primReminder("invoke the `prim` skill", "invoke the skill");
+var CODEX_PRIM_ACTION = "follow the installed Prim workflow and use the `prim` CLI";
+var CODEX_PRIM_REMINDER = primReminder(CODEX_PRIM_ACTION, CODEX_PRIM_ACTION);
+async function activeProjectRoot(cwd) {
+  try {
+    const root = gitToplevel(cwd);
+    if (!root || !isRepoActiveForCapture(cwd)) return null;
+    let shellGateActive = repoActiveFlag(root) === "true";
+    if (!shellGateActive) {
+      try {
+        setRepoActive(root, true);
+        shellGateActive = true;
+      } catch {
+      }
+    }
+    if (shellGateActive) {
+      try {
+        ensureEffectivePostCommitHook(root);
+      } catch {
+      }
+      try {
+        ensureEffectivePostRewriteHook(root);
+      } catch {
+      }
+    }
+    try {
+      await bindRepository(root, {
+        signal: AbortSignal.timeout(REPOSITORY_BIND_TIMEOUT_MS),
+        quietRefresh: true
+      });
+    } catch {
+    }
+    return root;
+  } catch {
+    return null;
+  }
+}
+async function processSessionStart(raw, agent, feedbackSignal) {
+  let envelope;
+  try {
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return { output: buildHookOutput({}) };
+    }
+    envelope = normalizeEnvelope(parsed, agent);
+  } catch {
+    return { output: buildHookOutput({}) };
+  }
+  if (envelope.hook_event_name !== "SessionStart") {
+    return { output: buildHookOutput({}) };
+  }
+  if (typeof envelope.session_id !== "string" || envelope.session_id.length === 0) {
+    return { output: buildHookOutput({}) };
+  }
+  kickDaemonEnsure();
+  await daemonRequest(
+    "session_start",
+    { sessionId: envelope.session_id, callerEnv: getSiteUrl() },
+    { timeoutMs: DAEMON_TIMEOUT_MS }
+  );
+  const cwd = envelope.cwd ?? process.cwd();
+  let projectRoot = null;
+  let active = false;
+  let skillState = { installed: 0, refreshed: 0 };
+  if (agent === "claude_code") {
+    projectRoot = await activeProjectRoot(cwd);
+    active = projectRoot !== null;
+    try {
+      skillState = await refreshClaudePlugins(
+        cwd,
+        active && projectRoot !== null ? { includeProject: true, projectRoot } : { includeProject: false }
+      );
+    } catch {
+    }
+  }
+  if (isSessionEnded() && agent !== "codex") {
+    const notice = reauthNoticeFields(agent);
+    if (notice) {
+      return {
+        output: buildHookOutput({ ...notice, reloadSkills: skillState.refreshed > 0 })
+      };
+    }
+  }
+  if (agent === "codex") {
+    let context;
+    try {
+      context = await prepareCodexContext({
+        cwd,
+        sessionId: envelope.session_id,
+        startup: true,
+        includeDigest: false
+      });
+    } catch {
+    }
+    projectRoot = await activeProjectRoot(cwd);
+    active = projectRoot !== null;
+    let proactive = false;
+    try {
+      proactive = projectRoot !== null && active && hasUsableCodexGuidance(projectRoot);
+    } catch {
+    }
+    const additionalContext = [proactive ? CODEX_PRIM_REMINDER : void 0, context?.context].filter((value) => value !== void 0).join("\n\n");
+    return {
+      output: buildHookOutput({ additionalContext }),
+      acknowledge: async () => {
+        await context?.acknowledge(true);
+      }
+    };
+  }
+  if (agent === "claude_code") {
+    const additionalContext = active && skillState.installed > 0 ? PRIM_SKILL_REMINDER : void 0;
+    const reloadSkills = skillState.refreshed > 0;
+    if (active) {
+      const identity = getOrCreateWorkspaceId(cwd);
+      if (identity.status === "ready") {
+        const signal = feedbackSignal ?? AbortSignal.timeout(FEEDBACK_DEADLINE_MS);
+        const lease = await leaseDecisionFeedback({
+          workspaceId: identity.workspaceId,
+          currentSessionId: envelope.session_id,
+          signal
+        });
+        const rendered = lease ? renderFeedback(lease) : void 0;
+        return {
+          output: buildHookOutput({
+            systemMessage: rendered?.systemMessage,
+            additionalContext,
+            reloadSkills
+          }),
+          acknowledge: rendered ? async () => {
+            await acknowledgeDecisionFeedback({
+              protocolVersion: rendered.protocolVersion,
+              workspaceId: identity.workspaceId,
+              deliveries: rendered.deliveries,
+              signal
+            });
+          } : void 0
+        };
+      }
+    }
+    return { output: buildHookOutput({ additionalContext, reloadSkills }) };
+  }
+  await activeProjectRoot(cwd);
+  return { output: buildHookOutput({}) };
+}
+
+// src/hooks/session-start.ts
+var STDIN_TIMEOUT_MS = 1e3;
+var outputAttempted = false;
+function emitOutput(output, acknowledge) {
+  outputAttempted = true;
+  return handoffHookOutput(output, acknowledge);
+}
+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);
+    });
+  });
+}
+async function main() {
+  warmBinCache();
+  const agent = parseAgent(process.argv);
+  let raw;
+  try {
+    raw = await readStdin();
+  } catch {
+    await emitOutput(buildHookOutput({}));
+    return;
+  }
+  const result = await processSessionStart(raw, agent);
+  await emitOutput(result.output, result.acknowledge);
+}
+void main().catch(async () => {
+  if (!outputAttempted) await emitOutput(buildHookOutput({}));
+});