kibi-cli 0.5.0 → 0.6.0

package/dist/prolog/codec.js

@@ -16,6 +16,7 @@
  * Doubles single-quote characters per ISO Prolog standard.
  */
 export function escapeAtom(value) {
+    // implements REQ-009
     return value.replace(/'/g, "''");
 }
 /**
@@ -23,6 +24,7 @@ export function escapeAtom(value) {
  * Simple atoms (lowercase start, alphanumeric + underscore) pass through.
  */
 export function toPrologAtom(value) {
+    // implements REQ-009
     const simplePrologAtom = /^[a-z][a-zA-Z0-9_]*$/;
     return simplePrologAtom.test(value)
         ? value
@@ -48,14 +50,11 @@ export function toPrologString(value) {
  * Alias for escapeAtom for semantic clarity.
  */
 export function escapeAtomContent(value) {
+    // implements REQ-009
     return value.replace(/'/g, "''");
 }
-/**
- * Parse a Prolog list of lists into a JavaScript array.
- * Input: "[[a,b,c],[d,e,f]]"
- * Output: [["a", "b", "c"], ["d", "e", "f"]]
- */
 export function parseListOfLists(listStr) {
+    // implements REQ-009
     const cleaned = listStr.trim().replace(/^\[/, "").replace(/\]$/, "");
     if (cleaned === "") {
         return [];
@@ -102,41 +101,44 @@ export function parseListOfLists(listStr) {
     }
     return results;
 }
-/**
- * Parse a single entity from Prolog binding format.
- * Input: "[abc123, req, [id=abc123, title=\"Test\", ...]]"
- */
-export function parseEntityFromBinding(bindingStr) {
+export function parseEntityFromBinding(
+// implements REQ-009
+bindingStr) {
     const cleaned = bindingStr.trim().replace(/^\[/, "").replace(/\]$/, "");
     const parts = splitTopLevelGeneral(cleaned, ",");
     if (parts.length < 3) {
         return {};
     }
-    const id = parts[0].trim();
-    const type = parts[1].trim();
+    const idPart = parts[0];
+    const typePart = parts[1];
+    if (idPart === undefined || typePart === undefined) {
+        return {};
+    }
+    const id = idPart.trim();
+    const type = typePart.trim();
     const propsStr = parts.slice(2).join(",").trim();
     const props = parsePropertyList(propsStr);
     return { ...props, id: normalizeEntityId(stripOuterQuotes(id)), type };
 }
-/**
- * Parse entity from array returned by parseListOfLists.
- * Input: ["abc123", "req", "[id=abc123, title=\"Test\", ...]"]
- */
 export function parseEntityFromList(data) {
+    // implements REQ-009
     if (data.length < 3) {
         return {};
     }
-    const id = data[0].trim();
-    const type = data[1].trim();
-    const propsStr = data[2].trim();
+    const [idPart, typePart, propsPart] = data;
+    if (idPart === undefined ||
+        typePart === undefined ||
+        propsPart === undefined) {
+        return {};
+    }
+    const id = idPart.trim();
+    const type = typePart.trim();
+    const propsStr = propsPart.trim();
     const props = parsePropertyList(propsStr);
     return { ...props, id: normalizeEntityId(stripOuterQuotes(id)), type };
 }
-/**
- * Parse Prolog property list into JavaScript object.
- * Input: "[id=abc123, title=\"Test\"]"
- */
 export function parsePropertyList(propsStr) {
+    // implements REQ-009
     const props = {};
     let cleaned = propsStr.trim();
     if (cleaned.startsWith("[")) {
@@ -160,9 +162,6 @@ export function parsePropertyList(propsStr) {
     }
     return props;
 }
-/**
- * Parse a single Prolog value, handling typed literals and URIs.
- */
 export function parsePrologValue(valueInput) {
     // implements REQ-009
     const value = valueInput.trim();
@@ -185,8 +184,13 @@ export function parsePrologValue(valueInput) {
         const innerContent = value.substring(innerStart, innerEnd);
         const parts = splitTopLevelGeneral(innerContent, ",");
         if (parts.length >= 2) {
-            let literalValue = parts[0].trim();
-            const datatype = parts[1].trim();
+            const literalPart = parts[0];
+            const datatypePart = parts[1];
+            if (literalPart === undefined || datatypePart === undefined) {
+                return value;
+            }
+            let literalValue = literalPart.trim();
+            const datatype = datatypePart.trim();
             if (literalValue.startsWith('"') && literalValue.endsWith('"')) {
                 literalValue = literalValue.substring(1, literalValue.length - 1);
             }
@@ -240,10 +244,6 @@ export function parsePrologValue(valueInput) {
     }
     return value;
 }
-/**
- * General-purpose split at top level (not inside brackets or quotes).
- * More robust version used by property parsing.
- */
 export function splitTopLevelGeneral(str, delimiter) {
     // implements REQ-009
     const results = [];
@@ -292,17 +292,10 @@ export 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.
- */
 function stripOuterQuotes(value) {
     if (value.startsWith("'") && value.endsWith("'")) {
         return value.slice(1, -1);
@@ -312,9 +305,6 @@ function stripOuterQuotes(value) {
     }
     return value;
 }
-/**
- * Normalize entity ID by extracting filename from file:// URI.
- */
 function normalizeEntityId(value) {
     if (!value.startsWith("file:///")) {
         return value;
@@ -322,11 +312,8 @@ function normalizeEntityId(value) {
     const idx = value.lastIndexOf("/");
     return idx === -1 ? value : value.slice(idx + 1);
 }
-/**
- * Parse an atom list from Prolog response.
- * Input: "[a, b, c]" or atom string
- */
 export function parseAtomList(raw) {
+    // implements REQ-009
     const trimmed = raw.trim();
     if (trimmed === "[]" || trimmed.length === 0) {
         return [];
@@ -339,37 +326,39 @@ export function parseAtomList(raw) {
         .map((token) => stripQuotes(token.trim()))
         .filter((token) => token.length > 0);
 }
-/**
- * Parse a list of pairs from Prolog response.
- */
 export function parsePairList(raw) {
+    // implements REQ-009
     const rows = parseListRows(raw);
     const pairs = [];
     for (const row of rows) {
         const parts = splitTopLevelGeneral(row, ",").map((part) => stripQuotes(part.trim()));
         if (parts.length >= 2) {
-            pairs.push([parts[0], parts[1]]);
+            const first = parts[0];
+            const second = parts[1];
+            if (first !== undefined && second !== undefined) {
+                pairs.push([first, second]);
+            }
         }
     }
     return pairs;
 }
-/**
- * Parse a list of triples from Prolog response.
- */
 export function parseTriples(raw) {
+    // implements REQ-009
     const rows = parseListRows(raw);
     const triples = [];
     for (const row of rows) {
         const parts = splitTopLevelGeneral(row, ",").map((part) => stripQuotes(part.trim()));
         if (parts.length >= 3) {
-            triples.push([parts[0], parts[1], parts[2]]);
+            const first = parts[0];
+            const second = parts[1];
+            const third = parts[2];
+            if (first !== undefined && second !== undefined && third !== undefined) {
+                triples.push([first, second, third]);
+            }
         }
     }
     return triples;
 }
-/**
- * Parse list rows from Prolog response.
- */
 function parseListRows(raw) {
     const trimmed = raw.trim();
     if (trimmed === "[]" || trimmed.length === 0) {
@@ -409,20 +398,12 @@ function parseListRows(raw) {
     }
     return rows;
 }
-/**
- * Unwrap outer list brackets.
- */
 function unwrapList(value) {
     if (value.startsWith("[") && value.endsWith("]")) {
         return value.slice(1, -1).trim();
     }
     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();
@@ -446,20 +427,33 @@ export function parseViolationRows(raw) {
         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 rulePart = parts[0];
+        const entityIdPart = parts[1];
+        const descriptionPart = parts[2];
+        const suggestionPart = parts[3];
+        if (rulePart === undefined ||
+            entityIdPart === undefined ||
+            descriptionPart === undefined ||
+            suggestionPart === undefined) {
+            continue;
+        }
+        const rule = rulePart.trim().replace(/^'|'$/g, "");
+        const entityId = entityIdPart.trim().replace(/^'|'$/g, "");
+        const description = descriptionPart.trim().replace(/^"|"$/g, "");
+        const suggestion = suggestionPart.trim().replace(/^"|"$/g, "");
         const source = parts.length >= 5
-            ? parts[4].trim().replace(/^'|'$/g, "") || undefined
+            ? parts[4]?.trim().replace(/^'|'$/g, "") || undefined
             : undefined;
-        violations.push({ rule, entityId, description, suggestion, source });
+        violations.push({
+            rule,
+            entityId,
+            description,
+            suggestion,
+            ...(source !== undefined ? { source } : {}),
+        });
     }
     return violations;
 }
-/**
- * Strip quotes from a value (single or double).
- */
 function stripQuotes(value) {
     if (value.startsWith("'") && value.endsWith("'")) {
         return value.slice(1, -1);

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,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"}
+{"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;YAsCd,YAAY;IA0CpB,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;IA2C1B,OAAO,CAAC,WAAW;IAsGnB,OAAO,CAAC,aAAa;IAIrB,OAAO,CAAC,eAAe;IAiBvB,OAAO,CAAC,cAAc;IA+BtB,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIV,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAyBjC"}

package/dist/prolog.js

@@ -20,36 +20,41 @@ import { existsSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import { getKbPlPathOverride, isPrologDebugEnabled } from "./env.js";
 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)) {
+    const overrideKbPath = getKbPlPathOverride();
+    if (overrideKbPath) {
         return overrideKbPath;
     }
+    // Strategy 1: Resolve kibi-core package and derive the source file path.
+    // This works in npm workspaces where kibi-core is a direct dependency of kibi-cli.
     try {
-        const installedKbPl = require.resolve("kibi-core/src/kb.pl");
-        if (existsSync(installedKbPl))
-            return installedKbPl;
+        try {
+            // First try: resolve as a file within the package
+            return require.resolve("kibi-core/src/kb.pl");
+        }
+        catch {
+            // Fall back: resolve package entry point and derive path
+            const coreMain = require.resolve("kibi-core");
+            const coreDir = path.dirname(coreMain);
+            return path.join(coreDir, "src", "kb.pl");
+        }
     }
     catch {
-        // require.resolve not available or package not installed
+        // Both resolution strategies failed
     }
-    const startDirs = [importMetaDir, process.cwd()];
-    for (const startDir of startDirs) {
-        let currentDir = path.resolve(startDir);
-        while (true) {
-            const candidate = path.join(currentDir, "packages", "core", "src", "kb.pl");
-            if (existsSync(candidate)) {
-                return candidate;
-            }
-            const parentDir = path.dirname(currentDir);
-            if (parentDir === currentDir) {
-                break;
-            }
-            currentDir = parentDir;
+    // Strategy 2: Walk up from importMetaDir looking for packages/core/src/kb.pl.
+    // This works when running from the source tree (e.g., during development).
+    let currentDir = importMetaDir;
+    while (currentDir !== path.dirname(currentDir)) {
+        const candidate = path.join(currentDir, "packages", "core", "src", "kb.pl");
+        if (existsSync(candidate)) {
+            return candidate;
         }
+        currentDir = path.dirname(currentDir);
     }
     throw new Error("Unable to resolve kb.pl. Expected kibi-core to be installed (node_modules) " +
         "or to be running inside the monorepo checkout.");
@@ -88,6 +93,7 @@ export class PrologProcess {
         this.process.stderr.on("data", (chunk) => {
             this.errorBuffer += chunk.toString();
         });
+        this.process.stdin.write("true.\n");
         if (!this.onProcessExit) {
             this.onProcessExit = () => {
                 void this.terminate();
@@ -109,13 +115,14 @@ export class PrologProcess {
             if (this.errorBuffer.includes("ERROR")) {
                 throw new Error(`Failed to load kb module: ${this.translateError(this.errorBuffer)}`);
             }
-            // If stdout or stderr shows any output, assume ready.
-            if (this.outputBuffer.length > 0 || this.errorBuffer.length > 0) {
-                break;
+            if (this.outputBuffer.includes("true.")) {
+                this.outputBuffer = "";
+                this.errorBuffer = "";
+                return;
             }
             // brief pause
             // eslint-disable-next-line no-await-in-loop
-            await new Promise((resolve) => setTimeout(resolve, 50));
+            await new Promise((resolve) => setTimeout(resolve, 10));
         }
         // Final sanity check
         if (this.errorBuffer.includes("ERROR")) {
@@ -154,7 +161,7 @@ export class PrologProcess {
         const runInteractiveQuery = async () => {
             this.outputBuffer = "";
             this.errorBuffer = "";
-            const debug = !!process.env.KIBI_PROLOG_DEBUG;
+            const debug = isPrologDebugEnabled();
             const normalizedGoal = this.normalizeGoal(goal);
             const wrappedGoal = /^once\s*\(/.test(normalizedGoal)
                 ? normalizedGoal
@@ -282,6 +289,14 @@ export class PrologProcess {
         }
         const attachMatch = trimmedGoal.match(/^kb_attach\('(.+)'\)$/);
         if (attachMatch) {
+            const attachPath = attachMatch[1] ?? null;
+            if (!attachPath) {
+                return {
+                    success: false,
+                    bindings: {},
+                    error: "Invalid KB attach path",
+                };
+            }
             if (this.attachedKbPath !== null) {
                 return {
                     success: false,
@@ -291,7 +306,7 @@ export class PrologProcess {
             }
             const attachResult = this.execOneShot(trimmedGoal, null);
             if (attachResult.success) {
-                this.attachedKbPath = attachMatch[1];
+                this.attachedKbPath = attachPath;
             }
             return attachResult;
         }
@@ -389,7 +404,9 @@ export class PrologProcess {
             const match = line.match(/^([A-Z_][A-Za-z0-9_]*)\s*=\s*(.+)\.?\s*$/);
             if (match) {
                 const [, varName, value] = match;
-                bindings[varName] = value.trim().replace(/\.$/, "").replace(/,$/, "");
+                if (varName !== undefined && value !== undefined) {
+                    bindings[varName] = value.trim().replace(/\.$/, "").replace(/,$/, "");
+                }
             }
         }
         return bindings;
@@ -409,12 +426,11 @@ export class PrologProcess {
         if (errorText.includes("timeout_error")) {
             return `Operation exceeded ${this.timeout / 1000}s timeout`;
         }
-        const simpleError = errorText
+        const simpleError = (errorText
             .replace(/ERROR:\s*/g, "")
             .replace(/^\*\*.*\*\*$/gm, "")
             .replace(/^\s+/gm, "")
-            .split("\n")[0]
-            .trim();
+            .split("\n")[0] ?? "").trim();
         return simpleError || "Unknown error";
     }
     isRunning() {

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

@@ -46,6 +46,9 @@ declare const entitySchema: {
         text_ref: {
             type: string;
         };
+        sourceFile: {
+            type: string;
+        };
         type: {
             type: string;
             enum: string[];

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":"AAwBA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoHjB,CAAC;AAEF,eAAe,YAAY,CAAC"}
+{"version":3,"file":"entity.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/entity.ts"],"names":[],"mappings":"AAwBA,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHjB,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/public/schemas/entity.js

@@ -55,6 +55,7 @@ const entitySchema = {
         severity: { type: "string" },
         links: { type: "array", items: { type: "string" } },
         text_ref: { type: "string" },
+        sourceFile: { type: "string" },
         type: {
             type: "string",
             enum: [

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

@@ -1 +1 @@
-{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/relationship.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiCvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}
+{"version":3,"file":"relationship.d.ts","sourceRoot":"","sources":["../../../src/public/schemas/relationship.ts"],"names":[],"mappings":"AAkBA,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCvB,CAAC;AAEF,eAAe,kBAAkB,CAAC"}

package/dist/public/schemas/relationship.js

@@ -29,6 +29,7 @@ const relationshipSchema = {
                 "validates",
                 "implements",
                 "covered_by",
+                "executable_for",
                 "constrained_by",
                 "constrains",
                 "requires_property",

package/dist/query/service.d.ts

@@ -11,6 +11,14 @@ export interface QueryResult {
     entities: Array<Record<string, unknown>>;
     totalCount: number;
 }
+interface QueryCodecDeps {
+    escapeAtom: (value: string) => string;
+    parseListOfLists: (value: string) => string[][];
+    parseEntityFromList: (value: string[]) => Record<string, unknown>;
+    parseEntityFromBinding: (value: string) => Record<string, unknown>;
+}
+export declare function _setQueryCodecDepsForTests(deps: QueryCodecDeps): void;
+export declare function _resetQueryCodecDepsForTests(): void;
 export declare const VALID_ENTITY_TYPES: string[];
 /**
  * Build a Prolog query goal from filters.
@@ -32,4 +40,5 @@ export declare function getInvalidTypeError(type: string): string;
  * Build human-readable summary text for query results.
  */
 export declare function buildQuerySummaryText(result: QueryResult, filters: QueryFilters): string;
+export {};
 //# sourceMappingURL=service.d.ts.map

package/dist/query/service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/query/service.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAQlD,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,eAAO,MAAM,kBAAkB,UAS9B,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAqClE;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,WAAW,CAAC,CAmCtB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,YAAY,GACpB,MAAM,CAkBR"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/query/service.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAQlD,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACzC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,UAAU,cAAc;IACtB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IACtC,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EAAE,EAAE,CAAC;IAChD,mBAAmB,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClE,sBAAsB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpE;AAWD,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAGrE;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAGnD;AAED,eAAO,MAAM,kBAAkB,UAS9B,CAAC;AAEF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAsClE;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,WAAW,CAAC,CAwCtB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAExD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,YAAY,GACpB,MAAM,CAkBR"}

package/dist/query/service.js

@@ -8,6 +8,21 @@
  * (at your option) any later version.
  */
 import { escapeAtom, parseEntityFromBinding, parseEntityFromList, parseListOfLists, } from "../prolog/codec.js";
+const defaultCodecDeps = {
+    escapeAtom,
+    parseListOfLists,
+    parseEntityFromList,
+    parseEntityFromBinding,
+};
+let codecDeps = defaultCodecDeps;
+export function _setQueryCodecDepsForTests(deps) {
+    // implements REQ-003
+    codecDeps = deps;
+}
+export function _resetQueryCodecDepsForTests() {
+    // implements REQ-003
+    codecDeps = defaultCodecDeps;
+}
 export const VALID_ENTITY_TYPES = [
     "req",
     "scenario",
@@ -22,33 +37,34 @@ export const VALID_ENTITY_TYPES = [
  * Build a Prolog query goal from filters.
  */
 export function buildEntityQueryGoal(filters) {
+    // implements REQ-003
     const { type, id, sourceFile, tags } = filters;
     if (sourceFile) {
-        const safeSource = escapeAtom(sourceFile);
+        const safeSource = codecDeps.escapeAtom(sourceFile);
         if (type) {
-            const safeType = escapeAtom(type);
+            const safeType = codecDeps.escapeAtom(type);
             return `findall([Id,'${safeType}',Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, '${safeType}', Props)), Results)`;
         }
         return `findall([Id,Type,Props], (kb_entities_by_source('${safeSource}', SourceIds), member(Id, SourceIds), kb_entity(Id, Type, Props)), Results)`;
     }
     if (id && type) {
-        const safeId = escapeAtom(id);
-        const safeType = escapeAtom(type);
+        const safeId = codecDeps.escapeAtom(id);
+        const safeType = codecDeps.escapeAtom(type);
         return `findall(['${safeId}','${safeType}',Props], kb_entity('${safeId}', '${safeType}', Props), Results)`;
     }
     if (id) {
-        const safeId = escapeAtom(id);
+        const safeId = codecDeps.escapeAtom(id);
         return `findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`;
     }
     if (tags && tags.length > 0) {
         if (type) {
-            const safeType = escapeAtom(type);
+            const safeType = codecDeps.escapeAtom(type);
             return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
         }
         return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
     }
     if (type) {
-        const safeType = escapeAtom(type);
+        const safeType = codecDeps.escapeAtom(type);
         return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
     }
     return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
@@ -57,20 +73,21 @@ export function buildEntityQueryGoal(filters) {
  * Execute a filtered entity query against the KB.
  */
 export async function queryEntities(prolog, filters) {
+    // implements REQ-003
     const { tags, limit = 100, offset = 0 } = filters;
     const goal = buildEntityQueryGoal(filters);
     const queryResult = await prolog.query(goal);
     let entities = [];
     if (queryResult.success) {
         if (queryResult.bindings.Results) {
-            const entitiesData = parseListOfLists(queryResult.bindings.Results);
+            const entitiesData = codecDeps.parseListOfLists(queryResult.bindings.Results);
             for (const data of entitiesData) {
-                const entity = parseEntityFromList(data);
+                const entity = codecDeps.parseEntityFromList(data);
                 entities.push(entity);
             }
         }
         else if (queryResult.bindings.Result) {
-            const entity = parseEntityFromBinding(queryResult.bindings.Result);
+            const entity = codecDeps.parseEntityFromBinding(queryResult.bindings.Result);
             entities = [entity];
         }
     }

package/dist/schemas/entity.schema.json

@@ -38,6 +38,15 @@
         "severity": { "type": "string" },
         "links": { "type": "array", "items": { "type": "string" } },
         "text_ref": { "type": "string" },
+        "sourceFile": { "type": "string" },
+        "verification_scope": {
+            "type": "string",
+            "enum": ["unit", "integration", "end_to_end"]
+        },
+        "verification_perspective": {
+            "type": "string",
+            "enum": ["internal", "consumer"]
+        },
         "type": {
             "type": "string",
             "enum": [
@@ -87,6 +96,20 @@
         "type"
     ],
     "allOf": [
+        {
+            "if": {
+                "properties": { "type": { "const": "test" } }
+            },
+            "then": {},
+            "else": {
+                "not": {
+                    "anyOf": [
+                        { "required": ["verification_scope"] },
+                        { "required": ["verification_perspective"] }
+                    ]
+                }
+            }
+        },
         {
             "if": {
                 "properties": { "type": { "const": "fact" } }

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

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