@primitive.ai/prim 0.1.0-alpha.8 → 0.1.0-alpha.80

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,299 @@
+#!/usr/bin/env node
+import {
+  bindRepository,
+  ensureEffectivePostCommitHook,
+  ensureEffectivePostRewriteHook,
+  hasUsableCodexGuidance,
+  refreshClaudePlugins,
+  resolveRepositoryBinding,
+  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-EZXEWFDG.js";
+import {
+  prepareCodexContext
+} from "../chunk-KKP2NYZ3.js";
+import {
+  binFile
+} from "../chunk-4A2XB2PC.js";
+import {
+  gitToplevel,
+  githubRepositoryFullName,
+  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 {
+      const binding = await bindRepository(root, {
+        signal: AbortSignal.timeout(REPOSITORY_BIND_TIMEOUT_MS),
+        quietRefresh: true
+      });
+      return { root, binding };
+    } catch {
+    }
+    return { root };
+  } catch {
+    return null;
+  }
+}
+function claudeBindingReminder(binding) {
+  if (binding.status === "connected") {
+    return `The current GitHub repository is connected to Primitive. In your first response, begin with exactly: "GitHub repository connected to Primitive: ${binding.repositoryFullName}." Then continue the user's request.`;
+  }
+  return `The current GitHub repository is not connected to Primitive. Before doing task work, ask exactly: "This GitHub repository isn't connected to Primitive yet. Would you like me to start the one-time GitHub connection now?" Wait for the user's answer. If they approve, run \`npx --yes @primitive.ai/prim github connect\`, drive the browser-based GitHub App workflow, report its actual outcome concisely, and resume work. If they decline or the connection does not complete, continue without asking again in this session. Do not use owner/admin escalation or capability-loss warnings.`;
+}
+async function claudeRepositoryBinding(cwd, activeProject) {
+  const root = activeProject?.root ?? gitToplevel(cwd);
+  if (!root || !githubRepositoryFullName(root)) return void 0;
+  if (activeProject) return activeProject.binding;
+  try {
+    return await resolveRepositoryBinding(root, {
+      signal: AbortSignal.timeout(REPOSITORY_BIND_TIMEOUT_MS),
+      quietRefresh: true
+    });
+  } catch {
+    return void 0;
+  }
+}
+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 };
+  let claudeBinding;
+  if (agent === "claude_code") {
+    const activeProject = await activeProjectRoot(cwd);
+    projectRoot = activeProject?.root ?? null;
+    active = projectRoot !== null;
+    claudeBinding = await claudeRepositoryBinding(cwd, activeProject);
+    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))?.root ?? null;
+    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 = [
+      claudeBinding ? claudeBindingReminder(claudeBinding) : void 0,
+      active && skillState.installed > 0 ? PRIM_SKILL_REMINDER : void 0
+    ].filter((value) => value !== void 0).join("\n\n");
+    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({}));
+});