kibi-cli 0.14.0 → 0.17.0

package/dist/public/operations/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/public/operations/catalog.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE/D,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmBe,CAAC;AAO9C,wBAAgB,OAAO,CAAC,IAAI,EAAE,aAAa,GAAG,aAAa,CAM1D;AAGD,wBAAgB,SAAS,IAAI,SAAS,aAAa,EAAE,CAEpD"}

package/dist/public/operations/catalog.js

@@ -0,0 +1,42 @@
+import { autopilotGenerateSpec } from "./specs/autopilot.js";
+import { checkSpec } from "./specs/check.js";
+import { querySpec, searchSpec, statusSpec } from "./specs/discovery.js";
+import { modelRequirementSpec, suggestPredicatesSpec, } from "./specs/modeling.js";
+import { deleteSpec, upsertSpec, validateUpsertSpec, } from "./specs/mutation.js";
+import { coverageSpec, findGapsSpec, graphSpec } from "./specs/reporting.js";
+import { semanticAdvisorSpec } from "./specs/semantic.js";
+import { skillsListSpec, skillsLoadSpec, skillsReadSpec, } from "./specs/skills.js";
+import { sparqlRemoteSpec } from "./specs/sparql.js";
+export const OPERATION_CATALOG = [
+    skillsListSpec,
+    skillsLoadSpec,
+    skillsReadSpec,
+    querySpec,
+    searchSpec,
+    statusSpec,
+    findGapsSpec,
+    coverageSpec,
+    graphSpec,
+    semanticAdvisorSpec,
+    modelRequirementSpec,
+    suggestPredicatesSpec,
+    autopilotGenerateSpec,
+    validateUpsertSpec,
+    upsertSpec,
+    deleteSpec,
+    checkSpec,
+    sparqlRemoteSpec,
+];
+const SPECS_BY_NAME = new Map(OPERATION_CATALOG.map((spec) => [spec.name, spec]));
+// implements REQ-kibi-operation-interface-parity
+export function getSpec(name) {
+    const spec = SPECS_BY_NAME.get(name);
+    if (!spec) {
+        throw new RangeError(`Unknown Kibi operation: ${name}`);
+    }
+    return spec;
+}
+// implements REQ-kibi-operation-interface-parity
+export function listSpecs() {
+    return OPERATION_CATALOG;
+}

package/dist/public/operations/check-executor.d.ts

@@ -0,0 +1,21 @@
+import { type CheckDiagnostic, type CheckStructuredContent, buildStructuredContent, buildSummary } from "./check-format-shared.js";
+import { getEffectiveRules, loadChecksConfig } from "./check-helpers.js";
+import type { OperationContext } from "./runtime-types.js";
+import type { OperationResult } from "./types.js";
+export type CheckInput = {
+    readonly rules?: readonly string[];
+    readonly workspaceRoot?: string;
+    readonly sourceFiles?: readonly string[];
+    readonly staged?: boolean;
+    readonly includeWorkingTreeDiff?: boolean;
+    readonly includeImpactDiagnostics?: boolean;
+    readonly maxDiagnostics?: number;
+};
+export type CheckPayload = CheckStructuredContent;
+export type { CheckDiagnostic, CheckStructuredContent };
+export { buildStructuredContent, buildSummary, getEffectiveRules, loadChecksConfig, };
+export type CheckExecutionOptions = {
+    readonly collectFullQualityDiagnosticsForExplicitRules?: boolean;
+};
+export declare function executeCheck(args: CheckInput, context: OperationContext, options?: CheckExecutionOptions): Promise<OperationResult<CheckPayload>>;
+//# sourceMappingURL=check-executor.d.ts.map

package/dist/public/operations/check-executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-executor.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-executor.ts"],"names":[],"mappings":"AAoBA,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,sBAAsB,EACtB,YAAY,EACb,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,iBAAiB,EACjB,gBAAgB,EAEjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGlD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,OAAO,CAAC;IAC1C,QAAQ,CAAC,wBAAwB,CAAC,EAAE,OAAO,CAAC;IAC5C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,sBAAsB,CAAC;AAClD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,CAAC;AACxD,OAAO,EACL,sBAAsB,EACtB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,GACjB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,6CAA6C,CAAC,EAAE,OAAO,CAAC;CAClE,CAAC;AAcF,wBAAsB,YAAY,CAChC,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,qBAA0B,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA4GxC"}

package/dist/public/operations/check-executor.js

@@ -0,0 +1,111 @@
+import { runAggregatedChecks } from "../../commands/aggregated-checks.js";
+import { collectFullKbQualityDiagnostics } from "../impact-diagnostics.js";
+import { buildStructuredContent, buildSummary, } from "./check-format-shared.js";
+import { analyzeKbCheckImpact, collectQueryPlanSafetyViolations, getEffectiveRules, loadChecksConfig, qualityDiagnosticsFromImpact, } from "./check-helpers.js";
+export { buildStructuredContent, buildSummary, getEffectiveRules, loadChecksConfig, };
+function requireProlog(context) {
+    if (context.prolog === undefined) {
+        throw new Error("Check operation requires a Prolog runtime");
+    }
+    return context.prolog;
+}
+function invalidatePrologCache(prolog) {
+    prolog.invalidateCache?.();
+}
+// implements REQ-kibi-operation-interface-parity, REQ-002
+export async function executeCheck(args, context, options = {}) {
+    try {
+        const workspaceRoot = args.workspaceRoot ?? context.workspaceRoot;
+        const prolog = requireProlog(context);
+        const checksConfig = await loadChecksConfig(workspaceRoot);
+        const rulesAllowlist = args.rules === undefined
+            ? getEffectiveRules(checksConfig.rules)
+            : args.rules.length === 0
+                ? new Set()
+                : getEffectiveRules(undefined, args.rules.join(","));
+        const hasExplicitRules = args.rules !== undefined;
+        const impactResult = analyzeKbCheckImpact(workspaceRoot, args);
+        const impactQualityDiagnostics = qualityDiagnosticsFromImpact(impactResult);
+        const maxDiagnosticsOption = args.maxDiagnostics !== undefined
+            ? { maxDiagnostics: args.maxDiagnostics }
+            : {};
+        if (rulesAllowlist.size === 0) {
+            const qualityDiagnostics = hasExplicitRules &&
+                options.collectFullQualityDiagnosticsForExplicitRules !== true
+                ? []
+                : impactResult
+                    ? impactQualityDiagnostics
+                    : await collectFullKbQualityDiagnostics({
+                        prolog,
+                        ...maxDiagnosticsOption,
+                    });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: buildSummary({
+                            violations: [],
+                            impactResult,
+                            qualityDiagnostics,
+                        }),
+                    },
+                ],
+                structuredContent: buildStructuredContent({
+                    violations: [],
+                    diagnostics: [],
+                    qualityDiagnostics,
+                    impactResult,
+                }),
+            };
+        }
+        invalidatePrologCache(prolog);
+        const aggregatedViolations = await runAggregatedChecks(prolog, rulesAllowlist, checksConfig.symbolTraceability.requireAdr);
+        const queryPlanViolations = rulesAllowlist.has("query-plan-safety")
+            ? collectQueryPlanSafetyViolations()
+            : [];
+        const violations = [
+            ...aggregatedViolations,
+            ...queryPlanViolations,
+        ];
+        const diagnostics = violations.map((v) => ({
+            category: "SYNC_ERROR",
+            severity: "error",
+            message: v.description,
+            ...(v.source !== undefined ? { file: v.source } : {}),
+            ...(v.suggestion !== undefined ? { suggestion: v.suggestion } : {}),
+        }));
+        const collectFullQualityDiagnostics = !hasExplicitRules ||
+            options.collectFullQualityDiagnosticsForExplicitRules === true;
+        const qualityDiagnostics = !collectFullQualityDiagnostics
+            ? impactQualityDiagnostics
+            : impactResult
+                ? impactQualityDiagnostics
+                : await collectFullKbQualityDiagnostics({
+                    prolog,
+                    hardViolationEntityIds: new Set(violations.map((v) => v.entityId)),
+                    ...maxDiagnosticsOption,
+                });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: buildSummary({
+                        violations,
+                        impactResult,
+                        qualityDiagnostics,
+                    }),
+                },
+            ],
+            structuredContent: buildStructuredContent({
+                violations,
+                diagnostics,
+                qualityDiagnostics,
+                impactResult,
+            }),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Check execution failed: ${message}`);
+    }
+}

package/dist/public/operations/check-format-shared.d.ts

@@ -0,0 +1,36 @@
+import type { Violation } from "../check-types.js";
+import type { ChangedFileImpactResult } from "../impact-diagnostics.js";
+import type { QualityDiagnostic } from "../impact-diagnostics.js";
+export interface CheckDiagnostic {
+    readonly category: string;
+    readonly severity: "error" | "warning";
+    readonly message: string;
+    readonly file?: string;
+    readonly suggestion?: string;
+}
+export interface CheckStructuredContent {
+    readonly violations: readonly Violation[];
+    readonly count: number;
+    readonly diagnostics: readonly CheckDiagnostic[];
+    readonly qualityDiagnostics?: readonly QualityDiagnostic[];
+    readonly impactDiagnostics?: ChangedFileImpactResult["impactDiagnostics"];
+    readonly sourceFiles?: ChangedFileImpactResult["sourceFiles"];
+    readonly extractedSymbols?: ChangedFileImpactResult["extractedSymbols"];
+    readonly linkedEntities?: ChangedFileImpactResult["linkedEntities"];
+    readonly nextActions?: ChangedFileImpactResult["nextActions"];
+}
+export declare function formatImpactText(impactResult: ChangedFileImpactResult): string;
+export declare function formatQualityDiagnosticsText(diagnostics: readonly QualityDiagnostic[]): string;
+export declare function formatViolationText(violations: readonly Violation[]): string;
+export declare function buildStructuredContent(input: {
+    violations: readonly Violation[];
+    diagnostics: readonly CheckDiagnostic[];
+    qualityDiagnostics?: readonly QualityDiagnostic[];
+    impactResult: ChangedFileImpactResult | undefined;
+}): CheckStructuredContent;
+export declare function buildSummary(input: {
+    readonly violations: readonly Violation[];
+    readonly impactResult: ChangedFileImpactResult | undefined;
+    readonly qualityDiagnostics: readonly QualityDiagnostic[];
+}): string;
+//# sourceMappingURL=check-format-shared.d.ts.map

package/dist/public/operations/check-format-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-format-shared.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-format-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAkBnD,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAGD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACjD,QAAQ,CAAC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAC3D,QAAQ,CAAC,iBAAiB,CAAC,EAAE,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;IAC1E,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;IAC9D,QAAQ,CAAC,gBAAgB,CAAC,EAAE,uBAAuB,CAAC,kBAAkB,CAAC,CAAC;IACxE,QAAQ,CAAC,cAAc,CAAC,EAAE,uBAAuB,CAAC,gBAAgB,CAAC,CAAC;IACpE,QAAQ,CAAC,WAAW,CAAC,EAAE,uBAAuB,CAAC,aAAa,CAAC,CAAC;CAC/D;AAaD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,uBAAuB,GACpC,MAAM,CAaR;AAaD,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,SAAS,iBAAiB,EAAE,GACxC,MAAM,CA4BR;AAGD,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,GAAG,MAAM,CAmB5E;AAGD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE;IAC5C,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IACjC,WAAW,EAAE,SAAS,eAAe,EAAE,CAAC;IACxC,kBAAkB,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IAClD,YAAY,EAAE,uBAAuB,GAAG,SAAS,CAAC;CACnD,GAAG,sBAAsB,CAmBzB;AAGD,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAC3D,QAAQ,CAAC,kBAAkB,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC3D,GAAG,MAAM,CAST"}

package/dist/public/operations/check-format-shared.js

@@ -0,0 +1,107 @@
+function formatDiagnostics(diagnostics) {
+    return diagnostics.map((d) => ({
+        category: d.category,
+        severity: d.severity,
+        message: d.message,
+        ...(d.file !== undefined ? { file: d.file } : {}),
+        ...(d.suggestion !== undefined ? { suggestion: d.suggestion } : {}),
+    }));
+}
+// implements REQ-mcp-tool-check
+export function formatImpactText(impactResult) {
+    if (impactResult.impactDiagnostics.length === 0) {
+        return "No impact diagnostics found";
+    }
+    const details = impactResult.impactDiagnostics.map((diagnostic) => {
+        const files = diagnostic.files.length > 0
+            ? diagnostic.files.join(", ")
+            : "unknown-source";
+        return `- ${diagnostic.id} | ${diagnostic.severity} | ${files} | ${diagnostic.message} Suggestion: ${diagnostic.suggestion}`;
+    });
+    return `${impactResult.impactDiagnostics.length} impact diagnostics found\n${details.join("\n")}`;
+}
+function formatOptionalList(label, values) {
+    if (values === undefined || values.length === 0) {
+        return [];
+    }
+    return [`${label}: ${values.join(", ")}`];
+}
+// implements REQ-mcp-tool-check
+export function formatQualityDiagnosticsText(diagnostics) {
+    if (diagnostics.length === 0) {
+        return "No quality diagnostics found";
+    }
+    const details = diagnostics.map((diagnostic) => {
+        const parts = [
+            diagnostic.id,
+            diagnostic.severity,
+            diagnostic.category,
+            diagnostic.message,
+        ];
+        const metadata = [
+            `Blocking: ${diagnostic.blocking ? "yes" : "no"}`,
+            ...formatOptionalList("Files", diagnostic.files),
+            ...formatOptionalList("Docs", diagnostic.docs),
+            ...(diagnostic.entityId !== undefined
+                ? [`Entity: ${diagnostic.entityId}`]
+                : []),
+            ...(diagnostic.source !== undefined
+                ? [`Source: ${diagnostic.source}`]
+                : []),
+            `Suggestion: ${diagnostic.suggestion}`,
+        ];
+        return `- ${parts.join(" | ")}\n  ${metadata.join("\n  ")}`;
+    });
+    return `${diagnostics.length} quality diagnostic${diagnostics.length === 1 ? "" : "s"} found\n${details.join("\n")}`;
+}
+// implements REQ-mcp-tool-check
+export function formatViolationText(violations) {
+    if (violations.length === 0) {
+        return "No violations found";
+    }
+    const details = violations.map((violation) => {
+        const parts = [
+            violation.rule,
+            violation.entityId,
+            violation.source ?? "unknown-source",
+            violation.description,
+        ];
+        if (violation.suggestion) {
+            parts.push(`Suggestion: ${violation.suggestion}`);
+        }
+        return `- ${parts.join(" | ")}`;
+    });
+    return `${violations.length} violations found\n${details.join("\n")}`;
+}
+// implements REQ-mcp-tool-check
+export function buildStructuredContent(input) {
+    const qualityDiagnostics = input.qualityDiagnostics ?? [];
+    return {
+        violations: [...input.violations],
+        count: input.violations.length,
+        diagnostics: formatDiagnostics(input.diagnostics),
+        ...(qualityDiagnostics.length > 0
+            ? { qualityDiagnostics: [...qualityDiagnostics] }
+            : {}),
+        ...(input.impactResult
+            ? {
+                impactDiagnostics: input.impactResult.impactDiagnostics,
+                sourceFiles: input.impactResult.sourceFiles,
+                extractedSymbols: input.impactResult.extractedSymbols,
+                linkedEntities: input.impactResult.linkedEntities,
+                nextActions: input.impactResult.nextActions,
+            }
+            : {}),
+    };
+}
+// implements REQ-mcp-tool-check
+export function buildSummary(input) {
+    const sections = [formatViolationText(input.violations)];
+    if (input.impactResult !== undefined) {
+        sections.push(formatImpactText(input.impactResult));
+    }
+    if (input.qualityDiagnostics.length > 0) {
+        sections.push(formatQualityDiagnosticsText(input.qualityDiagnostics));
+    }
+    return sections.join("\n");
+}

package/dist/public/operations/check-helpers.d.ts

@@ -0,0 +1,10 @@
+import { type ChecksConfig, RULE_NAMES, type Violation, getEffectiveRules } from "../../utils/rule-registry.js";
+import { type ChangedFileImpactResult, type QualityDiagnostic } from "../impact-diagnostics.js";
+import type { CheckInput } from "./check-executor.js";
+export { RULE_NAMES, getEffectiveRules };
+export declare function collectQueryPlanSafetyViolations(): Violation[];
+export declare function loadChecksConfig(workspaceRoot: string): Promise<ChecksConfig>;
+export declare function hasImpactOptions(args: CheckInput): boolean;
+export declare function analyzeKbCheckImpact(workspaceRoot: string, args: CheckInput): ChangedFileImpactResult | undefined;
+export declare function qualityDiagnosticsFromImpact(impactResult: ChangedFileImpactResult | undefined): readonly QualityDiagnostic[];
+//# sourceMappingURL=check-helpers.d.ts.map

package/dist/public/operations/check-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-helpers.d.ts","sourceRoot":"","sources":["../../../src/public/operations/check-helpers.ts"],"names":[],"mappings":"AAuBA,OAAO,EACL,KAAK,YAAY,EAEjB,UAAU,EACV,KAAK,SAAS,EACd,iBAAiB,EAClB,MAAM,8BAA8B,CAAC;AACtC,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,iBAAiB,EAEvB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,CAAC;AAQzC,wBAAgB,gCAAgC,IAAI,SAAS,EAAE,CAU9D;AAGD,wBAAsB,gBAAgB,CACpC,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,YAAY,CAAC,CAkCvB;AAGD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAO1D;AAGD,wBAAgB,oBAAoB,CAClC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,UAAU,GACf,uBAAuB,GAAG,SAAS,CAoBrC;AAGD,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,uBAAuB,GAAG,SAAS,GAChD,SAAS,iBAAiB,EAAE,CAK9B"}

package/dist/public/operations/check-helpers.js

@@ -0,0 +1,107 @@
+import { readFileSync } from "node:fs";
+/*
+ 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 { readFile } from "node:fs/promises";
+import path from "node:path";
+import { getKbPlPathOverride } from "../../env.js";
+import { resolveKbPlPath } from "../../prolog.js";
+import { analyzePrologQueryPlanSafety } from "../../utils/prolog-query-plan-safety.js";
+import { DEFAULT_CHECKS_CONFIG, RULE_NAMES, getEffectiveRules, } from "../../utils/rule-registry.js";
+import { analyzeChangedFileImpact, } from "../impact-diagnostics.js";
+export { RULE_NAMES, getEffectiveRules };
+function resolveChecksPlPath() {
+    const override = getKbPlPathOverride();
+    return path.join(path.dirname(override ?? resolveKbPlPath()), "checks.pl");
+}
+// implements REQ-mcp-tool-check
+export function collectQueryPlanSafetyViolations() {
+    const checksPlPath = resolveChecksPlPath();
+    const source = readFileSync(checksPlPath, "utf8");
+    return analyzePrologQueryPlanSafety(source).map((v) => ({
+        rule: "query-plan-safety",
+        entityId: v.predicate,
+        description: v.description,
+        suggestion: v.suggestion,
+        source: `${checksPlPath}:${v.line}`,
+    }));
+}
+// implements REQ-mcp-tool-check
+export async function loadChecksConfig(workspaceRoot) {
+    const configPath = path.join(workspaceRoot, ".kb", "config.json");
+    try {
+        const content = await readFile(configPath, "utf8");
+        const parsed = JSON.parse(content);
+        const parsedRules = parsed.checks?.rules;
+        const normalizedRules = {
+            ...DEFAULT_CHECKS_CONFIG.rules,
+        };
+        if (parsedRules && typeof parsedRules === "object") {
+            for (const [key, value] of Object.entries(parsedRules)) {
+                if (typeof value === "boolean") {
+                    normalizedRules[key] = value;
+                }
+            }
+        }
+        const parsedSt = parsed.checks?.symbolTraceability;
+        const normalizedSt = { ...DEFAULT_CHECKS_CONFIG.symbolTraceability };
+        if (parsedSt &&
+            typeof parsedSt === "object" &&
+            typeof parsedSt.requireAdr === "boolean") {
+            normalizedSt.requireAdr = parsedSt.requireAdr;
+        }
+        return { rules: normalizedRules, symbolTraceability: normalizedSt };
+    }
+    catch {
+        return DEFAULT_CHECKS_CONFIG;
+    }
+}
+// implements REQ-mcp-tool-check
+export function hasImpactOptions(args) {
+    return Boolean(args.includeImpactDiagnostics ||
+        args.staged ||
+        args.includeWorkingTreeDiff ||
+        (args.sourceFiles !== undefined && args.sourceFiles.length > 0));
+}
+// implements REQ-mcp-tool-check
+export function analyzeKbCheckImpact(workspaceRoot, args) {
+    if (!hasImpactOptions(args)) {
+        return undefined;
+    }
+    return analyzeChangedFileImpact({
+        workspaceRoot,
+        ...(args.sourceFiles !== undefined
+            ? { sourceFiles: args.sourceFiles }
+            : {}),
+        ...(args.staged !== undefined ? { staged: args.staged } : {}),
+        ...(args.includeWorkingTreeDiff !== undefined
+            ? { includeWorkingTreeDiff: args.includeWorkingTreeDiff }
+            : {}),
+        ...(args.includeImpactDiagnostics !== undefined
+            ? { includeImpactDiagnostics: args.includeImpactDiagnostics }
+            : {}),
+        ...(args.maxDiagnostics !== undefined
+            ? { maxDiagnostics: args.maxDiagnostics }
+            : {}),
+    });
+}
+// implements REQ-mcp-tool-check
+export function qualityDiagnosticsFromImpact(impactResult) {
+    if (impactResult === undefined)
+        return [];
+    return impactResult.impactDiagnostics.filter((d) => !d.blocking && d.severity !== "error");
+}

package/dist/public/operations/discovery-entities.d.ts

@@ -0,0 +1,14 @@
+import type { PrologPort } from "./runtime-types.js";
+export type EntityQueryInput = {
+    readonly type?: string;
+    readonly id?: string;
+    readonly tags?: readonly string[];
+    readonly sourceFile?: string;
+};
+export declare const VALID_ENTITY_TYPES: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+export declare function validateEntityType(type?: string): void;
+export declare function buildEntityGoal(input: EntityQueryInput): string;
+export declare function loadEntities(prolog: Pick<PrologPort, "query">, input: EntityQueryInput): Promise<Record<string, unknown>[]>;
+export declare function paginateResults<T>(results: readonly T[], limit?: number, offset?: number): T[];
+export declare function dedupeEntities(entities: readonly Record<string, unknown>[]): Record<string, unknown>[];
+//# sourceMappingURL=discovery-entities.d.ts.map

package/dist/public/operations/discovery-entities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-entities.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-entities.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAErD,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF,eAAO,MAAM,kBAAkB,gFASrB,CAAC;AAGX,wBAAgB,kBAAkB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI,CAMtD;AAGD,wBAAgB,eAAe,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CA+B/D;AAGD,wBAAsB,YAAY,CAChC,MAAM,EAAE,IAAI,CAAC,UAAU,EAAE,OAAO,CAAC,EACjC,KAAK,EAAE,gBAAgB,GACtB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CA0BpC;AAGD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,KAAK,SAAM,EACX,MAAM,SAAI,GACT,CAAC,EAAE,CAEL;AAGD,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,GAC3C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAQ3B"}

package/dist/public/operations/discovery-entities.js

@@ -0,0 +1,91 @@
+import { escapeAtomContent, parseEntityFromBinding, parseEntityFromList, parseListOfLists, } from "../../prolog/codec.js";
+export const VALID_ENTITY_TYPES = [
+    "req",
+    "scenario",
+    "test",
+    "adr",
+    "flag",
+    "event",
+    "symbol",
+    "fact",
+];
+// implements REQ-002, REQ-013
+export function validateEntityType(type) {
+    if (type && !VALID_ENTITY_TYPES.some((candidate) => candidate === type)) {
+        throw new Error(`Invalid type '${type}'. Valid types: ${VALID_ENTITY_TYPES.join(", ")}. Use a single type value, or omit this parameter to query all entities.`);
+    }
+}
+// implements REQ-002, REQ-013
+export function buildEntityGoal(input) {
+    const { type, id, tags, sourceFile } = input;
+    if (sourceFile) {
+        const safeSource = escapeAtomContent(sourceFile);
+        if (type) {
+            const safeType = escapeAtomContent(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 = escapeAtomContent(id);
+        const safeType = escapeAtomContent(type);
+        return `findall(['${safeId}','${safeType}',Props], kb_entity('${safeId}', '${safeType}', Props), Results)`;
+    }
+    if (id) {
+        const safeId = escapeAtomContent(id);
+        return `findall(['${safeId}',Type,Props], kb_entity('${safeId}', Type, Props), Results)`;
+    }
+    if (tags && tags.length > 0) {
+        if (type) {
+            const safeType = escapeAtomContent(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 = escapeAtomContent(type);
+        return `findall([Id,'${safeType}',Props], kb_entity(Id, '${safeType}', Props), Results)`;
+    }
+    return "findall([Id,Type,Props], kb_entity(Id, Type, Props), Results)";
+}
+// implements REQ-002, REQ-013
+export async function loadEntities(prolog, input) {
+    validateEntityType(input.type);
+    const queryResult = await prolog.query(buildEntityGoal(input));
+    if (!queryResult.success) {
+        throw new Error(queryResult.error || "Query failed with unknown error");
+    }
+    let entities = [];
+    const resultsBinding = queryResult.bindings.Results;
+    const resultBinding = queryResult.bindings.Result;
+    if (resultsBinding) {
+        entities = parseListOfLists(resultsBinding).map(parseEntityFromList);
+    }
+    else if (resultBinding) {
+        entities = [parseEntityFromBinding(resultBinding)];
+    }
+    if (input.tags && input.tags.length > 0) {
+        const requested = new Set(input.tags.map((tag) => tag.trim()));
+        entities = entities.filter((entity) => {
+            const tags = entity.tags;
+            return (Array.isArray(tags) &&
+                tags.some((tag) => requested.has(String(tag).trim())));
+        });
+    }
+    return dedupeEntities(entities);
+}
+// implements REQ-002
+export function paginateResults(results, limit = 100, offset = 0) {
+    return results.slice(offset, offset + limit);
+}
+// implements REQ-002
+export function dedupeEntities(entities) {
+    const seen = new Set();
+    return entities.filter((entity) => {
+        const key = `${String(entity.type ?? "")}::${String(entity.id ?? "")}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}

package/dist/public/operations/discovery-executors.d.ts

@@ -0,0 +1,39 @@
+import type { SearchMatch } from "../../search-ranking.js";
+import type { OperationContext } from "./runtime-types.js";
+import type { OperationResult } from "./types.js";
+export type QueryInput = {
+    readonly type?: string;
+    readonly id?: string;
+    readonly tags?: readonly string[];
+    readonly sourceFile?: string;
+    readonly limit?: number;
+    readonly offset?: number;
+};
+export type QueryPayload = {
+    readonly entities: readonly Record<string, unknown>[];
+    readonly count: number;
+};
+export type SearchInput = {
+    readonly query: string;
+    readonly type?: string;
+    readonly limit?: number;
+    readonly offset?: number;
+};
+export type SearchPayload = {
+    readonly results: readonly SearchMatch[];
+    readonly count: number;
+};
+export type StatusInput = Readonly<Record<string, never>>;
+export type StatusPayload = {
+    readonly branch: string;
+    readonly snapshotId: string;
+    readonly syncedAt: string | null;
+    readonly dirty: boolean;
+    readonly syncState: string;
+    readonly kbPath?: string;
+    readonly lastSyncSource?: string;
+};
+export declare function executeQuery(input: QueryInput, context: OperationContext): Promise<OperationResult<QueryPayload>>;
+export declare function executeSearch(input: SearchInput, context: OperationContext): Promise<OperationResult<SearchPayload>>;
+export declare function executeStatus(_input: StatusInput, context: OperationContext): Promise<OperationResult<StatusPayload>>;
+//# sourceMappingURL=discovery-executors.d.ts.map

package/dist/public/operations/discovery-executors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery-executors.d.ts","sourceRoot":"","sources":["../../../src/public/operations/discovery-executors.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAO3D,OAAO,KAAK,EAAE,gBAAgB,EAAc,MAAM,oBAAoB,CAAC;AACvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,OAAO,EAAE,SAAS,WAAW,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;AAE1D,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;CAClC,CAAC;AAqBF,wBAAsB,YAAY,CAChC,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CA+BxC;AAED,wBAAsB,aAAa,CACjC,KAAK,EAAE,WAAW,EAClB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAsCzC;AAED,wBAAsB,aAAa,CACjC,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,aAAa,CAAC,CAAC,CAyBzC"}