@infinitedusky/indusk-mcp 0.4.0 → 0.6.0

package/dist/bin/cli.js

@@ -14,9 +14,15 @@ program
     .command("init")
     .description("Initialize a project with InDusk dev system")
     .option("-f, --force", "Overwrite existing files (except CLAUDE.md and planning/)")
+    .option("--skills <list>", "Comma-separated domain skills to install (e.g., nextjs,tailwind)")
+    .option("--no-domain-skills", "Skip domain skill detection and installation")
     .action(async (opts) => {
     const { init } = await import("./commands/init.js");
-    await init(process.cwd(), { force: opts.force ?? false });
+    await init(process.cwd(), {
+        force: opts.force ?? false,
+        skills: opts.skills,
+        noDomainSkills: opts.domainSkills === false,
+    });
 });
 program
     .command("update")
@@ -25,6 +31,15 @@ program
     const { update } = await import("./commands/update.js");
     await update(process.cwd());
 });
+program
+    .command("check-gates")
+    .description("Validate plan execution gates — reports incomplete verification, context, and document items")
+    .option("--file <path>", "Path to a specific impl.md file")
+    .option("--phase <number>", "Check a specific phase number", Number.parseInt)
+    .action(async (opts) => {
+    const { checkGates } = await import("./commands/check-gates.js");
+    await checkGates(process.cwd(), { file: opts.file, phase: opts.phase });
+});
 program
     .command("serve")
     .description("Start the MCP server (used by Claude Code via .mcp.json)")

package/dist/bin/commands/check-gates.d.ts

@@ -0,0 +1,4 @@
+export declare function checkGates(projectRoot: string, options?: {
+    file?: string;
+    phase?: number;
+}): Promise<void>;

package/dist/bin/commands/check-gates.js

@@ -0,0 +1,84 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAllPhaseCompletions, parseImpl } from "../../lib/impl-parser.js";
+export async function checkGates(projectRoot, options = {}) {
+    let implPath;
+    if (options.file) {
+        implPath = options.file;
+    }
+    else {
+        // Find active impl (in-progress status) in planning/
+        const planningDir = join(projectRoot, "planning");
+        if (!existsSync(planningDir)) {
+            console.error("No planning/ directory found");
+            process.exitCode = 1;
+            return;
+        }
+        const plans = readdirSync(planningDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && d.name !== "archive")
+            .map((d) => d.name);
+        let found = null;
+        for (const plan of plans) {
+            const path = join(planningDir, plan, "impl.md");
+            if (!existsSync(path))
+                continue;
+            const content = readFileSync(path, "utf-8");
+            if (content.includes("status: in-progress")) {
+                found = path;
+                break;
+            }
+        }
+        if (!found) {
+            console.error("No in-progress impl found in planning/");
+            process.exitCode = 1;
+            return;
+        }
+        implPath = found;
+    }
+    if (!existsSync(implPath)) {
+        console.error(`File not found: ${implPath}`);
+        process.exitCode = 1;
+        return;
+    }
+    const parsed = parseImpl(implPath);
+    const completions = getAllPhaseCompletions(parsed);
+    if (options.phase) {
+        const phase = completions.find((c) => c.phase === options.phase);
+        if (!phase) {
+            console.error(`Phase ${options.phase} not found`);
+            process.exitCode = 1;
+            return;
+        }
+        printPhase(phase);
+        process.exitCode = phase.complete ? 0 : 1;
+        return;
+    }
+    // Report all phases
+    let allPass = true;
+    console.info(`Gate status: ${implPath}\n`);
+    for (const phase of completions) {
+        printPhase(phase);
+        if (!phase.complete)
+            allPass = false;
+    }
+    // Check for blockers
+    for (const phase of parsed.phases) {
+        if (phase.blocker) {
+            console.info(`  BLOCKER in Phase ${phase.number}: ${phase.blocker}`);
+            allPass = false;
+        }
+    }
+    console.info(allPass ? "\nAll gates pass." : "\nSome gates incomplete.");
+    process.exitCode = allPass ? 0 : 1;
+}
+function printPhase(phase) {
+    const status = phase.complete ? "PASS" : "FAIL";
+    console.info(`Phase ${phase.phase}: ${phase.name} — ${status} (${phase.checkedItems}/${phase.totalItems})`);
+    if (!phase.complete) {
+        for (const [gate, items] of Object.entries(phase.uncheckedByGate)) {
+            for (const item of items) {
+                console.info(`  [${gate}] ${item}`);
+            }
+        }
+    }
+}

package/dist/bin/commands/init.d.ts

@@ -1,4 +1,6 @@
 export interface InitOptions {
     force?: boolean;
+    skills?: string;
+    noDomainSkills?: boolean;
 }
 export declare function init(projectRoot: string, options?: InitOptions): Promise<void>;

package/dist/bin/commands/init.js

@@ -70,8 +70,56 @@ function createCgcIgnore(projectRoot) {
     ].join("\n"));
     console.info("  create: .cgcignore");
 }
+const DOMAIN_DETECTION_MAP = [
+    { signal: "dependency", match: "next", skill: "nextjs" },
+    { signal: "dependency", match: "tailwindcss", skill: "tailwind" },
+    { signal: "dependency", match: "react", skill: "react" },
+    { signal: "devDependency", match: "typescript", skill: "typescript" },
+    { signal: "devDependency", match: "vitest", skill: "testing" },
+    { signal: "devDependency", match: "jest", skill: "testing" },
+    { signal: "dependency", match: "vitepress", skill: "vitepress" },
+];
+const FILE_PATTERN_DETECTIONS = [
+    { pattern: "*.sol", skill: "solidity" },
+    { pattern: "Dockerfile*", skill: "docker" },
+];
+function detectDomainSkills(projectRoot) {
+    const detections = [];
+    const seen = new Set();
+    // Check package.json dependencies
+    const pkgPath = join(projectRoot, "package.json");
+    if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const deps = pkg.dependencies ?? {};
+        const devDeps = pkg.devDependencies ?? {};
+        for (const rule of DOMAIN_DETECTION_MAP) {
+            if (seen.has(rule.skill))
+                continue;
+            const source = rule.signal === "dependency" ? deps : devDeps;
+            if (source[rule.match]) {
+                detections.push({
+                    skill: rule.skill,
+                    signal: rule.signal,
+                    match: rule.match,
+                });
+                seen.add(rule.skill);
+            }
+        }
+    }
+    // Check file patterns
+    for (const rule of FILE_PATTERN_DETECTIONS) {
+        if (seen.has(rule.skill))
+            continue;
+        const matches = globSync(rule.pattern, { cwd: projectRoot, maxDepth: 3 });
+        if (matches.length > 0) {
+            detections.push({ skill: rule.skill, signal: "file-pattern", match: rule.pattern });
+            seen.add(rule.skill);
+        }
+    }
+    return detections;
+}
 export async function init(projectRoot, options = {}) {
-    const { force = false } = options;
+    const { force = false, skills, noDomainSkills = false } = options;
     const projectName = basename(projectRoot);
     console.info(`Initializing InDusk dev system...${force ? " (--force)" : ""}\n`);
     // 1. Copy skills
@@ -91,7 +139,66 @@ export async function init(projectRoot, options = {}) {
         cpSync(join(skillsSource, file), targetFile);
         console.info(`  ${existsSync(targetFile) ? "overwrite" : "create"}: .claude/skills/${skillName}/SKILL.md`);
     }
-    // 2. Create CLAUDE.md (never overwrite — write CLAUDE-NEW.md if exists)
+    // 2. Install domain skills
+    if (!noDomainSkills) {
+        console.info("\n[Domain Skills]");
+        const domainSource = join(packageRoot, "skills/domain");
+        let skillsToInstall;
+        if (skills) {
+            skillsToInstall = skills.split(",").map((s) => s.trim());
+            console.info(`  manual: installing ${skillsToInstall.join(", ")}`);
+        }
+        else {
+            const detections = detectDomainSkills(projectRoot);
+            skillsToInstall = detections.map((d) => d.skill);
+            if (detections.length > 0) {
+                for (const d of detections) {
+                    console.info(`  detected: ${d.skill} (${d.signal}: ${d.match})`);
+                }
+            }
+            else {
+                console.info("  none detected");
+            }
+        }
+        for (const skillName of skillsToInstall) {
+            const sourceFile = join(domainSource, `${skillName}.md`);
+            if (!existsSync(sourceFile)) {
+                console.info(`  skip: ${skillName} (not found in registry)`);
+                continue;
+            }
+            const targetDir = join(skillsTarget, skillName);
+            const targetFile = join(targetDir, "SKILL.md");
+            if (existsSync(targetFile) && !force) {
+                console.info(`  skip: .claude/skills/${skillName}/SKILL.md (already exists)`);
+                continue;
+            }
+            mkdirSync(targetDir, { recursive: true });
+            cpSync(sourceFile, targetFile);
+            console.info(`  install: .claude/skills/${skillName}/SKILL.md`);
+        }
+    }
+    else {
+        console.info("\n[Domain Skills]");
+        console.info("  skipped (--no-domain-skills)");
+    }
+    // 3. Copy community lessons
+    console.info("\n[Lessons]");
+    const lessonsSource = join(packageRoot, "lessons/community");
+    const lessonsTarget = join(projectRoot, ".claude/lessons");
+    mkdirSync(lessonsTarget, { recursive: true });
+    if (existsSync(lessonsSource)) {
+        const lessonFiles = globSync("community-*.md", { cwd: lessonsSource });
+        for (const file of lessonFiles) {
+            const targetFile = join(lessonsTarget, file);
+            if (existsSync(targetFile) && !force) {
+                console.info(`  skip: .claude/lessons/${file} (already exists)`);
+                continue;
+            }
+            cpSync(join(lessonsSource, file), targetFile);
+            console.info(`  ${existsSync(targetFile) ? "overwrite" : "create"}: .claude/lessons/${file}`);
+        }
+    }
+    // 3. Create CLAUDE.md (never overwrite — write CLAUDE-NEW.md if exists)
     console.info("\n[Project files]");
     const claudeMdPath = join(projectRoot, "CLAUDE.md");
     if (existsSync(claudeMdPath)) {
@@ -184,7 +291,74 @@ export async function init(projectRoot, options = {}) {
         cpSync(join(packageRoot, "templates/biome.template.json"), biomePath);
         console.info(`  ${existsSync(biomePath) ? "overwrite" : "create"}: biome.json`);
     }
-    // 7. Create .cgcignore (always overwrite — package-owned)
+    // 7. Install gate enforcement hooks
+    console.info("\n[Hooks]");
+    const hooksSource = join(packageRoot, "hooks");
+    const hooksTarget = join(projectRoot, ".claude/hooks");
+    const hookFiles = ["check-gates.js", "gate-reminder.js"];
+    if (existsSync(hooksSource)) {
+        mkdirSync(hooksTarget, { recursive: true });
+        for (const file of hookFiles) {
+            const sourceFile = join(hooksSource, file);
+            const targetFile = join(hooksTarget, file);
+            if (!existsSync(sourceFile))
+                continue;
+            if (existsSync(targetFile) && !force) {
+                console.info(`  skip: .claude/hooks/${file} (already exists)`);
+            }
+            else {
+                cpSync(sourceFile, targetFile);
+                console.info(`  ${existsSync(targetFile) ? "overwrite" : "create"}: .claude/hooks/${file}`);
+            }
+        }
+    }
+    // Merge hook config into .claude/settings.json
+    const claudeSettingsPath = join(projectRoot, ".claude/settings.json");
+    const hookConfig = {
+        PreToolUse: [
+            {
+                matcher: "Edit|Write",
+                hooks: [{ type: "command", command: "node .claude/hooks/check-gates.js" }],
+            },
+        ],
+        PostToolUse: [
+            {
+                matcher: "Edit|Write",
+                hooks: [{ type: "command", command: "node .claude/hooks/gate-reminder.js" }],
+            },
+        ],
+    };
+    if (existsSync(claudeSettingsPath)) {
+        const existing = JSON.parse(readFileSync(claudeSettingsPath, "utf-8"));
+        existing.hooks = existing.hooks || {};
+        let hooksUpdated = false;
+        for (const [event, entries] of Object.entries(hookConfig)) {
+            const existingEntries = existing.hooks[event] || [];
+            // Check if our hook is already present
+            const hasOurHook = existingEntries.some((e) => e.hooks?.some((h) => h.command?.includes("check-gates") || h.command?.includes("gate-reminder")));
+            if (!hasOurHook || force) {
+                // Remove old entries if force, then add
+                if (force) {
+                    existing.hooks[event] = existingEntries.filter((e) => !e.hooks?.some((h) => h.command?.includes("check-gates") || h.command?.includes("gate-reminder")));
+                }
+                existing.hooks[event] = [...(existing.hooks[event] || []), ...entries];
+                hooksUpdated = true;
+            }
+        }
+        if (hooksUpdated) {
+            writeFileSync(claudeSettingsPath, `${JSON.stringify(existing, null, "\t")}\n`);
+            console.info("  update: .claude/settings.json (added hook config)");
+        }
+        else {
+            console.info("  skip: .claude/settings.json hooks (already configured)");
+        }
+    }
+    else {
+        const settings = { hooks: hookConfig };
+        writeFileSync(claudeSettingsPath, `${JSON.stringify(settings, null, "\t")}\n`);
+        console.info("  create: .claude/settings.json (with hook config)");
+    }
+    // 8. Create .cgcignore (always overwrite — package-owned)
     createCgcIgnore(projectRoot);
     // 8. Infrastructure: FalkorDB + CGC
     console.info("\n[Infrastructure]");

package/dist/bin/commands/update.js

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { cpSync, existsSync, readFileSync } from "node:fs";
+import { cpSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { globSync } from "glob";
@@ -14,21 +14,25 @@ export async function update(projectRoot) {
     const skillsTarget = join(projectRoot, ".claude/skills");
     const skillFiles = globSync("*.md", { cwd: skillsSource });
     let updated = 0;
-    let skipped = 0;
+    let added = 0;
+    let current = 0;
     for (const file of skillFiles) {
         const skillName = file.replace(".md", "");
         const sourceFile = join(skillsSource, file);
-        const targetFile = join(skillsTarget, skillName, "SKILL.md");
+        const targetDir = join(skillsTarget, skillName);
+        const targetFile = join(targetDir, "SKILL.md");
         if (!existsSync(targetFile)) {
-            console.info(`  skip: ${skillName} (not installed — run init first)`);
-            skipped++;
+            mkdirSync(targetDir, { recursive: true });
+            cpSync(sourceFile, targetFile);
+            console.info(`  added: ${skillName} (new skill)`);
+            added++;
             continue;
         }
         const sourceHash = fileHash(sourceFile);
         const targetHash = fileHash(targetFile);
         if (sourceHash === targetHash) {
             console.info(`  current: ${skillName}`);
-            skipped++;
+            current++;
         }
         else {
             cpSync(sourceFile, targetFile);
@@ -36,5 +40,101 @@ export async function update(projectRoot) {
             updated++;
         }
     }
-    console.info(`\n${updated} updated, ${skipped} current.`);
+    console.info(`\n${added} added, ${updated} updated, ${current} current.`);
+    // Sync community lessons (only community- prefixed files)
+    console.info("\nChecking for lesson updates...\n");
+    const lessonsSource = join(packageRoot, "lessons/community");
+    const lessonsTarget = join(projectRoot, ".claude/lessons");
+    let lessonsAdded = 0;
+    let lessonsUpdated = 0;
+    let lessonsCurrent = 0;
+    if (existsSync(lessonsSource)) {
+        mkdirSync(lessonsTarget, { recursive: true });
+        const lessonFiles = globSync("community-*.md", { cwd: lessonsSource });
+        for (const file of lessonFiles) {
+            const sourceFile = join(lessonsSource, file);
+            const targetFile = join(lessonsTarget, file);
+            if (!existsSync(targetFile)) {
+                cpSync(sourceFile, targetFile);
+                console.info(`  added: ${file}`);
+                lessonsAdded++;
+                continue;
+            }
+            const sourceH = fileHash(sourceFile);
+            const targetH = fileHash(targetFile);
+            if (sourceH === targetH) {
+                console.info(`  current: ${file}`);
+                lessonsCurrent++;
+            }
+            else {
+                cpSync(sourceFile, targetFile);
+                console.info(`  updated: ${file}`);
+                lessonsUpdated++;
+            }
+        }
+    }
+    console.info(`\n${lessonsAdded} added, ${lessonsUpdated} updated, ${lessonsCurrent} current.`);
+    // Sync installed domain skills (only update ones already installed)
+    console.info("\nChecking for domain skill updates...\n");
+    const domainSource = join(packageRoot, "skills/domain");
+    let domainUpdated = 0;
+    let domainCurrent = 0;
+    if (existsSync(domainSource)) {
+        const domainFiles = globSync("*.md", { cwd: domainSource });
+        for (const file of domainFiles) {
+            const skillName = file.replace(".md", "");
+            const sourceFile = join(domainSource, file);
+            const targetFile = join(skillsTarget, skillName, "SKILL.md");
+            // Only update if already installed — don't install new domain skills during update
+            if (!existsSync(targetFile))
+                continue;
+            const sourceH = fileHash(sourceFile);
+            const targetH = fileHash(targetFile);
+            if (sourceH === targetH) {
+                console.info(`  current: ${skillName}`);
+                domainCurrent++;
+            }
+            else {
+                cpSync(sourceFile, targetFile);
+                console.info(`  updated: ${skillName}`);
+                domainUpdated++;
+            }
+        }
+    }
+    if (domainUpdated + domainCurrent > 0) {
+        console.info(`\n${domainUpdated} updated, ${domainCurrent} current.`);
+    }
+    else {
+        console.info("  no domain skills installed");
+    }
+    // Sync hook scripts (only if hooks directory exists in target)
+    console.info("\nChecking for hook updates...\n");
+    const hooksSource = join(packageRoot, "hooks");
+    const hooksTarget = join(projectRoot, ".claude/hooks");
+    let hooksUpdated = 0;
+    let hooksCurrent = 0;
+    if (existsSync(hooksSource) && existsSync(hooksTarget)) {
+        const hookFiles = ["check-gates.js", "gate-reminder.js"];
+        for (const file of hookFiles) {
+            const sourceFile = join(hooksSource, file);
+            const targetFile = join(hooksTarget, file);
+            if (!existsSync(sourceFile) || !existsSync(targetFile))
+                continue;
+            const sourceH = fileHash(sourceFile);
+            const targetH = fileHash(targetFile);
+            if (sourceH === targetH) {
+                console.info(`  current: ${file}`);
+                hooksCurrent++;
+            }
+            else {
+                cpSync(sourceFile, targetFile);
+                console.info(`  updated: ${file}`);
+                hooksUpdated++;
+            }
+        }
+        console.info(`\n${hooksUpdated} updated, ${hooksCurrent} current.`);
+    }
+    else {
+        console.info("  hooks not installed (run init to install)");
+    }
 }

package/dist/lib/impl-parser.d.ts

@@ -11,6 +11,8 @@ export interface ImplPhase {
     number: number;
     name: string;
     gates: PhaseGate[];
+    blocker: string | null;
+    forwardIntelligence: string | null;
 }
 export interface ParsedImpl {
     title: string;

package/dist/lib/impl-parser.js

@@ -27,6 +27,8 @@ export function parseImplString(raw) {
     let currentPhase = null;
     let currentGateType = "implementation";
     let currentGateLines = [];
+    let inForwardIntelligence = false;
+    let forwardIntelligenceLines = [];
     function flushGate() {
         if (!currentPhase)
             return;
@@ -47,21 +49,51 @@ export function parseImplString(raw) {
                 number: Number.parseInt(phaseMatch[1], 10),
                 name: phaseMatch[2].trim(),
                 gates: [],
+                blocker: null,
+                forwardIntelligence: null,
             };
             currentGateType = "implementation";
             currentGateLines = [];
             continue;
         }
+        // Forward Intelligence header: #### Phase N Forward Intelligence
+        const fiMatch = line.match(/^####\s+Phase\s+\d+\s+Forward Intelligence\b/);
+        if (fiMatch) {
+            flushGate();
+            inForwardIntelligence = true;
+            forwardIntelligenceLines = [];
+            continue;
+        }
         // Gate header: #### Phase N Verification|Context|Document
         const gateMatch = line.match(/^####\s+Phase\s+\d+\s+(Verification|Context|Document)\b/);
         if (gateMatch) {
+            if (inForwardIntelligence && currentPhase) {
+                currentPhase.forwardIntelligence = forwardIntelligenceLines.join("\n").trim() || null;
+                inForwardIntelligence = false;
+            }
             flushGate();
             currentGateType = GATE_SUFFIXES[gateMatch[1]];
             continue;
         }
-        currentGateLines.push(line);
+        // Blocker line: blocker: description
+        if (currentPhase) {
+            const blockerMatch = line.match(/^blocker:\s+(.*)/);
+            if (blockerMatch) {
+                currentPhase.blocker = blockerMatch[1].trim();
+                continue;
+            }
+        }
+        if (inForwardIntelligence) {
+            forwardIntelligenceLines.push(line);
+        }
+        else {
+            currentGateLines.push(line);
+        }
+    }
+    // Flush last forward intelligence, gate, and phase
+    if (inForwardIntelligence && currentPhase) {
+        currentPhase.forwardIntelligence = forwardIntelligenceLines.join("\n").trim() || null;
     }
-    // Flush last gate and phase
     flushGate();
     if (currentPhase)
         phases.push(currentPhase);

package/dist/lib/verification-discovery.d.ts

@@ -0,0 +1,6 @@
+export interface DiscoveredCheck {
+    name: string;
+    command: string;
+    source: "package.json" | "config-file";
+}
+export declare function discoverVerificationCommands(projectRoot: string): DiscoveredCheck[];

package/dist/lib/verification-discovery.js

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { globSync } from "glob";
+const SCRIPT_PATTERNS = {
+    typecheck: "typecheck",
+    "type-check": "type-check",
+    lint: "lint",
+    test: "test",
+    build: "build",
+    check: "check",
+    "check:fix": "check:fix",
+};
+export function discoverVerificationCommands(projectRoot) {
+    const checks = [];
+    // 1. Read package.json scripts
+    const pkgPath = join(projectRoot, "package.json");
+    if (existsSync(pkgPath)) {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        const scripts = pkg.scripts ?? {};
+        for (const [pattern, name] of Object.entries(SCRIPT_PATTERNS)) {
+            if (scripts[pattern]) {
+                const runner = existsSync(join(projectRoot, "pnpm-lock.yaml"))
+                    ? "pnpm"
+                    : existsSync(join(projectRoot, "yarn.lock"))
+                        ? "yarn"
+                        : "npm";
+                checks.push({
+                    name,
+                    command: `${runner} run ${pattern}`,
+                    source: "package.json",
+                });
+            }
+        }
+        // Check for tsc script variants
+        if (!checks.some((c) => c.name === "typecheck") && scripts.tsc) {
+            checks.push({ name: "typecheck", command: "npm run tsc", source: "package.json" });
+        }
+    }
+    // 2. Detect tool configs
+    if (existsSync(join(projectRoot, "biome.json")) && !checks.some((c) => c.name === "check")) {
+        checks.push({ name: "biome", command: "npx biome check", source: "config-file" });
+    }
+    if (existsSync(join(projectRoot, "tsconfig.json")) &&
+        !checks.some((c) => c.name === "typecheck")) {
+        checks.push({ name: "typecheck", command: "npx tsc --noEmit", source: "config-file" });
+    }
+    const vitestConfigs = globSync("vitest.config.*", { cwd: projectRoot });
+    if (vitestConfigs.length > 0 && !checks.some((c) => c.name === "test")) {
+        checks.push({ name: "test", command: "npx vitest run", source: "config-file" });
+    }
+    const jestConfigs = globSync("jest.config.*", { cwd: projectRoot });
+    if (jestConfigs.length > 0 && !checks.some((c) => c.name === "test")) {
+        checks.push({ name: "test", command: "npx jest", source: "config-file" });
+    }
+    return checks;
+}

package/dist/server/index.js

@@ -4,6 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { registerContextTools } from "../tools/context-tools.js";
 import { registerDocumentTools } from "../tools/document-tools.js";
 import { registerGraphTools } from "../tools/graph-tools.js";
+import { registerLessonTools } from "../tools/lesson-tools.js";
 import { registerPlanTools } from "../tools/plan-tools.js";
 import { registerQualityTools } from "../tools/quality-tools.js";
 import { registerSystemTools } from "../tools/system-tools.js";
@@ -19,6 +20,7 @@ export async function startServer() {
     registerDocumentTools(server, projectRoot);
     registerSystemTools(server, projectRoot);
     registerGraphTools(server, projectRoot);
+    registerLessonTools(server, projectRoot);
     const transport = new StdioServerTransport();
     await server.connect(transport);
 }

package/dist/tools/lesson-tools.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerLessonTools(server: McpServer, projectRoot: string): void;