kibi-cli 0.14.0 → 0.17.0

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,EAKb,MAAM,sBAAsB,CAAC;AAG9B,wBAAgB,SAAS,CACvB,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,MAAM,EAAE,CA0JV;AAGD,OAAO,EAAE,YAAY,EAAE,CAAC"}

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

@@ -0,0 +1,163 @@
+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, normalizePredicateToken, 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) => {
+                if (name === "subject")
+                    return subject;
+                const normalized = normalizePredicateToken(name);
+                const words = normalized.split("_").filter((word) => word.length > 2);
+                // Project-local schemas often use the exact domain vocabulary in
+                // their ordered argument names. Reuse that declared value when the
+                // complete name (or all meaningful words) occurs in the claim; keep
+                // genuinely unbound arguments explicit instead of guessing.
+                const phrase = words.join(" ");
+                return phrase.length > 0 &&
+                    (lower.includes(phrase) ||
+                        words.every((word) => lower.includes(word)))
+                    ? normalized
+                    : "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,CAmBA;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,CAiC5B;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,94 @@
+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,
+        ...(schema.aliases ? { aliases: schema.aliases } : {}),
+        ...(schema.paraphrase_templates
+            ? { paraphrase_templates: schema.paraphrase_templates }
+            : {}),
+        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),
+            ],
+            aliases: stringArray(entity.aliases),
+            paraphrase_templates: stringArray(entity.paraphrase_templates),
+            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;AA6BrE,wBAAgB,WAAW,CACzB,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,CAuDR"}

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

@@ -0,0 +1,62 @@
+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";
+function tokens(value) {
+    return value.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+function stem(value) {
+    if (value.length > 5 && value.endsWith("ies"))
+        return `${value.slice(0, -3)}y`;
+    if (value.length > 4 && value.endsWith("ing"))
+        return value.slice(0, -3);
+    if (value.length > 4 && value.endsWith("ed"))
+        return value.slice(0, -2);
+    if (value.length > 4 && value.endsWith("s"))
+        return value.slice(0, -1);
+    return value;
+}
+function overlap(left, right) {
+    const target = new Set(right.map(stem));
+    const matches = new Set(left.map(stem).filter((token) => target.has(token)));
+    return target.size === 0 ? 0 : matches.size / target.size;
+}
+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;
+    const textTokens = tokens(text);
+    const descriptors = [
+        schema.predicate_name,
+        schema.title,
+        schema.description,
+        ...(schema.aliases ?? []),
+        ...(schema.paraphrase_templates ?? []),
+        ...schema.examples,
+    ];
+    const descriptorOverlap = Math.max(...descriptors.map((descriptor) => overlap(textTokens, tokens(descriptor))), 0);
+    const useWhenOverlap = Math.max(...(schema.usage_hints?.use_when ?? []).map((descriptor) => overlap(textTokens, tokens(descriptor))), 0);
+    const doNotUseWhenOverlap = Math.max(...(schema.usage_hints?.do_not_use_when ?? []).map((descriptor) => overlap(textTokens, tokens(descriptor))), 0);
+    const morphologyHits = schema.keywords.filter((keyword) => textTokens.map(stem).includes(stem(keyword.toLowerCase()))).length;
+    if (keywordHits === 0 && morphologyHits === 0 && descriptorOverlap < 0.25)
+        return 0;
+    const normalized = keywordHits / Math.max(3, schema.keywords.length / 2);
+    const score = Math.min(0.98, Math.max(0, 0.2 +
+        normalized * 0.4 +
+        keywordHits * 0.05 +
+        morphologyHits * 0.04 +
+        descriptorOverlap * 0.3 +
+        useWhenOverlap * 0.08 -
+        doNotUseWhenOverlap * 0.18));
+    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

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-score-1.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-score-1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CA6Lf"}

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

@@ -0,0 +1,121 @@
+// implements REQ-mcp-suggest-predicates
+export function scoreExactPredicates1(schema, text) {
+    if (schema.predicate_name === "guard") {
+        if (/^.+?\s+(?:must|shall|should)?\s*(?:stay|remain)?\s*disabled\s+until\s+.+?\.?$/i.test(text)) {
+            return 0.98;
+        }
+    }
+    if (schema.predicate_name === "conditional_behavior") {
+        if (/^if\s+(?:(?:a|an|the)\s+)?[a-z][a-z_-]*\s+.+?,\s*(?:it|they|the\s+[a-z][a-z\s_-]*?)\s+.+?\.?$/i.test(text)) {
+            return 0.98;
+        }
+        if (/^when\s+.+?,\s*(?:the\s+)?.+?\s+(?:must|shall|should)\s+.+?\.?$/i.test(text)) {
+            return 0.36;
+        }
+        return 0;
+    }
+    if (schema.predicate_name === "exception_rule") {
+        if (!/^(?:the\s+)?[a-z][a-z\s_-]*?\s+(?:must|shall|should)\s+.+?\s+unless\s+(?:the\s+)?.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "mutual_exclusion") {
+        if (!/^.+?\s+and\s+.+?\s+(?:must|shall|should)\s+be\s+mutually\s+exclusive\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "dependency_rule") {
+        if (!/^.+?\s+requires\s+.+?\s+before\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "ownership_rule") {
+        if (!/^.+?\s+(?:is|are)\s+owned\s+by\s+(?:the\s+)?.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "retry_policy") {
+        if (!/^.+?\s+(?:must|shall|should)\s+retry\s+up\s+to\s+\d+\s+(?:times|attempts?)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "escalation_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+escalate\s+to\s+.+?\s+after\s+\d+\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "availability_sla") {
+        if (!/^.+?\s+availability\s+(?:must|shall|should)\s+be\s+at\s+least\s+\d+(?:\.\d+)?\s+(?:percent|%)\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "notification_route") {
+        if (!/^.+?\s+(?:must|shall|should)\s+notify\s+.+?\s+by\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "idempotency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+idempotent\s+by\s+.+?\.?$/i.test(text) &&
+            !/^.+?\s+(?:must|shall|should)\s+be\s+deduplicated\s+to\s+prevent\s+redundant\s+requests\s+during\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "data_residency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:stored|processed|kept)\s+in\s+(?:the\s+)?.+?\b(?:region|jurisdiction|country|zone|area)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "audit_event_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:recorded|logged|audited)\s+in\s+(?:the\s+)?audit\s+(?:log|trail)\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "consent_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+require\s+.+?consent\s+before\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "lifecycle_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+be\s+(?:archived|deleted|expired)\s+after\s+\d+\s+[a-z]+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "conflict_resolution_rule") {
+        if (!/^when\s+.+?\s+conflicts?,\s+(?:the\s+)?.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "fallback_rule") {
+        if (!/^if\s+.+?,\s+.+?\s+(?:must|shall|should)\s+fall\s+back\s+to\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "batch_operation_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+process\s+.+?\s+in\s+batches\s+of\s+\d+\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    if (schema.predicate_name === "consistency_rule") {
+        if (!/^.+?\s+(?:must|shall|should)\s+reference\s+an?\s+existing\s+.+?\.?$/i.test(text)) {
+            return 0;
+        }
+        return 0.98;
+    }
+    return null;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-score-2.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-score-2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAGrE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,wBAAwB,EAChC,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,IAAI,CAgMf"}