kibi-cli 0.14.0 → 0.17.0

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

@@ -0,0 +1,107 @@
+import { createHash } from "node:crypto";
+import { listBundledSkills, loadBundledSkill, readBundledSkillResource, } from "../../skills.js";
+function assertNonEmptyString(value, field) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`${field} must be a non-empty string`);
+    }
+}
+async function executeSkillsList(_input, _context) {
+    const skills = listBundledSkills();
+    const ids = skills.map((skill) => skill.id).join(", ") || "none";
+    return {
+        content: [
+            { type: "text", text: `Found ${skills.length} bundled skills: ${ids}` },
+        ],
+        structuredContent: { skills },
+    };
+}
+async function executeSkillsLoad(input, _context) {
+    const id = typeof input.id === "string" ? input.id : "";
+    assertNonEmptyString(id, "id");
+    const bundle = loadBundledSkill(id);
+    const resources = bundle.manifest.resources ?? [];
+    const contentHash = createHash("sha256")
+        .update(bundle.body, "utf8")
+        .digest("hex");
+    const resourceList = resources.length === 0 ? "none" : resources.join(", ");
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Loaded bundled skill ${bundle.manifest.id} with ${resources.length} resources: ${resourceList}`,
+            },
+        ],
+        structuredContent: {
+            metadata: bundle.manifest,
+            body: bundle.body,
+            resources,
+            contentHash,
+            sourceType: "bundled",
+        },
+    };
+}
+async function executeSkillsRead(input, _context) {
+    const id = typeof input.id === "string" ? input.id : "";
+    const resource = typeof input.resource === "string" ? input.resource : "";
+    assertNonEmptyString(id, "id");
+    assertNonEmptyString(resource, "resource");
+    const resourceContent = readBundledSkillResource(id, resource);
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Read bundled skill resource ${id}/${resource}`,
+            },
+        ],
+        structuredContent: { content: resourceContent },
+    };
+}
+export const skillsListSpec = {
+    name: "kb_skills_list",
+    cliName: "skills list",
+    description: "List bundled Kibi agent skills available for progressive disclosure. Read-only; does not mutate the KB or require Prolog.",
+    businessInputSchema: { type: "object", properties: {} },
+    requiresProlog: false,
+    effects: ["local-read"],
+    execute: executeSkillsList,
+};
+export const skillsLoadSpec = {
+    name: "kb_skills_load",
+    cliName: "skills load",
+    description: "Load a bundled Kibi agent skill by ID, returning its manifest metadata, Markdown body, declared resources, content hash, and source type. Read-only; does not execute scripts or require Prolog.",
+    businessInputSchema: {
+        type: "object",
+        required: ["id"],
+        properties: {
+            id: {
+                type: "string",
+                description: "Bundled skill ID to load. Example: 'kibi-usage'.",
+            },
+        },
+    },
+    requiresProlog: false,
+    effects: ["local-read"],
+    execute: executeSkillsLoad,
+};
+export const skillsReadSpec = {
+    name: "kb_skills_read",
+    cliName: "skills read",
+    description: "Read a declared resource from a bundled Kibi agent skill. Resource paths are restricted to the skill manifest; arbitrary file paths are not exposed. Read-only; does not require Prolog.",
+    businessInputSchema: {
+        type: "object",
+        required: ["id", "resource"],
+        properties: {
+            id: {
+                type: "string",
+                description: "Bundled skill ID. Example: 'kibi-usage'.",
+            },
+            resource: {
+                type: "string",
+                description: "Manifest-declared resource path to read. Example: 'resources/workflows.md'.",
+            },
+        },
+    },
+    requiresProlog: false,
+    effects: ["local-read"],
+    execute: executeSkillsRead,
+};

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

@@ -0,0 +1,39 @@
+import type { OperationContext } from "../runtime-types.js";
+import type { OperationResult } from "../types.js";
+export type SparqlRemoteInput = {
+    readonly endpoint: string;
+    readonly query: string;
+    readonly timeoutMs?: number;
+};
+export type SparqlRemoteOutput = {
+    readonly rows: readonly Readonly<Record<string, unknown>>[];
+};
+declare function executeSparqlRemote(input: SparqlRemoteInput, context: OperationContext): Promise<OperationResult<SparqlRemoteOutput>>;
+export declare const sparqlRemoteSpec: {
+    readonly name: "kb_sparql_remote";
+    readonly cliName: "sparql-remote";
+    readonly description: "Opt-in remote SPARQL query tool for external HTTP(S) RDF endpoints. This does not query Kibi's local RDF store directly, stores no credentials, and depends on network availability.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["endpoint", "query"];
+        readonly properties: {
+            readonly endpoint: {
+                readonly type: "string";
+                readonly description: "Remote SPARQL endpoint URL. Must start with http:// or https://.";
+            };
+            readonly query: {
+                readonly type: "string";
+                readonly description: "SPARQL SELECT query to send to the remote endpoint.";
+            };
+            readonly timeoutMs: {
+                readonly type: "number";
+                readonly description: "Optional positive timeout in milliseconds for the remote query.";
+            };
+        };
+    };
+    readonly requiresProlog: false;
+    readonly effects: readonly ["network-read"];
+    readonly execute: typeof executeSparqlRemote;
+};
+export {};
+//# sourceMappingURL=sparql.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sparql.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/sparql.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAiB,MAAM,aAAa,CAAC;AAGlE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAGF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,CAAC;CAC7D,CAAC;AA2DF,iBAAe,mBAAmB,CAChC,KAAK,EAAE,iBAAiB,EACxB,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CA2C9C;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;CA4B4C,CAAC"}

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

@@ -0,0 +1,121 @@
+function validateInput(input) {
+    if (typeof input.endpoint !== "string" || input.endpoint.trim() === "") {
+        throw new Error("SPARQL endpoint is required");
+    }
+    if (typeof input.query !== "string" || input.query.trim() === "") {
+        throw new Error("SPARQL query is required");
+    }
+    let endpoint;
+    try {
+        endpoint = new URL(input.endpoint);
+    }
+    catch {
+        throw new Error("SPARQL endpoint must be an http:// or https:// URL");
+    }
+    if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:") {
+        throw new Error("SPARQL endpoint must be an http:// or https:// URL");
+    }
+    if (!/^\s*select\b/i.test(input.query)) {
+        throw new Error("SPARQL query must be a SELECT query");
+    }
+    if (input.timeoutMs !== undefined &&
+        (!Number.isFinite(input.timeoutMs) || input.timeoutMs <= 0)) {
+        throw new Error("SPARQL timeoutMs must be a positive number when provided");
+    }
+    return endpoint;
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function decodeRows(payload) {
+    if (!isRecord(payload) || !isRecord(payload.results)) {
+        throw new Error("SPARQL endpoint returned an invalid result document");
+    }
+    const bindings = payload.results.bindings;
+    if (!Array.isArray(bindings)) {
+        throw new Error("SPARQL endpoint returned an invalid bindings array");
+    }
+    const rows = bindings.map((binding) => {
+        if (!isRecord(binding)) {
+            throw new Error("SPARQL endpoint returned an invalid binding");
+        }
+        const row = {};
+        for (const [variable, term] of Object.entries(binding)) {
+            if (!isRecord(term) || typeof term.value !== "string") {
+                throw new Error(`SPARQL endpoint returned an invalid ${variable} term`);
+            }
+            row[variable] = term.value;
+        }
+        return row;
+    });
+    return { rows };
+}
+// implements REQ-kibi-operation-interface-parity, REQ-002, REQ-013
+async function executeSparqlRemote(input, context) {
+    const endpoint = validateInput(input);
+    if (context.net === undefined) {
+        throw new Error("SPARQL remote query requires a network port");
+    }
+    const signal = input.timeoutMs === undefined
+        ? context.signal
+        : AbortSignal.any([
+            context.signal,
+            AbortSignal.timeout(Math.max(1, Math.ceil(input.timeoutMs / 1_000)) * 1_000),
+        ]);
+    try {
+        const response = await context.net.fetch(endpoint, {
+            method: "POST",
+            headers: {
+                accept: "application/sparql-results+json",
+                "content-type": "application/x-www-form-urlencoded;charset=UTF-8",
+            },
+            body: new URLSearchParams({ query: input.query }),
+            signal,
+        });
+        if (!response.ok) {
+            throw new Error(`SPARQL endpoint returned HTTP ${response.status}`);
+        }
+        const payload = await response.json();
+        const structuredContent = decodeRows(payload);
+        const rowCount = structuredContent.rows.length;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Remote SPARQL query returned ${rowCount} row${rowCount === 1 ? "" : "s"}.`,
+                },
+            ],
+            structuredContent,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`SPARQL remote query failed: ${message}`);
+    }
+}
+export const sparqlRemoteSpec = {
+    name: "kb_sparql_remote",
+    cliName: "sparql-remote",
+    description: "Opt-in remote SPARQL query tool for external HTTP(S) RDF endpoints. This does not query Kibi's local RDF store directly, stores no credentials, and depends on network availability.",
+    businessInputSchema: {
+        type: "object",
+        required: ["endpoint", "query"],
+        properties: {
+            endpoint: {
+                type: "string",
+                description: "Remote SPARQL endpoint URL. Must start with http:// or https://.",
+            },
+            query: {
+                type: "string",
+                description: "SPARQL SELECT query to send to the remote endpoint.",
+            },
+            timeoutMs: {
+                type: "number",
+                description: "Optional positive timeout in milliseconds for the remote query.",
+            },
+        },
+    },
+    requiresProlog: false,
+    effects: ["network-read"],
+    execute: executeSparqlRemote,
+};

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

@@ -0,0 +1,291 @@
+import { executeUpsert } from "../../../operations/mutation/upsert.js";
+export declare const upsertSpec: {
+    readonly name: "kb_upsert";
+    readonly cliName: "upsert";
+    readonly description: "Create or update one entity and optional relationships. Use for KB mutations after validating intent; prefer kb_validate_upsert first because it returns semantic advisor receipts for prose-heavy requirements. Use kb_model_requirement before hand-writing strict property facts from prose, and kb_suggest_predicates before hand-writing ontology predicate facts. Use the `relationships` array for batch creation of multiple links in a single call (e.g., linking a requirement to multiple tests or facts). Prefer modeling requirements as reusable fact links (`constrains`, `requires_property`, or `requires_predicate`) so consistency and contradiction checks remain queryable. Relationship endpoints must already exist in KB. For requirements, the write will be rejected if it contradicts existing current requirements that constrain the same subject with incompatible properties. To replace a conflicting requirement, include a `supersedes` relationship from the new requirement to the old one in the same request. Successful writes may return non-blocking semantic advisor warnings; inspect and repair those warnings before treating prose as contradiction-checkable. Do not use for read-only inspection. Side effects: writes KB, may refresh symbol coordinates.";
+    readonly businessInputSchema: {
+        readonly type: "object";
+        readonly required: readonly ["type", "id", "properties"];
+        readonly properties: {
+            readonly type: {
+                readonly type: "string";
+                readonly enum: readonly ["req", "scenario", "test", "adr", "flag", "event", "symbol", "fact"];
+                readonly description: "Entity type to create/update. Allowed: req, scenario, test, adr, flag, event, symbol, fact. Example: 'req'.";
+            };
+            readonly id: {
+                readonly type: "string";
+                readonly description: "Unique entity ID (string). Example: 'REQ-123'. Existing ID updates the entity; new ID creates it.";
+            };
+            readonly properties: {
+                readonly type: "object";
+                readonly description: "Entity fields to persist. Must include title and status. If created_at, updated_at, or source are omitted, server fills defaults.";
+                readonly properties: {
+                    readonly title: {
+                        readonly type: "string";
+                        readonly description: "Required short title. Example: 'Protect account settings endpoint'.";
+                    };
+                    readonly status: {
+                        readonly type: "string";
+                        readonly description: "Required lifecycle state. Allowed values depend on entity type; backward-compatible legacy statuses are also accepted. Examples: 'open', 'passing', 'accepted', 'active'.";
+                    };
+                    readonly source: {
+                        readonly type: "string";
+                        readonly description: "Optional provenance string. Example: 'docs/requirements/REQ-123.md'. Defaults to 'mcp://kibi/upsert'.";
+                    };
+                    readonly tags: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional categorization tags. Example: ['security','api'].";
+                    };
+                    readonly owner: {
+                        readonly type: "string";
+                        readonly description: "Optional owner name/team. Example: 'platform-team'.";
+                    };
+                    readonly priority: {
+                        readonly type: "string";
+                        readonly description: "Optional priority label. Example: 'high'.";
+                    };
+                    readonly severity: {
+                        readonly type: "string";
+                        readonly description: "Optional severity label. Example: 'critical'.";
+                    };
+                    readonly links: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional references. Example: ['REQ-010','https://example.com/spec'].";
+                    };
+                    readonly text_ref: {
+                        readonly type: "string";
+                        readonly description: "Optional text anchor/reference. Example: 'requirements.md#L40'.";
+                    };
+                    readonly logic_claims: {
+                        readonly type: "array";
+                        readonly minItems: 1;
+                        readonly uniqueItems: true;
+                        readonly items: {
+                            readonly type: "string";
+                            readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                        };
+                        readonly description: "Requirement-only manifest of every atomic normative claim key returned by kb_semantic_advisor. A requirement is logic-complete only when every key is grounded by a linked property_value or predicate fact with the same claim_key.";
+                    };
+                    readonly sourceFile: {
+                        readonly type: "string";
+                        readonly description: "Optional code source file for symbol entities. Example: 'src/auth/login.ts'.";
+                    };
+                    readonly granularity_reason: {
+                        readonly type: "string";
+                        readonly enum: readonly ["config-artifact", "module-level-behavior", "extractor-miss", "legacy-link"];
+                        readonly description: "Optional justification for a coarse file/module-level symbol traceability relationship when narrower function/class/type symbols exist.";
+                    };
+                    readonly symbol_role: {
+                        readonly type: "string";
+                        readonly enum: readonly ["behavioral", "structural", "type-shape", "config", "module", "unknown"];
+                        readonly description: "Optional role classification for symbol entities. Example: 'behavioral'.";
+                    };
+                    readonly verification_scope: {
+                        readonly type: "string";
+                        readonly enum: readonly ["unit", "integration", "end_to_end"];
+                        readonly description: "Optional typed verification scope for test entities. Example: 'end_to_end'.";
+                    };
+                    readonly verification_perspective: {
+                        readonly type: "string";
+                        readonly enum: readonly ["internal", "consumer"];
+                        readonly description: "Optional typed verification perspective for test entities. Example: 'consumer'.";
+                    };
+                    readonly fact_kind: {
+                        readonly type: "string";
+                        readonly enum: readonly ["subject", "property_value", "observation", "meta", "predicate_schema", "predicate", "rule_schema", "rule"];
+                        readonly description: "Optional fact lane kind for fact entities. Strict lane uses 'subject' and 'property_value'; context lane uses 'observation' or 'meta'; ontology lane uses 'predicate_schema' or 'predicate'. Use kb_model_requirement or kb_suggest_predicates when starting from prose.";
+                    };
+                    readonly subject_key: {
+                        readonly type: "string";
+                        readonly description: "Snake_case only. Optional canonical subject key for strict fact entities. Example: 'user.session'. Do not use subjectKey in kb_upsert.properties.";
+                    };
+                    readonly property_key: {
+                        readonly type: "string";
+                        readonly description: "Snake_case only. Optional canonical property key for property_value facts. Example: 'session.timeout_minutes'. Do not use propertyKey in kb_upsert.properties.";
+                    };
+                    readonly operator: {
+                        readonly type: "string";
+                        readonly enum: readonly ["eq", "neq", "lt", "lte", "gt", "gte"];
+                        readonly description: "Optional comparison operator for property_value facts. Example: 'eq'.";
+                    };
+                    readonly value_type: {
+                        readonly type: "string";
+                        readonly enum: readonly ["string", "int", "number", "bool"];
+                        readonly description: "Optional typed value discriminator for property_value facts. Pair with exactly one value_string, value_int, value_number, or value_bool; do not use generic value.";
+                    };
+                    readonly value_string: {
+                        readonly type: "string";
+                        readonly description: "Optional string value for property_value facts.";
+                    };
+                    readonly value_int: {
+                        readonly type: "integer";
+                        readonly description: "Optional integer value for property_value facts.";
+                    };
+                    readonly value_number: {
+                        readonly type: "number";
+                        readonly description: "Optional number value for property_value facts.";
+                    };
+                    readonly value_bool: {
+                        readonly type: "boolean";
+                        readonly description: "Optional boolean value for property_value facts.";
+                    };
+                    readonly unit: {
+                        readonly type: "string";
+                        readonly description: "Optional unit for numeric property_value facts.";
+                    };
+                    readonly scope: {
+                        readonly type: "string";
+                        readonly description: "Optional scope qualifier for fact entities.";
+                    };
+                    readonly polarity: {
+                        readonly type: "string";
+                        readonly enum: readonly ["require", "forbid", "assert", "deny"];
+                        readonly description: "Optional polarity for property_value or predicate facts.";
+                    };
+                    readonly closed_world: {
+                        readonly type: "boolean";
+                        readonly description: "Optional closed-world marker for strict fact interpretation.";
+                    };
+                    readonly canonical_key: {
+                        readonly type: "string";
+                        readonly description: "Optional canonical identity key for predicate or strict fact claims.";
+                    };
+                    readonly claim_key: {
+                        readonly type: "string";
+                        readonly pattern: "^CLAIM-[A-F0-9]{16}$";
+                        readonly description: "Stable semantic-advisor key for the atomic prose clause grounded by this fact.";
+                    };
+                    readonly claim_text: {
+                        readonly type: "string";
+                        readonly description: "Exact atomic requirement clause represented by this fact, retained for human audit.";
+                    };
+                    readonly predicate_name: {
+                        readonly type: "string";
+                        readonly description: "Optional predicate name for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_name.";
+                    };
+                    readonly predicate_args: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional ordered predicate arguments for ontology predicate facts. Prefer kb_suggest_predicates before hand-writing predicate_args.";
+                    };
+                    readonly predicate_namespace: {
+                        readonly type: "string";
+                        readonly description: "Optional namespace for a project-local predicate schema.";
+                    };
+                    readonly predicate_arity: {
+                        readonly type: "integer";
+                        readonly minimum: 1;
+                        readonly description: "Required arity for predicate_schema facts.";
+                    };
+                    readonly argument_names: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Ordered argument role names for predicate_schema facts.";
+                    };
+                    readonly argument_types: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Ordered argument types for predicate_schema facts.";
+                    };
+                    readonly argument_descriptions: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional ordered argument explanations.";
+                    };
+                    readonly aliases: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional vocabulary aliases for predicate discovery.";
+                    };
+                    readonly examples: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "string";
+                        };
+                        readonly description: "Optional ground-term examples for a predicate schema.";
+                    };
+                    readonly semantic_inventory: {
+                        readonly type: "array";
+                        readonly description: "Requirement proposition ledger returned by kb_semantic_advisor; preserve entries while modeling each assertive span.";
+                        readonly items: {
+                            readonly type: "object";
+                        };
+                    };
+                    readonly rule_ir: {
+                        readonly type: "object";
+                        readonly description: "Schema-validated kibi.logic.v1 rule IR. It is persisted as data and never executed as caller-supplied Prolog.";
+                    };
+                    readonly rule_hash: {
+                        readonly type: "string";
+                        readonly description: "Deterministic hash of canonical rule_ir.";
+                    };
+                    readonly rule_schema_id: {
+                        readonly type: "string";
+                        readonly description: "Rule schema fact ID used to validate this rule.";
+                    };
+                    readonly rule_name: {
+                        readonly type: "string";
+                        readonly description: "Stable rule schema name.";
+                    };
+                    readonly semantic_key: {
+                        readonly type: "string";
+                        readonly description: "Canonical semantic identity of the normalized logical model.";
+                    };
+                    readonly claim_span_start: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                    readonly claim_span_end: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                };
+                readonly allOf: readonly [Record<string, unknown>];
+                readonly required: readonly ["title", "status"];
+            };
+            readonly relationships: {
+                readonly type: "array";
+                readonly description: "Optional relationship rows to create in the same call. For requirement encoding, prefer `constrains` + `requires_property` for strict property facts or `requires_predicate` for ontology predicate facts. Side effect: asserts edges in KB.";
+                readonly items: {
+                    readonly type: "object";
+                    readonly required: readonly ["type", "from", "to"];
+                    readonly properties: {
+                        readonly type: {
+                            readonly type: "string";
+                            readonly enum: readonly ["depends_on", "specified_by", "verified_by", "validates", "implements", "covered_by", "executable_for", "constrained_by", "constrains", "requires_property", "requires_predicate", "requires_rule", "guards", "publishes", "consumes", "supersedes", "relates_to"];
+                            readonly description: "Relationship type enum. Use only supported values. Direction semantics follow KB model (e.g., implements symbol->req, verified_by req/scenario->test, executable_for symbol->test).";
+                        };
+                        readonly from: {
+                            readonly type: "string";
+                            readonly description: "Source entity ID (must exist). Example: 'SYM-login-handler'.";
+                        };
+                        readonly to: {
+                            readonly type: "string";
+                            readonly description: "Target entity ID (must exist). Example: 'REQ-001'.";
+                        };
+                    };
+                };
+            };
+        };
+    };
+    readonly requiresProlog: true;
+    readonly effects: readonly ["kb-write", "workspace-write"];
+    readonly execute: typeof executeUpsert;
+};
+//# sourceMappingURL=upsert.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"upsert.d.ts","sourceRoot":"","sources":["../../../../src/public/operations/specs/upsert.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,aAAa,EAAE,MAAM,wCAAwC,CAAC;AAQvE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BuC,CAAC"}

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

@@ -0,0 +1,27 @@
+import { executeUpsert } from "../../../operations/mutation/upsert.js";
+import { ENTITY_PROPERTIES_SCHEMA, ENTITY_TYPES, RELATIONSHIPS_SCHEMA, } from "./mutation-schemas.js";
+export const upsertSpec = {
+    name: "kb_upsert",
+    cliName: "upsert",
+    description: "Create or update one entity and optional relationships. Use for KB mutations after validating intent; prefer kb_validate_upsert first because it returns semantic advisor receipts for prose-heavy requirements. Use kb_model_requirement before hand-writing strict property facts from prose, and kb_suggest_predicates before hand-writing ontology predicate facts. Use the `relationships` array for batch creation of multiple links in a single call (e.g., linking a requirement to multiple tests or facts). Prefer modeling requirements as reusable fact links (`constrains`, `requires_property`, or `requires_predicate`) so consistency and contradiction checks remain queryable. Relationship endpoints must already exist in KB. For requirements, the write will be rejected if it contradicts existing current requirements that constrain the same subject with incompatible properties. To replace a conflicting requirement, include a `supersedes` relationship from the new requirement to the old one in the same request. Successful writes may return non-blocking semantic advisor warnings; inspect and repair those warnings before treating prose as contradiction-checkable. Do not use for read-only inspection. Side effects: writes KB, may refresh symbol coordinates.",
+    businessInputSchema: {
+        type: "object",
+        required: ["type", "id", "properties"],
+        properties: {
+            type: {
+                type: "string",
+                enum: ENTITY_TYPES,
+                description: "Entity type to create/update. Allowed: req, scenario, test, adr, flag, event, symbol, fact. Example: 'req'.",
+            },
+            id: {
+                type: "string",
+                description: "Unique entity ID (string). Example: 'REQ-123'. Existing ID updates the entity; new ID creates it.",
+            },
+            properties: ENTITY_PROPERTIES_SCHEMA,
+            relationships: RELATIONSHIPS_SCHEMA,
+        },
+    },
+    requiresProlog: true,
+    effects: ["kb-write", "workspace-write"],
+    execute: executeUpsert,
+};

package/dist/public/operations/types.d.ts

@@ -0,0 +1,24 @@
+import type { OperationContext } from "./runtime-types.js";
+export type { OperationContext };
+export type OperationName = "kb_query" | "kb_search" | "kb_status" | "kb_skills_list" | "kb_skills_load" | "kb_skills_read" | "kb_find_gaps" | "kb_coverage" | "kb_graph" | "kb_sparql_remote" | "kb_semantic_advisor" | "kb_upsert" | "kb_validate_upsert" | "kb_delete" | "kb_check" | "kb_model_requirement" | "kb_suggest_predicates" | "kb_autopilot_generate";
+export type OperationEffect = "local-read" | "kb-read" | "workspace-read" | "network-read" | "kb-write" | "workspace-write";
+export interface OperationContent {
+    readonly type: string;
+    readonly text?: string;
+}
+export interface OperationResult<O = unknown> {
+    readonly content: readonly OperationContent[];
+    readonly structuredContent?: O;
+}
+export interface OperationSpec<I = Readonly<Record<string, unknown>>, O = unknown> {
+    readonly name: OperationName;
+    readonly cliName: string;
+    readonly description: string;
+    readonly businessInputSchema: Readonly<Record<string, unknown>>;
+    readonly requiresProlog: boolean;
+    readonly effects: readonly OperationEffect[];
+    readonly execute: {
+        bivarianceHack(input: I, context: OperationContext): Promise<OperationResult<O>>;
+    }["bivarianceHack"];
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/public/operations/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC3D,YAAY,EAAE,gBAAgB,EAAE,CAAC;AACjC,MAAM,MAAM,aAAa,GACrB,UAAU,GACV,WAAW,GACX,WAAW,GACX,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,cAAc,GACd,aAAa,GACb,UAAU,GACV,kBAAkB,GAClB,qBAAqB,GACrB,WAAW,GACX,oBAAoB,GACpB,WAAW,GACX,UAAU,GACV,sBAAsB,GACtB,uBAAuB,GACvB,uBAAuB,CAAC;AAE5B,MAAM,MAAM,eAAe,GACvB,YAAY,GACZ,SAAS,GACT,gBAAgB,GAChB,cAAc,GACd,UAAU,GACV,iBAAiB,CAAC;AAEtB,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC1C,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;IAC9C,QAAQ,CAAC,iBAAiB,CAAC,EAAE,CAAC,CAAC;CAChC;AAED,MAAM,WAAW,aAAa,CAC5B,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACrC,CAAC,GAAG,OAAO;IAEX,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAChE,QAAQ,CAAC,cAAc,EAAE,OAAO,CAAC;IACjC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,QAAQ,CAAC,OAAO,EAAE;QAChB,cAAc,CACZ,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;KAChC,CAAC,gBAAgB,CAAC,CAAC;CACrB"}

package/dist/public/operations/types.js

@@ -0,0 +1 @@
+export {};

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