kibi-cli 0.12.8 → 0.16.1

package/dist/public/operations/specs/check.js

@@ -0,0 +1,62 @@
+import { executeCheck } from "../check-executor.js";
+export const checkSpec = {
+    name: "kb_check",
+    cliName: "check",
+    description: "Run KB validation rules and return violations. Use before or after mutations, and after meaningful source edits with impact options to surface symbol granularity and semantic-review diagnostics. Do not use for point lookups. No write side effects. Prefer explicit rules for faster iteration; omit rules for final full validation plus full-KB qualityDiagnostics review.",
+    businessInputSchema: {
+        type: "object",
+        properties: {
+            rules: {
+                type: "array",
+                items: {
+                    type: "string",
+                    enum: [
+                        "must-priority-coverage",
+                        "symbol-coverage",
+                        "symbol-traceability",
+                        "no-dangling-refs",
+                        "no-cycles",
+                        "required-fields",
+                        "deprecated-adr-no-successor",
+                        "domain-contradictions",
+                        "strict-fact-shape",
+                        "strict-req-fact-pairing",
+                        "predicate-verifiability",
+                        "logic-coverage",
+                        "query-plan-safety",
+                    ],
+                },
+                description: "Optional rule subset. Allowed: must-priority-coverage, symbol-coverage, symbol-traceability, no-dangling-refs, no-cycles, required-fields, deprecated-adr-no-successor, domain-contradictions, strict-fact-shape, strict-req-fact-pairing, predicate-verifiability, logic-coverage, query-plan-safety. If omitted, server runs all rules plus the full-KB qualityDiagnostics audit scan; if supplied, server preserves scoped validation and skips the full-KB advisory scan.",
+            },
+            sourceFiles: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional repo-relative source files to inspect for early impact diagnostics. Use with includeImpactDiagnostics after meaningful source edits.",
+            },
+            staged: {
+                type: "boolean",
+                description: "When true, inspect staged source changes for impact diagnostics using the shared CLI impact analyzer without shelling out to kibi check.",
+            },
+            includeWorkingTreeDiff: {
+                type: "boolean",
+                description: "When true, inspect current unstaged working-tree diffs for impact diagnostics. Pair with sourceFiles to scope the analysis.",
+            },
+            includeImpactDiagnostics: {
+                type: "boolean",
+                description: "When true, include changed-file impact diagnostics such as symbol_granularity_violation and symbol_semantic_review_needed in structured output.",
+            },
+            maxDiagnostics: {
+                type: "integer",
+                minimum: 0,
+                description: "Optional maximum number of impact diagnostics to return. Graph validation violations are not capped by this value.",
+            },
+            workspaceRoot: {
+                type: "string",
+                description: "Optional workspace root for impact diagnostics and .kb/config.json lookup. Defaults to the MCP server workspace.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read", "workspace-read"],
+    execute: executeCheck,
+};

package/dist/public/operations/specs/discovery.d.ts

@@ -0,0 +1,94 @@
+import { executeQuery, executeSearch, executeStatus } from "../discovery-executors.js";
+export declare const querySpec: {
+    readonly name: "kb_query";
+    readonly cliName: "query";
+    readonly description: "Read entities from the KB with filters. Use for discovery and lookup before edits. Do not use for writes. No mutation side effects. Tags filter by metadata tags only, not entity IDs.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly description: "Optional entity type filter. Allowed: req, scenario, test, adr, flag, event, symbol, fact. Example: 'req'.";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Optional exact entity ID. Example: 'REQ-001'. If omitted, returns matching entities by other filters.";
+            };
+            readonly tags: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional tag filter. Matches entities that contain any provided tag. Example: ['security','billing'].";
+            };
+            readonly sourceFile: {
+                readonly type: "string";
+                readonly description: "Optional source-file substring filter. Example: 'src/auth/login.ts'. Uses KB source linkage, not file-system scanning.";
+            };
+            readonly limit: {
+                readonly type: "number";
+                readonly default: 100;
+                readonly description: "Optional max rows to return after filtering. Default: 100 when omitted. Example: 25.";
+            };
+            readonly offset: {
+                readonly type: "number";
+                readonly default: 0;
+                readonly description: "Optional zero-based pagination offset. Default: 0. Example: 50 to skip first 50 rows.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeQuery;
+};
+export declare const searchSpec: {
+    readonly name: "kb_search";
+    readonly cliName: "search";
+    readonly description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["query"];
+        readonly properties: {
+            readonly query: {
+                readonly type: "string";
+                readonly minLength: 1;
+                readonly maxLength: 4096;
+                readonly description: "Free-text query for metadata and markdown body discovery. Example: 'OAuth login flow'.";
+            };
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly description: "Optional entity type filter to narrow discovery. Example: 'req'.";
+            };
+            readonly limit: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly default: 20;
+                readonly description: "Optional max rows to return after ranking. Default: 20.";
+            };
+            readonly offset: {
+                readonly type: "integer";
+                readonly minimum: 0;
+                readonly default: 0;
+                readonly description: "Optional zero-based pagination offset. Default: 0.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeSearch;
+};
+export declare const statusSpec: {
+    readonly name: "kb_status";
+    readonly cliName: "status";
+    readonly description: "Report current branch, snapshot, and freshness metadata for the attached KB. Read-only status inspection with no mutation side effects.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly properties: {};
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read", "workspace-read"];
+    readonly execute: typeof executeStatus;
+};
+//# sourceMappingURL=discovery.d.ts.map

package/dist/public/operations/specs/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,aAAa,EACb,aAAa,EACd,MAAM,2BAA2B,CAAC;AAsBnC,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CsC,CAAC;AAE7D,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCuC,CAAC;AAE/D,eAAO,MAAM,UAAU;;;;;;;;;;;CASuC,CAAC"}

package/dist/public/operations/specs/discovery.js

@@ -0,0 +1,98 @@
+import { executeQuery, executeSearch, executeStatus, } from "../discovery-executors.js";
+const ENTITY_TYPES = [
+    "req",
+    "scenario",
+    "test",
+    "adr",
+    "flag",
+    "event",
+    "symbol",
+    "fact",
+];
+export const querySpec = {
+    name: "kb_query",
+    cliName: "query",
+    description: "Read entities from the KB with filters. Use for discovery and lookup before edits. Do not use for writes. No mutation side effects. Tags filter by metadata tags only, not entity IDs.",
+    businessInputSchema: {
+        type: "object",
+        properties: {
+            type: {
+                type: "string",
+                enum: ENTITY_TYPES,
+                description: "Optional entity type filter. Allowed: req, scenario, test, adr, flag, event, symbol, fact. Example: 'req'.",
+            },
+            id: {
+                type: "string",
+                description: "Optional exact entity ID. Example: 'REQ-001'. If omitted, returns matching entities by other filters.",
+            },
+            tags: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional tag filter. Matches entities that contain any provided tag. Example: ['security','billing'].",
+            },
+            sourceFile: {
+                type: "string",
+                description: "Optional source-file substring filter. Example: 'src/auth/login.ts'. Uses KB source linkage, not file-system scanning.",
+            },
+            limit: {
+                type: "number",
+                default: 100,
+                description: "Optional max rows to return after filtering. Default: 100 when omitted. Example: 25.",
+            },
+            offset: {
+                type: "number",
+                default: 0,
+                description: "Optional zero-based pagination offset. Default: 0. Example: 50 to skip first 50 rows.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeQuery,
+};
+export const searchSpec = {
+    name: "kb_search",
+    cliName: "search",
+    description: "Search KB entities for discovery using metadata and markdown body text. Use for exploratory lookup before exact follow-up with kb_query. No mutation side effects.",
+    businessInputSchema: {
+        type: "object",
+        required: ["query"],
+        properties: {
+            query: {
+                type: "string",
+                minLength: 1,
+                maxLength: 4096,
+                description: "Free-text query for metadata and markdown body discovery. Example: 'OAuth login flow'.",
+            },
+            type: {
+                type: "string",
+                enum: ENTITY_TYPES,
+                description: "Optional entity type filter to narrow discovery. Example: 'req'.",
+            },
+            limit: {
+                type: "integer",
+                minimum: 0,
+                default: 20,
+                description: "Optional max rows to return after ranking. Default: 20.",
+            },
+            offset: {
+                type: "integer",
+                minimum: 0,
+                default: 0,
+                description: "Optional zero-based pagination offset. Default: 0.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeSearch,
+};
+export const statusSpec = {
+    name: "kb_status",
+    cliName: "status",
+    description: "Report current branch, snapshot, and freshness metadata for the attached KB. Read-only status inspection with no mutation side effects.",
+    businessInputSchema: { type: "object", properties: {} },
+    requiresProlog: true,
+    effects: ["kb-read", "workspace-read"],
+    execute: executeStatus,
+};

package/dist/public/operations/specs/modeling.d.ts

@@ -0,0 +1,126 @@
+import { executeModelRequirement } from "../../../operations/modeling/model-requirement.js";
+import { executeSuggestPredicates } from "../../../operations/modeling/suggest-predicates.js";
+export declare const modelRequirementSpec: {
+    readonly name: "kb_model_requirement";
+    readonly cliName: "model-requirement";
+    readonly description: "Convert a prose requirement plus optional extracted claim fields into a deterministic strict-lane write set. Read-only modeling returns a sequential applyPlan for later kb_upsert calls. High-confidence claims emit req+fact strict output; lower-confidence claims emit an observation review artifact. Includes migration warnings when legacy schemaVersion metadata is detected.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["text"];
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Required prose requirement text to model. Example: 'Customer data must be retained for 7 years.'";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.";
+            };
+            readonly sourceFiles: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                };
+                readonly description: "Optional related source files. The first value is used as the source fallback when source is omitted.";
+            };
+            readonly confidence: {
+                readonly type: "number";
+                readonly default: 0.8;
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly description: "Confidence score for the extracted claim. >= 0.70 yields strict-lane output; lower confidence yields observation-only review output.";
+            };
+            readonly subjectKey: {
+                readonly type: "string";
+                readonly description: "Optional extracted semantic claim subjectKey. Example: 'Customer.Data'.";
+            };
+            readonly propertyKey: {
+                readonly type: "string";
+                readonly description: "Optional extracted semantic claim propertyKey. Example: 'Retention Years'.";
+            };
+            readonly operator: {
+                readonly type: "string";
+                readonly enum: readonly ["eq", "gte", "lte", "neq", "bool", "polarity"];
+                readonly description: "Optional extracted semantic claim operator. Example: 'eq'.";
+            };
+            readonly value: {
+                readonly description: "Optional extracted semantic claim value. Accepts string, number, or boolean.";
+            };
+            readonly provenance: {
+                readonly type: "string";
+                readonly description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.";
+            };
+            readonly existingLogicClaims: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                };
+                readonly uniqueItems: true;
+                readonly description: "Existing requirement logic_claims values. The returned requirement update merges the new atomic claim key into this manifest instead of replacing prior claims.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeModelRequirement;
+};
+export declare const suggestPredicatesSpec: {
+    readonly name: "kb_suggest_predicates";
+    readonly cliName: "suggest-predicates";
+    readonly description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, a safe predicate-fact applyPlan, a separate requires_predicate relationshipPlan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["text"];
+        readonly properties: {
+            readonly text: {
+                readonly type: "string";
+                readonly description: "Required prose requirement or claim to classify into ontology predicates. Example: 'When users navigate away, draft edits must auto-save.'.";
+            };
+            readonly requirementId: {
+                readonly type: "string";
+                readonly description: "Optional existing requirement ID. When provided, the response includes a relationshipPlan describing the req -> fact requires_predicate link to attach after preserving existing requirement metadata.";
+            };
+            readonly source: {
+                readonly type: "string";
+                readonly description: "Optional provenance or text reference for generated predicate facts or ontology-gap observations.";
+            };
+            readonly subjectHint: {
+                readonly type: "string";
+                readonly description: "Optional canonical subject key to use as the first predicate argument. Example: 'editor.annotation'.";
+            };
+            readonly maxCandidates: {
+                readonly type: "integer";
+                readonly default: 5;
+                readonly minimum: 1;
+                readonly maximum: 20;
+                readonly description: "Maximum ranked predicate candidates to return. Default: 5.";
+            };
+            readonly minScore: {
+                readonly type: "number";
+                readonly default: 0.35;
+                readonly minimum: 0;
+                readonly maximum: 1;
+                readonly description: "Minimum candidate score. Higher values make ontology-gap fallback more likely. Default: 0.35.";
+            };
+            readonly includeExistingSchemas: {
+                readonly type: "boolean";
+                readonly default: true;
+                readonly description: "Whether to include existing KB fact_kind=predicate_schema facts alongside Kibi's built-in predicate catalog. Default: true.";
+            };
+            readonly existingLogicClaims: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "string";
+                    readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                };
+                readonly uniqueItems: true;
+                readonly description: "Existing requirement logic_claims values. Returned relationship guidance includes a merged manifest so repeated clause modeling does not discard earlier claims.";
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-read"];
+    readonly execute: typeof executeSuggestPredicates;
+};
+//# sourceMappingURL=modeling.d.ts.map

package/dist/public/operations/specs/modeling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modeling.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/modeling.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,uBAAuB,EACxB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAGL,wBAAwB,EACzB,MAAM,oDAAoD,CAAC;AAG5D,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyEhC,CAAC;AAEF,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEjC,CAAC"}

package/dist/public/operations/specs/modeling.js

@@ -0,0 +1,117 @@
+import { executeModelRequirement, } from "../../../operations/modeling/model-requirement.js";
+import { executeSuggestPredicates, } from "../../../operations/modeling/suggest-predicates.js";
+export const modelRequirementSpec = {
+    name: "kb_model_requirement",
+    cliName: "model-requirement",
+    description: "Convert a prose requirement plus optional extracted claim fields into a deterministic strict-lane write set. Read-only modeling returns a sequential applyPlan for later kb_upsert calls. High-confidence claims emit req+fact strict output; lower-confidence claims emit an observation review artifact. Includes migration warnings when legacy schemaVersion metadata is detected.",
+    businessInputSchema: {
+        type: "object",
+        required: ["text"],
+        properties: {
+            text: {
+                type: "string",
+                description: "Required prose requirement text to model. Example: 'Customer data must be retained for 7 years.'",
+            },
+            source: {
+                type: "string",
+                description: "Optional primary source path or provenance root used for stable IDs and text refs. Example: 'documentation/requirements/customer-retention.md'.",
+            },
+            sourceFiles: {
+                type: "array",
+                items: { type: "string" },
+                description: "Optional related source files. The first value is used as the source fallback when source is omitted.",
+            },
+            confidence: {
+                type: "number",
+                default: 0.8,
+                minimum: 0,
+                maximum: 1,
+                description: "Confidence score for the extracted claim. >= 0.70 yields strict-lane output; lower confidence yields observation-only review output.",
+            },
+            subjectKey: {
+                type: "string",
+                description: "Optional extracted semantic claim subjectKey. Example: 'Customer.Data'.",
+            },
+            propertyKey: {
+                type: "string",
+                description: "Optional extracted semantic claim propertyKey. Example: 'Retention Years'.",
+            },
+            operator: {
+                type: "string",
+                enum: ["eq", "gte", "lte", "neq", "bool", "polarity"],
+                description: "Optional extracted semantic claim operator. Example: 'eq'.",
+            },
+            value: {
+                description: "Optional extracted semantic claim value. Accepts string, number, or boolean.",
+            },
+            provenance: {
+                type: "string",
+                description: "Optional extracted text reference. Falls back to source when omitted. Example: 'documentation/requirements/customer-retention.md#L1'.",
+            },
+            existingLogicClaims: {
+                type: "array",
+                items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+                uniqueItems: true,
+                description: "Existing requirement logic_claims values. The returned requirement update merges the new atomic claim key into this manifest instead of replacing prior claims.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeModelRequirement,
+};
+export const suggestPredicatesSpec = {
+    name: "kb_suggest_predicates",
+    cliName: "suggest-predicates",
+    description: "Suggest ontology predicate schemas for prose requirements before agents write facts. Read-only guidance returns ranked candidates, a safe predicate-fact applyPlan, a separate requires_predicate relationshipPlan when a requirement ID is supplied, or an explicit ontology-gap observation when no predicate fits.",
+    businessInputSchema: {
+        type: "object",
+        required: ["text"],
+        properties: {
+            text: {
+                type: "string",
+                description: "Required prose requirement or claim to classify into ontology predicates. Example: 'When users navigate away, draft edits must auto-save.'.",
+            },
+            requirementId: {
+                type: "string",
+                description: "Optional existing requirement ID. When provided, the response includes a relationshipPlan describing the req -> fact requires_predicate link to attach after preserving existing requirement metadata.",
+            },
+            source: {
+                type: "string",
+                description: "Optional provenance or text reference for generated predicate facts or ontology-gap observations.",
+            },
+            subjectHint: {
+                type: "string",
+                description: "Optional canonical subject key to use as the first predicate argument. Example: 'editor.annotation'.",
+            },
+            maxCandidates: {
+                type: "integer",
+                default: 5,
+                minimum: 1,
+                maximum: 20,
+                description: "Maximum ranked predicate candidates to return. Default: 5.",
+            },
+            minScore: {
+                type: "number",
+                default: 0.35,
+                minimum: 0,
+                maximum: 1,
+                description: "Minimum candidate score. Higher values make ontology-gap fallback more likely. Default: 0.35.",
+            },
+            includeExistingSchemas: {
+                type: "boolean",
+                default: true,
+                description: "Whether to include existing KB fact_kind=predicate_schema facts alongside Kibi's built-in predicate catalog. Default: true.",
+            },
+            existingLogicClaims: {
+                type: "array",
+                items: { type: "string", pattern: "^CLAIM-[A-F0-9]{16}$" },
+                uniqueItems: true,
+                description: "Existing requirement logic_claims values. Returned relationship guidance includes a merged manifest so repeated clause modeling does not discard earlier claims.",
+            },
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-read"],
+    execute: executeSuggestPredicates,
+};