kibi-mcp 0.19.0 → 0.19.2

package/dist/tools/semantic-advisor.js

@@ -1,42 +1,4 @@
-import { analyzeSemanticAdvisorInput } from "../semantic-advisor/analyze-prose.js";
-function normalizeText(value) {
-    const text = typeof value === "string" ? value.trim() : "";
-    if (!text) {
-        throw new Error("Semantic advisor failed: text must be a non-empty string");
-    }
-    return text;
-}
-function optionalString(value) {
-    const text = typeof value === "string" ? value.trim() : "";
-    return text.length > 0 ? text : undefined;
-}
+import { executeSemanticAdvisor } from "kibi-cli/operations";
 export async function handleKbSemanticAdvisor(args) {
-    const text = normalizeText(args.text);
-    const id = optionalString(args.id) ?? "REQ-SEMANTIC-ADVISOR-PREVIEW";
-    const title = optionalString(args.title) ?? text.split(/[.!?]/, 1)[0] ?? text;
-    const source = optionalString(args.source) ?? "mcp://kibi/semantic-advisor";
-    const result = analyzeSemanticAdvisorInput({
-        payload: {
-            type: optionalString(args.type) ?? "req",
-            id,
-            properties: {
-                title,
-                status: optionalString(args.status) ?? "open",
-                source,
-                text_ref: text,
-            },
-        },
-    });
-    return {
-        content: [
-            {
-                type: "text",
-                text: `kb_semantic_advisor: ${result.receipt.summary} Suggestions: ${result.receipt.suggestions.map((suggestion) => suggestion.kind).join(", ") || "none"}.`,
-            },
-        ],
-        structuredContent: {
-            receipt: result.receipt,
-            warnings: result.warnings,
-        },
-    };
+    return executeSemanticAdvisor(args);
 }

package/dist/tools/skills.js

@@ -1,16 +1,16 @@
-import { createHash } from "node:crypto";
-import { listBundledSkills, loadBundledSkill, readBundledSkillResource, } from "kibi-cli/skills";
+import { skillsListSpec, skillsLoadSpec, skillsReadSpec, } from "kibi-cli/operations";
+import { loadBundledSkill } from "kibi-cli/skills";
+function runtimeContext() {
+    return {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+    };
+}
 // implements REQ-001
 export async function handleKbSkillsList(_args) {
     try {
-        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 },
-        };
+        return await skillsListSpec.execute({}, runtimeContext());
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -20,27 +20,7 @@ export async function handleKbSkillsList(_args) {
 // implements REQ-001
 export async function handleKbSkillsLoad(args) {
     try {
-        assertNonEmptyString(args.id, "id");
-        const bundle = loadBundledSkill(args.id);
-        const resources = bundle.manifest.resources ?? [];
-        const payload = {
-            metadata: bundle.manifest,
-            body: bundle.body,
-            resources,
-            contentHash: createHash("sha256")
-                .update(bundle.body, "utf8")
-                .digest("hex"),
-            sourceType: "bundled",
-        };
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Loaded bundled skill ${bundle.manifest.id} with ${resources.length} resources: ${formatResourceList(resources)}`,
-                },
-            ],
-            structuredContent: payload,
-        };
+        return await skillsLoadSpec.execute(args, runtimeContext());
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -50,44 +30,24 @@ export async function handleKbSkillsLoad(args) {
 // implements REQ-001
 export async function handleKbSkillsRead(args) {
     try {
-        assertNonEmptyString(args.id, "id");
-        assertNonEmptyString(args.resource, "resource");
-        const resourceContent = readBundledSkillResource(args.id, args.resource);
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Read bundled skill resource ${args.id}/${args.resource}`,
-                },
-            ],
-            structuredContent: { content: resourceContent },
-        };
+        return await skillsReadSpec.execute(args, runtimeContext());
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         throw new Error(`Skills read failed: ${message}${resourceListHint(args.id)}`);
     }
 }
-function formatResourceList(resources) {
-    return resources.length === 0 ? "none" : resources.join(", ");
-}
 function resourceListHint(id) {
     if (typeof id !== "string" || id.trim() === "") {
         return "";
     }
     try {
         const bundle = loadBundledSkill(id);
-        return `. Declared resources: ${formatResourceList(bundle.manifest.resources ?? [])}`;
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            return "";
-        }
-        throw error;
+        const resources = bundle.manifest.resources ?? [];
+        const resourceList = resources.length === 0 ? "none" : resources.join(", ");
+        return `. Declared resources: ${resourceList}`;
     }
-}
-function assertNonEmptyString(value, field) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`${field} must be a non-empty string`);
+    catch {
+        return "";
     }
 }

package/dist/tools/sparql.js

@@ -1,96 +1,15 @@
-import { runJsonModuleQuery, toPrologAtom } from "./core-module.js";
-// implements REQ-002, REQ-013
-export async function handleSparql(prolog, args) {
-    validateSparqlArgs(args);
-    try {
-        const payload = await runJsonModuleQuery(prolog, "sparql_client.pl", `kibi_sparql_client:remote_sparql_select_json(${toPrologAtom(args.endpoint)}, ${toPrologAtom(args.query)}, ${toSparqlOptions(args)}, JsonString)`, "SPARQL remote query");
-        const rows = payload?.rows ?? [];
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Remote SPARQL query returned ${rows.length} row${rows.length === 1 ? "" : "s"}.`,
-                },
-            ],
-            ...(payload !== undefined ? { structuredContent: payload } : {}),
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`SPARQL remote query failed: ${message}`);
-    }
-}
-function validateSparqlArgs(args) {
-    if (!args.endpoint || args.endpoint.trim().length === 0) {
+import { sparqlRemoteSpec } from "kibi-cli/operations";
+// implements REQ-002, REQ-013, REQ-kibi-operation-interface-parity
+export async function handleSparql(prologOrArgs, legacyArgs) {
+    const args = legacyArgs ?? ("endpoint" in prologOrArgs ? prologOrArgs : undefined);
+    if (args === undefined) {
         throw new Error("SPARQL endpoint is required");
     }
-    if (!args.query || args.query.trim().length === 0) {
-        throw new Error("SPARQL query is required");
-    }
-    if (!isRemoteHttpEndpoint(args.endpoint)) {
-        throw new Error("SPARQL endpoint must be an http:// or https:// URL");
-    }
-    if (!isSelectQuery(args.query)) {
-        throw new Error("SPARQL query must be a SELECT query");
-    }
-    if (!isPublicRemoteEndpoint(args.endpoint)) {
-        throw new Error("SPARQL endpoint must target a public remote host");
-    }
-    if (args.timeoutMs !== undefined &&
-        (!Number.isFinite(args.timeoutMs) || args.timeoutMs <= 0)) {
-        throw new Error("SPARQL timeoutMs must be a positive number when provided");
-    }
-}
-function isRemoteHttpEndpoint(endpoint) {
-    try {
-        const url = new URL(endpoint);
-        return url.protocol === "http:" || url.protocol === "https:";
-    }
-    catch {
-        return false;
-    }
-}
-function isSelectQuery(query) {
-    return /^\s*select\b/i.test(query);
-}
-function isPublicRemoteEndpoint(endpoint) {
-    const url = new URL(endpoint);
-    const host = normalizeHostname(url.hostname);
-    return !isLocalOrPrivateHost(host);
-}
-function normalizeHostname(hostname) {
-    return hostname
-        .toLowerCase()
-        .replace(/^\[/, "")
-        .replace(/\]$/, "")
-        .replace(/\.$/, "");
-}
-function isLocalOrPrivateHost(host) {
-    if (host === "localhost" ||
-        host.endsWith(".localhost") ||
-        host === "0.0.0.0" ||
-        host === "::1" ||
-        (host.includes(":") &&
-            (host.startsWith("fe80:") ||
-                host.startsWith("fc") ||
-                host.startsWith("fd")))) {
-        return true;
-    }
-    const octets = host.split(".").map((part) => Number(part));
-    if (octets.length !== 4 || octets.some((octet) => !Number.isInteger(octet))) {
-        return false;
-    }
-    const [first = -1, second = -1] = octets;
-    return (first === 10 ||
-        first === 127 ||
-        (first === 169 && second === 254) ||
-        (first === 172 && second >= 16 && second <= 31) ||
-        (first === 192 && second === 168));
-}
-function toSparqlOptions(args) {
-    if (args.timeoutMs === undefined) {
-        return "[]";
-    }
-    const timeoutSeconds = Math.max(1, Math.ceil(args.timeoutMs / 1000));
-    return `[timeout(${timeoutSeconds})]`;
+    const context = {
+        workspaceRoot: process.cwd(),
+        signal: new AbortController().signal,
+        clock: () => new Date(),
+        net: { fetch: (input, init) => globalThis.fetch(input, init) },
+    };
+    return sparqlRemoteSpec.execute(args, context);
 }

package/dist/tools/status.js

@@ -1,20 +1,6 @@
-import { runJsonModuleQuery } from "./core-module.js";
-// implements REQ-002, REQ-013
-export async function handleKbStatus(prolog, _args) {
-    try {
-        const payload = await runJsonModuleQuery(prolog, "status.pl", "status:kb_status_json(JsonString)", "Status execution");
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: `Branch ${payload.branch} is ${payload.syncState} (snapshot ${payload.snapshotId}, dirty=${payload.dirty})`,
-                },
-            ],
-            structuredContent: payload,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Status execution failed: ${message}`);
-    }
+import { statusSpec } from "kibi-cli/operations";
+import { createDiscoveryContext } from "./discovery-adapter.js";
+export async function handleKbStatus(prolog, args) {
+    // implements REQ-kibi-operation-interface-parity
+    return statusSpec.execute(args, createDiscoveryContext(prolog));
 }