kibi-cli 0.12.8 → 0.16.1

package/dist/operations/modeling/predicate-inference-2.js

@@ -0,0 +1,169 @@
+import { normalizePredicateToken, slug } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function inferConflictResolutionRuleArgs(text) {
+    const conflict = text.match(/^when\s+(?<subject>.+?)\s+conflicts?,\s+(?:the\s+)?(?<strategy>.+?)\.?$/i);
+    return [
+        slug(conflict?.groups?.subject ?? "subject"),
+        normalizePredicateToken(conflict?.groups?.strategy ?? "strategy"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferFallbackRuleArgs(text) {
+    const fallback = text.match(/^if\s+(?<condition>.+?),\s+(?<subject>.+?)\s+(?:must|shall|should)\s+fall\s+back\s+to\s+(?<target>.+?)\.?$/i);
+    return [
+        normalizePredicateToken(fallback?.groups?.condition ?? "condition"),
+        slug(fallback?.groups?.subject ?? "subject"),
+        normalizePredicateToken(fallback?.groups?.target ?? "fallback"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferBatchOperationRuleArgs(text) {
+    const batch = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+process\s+(?<resource>.+?)\s+in\s+batches\s+of\s+(?<size>\d+)\.?$/i);
+    return [
+        slug(batch?.groups?.subject ?? "subject"),
+        slug(batch?.groups?.resource ?? "resource"),
+        batch?.groups?.size ?? "0",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferConsistencyRuleArgs(text) {
+    const consistency = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+reference\s+(?<target>an?\s+existing\s+.+?)\.?$/i);
+    return [
+        slug(consistency?.groups?.subject ?? "subject"),
+        normalizePredicateToken(consistency?.groups?.target ?? "target"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferBuildConstraintArgs(text) {
+    const build = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<property>deterministic)\s+at\s+(?<scope>build\s+time)\.?$/i);
+    return [
+        slug(build?.groups?.subject ?? "subject"),
+        normalizePredicateToken(build?.groups?.property ?? "property"),
+        normalizePredicateToken(build?.groups?.scope ?? "build_time"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferEnvironmentSafetyRuleArgs(text) {
+    const safety = text.match(/^(?<action>.+?)\s+(?:must|shall|should)\s+be\s+(?<decision>forbidden|read-only|allowed)\s+in\s+(?<environment>production|staging|development)\.?$/i);
+    return [
+        slug(safety?.groups?.action ?? "action"),
+        normalizePredicateToken(safety?.groups?.decision ?? "decision"),
+        slug(safety?.groups?.environment ?? "environment"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferSchemaInvariantRuleArgs(text) {
+    const invariant = text.match(/^(?<field>.+?)\s+(?:must|shall|should)\s+be\s+(?<kind>immutable)\s+after\s+(?<scope>.+?)\.?$/i);
+    return [
+        slug(invariant?.groups?.field ?? "field"),
+        normalizePredicateToken(invariant?.groups?.kind ?? "invariant"),
+        normalizePredicateToken(invariant?.groups?.scope ? `after ${invariant.groups.scope}` : "scope"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferCodingStandardRuleArgs(text) {
+    const standard = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+(?<action>use|avoid)\s+(?<target>.+?)\.?$/i);
+    return [
+        slug(standard?.groups?.subject ?? "subject"),
+        normalizePredicateToken(standard?.groups?.action ?? "action"),
+        normalizePredicateToken(standard?.groups?.target ?? "target"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferMigrationBoundaryRuleArgs(text) {
+    const migration = text.match(/^(?<subject>.+?)\s+may\s+only\s+be\s+(?<action>read)\s+as\s+(?<scope>migration\s+input)(?:\s+by\s+.+?)?\.?$/i);
+    return [
+        slug(migration?.groups?.subject ?? "legacy_input"),
+        normalizePredicateToken(migration?.groups?.action ?? "action"),
+        normalizePredicateToken(migration?.groups?.scope ?? "migration_input"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferAbsenceRequirementArgs(text) {
+    const absence = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<state>absent|removed)\.?$/i);
+    const declarativeAbsence = text.match(/^no\s+(?<subject>.+?)\.?$/i);
+    return [
+        normalizePredicateToken(absence?.groups?.subject ??
+            declarativeAbsence?.groups?.subject ??
+            "subject"),
+        normalizePredicateToken(absence?.groups?.state ?? "absent"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferOfflineBehaviorRuleArgs(text) {
+    const offline = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<behavior>non-blocking|resilient)\s+during\s+(?<condition>offline\s+conditions)\.?$/i);
+    return [
+        slug(offline?.groups?.subject ?? "subject"),
+        normalizePredicateToken(offline?.groups?.behavior ?? "behavior"),
+        normalizePredicateToken(offline?.groups?.condition ?? "offline_conditions"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferReleaseGateRuleArgs(text) {
+    const release = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+pass\s+(?<gate>.+?)\s+before\s+(?<target>.+?)\.?$/i);
+    return [
+        slug(release?.groups?.subject ?? "builds"),
+        normalizePredicateToken(release?.groups?.gate ?? "gate"),
+        slug(release?.groups?.target ?? "target"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferPlatformConsistencyRuleArgs(text) {
+    const platform = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+synchronize\s+across\s+(?<platforms>.+?)\.?$/i);
+    const platforms = (platform?.groups?.platforms ?? "platform")
+        .split(/,|\band\b/i)
+        .map((part) => slug(part.trim()))
+        .filter((part) => part.length > 0)
+        .join(",");
+    return [slug(platform?.groups?.subject ?? "subject"), platforms];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferPreservationRuleArgs(text) {
+    const preservation = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+preserve\s+(?<preserved>.+?)\s+when\s+(?:the\s+)?(?<condition>.+?)\.?$/i);
+    return [
+        slug(preservation?.groups?.subject ?? "subject"),
+        slug(preservation?.groups?.preserved ?? "preserved"),
+        normalizePredicateToken(preservation?.groups?.condition ?? "condition"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferAbstractionBoundaryRuleArgs(text) {
+    const boundary = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+persisted\s+as\s+(?<contract>.+?)\.?$/i);
+    return [
+        slug(boundary?.groups?.subject ?? "subject"),
+        "persisted_as",
+        normalizePredicateToken(boundary?.groups?.contract ?? "contract"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferSecurityConfigurationRuleArgs(text) {
+    const config = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+have\s+explicit\s+(?<setting>[A-Za-z0-9_.-]+)\s+(?<value>[A-Za-z0-9_.-]+)\.?$/i);
+    return [
+        slug(config?.groups?.subject ?? "subject"),
+        slug(config?.groups?.setting ?? "setting"),
+        slug(config?.groups?.value ?? "value"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferOrderedStrategyRuleArgs(text) {
+    const ordered = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+use\s+(?<kind>.+?)\s+in\s+priority\s+order\s+(?<values>.+?)\.?$/i);
+    const values = (ordered?.groups?.values ?? "")
+        .split(/,|>/)
+        .map((value) => normalizePredicateToken(value))
+        .filter((value) => value.length > 0)
+        .join(",");
+    return [
+        slug(ordered?.groups?.subject ?? "subject"),
+        slug(ordered?.groups?.kind ?? "strategy"),
+        values || "ordered_values",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferRefreshPolicyRuleArgs(text) {
+    const refresh = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+automatically\s+refresh\s+(?<target>.+?)\s+without\s+requiring\s+manual\s+page\s+reload\.?$/i);
+    return [
+        slug(refresh?.groups?.subject ?? "subject"),
+        slug(refresh?.groups?.target ?? "target"),
+        "automatic",
+    ];
+}

package/dist/operations/modeling/predicate-inference-3.d.ts

@@ -0,0 +1,15 @@
+export declare function inferScopedAuthorizationRuleArgs(text: string): string[];
+export declare function inferDocumentationStandardRuleArgs(text: string): string[];
+export declare function inferWarmupPolicyRuleArgs(text: string): string[];
+export declare function inferVisualLayoutRuleArgs(text: string): string[];
+export declare function inferEnforcementLocationRuleArgs(text: string): string[];
+export declare function inferReconciliationRuleArgs(text: string): string[];
+export declare function inferThrottlePolicyRuleArgs(text: string): string[];
+export declare function inferDefaultValueArgs(text: string, subject: string): string[];
+export declare function inferUniquenessArgs(text: string): string[];
+export declare function inferStateMembershipArgs(text: string, subject: string): string[];
+export declare function inferTemporalOrderArgs(text: string, subject: string): string[];
+export declare function inferConditionalBehaviorArgs(text: string, subject: string): string[];
+export declare function inferStateTransitionArgs(text: string, subject: string): string[];
+export declare function inferRateLimitArgs(text: string): string[];
+//# sourceMappingURL=predicate-inference-3.d.ts.map

package/dist/operations/modeling/predicate-inference-3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-inference-3.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-inference-3.ts"],"names":[],"mappings":"AASA,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASvE;AAGD,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASzE;AAGD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQhE;AAGD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAShE;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQvE;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAUlE;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQlE;AAGD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAW7E;AAGD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAW1D;AAGD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAgBV;AAGD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAsBV;AAGD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAsBV;AAGD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAYV;AAGD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAazD"}

package/dist/operations/modeling/predicate-inference-3.js

@@ -0,0 +1,163 @@
+import { inferTrigger, normalizePredicateToken, normalizeSubjectKey, singularize, slug, } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function inferScopedAuthorizationRuleArgs(text) {
+    const scoped = text.match(/^(?<actor>.+?)\s+(?:must|shall|should)\s+be\s+denied\s+(?<action>.+?)\.?$/i);
+    return [
+        slug(scoped?.groups?.actor ?? "actor"),
+        slug(scoped?.groups?.action ?? "action"),
+        "deny",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDocumentationStandardRuleArgs(text) {
+    const docs = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+documented\s+in\s+(?<artifact>.+?)\.?$/i);
+    return [
+        slug(docs?.groups?.subject ?? "subject"),
+        "documented_in",
+        slug(docs?.groups?.artifact ?? "documentation"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferWarmupPolicyRuleArgs(text) {
+    const warmup = text.match(/^(?:the\s+)?(?<subject>.+?)\s+(?:must|shall|should)\s+warm\s+up\s+on\s+(?<trigger>.+?)\.?$/i);
+    return [
+        slug(warmup?.groups?.subject ?? "subject"),
+        slug(warmup?.groups?.trigger ?? "trigger"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferVisualLayoutRuleArgs(text) {
+    const layout = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+remain\s+visually\s+aligned\s+with\s+(?<target>.+?)\.?$/i);
+    return [
+        slug(layout?.groups?.subject ?? "subject"),
+        "aligned_with",
+        slug(layout?.groups?.target ?? "target"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferEnforcementLocationRuleArgs(text) {
+    const enforcement = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+enforced\s+at\s+(?<location>.+?)\.?$/i);
+    return [
+        slug(enforcement?.groups?.subject ?? "subject"),
+        slug(enforcement?.groups?.location ?? "location"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferReconciliationRuleArgs(text) {
+    const reconciliation = text.match(/^on\s+(?<trigger>.+?),\s*(?<subject>.+?)\s+(?:must|shall|should)\s+reconcile\s+(?<target>.+?)\s+and\s+(?<action>clear\s+stale\s+.+?)\.?$/i);
+    return [
+        slug(reconciliation?.groups?.subject ?? "subject"),
+        slug(reconciliation?.groups?.trigger ?? "trigger"),
+        slug(reconciliation?.groups?.target ?? "target"),
+        slug(reconciliation?.groups?.action ?? "action"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferThrottlePolicyRuleArgs(text) {
+    const throttle = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+throttled\s+for\s+(?<condition>.+?)\.?$/i);
+    return [
+        slug(throttle?.groups?.subject ?? "subject"),
+        normalizePredicateToken(throttle?.groups?.condition ?? "condition"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDefaultValueArgs(text, subject) {
+    const defaultValue = text.match(/^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+defaults?\s+to\s+(?<value>[a-z][a-z0-9\s_-]*?)(?:\s+(?<property>mode|state|status))?\.?$/i);
+    return [
+        defaultValue?.groups?.subject
+            ? normalizeSubjectKey(defaultValue.groups.subject)
+            : subject,
+        slug(defaultValue?.groups?.property ?? "value"),
+        slug(defaultValue?.groups?.value ?? "value"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferUniquenessArgs(text) {
+    const uniqueness = text.match(/^(?:there\s+)?(?:must|shall|should)\s+be\s+at\s+most\s+one\s+(?<subject>[a-z][a-z\s_-]*?)\s+per\s+(?<scope>.+?)\.?$/i);
+    const scope = (uniqueness?.groups?.scope ?? "scope")
+        .split(/\s+per\s+/i)
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .map(normalizePredicateToken)
+        .join(",");
+    return [slug(uniqueness?.groups?.subject ?? "subject"), scope];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferStateMembershipArgs(text, subject) {
+    const stateMembership = text.match(/^(?<subject>.+?)\s+(?:terminal\s+)?states\s+are\s+(?<states>.+?)\.?$/i);
+    const states = (stateMembership?.groups?.states ?? "state")
+        .split(/,|\band\b|\bor\b/i)
+        .map((state) => state.trim())
+        .filter((state) => state.length > 0)
+        .map(normalizePredicateToken)
+        .join(",");
+    return [
+        stateMembership?.groups?.subject
+            ? normalizeSubjectKey(stateMembership.groups.subject)
+            : subject,
+        states,
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferTemporalOrderArgs(text, subject) {
+    const initializesAfter = text.match(/^(?:the\s+)?(?<subject>.+?)\s+initializes\s+after\s+(?:the\s+)?(?<ready>.+?)\s+is\s+ready\.?$/i);
+    if (initializesAfter?.groups?.subject && initializesAfter.groups.ready) {
+        return [
+            slug(initializesAfter.groups.subject),
+            `${slug(initializesAfter.groups.ready)}_ready`,
+            "initializes",
+        ];
+    }
+    const temporal = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<before>[a-z][a-z\s_-]*?)\s+before\s+(?<after>.+?)\.?$/i);
+    return [
+        temporal?.groups?.subject
+            ? slug(temporal.groups.subject).replace(/_/g, ".")
+            : subject,
+        normalizePredicateToken(temporal?.groups?.before ?? "before_event"),
+        normalizePredicateToken(temporal?.groups?.after ?? "after_event"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferConditionalBehaviorArgs(text, subject) {
+    const whenMust = text.match(/^when\s+(?<condition>.+?),\s*(?:the\s+)?(?<subject>.+?)\s+(?:must|shall|should)\s+(?<behavior>.+?)\.?$/i);
+    if (whenMust?.groups?.condition && whenMust.groups.subject) {
+        return [
+            slug(whenMust.groups.subject),
+            normalizePredicateToken(whenMust.groups.condition),
+            normalizePredicateToken(whenMust.groups.behavior ?? "behavior"),
+        ];
+    }
+    const conditional = text.match(/^if\s+(?:(?:a|an|the)\s+)?(?<conditionSubject>[a-z][a-z_-]*)\s+(?<condition>.+?),\s*(?:it|they|the\s+[a-z][a-z\s_-]*?)\s+(?<behavior>.+?)\.?$/i);
+    return [
+        conditional?.groups?.conditionSubject
+            ? singularize(slug(conditional.groups.conditionSubject))
+            : subject,
+        normalizePredicateToken(conditional?.groups?.condition ?? "condition"),
+        normalizePredicateToken(conditional?.groups?.behavior ?? "behavior"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferStateTransitionArgs(text, subject) {
+    const transition = text.match(/^when\s+(?<trigger>.+?),\s*(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+transitions?\s+from\s+(?<from>[a-z][a-z0-9_-]*)\s+to\s+(?<to>[a-z][a-z0-9_-]*)\.?$/i);
+    return [
+        transition?.groups?.subject
+            ? normalizeSubjectKey(transition.groups.subject)
+            : subject,
+        normalizePredicateToken(transition?.groups?.from ?? "from_state"),
+        normalizePredicateToken(transition?.groups?.to ?? "to_state"),
+        normalizePredicateToken(transition?.groups?.trigger ?? inferTrigger(text)),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferRateLimitArgs(text) {
+    const rateLimit = text.match(/^(?<subject>.+?)\s+must\s+be\s+rate\s+limited\s+to\s+(?<count>\d+)\s+(?<action>[a-z][a-z\s_-]*?)\s+per\s+(?<window>[a-z]+)\.?$/i);
+    const subject = rateLimit?.groups?.subject
+        ? slug(rateLimit.groups.subject).replace(/_requests?$/, ".request")
+        : "requirement.subject";
+    return [
+        subject,
+        normalizePredicateToken(rateLimit?.groups?.action ?? "action"),
+        normalizePredicateToken(rateLimit?.groups?.window ?? "window"),
+        rateLimit?.groups?.count ?? "0",
+    ];
+}

package/dist/operations/modeling/predicate-inference.d.ts

@@ -0,0 +1,5 @@
+import type { PredicateSchemaCandidate } from "./predicate-types.js";
+import { inferSubject } from "./predicate-utils.js";
+export declare function inferArgs(schema: PredicateSchemaCandidate, text: string, subject: string): string[];
+export { inferSubject };
+//# sourceMappingURL=predicate-inference.d.ts.map

package/dist/operations/modeling/predicate-inference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-inference.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-inference.ts"],"names":[],"mappings":"AAqDA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EASL,YAAY,EAIb,MAAM,sBAAsB,CAAC;AAG9B,wBAAgB,SAAS,CACvB,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CA8IV;AAGD,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/operations/modeling/predicate-inference.js

@@ -0,0 +1,148 @@
+import { inferAuditEventRuleArgs, inferAvailabilitySlaArgs, inferConsentRuleArgs, inferDataResidencyRuleArgs, inferDependencyRuleArgs, inferEscalationRuleArgs, inferExceptionRuleArgs, inferGuardArgs, inferIdempotencyRuleArgs, inferLifecycleRuleArgs, inferMutualExclusionArgs, inferNotificationRouteArgs, inferOwnershipRuleArgs, inferPermissionRuleArgs, inferRetryPolicyArgs, } from "./predicate-inference-1.js";
+import { inferAbsenceRequirementArgs, inferAbstractionBoundaryRuleArgs, inferBatchOperationRuleArgs, inferBuildConstraintArgs, inferCodingStandardRuleArgs, inferConflictResolutionRuleArgs, inferConsistencyRuleArgs, inferEnvironmentSafetyRuleArgs, inferFallbackRuleArgs, inferMigrationBoundaryRuleArgs, inferOfflineBehaviorRuleArgs, inferOrderedStrategyRuleArgs, inferPlatformConsistencyRuleArgs, inferPreservationRuleArgs, inferRefreshPolicyRuleArgs, inferReleaseGateRuleArgs, inferSchemaInvariantRuleArgs, inferSecurityConfigurationRuleArgs, } from "./predicate-inference-2.js";
+import { inferConditionalBehaviorArgs, inferDefaultValueArgs, inferDocumentationStandardRuleArgs, inferEnforcementLocationRuleArgs, inferRateLimitArgs, inferReconciliationRuleArgs, inferScopedAuthorizationRuleArgs, inferStateMembershipArgs, inferStateTransitionArgs, inferTemporalOrderArgs, inferThrottlePolicyRuleArgs, inferUniquenessArgs, inferVisualLayoutRuleArgs, inferWarmupPolicyRuleArgs, } from "./predicate-inference-3.js";
+import { inferDuration, inferDurationUnit, inferEvent, inferGate, inferNumber, inferOperator, inferResource, inferScope, inferSubject, inferTrigger, inferUnit, slug, } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function inferArgs(schema, text, subject) {
+    const lower = text.toLowerCase();
+    switch (schema.predicate_name) {
+        case "state":
+            return [subject, lower.includes("idle") ? "idle" : "active"];
+        case "transition":
+            return [
+                subject,
+                lower.includes("edit") ? "edit" : "draft",
+                lower.includes("idle") ? "idle" : "active",
+                inferTrigger(text),
+            ];
+        case "guard":
+            return inferGuardArgs(text, subject);
+        case "exception_rule":
+            return inferExceptionRuleArgs(text, subject);
+        case "mutual_exclusion":
+            return inferMutualExclusionArgs(text);
+        case "dependency_rule":
+            return inferDependencyRuleArgs(text);
+        case "ownership_rule":
+            return inferOwnershipRuleArgs(text);
+        case "retry_policy":
+            return inferRetryPolicyArgs(text);
+        case "escalation_rule":
+            return inferEscalationRuleArgs(text);
+        case "availability_sla":
+            return inferAvailabilitySlaArgs(text);
+        case "notification_route":
+            return inferNotificationRouteArgs(text);
+        case "idempotency_rule":
+            return inferIdempotencyRuleArgs(text);
+        case "data_residency_rule":
+            return inferDataResidencyRuleArgs(text);
+        case "audit_event_rule":
+            return inferAuditEventRuleArgs(text);
+        case "consent_rule":
+            return inferConsentRuleArgs(text);
+        case "lifecycle_rule":
+            return inferLifecycleRuleArgs(text);
+        case "conflict_resolution_rule":
+            return inferConflictResolutionRuleArgs(text);
+        case "fallback_rule":
+            return inferFallbackRuleArgs(text);
+        case "batch_operation_rule":
+            return inferBatchOperationRuleArgs(text);
+        case "consistency_rule":
+            return inferConsistencyRuleArgs(text);
+        case "build_constraint":
+            return inferBuildConstraintArgs(text);
+        case "environment_safety_rule":
+            return inferEnvironmentSafetyRuleArgs(text);
+        case "schema_invariant_rule":
+            return inferSchemaInvariantRuleArgs(text);
+        case "coding_standard_rule":
+            return inferCodingStandardRuleArgs(text);
+        case "migration_boundary_rule":
+            return inferMigrationBoundaryRuleArgs(text);
+        case "absence_requirement":
+            return inferAbsenceRequirementArgs(text);
+        case "offline_behavior_rule":
+            return inferOfflineBehaviorRuleArgs(text);
+        case "release_gate_rule":
+            return inferReleaseGateRuleArgs(text);
+        case "platform_consistency_rule":
+            return inferPlatformConsistencyRuleArgs(text);
+        case "preservation_rule":
+            return inferPreservationRuleArgs(text);
+        case "abstraction_boundary_rule":
+            return inferAbstractionBoundaryRuleArgs(text);
+        case "security_configuration_rule":
+            return inferSecurityConfigurationRuleArgs(text);
+        case "ordered_strategy_rule":
+            return inferOrderedStrategyRuleArgs(text);
+        case "refresh_policy_rule":
+            return inferRefreshPolicyRuleArgs(text);
+        case "scoped_authorization_rule":
+            return inferScopedAuthorizationRuleArgs(text);
+        case "documentation_standard_rule":
+            return inferDocumentationStandardRuleArgs(text);
+        case "warmup_policy_rule":
+            return inferWarmupPolicyRuleArgs(text);
+        case "visual_layout_rule":
+            return inferVisualLayoutRuleArgs(text);
+        case "enforcement_location_rule":
+            return inferEnforcementLocationRuleArgs(text);
+        case "reconciliation_rule":
+            return inferReconciliationRuleArgs(text);
+        case "throttle_policy_rule":
+            return inferThrottlePolicyRuleArgs(text);
+        case "has_unsaved_changes":
+            return [subject, lower.includes("no unsaved") ? "false" : "true"];
+        case "commit_action":
+        case "discard_action":
+            return [subject, inferTrigger(text), inferScope(text)];
+        case "accessibility_requirement":
+            return [
+                subject,
+                lower.includes("wcag") ? "WCAG" : "accessibility",
+                "required",
+            ];
+        case "retention_policy":
+            return [subject, inferDuration(text), inferDurationUnit(text)];
+        case "resource_constraint":
+            return [
+                subject,
+                inferResource(text),
+                inferOperator(text),
+                inferNumber(text),
+                inferUnit(text),
+            ];
+        case "feature_gate":
+            return [
+                subject,
+                inferGate(text),
+                lower.includes("disabled") ? "false" : "true",
+            ];
+        case "publishes_event":
+            return [subject, inferEvent(text)];
+        case "acceptance_rule":
+            return [subject, slug(text).slice(0, 64) || "observable_outcome"];
+        case "permission_rule":
+            return inferPermissionRuleArgs(text);
+        case "default_value":
+            return inferDefaultValueArgs(text, subject);
+        case "uniqueness_constraint":
+            return inferUniquenessArgs(text);
+        case "state_membership":
+            return inferStateMembershipArgs(text, subject);
+        case "temporal_order":
+            return inferTemporalOrderArgs(text, subject);
+        case "conditional_behavior":
+            return inferConditionalBehaviorArgs(text, subject);
+        case "state_transition":
+            return inferStateTransitionArgs(text, subject);
+        case "rate_limit":
+            return inferRateLimitArgs(text);
+        default:
+            return schema.argument_names.map((name) => name === "subject" ? subject : "unknown");
+    }
+}
+// implements REQ-mcp-suggest-predicates
+export { inferSubject };

package/dist/operations/modeling/predicate-loader.d.ts

@@ -0,0 +1,10 @@
+import type { PrologPort } from "../../public/operations/runtime-types.js";
+import type { PredicateSchemaCandidate, PredicateUsageHints } from "./predicate-types.js";
+export declare function schemaForCandidate(schema: PredicateSchemaCandidate): Omit<PredicateSchemaCandidate, "keywords"> & {
+    usage_hints: PredicateUsageHints;
+};
+export declare function loadExistingPredicateSchemas(prolog: PrologPort | null, includeExistingSchemas: boolean, warnings: string[]): Promise<PredicateSchemaCandidate[]>;
+export declare function predicateSchemaFromEntity(entity: Record<string, unknown>): PredicateSchemaCandidate[];
+export declare function usageHintsFromEntity(entity: Record<string, unknown>): PredicateUsageHints | undefined;
+export declare function stringArray(value: unknown): string[];
+//# sourceMappingURL=predicate-loader.d.ts.map

package/dist/operations/modeling/predicate-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-loader.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0CAA0C,CAAC;AAK3E,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAI9B,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,wBAAwB,GAAG,IAAI,CACxE,wBAAwB,EACxB,UAAU,CACX,GAAG;IACF,WAAW,EAAE,mBAAmB,CAAC;CAClC,CAeA;AAGD,wBAAsB,4BAA4B,CAChD,MAAM,EAAE,UAAU,GAAG,IAAI,EACzB,sBAAsB,EAAE,OAAO,EAC/B,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAwBrC;AAGD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,wBAAwB,EAAE,CA+B5B;AAGD,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,mBAAmB,GAAG,SAAS,CAOjC;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,EAAE,CAQpD"}

package/dist/operations/modeling/predicate-loader.js

@@ -0,0 +1,88 @@
+import { parseEntityFromList, parseListOfLists } from "../../prolog/codec.js";
+import { DEFAULT_USAGE_HINTS, USAGE_HINTS_BY_PREDICATE, } from "./predicate-catalog.js";
+import { hashId, normalizeOptionalString } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function schemaForCandidate(schema) {
+    return {
+        id: schema.id,
+        predicate_name: schema.predicate_name,
+        title: schema.title,
+        description: schema.description,
+        argument_names: schema.argument_names,
+        argument_types: schema.argument_types,
+        examples: schema.examples,
+        tags: schema.tags,
+        usage_hints: schema.usage_hints ??
+            USAGE_HINTS_BY_PREDICATE[schema.predicate_name] ??
+            DEFAULT_USAGE_HINTS,
+    };
+}
+// implements REQ-mcp-suggest-predicates
+export async function loadExistingPredicateSchemas(prolog, includeExistingSchemas, warnings) {
+    if (!includeExistingSchemas || prolog === null) {
+        return [];
+    }
+    try {
+        const queryResult = await prolog.query("findall([Id,'fact',Props], (kb_entity(Id, 'fact', Props), member(fact_kind=predicate_schema, Props)), Results)");
+        if (!queryResult.success) {
+            throw new Error(queryResult.error || "Query failed with unknown error");
+        }
+        const facts = queryResult.bindings.Results
+            ? parseListOfLists(queryResult.bindings.Results).map(parseEntityFromList)
+            : [];
+        return facts.flatMap((fact) => predicateSchemaFromEntity(fact));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        warnings.push(`Existing predicate_schema facts could not be loaded: ${message}`);
+        return [];
+    }
+}
+// implements REQ-mcp-suggest-predicates
+export function predicateSchemaFromEntity(entity) {
+    if (entity.fact_kind !== "predicate_schema")
+        return [];
+    const predicateName = normalizeOptionalString(typeof entity.predicate_name === "string"
+        ? entity.predicate_name
+        : undefined);
+    if (!predicateName)
+        return [];
+    const usageHints = usageHintsFromEntity(entity);
+    return [
+        {
+            id: String(entity.id ?? hashId("FACT-SCHEMA", [predicateName])),
+            predicate_name: predicateName,
+            title: String(entity.title ?? predicateName),
+            description: String(entity.description ??
+                `Project-local ${predicateName} predicate schema.`),
+            argument_names: stringArray(entity.argument_names),
+            argument_types: stringArray(entity.argument_types),
+            keywords: [
+                predicateName,
+                ...stringArray(entity.aliases),
+                ...stringArray(entity.tags),
+            ],
+            examples: stringArray(entity.examples),
+            tags: stringArray(entity.tags),
+            ...(usageHints ? { usage_hints: usageHints } : {}),
+        },
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function usageHintsFromEntity(entity) {
+    const useWhen = stringArray(entity.use_when);
+    const doNotUseWhen = stringArray(entity.do_not_use_when);
+    if (useWhen.length === 0 || doNotUseWhen.length === 0) {
+        return undefined;
+    }
+    return { use_when: useWhen, do_not_use_when: doNotUseWhen };
+}
+// implements REQ-mcp-suggest-predicates
+export function stringArray(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        const normalized = normalizeOptionalString(typeof item === "string" ? item : undefined);
+        return normalized ? [normalized] : [];
+    });
+}

package/dist/operations/modeling/predicate-ranker.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateSchemaCandidate } from "./predicate-types.js";
+export declare function scoreSchema(schema: PredicateSchemaCandidate, text: string): number;
+//# sourceMappingURL=predicate-ranker.d.ts.map

package/dist/operations/modeling/predicate-ranker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-ranker.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-ranker.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAUrE,wBAAgB,WAAW,CACzB,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,CAcR"}

package/dist/operations/modeling/predicate-ranker.js

@@ -0,0 +1,24 @@
+import { scoreExactPredicates1 } from "./predicate-score-1.js";
+import { scoreExactPredicates2 } from "./predicate-score-2.js";
+import { scoreExactPredicates3 } from "./predicate-score-3.js";
+import { matchesKeyword } from "./predicate-utils.js";
+const EXACT_SCORERS = [
+    scoreExactPredicates1,
+    scoreExactPredicates2,
+    scoreExactPredicates3,
+];
+// implements REQ-mcp-suggest-predicates
+export function scoreSchema(schema, text) {
+    for (const scorer of EXACT_SCORERS) {
+        const score = scorer(schema, text);
+        if (score !== null)
+            return score;
+    }
+    const lower = text.toLowerCase();
+    const keywordHits = schema.keywords.filter((keyword) => matchesKeyword(text, lower, keyword)).length;
+    if (keywordHits === 0)
+        return 0;
+    const normalized = keywordHits / Math.max(3, schema.keywords.length / 2);
+    const score = Math.min(0.98, 0.24 + normalized * 0.5 + keywordHits * 0.06);
+    return Math.round(score * 100) / 100;
+}

package/dist/operations/modeling/predicate-score-1.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateSchemaCandidate } from "./predicate-types.js";
+export declare function scoreExactPredicates1(schema: PredicateSchemaCandidate, text: string): number | null;
+//# sourceMappingURL=predicate-score-1.d.ts.map