kibi-cli 0.2.8 → 0.4.0

package/dist/prolog/codec.js

@@ -28,6 +28,21 @@ export function toPrologAtom(value) {
         ? value
         : `'${value.replace(/'/g, "''")}'`;
 }
+/**
+ * Escape a string value for use inside a Prolog double-quoted string literal.
+ * Escapes: backslash, double-quote, newline, carriage-return, tab.
+ * Returns the full quoted literal including surrounding double-quotes.
+ */
+export function toPrologString(value) {
+    // implements REQ-009
+    const escaped = value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\n/g, "\\n")
+        .replace(/\r/g, "\\r")
+        .replace(/\t/g, "\\t");
+    return `"${escaped}"`;
+}
 /**
  * Escape a string for embedding inside a single-quoted Prolog atom.
  * Alias for escapeAtom for semantic clarity.
@@ -35,56 +50,6 @@ export function toPrologAtom(value) {
 export function escapeAtomContent(value) {
     return value.replace(/'/g, "''");
 }
-/**
- * Split a string by delimiter at the top level (not inside brackets or quotes).
- * This is the general-purpose version that splits at depth 0.
- */
-export function splitTopLevel(str, delimiter) {
-    const results = [];
-    let current = "";
-    let depth = 0;
-    let inDoubleQuotes = false;
-    let inSingleQuotes = false;
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        const prev = i > 0 ? str[i - 1] : "";
-        if (char === '"' && !inSingleQuotes && prev !== "\\") {
-            inDoubleQuotes = !inDoubleQuotes;
-            current += char;
-            continue;
-        }
-        if (char === "'" && !inDoubleQuotes && prev !== "\\") {
-            inSingleQuotes = !inSingleQuotes;
-            current += char;
-            continue;
-        }
-        if (!inSingleQuotes && !inDoubleQuotes && (char === "[" || char === "(")) {
-            depth++;
-            current += char;
-            continue;
-        }
-        if (!inSingleQuotes && !inDoubleQuotes && (char === "]" || char === ")")) {
-            depth--;
-            current += char;
-            continue;
-        }
-        if (!inSingleQuotes &&
-            !inDoubleQuotes &&
-            depth === 0 &&
-            char === delimiter) {
-            if (current.length > 0) {
-                results.push(current);
-            }
-            current = "";
-            continue;
-        }
-        current += char;
-    }
-    if (current.length > 0) {
-        results.push(current);
-    }
-    return results;
-}
 /**
  * Parse a Prolog list of lists into a JavaScript array.
  * Input: "[[a,b,c],[d,e,f]]"
@@ -199,6 +164,7 @@ export function parsePropertyList(propsStr) {
  * Parse a single Prolog value, handling typed literals and URIs.
  */
 export function parsePrologValue(valueInput) {
+    // implements REQ-009
     const value = valueInput.trim();
     // Handle typed literal: ^^("value", type)
     if (value.startsWith("^^(")) {
@@ -220,10 +186,21 @@ export function parsePrologValue(valueInput) {
         const parts = splitTopLevelGeneral(innerContent, ",");
         if (parts.length >= 2) {
             let literalValue = parts[0].trim();
+            const datatype = parts[1].trim();
             if (literalValue.startsWith('"') && literalValue.endsWith('"')) {
                 literalValue = literalValue.substring(1, literalValue.length - 1);
             }
-            // Handle array notation
+            // Parse typed literals based on datatype
+            if (datatype.includes("#integer")) {
+                return Number.parseInt(literalValue, 10);
+            }
+            if (datatype.includes("#decimal") || datatype.includes("#double")) {
+                return Number.parseFloat(literalValue);
+            }
+            if (datatype.includes("#boolean")) {
+                return literalValue === "true";
+            }
+            // Handle array notation for string values
             if (literalValue.startsWith("[") && literalValue.endsWith("]")) {
                 const listContent = literalValue.substring(1, literalValue.length - 1);
                 if (listContent === "") {
@@ -267,27 +244,40 @@ export function parsePrologValue(valueInput) {
  * General-purpose split at top level (not inside brackets or quotes).
  * More robust version used by property parsing.
  */
-function splitTopLevelGeneral(str, delimiter) {
+export function splitTopLevelGeneral(str, delimiter) {
+    // implements REQ-009
     const results = [];
     let current = "";
     let depth = 0;
-    let inQuotes = false;
+    let inDoubleQuotes = false;
+    let inSingleQuotes = false;
     for (let i = 0; i < str.length; i++) {
         const char = str[i];
         const prevChar = i > 0 ? str[i - 1] : "";
-        if (char === '"' && prevChar !== "\\") {
-            inQuotes = !inQuotes;
+        if (char === '"' && !inSingleQuotes && prevChar !== "\\") {
+            inDoubleQuotes = !inDoubleQuotes;
             current += char;
         }
-        else if (!inQuotes && (char === "[" || char === "(")) {
+        else if (char === "'" && !inDoubleQuotes && prevChar !== "\\") {
+            inSingleQuotes = !inSingleQuotes;
+            current += char;
+        }
+        else if (!inDoubleQuotes &&
+            !inSingleQuotes &&
+            (char === "[" || char === "(")) {
             depth++;
             current += char;
         }
-        else if (!inQuotes && (char === "]" || char === ")")) {
+        else if (!inDoubleQuotes &&
+            !inSingleQuotes &&
+            (char === "]" || char === ")")) {
             depth--;
             current += char;
         }
-        else if (!inQuotes && depth === 0 && char === delimiter) {
+        else if (!inDoubleQuotes &&
+            !inSingleQuotes &&
+            depth === 0 &&
+            char === delimiter) {
             if (current) {
                 results.push(current);
                 current = "";
@@ -302,6 +292,14 @@ function splitTopLevelGeneral(str, delimiter) {
     }
     return results;
 }
+/**
+ * Split a string by delimiter at the top level (not inside brackets or quotes).
+ * @see splitTopLevelGeneral
+ */
+export function splitTopLevel(str, delimiter) {
+    // implements REQ-009
+    return splitTopLevelGeneral(str, delimiter);
+}
 /**
  * Strip outer quotes from a string value.
  */
@@ -420,6 +418,45 @@ function unwrapList(value) {
     }
     return value;
 }
+/**
+ * Parse a Prolog list of violation/5 terms into JavaScript objects.
+ * Handles descriptions and suggestions that contain commas or nested parens.
+ * Input: "[violation(rule,'EntityId',\"Desc\",\"Sugg\",'src')]"
+ */
+export function parseViolationRows(raw) {
+    // implements REQ-006
+    const trimmed = raw.trim();
+    if (trimmed === "[]" || trimmed.length === 0) {
+        return [];
+    }
+    const violations = [];
+    // Unwrap outer list
+    const content = trimmed.startsWith("[") && trimmed.endsWith("]")
+        ? trimmed.slice(1, -1)
+        : trimmed;
+    // Split at top-level commas to get individual violation(...) terms
+    const terms = splitTopLevelGeneral(content, ",");
+    for (const term of terms) {
+        const t = term.trim();
+        if (!t.startsWith("violation(") || !t.endsWith(")"))
+            continue;
+        // Strip "violation(" prefix and trailing ")"
+        const inner = t.slice("violation(".length, -1);
+        // Split the 5 arguments at top-level commas
+        const parts = splitTopLevelGeneral(inner, ",");
+        if (parts.length < 4)
+            continue;
+        const rule = parts[0].trim().replace(/^'|'$/g, "");
+        const entityId = parts[1].trim().replace(/^'|'$/g, "");
+        const description = parts[2].trim().replace(/^"|"$/g, "");
+        const suggestion = parts[3].trim().replace(/^"|"$/g, "");
+        const source = parts.length >= 5
+            ? parts[4].trim().replace(/^'|'$/g, "") || undefined
+            : undefined;
+        violations.push({ rule, entityId, description, suggestion, source });
+    }
+    return violations;
+}
 /**
  * Strip quotes from a value (single or double).
  */

package/dist/prolog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AA4BA,wBAAgB,eAAe,IAAI,MAAM,CAsCxC;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAoCd,YAAY;IAyCpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAuJ1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;YAIZ,YAAY;IAkC1B,OAAO,CAAC,WAAW;IA8FnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,cAAc;IA8BtB,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBjC"}
+{"version":3,"file":"prolog.d.ts","sourceRoot":"","sources":["../src/prolog.ts"],"names":[],"mappings":"AA4BA,wBAAgB,eAAe,IAAI,MAAM,CAyCxC;AACD,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAA6B;IAC5C,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAM;IAC1B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,KAAK,CAAuC;IACpD,OAAO,CAAC,oBAAoB,CAAoC;IAChE,OAAO,CAAC,cAAc,CACyC;IAC/D,OAAO,CAAC,cAAc,CAAuB;IAC7C,OAAO,CAAC,aAAa,CAA6B;gBAEtC,OAAO,GAAE,aAAkB;IAKjC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YAoCd,YAAY;IAyCpB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC;IAuJ1D,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,eAAe;IAavB,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,kBAAkB;YAIZ,YAAY;IAkC1B,OAAO,CAAC,WAAW;IAsGnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAevB,OAAO,CAAC,cAAc;IA8BtB,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBjC"}

package/dist/prolog.js

@@ -23,6 +23,7 @@ import { fileURLToPath } from "node:url";
 const importMetaDir = path.dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 export function resolveKbPlPath() {
+    // implements REQ-009
     const overrideKbPath = process.env.KIBI_KB_PL_PATH;
     if (overrideKbPath && existsSync(overrideKbPath)) {
         return overrideKbPath;
@@ -32,7 +33,9 @@ export function resolveKbPlPath() {
         if (existsSync(installedKbPl))
             return installedKbPl;
     }
-    catch { }
+    catch {
+        // require.resolve not available or package not installed
+    }
     const startDirs = [importMetaDir, process.cwd()];
     for (const startDir of startDirs) {
         let currentDir = path.resolve(startDir);
@@ -363,10 +366,17 @@ export class PrologProcess {
                 bindings: this.extractBindings(clean),
             };
         }
+        if (stdout.includes("__KIBI_FALSE__")) {
+            return {
+                success: false,
+                bindings: {},
+                error: "Query returned false",
+            };
+        }
         return {
             success: false,
             bindings: {},
-            error: "Query failed",
+            error: `Query failed - stdout: ${stdout.substring(0, 200)}, stderr: ${stderr.substring(0, 200)}`,
         };
     }
     normalizeGoal(goal) {

package/dist/public/check-types.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Public re-export barrel for shared check types.
+ * Import from "kibi-cli/public/check-types" in MCP or external consumers.
+ */
+export type { ChecksConfig, RuleDefinition, SymbolTraceabilityOptions, Violation, } from "../utils/rule-registry.js";
+export { DEFAULT_CHECKS_CONFIG, RULE_NAMES, RULES, getEffectiveRules, mergeChecksConfig, validateRuleName, } from "../utils/rule-registry.js";
+//# sourceMappingURL=check-types.d.ts.map

package/dist/public/check-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-types.d.ts","sourceRoot":"","sources":["../../src/public/check-types.ts"],"names":[],"mappings":"AAkBA;;;GAGG;AACH,YAAY,EACV,YAAY,EACZ,cAAc,EACd,yBAAyB,EACzB,SAAS,GACV,MAAM,2BAA2B,CAAC;AAEnC,OAAO,EACL,qBAAqB,EACrB,UAAU,EACV,KAAK,EACL,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,2BAA2B,CAAC"}

package/dist/public/check-types.js

@@ -0,0 +1,18 @@
+/*
+ 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/>.
+ */
+export { DEFAULT_CHECKS_CONFIG, RULE_NAMES, RULES, getEffectiveRules, mergeChecksConfig, validateRuleName, } from "../utils/rule-registry.js";

package/dist/public/schemas/entity.d.ts

@@ -50,8 +50,76 @@ declare const entitySchema: {
             type: string;
             enum: string[];
         };
+        fact_kind: {
+            type: string;
+            enum: string[];
+        };
+        subject_key: {
+            type: string;
+        };
+        property_key: {
+            type: string;
+        };
+        operator: {
+            type: string;
+            enum: string[];
+        };
+        value_type: {
+            type: string;
+            enum: string[];
+        };
+        value_string: {
+            type: string;
+        };
+        value_int: {
+            type: string;
+        };
+        value_number: {
+            type: string;
+        };
+        value_bool: {
+            type: string;
+        };
+        unit: {
+            type: string;
+        };
+        scope: {
+            type: string;
+        };
+        polarity: {
+            type: string;
+            enum: string[];
+        };
+        closed_world: {
+            type: string;
+        };
+        valid_from: {
+            type: string;
+        };
+        valid_to: {
+            type: string;
+        };
+        canonical_key: {
+            type: string;
+        };
     };
     required: string[];
+    allOf: {
+        if: {
+            properties: {
+                type: {
+                    const: string;
+                };
+            };
+        };
+        else: {
+            not: {
+                anyOf: {
+                    required: string[];
+                }[];
+            };
+        };
+    }[];
     additionalProperties: boolean;
 };
 export default entitySchema;

package/dist/public/schemas/entity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgEjB,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAwBA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHjB,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/public/schemas/entity.js

@@ -68,6 +68,26 @@ const entitySchema = {
                 "fact",
             ],
         },
+        // Typed fact fields - only valid when type === "fact"
+        fact_kind: {
+            type: "string",
+            enum: ["subject", "property_value", "observation", "meta"],
+        },
+        subject_key: { type: "string" },
+        property_key: { type: "string" },
+        operator: { type: "string", enum: ["eq", "neq", "lt", "lte", "gt", "gte"] },
+        value_type: { type: "string", enum: ["string", "int", "number", "bool"] },
+        value_string: { type: "string" },
+        value_int: { type: "integer" },
+        value_number: { type: "number" },
+        value_bool: { type: "boolean" },
+        unit: { type: "string" },
+        scope: { type: "string" },
+        polarity: { type: "string", enum: ["require", "forbid"] },
+        closed_world: { type: "boolean" },
+        valid_from: { type: "string" },
+        valid_to: { type: "string" },
+        canonical_key: { type: "string" },
     },
     required: [
         "id",
@@ -78,6 +98,38 @@ const entitySchema = {
         "source",
         "type",
     ],
+    allOf: [
+        // Forbid fact-only fields on non-fact entities
+        {
+            if: {
+                properties: { type: { const: "fact" } },
+            },
+            // Fact entities can have fact fields (no restriction)
+            // Non-fact entities cannot have fact fields
+            else: {
+                not: {
+                    anyOf: [
+                        { required: ["fact_kind"] },
+                        { required: ["subject_key"] },
+                        { required: ["property_key"] },
+                        { required: ["operator"] },
+                        { required: ["value_type"] },
+                        { required: ["value_string"] },
+                        { required: ["value_int"] },
+                        { required: ["value_number"] },
+                        { required: ["value_bool"] },
+                        { required: ["unit"] },
+                        { required: ["scope"] },
+                        { required: ["polarity"] },
+                        { required: ["closed_world"] },
+                        { required: ["valid_from"] },
+                        { required: ["valid_to"] },
+                        { required: ["canonical_key"] },
+                    ],
+                },
+            },
+        },
+    ],
     additionalProperties: false,
 };
 export default entitySchema;

package/dist/relationships/shards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shards.d.ts","sourceRoot":"","sources":["../../src/relationships/shards.ts"],"names":[],"mappings":"AAuBA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAqFjE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kBAAkB,EAAE,GAC5B,IAAI,CAoBN;AAqCD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,GAC3C;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA4BzC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAUnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAUlE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,kBAAkB,EAAE,EAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,kBAAkB,EAAE,CAKtB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,MAAM,CAMR;AAID;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,kBAAkB,EAAE,EAC9B,QAAQ,EAAE,kBAAkB,EAAE,GAC7B,kBAAkB,EAAE,CAgCtB"}
+{"version":3,"file":"shards.d.ts","sourceRoot":"","sources":["../../src/relationships/shards.ts"],"names":[],"mappings":"AAuBA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGzE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAsFjE;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,kBAAkB,EAAE,GAC5B,IAAI,CAoBN;AAqCD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,GAC3C;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CA4BzC;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAUnD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAUlE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,kBAAkB,EAAE,EAC7B,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,GAC1B,kBAAkB,EAAE,CAKtB;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAE1B,QAAQ,EAAE,kBAAkB,EAAE,EAC9B,QAAQ,EAAE,kBAAkB,EAAE,GAC7B,kBAAkB,EAAE,CAgCtB"}

package/dist/relationships/shards.js

@@ -46,6 +46,7 @@ export function computeShardPath(kbRoot, entityId) {
  * Throws on parse errors.
  */
 export function readShard(shardPath) {
+    // implements REQ-005
     if (!fs.existsSync(shardPath)) {
         return [];
     }
@@ -78,7 +79,7 @@ export function readShard(shardPath) {
         // Handle created_at - YAML may auto-convert ISO dates to Date objects
         let createdAt;
         if (rec.created_at instanceof Date) {
-            createdAt = rec.created_at.toISOString().replace(/\.000Z$/, 'Z');
+            createdAt = rec.created_at.toISOString().replace(/\.000Z$/, "Z");
         }
         else if (typeof rec.created_at === "string" && rec.created_at) {
             createdAt = rec.created_at;
@@ -150,7 +151,7 @@ function serializeToYAML(records) {
             lines.push(`    confidence: ${record.confidence}`);
         }
     }
-    return lines.join("\n") + "\n";
+    return `${lines.join("\n")}\n`;
 }
 /**
  * Sorts records deterministically by from, then type, then to.
@@ -234,7 +235,9 @@ export function relationshipIdFor(type, from, to) {
  * Deduplicates by (type, from, to) tuple.
  * On conflict, keeps the record with newer created_at timestamp.
  */
-export function mergeRecords(existing, incoming) {
+export function mergeRecords(
+// implements REQ-005
+existing, incoming) {
     const recordMap = new Map();
     // Helper to create key from record
     const makeKey = (r) => `${r.type}|${r.from}|${r.to}`;

package/dist/schemas/entity.schema.json

@@ -0,0 +1,120 @@
+{
+    "$id": "entity.schema.json",
+    "title": "Entity",
+    "type": "object",
+    "properties": {
+        "id": { "type": "string" },
+        "title": { "type": "string" },
+        "status": {
+            "type": "string",
+            "enum": [
+                "active",
+                "inactive",
+                "draft",
+                "archived",
+                "deleted",
+                "approved",
+                "rejected",
+                "pending",
+                "in_progress",
+                "superseded",
+                "open",
+                "closed",
+                "deprecated",
+                "passing",
+                "failing",
+                "skipped",
+                "proposed",
+                "accepted",
+                "removed"
+            ]
+        },
+        "created_at": { "type": "string" },
+        "updated_at": { "type": "string" },
+        "source": { "type": "string" },
+        "tags": { "type": "array", "items": { "type": "string" } },
+        "owner": { "type": "string" },
+        "priority": { "type": "string" },
+        "severity": { "type": "string" },
+        "links": { "type": "array", "items": { "type": "string" } },
+        "text_ref": { "type": "string" },
+        "type": {
+            "type": "string",
+            "enum": [
+                "req",
+                "scenario",
+                "test",
+                "adr",
+                "flag",
+                "event",
+                "symbol",
+                "fact"
+            ]
+        },
+        "fact_kind": {
+            "type": "string",
+            "enum": ["subject", "property_value", "observation", "meta"]
+        },
+        "subject_key": { "type": "string" },
+        "property_key": { "type": "string" },
+        "operator": {
+            "type": "string",
+            "enum": ["eq", "neq", "lt", "lte", "gt", "gte"]
+        },
+        "value_type": {
+            "type": "string",
+            "enum": ["string", "int", "number", "bool"]
+        },
+        "value_string": { "type": "string" },
+        "value_int": { "type": "integer" },
+        "value_number": { "type": "number" },
+        "value_bool": { "type": "boolean" },
+        "unit": { "type": "string" },
+        "scope": { "type": "string" },
+        "polarity": { "type": "string", "enum": ["require", "forbid"] },
+        "closed_world": { "type": "boolean" },
+        "valid_from": { "type": "string" },
+        "valid_to": { "type": "string" },
+        "canonical_key": { "type": "string" }
+    },
+    "required": [
+        "id",
+        "title",
+        "status",
+        "created_at",
+        "updated_at",
+        "source",
+        "type"
+    ],
+    "allOf": [
+        {
+            "if": {
+                "properties": { "type": { "const": "fact" } }
+            },
+            "then": {},
+            "else": {
+                "not": {
+                    "anyOf": [
+                        { "required": ["fact_kind"] },
+                        { "required": ["subject_key"] },
+                        { "required": ["property_key"] },
+                        { "required": ["operator"] },
+                        { "required": ["value_type"] },
+                        { "required": ["value_string"] },
+                        { "required": ["value_int"] },
+                        { "required": ["value_number"] },
+                        { "required": ["value_bool"] },
+                        { "required": ["unit"] },
+                        { "required": ["scope"] },
+                        { "required": ["polarity"] },
+                        { "required": ["closed_world"] },
+                        { "required": ["valid_from"] },
+                        { "required": ["valid_to"] },
+                        { "required": ["canonical_key"] }
+                    ]
+                }
+            }
+        }
+    ],
+    "additionalProperties": false
+}

package/dist/search-ranking.d.ts

@@ -0,0 +1,9 @@
+export interface SearchMatch {
+    entity: Record<string, unknown>;
+    score: number;
+    reasons: string[];
+    snippet?: string;
+}
+export declare function rankEntities(entities: Record<string, unknown>[], query: string, workspaceRoot: string): Promise<SearchMatch[]>;
+export declare function loadMarkdownBody(source: string, workspaceRoot: string): Promise<string | null>;
+//# sourceMappingURL=search-ranking.d.ts.map

package/dist/search-ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-ranking.d.ts","sourceRoot":"","sources":["../src/search-ranking.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAGD,wBAAsB,YAAY,CAChC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,WAAW,EAAE,CAAC,CAyBxB;AA+FD,wBAAsB,gBAAgB,CAEpC,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CA6BxB"}