kibi-cli 0.14.0 → 0.17.0

package/dist/operations/modeling/predicate-catalog-4.js

@@ -0,0 +1,149 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_CATALOG_4 = [
+    {
+        id: "FACT-SCHEMA-FEATURE-GATE",
+        predicate_name: "feature_gate",
+        title: "Feature gate",
+        description: "A subject is controlled by a runtime or configuration gate.",
+        argument_names: ["subject", "gate", "expected"],
+        argument_types: ["entity", "flag", "boolean"],
+        keywords: ["flag", "feature gate", "enabled", "disabled", "kill switch"],
+        examples: ["feature_gate(checkout.v2, checkoutV2Enabled, true)"],
+        tags: ["flag", "runtime"],
+    },
+    {
+        id: "FACT-SCHEMA-EVENT-PUBLISH",
+        predicate_name: "publishes_event",
+        title: "Event publication",
+        description: "A subject publishes a domain or system event.",
+        argument_names: ["subject", "event"],
+        argument_types: ["entity", "event"],
+        keywords: ["publish", "publishes", "emit", "emits", "event"],
+        examples: ["publishes_event(order.checkout, OrderSubmitted)"],
+        tags: ["event", "architecture"],
+    },
+    {
+        id: "FACT-SCHEMA-ACCEPTANCE-RULE",
+        predicate_name: "acceptance_rule",
+        title: "Acceptance rule",
+        description: "A subject has an observable acceptance outcome.",
+        argument_names: ["subject", "outcome"],
+        argument_types: ["entity", "outcome"],
+        keywords: [
+            "acceptance",
+            "observable",
+            "outcome",
+            "must show",
+            "must display",
+        ],
+        examples: ["acceptance_rule(search.results, shows_empty_state)"],
+        tags: ["acceptance", "quality"],
+    },
+    {
+        id: "FACT-SCHEMA-PERMISSION-RULE",
+        predicate_name: "permission_rule",
+        title: "Permission rule",
+        description: "An actor is allowed or denied an action against a resource.",
+        argument_names: ["actor", "action", "resource", "decision"],
+        argument_types: ["actor", "action", "resource", "decision"],
+        keywords: [
+            "may",
+            "can",
+            "allowed",
+            "denied",
+            "forbidden",
+            "must not",
+            "cannot",
+            "can't",
+            "export",
+            "permission",
+        ],
+        examples: ["permission_rule(guest, export, customer_data, deny)"],
+        tags: ["permission", "policy"],
+    },
+    {
+        id: "FACT-SCHEMA-DEFAULT-VALUE",
+        predicate_name: "default_value",
+        title: "Default value",
+        description: "A subject property defaults to a value.",
+        argument_names: ["subject", "property", "value"],
+        argument_types: ["entity", "property", "value"],
+        keywords: ["default", "defaults", "defaulted", "initial", "mode", "tool"],
+        examples: ["default_value(annotation.tool, mode, move)"],
+        tags: ["default", "configuration"],
+    },
+    {
+        id: "FACT-SCHEMA-UNIQUENESS-CONSTRAINT",
+        predicate_name: "uniqueness_constraint",
+        title: "Uniqueness constraint",
+        description: "A subject is unique within one or more scope keys.",
+        argument_names: ["subject", "scope"],
+        argument_types: ["entity", "scope"],
+        keywords: ["unique", "uniqueness", "at most one", "one", "per"],
+        examples: ["uniqueness_constraint(annotation, video,timeKey)"],
+        tags: ["constraint", "identity"],
+    },
+    {
+        id: "FACT-SCHEMA-STATE-MEMBERSHIP",
+        predicate_name: "state_membership",
+        title: "State membership",
+        description: "A state-valued subject has a closed set of allowed states.",
+        argument_names: ["subject", "states"],
+        argument_types: ["entity", "state_list"],
+        keywords: ["terminal states", "states are", "one of", "ready", "anonymous"],
+        examples: ["state_membership(auth.status, ready,anonymous,profile-error)"],
+        tags: ["state", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-TEMPORAL-ORDER",
+        predicate_name: "temporal_order",
+        title: "Temporal order",
+        description: "One event or state must occur before or after another.",
+        argument_names: ["subject", "before_event", "after_event"],
+        argument_types: ["entity", "event", "event"],
+        keywords: ["before", "after", "saved", "completes", "navigation"],
+        examples: ["temporal_order(draft.changes, saved, navigation_completes)"],
+        tags: ["temporal", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-CONDITIONAL-BEHAVIOR",
+        predicate_name: "conditional_behavior",
+        title: "Conditional behavior",
+        description: "A behavior follows when a condition is true.",
+        argument_names: ["subject", "condition", "behavior"],
+        argument_types: ["entity", "condition", "behavior"],
+        keywords: ["if", "during", "becomes", "condition", "provided that"],
+        examples: [
+            "conditional_behavior(card, fails_during_session, becomes_tainted)",
+        ],
+        tags: ["conditional", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-STATE-TRANSITION",
+        predicate_name: "state_transition",
+        title: "State transition",
+        description: "A subject moves from one state to another because of a trigger.",
+        argument_names: ["subject", "from_state", "to_state", "trigger"],
+        argument_types: ["entity", "state", "state", "trigger"],
+        keywords: ["transitions from", "transition from", "from draft", "to idle"],
+        examples: ["state_transition(editor, draft, idle, navigation_completes)"],
+        tags: ["state", "workflow"],
+    },
+    {
+        id: "FACT-SCHEMA-RATE-LIMIT",
+        predicate_name: "rate_limit",
+        title: "Rate limit",
+        description: "An action is limited to a count within a time window.",
+        argument_names: ["subject", "action", "window", "count"],
+        argument_types: ["entity", "action", "duration", "number"],
+        keywords: [
+            "rate limited",
+            "rate limit",
+            "attempts",
+            "per hour",
+            "per minute",
+        ],
+        examples: ["rate_limit(password_reset.request, attempts, hour, 5)"],
+        tags: ["rate-limit", "security"],
+    },
+];

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

@@ -0,0 +1,5 @@
+import type { PredicateSchemaCandidate, PredicateUsageHints } from "./predicate-types.js";
+export declare const DEFAULT_USAGE_HINTS: PredicateUsageHints;
+export declare const USAGE_HINTS_BY_PREDICATE: Record<string, PredicateUsageHints>;
+export declare const BUILT_IN_PREDICATE_SCHEMAS: PredicateSchemaCandidate[];
+//# sourceMappingURL=predicate-catalog.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-catalog.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-catalog.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAM9B,eAAO,MAAM,mBAAmB,EAAE,mBAOjC,CAAC;AAGF,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAIxE,CAAC;AAGF,eAAO,MAAM,0BAA0B,EAAE,wBAAwB,EAKhE,CAAC"}

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

@@ -0,0 +1,29 @@
+import { PREDICATE_CATALOG_1 } from "./predicate-catalog-1.js";
+import { PREDICATE_CATALOG_2 } from "./predicate-catalog-2.js";
+import { PREDICATE_CATALOG_3 } from "./predicate-catalog-3.js";
+import { PREDICATE_CATALOG_4 } from "./predicate-catalog-4.js";
+import { PREDICATE_USAGE_HINTS_1 } from "./predicate-usage-hints-1.js";
+import { PREDICATE_USAGE_HINTS_2 } from "./predicate-usage-hints-2.js";
+import { PREDICATE_USAGE_HINTS_3 } from "./predicate-usage-hints-3.js";
+// implements REQ-mcp-suggest-predicates
+export const DEFAULT_USAGE_HINTS = {
+    use_when: [
+        "Use when the prose matches this predicate signature and all required arguments can be named explicitly.",
+    ],
+    do_not_use_when: [
+        "Do not use when a stricter scalar property, a more specific predicate, or an ontology-gap observation better preserves the claim.",
+    ],
+};
+// implements REQ-mcp-suggest-predicates
+export const USAGE_HINTS_BY_PREDICATE = {
+    ...PREDICATE_USAGE_HINTS_1,
+    ...PREDICATE_USAGE_HINTS_2,
+    ...PREDICATE_USAGE_HINTS_3,
+};
+// implements REQ-mcp-suggest-predicates
+export const BUILT_IN_PREDICATE_SCHEMAS = [
+    ...PREDICATE_CATALOG_1,
+    ...PREDICATE_CATALOG_2,
+    ...PREDICATE_CATALOG_3,
+    ...PREDICATE_CATALOG_4,
+];

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

@@ -0,0 +1,16 @@
+export declare function inferPermissionRuleArgs(text: string): string[];
+export declare function inferGuardArgs(text: string, subject: string): string[];
+export declare function inferExceptionRuleArgs(text: string, subject: string): string[];
+export declare function inferMutualExclusionArgs(text: string): string[];
+export declare function inferDependencyRuleArgs(text: string): string[];
+export declare function inferOwnershipRuleArgs(text: string): string[];
+export declare function inferRetryPolicyArgs(text: string): string[];
+export declare function inferEscalationRuleArgs(text: string): string[];
+export declare function inferAvailabilitySlaArgs(text: string): string[];
+export declare function inferNotificationRouteArgs(text: string): string[];
+export declare function inferIdempotencyRuleArgs(text: string): string[];
+export declare function inferDataResidencyRuleArgs(text: string): string[];
+export declare function inferAuditEventRuleArgs(text: string): string[];
+export declare function inferConsentRuleArgs(text: string): string[];
+export declare function inferLifecycleRuleArgs(text: string): string[];
+//# sourceMappingURL=predicate-inference-1.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-inference-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-inference-1.ts"],"names":[],"mappings":"AAQA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAsB9D;AAGD,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBtE;AAGD,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CAWV;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/D;AAGD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS9D;AAGD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ7D;AAGD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS3D;AAGD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAU9D;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAY/D;AAGD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASjE;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAmB/D;AAGD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQjE;AAGD,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ9D;AAGD,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS3D;AAGD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAU7D"}

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

@@ -0,0 +1,161 @@
+import { normalizePredicateToken, normalizeSubjectKey, singularize, slug, } from "./predicate-utils.js";
+// implements REQ-mcp-suggest-predicates
+export function inferPermissionRuleArgs(text) {
+    const prohibition = text.match(/^(?<actor>[a-z][a-z\s_-]*?)\s+(?:must\s+not|cannot|can't|is\s+forbidden\s+to)\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)\.?$/i);
+    if (prohibition?.groups) {
+        return [
+            singularize(slug(prohibition.groups.actor ?? "actor")),
+            normalizePredicateToken(prohibition.groups.action ?? "action"),
+            normalizePredicateToken(prohibition.groups.resource ?? "resource"),
+            "deny",
+        ];
+    }
+    const permission = text.match(/^(?:only\s+)?(?<actor>[a-z][a-z\s_-]*?)\s+(?:may|can|is\s+allowed\s+to)\s+(?<action>[a-z][a-z_-]*)\s+(?<resource>.+?)(?:\s+when\s+.+)?\.?$/i);
+    return [
+        singularize(slug(permission?.groups?.actor ?? "actor")),
+        normalizePredicateToken(permission?.groups?.action ?? "action"),
+        normalizePredicateToken(permission?.groups?.resource ?? "resource"),
+        "assert",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferGuardArgs(text, subject) {
+    const disabledUntil = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)?\s*(?:stay|remain)?\s*disabled\s+until\s+(?<condition>.+?)\.?$/i);
+    if (disabledUntil?.groups?.subject && disabledUntil.groups.condition) {
+        return [
+            slug(disabledUntil.groups.subject),
+            normalizePredicateToken(disabledUntil.groups.condition),
+            "disabled",
+        ];
+    }
+    const lower = text.toLowerCase();
+    return [
+        subject,
+        lower.includes("readonly") ? "isReadOnly" : "condition",
+        "true",
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferExceptionRuleArgs(text, subject) {
+    const exception = text.match(/^(?:the\s+)?(?<subject>[a-z][a-z\s_-]*?)\s+(?:must|shall|should)\s+(?<behavior>.+?)\s+unless\s+(?:the\s+)?(?<exception>.+?)\.?$/i);
+    return [
+        exception?.groups?.subject
+            ? normalizeSubjectKey(exception.groups.subject)
+            : subject,
+        normalizePredicateToken(exception?.groups?.behavior ?? "behavior"),
+        normalizePredicateToken(exception?.groups?.exception ?? "exception"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferMutualExclusionArgs(text) {
+    const exclusion = text.match(/^(?<left>.+?)\s+and\s+(?<right>.+?)\s+(?:must|shall|should)\s+be\s+mutually\s+exclusive\.?$/i);
+    return [
+        slug(exclusion?.groups?.left ?? "left"),
+        slug(exclusion?.groups?.right ?? "right"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDependencyRuleArgs(text) {
+    const dependency = text.match(/^(?<subject>.+?)\s+requires\s+(?<prerequisite>.+?)\s+before\s+(?<dependent>.+?)\.?$/i);
+    return [
+        slug(dependency?.groups?.subject ?? "subject"),
+        normalizePredicateToken(dependency?.groups?.prerequisite ?? "prerequisite"),
+        normalizePredicateToken(dependency?.groups?.dependent ?? "dependent"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferOwnershipRuleArgs(text) {
+    const ownership = text.match(/^(?<resource>.+?)\s+(?:is|are)\s+owned\s+by\s+(?:the\s+)?(?<owner>.+?)\.?$/i);
+    return [
+        slug(ownership?.groups?.resource ?? "resource"),
+        slug(ownership?.groups?.owner ?? "owner"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferRetryPolicyArgs(text) {
+    const retry = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+retry\s+up\s+to\s+(?<count>\d+)\s+(?<unit>times|attempts?)\.?$/i);
+    return [
+        slug(retry?.groups?.subject ?? "subject"),
+        retry?.groups?.count ?? "0",
+        slug(retry?.groups?.unit ?? "times"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferEscalationRuleArgs(text) {
+    const escalation = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+escalate\s+to\s+(?<target>.+?)\s+after\s+(?<delay>\d+)\s+(?<unit>[a-z]+)\.?$/i);
+    return [
+        slug(escalation?.groups?.subject ?? "subject"),
+        slug(escalation?.groups?.target ?? "target"),
+        escalation?.groups?.delay ?? "0",
+        slug(escalation?.groups?.unit ?? "unit"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferAvailabilitySlaArgs(text) {
+    const availability = text.match(/^(?<subject>.+?)\s+availability\s+(?:must|shall|should)\s+be\s+at\s+least\s+(?<threshold>\d+(?:\.\d+)?)\s+(?<unit>percent|%)\s+(?<window>[a-z]+)\.?$/i);
+    return [
+        slug(availability?.groups?.subject ?? "subject"),
+        availability?.groups?.threshold ?? "0",
+        availability?.groups?.unit === "%"
+            ? "percent"
+            : slug(availability?.groups?.unit ?? "percent"),
+        slug(availability?.groups?.window ?? "window"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferNotificationRouteArgs(text) {
+    const notification = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+notify\s+(?<recipient>.+?)\s+by\s+(?<channel>[a-z]+)\.?$/i);
+    return [
+        slug(notification?.groups?.subject ?? "subject"),
+        slug(notification?.groups?.recipient ?? "recipient"),
+        slug(notification?.groups?.channel ?? "channel"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferIdempotencyRuleArgs(text) {
+    const idempotency = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+idempotent\s+by\s+(?<key>.+?)\.?$/i);
+    const deduplicated = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+deduplicated\s+to\s+prevent\s+redundant\s+requests\s+during\s+(?<key>.+?)\.?$/i);
+    return [
+        slug(idempotency?.groups?.subject ??
+            deduplicated?.groups?.subject ??
+            "subject"),
+        slug(idempotency?.groups?.key ??
+            deduplicated?.groups?.key ??
+            "idempotency_key"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDataResidencyRuleArgs(text) {
+    const residency = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?:stored|processed|kept)\s+in\s+(?:the\s+)?(?<region>.+?\b(?:region|jurisdiction|country|zone|area))\.?$/i);
+    return [
+        slug(residency?.groups?.subject ?? "data"),
+        slug(residency?.groups?.region ?? "region"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferAuditEventRuleArgs(text) {
+    const audit = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?:recorded|logged|audited)\s+in\s+(?:the\s+)?(?<log>audit\s+(?:log|trail))\.?$/i);
+    return [
+        slug(audit?.groups?.subject ?? "subject"),
+        slug(audit?.groups?.log ?? "audit_log"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferConsentRuleArgs(text) {
+    const consent = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+require\s+(?<consent>.+?consent)\s+before\s+(?<purpose>.+?)\.?$/i);
+    return [
+        slug(consent?.groups?.subject ?? "subject"),
+        slug(consent?.groups?.consent ?? "consent"),
+        normalizePredicateToken(consent?.groups?.purpose ?? "purpose"),
+    ];
+}
+// implements REQ-mcp-suggest-predicates
+export function inferLifecycleRuleArgs(text) {
+    const lifecycle = text.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<action>archived|deleted|expired)\s+after\s+(?<duration>\d+)\s+(?<unit>[a-z]+)\.?$/i);
+    return [
+        slug(lifecycle?.groups?.subject ?? "subject"),
+        slug(lifecycle?.groups?.action ?? "action"),
+        lifecycle?.groups?.duration ?? "0",
+        slug(lifecycle?.groups?.unit ?? "unit"),
+    ];
+}

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

@@ -0,0 +1,19 @@
+export declare function inferConflictResolutionRuleArgs(text: string): string[];
+export declare function inferFallbackRuleArgs(text: string): string[];
+export declare function inferBatchOperationRuleArgs(text: string): string[];
+export declare function inferConsistencyRuleArgs(text: string): string[];
+export declare function inferBuildConstraintArgs(text: string): string[];
+export declare function inferEnvironmentSafetyRuleArgs(text: string): string[];
+export declare function inferSchemaInvariantRuleArgs(text: string): string[];
+export declare function inferCodingStandardRuleArgs(text: string): string[];
+export declare function inferMigrationBoundaryRuleArgs(text: string): string[];
+export declare function inferAbsenceRequirementArgs(text: string): string[];
+export declare function inferOfflineBehaviorRuleArgs(text: string): string[];
+export declare function inferReleaseGateRuleArgs(text: string): string[];
+export declare function inferPlatformConsistencyRuleArgs(text: string): string[];
+export declare function inferPreservationRuleArgs(text: string): string[];
+export declare function inferAbstractionBoundaryRuleArgs(text: string): string[];
+export declare function inferSecurityConfigurationRuleArgs(text: string): string[];
+export declare function inferOrderedStrategyRuleArgs(text: string): string[];
+export declare function inferRefreshPolicyRuleArgs(text: string): string[];
+//# sourceMappingURL=predicate-inference-2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-inference-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-inference-2.ts"],"names":[],"mappings":"AAGA,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQtE;AAGD,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS5D;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASlE;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/D;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAGD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASrE;AAGD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAWnE;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASlE;AAGD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASrE;AAGD,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAalE;AAGD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASnE;AAGD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAS/D;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAUvE;AAGD,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAShE;AAGD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASvE;AAGD,wBAAgB,kCAAkC,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASzE;AAGD,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAcnE;AAGD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CASjE"}

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"}