@vodailoc/kilo-kit-mcp 1.1.1 → 1.2.0

package/mcp/dist/router.js

@@ -1,98 +1,91 @@
-export function routeIntent(registry, input) {
-    const query = buildQuery(input);
+import { analyzeIntent, explainRoute, RULE_HIERARCHY, scoreSkillForRoute, workflowForMode, } from "./routing-policy.js";
+export function routeIntent(registry, input, options = {}) {
+    const profile = analyzeIntent(input);
     const limit = Math.max(1, Math.min(input.limit ?? 5, 10));
-    const searchMatches = registry.searchSkills({ query, limit: 25 });
-    const candidateIds = new Set(searchMatches.map((skill) => skill.id));
-    const candidates = [
-        ...searchMatches,
-        ...registry.listSkills().filter((skill) => !candidateIds.has(skill.id)),
-    ];
-    const ranked = candidates
-        .map((skill) => ({
-        skill,
-        score: scoreRoute(skill, input),
-        reason: explainRoute(skill, input),
-    }))
+    const ranked = registry
+        .listSkills()
+        .map((skill) => applyAnalyticsAdjustment(scoreSkillForRoute(skill, input, profile), profile.mode, options.analytics))
         .filter((candidate) => candidate.score > 0)
-        .sort((left, right) => right.score - left.score || left.skill.id.localeCompare(right.skill.id))
-        .slice(0, limit);
-    const recommended = ranked.map((candidate, index) => ({
+        .sort((left, right) => right.score - left.score || left.skill.id.localeCompare(right.skill.id));
+    const recommended = ranked.slice(0, limit).map((candidate, index) => ({
         skill: candidate.skill,
-        confidence: Math.max(0.1, Math.min(0.99, candidate.score / (candidate.score + 20 + index * 3))),
+        confidence: Math.max(0.1, Math.min(0.99, candidate.score / (candidate.score + 18 + index * 3))),
         reason: candidate.reason,
+        score: candidate.score,
     }));
-    return {
+    const workflow = buildWorkflow(registry, profile.mode, ranked);
+    const decisionTrail = ranked.slice(0, 10).map((candidate) => ({
+        skillId: candidate.skill.id,
+        score: candidate.score,
+        matchedSignals: candidate.matchedSignals,
+        scoreBreakdown: candidate.scoreBreakdown,
+        reason: candidate.reason,
+    }));
+    const result = {
         recommended,
-        nextAction: recommended[0]
-            ? `Load ${recommended[0].skill.id} with kilo_get_skill before executing the workflow.`
-            : "No strong skill match found. Search with more specific task keywords or inspect skills/SKILLS_INDEX.md.",
+        taskMode: profile.mode,
+        workflow,
+        ruleHierarchy: RULE_HIERARCHY,
+        decisionTrail,
+        nextAction: buildNextAction(recommended, workflow),
     };
+    options.analytics?.record({
+        timestamp: new Date().toISOString(),
+        message: input.message,
+        taskMode: result.taskMode,
+        recommendedSkillIds: recommended.map((item) => item.skill.id),
+        workflowSkillIds: workflow.map((step) => step.skill.id),
+        decisionTrail,
+    });
+    return result;
 }
-function buildQuery(input) {
-    return [
-        input.message,
-        input.context?.mode,
-        input.context?.previousErrors,
-        ...(input.context?.files ?? []),
-    ]
-        .filter(Boolean)
-        .join(" ");
-}
-function scoreRoute(skill, input) {
-    const text = buildQuery(input).toLowerCase();
-    let score = 1;
-    if (text.includes("test") || text.includes("tdd") || text.includes("test trước")) {
-        if (skill.id === "engineering/tdd")
-            score += 50;
-        if (skill.id.includes("tdd"))
-            score += 25;
-        if (skill.id.includes("testing"))
-            score += 15;
-    }
-    if (text.includes("bug") || text.includes("fix") || text.includes("failing") || text.includes("error")) {
-        if (skill.id === "engineering/diagnose")
-            score += 35;
-        if (skill.id.includes("debug"))
-            score += 20;
-        if (skill.id === "kilo-kit/debugging/systematic")
-            score += 15;
-    }
-    if (text.includes("ui") || text.includes("dashboard") || text.includes("react") || text.includes("frontend")) {
-        if (skill.category === "design")
-            score += 35;
-        if (skill.id === "design/frontend-design")
-            score += 20;
+function applyAnalyticsAdjustment(candidate, taskMode, analytics) {
+    const adjustment = analytics?.scoreAdjustment(candidate.skill.id, taskMode) ?? 0;
+    if (adjustment <= 0) {
+        return candidate;
     }
-    if (text.includes("mcp")) {
-        if (skill.id === "operations/mcp-builder")
-            score += 40;
-        if (skill.id === "operations/mcp-management")
-            score += 20;
-    }
-    if (input.context?.files?.some((file) => file.endsWith(".tsx") || file.endsWith(".jsx"))) {
-        if (skill.category === "design")
-            score += 10;
-        if (skill.id === "engineering/react-patterns")
-            score += 10;
+    const scoreBreakdown = { ...candidate.scoreBreakdown, analytics: adjustment };
+    return {
+        ...candidate,
+        score: candidate.score + adjustment,
+        scoreBreakdown,
+        reason: explainRoute(candidate.skill, taskMode, candidate.matchedSignals, scoreBreakdown),
+    };
+}
+function buildWorkflow(registry, mode, ranked) {
+    const workflowDefinition = workflowForMode(mode);
+    if (workflowDefinition.length === 0) {
+        return ranked.slice(0, 1).map((candidate) => ({
+            skill: candidate.skill,
+            role: "primary",
+            reason: "Best available skill from metadata and signal scoring.",
+        }));
     }
-    return score;
+    return workflowDefinition
+        .map((step) => {
+        const skill = findSkillById(registry, step.id);
+        return skill ? { skill, role: step.role, reason: step.reason } : null;
+    })
+        .filter((step) => step !== null);
 }
-function explainRoute(skill, input) {
-    const text = buildQuery(input).toLowerCase();
-    const reasons = [];
-    if (skill.id === "engineering/tdd" && (text.includes("test") || text.includes("test trước"))) {
-        reasons.push("the request asks for test-first work");
+function findSkillById(registry, id) {
+    const [category, skill] = id.split("/");
+    if (!category || !skill) {
+        return undefined;
     }
-    if (skill.id === "engineering/diagnose" && (text.includes("bug") || text.includes("fix"))) {
-        reasons.push("the request describes a bug/fix workflow");
+    try {
+        return registry.getSkill(category, skill);
     }
-    if (skill.category === "design" && (text.includes("ui") || text.includes("dashboard"))) {
-        reasons.push("the request targets user interface work");
+    catch {
+        return undefined;
     }
-    if (skill.id.includes("mcp") && text.includes("mcp")) {
-        reasons.push("the request is about MCP integration");
+}
+function buildNextAction(recommended, workflow) {
+    if (workflow.length > 0) {
+        const workflowOrder = workflow.map((step) => step.skill.id).join(" -> ");
+        return `Load skills in workflow order: ${workflowOrder}. Start with ${workflow[0]?.skill.id} using kilo_get_skill.`;
     }
-    return reasons.length > 0
-        ? `Selected because ${reasons.join(" and ")}.`
-        : `Selected from skill metadata match for '${input.message.slice(0, 80)}'.`;
+    return recommended[0]
+        ? `Load ${recommended[0].skill.id} with kilo_get_skill before executing the workflow.`
+        : "No strong skill match found. Search with more specific task keywords or inspect skills/SKILLS_INDEX.md.";
 }

package/mcp/dist/routing-policy-data.js

@@ -0,0 +1,241 @@
+export const RULE_HIERARCHY = [
+    "user-instructions",
+    "platform-safety",
+    "kilo-global",
+    "task-mode",
+    "selected-skill",
+    "on-demand-reference",
+    "verification",
+];
+export const SIGNAL_PATTERNS = [
+    {
+        signal: "workflow-optimization",
+        patterns: [
+            /\boptimi[sz]e\b/i,
+            /\btoi uu\b/i,
+            /\btối ưu\b/i,
+            /\bworkflow\b/i,
+            /\bwordflow\b/i,
+            /\brules?\b/i,
+            /\bskill(?:s)?\b/i,
+            /\bchong cheo\b/i,
+            /\bchồng chéo\b/i,
+        ],
+    },
+    {
+        signal: "architecture",
+        patterns: [/\barchitecture\b/i, /\brefactor\b/i, /\bstructure\b/i, /\brouting\b/i, /\bkernel\b/i],
+    },
+    {
+        signal: "context-engineering",
+        patterns: [/\bcontext\b/i, /\btoken\b/i, /\bagent\b/i, /\badaptive\b/i, /\bpredictive\b/i],
+    },
+    {
+        signal: "skill-authoring",
+        patterns: [/\bSKILL\.md\b/i, /\bskill(?:s)?\b/i, /\brules?\b/i, /\bworkflow\b/i],
+    },
+    {
+        signal: "bug-fix",
+        patterns: [/\bbugs?\b/i, /\bfix\b/i, /\bfailing\b/i, /\berrors?\b/i, /\bbroken\b/i, /\bcrash(?:es|ing)?\b/i],
+    },
+    {
+        signal: "test-first",
+        patterns: [/\btdd\b/i, /\btest[- ]first\b/i, /\btest trước\b/i, /\bviết test trước\b/i, /\bviet test truoc\b/i],
+    },
+    {
+        signal: "ui-work",
+        patterns: [/\bui\b/i, /\bdashboard\b/i, /\breact\b/i, /\bfrontend\b/i, /\binterface\b/i],
+    },
+    {
+        signal: "review",
+        patterns: [/\breview\b/i, /\bPR\b/, /\bpull request\b/i, /\bmerge\b/i, /\bcode review\b/i],
+    },
+    {
+        signal: "mcp",
+        patterns: [/\bmcp\b/i],
+    },
+    {
+        signal: "verification",
+        patterns: [/\bverify\b/i, /\bverification\b/i, /\bvalidate\b/i, /\blint\b/i, /\bcomplete\b/i, /\bdone\b/i],
+    },
+];
+export const SKILL_SIGNAL_WEIGHTS = {
+    "engineering/improve-codebase-architecture": {
+        "workflow-optimization": 58,
+        architecture: 35,
+        "context-engineering": 8,
+        "skill-authoring": 12,
+    },
+    "engineering/context-engineering": {
+        "workflow-optimization": 46,
+        "context-engineering": 42,
+        architecture: 12,
+        mcp: 6,
+    },
+    "productivity/writing-skills": {
+        "workflow-optimization": 44,
+        "skill-authoring": 42,
+        "context-engineering": 6,
+    },
+    "engineering/diagnose": {
+        "bug-fix": 44,
+        "test-first": 8,
+        verification: 6,
+    },
+    "engineering/tdd": {
+        "test-first": 58,
+        "bug-fix": 22,
+        verification: 5,
+    },
+    "engineering/lint-and-validate": {
+        verification: 28,
+        "bug-fix": 10,
+        "test-first": 10,
+        review: 5,
+    },
+    "productivity/verification-before-completion": {
+        verification: 34,
+        "bug-fix": 12,
+        "test-first": 10,
+        "workflow-optimization": 10,
+        review: 18,
+        "ui-work": 8,
+    },
+    "productivity/brainstorming": {
+        "ui-work": 34,
+        "workflow-optimization": 8,
+        architecture: 5,
+    },
+    "design/frontend-design": {
+        "ui-work": 58,
+    },
+    "design/ui-styling": {
+        "ui-work": 46,
+    },
+    "engineering/code-review": {
+        review: 68,
+        verification: 10,
+    },
+    "operations/mcp-builder": {
+        mcp: 42,
+        architecture: 6,
+    },
+    "operations/mcp-management": {
+        mcp: 32,
+        "context-engineering": 8,
+    },
+};
+export const WORKFLOWS = {
+    "workflow-optimization": [
+        {
+            id: "engineering/improve-codebase-architecture",
+            role: "primary",
+            reason: "Find the modules where workflow and rule responsibilities are shallow or duplicated.",
+        },
+        {
+            id: "engineering/context-engineering",
+            role: "support",
+            reason: "Tune context loading, routing metadata, and token-aware skill selection.",
+        },
+        {
+            id: "productivity/writing-skills",
+            role: "support",
+            reason: "Improve rule wording, trigger metadata, and skill authoring discipline.",
+        },
+        {
+            id: "productivity/verification-before-completion",
+            role: "quality",
+            reason: "Require evidence before claiming workflow improvements are complete.",
+        },
+    ],
+    "bug-test-first": [
+        {
+            id: "engineering/diagnose",
+            role: "prepare",
+            reason: "Reproduce and rank hypotheses before changing behavior.",
+        },
+        {
+            id: "engineering/tdd",
+            role: "primary",
+            reason: "Write the failing regression test before implementation.",
+        },
+        {
+            id: "engineering/lint-and-validate",
+            role: "quality",
+            reason: "Run static checks after implementation changes.",
+        },
+        {
+            id: "productivity/verification-before-completion",
+            role: "quality",
+            reason: "Verify tests and requirements before making completion claims.",
+        },
+    ],
+    review: [
+        {
+            id: "engineering/code-review",
+            role: "primary",
+            reason: "Prioritize defects, regressions, and missing tests before summary.",
+        },
+        {
+            id: "productivity/verification-before-completion",
+            role: "quality",
+            reason: "Require fresh evidence before accepting review or merge readiness.",
+        },
+    ],
+    ui: [
+        {
+            id: "productivity/brainstorming",
+            role: "prepare",
+            reason: "Resolve design intent before creating or modifying UI behavior.",
+        },
+        {
+            id: "design/frontend-design",
+            role: "primary",
+            reason: "Design the production-grade frontend experience.",
+        },
+        {
+            id: "design/ui-styling",
+            role: "support",
+            reason: "Apply accessible styling, component, and responsive layout patterns.",
+        },
+        {
+            id: "productivity/verification-before-completion",
+            role: "quality",
+            reason: "Verify UI implementation evidence before completion claims.",
+        },
+    ],
+    bug: [
+        {
+            id: "engineering/diagnose",
+            role: "primary",
+            reason: "Reproduce, minimize, hypothesize, instrument, fix, and regression-test.",
+        },
+        {
+            id: "engineering/lint-and-validate",
+            role: "quality",
+            reason: "Run static checks after implementation changes.",
+        },
+        {
+            id: "productivity/verification-before-completion",
+            role: "quality",
+            reason: "Verify the fix before claiming success.",
+        },
+    ],
+    mcp: [
+        {
+            id: "operations/mcp-builder",
+            role: "primary",
+            reason: "Design or update MCP tools/resources/prompts with clear interfaces.",
+        },
+        {
+            id: "operations/mcp-management",
+            role: "support",
+            reason: "Inspect and manage MCP server capabilities efficiently.",
+        },
+        {
+            id: "productivity/verification-before-completion",
+            role: "quality",
+            reason: "Run MCP build/test/smoke evidence before completion claims.",
+        },
+    ],
+};

package/mcp/dist/routing-policy.js

@@ -0,0 +1,145 @@
+import { SIGNAL_PATTERNS, SKILL_SIGNAL_WEIGHTS, WORKFLOWS } from "./routing-policy-data.js";
+export { RULE_HIERARCHY } from "./routing-policy-data.js";
+export function analyzeIntent(input) {
+    const signals = new Set();
+    const message = input.message;
+    const contextText = [input.context?.mode, input.context?.previousErrors].filter(Boolean).join(" ");
+    const files = input.context?.files ?? [];
+    for (const { signal, patterns } of SIGNAL_PATTERNS) {
+        if (patterns.some((pattern) => pattern.test(message))) {
+            signals.add(signal);
+        }
+    }
+    if (/\barchitecture\b/i.test(contextText)) {
+        signals.add("architecture");
+    }
+    if (/\breview\b/i.test(contextText)) {
+        signals.add("review");
+    }
+    if (/\bcoding\b/i.test(contextText) && signals.has("bug-fix")) {
+        signals.add("verification");
+    }
+    if (files.some((file) => file.endsWith(".tsx") || file.endsWith(".jsx"))) {
+        signals.add("ui-work");
+    }
+    if (files.some((file) => /KILO_MASTER|SKILLS_INDEX|router\.ts|SKILL\.md/.test(file))) {
+        signals.add("architecture");
+        signals.add("context-engineering");
+    }
+    if (signals.has("review")) {
+        return { mode: "review", signals };
+    }
+    if (signals.has("workflow-optimization")) {
+        return { mode: "workflow-optimization", signals };
+    }
+    if (signals.has("ui-work")) {
+        return { mode: "ui", signals };
+    }
+    if (signals.has("bug-fix") && signals.has("test-first")) {
+        return { mode: "bug-test-first", signals };
+    }
+    if (signals.has("bug-fix")) {
+        return { mode: "bug", signals };
+    }
+    if (signals.has("mcp")) {
+        return { mode: "mcp", signals };
+    }
+    return { mode: "general", signals };
+}
+export function scoreSkillForRoute(skill, input, profile) {
+    const matchedSignals = [];
+    const scoreBreakdown = {};
+    const policy = SKILL_SIGNAL_WEIGHTS[skill.id] ?? {};
+    for (const signal of profile.signals) {
+        const signalScore = policy[signal] ?? 0;
+        if (signalScore > 0) {
+            matchedSignals.push(signal);
+            scoreBreakdown[signal] = signalScore;
+        }
+    }
+    const metadataScore = scoreMetadata(skill, input);
+    if (metadataScore > 0) {
+        scoreBreakdown.metadata = metadataScore;
+    }
+    const workflowScore = workflowPriorityScore(skill.id, profile.mode);
+    if (workflowScore > 0) {
+        scoreBreakdown.workflow = workflowScore;
+    }
+    const penalty = conflictPenalty(skill.id, profile.mode);
+    if (penalty < 0) {
+        scoreBreakdown.conflict = penalty;
+    }
+    const score = Object.values(scoreBreakdown).reduce((total, value) => total + value, 0);
+    return {
+        skill,
+        score,
+        matchedSignals,
+        scoreBreakdown,
+        reason: explainRoute(skill, profile.mode, matchedSignals, scoreBreakdown),
+    };
+}
+export function workflowForMode(mode) {
+    return WORKFLOWS[mode] ?? [];
+}
+export function explainRoute(skill, mode, matchedSignals, scoreBreakdown) {
+    const reasons = [];
+    if (matchedSignals.length > 0) {
+        reasons.push(`matched ${matchedSignals.join(", ")}`);
+    }
+    if (scoreBreakdown.workflow) {
+        reasons.push(`belongs to the ${mode} workflow`);
+    }
+    if (scoreBreakdown.metadata) {
+        reasons.push("matched skill metadata");
+    }
+    if (scoreBreakdown.analytics) {
+        reasons.push("has positive route analytics");
+    }
+    if (scoreBreakdown.conflict) {
+        reasons.push("received a conflict penalty");
+    }
+    return reasons.length > 0
+        ? `Selected because it ${reasons.join(" and ")}.`
+        : `Selected from fallback ranking for ${skill.id}.`;
+}
+function scoreMetadata(skill, input) {
+    const query = normalizeText(buildQuery(input));
+    if (!query) {
+        return 0;
+    }
+    const haystack = normalizeText([skill.id, skill.title, skill.description, skill.category].join(" "));
+    const tokens = query.split(" ").filter((token) => token.length >= 3);
+    const tokenHits = tokens.filter((token) => haystack.includes(token)).length;
+    const exactBoost = haystack.includes(query) ? 10 : 0;
+    return Math.min(18, exactBoost + tokenHits * 2);
+}
+function workflowPriorityScore(skillId, mode) {
+    const workflow = workflowForMode(mode);
+    const index = workflow.findIndex((step) => step.id === skillId);
+    if (index === -1) {
+        return 0;
+    }
+    return 24 - index * 3;
+}
+function conflictPenalty(skillId, mode) {
+    if (mode === "review" && (skillId.includes("tdd") || skillId.includes("testing"))) {
+        return -45;
+    }
+    if (mode === "workflow-optimization" && skillId.startsWith("operations/mcp")) {
+        return -10;
+    }
+    return 0;
+}
+function buildQuery(input) {
+    return [
+        input.message,
+        input.context?.mode,
+        input.context?.previousErrors,
+        ...(input.context?.files ?? []),
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+function normalizeText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
+}