kibi-mcp 0.17.5 → 0.19.2

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`,
-                },
-            ],
-            structuredContent: payload,
-        };
+        return await skillsLoadSpec.execute(args, runtimeContext());
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -50,26 +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}`);
+        throw new Error(`Skills read failed: ${message}${resourceListHint(args.id)}`);
     }
 }
-function assertNonEmptyString(value, field) {
-    if (typeof value !== "string" || value.trim() === "") {
-        throw new Error(`${field} must be a non-empty string`);
+function resourceListHint(id) {
+    if (typeof id !== "string" || id.trim() === "") {
+        return "";
+    }
+    try {
+        const bundle = loadBundledSkill(id);
+        const resources = bundle.manifest.resources ?? [];
+        const resourceList = resources.length === 0 ? "none" : resources.join(", ");
+        return `. Declared resources: ${resourceList}`;
+    }
+    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));
 }