@plures/praxis 1.4.0 → 1.4.4

package/dist/browser/chunk-BQOYZBWA.js

@@ -0,0 +1,282 @@
+import {
+  RuleResult,
+  fact
+} from "./chunk-IG5BJ2MT.js";
+
+// src/project/project.ts
+function defineGate(name, config) {
+  const { expects, onSatisfied, onViolation } = config;
+  const rule = {
+    id: `gate/${name}`,
+    description: `Feature gate: ${name} \u2014 requires: ${expects.join(", ")}`,
+    eventTypes: ["gate.check", `gate.${name}.check`],
+    contract: {
+      ruleId: `gate/${name}`,
+      behavior: `Opens gate "${name}" when all expectations are met: ${expects.join(", ")}`,
+      examples: [
+        {
+          given: `all expectations satisfied: ${expects.join(", ")}`,
+          when: "gate checked",
+          then: `gate.${name}.open emitted${onSatisfied ? ` \u2192 ${onSatisfied}` : ""}`
+        },
+        {
+          given: "one or more expectations unsatisfied",
+          when: "gate checked",
+          then: `gate.${name}.blocked emitted${onViolation ? ` \u2192 ${onViolation}` : ""}`
+        }
+      ],
+      invariants: [
+        `Gate "${name}" must never open with unsatisfied expectations`,
+        "Gate status must reflect current expectation state exactly"
+      ]
+    },
+    impl: (state, events) => {
+      const gateEvent = events.find(
+        (e) => e.tag === "gate.check" || e.tag === `gate.${name}.check`
+      );
+      if (!gateEvent) return RuleResult.skip("No gate check event");
+      const expectationState = state.context.expectations ?? {};
+      const satisfied = [];
+      const unsatisfied = [];
+      for (const exp of expects) {
+        if (expectationState[exp]) {
+          satisfied.push(exp);
+        } else {
+          unsatisfied.push(exp);
+        }
+      }
+      const status = unsatisfied.length === 0 ? "open" : "blocked";
+      const gateState = {
+        name,
+        status,
+        satisfied,
+        unsatisfied,
+        lastChanged: Date.now()
+      };
+      const facts = [fact(`gate.${name}.status`, gateState)];
+      if (status === "open" && onSatisfied) {
+        facts.push(fact(`gate.${name}.action`, { action: onSatisfied }));
+      } else if (status === "blocked" && onViolation) {
+        facts.push(fact(`gate.${name}.action`, { action: onViolation }));
+      }
+      return RuleResult.emit(facts);
+    }
+  };
+  const constraint = {
+    id: `gate/${name}/integrity`,
+    description: `Ensures gate "${name}" status matches expectation reality`,
+    contract: {
+      ruleId: `gate/${name}/integrity`,
+      behavior: `Validates that gate "${name}" is not open when expectations are unmet`,
+      examples: [
+        {
+          given: `gate ${name} is open but expectations unmet`,
+          when: "constraint checked",
+          then: "violation"
+        }
+      ],
+      invariants: [`Gate "${name}" must never report open when expectations are unsatisfied`]
+    },
+    impl: (state) => {
+      const gateState = state.context.gates?.[name];
+      if (!gateState) return true;
+      if (gateState.status === "open" && gateState.unsatisfied.length > 0) {
+        return `Gate "${name}" is open but has unsatisfied expectations: ${gateState.unsatisfied.join(", ")}`;
+      }
+      return true;
+    }
+  };
+  return { rules: [rule], constraints: [constraint] };
+}
+function semverContract(config) {
+  const { sources, invariants } = config;
+  const rule = {
+    id: "project/semver-check",
+    description: `Checks version consistency across: ${sources.join(", ")}`,
+    eventTypes: ["project.version-check"],
+    contract: {
+      ruleId: "project/semver-check",
+      behavior: `Verifies version consistency across ${sources.length} sources`,
+      examples: [
+        {
+          given: "all sources have version 1.2.3",
+          when: "version check runs",
+          then: "semver.consistent emitted"
+        },
+        {
+          given: "package.json has 1.2.3 but README has 1.2.2",
+          when: "version check runs",
+          then: "semver.inconsistent emitted with diff"
+        }
+      ],
+      invariants: invariants.length > 0 ? invariants : ["All version sources must report the same semver string"]
+    },
+    impl: (_state, events) => {
+      const checkEvent = events.find((e) => e.tag === "project.version-check");
+      if (!checkEvent) return RuleResult.skip("No version check event");
+      const versions = checkEvent.payload?.versions ?? {};
+      const versionValues = Object.values(versions);
+      const unique = new Set(versionValues);
+      if (unique.size <= 1) {
+        return RuleResult.emit([
+          fact("semver.consistent", {
+            version: versionValues[0] ?? "unknown",
+            sources: Object.keys(versions)
+          })
+        ]);
+      }
+      const report = {
+        consistent: false,
+        versions,
+        violations: [`Version mismatch: ${JSON.stringify(versions)}`]
+      };
+      return RuleResult.emit([fact("semver.inconsistent", report)]);
+    }
+  };
+  return { rules: [rule], constraints: [] };
+}
+function commitFromState(diff) {
+  const parts = [];
+  const bodyParts = [];
+  const totalAdded = diff.rulesAdded.length + diff.contractsAdded.length + diff.expectationsAdded.length;
+  const totalRemoved = diff.rulesRemoved.length + diff.contractsRemoved.length + diff.expectationsRemoved.length;
+  const totalModified = diff.rulesModified.length;
+  const hasGateChanges = diff.gateChanges.length > 0;
+  if (totalAdded > 0 && totalRemoved === 0 && totalModified === 0) {
+    if (diff.rulesAdded.length > 0) {
+      const scope = inferScope(diff.rulesAdded);
+      parts.push(`feat(${scope}): add ${formatIds(diff.rulesAdded)}`);
+    } else if (diff.contractsAdded.length > 0) {
+      parts.push(`feat(contracts): add contracts for ${formatIds(diff.contractsAdded)}`);
+    } else {
+      parts.push(`feat(expectations): add ${formatIds(diff.expectationsAdded)}`);
+    }
+  } else if (totalRemoved > 0 && totalAdded === 0) {
+    if (diff.rulesRemoved.length > 0) {
+      const scope = inferScope(diff.rulesRemoved);
+      parts.push(`refactor(${scope}): remove ${formatIds(diff.rulesRemoved)}`);
+    } else {
+      parts.push(`refactor: remove ${totalRemoved} item(s)`);
+    }
+  } else if (totalModified > 0) {
+    const scope = inferScope(diff.rulesModified);
+    parts.push(`refactor(${scope}): update ${formatIds(diff.rulesModified)}`);
+  } else if (hasGateChanges) {
+    const gateNames = diff.gateChanges.map((g) => g.gate);
+    parts.push(`chore(gates): ${formatIds(gateNames)} state changed`);
+  } else {
+    parts.push("chore: behavioral state update");
+  }
+  if (diff.rulesAdded.length > 0) bodyParts.push(`Rules added: ${diff.rulesAdded.join(", ")}`);
+  if (diff.rulesRemoved.length > 0) bodyParts.push(`Rules removed: ${diff.rulesRemoved.join(", ")}`);
+  if (diff.rulesModified.length > 0) bodyParts.push(`Rules modified: ${diff.rulesModified.join(", ")}`);
+  if (diff.contractsAdded.length > 0) bodyParts.push(`Contracts added: ${diff.contractsAdded.join(", ")}`);
+  if (diff.contractsRemoved.length > 0) bodyParts.push(`Contracts removed: ${diff.contractsRemoved.join(", ")}`);
+  if (diff.expectationsAdded.length > 0) bodyParts.push(`Expectations added: ${diff.expectationsAdded.join(", ")}`);
+  if (diff.expectationsRemoved.length > 0) bodyParts.push(`Expectations removed: ${diff.expectationsRemoved.join(", ")}`);
+  for (const gc of diff.gateChanges) {
+    bodyParts.push(`Gate "${gc.gate}": ${gc.from} \u2192 ${gc.to}`);
+  }
+  const subject = parts[0] || "chore: update";
+  return bodyParts.length > 0 ? `${subject}
+
+${bodyParts.join("\n")}` : subject;
+}
+function inferScope(ids) {
+  if (ids.length === 0) return "rules";
+  const prefixes = ids.map((id) => {
+    const slash = id.indexOf("/");
+    return slash > 0 ? id.slice(0, slash) : id;
+  });
+  const unique = new Set(prefixes);
+  return unique.size === 1 ? prefixes[0] : "rules";
+}
+function formatIds(ids) {
+  if (ids.length <= 3) return ids.join(", ");
+  return `${ids.slice(0, 2).join(", ")} (+${ids.length - 2} more)`;
+}
+function branchRules(config) {
+  const { naming, mergeConditions } = config;
+  const namePattern = naming.replace("{name}", "(.+)").replace("{issue}", "(\\d+)");
+  const nameRegex = new RegExp(`^${namePattern}$`);
+  const rule = {
+    id: "project/branch-check",
+    description: `Validates branch naming (${naming}) and merge conditions`,
+    eventTypes: ["project.branch-check"],
+    contract: {
+      ruleId: "project/branch-check",
+      behavior: `Ensures branch follows "${naming}" pattern and merge conditions are met`,
+      examples: [
+        {
+          given: `branch named "${naming.replace("{name}", "my-feature")}"`,
+          when: "branch checked",
+          then: "branch.valid emitted"
+        },
+        {
+          given: 'branch named "random-name"',
+          when: "branch checked",
+          then: "branch.invalid emitted"
+        }
+      ],
+      invariants: [
+        `Branch names must follow pattern: ${naming}`,
+        `Merge requires: ${mergeConditions.join(", ")}`
+      ]
+    },
+    impl: (_state, events) => {
+      const checkEvent = events.find((e) => e.tag === "project.branch-check");
+      if (!checkEvent) return RuleResult.skip("No branch check event");
+      const payload = checkEvent.payload;
+      const branch = payload.branch ?? "";
+      const conditions = payload.conditions ?? {};
+      const validName = nameRegex.test(branch);
+      const unmetConditions = mergeConditions.filter((c) => !conditions[c]);
+      if (validName && unmetConditions.length === 0) {
+        return RuleResult.emit([
+          fact("branch.valid", { branch, mergeReady: true })
+        ]);
+      }
+      const reasons = [];
+      if (!validName) reasons.push(`Branch name "${branch}" doesn't match pattern "${naming}"`);
+      if (unmetConditions.length > 0) reasons.push(`Unmet merge conditions: ${unmetConditions.join(", ")}`);
+      return RuleResult.emit([
+        fact("branch.invalid", { branch, reasons, mergeReady: false })
+      ]);
+    }
+  };
+  return { rules: [rule], constraints: [] };
+}
+function lintGate(config = {}) {
+  const expects = ["lint-passes", ...config.additionalExpects ?? []];
+  return defineGate("lint", {
+    expects,
+    onSatisfied: "lint-passed",
+    onViolation: "lint-failed"
+  });
+}
+function formatGate(config = {}) {
+  const expects = ["format-passes", ...config.additionalExpects ?? []];
+  return defineGate("format", {
+    expects,
+    onSatisfied: "format-passed",
+    onViolation: "format-failed"
+  });
+}
+function expectationGate(config = {}) {
+  const expects = ["expectations-verified", ...config.additionalExpects ?? []];
+  return defineGate("expectations", {
+    expects,
+    onSatisfied: "expectations-passed",
+    onViolation: "expectations-failed"
+  });
+}
+
+export {
+  defineGate,
+  semverContract,
+  commitFromState,
+  branchRules,
+  lintGate,
+  formatGate,
+  expectationGate
+};

package/dist/browser/chunk-IG5BJ2MT.js

@@ -0,0 +1,91 @@
+// src/core/rule-result.ts
+var RuleResult = class _RuleResult {
+  /** The kind of result */
+  kind;
+  /** Facts produced (only for 'emit') */
+  facts;
+  /** Fact tags to retract (only for 'retract') */
+  retractTags;
+  /** Optional reason (for noop/skip/retract — useful for debugging) */
+  reason;
+  /** The rule ID that produced this result (set by engine) */
+  ruleId;
+  constructor(kind, facts, retractTags, reason) {
+    this.kind = kind;
+    this.facts = facts;
+    this.retractTags = retractTags;
+    this.reason = reason;
+  }
+  /**
+   * Rule produced facts.
+   *
+   * @example
+   * return RuleResult.emit([
+   *   { tag: 'sprint.behind', payload: { deficit: 5 } }
+   * ]);
+   */
+  static emit(facts) {
+    if (facts.length === 0) {
+      throw new Error(
+        "RuleResult.emit() requires at least one fact. Use RuleResult.noop() or RuleResult.skip() when a rule has nothing to say."
+      );
+    }
+    return new _RuleResult("emit", facts, []);
+  }
+  /**
+   * Rule evaluated but had nothing to report.
+   * Unlike returning [], this is explicit and traceable.
+   *
+   * @example
+   * if (ctx.completedHours >= expectedHours) {
+   *   return RuleResult.noop('Sprint is on pace');
+   * }
+   */
+  static noop(reason) {
+    return new _RuleResult("noop", [], [], reason);
+  }
+  /**
+   * Rule decided to skip because preconditions were not met.
+   * Distinct from noop: skip means "I can't evaluate", noop means "I evaluated and found nothing".
+   *
+   * @example
+   * if (!ctx.sprintName) {
+   *   return RuleResult.skip('No active sprint');
+   * }
+   */
+  static skip(reason) {
+    return new _RuleResult("skip", [], [], reason);
+  }
+  /**
+   * Rule retracts previously emitted facts by tag.
+   * Used when a condition that previously produced facts is no longer true.
+   *
+   * @example
+   * // Sprint was behind, but caught up
+   * if (ctx.completedHours >= expectedHours) {
+   *   return RuleResult.retract(['sprint.behind'], 'Sprint caught up');
+   * }
+   */
+  static retract(tags, reason) {
+    if (tags.length === 0) {
+      throw new Error("RuleResult.retract() requires at least one tag.");
+    }
+    return new _RuleResult("retract", [], tags, reason);
+  }
+  /** Whether this result produced facts */
+  get hasFacts() {
+    return this.facts.length > 0;
+  }
+  /** Whether this result retracts facts */
+  get hasRetractions() {
+    return this.retractTags.length > 0;
+  }
+};
+function fact(tag, payload) {
+  return { tag, payload };
+}
+
+export {
+  RuleResult,
+  fact
+};

package/dist/browser/{chunk-MJK3IYTJ.js → chunk-JZDJU2DO.js}

@@ -1,90 +1,10 @@
+import {
+  RuleResult
+} from "./chunk-IG5BJ2MT.js";
+
 // src/core/protocol.ts
 var PRAXIS_PROTOCOL_VERSION = "1.0.0";
 
-// src/core/rule-result.ts
-var RuleResult = class _RuleResult {
-  /** The kind of result */
-  kind;
-  /** Facts produced (only for 'emit') */
-  facts;
-  /** Fact tags to retract (only for 'retract') */
-  retractTags;
-  /** Optional reason (for noop/skip/retract — useful for debugging) */
-  reason;
-  /** The rule ID that produced this result (set by engine) */
-  ruleId;
-  constructor(kind, facts, retractTags, reason) {
-    this.kind = kind;
-    this.facts = facts;
-    this.retractTags = retractTags;
-    this.reason = reason;
-  }
-  /**
-   * Rule produced facts.
-   *
-   * @example
-   * return RuleResult.emit([
-   *   { tag: 'sprint.behind', payload: { deficit: 5 } }
-   * ]);
-   */
-  static emit(facts) {
-    if (facts.length === 0) {
-      throw new Error(
-        "RuleResult.emit() requires at least one fact. Use RuleResult.noop() or RuleResult.skip() when a rule has nothing to say."
-      );
-    }
-    return new _RuleResult("emit", facts, []);
-  }
-  /**
-   * Rule evaluated but had nothing to report.
-   * Unlike returning [], this is explicit and traceable.
-   *
-   * @example
-   * if (ctx.completedHours >= expectedHours) {
-   *   return RuleResult.noop('Sprint is on pace');
-   * }
-   */
-  static noop(reason) {
-    return new _RuleResult("noop", [], [], reason);
-  }
-  /**
-   * Rule decided to skip because preconditions were not met.
-   * Distinct from noop: skip means "I can't evaluate", noop means "I evaluated and found nothing".
-   *
-   * @example
-   * if (!ctx.sprintName) {
-   *   return RuleResult.skip('No active sprint');
-   * }
-   */
-  static skip(reason) {
-    return new _RuleResult("skip", [], [], reason);
-  }
-  /**
-   * Rule retracts previously emitted facts by tag.
-   * Used when a condition that previously produced facts is no longer true.
-   *
-   * @example
-   * // Sprint was behind, but caught up
-   * if (ctx.completedHours >= expectedHours) {
-   *   return RuleResult.retract(['sprint.behind'], 'Sprint caught up');
-   * }
-   */
-  static retract(tags, reason) {
-    if (tags.length === 0) {
-      throw new Error("RuleResult.retract() requires at least one tag.");
-    }
-    return new _RuleResult("retract", [], tags, reason);
-  }
-  /** Whether this result produced facts */
-  get hasFacts() {
-    return this.facts.length > 0;
-  }
-  /** Whether this result retracts facts */
-  get hasRetractions() {
-    return this.retractTags.length > 0;
-  }
-};
-
 // src/core/engine.ts
 function safeClone(value) {
   if (value === null || typeof value !== "object") {