@vodailoc/kilo-kit-mcp 1.1.0

package/mcp/dist/registry.js

@@ -0,0 +1,185 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { parseSkillFrontmatter } from "./frontmatter.js";
+import { assertSafeSegment, normalizeRepoRoot, resolveInsideRepo, toPosixPath } from "./paths.js";
+const DEFAULT_LIMIT = 10;
+const MAX_LIMIT = 50;
+const DEFAULT_MAX_CHARS = 12_000;
+export async function createSkillRegistry(options) {
+    const repoRoot = normalizeRepoRoot(options.repoRoot);
+    const skillsRoot = resolveInsideRepo(repoRoot, "skills");
+    const records = await discoverSkills(repoRoot, skillsRoot);
+    return new FileSystemSkillRegistry(repoRoot, records);
+}
+class FileSystemSkillRegistry {
+    repoRoot;
+    #recordsById;
+    constructor(repoRoot, records) {
+        this.repoRoot = repoRoot;
+        this.#recordsById = new Map(records.map((record) => [record.id, record]));
+    }
+    listSkills() {
+        return [...this.#recordsById.values()].sort((left, right) => left.id.localeCompare(right.id));
+    }
+    searchSkills(input) {
+        const query = input.query.trim();
+        const limit = clampLimit(input.limit);
+        const category = input.category?.trim();
+        if (category) {
+            assertSafeSegment(category, "category");
+        }
+        const scored = this.listSkills()
+            .filter((skill) => !category || skill.category === category)
+            .map((skill) => ({ skill, score: scoreSkill(skill, query) }))
+            .filter((entry) => entry.score > 0)
+            .sort((left, right) => right.score - left.score || left.skill.id.localeCompare(right.skill.id));
+        return scored.slice(0, limit).map((entry) => entry.skill);
+    }
+    getSkill(category, skill) {
+        assertSafeSegment(category, "category");
+        assertSafeSegment(skill, "skill");
+        const record = this.#recordsById.get(`${category}/${skill}`);
+        if (!record) {
+            throw new Error(`Skill '${category}/${skill}' was not found. Search skills first, then load one exact result.`);
+        }
+        return record;
+    }
+    async loadSkill(input) {
+        const record = this.getSkill(input.category, input.skill);
+        const maxChars = Math.max(100, Math.min(input.maxChars ?? DEFAULT_MAX_CHARS, 50_000));
+        const absoluteSkillPath = resolveInsideRepo(this.repoRoot, record.skillPath);
+        const content = await fs.readFile(absoluteSkillPath, "utf8");
+        const truncated = content.length > maxChars;
+        return {
+            skill: {
+                ...record,
+                references: await listReferenceFiles(this.repoRoot, resolveInsideRepo(this.repoRoot, record.directoryPath)),
+            },
+            content: truncated ? content.slice(0, maxChars) : content,
+            truncated,
+            maxChars,
+        };
+    }
+}
+async function discoverSkills(repoRoot, skillsRoot) {
+    const skillFiles = await findSkillFiles(skillsRoot);
+    const records = await Promise.all(skillFiles.map((skillFile) => readSkillRecord(repoRoot, skillFile)));
+    return records.sort((left, right) => left.id.localeCompare(right.id));
+}
+async function findSkillFiles(directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const skillFiles = [];
+    for (const entry of entries) {
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            skillFiles.push(...(await findSkillFiles(absolute)));
+        }
+        else if (entry.isFile() && entry.name === "SKILL.md") {
+            skillFiles.push(absolute);
+        }
+    }
+    return skillFiles;
+}
+async function readSkillRecord(repoRoot, skillFile) {
+    const content = await fs.readFile(skillFile, "utf8");
+    const frontmatter = parseSkillFrontmatter(content);
+    const directory = path.dirname(skillFile);
+    const relativeDirectory = toPosixPath(repoRoot, directory);
+    const parts = relativeDirectory.split("/");
+    const skillsIndex = parts.indexOf("skills");
+    const category = parts[skillsIndex + 1];
+    const folderName = parts.at(-1);
+    if (!category || !folderName) {
+        throw new Error(`Could not infer skill category for ${relativeDirectory}`);
+    }
+    const name = frontmatter.name || folderName;
+    const description = frontmatter.description || "No description provided.";
+    const skillPath = toPosixPath(repoRoot, skillFile);
+    return {
+        id: `${category}/${folderName}`,
+        category,
+        name: folderName,
+        title: name,
+        description,
+        directoryPath: relativeDirectory,
+        skillPath,
+        references: [],
+    };
+}
+async function listReferenceFiles(repoRoot, directory) {
+    const containers = ["references", "reference", "scripts", "assets"];
+    const files = [];
+    for (const container of containers) {
+        const containerPath = path.join(directory, container);
+        try {
+            const stat = await fs.stat(containerPath);
+            if (!stat.isDirectory()) {
+                continue;
+            }
+            files.push(...(await listFiles(repoRoot, containerPath)));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                throw error;
+            }
+        }
+    }
+    return files.sort();
+}
+async function listFiles(repoRoot, directory) {
+    const entries = await fs.readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const absolute = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(repoRoot, absolute)));
+        }
+        else if (entry.isFile()) {
+            files.push(toPosixPath(repoRoot, absolute));
+        }
+    }
+    return files;
+}
+function clampLimit(limit) {
+    return Math.max(1, Math.min(limit ?? DEFAULT_LIMIT, MAX_LIMIT));
+}
+function scoreSkill(skill, rawQuery) {
+    const query = normalizeText(rawQuery);
+    if (!query) {
+        return 1;
+    }
+    const haystack = normalizeText([skill.id, skill.title, skill.description, skill.category, expandSkillVocabulary(skill)].join(" "));
+    const tokens = query.split(" ").filter(Boolean);
+    let score = 0;
+    if (haystack.includes(query)) {
+        score += 40;
+    }
+    for (const token of tokens) {
+        if (skill.id.includes(token)) {
+            score += 12;
+        }
+        if (haystack.includes(token)) {
+            score += 4;
+        }
+    }
+    if (query.includes("test driven") && skill.id === "engineering/tdd") {
+        score += 80;
+    }
+    if (query.includes("test driven") && skill.id === "productivity/test-driven-development") {
+        score -= 20;
+    }
+    return score;
+}
+function normalizeText(value) {
+    return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function expandSkillVocabulary(skill) {
+    const expansions = {
+        "engineering/tdd": "test driven development test first red green refactor bug fix tests",
+        "engineering/diagnose": "bug fix debug reproduce failing error root cause",
+        "kilo-kit/debugging/systematic": "bug fix debug systematic validation",
+        "design/frontend-design": "ui ux react frontend interface dashboard polished responsive",
+        "design/ui-styling": "ui styling shadcn tailwind accessible responsive",
+    };
+    return expansions[skill.id] ?? "";
+}

package/mcp/dist/router.js

@@ -0,0 +1,98 @@
+export function routeIntent(registry, input) {
+    const query = buildQuery(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),
+    }))
+        .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) => ({
+        skill: candidate.skill,
+        confidence: Math.max(0.1, Math.min(0.99, candidate.score / (candidate.score + 20 + index * 3))),
+        reason: candidate.reason,
+    }));
+    return {
+        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.",
+    };
+}
+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;
+    }
+    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;
+    }
+    return score;
+}
+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");
+    }
+    if (skill.id === "engineering/diagnose" && (text.includes("bug") || text.includes("fix"))) {
+        reasons.push("the request describes a bug/fix workflow");
+    }
+    if (skill.category === "design" && (text.includes("ui") || text.includes("dashboard"))) {
+        reasons.push("the request targets user interface work");
+    }
+    if (skill.id.includes("mcp") && text.includes("mcp")) {
+        reasons.push("the request is about MCP integration");
+    }
+    return reasons.length > 0
+        ? `Selected because ${reasons.join(" and ")}.`
+        : `Selected from skill metadata match for '${input.message.slice(0, 80)}'.`;
+}

package/mcp/dist/server.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+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 { resolveInsideRepo } from "./paths.js";
+import { createSkillRegistry } from "./registry.js";
+import { routeIntent } from "./router.js";
+import { validateSkills } from "./validator.js";
+const SERVER_VERSION = "1.1.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 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.",
+    });
+    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.",
+        inputSchema: {
+            query: z.string().min(1).max(500).describe("Natural-language task or keyword query."),
+            category: z.string().min(1).max(80).optional().describe("Optional category such as engineering or design."),
+            limit: z.number().int().min(1).max(50).optional().describe("Maximum number of skills to return."),
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ query, category, limit, format }) => {
+        const searchInput = {
+            query,
+            ...(category ? { category } : {}),
+            ...(limit ? { limit } : {}),
+        };
+        const skills = registry.searchSkills(searchInput);
+        return textResponse(formatSkills(skills, searchInput, normalizeFormat(format)));
+    });
+    server.registerTool("kilo_get_skill", {
+        title: "Load Kilo-Kit Skill",
+        description: "Load one exact Kilo-Kit skill by category and skill name. Use after kilo_route_intent or kilo_search_skills.",
+        inputSchema: {
+            category: z.string().min(1).max(80).describe("Skill category, for example engineering."),
+            skill: z.string().min(1).max(120).describe("Skill folder name, for example tdd."),
+            maxChars: z.number().int().min(100).max(50000).optional().describe("Maximum SKILL.md characters to return."),
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ category, skill, maxChars, format }) => {
+        const loaded = await registry.loadSkill({
+            category,
+            skill,
+            ...(maxChars ? { maxChars } : {}),
+        });
+        return textResponse(formatLoadedSkill(loaded, normalizeFormat(format)));
+    });
+    server.registerTool("kilo_route_intent", {
+        title: "Route Current Intent to Skills",
+        description: "Recommend the best Kilo-Kit skills for the current chat request and optional repo context. Call this before choosing a workflow skill.",
+        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(),
+            })
+                .optional(),
+            limit: z.number().int().min(1).max(10).optional(),
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ message, context, limit, format }) => {
+        const routeContext = context
+            ? {
+                ...(context.files ? { files: context.files } : {}),
+                ...(context.mode ? { mode: context.mode } : {}),
+                ...(context.previousErrors ? { previousErrors: context.previousErrors } : {}),
+            }
+            : undefined;
+        const result = routeIntent(registry, {
+            message,
+            ...(routeContext ? { context: routeContext } : {}),
+            ...(limit ? { limit } : {}),
+        });
+        return textResponse(formatRoute(result, 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.",
+        inputSchema: {
+            format: formatSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+        },
+    }, async ({ format }) => {
+        const summary = await validateSkills({ repoRoot });
+        return textResponse(formatValidation(summary, normalizeFormat(format)));
+    });
+    registerResources(server, repoRoot, registry);
+    registerPrompts(server);
+    return server;
+}
+function registerResources(server, repoRoot, registry) {
+    server.registerResource("kilo-skills-index", "kilo://skills/index", {
+        title: "Kilo-Kit Skills Index",
+        description: "Lightweight index for skill discovery.",
+        mimeType: "text/markdown",
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                text: await readFile(resolveInsideRepo(repoRoot, "skills/SKILLS_INDEX.md"), "utf8"),
+            },
+        ],
+    }));
+    server.registerResource("kilo-core-master", "kilo://core/master", {
+        title: "Kilo-Kit Master Skill",
+        description: "Core Cognitive Flow Architecture and routing protocol.",
+        mimeType: "text/markdown",
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                text: await readFile(resolveInsideRepo(repoRoot, "src/core/KILO_MASTER.md"), "utf8"),
+            },
+        ],
+    }));
+    server.registerResource("kilo-skill", new ResourceTemplate("kilo://skills/{category}/{skill}", {
+        list: async () => ({
+            resources: registry.listSkills().map((skill) => ({
+                uri: `kilo://skills/${skill.category}/${skill.name}`,
+                name: skill.id,
+                description: skill.description,
+                mimeType: "text/markdown",
+            })),
+        }),
+    }), {
+        title: "Kilo-Kit Skill",
+        description: "Dynamic resource for one Kilo-Kit skill.",
+        mimeType: "text/markdown",
+    }, async (uri, variables) => {
+        const category = String(variables.category);
+        const skill = String(variables.skill);
+        const loaded = await registry.loadSkill({ category, skill, maxChars: 20_000 });
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    text: loaded.content,
+                },
+            ],
+        };
+    });
+}
+function registerPrompts(server) {
+    server.registerPrompt("kilo-select-skill", {
+        title: "Select Kilo-Kit Skill",
+        description: "Prompt the agent to route the current request through Kilo-Kit before implementation.",
+        argsSchema: {
+            request: z.string().min(1).max(4000),
+        },
+    }, ({ request }) => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: `Route this request through Kilo-Kit. First call kilo_route_intent with the request, then load the top skill with kilo_get_skill, then proceed.\n\nRequest:\n${request}`,
+                },
+            },
+        ],
+    }));
+    server.registerPrompt("kilo-validate-library", {
+        title: "Validate Kilo-Kit Library",
+        description: "Prompt the agent to run the Kilo-Kit validation quality gate.",
+        argsSchema: {},
+    }, () => ({
+        messages: [
+            {
+                role: "user",
+                content: {
+                    type: "text",
+                    text: "Run kilo_validate_skills and summarize whether the Kilo-Kit skill library passes the quality gate.",
+                },
+            },
+        ],
+    }));
+}
+function normalizeFormat(format) {
+    return format ?? "markdown";
+}
+async function main() {
+    const server = await createKiloKitServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+    main().catch((error) => {
+        console.error(error);
+        process.exit(1);
+    });
+}

package/mcp/dist/smoke.js

@@ -0,0 +1,57 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+const transport = new StdioClientTransport({
+    command: process.env.KILO_KIT_SMOKE_COMMAND ?? process.execPath,
+    args: parseSmokeArgs(),
+});
+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"]) {
+        if (!toolNames.includes(required)) {
+            throw new Error(`Missing expected tool: ${required}`);
+        }
+    }
+    const route = await client.callTool({
+        name: "kilo_route_intent",
+        arguments: {
+            message: "Fix bug login, viết test trước",
+            context: { files: ["src/auth/login.ts"], mode: "coding" },
+            format: "json",
+        },
+    });
+    const routeText = extractFirstText(route);
+    if (!routeText.includes("engineering/tdd")) {
+        throw new Error(`Smoke route did not recommend engineering/tdd: ${routeText}`);
+    }
+    const skill = await client.callTool({
+        name: "kilo_get_skill",
+        arguments: { category: "engineering", skill: "tdd", maxChars: 800 },
+    });
+    const skillText = extractFirstText(skill);
+    if (!skillText.includes("Test-Driven Development")) {
+        throw new Error("Smoke skill load did not return the TDD skill body.");
+    }
+    console.log("MCP smoke check passed.");
+}
+finally {
+    await client.close();
+}
+function extractFirstText(value) {
+    const content = value.content;
+    const first = content?.[0];
+    return first?.type === "text" && first.text ? first.text : "";
+}
+function parseSmokeArgs() {
+    const rawArgs = process.env.KILO_KIT_SMOKE_ARGS;
+    if (!rawArgs) {
+        return ["dist/server.js"];
+    }
+    const parsed = JSON.parse(rawArgs);
+    if (!Array.isArray(parsed) || !parsed.every((item) => typeof item === "string")) {
+        throw new Error("KILO_KIT_SMOKE_ARGS must be a JSON array of strings.");
+    }
+    return parsed;
+}

package/mcp/dist/types.js

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

package/mcp/dist/validator.js

@@ -0,0 +1,35 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { normalizeRepoRoot, resolveInsideRepo } from "./paths.js";
+const execFileAsync = promisify(execFile);
+export async function validateSkills(input) {
+    const repoRoot = normalizeRepoRoot(input.repoRoot);
+    const script = resolveInsideRepo(repoRoot, "src/tools/validate-skill.js");
+    const skillsPath = resolveInsideRepo(repoRoot, "skills");
+    const command = `${process.execPath} ${script} --all ${skillsPath}`;
+    const result = await execFileAsync(process.execPath, [script, "--all", skillsPath], {
+        cwd: repoRoot,
+        maxBuffer: 10 * 1024 * 1024,
+        windowsHide: true,
+    });
+    const output = `${result.stdout}${result.stderr}`.trim();
+    const summary = output.match(/SUMMARY:\s+(\d+)\/(\d+)\s+skills valid/);
+    const valid = summary?.[1] ? Number(summary[1]) : 0;
+    const total = summary?.[2] ? Number(summary[2]) : 0;
+    return {
+        command,
+        total,
+        valid,
+        invalid: Math.max(0, total - valid),
+        output: summarizeOutput(output),
+    };
+}
+function summarizeOutput(output) {
+    const lines = output
+        .split(/\r?\n/)
+        .filter((line) => /SUMMARY|All skills passed|INVALID|errors|warnings/.test(stripAnsi(line)));
+    return lines.map(stripAnsi).join("\n").slice(0, 2_800);
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "");
+}

package/mcp/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@kilo-kit/mcp",
+  "version": "1.1.0",
+  "description": "Kilo-Kit MCP server for skill routing, skill loading, and validation.",
+  "type": "module",
+  "private": true,
+  "bin": {
+    "kilo-kit-mcp": "./dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "start": "node dist/server.js",
+    "smoke": "node dist/smoke.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@vodailoc/kilo-kit-mcp": "file:..",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.3",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}