kibi-cli 0.7.0 → 0.10.0

package/dist/utils/schema-version.js

@@ -0,0 +1,59 @@
+// implements REQ-003
+export const LATEST_KB_SCHEMA_VERSION = 1;
+// implements REQ-003
+export function normalizeSchemaVersion(schemaVersion) {
+    if (schemaVersion === undefined || schemaVersion === null) {
+        return null;
+    }
+    if (typeof schemaVersion === "number") {
+        return Number.isInteger(schemaVersion) ? schemaVersion : null;
+    }
+    const trimmed = schemaVersion.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    const parsed = Number(trimmed);
+    return Number.isInteger(parsed) ? parsed : null;
+}
+// implements REQ-003
+export function getSchemaVersionStatus(config) {
+    const latestVersion = LATEST_KB_SCHEMA_VERSION;
+    const hasSchemaVersion = config !== null && config !== undefined && "schemaVersion" in config;
+    const currentVersion = normalizeSchemaVersion(config?.schemaVersion);
+    if (currentVersion === null) {
+        return {
+            status: hasSchemaVersion ? "invalid" : "missing",
+            currentVersion: null,
+            latestVersion,
+            needsMigration: true,
+            warning: hasSchemaVersion
+                ? "KB config schemaVersion is invalid and should be migrated."
+                : "KB config schemaVersion is missing; legacy config should be migrated.",
+        };
+    }
+    if (currentVersion > latestVersion) {
+        return {
+            status: "newer",
+            currentVersion,
+            latestVersion,
+            needsMigration: false,
+            warning: `KB config schemaVersion ${currentVersion} is newer than the latest supported version ${latestVersion}.`,
+        };
+    }
+    if (currentVersion < latestVersion) {
+        return {
+            status: "older",
+            currentVersion,
+            latestVersion,
+            needsMigration: true,
+            warning: `KB config schemaVersion ${currentVersion} is older than the latest version ${latestVersion} and should be migrated.`,
+        };
+    }
+    return {
+        status: "current",
+        currentVersion,
+        latestVersion,
+        needsMigration: false,
+        warning: null,
+    };
+}

package/dist/utils/strict-modeling.d.ts

@@ -0,0 +1,64 @@
+import { type KbConfigPaths } from "./config.js";
+import type { BaseEntity, FactFields } from "../types/entities.js";
+import type { BaseRelationship } from "../types/relationships.js";
+export interface SemanticClaim {
+    source: string;
+    subjectKey: string;
+    propertyKey: string;
+    operator: "eq" | "gte" | "lte" | "neq" | "bool" | "polarity";
+    value: string | number | boolean;
+    confidence: number;
+    provenance?: string;
+}
+export interface StrictModelInput {
+    claim: SemanticClaim;
+    statement: string;
+    config?: Pick<{
+        paths: KbConfigPaths;
+    }, "paths">;
+}
+type EntityProperties = Partial<Omit<BaseEntity, "created_at" | "updated_at"> & FactFields> & {
+    id: string;
+    title: string;
+    status: string;
+    source: string;
+};
+export interface EntitySpec<TType extends "req" | "fact" = "req" | "fact", TProperties extends EntityProperties = EntityProperties> {
+    type: TType;
+    id: string;
+    properties: TProperties;
+}
+export type RelationshipSpec = Pick<BaseRelationship, "type" | "from" | "to" | "source" | "confidence">;
+export interface StableRequirementIds {
+    stableKey: string;
+    reqId: string;
+    subjectFactId: string;
+    propertyFactId: string;
+    observationFactId: string;
+    normalizedSource: string;
+    normalizedSubjectKey: string;
+    normalizedPropertyKey: string;
+    normalizedValue: string;
+}
+interface StrictRequirementWriteSet {
+    req: EntitySpec<"req">;
+    subjectFact: EntitySpec<"fact">;
+    propertyFact: EntitySpec<"fact">;
+    relationships: RelationshipSpec[];
+    isStrict: true;
+    confidence: number;
+}
+interface ObservationWriteSet {
+    observationFact: EntitySpec<"fact">;
+    relationships: RelationshipSpec[];
+    isStrict: false;
+    confidence: number;
+}
+export type StrictWriteSet = StrictRequirementWriteSet | ObservationWriteSet;
+export declare function normalizeSubjectKey(value: string): string;
+export declare function normalizePropertyKey(value: string): string;
+export declare function buildStableRequirementIds(claim: SemanticClaim): StableRequirementIds;
+export declare function buildStrictWriteSet(input: StrictModelInput): StrictWriteSet;
+export declare function modelRequirementClaims(inputs: ReadonlyArray<StrictModelInput>): StrictWriteSet[];
+export {};
+//# sourceMappingURL=strict-modeling.d.ts.map

package/dist/utils/strict-modeling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict-modeling.d.ts","sourceRoot":"","sources":["../../src/utils/strict-modeling.ts"],"names":[],"mappings":"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"}

package/dist/utils/strict-modeling.js

@@ -0,0 +1,371 @@
+/*
+ * 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 { createHash } from "node:crypto";
+import * as path from "node:path";
+import { DEFAULT_CONFIG } from "./config.js";
+const STRICT_CONFIDENCE_THRESHOLD = 0.7;
+export function normalizeSubjectKey(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[\\/]+/g, ".")
+        .replace(/[^a-z0-9.]+/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/\.+/g, ".")
+        .replace(/(^[._]+|[._]+$)/g, "");
+    if (!normalized) {
+        throw new Error("Semantic claim subjectKey must normalize to a non-empty value");
+    }
+    return normalized;
+}
+export function normalizePropertyKey(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    if (!normalized) {
+        throw new Error("Semantic claim propertyKey must normalize to a non-empty value");
+    }
+    return normalized;
+}
+export function buildStableRequirementIds(claim) {
+    const normalizedSource = normalizeSourceKey(claim.source);
+    const normalizedSubjectKey = normalizeSubjectKey(claim.subjectKey);
+    const normalizedPropertyKey = normalizePropertyKey(claim.propertyKey);
+    const normalizedValue = normalizeStableValue(claim.value);
+    const stableKey = [
+        normalizedSource,
+        normalizedSubjectKey,
+        normalizedPropertyKey,
+        claim.operator,
+        normalizedValue,
+    ].join(":");
+    return {
+        stableKey,
+        reqId: buildEntityId("REQ-AUTO", `req:${stableKey}`),
+        subjectFactId: buildEntityId("FACT-SUBJECT", `subject:${stableKey}`),
+        propertyFactId: buildEntityId("FACT-PROP", `property:${stableKey}`),
+        observationFactId: buildEntityId("FACT-OBS", `observation:${stableKey}`),
+        normalizedSource,
+        normalizedSubjectKey,
+        normalizedPropertyKey,
+        normalizedValue,
+    };
+}
+export function buildStrictWriteSet(input) {
+    const statement = normalizeStatement(input.statement);
+    const confidence = normalizeConfidence(input.claim.confidence);
+    const ids = buildStableRequirementIds(input.claim);
+    const textRef = normalizeTextRef(input.claim.provenance, input.claim.source);
+    const metadataTags = buildMetadataTags({
+        confidence,
+        provenance: textRef,
+    });
+    const sourcePaths = resolveEntitySourcePaths(input.config?.paths);
+    if (confidence < STRICT_CONFIDENCE_THRESHOLD) {
+        return {
+            observationFact: {
+                type: "fact",
+                id: ids.observationFactId,
+                properties: {
+                    id: ids.observationFactId,
+                    title: statement,
+                    status: "active",
+                    source: buildEntitySourcePath(sourcePaths.facts, ids.observationFactId),
+                    text_ref: textRef,
+                    tags: buildUniqueTags([...metadataTags, "lane:observation", "review:required"]),
+                    fact_kind: "observation",
+                    subject_key: ids.normalizedSubjectKey,
+                    property_key: ids.normalizedPropertyKey,
+                    canonical_key: ids.stableKey,
+                },
+            },
+            relationships: [],
+            isStrict: false,
+            confidence,
+        };
+    }
+    const req = {
+        type: "req",
+        id: ids.reqId,
+        properties: {
+            id: ids.reqId,
+            title: statement,
+            status: "open",
+            source: buildEntitySourcePath(sourcePaths.requirements, ids.reqId),
+            text_ref: textRef,
+            tags: buildUniqueTags([...metadataTags, "lane:strict"]),
+        },
+    };
+    const subjectFact = {
+        type: "fact",
+        id: ids.subjectFactId,
+        properties: {
+            id: ids.subjectFactId,
+            title: humanizeKey(ids.normalizedSubjectKey),
+            status: "active",
+            source: buildEntitySourcePath(sourcePaths.facts, ids.subjectFactId),
+            text_ref: textRef,
+            tags: buildUniqueTags([...metadataTags, "lane:strict", "fact:subject"]),
+            fact_kind: "subject",
+            subject_key: ids.normalizedSubjectKey,
+            canonical_key: ids.normalizedSubjectKey,
+        },
+    };
+    const propertyFact = {
+        type: "fact",
+        id: ids.propertyFactId,
+        properties: {
+            id: ids.propertyFactId,
+            title: buildPropertyFactTitle(ids.normalizedPropertyKey, input.claim),
+            status: "active",
+            source: buildEntitySourcePath(sourcePaths.facts, ids.propertyFactId),
+            text_ref: textRef,
+            tags: buildUniqueTags([...metadataTags, "lane:strict", "fact:property_value"]),
+            fact_kind: "property_value",
+            subject_key: ids.normalizedSubjectKey,
+            property_key: ids.normalizedPropertyKey,
+            canonical_key: ids.stableKey,
+            ...buildPropertyFactFields(input.claim),
+        },
+    };
+    const relationships = dedupeRelationships([
+        {
+            type: "constrains",
+            from: req.id,
+            to: subjectFact.id,
+            source: input.claim.source,
+            confidence,
+        },
+        {
+            type: "requires_property",
+            from: req.id,
+            to: propertyFact.id,
+            source: input.claim.source,
+            confidence,
+        },
+    ]);
+    return {
+        req,
+        subjectFact,
+        propertyFact,
+        relationships,
+        isStrict: true,
+        confidence,
+    };
+}
+export function modelRequirementClaims(inputs) {
+    const seen = new Set();
+    const modeled = [];
+    for (const input of inputs) {
+        const writeSet = buildStrictWriteSet(input);
+        const stableId = writeSet.isStrict ? writeSet.req.id : writeSet.observationFact.id;
+        if (seen.has(stableId)) {
+            continue;
+        }
+        seen.add(stableId);
+        modeled.push(writeSet);
+    }
+    return modeled;
+}
+function buildEntityId(prefix, value) {
+    const hash = createHash("sha256");
+    hash.update(value);
+    return `${prefix}-${hash.digest("hex").substring(0, 16).toUpperCase()}`;
+}
+function normalizeSourceKey(value) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/(^-|-$)/g, "");
+    if (!normalized) {
+        throw new Error("Semantic claim source must normalize to a non-empty value");
+    }
+    return normalized;
+}
+function normalizeStableValue(value) {
+    if (typeof value === "string") {
+        const normalized = value
+            .trim()
+            .toLowerCase()
+            .replace(/\s+/g, "_")
+            .replace(/[^a-z0-9._-]+/g, "_")
+            .replace(/_+/g, "_")
+            .replace(/^_+|_+$/g, "");
+        return normalized || "empty";
+    }
+    return String(value);
+}
+function normalizeStatement(statement) {
+    const normalized = statement.trim();
+    if (!normalized) {
+        throw new Error("Strict modeling requires a non-empty prose statement");
+    }
+    return normalized;
+}
+function normalizeTextRef(provenance, source) {
+    const value = provenance?.trim() || source.trim();
+    if (!value) {
+        throw new Error("Strict modeling requires claim provenance or source");
+    }
+    return value;
+}
+function normalizeConfidence(value) {
+    if (!Number.isFinite(value)) {
+        return 0;
+    }
+    return Math.round(Math.min(1, Math.max(0, value)) * 100) / 100;
+}
+function toConfidenceBand(confidence) {
+    if (confidence >= 0.9)
+        return "high";
+    if (confidence >= 0.8)
+        return "medium";
+    return "low";
+}
+function buildMetadataTags({ confidence, provenance, }) {
+    return buildUniqueTags([
+        "strict-modeling",
+        `confidence:${confidence.toFixed(2)}`,
+        `confidence-band:${toConfidenceBand(confidence)}`,
+        `provenance:${normalizeSourceKey(provenance)}`,
+    ]);
+}
+function buildUniqueTags(tags) {
+    return Array.from(new Set(tags));
+}
+function buildPropertyFactTitle(normalizedPropertyKey, claim) {
+    const label = humanizeKey(normalizedPropertyKey);
+    if (claim.operator === "polarity") {
+        return `${label} ${normalizePolarityValue(claim.value)}`;
+    }
+    const operatorLabel = claim.operator === "bool"
+        ? "="
+        : claim.operator === "eq"
+            ? "="
+            : claim.operator === "neq"
+                ? "!="
+                : claim.operator === "gte"
+                    ? ">="
+                    : "<=";
+    return `${label} ${operatorLabel} ${String(claim.value)}`;
+}
+function buildPropertyFactFields(claim) {
+    if (claim.operator === "polarity") {
+        return {
+            polarity: normalizePolarityValue(claim.value),
+        };
+    }
+    if (claim.operator === "bool") {
+        return {
+            operator: "eq",
+            value_type: "bool",
+            value_bool: normalizeBooleanValue(claim.value),
+        };
+    }
+    return {
+        operator: claim.operator,
+        ...buildTypedValueFields(claim.value),
+    };
+}
+function buildTypedValueFields(value) {
+    if (typeof value === "boolean") {
+        return {
+            value_type: "bool",
+            value_bool: value,
+        };
+    }
+    if (typeof value === "number") {
+        if (Number.isInteger(value)) {
+            return {
+                value_type: "int",
+                value_int: value,
+            };
+        }
+        return {
+            value_type: "number",
+            value_number: value,
+        };
+    }
+    return {
+        value_type: "string",
+        value_string: value,
+    };
+}
+function normalizePolarityValue(value) {
+    if (typeof value === "boolean") {
+        return value ? "require" : "forbid";
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "require" || normalized === "forbid") {
+            return normalized;
+        }
+    }
+    throw new Error("Polarity claims must use a boolean or the string 'require'/'forbid'");
+}
+function normalizeBooleanValue(value) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true")
+            return true;
+        if (normalized === "false")
+            return false;
+    }
+    throw new Error("Boolean claims must use a boolean or the string 'true'/'false'");
+}
+function humanizeKey(value) {
+    return value
+        .split(/[._-]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function dedupeRelationships(relationships) {
+    const seen = new Set();
+    const deduped = [];
+    for (const relationship of relationships) {
+        const key = `${relationship.type}:${relationship.from}:${relationship.to}`;
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(relationship);
+    }
+    return deduped;
+}
+function resolveEntitySourcePaths(configPaths) {
+    return {
+        requirements: normalizeEntityDirectory(configPaths?.requirements, DEFAULT_CONFIG.paths.requirements),
+        facts: normalizeEntityDirectory(configPaths?.facts, DEFAULT_CONFIG.paths.facts),
+    };
+}
+function normalizeEntityDirectory(directory, fallback) {
+    const selected = directory?.trim() || fallback?.trim() || "documentation";
+    return selected.split(path.sep).join("/").replace(/\/+$/g, "");
+}
+function buildEntitySourcePath(directory, entityId) {
+    return `${directory}/${entityId}.md`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kibi-cli",
-  "version": "0.7.0",
+  "version": "0.10.0",
   "type": "module",
   "description": "Kibi CLI for knowledge base management",
   "engines": {
@@ -78,6 +78,19 @@
     "./brief-config": {
       "types": "./dist/public/brief-config.d.ts",
       "default": "./dist/public/brief-config.js"
+    },
+    "./schema-version": {
+      "types": "./dist/public/schema-version.d.ts",
+      "default": "./dist/public/schema-version.js"
+    },
+    "./operational-artifacts": {
+      "types": "./dist/public/operational-artifacts.d.ts",
+      "default": "./dist/public/operational-artifacts.js"
+    },
+    "./ignore-policy": {
+      "types": "./dist/public/ignore-policy.d.ts",
+      "import": "./dist/public/ignore-policy.js",
+      "default": "./dist/public/ignore-policy.js"
     }
   },
   "types": "./dist/cli.d.ts",
@@ -88,8 +101,9 @@
     "fast-glob": "^3.2.12",
     "gray-matter": "^4.0.3",
     "js-yaml": "^4.1.0",
-    "kibi-core": "^0.5.2",
-    "ts-morph": "^23.0.0"
+    "kibi-core": "^0.5.3",
+    "ts-morph": "^23.0.0",
+    "ignore": "^5.3.0"
   },
   "devDependencies": {
     "@types/node": "latest",

package/schema/config.json

@@ -186,6 +186,11 @@
               "type": "boolean",
               "description": "Detect requirements with incomplete strict subject/property fact pairing for contradiction-safe semantics",
               "default": false
+            },
+            "strict-readiness": {
+              "type": "boolean",
+              "description": "Report strict contradiction-readiness levels for requirements that are still prose-only or otherwise not contradiction-ready",
+              "default": false
             }
           },
           "additionalProperties": false
@@ -229,7 +234,9 @@
           "required-fields": true,
           "deprecated-adr-no-successor": true,
           "domain-contradictions": true,
-          "strict-fact-shape": false
+          "strict-fact-shape": false,
+          "strict-req-fact-pairing": false,
+          "strict-readiness": false
         },
         "symbolTraceability": {
           "requireAdr": false

package/src/public/check-types.ts

@@ -17,7 +17,7 @@
  */
 
 /**
- * Public re-export barrel for shared check types.
+ * Public re-export barrel for shared check types and MCP-consumed modeling helpers.
  * Import from "kibi-cli/public/check-types" in MCP or external consumers.
  */
 export type {
@@ -26,6 +26,12 @@ export type {
   SymbolTraceabilityOptions,
   Violation,
 } from "../utils/rule-registry.js";
+export type {
+  SemanticClaim,
+  StableRequirementIds,
+  StrictModelInput,
+  StrictWriteSet,
+} from "../utils/strict-modeling.js";
 
 export {
   DEFAULT_CHECKS_CONFIG,
@@ -35,3 +41,11 @@ export {
   mergeChecksConfig,
   validateRuleName,
 } from "../utils/rule-registry.js";
+
+export {
+  buildStableRequirementIds,
+  buildStrictWriteSet,
+  modelRequirementClaims,
+  normalizePropertyKey,
+  normalizeSubjectKey,
+} from "../utils/strict-modeling.js";