failproofai 0.0.6-beta.4 → 0.0.6

package/dist/cli.mjs

@@ -198,6 +198,9 @@ function instruct(reason) {
 }
 
 // src/hooks/policy-registry.ts
+function normalizePolicyName(name) {
+  return name.includes("/") ? name : `${DEFAULT_POLICY_NAMESPACE}/${name}`;
+}
 function getIndexCache() {
   return globalThis[INDEX_CACHE_KEY];
 }
@@ -212,9 +215,10 @@ function getRegistry() {
   return g[REGISTRY_KEY];
 }
 function registerPolicy(name, description, fn, match, priority = 0) {
+  const canonical = normalizePolicyName(name);
   const registry = getRegistry();
-  const idx = registry.findIndex((p) => p.name === name);
-  const entry = { name, description, fn, match, priority };
+  const idx = registry.findIndex((p) => p.name === canonical);
+  const entry = { name: canonical, description, fn, match, priority };
   if (idx >= 0) {
     registry[idx] = entry;
   } else {
@@ -251,7 +255,7 @@ function clearPolicies() {
   g[REGISTRY_KEY] = [];
   setIndexCache(null);
 }
-var REGISTRY_KEY = "__FAILPROOFAI_POLICY_REGISTRY__", INDEX_CACHE_KEY = "__FAILPROOFAI_POLICY_INDEX_CACHE__";
+var REGISTRY_KEY = "__FAILPROOFAI_POLICY_REGISTRY__", INDEX_CACHE_KEY = "__FAILPROOFAI_POLICY_INDEX_CACHE__", DEFAULT_POLICY_NAMESPACE = "exospherehost";
 
 // src/hooks/builtin-policies.ts
 import { resolve as resolve2, join as join2 } from "node:path";
@@ -1045,6 +1049,82 @@ function requirePrBeforeStop(ctx) {
     return allow("Could not check PR status, skipping.");
   }
 }
+function requireNoConflictsBeforeStop(ctx) {
+  const cwd = ctx.session?.cwd;
+  if (!cwd)
+    return allow("No working directory available, skipping conflict check.");
+  const branch = getCurrentBranch(cwd);
+  if (!branch || branch === "HEAD")
+    return allow("Detached HEAD, skipping conflict check.");
+  const baseBranch = ctx.params?.baseBranch ?? "main";
+  if (branch === baseBranch) {
+    return allow(`On base branch "${baseBranch}", skipping conflict check.`);
+  }
+  let localSkipped = false;
+  try {
+    execFileSync("git", ["rev-parse", "--verify", `origin/${baseBranch}`], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 3000
+    });
+    const ahead = execFileSync("git", ["log", `origin/${baseBranch}..HEAD`, "--oneline"], { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 }).trim();
+    if (!ahead) {
+      localSkipped = true;
+    } else {
+      execFileSync("git", ["merge-tree", "--write-tree", "--name-only", `origin/${baseBranch}`, "HEAD"], { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 1e4 });
+    }
+  } catch (err) {
+    const e = err;
+    if (e.status === 1) {
+      const out = (typeof e.stdout === "string" ? e.stdout : e.stdout?.toString("utf8") ?? "").trim();
+      const lines = out.split(`
+`);
+      const files = [];
+      for (let i = 1;i < lines.length; i++) {
+        const line = lines[i];
+        if (line === "")
+          break;
+        files.push(line);
+      }
+      const fileList = files.length ? files.join(", ") : "one or more files";
+      return deny(`Branch "${branch}" has merge conflicts with ${baseBranch} in: ${fileList}. ` + `Rebase or merge origin/${baseBranch} now and resolve the conflicts.`);
+    }
+    localSkipped = true;
+  }
+  try {
+    execSync("gh --version", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+  } catch {
+    return allow(localSkipped ? "Local conflict check skipped and gh CLI not installed, skipping conflict check." : `Branch "${branch}" merges cleanly with ${baseBranch} locally (gh CLI not installed, PR mergeability not verified).`);
+  }
+  let prJson;
+  try {
+    prJson = execSync("gh pr view --json mergeable,number,url,state", {
+      cwd,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 15000
+    }).trim();
+  } catch {
+    return allow(localSkipped ? "No pull request found for branch, skipping conflict check." : `Branch "${branch}" merges cleanly with ${baseBranch} locally (no PR to verify against).`);
+  }
+  let pr;
+  try {
+    pr = JSON.parse(prJson);
+  } catch {
+    return allow("Could not parse gh pr view output, skipping PR mergeability check.");
+  }
+  if (pr.state !== "OPEN") {
+    return allow(`PR #${pr.number} is ${pr.state.toLowerCase()}; skipping conflict check.`);
+  }
+  if (pr.mergeable === "CONFLICTING") {
+    return deny(`PR #${pr.number} has merge conflicts per GitHub (${pr.url}). ` + `Rebase or merge origin/${baseBranch} now and resolve the conflicts.`);
+  }
+  if (pr.mergeable === "UNKNOWN") {
+    return deny(`GitHub is still computing mergeability for PR #${pr.number} (${pr.url}). ` + `Wait ~10 seconds, then re-check with \`gh pr view --json mergeable\` before attempting to stop again.`);
+  }
+  return allow(`PR #${pr.number} merges cleanly per GitHub.`);
+}
 function requireCiGreenBeforeStop(ctx) {
   const cwd = ctx.session?.cwd;
   if (!cwd)
@@ -1091,9 +1171,9 @@ function requireCiGreenBeforeStop(ctx) {
   }
 }
 function registerBuiltinPolicies(enabledNames) {
-  const enabledSet = new Set(enabledNames);
+  const enabledSet = new Set(enabledNames.map(normalizePolicyName));
   for (const policy of BUILTIN_POLICIES) {
-    if (enabledSet.has(policy.name)) {
+    if (enabledSet.has(normalizePolicyName(policy.name))) {
       registerPolicy(policy.name, policy.description, policy.fn, policy.match);
     }
   }
@@ -1502,6 +1582,21 @@ var init_builtin_policies = __esm(() => {
         }
       }
     },
+    {
+      name: "require-no-conflicts-before-stop",
+      description: "Require the current branch to merge cleanly with the base branch before Claude stops",
+      fn: requireNoConflictsBeforeStop,
+      match: { events: ["Stop"] },
+      defaultEnabled: false,
+      category: "Workflow",
+      params: {
+        baseBranch: {
+          type: "string",
+          description: "Base branch to check for conflicts against (default: main)",
+          default: "main"
+        }
+      }
+    },
     {
       name: "require-ci-green-before-stop",
       description: "Require CI checks to pass on the current branch before Claude stops",
@@ -1523,6 +1618,17 @@ function appendHint(baseReason, hint) {
     return normalizedHint;
   return `${base}. ${normalizedHint}`;
 }
+function getConfigParamsFor(config, canonicalName) {
+  if (!config?.policyParams)
+    return;
+  const canonicalParams = config.policyParams[canonicalName];
+  if (canonicalParams)
+    return canonicalParams;
+  const defaultPrefix = `${DEFAULT_POLICY_NAMESPACE}/`;
+  if (!canonicalName.startsWith(defaultPrefix))
+    return;
+  return config.policyParams[canonicalName.slice(defaultPrefix.length)];
+}
 async function evaluatePolicies(eventType, payload, session, config) {
   const toolName = payload.tool_name;
   const toolInput = payload.tool_input;
@@ -1544,7 +1650,7 @@ async function evaluatePolicies(eventType, payload, session, config) {
     const schema = POLICY_PARAMS_MAP.get(policy.name);
     let ctx;
     if (schema) {
-      const userParams = config?.policyParams?.[policy.name] ?? {};
+      const userParams = getConfigParamsFor(config, policy.name) ?? {};
       const resolvedParams = {};
       for (const [key, spec] of Object.entries(schema)) {
         resolvedParams[key] = key in userParams ? userParams[key] : spec.default;
@@ -1561,7 +1667,7 @@ async function evaluatePolicies(eventType, payload, session, config) {
       continue;
     }
     if (result.decision === "deny") {
-      const reason = appendHint(result.reason ?? `Blocked by policy: ${policy.name}`, config?.policyParams?.[policy.name]?.hint);
+      const reason = appendHint(result.reason ?? `Blocked by policy: ${policy.name}`, getConfigParamsFor(config, policy.name)?.hint);
       hookLogInfo(`deny by "${policy.name}": ${reason}`);
       const displayTool = ctx.toolName ?? "unknown tool";
       if (eventType === "PreToolUse") {
@@ -1619,7 +1725,7 @@ You MUST complete the above action NOW. Do NOT ask the user for confirmation —
       };
     }
     if (result.decision === "instruct") {
-      const reason = appendHint(result.reason ?? `Instruction from policy: ${policy.name}`, config?.policyParams?.[policy.name]?.hint);
+      const reason = appendHint(result.reason ?? `Instruction from policy: ${policy.name}`, getConfigParamsFor(config, policy.name)?.hint);
       instructEntries.push({ policyName: policy.name, reason });
       hookLogInfo(`instruct by "${policy.name}": ${reason}`);
     }
@@ -1678,7 +1784,7 @@ var POLICY_PARAMS_MAP;
 var init_policy_evaluator = __esm(() => {
   init_builtin_policies();
   init_hook_logger();
-  POLICY_PARAMS_MAP = new Map(BUILTIN_POLICIES.filter((p) => p.params).map((p) => [p.name, p.params]));
+  POLICY_PARAMS_MAP = new Map(BUILTIN_POLICIES.filter((p) => p.params).map((p) => [normalizePolicyName(p.name), p.params]));
 });
 
 // src/hooks/custom-hooks-registry.ts
@@ -2065,7 +2171,7 @@ var init_hook_activity_store = __esm(() => {
 });
 
 // package.json
-var version2 = "0.0.6-beta.4";
+var version2 = "0.0.6";
 var init_package = () => {};
 
 // src/posthog-key.ts
@@ -4378,7 +4484,7 @@ import { realpathSync as realpathSync2 } from "fs";
 import { dirname as dirname7, resolve as resolve8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 // package.json
-var version = "0.0.6-beta.4";
+var version = "0.0.6";
 
 // bin/failproofai.mjs
 if (!process.env.FAILPROOFAI_PACKAGE_ROOT) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "failproofai",
-  "version": "0.0.6-beta.4",
+  "version": "0.0.6",
   "description": "The easiest way to manage policies that keep your AI agents reliable, on-task, and running autonomously — for Claude Code & the Agents SDK",
   "bin": {
     "failproofai": "./dist/cli.mjs"

package/src/hooks/builtin-policies.ts

@@ -7,7 +7,7 @@ import { execSync, execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import type { BuiltinPolicyDefinition, PolicyContext, PolicyResult, PolicyParamsSchema } from "./policy-types";
 import { allow, deny, instruct } from "./policy-helpers";
-import { registerPolicy } from "./policy-registry";
+import { normalizePolicyName, registerPolicy } from "./policy-registry";
 import { hookLogWarn } from "./hook-logger";
 
 function isClaudeInternalPath(resolved: string): boolean {
@@ -1185,6 +1185,114 @@ function requirePrBeforeStop(ctx: PolicyContext): PolicyResult {
   }
 }
 
+function requireNoConflictsBeforeStop(ctx: PolicyContext): PolicyResult {
+  const cwd = ctx.session?.cwd;
+  if (!cwd) return allow("No working directory available, skipping conflict check.");
+
+  const branch = getCurrentBranch(cwd);
+  if (!branch || branch === "HEAD") return allow("Detached HEAD, skipping conflict check.");
+
+  const baseBranch = (ctx.params?.baseBranch as string) ?? "main";
+  if (branch === baseBranch) {
+    return allow(`On base branch "${baseBranch}", skipping conflict check.`);
+  }
+
+  // -- Layer 1: local git merge-tree --
+  let localSkipped = false;
+  try {
+    execFileSync("git", ["rev-parse", "--verify", `origin/${baseBranch}`], {
+      cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3000,
+    });
+
+    const ahead = execFileSync(
+      "git", ["log", `origin/${baseBranch}..HEAD`, "--oneline"],
+      { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 5000 },
+    ).trim();
+
+    if (!ahead) {
+      // Nothing ahead of base — Layer 1 doesn't apply, fall through to Layer 2.
+      localSkipped = true;
+    } else {
+      execFileSync(
+        "git",
+        ["merge-tree", "--write-tree", "--name-only", `origin/${baseBranch}`, "HEAD"],
+        { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 10000 },
+      );
+      // exit 0 → clean merge, fall through to Layer 2
+    }
+  } catch (err) {
+    const e = err as { status?: number; stdout?: string | Buffer };
+    if (e.status === 1) {
+      // git merge-tree exit 1 = conflicts. stdout: <tree>\n<file>\n<file>\n\n<messages>
+      const out = (typeof e.stdout === "string" ? e.stdout : e.stdout?.toString("utf8") ?? "").trim();
+      const lines = out.split("\n");
+      const files: string[] = [];
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line === "") break;
+        files.push(line);
+      }
+      const fileList = files.length ? files.join(", ") : "one or more files";
+      return deny(
+        `Branch "${branch}" has merge conflicts with ${baseBranch} in: ${fileList}. ` +
+        `Rebase or merge origin/${baseBranch} now and resolve the conflicts.`,
+      );
+    }
+    localSkipped = true;
+  }
+
+  // -- Layer 2: GitHub PR mergeability --
+  try {
+    execSync("gh --version", { cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3000 });
+  } catch {
+    return allow(
+      localSkipped
+        ? "Local conflict check skipped and gh CLI not installed, skipping conflict check."
+        : `Branch "${branch}" merges cleanly with ${baseBranch} locally (gh CLI not installed, PR mergeability not verified).`,
+    );
+  }
+
+  let prJson: string;
+  try {
+    prJson = execSync("gh pr view --json mergeable,number,url,state", {
+      cwd, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 15000,
+    }).trim();
+  } catch {
+    return allow(
+      localSkipped
+        ? "No pull request found for branch, skipping conflict check."
+        : `Branch "${branch}" merges cleanly with ${baseBranch} locally (no PR to verify against).`,
+    );
+  }
+
+  let pr: { mergeable: string; number: number; url: string; state: string };
+  try {
+    pr = JSON.parse(prJson);
+  } catch {
+    return allow("Could not parse gh pr view output, skipping PR mergeability check.");
+  }
+
+  // GitHub stops computing mergeability for non-OPEN PRs (returns UNKNOWN forever).
+  // Skip the check entirely so a merged or closed PR doesn't trap Stop in a wait loop.
+  if (pr.state !== "OPEN") {
+    return allow(`PR #${pr.number} is ${pr.state.toLowerCase()}; skipping conflict check.`);
+  }
+
+  if (pr.mergeable === "CONFLICTING") {
+    return deny(
+      `PR #${pr.number} has merge conflicts per GitHub (${pr.url}). ` +
+      `Rebase or merge origin/${baseBranch} now and resolve the conflicts.`,
+    );
+  }
+  if (pr.mergeable === "UNKNOWN") {
+    return deny(
+      `GitHub is still computing mergeability for PR #${pr.number} (${pr.url}). ` +
+      `Wait ~10 seconds, then re-check with \`gh pr view --json mergeable\` before attempting to stop again.`,
+    );
+  }
+  return allow(`PR #${pr.number} merges cleanly per GitHub.`);
+}
+
 function requireCiGreenBeforeStop(ctx: PolicyContext): PolicyResult {
   const cwd = ctx.session?.cwd;
   if (!cwd) return allow("No working directory available, skipping CI check.");
@@ -1590,6 +1698,21 @@ export const BUILTIN_POLICIES: BuiltinPolicyDefinition[] = [
       },
     } satisfies PolicyParamsSchema,
   },
+  {
+    name: "require-no-conflicts-before-stop",
+    description: "Require the current branch to merge cleanly with the base branch before Claude stops",
+    fn: requireNoConflictsBeforeStop,
+    match: { events: ["Stop"] },
+    defaultEnabled: false,
+    category: "Workflow",
+    params: {
+      baseBranch: {
+        type: "string",
+        description: "Base branch to check for conflicts against (default: main)",
+        default: "main",
+      },
+    } satisfies PolicyParamsSchema,
+  },
   {
     name: "require-ci-green-before-stop",
     description: "Require CI checks to pass on the current branch before Claude stops",
@@ -1601,9 +1724,11 @@ export const BUILTIN_POLICIES: BuiltinPolicyDefinition[] = [
 ];
 
 export function registerBuiltinPolicies(enabledNames: string[]): void {
-  const enabledSet = new Set(enabledNames);
+  // Tolerate both flat ("sanitize-jwt") and qualified ("exospherehost/sanitize-jwt")
+  // forms in the user's enabledPolicies config — canonicalize both sides.
+  const enabledSet = new Set(enabledNames.map(normalizePolicyName));
   for (const policy of BUILTIN_POLICIES) {
-    if (enabledSet.has(policy.name)) {
+    if (enabledSet.has(normalizePolicyName(policy.name))) {
       registerPolicy(policy.name, policy.description, policy.fn, policy.match);
     }
   }

package/src/hooks/policy-evaluator.ts

@@ -5,7 +5,7 @@
 import type { HookEventType, SessionMetadata } from "./types";
 import type { PolicyContext, HooksConfig } from "./policy-types";
 import { BUILTIN_POLICIES } from "./builtin-policies";
-import { getPoliciesForEvent } from "./policy-registry";
+import { DEFAULT_POLICY_NAMESPACE, getPoliciesForEvent, normalizePolicyName } from "./policy-registry";
 import { hookLogInfo, hookLogWarn } from "./hook-logger";
 
 function appendHint(baseReason: string, hint: unknown): string {
@@ -26,11 +26,33 @@ export interface EvaluationResult {
   decision: "allow" | "deny" | "instruct";
 }
 
-// Build a map from policy name to its params schema (for injecting defaults)
+// Build a map from canonical policy name to its params schema (for injecting defaults).
+// Keyed by canonical name because registered policies always carry the canonical form.
 const POLICY_PARAMS_MAP = new Map(
-  BUILTIN_POLICIES.filter((p) => p.params).map((p) => [p.name, p.params!]),
+  BUILTIN_POLICIES.filter((p) => p.params).map((p) => [normalizePolicyName(p.name), p.params!]),
 );
 
+/**
+ * Look up policy params for a canonical policy name in the user config,
+ * tolerating either flat ("block-force-push") or qualified
+ * ("exospherehost/block-force-push") config keys for built-in policies.
+ *
+ * The flat-key fallback is intentionally limited to the default namespace
+ * so namespace isolation is preserved: `policyParams.foo` only matches
+ * `exospherehost/foo`, never `myorg/foo` or `custom/foo`.
+ */
+function getConfigParamsFor(
+  config: HooksConfig | undefined,
+  canonicalName: string,
+): Record<string, unknown> | undefined {
+  if (!config?.policyParams) return undefined;
+  const canonicalParams = config.policyParams[canonicalName];
+  if (canonicalParams) return canonicalParams;
+  const defaultPrefix = `${DEFAULT_POLICY_NAMESPACE}/`;
+  if (!canonicalName.startsWith(defaultPrefix)) return undefined;
+  return config.policyParams[canonicalName.slice(defaultPrefix.length)];
+}
+
 export async function evaluatePolicies(
   eventType: HookEventType,
   payload: Record<string, unknown>,
@@ -63,11 +85,13 @@ export async function evaluatePolicies(
   const allowEntries: Array<{ policyName: string; reason: string }> = [];
 
   for (const policy of policies) {
-    // Inject params: merge policyParams[policy.name] over schema defaults
+    // Inject params: merge policyParams[policy.name] over schema defaults.
+    // policy.name is canonical (e.g. "exospherehost/block-force-push"); user
+    // config keys may be flat or canonical — getConfigParamsFor accepts both.
     const schema = POLICY_PARAMS_MAP.get(policy.name);
     let ctx: PolicyContext;
     if (schema) {
-      const userParams = config?.policyParams?.[policy.name] ?? {};
+      const userParams = getConfigParamsFor(config, policy.name) ?? {};
       const resolvedParams: Record<string, unknown> = {};
       for (const [key, spec] of Object.entries(schema)) {
         resolvedParams[key] = key in userParams ? userParams[key] : spec.default;
@@ -89,7 +113,7 @@ export async function evaluatePolicies(
     if (result.decision === "deny") {
       const reason = appendHint(
         result.reason ?? `Blocked by policy: ${policy.name}`,
-        config?.policyParams?.[policy.name]?.hint,
+        getConfigParamsFor(config, policy.name)?.hint,
       );
       hookLogInfo(`deny by "${policy.name}": ${reason}`);
 
@@ -156,7 +180,7 @@ export async function evaluatePolicies(
     if (result.decision === "instruct") {
       const reason = appendHint(
         result.reason ?? `Instruction from policy: ${policy.name}`,
-        config?.policyParams?.[policy.name]?.hint,
+        getConfigParamsFor(config, policy.name)?.hint,
       );
       instructEntries.push({ policyName: policy.name, reason });
       hookLogInfo(`instruct by "${policy.name}": ${reason}`);

package/src/hooks/policy-registry.ts

@@ -11,6 +11,22 @@ import type { PolicyFunction, PolicyMatcher, RegisteredPolicy } from "./policy-t
 const REGISTRY_KEY = "__FAILPROOFAI_POLICY_REGISTRY__";
 const INDEX_CACHE_KEY = "__FAILPROOFAI_POLICY_INDEX_CACHE__";
 
+/**
+ * The default namespace applied to any policy name registered without a
+ * `<namespace>/` prefix. Builtins live under this namespace; custom hooks
+ * loaded by the handler get their own prefixes (e.g. `custom/foo`).
+ */
+export const DEFAULT_POLICY_NAMESPACE = "exospherehost";
+
+/**
+ * Canonicalize a policy name. If the name already contains a `/`, it is
+ * treated as already-namespaced and returned unchanged. Otherwise the
+ * default namespace is prepended.
+ */
+export function normalizePolicyName(name: string): string {
+  return name.includes("/") ? name : `${DEFAULT_POLICY_NAMESPACE}/${name}`;
+}
+
 interface GlobalWithRegistry {
   [REGISTRY_KEY]?: RegisteredPolicy[];
 }
@@ -42,9 +58,10 @@ export function registerPolicy(
   match: PolicyMatcher,
   priority: number = 0,
 ): void {
+  const canonical = normalizePolicyName(name);
   const registry = getRegistry();
-  const idx = registry.findIndex((p) => p.name === name);
-  const entry: RegisteredPolicy = { name, description, fn, match, priority };
+  const idx = registry.findIndex((p) => p.name === canonical);
+  const entry: RegisteredPolicy = { name: canonical, description, fn, match, priority };
   if (idx >= 0) {
     registry[idx] = entry;
   } else {