@plures/praxis 1.3.0 → 1.4.4

package/dist/node/chunk-2IUFZBH3.js

@@ -0,0 +1,87 @@
+// src/core/completeness.ts
+function auditCompleteness(manifest, registryRuleIds, registryConstraintIds, rulesWithContracts, config) {
+  const threshold = config?.threshold ?? 90;
+  const domainBranches = manifest.branches.filter((b) => b.kind === "domain");
+  const coveredDomain = domainBranches.filter((b) => b.coveredBy && registryRuleIds.includes(b.coveredBy));
+  const uncoveredDomain = domainBranches.filter((b) => !b.coveredBy || !registryRuleIds.includes(b.coveredBy));
+  const invariantBranches = manifest.branches.filter((b) => b.kind === "invariant");
+  const coveredInvariants = invariantBranches.filter((b) => b.coveredBy && registryConstraintIds.includes(b.coveredBy));
+  const uncoveredInvariants = invariantBranches.filter((b) => !b.coveredBy || !registryConstraintIds.includes(b.coveredBy));
+  const needContracts = manifest.rulesNeedingContracts;
+  const haveContracts = needContracts.filter((id) => rulesWithContracts.includes(id));
+  const missingContracts = needContracts.filter((id) => !rulesWithContracts.includes(id));
+  const neededFields = manifest.stateFields.filter((f) => f.usedByRule);
+  const coveredFields = neededFields.filter((f) => f.inContext);
+  const missingFields = neededFields.filter((f) => !f.inContext);
+  const coveredTransitions = manifest.transitions.filter((t) => t.eventTag);
+  const missingTransitions = manifest.transitions.filter((t) => !t.eventTag);
+  const ruleScore = domainBranches.length > 0 ? coveredDomain.length / domainBranches.length * 40 : 40;
+  const constraintScore = invariantBranches.length > 0 ? coveredInvariants.length / invariantBranches.length * 20 : 20;
+  const contractScore = needContracts.length > 0 ? haveContracts.length / needContracts.length * 15 : 15;
+  const contextScore = neededFields.length > 0 ? coveredFields.length / neededFields.length * 15 : 15;
+  const eventScore = manifest.transitions.length > 0 ? coveredTransitions.length / manifest.transitions.length * 10 : 10;
+  const score = Math.round(ruleScore + constraintScore + contractScore + contextScore + eventScore);
+  const rating = score >= 90 ? "complete" : score >= 70 ? "good" : score >= 50 ? "partial" : "incomplete";
+  const report = {
+    score,
+    rating,
+    rules: { total: domainBranches.length, covered: coveredDomain.length, uncovered: uncoveredDomain },
+    constraints: { total: invariantBranches.length, covered: coveredInvariants.length, uncovered: uncoveredInvariants },
+    contracts: { total: needContracts.length, withContracts: haveContracts.length, missing: missingContracts },
+    context: { total: neededFields.length, covered: coveredFields.length, missing: missingFields },
+    events: { total: manifest.transitions.length, covered: coveredTransitions.length, missing: missingTransitions }
+  };
+  if (config?.strict && score < threshold) {
+    throw new Error(`Praxis completeness ${score}/100 (${rating}) \u2014 below threshold ${threshold}. ${uncoveredDomain.length} uncovered rules, ${uncoveredInvariants.length} uncovered invariants, ${missingContracts.length} missing contracts.`);
+  }
+  return report;
+}
+function formatReport(report) {
+  const lines = [];
+  const icon = report.rating === "complete" ? "\u2705" : report.rating === "good" ? "\u{1F7E2}" : report.rating === "partial" ? "\u{1F7E1}" : "\u{1F534}";
+  lines.push(`${icon} Praxis Completeness: ${report.score}/100 (${report.rating})`);
+  lines.push("");
+  lines.push(`Rules:       ${report.rules.covered}/${report.rules.total} domain branches covered (${pct(report.rules.covered, report.rules.total)})`);
+  lines.push(`Constraints: ${report.constraints.covered}/${report.constraints.total} invariants covered (${pct(report.constraints.covered, report.constraints.total)})`);
+  lines.push(`Contracts:   ${report.contracts.withContracts}/${report.contracts.total} rules have contracts (${pct(report.contracts.withContracts, report.contracts.total)})`);
+  lines.push(`Context:     ${report.context.covered}/${report.context.total} state fields in context (${pct(report.context.covered, report.context.total)})`);
+  lines.push(`Events:      ${report.events.covered}/${report.events.total} transitions have events (${pct(report.events.covered, report.events.total)})`);
+  if (report.rules.uncovered.length > 0) {
+    lines.push("");
+    lines.push("Uncovered domain logic:");
+    for (const b of report.rules.uncovered) {
+      lines.push(`  \u274C ${b.location}: ${b.condition}${b.note ? ` \u2014 ${b.note}` : ""}`);
+    }
+  }
+  if (report.constraints.uncovered.length > 0) {
+    lines.push("");
+    lines.push("Uncovered invariants:");
+    for (const b of report.constraints.uncovered) {
+      lines.push(`  \u274C ${b.location}: ${b.condition}${b.note ? ` \u2014 ${b.note}` : ""}`);
+    }
+  }
+  if (report.contracts.missing.length > 0) {
+    lines.push("");
+    lines.push("Rules missing contracts:");
+    for (const id of report.contracts.missing) {
+      lines.push(`  \u{1F4DD} ${id}`);
+    }
+  }
+  if (report.events.missing.length > 0) {
+    lines.push("");
+    lines.push("State transitions without events:");
+    for (const t of report.events.missing) {
+      lines.push(`  \u26A1 ${t.location}: ${t.description}`);
+    }
+  }
+  return lines.join("\n");
+}
+function pct(a, b) {
+  if (b === 0) return "100%";
+  return Math.round(a / b * 100) + "%";
+}
+
+export {
+  auditCompleteness,
+  formatReport
+};

package/dist/node/{chunk-WZ6B3LZ6.js → chunk-7CSWBDFL.js}

@@ -1,55 +1,6 @@
-// src/decision-ledger/types.ts
-function isContract(obj) {
-  if (typeof obj !== "object" || obj === null) {
-    return false;
-  }
-  const contract = obj;
-  return typeof contract.ruleId === "string" && typeof contract.behavior === "string" && Array.isArray(contract.examples) && contract.examples.length > 0 && contract.examples.every(
-    (ex) => typeof ex === "object" && ex !== null && typeof ex.given === "string" && typeof ex.when === "string" && typeof ex.then === "string"
-  ) && Array.isArray(contract.invariants) && contract.invariants.every((inv) => typeof inv === "string");
-}
-function defineContract(options) {
-  if (options.examples.length === 0) {
-    throw new Error("Contract must have at least one example");
-  }
-  if (options.assumptions) {
-    for (const assumption of options.assumptions) {
-      if (assumption.confidence < 0 || assumption.confidence > 1) {
-        throw new Error(
-          `Assumption '${assumption.id}' has invalid confidence value ${assumption.confidence}. Must be between 0.0 and 1.0`
-        );
-      }
-    }
-  }
-  return {
-    ruleId: options.ruleId,
-    behavior: options.behavior,
-    examples: options.examples,
-    invariants: options.invariants,
-    assumptions: options.assumptions,
-    references: options.references,
-    version: options.version || "1.0.0",
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-}
-function getContract(meta) {
-  if (!meta || !meta.contract) {
-    return void 0;
-  }
-  if (isContract(meta.contract)) {
-    return meta.contract;
-  }
-  return void 0;
-}
-function getContractFromDescriptor(descriptor) {
-  if (!descriptor) {
-    return void 0;
-  }
-  if (descriptor.contract && isContract(descriptor.contract)) {
-    return descriptor.contract;
-  }
-  return getContract(descriptor.meta);
-}
+import {
+  defineContract
+} from "./chunk-PGVSB6NR.js";
 
 // src/decision-ledger/logic-ledger.ts
 import { createHash } from "crypto";
@@ -628,10 +579,6 @@ function generateDefaultAssumptions(descriptor) {
 }
 
 export {
-  isContract,
-  defineContract,
-  getContract,
-  getContractFromDescriptor,
   writeLogicLedgerEntry,
   scanRepository,
   generateContractFromRule