@vodailoc/kilo-kit-mcp 1.1.1 → 1.3.0

package/mcp/dist/server.js

@@ -1,27 +1,106 @@
 #!/usr/bin/env node
 import { readFile } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
-import { formatLoadedSkill, formatRoute, formatSkills, formatValidation, textResponse, } from "./formatters.js";
+import { formatLoadedSkill, formatMemoryReport, formatOrchestration, formatRoute, formatRouteReport, formatSkills, formatValidation, textResponse, } from "./formatters.js";
+import { createJsonlOrchestrationAudit, createNoopOrchestrationAudit } from "./orchestration-audit.js";
+import { createSqliteOrchestrationMemory } from "./orchestration-memory.js";
+import { createOrchestrator } from "./orchestrator.js";
 import { resolveInsideRepo } from "./paths.js";
+import { createInMemoryRouteAnalytics, createJsonlRouteAnalytics } from "./route-analytics.js";
 import { createSkillRegistry } from "./registry.js";
 import { routeIntent } from "./router.js";
 import { validateSkills } from "./validator.js";
-const SERVER_VERSION = "1.1.1";
+const SERVER_VERSION = "1.3.0";
 const DEFAULT_REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const formatSchema = z.enum(["markdown", "json"]).default("markdown");
 export async function createKiloKitServer(options = {}) {
     const repoRoot = path.resolve(options.repoRoot ?? process.env.KILO_KIT_REPO_ROOT ?? DEFAULT_REPO_ROOT);
     const registry = await createSkillRegistry({ repoRoot });
+    const routeAnalytics = process.env.KILO_KIT_WRITE_DECISIONS === "true"
+        ? createJsonlRouteAnalytics({
+            filePath: process.env.KILO_KIT_DECISION_TRAIL_PATH
+                ? path.resolve(process.env.KILO_KIT_DECISION_TRAIL_PATH)
+                : resolveInsideRepo(repoRoot, ".kilo/decision-trail.jsonl"),
+        })
+        : createInMemoryRouteAnalytics();
+    const orchestrationMemory = await createSqliteOrchestrationMemory({
+        filePath: path.resolve(process.env.KILO_KIT_MEMORY_PATH ?? path.join(os.homedir(), ".kilo-kit/orchestrator.sqlite")),
+    });
+    const orchestrationAudit = process.env.KILO_KIT_ORCHESTRATION_AUDIT_PATH
+        ? createJsonlOrchestrationAudit(path.resolve(process.env.KILO_KIT_ORCHESTRATION_AUDIT_PATH))
+        : createNoopOrchestrationAudit();
+    const orchestrator = createOrchestrator({
+        registry,
+        memory: orchestrationMemory,
+        audit: orchestrationAudit,
+    });
     const server = new McpServer({
         name: "kilo-kit",
         version: SERVER_VERSION,
     }, {
-        instructions: "Use kilo_route_intent before selecting a Kilo-Kit workflow skill. Load one selected skill with kilo_get_skill, then follow its instructions. All tools are read-only.",
+        instructions: "Use kilo_route_intent before selecting a Kilo-Kit workflow skill. Load one selected skill with kilo_get_skill, then follow its instructions. Route telemetry is in-memory by default and only persists when KILO_KIT_WRITE_DECISIONS=true.",
     });
+    server.registerTool("kilo_orchestrate_task", {
+        title: "Kilo-Kit C4 Orchestrate Task",
+        description: "Central C4 orchestration gate. Routes internally, requires the real /brainstorming skill before substantive work, checks memory suggestions, and releases the post-brainstorming workflow after approval.",
+        inputSchema: {
+            message: z.string().min(1).max(4000).describe("Current user request or task summary."),
+            context: z
+                .object({
+                files: z.array(z.string().max(300)).max(30).optional(),
+                mode: z.string().max(80).optional(),
+                previousErrors: z.string().max(2000).optional(),
+                projectFingerprint: z.string().max(200).optional(),
+            })
+                .optional(),
+            sessionId: z.string().min(1).max(120).optional(),
+            brainstormingApproved: z.boolean().optional(),
+            answers: z.record(z.string().max(2000)).optional(),
+            memoryConfirmations: z.record(z.enum(["accepted", "rejected"])).optional(),
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: false,
+        },
+    }, async ({ message, context, sessionId, brainstormingApproved, answers, memoryConfirmations, format }) => {
+        const result = orchestrator.orchestrate({
+            message,
+            ...(context
+                ? {
+                    context: {
+                        ...(context.files ? { files: context.files } : {}),
+                        ...(context.mode ? { mode: context.mode } : {}),
+                        ...(context.previousErrors ? { previousErrors: context.previousErrors } : {}),
+                        ...(context.projectFingerprint ? { projectFingerprint: context.projectFingerprint } : {}),
+                    },
+                }
+                : {}),
+            ...(sessionId ? { sessionId } : {}),
+            ...(brainstormingApproved !== undefined ? { brainstormingApproved } : {}),
+            ...(answers ? { answers } : {}),
+            ...(memoryConfirmations ? { memoryConfirmations } : {}),
+        });
+        return textResponse(formatOrchestration(result, normalizeFormat(format)));
+    });
+    server.registerTool("kilo_memory_report", {
+        title: "Kilo-Kit C4 Memory Report",
+        description: "Read global C4 memory facts, decisions, and recent suggestions.",
+        inputSchema: {
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ format }) => textResponse(formatMemoryReport(orchestrationMemory.report(), normalizeFormat(format))));
     server.registerTool("kilo_search_skills", {
         title: "Search Kilo-Kit Skills",
         description: "Search the Kilo-Kit skill library by natural-language query. Use this for broad discovery before loading a specific skill.",
@@ -99,9 +178,21 @@ export async function createKiloKitServer(options = {}) {
             message,
             ...(routeContext ? { context: routeContext } : {}),
             ...(limit ? { limit } : {}),
-        });
+        }, { analytics: routeAnalytics });
         return textResponse(formatRoute(result, normalizeFormat(format)));
     });
+    server.registerTool("kilo_route_report", {
+        title: "Kilo-Kit Route Report",
+        description: "Summarize route telemetry: top skills, task modes, workflow chains, score averages, and conflict penalties.",
+        inputSchema: {
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ format }) => textResponse(formatRouteReport(routeAnalytics.report(), normalizeFormat(format))));
     server.registerTool("kilo_validate_skills", {
         title: "Validate Kilo-Kit Skills",
         description: "Run the Kilo-Kit skill validator and return a concise quality-gate summary. This is read-only and does not modify files.",

package/mcp/dist/smoke-env.js

@@ -0,0 +1,18 @@
+import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
+const FORWARDED_ENV_VARS = [
+    "KILO_KIT_WRITE_DECISIONS",
+    "KILO_KIT_DECISION_TRAIL_PATH",
+    "KILO_KIT_REPO_ROOT",
+    "KILO_KIT_MEMORY_PATH",
+    "KILO_KIT_ORCHESTRATION_AUDIT_PATH",
+];
+export function buildSmokeEnvironment(sourceEnv = process.env, baseEnv = getDefaultEnvironment()) {
+    const env = { ...baseEnv };
+    for (const name of FORWARDED_ENV_VARS) {
+        const value = sourceEnv[name];
+        if (value !== undefined) {
+            env[name] = value;
+        }
+    }
+    return env;
+}

package/mcp/dist/smoke.js

@@ -1,15 +1,24 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { buildSmokeEnvironment } from "./smoke-env.js";
 const transport = new StdioClientTransport({
     command: process.env.KILO_KIT_SMOKE_COMMAND ?? process.execPath,
     args: parseSmokeArgs(),
+    env: buildSmokeEnvironment(),
 });
 const client = new Client({ name: "kilo-kit-smoke", version: "1.0.0" });
 try {
     await client.connect(transport);
     const tools = await client.listTools();
     const toolNames = tools.tools.map((tool) => tool.name);
-    for (const required of ["kilo_route_intent", "kilo_get_skill", "kilo_validate_skills"]) {
+    for (const required of [
+        "kilo_route_intent",
+        "kilo_get_skill",
+        "kilo_validate_skills",
+        "kilo_route_report",
+        "kilo_orchestrate_task",
+        "kilo_memory_report",
+    ]) {
         if (!toolNames.includes(required)) {
             throw new Error(`Missing expected tool: ${required}`);
         }
@@ -26,6 +35,61 @@ try {
     if (!routeText.includes("engineering/tdd")) {
         throw new Error(`Smoke route did not recommend engineering/tdd: ${routeText}`);
     }
+    const report = await client.callTool({
+        name: "kilo_route_report",
+        arguments: { format: "json" },
+    });
+    const reportText = extractFirstText(report);
+    if (!reportText.includes('"totalEvents": 1') || !reportText.includes("engineering/tdd")) {
+        throw new Error(`Smoke route report did not include the routed event: ${reportText}`);
+    }
+    const orchestration = await client.callTool({
+        name: "kilo_orchestrate_task",
+        arguments: {
+            message: "Fix bug login, viết test trước",
+            context: { files: ["src/auth/login.ts"], mode: "coding", projectFingerprint: "smoke:typescript" },
+            format: "json",
+        },
+    });
+    const orchestrationText = extractFirstText(orchestration);
+    const orchestrationResult = JSON.parse(orchestrationText);
+    if (orchestrationResult.state !== "brainstorming_required") {
+        throw new Error(`Smoke orchestration did not require brainstorming: ${orchestrationText}`);
+    }
+    if (orchestrationResult.workflow?.[0]?.skill?.id !== "productivity/brainstorming") {
+        throw new Error(`Smoke orchestration did not start with brainstorming: ${orchestrationText}`);
+    }
+    if (orchestrationResult.firstSkillToLoad?.id !== "productivity/brainstorming") {
+        throw new Error(`Smoke orchestration did not instruct loading brainstorming: ${orchestrationText}`);
+    }
+    if ((orchestrationResult.questions?.length ?? 0) !== 0 || (orchestrationResult.missingInfo?.length ?? 0) !== 0) {
+        throw new Error(`Smoke orchestration should not use C4 questions as a gate: ${orchestrationText}`);
+    }
+    const readyOrchestration = await client.callTool({
+        name: "kilo_orchestrate_task",
+        arguments: {
+            message: "Fix bug login, viết test trước",
+            sessionId: orchestrationResult.sessionId,
+            brainstormingApproved: true,
+            format: "json",
+        },
+    });
+    const readyText = extractFirstText(readyOrchestration);
+    const readyResult = JSON.parse(readyText);
+    if (readyResult.state !== "ready" || readyResult.firstSkillToLoad?.id !== "engineering/diagnose") {
+        throw new Error(`Smoke orchestration did not release post-brainstorming workflow after approval: ${readyText}`);
+    }
+    if (readyResult.finalWorkflow?.some((step) => step.skill?.id === "productivity/brainstorming")) {
+        throw new Error(`Smoke final workflow should not repeat brainstorming after approval: ${readyText}`);
+    }
+    const memoryReport = await client.callTool({
+        name: "kilo_memory_report",
+        arguments: { format: "json" },
+    });
+    const memoryReportText = extractFirstText(memoryReport);
+    if (!memoryReportText.includes('"facts"')) {
+        throw new Error(`Smoke memory report did not return memory facts: ${memoryReportText}`);
+    }
     const skill = await client.callTool({
         name: "kilo_get_skill",
         arguments: { category: "engineering", skill: "tdd", maxChars: 800 },

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kilo-kit/mcp",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Kilo-Kit MCP server for skill routing, skill loading, and validation.",
   "type": "module",
   "private": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vodailoc/kilo-kit-mcp",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Kilo-Kit MCP server for adaptive skill routing, skill loading, and validation.",
   "license": "Apache-2.0",
   "author": "Kilo-Kit Team",