kibi-cli 2.3.0 → 2.5.0

package/dist/operations/migration/source-paths.js

@@ -0,0 +1,308 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { ENTITY_LANES, KB_PATHS, KB_ROOT } from "../../utils/kb-paths.js";
+import { listLaneMarkdownFiles, readText, readTopLevelField, sliceFrontmatter, withTopLevelField, withoutTopLevelField, writeFileAtomically, } from "./kb-sources.js";
+const URL_PATTERN = /^https?:\/\/\S+$/i;
+const LEGACY_ROOT = "documentation/";
+const SYMBOL_ID_LINE = /^[ \t]*-?[ \t]*id[ \t]*:[ \t]*(.+?)[ \t]*$/gm;
+const SOURCE_EDIT_REFUSED = "the source field spans several lines, or editing it would change other frontmatter fields";
+function scalarText(value) {
+    if (typeof value === "string")
+        return value.trim();
+    if (typeof value === "number")
+        return String(value);
+    return undefined;
+}
+function unquote(value) {
+    return value.replace(/^(['"])(.*)\1$/, "$2");
+}
+/** An authored value as plain text, the form plans record and compare. */
+// implements REQ-core-validation-rules, REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function shownSourceValue(value) {
+    return typeof value === "string" ? value : (JSON.stringify(value) ?? "");
+}
+/**
+ * Read every authored entity's `source` field and id in one pass over the
+ * canonical lanes, plus the symbol ids of the symbols manifest. Only the id
+ * and source lines are parsed. Read-only.
+ */
+// implements REQ-core-validation-rules, REQ-cli-schema-migration, REQ-kibi-kb-lifecycle-integrity
+export function scanAuthoredSources(workspaceRoot) {
+    const refs = [];
+    const entityIds = new Set();
+    for (const file of listLaneMarkdownFiles(workspaceRoot)) {
+        const content = readText(file.absolutePath);
+        if (content === null)
+            continue;
+        const slice = sliceFrontmatter(content);
+        if (slice === null)
+            continue;
+        const id = scalarText(readTopLevelField(slice.text, "id")) ||
+            path.basename(file.relativePath, ".md");
+        entityIds.add(id);
+        const value = readTopLevelField(slice.text, "source");
+        if (value === undefined || value === null)
+            continue;
+        if (typeof value === "string" && value.trim() === "")
+            continue;
+        refs.push({ entityId: id, file: file.relativePath, value });
+    }
+    const symbols = readText(path.join(workspaceRoot, KB_PATHS.symbolsManifest));
+    if (symbols !== null) {
+        for (const match of symbols.matchAll(SYMBOL_ID_LINE)) {
+            const id = unquote(match[1] ?? "");
+            if (id !== "")
+                entityIds.add(id);
+        }
+    }
+    return { refs, entityIds };
+}
+const LEGACY_LANE_ROOTS = new Set([...ENTITY_LANES, "symbols.yaml"]);
+/**
+ * Resolve one authored `source` value: an existing workspace path (any
+ * `#anchor` suffix ignored), an existing entity id or an http(s) URL. With
+ * the entity's own `file`, a value naming that file (canonical or
+ * pre-canonical spelling, `./` and `#anchor` ignored, compared
+ * case-insensitively) resolves to `self`. A dangling
+ * `documentation/<lane>/...` or `<lane>/...` value carries the
+ * `.kb/<lane>/...` rewrite when that file exists.
+ */
+// implements REQ-core-validation-rules, REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function resolveAuthoredSource(value, context) {
+    if (value === undefined || value === null)
+        return { kind: "missing" };
+    const text = scalarText(value);
+    if (text === undefined)
+        return { kind: "dangling" };
+    if (text === "")
+        return { kind: "missing" };
+    if (URL_PATTERN.test(text))
+        return { kind: "url" };
+    if (context.entityIds.has(text))
+        return { kind: "entity" };
+    const hash = text.indexOf("#");
+    const anchor = hash >= 0 ? text.slice(hash) : "";
+    const relative = (hash >= 0 ? text.slice(0, hash) : text)
+        .trim()
+        .replaceAll("\\", "/")
+        .replace(/^\.\//, "");
+    const own = context.file?.toLowerCase();
+    const exists = relative !== "" && context.exists(relative);
+    if (own !== undefined && relative.toLowerCase() === own) {
+        return { kind: "self", resolves: exists };
+    }
+    // Another existing file is provenance, even when its path would map onto
+    // the entity's own file under .kb/.
+    if (exists)
+        return { kind: "path" };
+    const lower = relative.toLowerCase();
+    const legacy = lower.startsWith(LEGACY_ROOT)
+        ? lower.slice(LEGACY_ROOT.length)
+        : lower;
+    if (own !== undefined && `${KB_ROOT}/${legacy}` === own) {
+        return { kind: "self", resolves: false };
+    }
+    const rest = relative.startsWith(LEGACY_ROOT)
+        ? relative.slice(LEGACY_ROOT.length)
+        : relative;
+    const lane = rest.split("/")[0] ?? "";
+    const target = `${KB_ROOT}/${rest}`;
+    if (LEGACY_LANE_ROOTS.has(lane) && context.exists(target)) {
+        return { kind: "dangling", rewrite: `${target}${anchor}` };
+    }
+    return { kind: "dangling" };
+}
+/** A memoized existence test confined to the workspace. */
+// implements REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function workspacePathExists(workspaceRoot) {
+    const root = path.resolve(workspaceRoot);
+    const cache = new Map();
+    return (relativePath) => {
+        const cached = cache.get(relativePath);
+        if (cached !== undefined)
+            return cached;
+        const absolute = path.resolve(root, relativePath);
+        const fromRoot = path.relative(root, absolute);
+        const exists = !fromRoot.startsWith("..") &&
+            !path.isAbsolute(fromRoot) &&
+            existsSync(absolute);
+        cache.set(relativePath, exists);
+        return exists;
+    };
+}
+function repairFor(ref, resolution) {
+    if (resolution.kind === "self") {
+        return {
+            ...ref,
+            dangling: !resolution.resolves,
+            fix: { kind: "remove", reason: "self" },
+        };
+    }
+    if (resolution.kind !== "dangling")
+        return undefined;
+    return {
+        ...ref,
+        dangling: true,
+        fix: resolution.rewrite !== undefined
+            ? { kind: "rewrite", to: resolution.rewrite }
+            : { kind: "remove", reason: "dangling" },
+    };
+}
+function editedContent(content, fix) {
+    return fix.kind === "rewrite"
+        ? withTopLevelField(content, "source", fix.to)
+        : withoutTopLevelField(content, "source");
+}
+/** Every repairable source value, sorted by entity id. Read-only. */
+function classifySources(workspaceRoot) {
+    const scan = scanAuthoredSources(workspaceRoot);
+    const exists = workspacePathExists(workspaceRoot);
+    const repairs = [];
+    for (const ref of scan.refs) {
+        const repair = repairFor(ref, resolveAuthoredSource(ref.value, {
+            workspaceRoot,
+            entityIds: scan.entityIds,
+            exists,
+            file: ref.file,
+        }));
+        if (repair !== undefined)
+            repairs.push(repair);
+    }
+    return repairs.sort((left, right) => left.entityId.localeCompare(right.entityId) ||
+        left.file.localeCompare(right.file));
+}
+/** Mark the repairs whose edit would not read back as exactly that change. */
+function withEditability(workspaceRoot, repairs) {
+    return repairs.map((repair) => {
+        const content = readText(path.join(workspaceRoot, repair.file));
+        if (content !== null && editedContent(content, repair.fix) !== null) {
+            return repair;
+        }
+        return {
+            ...repair,
+            refused: content === null
+                ? "the entity file cannot be read"
+                : SOURCE_EDIT_REFUSED,
+        };
+    });
+}
+/**
+ * Every authored `source` value that resolves to nothing, sorted by entity
+ * id, with the fix `kibi migrate` makes and, when the edit is not safe, why.
+ * Each path is checked once per call. Read-only.
+ */
+// implements REQ-core-validation-rules, REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function findDanglingSources(workspaceRoot) {
+    return withEditability(workspaceRoot, classifySources(workspaceRoot).filter((repair) => repair.dangling));
+}
+/**
+ * Every authored `source` value `kibi migrate` rewrites or removes: the
+ * dangling ones plus existing values that name the entity's own file.
+ * Read-only.
+ */
+// implements REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function findSourceRepairs(workspaceRoot) {
+    return withEditability(workspaceRoot, classifySources(workspaceRoot));
+}
+function plannedRepair(repair) {
+    const base = {
+        entityId: repair.entityId,
+        file: repair.file,
+        from: shownSourceValue(repair.value),
+    };
+    return repair.fix.kind === "rewrite"
+        ? { ...base, to: repair.fix.to }
+        : { ...base, reason: repair.fix.reason };
+}
+/**
+ * The rewrite and removal records a migration plan lists for these repairs.
+ * Repairs Kibi cannot edit safely are left out; they need a person.
+ */
+// implements REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function plannedSourcePathRepairs(repairs) {
+    const rewrites = [];
+    const removals = [];
+    for (const repair of repairs) {
+        if (repair.refused !== undefined)
+            continue;
+        const planned = plannedRepair(repair);
+        if ("to" in planned)
+            rewrites.push(planned);
+        else
+            removals.push(planned);
+    }
+    return { rewrites, removals };
+}
+function samePlannedRepair(left, right) {
+    if (left.entityId !== right.entityId || left.from !== right.from) {
+        return false;
+    }
+    if ("to" in left)
+        return "to" in right && left.to === right.to;
+    return "reason" in right && left.reason === right.reason;
+}
+/**
+ * Repair each redundant or dead `source` value, editing only its line: a
+ * moved knowledge file is rewritten to its `.kb/` path, and a value naming
+ * the entity's own file or nothing Kibi can map is removed. With `planned`,
+ * only those repairs are applied, and only while the value still reads as
+ * planned. A value that cannot be edited safely is skipped with a reason.
+ * Idempotent: a repaired value is not found again.
+ */
+// implements REQ-kibi-schema6-migration, REQ-kibi-kb-lifecycle-integrity
+export function applySourcePathRepairs(workspaceRoot, planned) {
+    const wanted = planned === undefined
+        ? undefined
+        : new Map([...planned.rewrites, ...planned.removals].map((repair) => [
+            repair.file,
+            repair,
+        ]));
+    const rewritten = [];
+    const removed = [];
+    const skipped = [];
+    for (const repair of classifySources(workspaceRoot)) {
+        const current = plannedRepair(repair);
+        if (wanted !== undefined) {
+            const plan = wanted.get(repair.file);
+            if (plan === undefined)
+                continue;
+            if (!samePlannedRepair(plan, current)) {
+                skipped.push({
+                    file: repair.file,
+                    reason: "source changed since planning",
+                });
+                continue;
+            }
+        }
+        const absolute = path.join(workspaceRoot, repair.file);
+        const content = readText(absolute);
+        const next = content === null ? null : editedContent(content, repair.fix);
+        if (next === null) {
+            skipped.push({ file: repair.file, reason: SOURCE_EDIT_REFUSED });
+            continue;
+        }
+        writeFileAtomically(absolute, next);
+        if ("to" in current)
+            rewritten.push(current);
+        else
+            removed.push(current);
+    }
+    return { rewritten, removed, skipped };
+}

package/dist/operations/migration/superseded-closure.d.ts

@@ -0,0 +1,54 @@
+/**
+ * A requirement another requirement supersedes is retired and must be
+ * closed (the superseded-requirement-open rule). This module reads authored
+ * sources, so the migration can plan before the KB compiles: superseded
+ * requirements that are not closed, and supersession cycles, which no status
+ * edit can resolve.
+ */
+/** The terminal requirement status. */
+export declare const CLOSED_REQUIREMENT_STATUS = "closed";
+/** A superseded requirement whose status is not closed. */
+export type SupersededClosure = Readonly<{
+    id: string;
+    /** Workspace-relative path of the requirement's file. */
+    path: string;
+    status: string;
+    supersededBy: readonly string[];
+}>;
+/** Requirements that supersede each other, directly or through a chain. */
+export type SupersessionCycle = Readonly<{
+    members: readonly string[];
+    edges: readonly (readonly [string, string])[];
+    files: readonly string[];
+}>;
+export type SupersessionPlan = Readonly<{
+    closures: readonly SupersededClosure[];
+    cycles: readonly SupersessionCycle[];
+}>;
+/**
+ * Sets of nodes that reach each other through the given edges (every
+ * strongly connected component that contains a cycle), as sorted member
+ * lists sorted by first member.
+ */
+export declare function supersessionCycles(edges: readonly (readonly [string, string])[]): string[][];
+/**
+ * Superseded requirements that are not closed, and supersession cycles,
+ * read from authored Markdown and relationship shards. Cycle members are
+ * listed only under their cycle. Read-only.
+ */
+export declare function planSupersededClosures(workspaceRoot: string): SupersessionPlan;
+export type SupersededClosureResult = Readonly<{
+    closed: readonly SupersededClosure[];
+    skipped: readonly Readonly<{
+        path: string;
+        reason: string;
+    }>[];
+}>;
+/**
+ * Set `status: closed` on each superseded requirement that is not closed,
+ * editing only the status line (or appending it). Requirements in a
+ * supersession cycle are never touched. With `planned`, only those ids are
+ * closed. Idempotent: a closed requirement is not planned again.
+ */
+export declare function applySupersededClosures(workspaceRoot: string, planned?: ReadonlySet<string>): SupersededClosureResult;
+//# sourceMappingURL=superseded-closure.d.ts.map

package/dist/operations/migration/superseded-closure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"superseded-closure.d.ts","sourceRoot":"","sources":["../../../src/operations/migration/superseded-closure.ts"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AAEH,uCAAuC;AAEvC,eAAO,MAAM,yBAAyB,WAAW,CAAC;AAElD,2DAA2D;AAE3D,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,EAAE,EAAE,MAAM,CAAC;IACX,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CACjC,CAAC,CAAC;AAEH,2EAA2E;AAE3E,MAAM,MAAM,iBAAiB,GAAG,QAAQ,CAAC;IACvC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;IAC3B,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,CAAC;IAC9C,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1B,CAAC,CAAC;AAGH,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IACtC,QAAQ,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACvC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CACtC,CAAC,CAAC;AAmBH;;;;GAIG;AAEH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,GAC5C,MAAM,EAAE,EAAE,CA0BZ;AAgDD;;;;GAIG;AAEH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,MAAM,GACpB,gBAAgB,CA0ClB;AAGD,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACrC,OAAO,EAAE,SAAS,QAAQ,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,EAAE,CAAC;CAChE,CAAC,CAAC;AAEH;;;;;GAKG;AAEH,wBAAgB,uBAAuB,CACrC,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5B,uBAAuB,CAsBzB"}

package/dist/operations/migration/superseded-closure.js

@@ -0,0 +1,187 @@
+/*
+ Kibi — repo-local, per-branch, queryable long-term memory for software projects
+ Copyright (C) 2026 Piotr Franczyk
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+import path from "node:path";
+import { extractFromMarkdown, } from "../../extractors/markdown.js";
+import { readAllShards } from "../../relationships/shards.js";
+import { listLaneMarkdownFiles, readText, withTopLevelField, writeFileAtomically, } from "./kb-sources.js";
+/**
+ * A requirement another requirement supersedes is retired and must be
+ * closed (the superseded-requirement-open rule). This module reads authored
+ * sources, so the migration can plan before the KB compiles: superseded
+ * requirements that are not closed, and supersession cycles, which no status
+ * edit can resolve.
+ */
+/** The terminal requirement status. */
+// implements REQ-cli-schema-migration, REQ-kibi-kb-lifecycle-integrity
+export const CLOSED_REQUIREMENT_STATUS = "closed";
+function reachable(adjacency, start) {
+    const seen = new Set();
+    const queue = [...(adjacency.get(start) ?? [])];
+    while (queue.length > 0) {
+        const node = queue.shift();
+        if (seen.has(node))
+            continue;
+        seen.add(node);
+        queue.push(...(adjacency.get(node) ?? []));
+    }
+    return seen;
+}
+/**
+ * Sets of nodes that reach each other through the given edges (every
+ * strongly connected component that contains a cycle), as sorted member
+ * lists sorted by first member.
+ */
+// implements REQ-core-validation-rules, REQ-kibi-kb-lifecycle-integrity
+export function supersessionCycles(edges) {
+    const adjacency = new Map();
+    for (const [from, to] of edges) {
+        adjacency.set(from, [...(adjacency.get(from) ?? []), to]);
+    }
+    const reach = new Map();
+    const reachOf = (node) => {
+        let nodes = reach.get(node);
+        if (nodes === undefined) {
+            nodes = reachable(adjacency, node);
+            reach.set(node, nodes);
+        }
+        return nodes;
+    };
+    const components = new Map();
+    for (const start of [...adjacency.keys()].sort()) {
+        const fromStart = reachOf(start);
+        if (!fromStart.has(start))
+            continue;
+        const members = [...fromStart]
+            .filter((node) => reachOf(node).has(start))
+            .sort();
+        components.set(members.join("\u0000"), members);
+    }
+    return [...components.values()].sort((left, right) => (left[0] ?? "").localeCompare(right[0] ?? ""));
+}
+function readRequirementsAndEdges(workspaceRoot) {
+    const requirements = new Map();
+    const relationships = [];
+    for (const file of listLaneMarkdownFiles(workspaceRoot, ["requirements"])) {
+        try {
+            const result = extractFromMarkdown(file.absolutePath);
+            requirements.set(result.entity.id, {
+                id: result.entity.id,
+                status: String(result.entity.status ?? "").trim(),
+                path: file.relativePath,
+            });
+            relationships.push(...result.relationships);
+        }
+        catch {
+            // Unreadable requirements fail sync with their own diagnostic.
+        }
+    }
+    try {
+        relationships.push(...readAllShards(path.join(workspaceRoot, ".kb")));
+    }
+    catch {
+        // Malformed shards fail sync with their own diagnostic.
+    }
+    const edges = new Map();
+    for (const relationship of relationships) {
+        if (relationship.type !== "supersedes" ||
+            !requirements.has(relationship.to)) {
+            continue;
+        }
+        edges.set(`${relationship.from}\u0000${relationship.to}`, [
+            relationship.from,
+            relationship.to,
+        ]);
+    }
+    return {
+        requirements,
+        edges: [...edges.values()].sort(([leftFrom, leftTo], [rightFrom, rightTo]) => leftFrom.localeCompare(rightFrom) || leftTo.localeCompare(rightTo)),
+    };
+}
+/**
+ * Superseded requirements that are not closed, and supersession cycles,
+ * read from authored Markdown and relationship shards. Cycle members are
+ * listed only under their cycle. Read-only.
+ */
+// implements REQ-core-validation-rules, REQ-cli-schema-migration, REQ-kibi-kb-lifecycle-integrity
+export function planSupersededClosures(workspaceRoot) {
+    const { requirements, edges } = readRequirementsAndEdges(workspaceRoot);
+    const cycles = supersessionCycles(edges);
+    const inCycle = new Set(cycles.flat());
+    const successors = new Map();
+    for (const [from, to] of edges) {
+        successors.set(to, [...(successors.get(to) ?? []), from]);
+    }
+    const closures = [];
+    for (const [id, supersededBy] of [...successors.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        const requirement = requirements.get(id);
+        if (requirement === undefined ||
+            inCycle.has(id) ||
+            requirement.status === CLOSED_REQUIREMENT_STATUS) {
+            continue;
+        }
+        closures.push({
+            id,
+            path: requirement.path,
+            status: requirement.status,
+            supersededBy: [...new Set(supersededBy)].sort(),
+        });
+    }
+    return {
+        closures,
+        cycles: cycles.map((members) => {
+            const memberSet = new Set(members);
+            return {
+                members,
+                edges: edges.filter(([from, to]) => memberSet.has(from) && memberSet.has(to)),
+                files: members
+                    .map((member) => requirements.get(member)?.path)
+                    .filter((file) => file !== undefined),
+            };
+        }),
+    };
+}
+/**
+ * Set `status: closed` on each superseded requirement that is not closed,
+ * editing only the status line (or appending it). Requirements in a
+ * supersession cycle are never touched. With `planned`, only those ids are
+ * closed. Idempotent: a closed requirement is not planned again.
+ */
+// implements REQ-cli-schema-migration, REQ-kibi-kb-lifecycle-integrity
+export function applySupersededClosures(workspaceRoot, planned) {
+    const closed = [];
+    const skipped = [];
+    for (const closure of planSupersededClosures(workspaceRoot).closures) {
+        if (planned !== undefined && !planned.has(closure.id))
+            continue;
+        const absolute = path.join(workspaceRoot, closure.path);
+        const content = readText(absolute);
+        const next = content === null
+            ? null
+            : withTopLevelField(content, "status", CLOSED_REQUIREMENT_STATUS);
+        if (next === null) {
+            skipped.push({
+                path: closure.path,
+                reason: "status could not be set without changing other fields",
+            });
+            continue;
+        }
+        writeFileAtomically(absolute, next);
+        closed.push(closure);
+    }
+    return { closed, skipped };
+}

package/dist/operations/modeling/logic-modeling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logic-modeling.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/logic-modeling.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,WAAW,EAIjB,MAAM,mBAAmB,CAAC;AAO3B,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACpD;AAUD,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,mBAAmB,GACzB,oBAAoB,CAsHtB"}
+{"version":3,"file":"logic-modeling.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/logic-modeling.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,WAAW,EAIjB,MAAM,mBAAmB,CAAC;AAQ3B,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACjD,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,WAAW,CAAC;IACjC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACpD;AAUD,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAE3D;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,mBAAmB,GACzB,oBAAoB,CAkHtB"}

package/dist/operations/modeling/logic-modeling.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { logicSemanticKey, utf8Span, validateLogicIr, } from "../../logic/ir.js";
-import { normalizeSemanticClause, semanticClaimKey, } from "../semantic-advisor/clauses.js";
+import { modeledClaimRole, normalizeSemanticClause, semanticClaimKey, } from "../semantic-advisor/clauses.js";
 import { semanticSourceHash } from "../semantic-advisor/shared.js";
 function shortId(value) {
     return createHash("sha256")
@@ -63,7 +63,7 @@ export function buildLogicApplyPlan(input) {
                 type: "fact",
                 id: ruleId,
                 properties: {
-                    title: `${validation.normalized.kind} rule ${semanticKey}`,
+                    title: `Rule: ${claimText}`,
                     status: "active",
                     source: input.source,
                     fact_kind: "rule",
@@ -98,9 +98,7 @@ export function buildLogicApplyPlan(input) {
                         {
                             claim_key: claimKey,
                             claim_text: claimText,
-                            role: /\b(?:must|shall|should|required|requires?)\b/i.test(claimText)
-                                ? "normative"
-                                : "descriptive",
+                            role: modeledClaimRole(claimText, validation.normalized.modality),
                             status: "modeled",
                             span,
                             semantic_key: semanticKey,

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

@@ -1 +1 @@
-{"version":3,"file":"model-requirement.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/model-requirement.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAYjF,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,iCAAiC,EACjC,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,wBAAwB,CAAC;AAUhC,YAAY,EACV,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAkNhC,OAAO,EACL,iCAAiC,EACjC,uBAAuB,EACvB,yBAAyB,EACzB,uBAAuB,GACxB,CAAC;AAIF,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,GACA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAgDzB;AAED,wBAAsB,4BAA4B,CAChD,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAIxB;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,oBAAoB,EAC1B,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAoIjC;AAED,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,sBAAsB,CAAC,CAajC"}
+{"version":3,"file":"model-requirement.d.ts","sourceRoot":"","sources":["../../../src/operations/modeling/model-requirement.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0CAA0C,CAAC;AAgBjF,OAAO,EACL,yBAAyB,EACzB,uBAAuB,EACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,iCAAiC,EACjC,uBAAuB,EACxB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,wBAAwB,CAAC;AAUhC,YAAY,EACV,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC;AAkNhC,OAAO,EACL,iCAAiC,EACjC,uBAAuB,EACvB,yBAAyB,EACzB,uBAAuB,GACxB,CAAC;AAIF,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,OAAO,EAAE;IACP,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,GACA,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA4CzB;AA+OD,wBAAsB,4BAA4B,CAChD,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAIxB;AAED,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,oBAAoB,EAC1B,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAgHjC;AAED,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,oBAAoB,EAC1B,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,sBAAsB,CAAC,CAajC"}