kibi-cli 0.14.0 → 0.16.1

package/dist/operations/modeling/predicate-usage-hints-2.js

@@ -0,0 +1,209 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_USAGE_HINTS_2 = {
+    offline_behavior_rule: {
+        use_when: [
+            "Use when synchronization or gameplay behavior must remain non-blocking or resilient during offline conditions.",
+        ],
+        do_not_use_when: [
+            "Do not use for generic fallback behavior without an offline/resilient synchronization condition.",
+        ],
+    },
+    release_gate_rule: {
+        use_when: [
+            "Use when builds or releases must pass named gates before distribution, review, or deployment.",
+        ],
+        do_not_use_when: [
+            "Do not use for runtime dependency prerequisites; use dependency_rule for product workflow dependencies.",
+        ],
+    },
+    platform_consistency_rule: {
+        use_when: [
+            "Use when a state or entitlement must synchronize across named platforms.",
+        ],
+        do_not_use_when: [
+            "Do not use for referential integrity within one data model; use consistency_rule instead.",
+        ],
+    },
+    preservation_rule: {
+        use_when: [
+            "Use when child data or feedback must be preserved across deletion/removal of a parent resource.",
+        ],
+        do_not_use_when: [
+            "Do not use for simple archive/delete timing rules without a preservation target.",
+        ],
+    },
+    abstraction_boundary_rule: {
+        use_when: [
+            "Use when persisted data, APIs, or contracts must remain neutral to a renderer, vendor, runtime, or implementation detail.",
+        ],
+        do_not_use_when: [
+            "Do not use for generic coding standards without a boundary/contract target; use coding_standard_rule instead.",
+        ],
+    },
+    security_configuration_rule: {
+        use_when: [
+            "Use when infrastructure, database, trigger, RPC, or deployment components must carry an explicit security configuration value.",
+        ],
+        do_not_use_when: [
+            "Do not use for actor authorization decisions; use permission_rule or scoped_authorization_rule instead.",
+        ],
+    },
+    ordered_strategy_rule: {
+        use_when: [
+            "Use when a subject must apply named strategies in a required priority or fallback order.",
+        ],
+        do_not_use_when: [
+            "Do not use for unordered enum membership; use strict allowed_values or state_membership instead.",
+        ],
+    },
+    refresh_policy_rule: {
+        use_when: [
+            "Use when a UI, dashboard, cache, or list must refresh a target automatically or on a named cadence/trigger.",
+        ],
+        do_not_use_when: [
+            "Do not use for save/commit actions or notification routing; use commit_action or notification_route instead.",
+        ],
+    },
+    scoped_authorization_rule: {
+        use_when: [
+            "Use when an actor is allowed or denied an action because they are assigned, unassigned, owner, member, or otherwise scoped to a resource.",
+        ],
+        do_not_use_when: [
+            "Do not use for simple actor/action/resource permissions without a scope qualifier; use permission_rule instead.",
+        ],
+    },
+    documentation_standard_rule: {
+        use_when: [
+            "Use when code symbols, APIs, tests, or project artifacts must be documented in a named documentation source.",
+        ],
+        do_not_use_when: [
+            "Do not use for runtime persistence or user-facing display labels.",
+        ],
+    },
+    warmup_policy_rule: {
+        use_when: [
+            "Use when a component, media element, cache, or service must warm up on a named entry or trigger.",
+        ],
+        do_not_use_when: [
+            "Do not use for generic state transitions without warmup behavior.",
+        ],
+    },
+    visual_layout_rule: {
+        use_when: [
+            "Use when UI elements must remain visually aligned, consistent, or layout-compatible with another element.",
+        ],
+        do_not_use_when: [
+            "Do not use for generic acceptance outcomes without a visual/layout relationship.",
+        ],
+    },
+    enforcement_location_rule: {
+        use_when: [
+            "Use when a constraint or policy must be enforced at a named layer such as database, application, edge, or client level.",
+        ],
+        do_not_use_when: [
+            "Do not use for the constraint itself when the enforcement location is not stated.",
+        ],
+    },
+    reconciliation_rule: {
+        use_when: [
+            "Use when a trigger requires reconciling a target and clearing stale or inconsistent records.",
+        ],
+        do_not_use_when: [
+            "Do not use for ordinary archive/delete timing without reconciliation.",
+        ],
+    },
+    throttle_policy_rule: {
+        use_when: [
+            "Use when handlers, operations, or streams must be throttled for high-frequency activity.",
+        ],
+        do_not_use_when: [
+            "Do not use for numeric API request quotas; use rate_limit instead.",
+        ],
+    },
+    has_unsaved_changes: {
+        use_when: [
+            "Use for dirty, draft, or unsaved local-edit state on a subject.",
+        ],
+        do_not_use_when: [
+            "Do not use for the action that saves or discards those changes.",
+        ],
+    },
+    commit_action: {
+        use_when: [
+            "Use when a trigger saves, commits, persists, or auto-saves a subject in a scope.",
+        ],
+        do_not_use_when: [
+            "Do not use for cancel, discard, revert, or abandon behavior.",
+        ],
+    },
+    discard_action: {
+        use_when: [
+            "Use when a trigger discards, cancels, reverts, or abandons changes in a scope.",
+        ],
+        do_not_use_when: ["Do not use for persistence or save behavior."],
+    },
+    accessibility_requirement: {
+        use_when: [
+            "Use for WCAG, keyboard, screen-reader, or accessibility target requirements.",
+        ],
+        do_not_use_when: [
+            "Do not use for generic acceptance outcomes or performance constraints.",
+        ],
+    },
+    retention_policy: {
+        use_when: [
+            "Use when records or data must be retained for a bounded duration.",
+        ],
+        do_not_use_when: [
+            "Do not use for request rate windows, session expiry, or latency thresholds.",
+        ],
+    },
+    resource_constraint: {
+        use_when: [
+            "Use for resource, latency, timeout, size, quota, or numeric threshold constraints.",
+        ],
+        do_not_use_when: [
+            "Do not use for uniqueness, rate limits, feature gates, or actor permissions.",
+        ],
+    },
+    feature_gate: {
+        use_when: [
+            "Use when behavior is controlled by a runtime/config flag, kill switch, or feature gate.",
+        ],
+        do_not_use_when: [
+            "Do not use for actor authorization or ordinary scalar enabled/disabled properties.",
+        ],
+    },
+    publishes_event: {
+        use_when: [
+            "Use when a subject publishes, emits, or raises a domain/system event.",
+        ],
+        do_not_use_when: [
+            "Do not use for consuming events or observable UI acceptance outcomes.",
+        ],
+    },
+    acceptance_rule: {
+        use_when: [
+            "Use for observable acceptance outcomes such as visible empty states or displayed results.",
+        ],
+        do_not_use_when: [
+            "Do not use for internal state machines, event publication, or accessibility standards.",
+        ],
+    },
+    permission_rule: {
+        use_when: [
+            "Use for allow/deny permission statements with an actor, action, and resource.",
+        ],
+        do_not_use_when: [
+            "Do not use for scalar quotas, feature flags, or state transitions; choose a more specific predicate or strict property instead.",
+        ],
+    },
+    default_value: {
+        use_when: [
+            "Use when behavior defines a default mode, state, status, option, or value.",
+        ],
+        do_not_use_when: [
+            "Do not use for current-state assertions or allowed value sets.",
+        ],
+    },
+};

package/dist/operations/modeling/predicate-usage-hints-3.d.ts

@@ -0,0 +1,3 @@
+import type { PredicateUsageHints } from "./predicate-types.js";
+export declare const PREDICATE_USAGE_HINTS_3: Record<string, PredicateUsageHints>;
+//# sourceMappingURL=predicate-usage-hints-3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-usage-hints-3.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-usage-hints-3.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAGhE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CA2CvE,CAAC"}

package/dist/operations/modeling/predicate-usage-hints-3.js

@@ -0,0 +1,45 @@
+// implements REQ-mcp-suggest-predicates
+export const PREDICATE_USAGE_HINTS_3 = {
+    uniqueness_constraint: {
+        use_when: ["Use for at-most-one or unique-per-scope constraints."],
+        do_not_use_when: [
+            "Do not use for numeric caps where more than one instance may be valid.",
+        ],
+    },
+    state_membership: {
+        use_when: ["Use for terminal, allowed, or enumerated state sets."],
+        do_not_use_when: [
+            "Do not use for one current state or a transition between states.",
+        ],
+    },
+    temporal_order: {
+        use_when: [
+            "Use for before/after ordering requirements between events, states, or actions.",
+        ],
+        do_not_use_when: [
+            "Do not use when source state, target state, and trigger are all explicit; use state_transition instead.",
+        ],
+    },
+    conditional_behavior: {
+        use_when: [
+            "Use for if/when conditional prose where a condition leads to a behavior.",
+        ],
+        do_not_use_when: [
+            "Do not use for simple boolean guards or actor permission rules.",
+        ],
+    },
+    state_transition: {
+        use_when: [
+            "Use for explicit transitions from one named state to another with a trigger.",
+        ],
+        do_not_use_when: [
+            "Do not use for a single state assertion or an allowed terminal-state set.",
+        ],
+    },
+    rate_limit: {
+        use_when: ["Use for per-window request, attempt, or action limits."],
+        do_not_use_when: [
+            "Do not use for resource thresholds that lack a repeated action and time window.",
+        ],
+    },
+};

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

@@ -0,0 +1,23 @@
+export declare function normalizeText(text: string): string;
+export declare function normalizeOptionalString(value: string | undefined): string | undefined;
+export declare function clampInteger(value: number | undefined, fallback: number, min: number, max: number): number;
+export declare function clampScore(value: number | undefined): number;
+export declare function slug(value: string): string;
+export declare function hashId(prefix: string, parts: string[]): string;
+export declare function inferSubject(text: string, subjectHint: string | undefined): string;
+export declare function inferTrigger(text: string): string;
+export declare function inferScope(text: string): string;
+export declare function normalizePredicateToken(value: string): string;
+export declare function singularize(value: string): string;
+export declare function normalizeSubjectKey(value: string): string;
+export declare function escapeRegExp(value: string): string;
+export declare function matchesKeyword(text: string, lowerText: string, keyword: string): boolean;
+export declare function inferDuration(text: string): string;
+export declare function inferDurationUnit(text: string): string;
+export declare function inferResource(text: string): string;
+export declare function inferOperator(text: string): string;
+export declare function inferNumber(text: string): string;
+export declare function inferUnit(text: string): string;
+export declare function inferGate(text: string): string;
+export declare function inferEvent(text: string): string;
+//# sourceMappingURL=predicate-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"predicate-utils.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/predicate-utils.ts"],"names":[],"mappings":"AAKA,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQlD;AAGD,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,MAAM,GAAG,SAAS,CAGpB;AAGD,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,GAAG,SAAS,EACzB,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,GACV,MAAM,CAIR;AAGD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAM5D;AAGD,wBAAgB,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM1C;AAGD,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAO9D;AAGD,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,GAAG,SAAS,GAC9B,MAAM,CAWR;AAGD,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOjD;AAGD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM/C;AAGD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAQ7D;AAGD,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGjD;AAGD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEzD;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAElD;AAGD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,OAAO,CAOT;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD;AAGD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMtD;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMlD;AAGD,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAclD;AAGD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD;AAGD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM9C;AAGD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI9C;AAGD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/C"}

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

@@ -0,0 +1,187 @@
+import { createHash } from "node:crypto";
+const DEFAULT_MIN_SCORE = 0.35;
+// implements REQ-mcp-suggest-predicates
+export function normalizeText(text) {
+    const normalized = String(text ?? "").trim();
+    if (!normalized) {
+        throw new Error("Predicate suggestion failed: text must be a non-empty string");
+    }
+    return normalized;
+}
+// implements REQ-mcp-suggest-predicates
+export function normalizeOptionalString(value) {
+    const normalized = String(value ?? "").trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+// implements REQ-mcp-suggest-predicates
+export function clampInteger(value, fallback, min, max) {
+    const numeric = typeof value === "number" && Number.isFinite(value) ? value : fallback;
+    return Math.min(max, Math.max(min, Math.trunc(numeric)));
+}
+// implements REQ-mcp-suggest-predicates
+export function clampScore(value) {
+    const numeric = typeof value === "number" && Number.isFinite(value)
+        ? value
+        : DEFAULT_MIN_SCORE;
+    return Math.min(1, Math.max(0, numeric));
+}
+// implements REQ-mcp-suggest-predicates
+export function slug(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-mcp-suggest-predicates
+export function hashId(prefix, parts) {
+    const digest = createHash("sha256")
+        .update(parts.join("\u0000"))
+        .digest("hex")
+        .slice(0, 12)
+        .toUpperCase();
+    return `${prefix}-${digest}`;
+}
+// implements REQ-mcp-suggest-predicates
+export function inferSubject(text, subjectHint) {
+    const explicit = normalizeOptionalString(subjectHint);
+    if (explicit)
+        return explicit;
+    const lower = text.toLowerCase();
+    if (lower.includes("annotation"))
+        return "editor.annotation";
+    if (lower.includes("editor"))
+        return "editor";
+    if (lower.includes("session"))
+        return "session";
+    if (lower.includes("customer data"))
+        return "customer.data";
+    if (lower.includes("user"))
+        return "user";
+    return "requirement.subject";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferTrigger(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("navigate"))
+        return "navigation";
+    if (lower.includes("escape"))
+        return "escape";
+    if (lower.includes("cancel"))
+        return "cancel";
+    if (lower.includes("submit"))
+        return "submit";
+    return "unspecified_trigger";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferScope(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("draft"))
+        return "draft";
+    if (lower.includes("annotation"))
+        return "active_annotation";
+    if (lower.includes("session"))
+        return "session";
+    return "subject";
+}
+// implements REQ-mcp-suggest-predicates
+export function normalizePredicateToken(value) {
+    return value
+        .trim()
+        .replace(/\b(?:a|an|the)\b\s*/gi, "")
+        .replace(/['’]/g, "")
+        .replace(/\s+/g, "_")
+        .replace(/[^A-Za-z0-9_-]+/g, "_")
+        .replace(/^_+|_+$/g, "");
+}
+// implements REQ-mcp-suggest-predicates
+export function singularize(value) {
+    if (["changes", "status", "results"].includes(value))
+        return value;
+    return value.endsWith("s") && value.length > 3 ? value.slice(0, -1) : value;
+}
+// implements REQ-mcp-suggest-predicates
+export function normalizeSubjectKey(value) {
+    return slug(value).split("_").map(singularize).join(".");
+}
+// implements REQ-mcp-suggest-predicates
+export function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+// implements REQ-mcp-suggest-predicates
+export function matchesKeyword(text, lowerText, keyword) {
+    const normalized = keyword.toLowerCase();
+    if (/^[a-z0-9\s-]+$/.test(normalized)) {
+        const pattern = escapeRegExp(normalized).replace(/\s+/g, "\\s+");
+        return new RegExp(`\\b${pattern}\\b`, "i").test(text);
+    }
+    return lowerText.includes(normalized);
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDuration(text) {
+    return text.match(/\b\d+\b/)?.[0] ?? "1";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferDurationUnit(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("year"))
+        return "years";
+    if (lower.includes("month"))
+        return "months";
+    if (lower.includes("day"))
+        return "days";
+    return "unit";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferResource(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("latency"))
+        return "latency";
+    if (lower.includes("timeout"))
+        return "timeout";
+    if (lower.includes("size"))
+        return "size";
+    return "resource";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferOperator(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("minimum") || lower.includes("at least"))
+        return "gte";
+    if (lower.includes("not exceed") ||
+        lower.includes("not be more than") ||
+        lower.includes("no more than") ||
+        lower.includes("at most") ||
+        lower.includes("maximum")) {
+        return "lte";
+    }
+    if (lower.includes("not"))
+        return "neq";
+    return "lte";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferNumber(text) {
+    return text.match(/\b\d+(?:\.\d+)?\b/)?.[0] ?? "0";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferUnit(text) {
+    const lower = text.toLowerCase();
+    if (lower.includes("ms"))
+        return "ms";
+    if (lower.includes("seconds"))
+        return "seconds";
+    if (lower.includes("mb"))
+        return "mb";
+    return "unit";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferGate(text) {
+    const quoted = text.match(/[`'"](?<gate>[A-Za-z0-9_.:-]+)[`'"]/)?.groups
+        ?.gate;
+    return quoted ?? "feature_gate";
+}
+// implements REQ-mcp-suggest-predicates
+export function inferEvent(text) {
+    const eventName = text.match(/\b[A-Z][A-Za-z0-9]+Event\b/)?.[0];
+    return eventName ?? "domain_event";
+}

package/dist/operations/modeling/requirement-applyplan.d.ts

@@ -0,0 +1,4 @@
+import type { StrictWriteSet } from "../../public/check-types.js";
+export declare function strictWriteSetToApplyPlan(writeSet: StrictWriteSet): Array<Record<string, unknown>>;
+export declare function writeSetPrimaryEntityId(writeSet: StrictWriteSet): string;
+//# sourceMappingURL=requirement-applyplan.d.ts.map

package/dist/operations/modeling/requirement-applyplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-applyplan.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/requirement-applyplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAalE,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,cAAc,GACvB,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CA+BhC;AAGD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAExE"}

package/dist/operations/modeling/requirement-applyplan.js

@@ -0,0 +1,44 @@
+function toRelationshipPlanRows(relationships) {
+    return relationships.map((relationship) => ({
+        type: relationship.type,
+        from: relationship.from,
+        to: relationship.to,
+    }));
+}
+// implements REQ-002
+export function strictWriteSetToApplyPlan(writeSet) {
+    if (!writeSet.isStrict) {
+        return [
+            {
+                type: writeSet.observationFact.type,
+                id: writeSet.observationFact.id,
+                properties: writeSet.observationFact.properties,
+                relationships: [],
+            },
+        ];
+    }
+    return [
+        {
+            type: writeSet.subjectFact.type,
+            id: writeSet.subjectFact.id,
+            properties: writeSet.subjectFact.properties,
+            relationships: [],
+        },
+        {
+            type: writeSet.propertyFact.type,
+            id: writeSet.propertyFact.id,
+            properties: writeSet.propertyFact.properties,
+            relationships: [],
+        },
+        {
+            type: writeSet.req.type,
+            id: writeSet.req.id,
+            properties: writeSet.req.properties,
+            relationships: toRelationshipPlanRows(writeSet.relationships),
+        },
+    ];
+}
+// implements REQ-002
+export function writeSetPrimaryEntityId(writeSet) {
+    return writeSet.isStrict ? writeSet.req.id : writeSet.observationFact.id;
+}

package/dist/operations/modeling/requirement-heuristics.d.ts

@@ -0,0 +1,4 @@
+import type { ExtractedRequirementClaim } from "./requirement-types.js";
+export declare function buildFallbackClaim(statement: string, source: string, confidence: number, provenance: string | undefined): ExtractedRequirementClaim;
+export declare function extractHeuristicClaim(statement: string, source: string, confidence: number, provenance: string | undefined): ExtractedRequirementClaim | null;
+//# sourceMappingURL=requirement-heuristics.d.ts.map

package/dist/operations/modeling/requirement-heuristics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-heuristics.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/requirement-heuristics.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAkBxE,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,yBAAyB,CAgB3B;AAGD,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GAAG,SAAS,GAC7B,yBAAyB,GAAG,IAAI,CA2FlC"}

package/dist/operations/modeling/requirement-heuristics.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import { cleanPredicate, cleanSubject, stripListPrefix, } from "./requirement-utils.js";
+const STRICT_FALLBACK_CONFIDENCE = 0.69;
+function fallbackSubjectFromSource(source) {
+    const basename = path
+        .basename(source, path.extname(source))
+        .replace(/[-_]+/g, " ")
+        .trim();
+    return basename || "Requirement";
+}
+// implements REQ-002
+export function buildFallbackClaim(statement, source, confidence, provenance) {
+    return {
+        claim: {
+            source,
+            subjectKey: fallbackSubjectFromSource(source),
+            propertyKey: "statement",
+            operator: "eq",
+            value: statement,
+            confidence: Math.min(confidence, STRICT_FALLBACK_CONFIDENCE),
+            ...(provenance ? { provenance } : {}),
+        },
+        extractionMode: "fallback",
+        extractionWarnings: [
+            "Deterministic claim extraction could not infer a strict semantic claim; emitted a review artifact instead.",
+        ],
+    };
+}
+// implements REQ-002
+export function extractHeuristicClaim(statement, source, confidence, provenance) {
+    const normalized = stripListPrefix(statement);
+    const retentionMatch = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+retained\s+for\s+(?<value>\d+)\s+(?<unit>day|days|month|months|year|years)\.?$/i);
+    if (retentionMatch?.groups) {
+        const { unit, subject, value } = retentionMatch.groups;
+        if (!unit || !subject || !value)
+            return null;
+        const normalizedUnit = unit.toLowerCase().startsWith("day")
+            ? "Days"
+            : unit.toLowerCase().startsWith("month")
+                ? "Months"
+                : "Years";
+        return {
+            claim: {
+                source,
+                subjectKey: cleanSubject(subject),
+                propertyKey: `Retention ${normalizedUnit}`,
+                operator: "eq",
+                value: Number(value),
+                confidence,
+                ...(provenance ? { provenance } : {}),
+            },
+            extractionMode: "heuristic",
+            extractionWarnings: [],
+        };
+    }
+    const enabledMatch = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+be\s+(?<state>enabled|disabled)\.?$/i);
+    if (enabledMatch?.groups) {
+        const { subject, state } = enabledMatch.groups;
+        if (!subject || !state)
+            return null;
+        return {
+            claim: {
+                source,
+                subjectKey: cleanSubject(subject),
+                propertyKey: "enabled",
+                operator: "bool",
+                value: state.toLowerCase() === "enabled",
+                confidence,
+                ...(provenance ? { provenance } : {}),
+            },
+            extractionMode: "heuristic",
+            extractionWarnings: [],
+        };
+    }
+    const forbiddenMatch = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+not\s+(?<predicate>.+?)\.?$/i);
+    if (forbiddenMatch?.groups) {
+        const { subject, predicate } = forbiddenMatch.groups;
+        if (!subject || !predicate)
+            return null;
+        return {
+            claim: {
+                source,
+                subjectKey: cleanSubject(subject),
+                propertyKey: cleanPredicate(predicate),
+                operator: "polarity",
+                value: "forbid",
+                confidence,
+                ...(provenance ? { provenance } : {}),
+            },
+            extractionMode: "heuristic",
+            extractionWarnings: [],
+        };
+    }
+    const requiredMatch = normalized.match(/^(?<subject>.+?)\s+(?:must|shall|should)\s+(?<predicate>.+?)\.?$/i);
+    if (requiredMatch?.groups) {
+        const { subject, predicate } = requiredMatch.groups;
+        if (!subject || !predicate)
+            return null;
+        return {
+            claim: {
+                source,
+                subjectKey: cleanSubject(subject),
+                propertyKey: cleanPredicate(predicate),
+                operator: "polarity",
+                value: "require",
+                confidence,
+                ...(provenance ? { provenance } : {}),
+            },
+            extractionMode: "heuristic",
+            extractionWarnings: [],
+        };
+    }
+    return null;
+}

package/dist/operations/modeling/requirement-modeler.d.ts

@@ -0,0 +1,8 @@
+import type { ExtractedRequirementClaim, ModelRequirementArgs } from "./requirement-types.js";
+export declare function estimateNormativeSignalConfidence(statement: string, heading?: string): number;
+export declare function extractRequirementClaim(args: ModelRequirementArgs): ExtractedRequirementClaim & {
+    statement: string;
+    source: string;
+    sourceFiles: string[];
+};
+//# sourceMappingURL=requirement-modeler.d.ts.map

package/dist/operations/modeling/requirement-modeler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requirement-modeler.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/requirement-modeler.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,yBAAyB,EACzB,oBAAoB,EACrB,MAAM,wBAAwB,CAAC;AAsBhC,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,MAAM,CAUR;AAGD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,oBAAoB,GACzB,yBAAyB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAyDA"}