@infinitedusky/indusk-mcp 0.1.0

package/dist/bin/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
+const program = new Command();
+program
+    .name("dev-system")
+    .description("InDusk development system — skills, MCP tools, and CLI")
+    .version(pkg.version);
+program
+    .command("init")
+    .description("Initialize a project with InDusk dev system")
+    .action(async () => {
+    const { init } = await import("./commands/init.js");
+    await init(process.cwd());
+});
+program
+    .command("update")
+    .description("Update skills from package without touching project content")
+    .action(async () => {
+    const { update } = await import("./commands/update.js");
+    await update(process.cwd());
+});
+program
+    .command("serve")
+    .description("Start the MCP server (used by Claude Code via .mcp.json)")
+    .action(async () => {
+    const { startServer } = await import("../server/index.js");
+    await startServer();
+});
+program.parse();

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

@@ -0,0 +1 @@
+export declare function init(projectRoot: string): Promise<void>;

package/dist/bin/commands/init.js

@@ -0,0 +1,213 @@
+import { execSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { globSync } from "glob";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, "../../..");
+function run(cmd, options) {
+    try {
+        return execSync(cmd, {
+            encoding: "utf-8",
+            timeout: 15000,
+            stdio: options?.stdio === "inherit" ? "inherit" : ["ignore", "pipe", "pipe"],
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+function ensureFalkorDB() {
+    // Check if FalkorDB container exists and is running
+    const status = run('docker ps --filter name=falkordb --format "{{.Status}}"');
+    if (status) {
+        console.info("  ok: FalkorDB container running");
+        return;
+    }
+    // Check if container exists but is stopped
+    const stopped = run('docker ps -a --filter name=falkordb --format "{{.Status}}"');
+    if (stopped) {
+        console.info("  start: FalkorDB container (was stopped)");
+        run("docker start falkordb");
+        return;
+    }
+    // Create and start the container
+    console.info("  create: FalkorDB container (global, persistent)");
+    run("docker run -d --name falkordb --restart unless-stopped -p 6379:6379 -v falkordb-global:/data falkordb/falkordb:latest");
+}
+function checkCGC() {
+    const cgcPaths = [join(process.env.HOME ?? "", ".local/bin/cgc"), "/usr/local/bin/cgc"];
+    const found = cgcPaths.find((p) => existsSync(p));
+    if (found) {
+        console.info(`  ok: CGC found at ${found}`);
+        return true;
+    }
+    console.info("  missing: CGC — install via: pipx install codegraphcontext");
+    return false;
+}
+function createCgcIgnore(projectRoot) {
+    const ignorePath = join(projectRoot, ".cgcignore");
+    if (existsSync(ignorePath)) {
+        console.info("  skip: .cgcignore (already exists)");
+        return;
+    }
+    writeFileSync(ignorePath, [
+        "node_modules/",
+        ".next/",
+        "dist/",
+        "build/",
+        ".git/",
+        "*.png",
+        "*.jpg",
+        "*.svg",
+        "*.ico",
+        "*.woff",
+        "*.woff2",
+        "*.lock",
+        "pnpm-lock.yaml",
+        "package-lock.json",
+        "",
+    ].join("\n"));
+    console.info("  create: .cgcignore");
+}
+export async function init(projectRoot) {
+    const projectName = basename(projectRoot);
+    console.info("Initializing InDusk dev system...\n");
+    // 1. Copy skills
+    console.info("[Skills]");
+    const skillsSource = join(packageRoot, "skills");
+    const skillsTarget = join(projectRoot, ".claude/skills");
+    const skillFiles = globSync("*.md", { cwd: skillsSource });
+    for (const file of skillFiles) {
+        const skillName = file.replace(".md", "");
+        const targetDir = join(skillsTarget, skillName);
+        const targetFile = join(targetDir, "SKILL.md");
+        if (existsSync(targetFile)) {
+            console.info(`  skip: .claude/skills/${skillName}/SKILL.md (already exists)`);
+            continue;
+        }
+        mkdirSync(targetDir, { recursive: true });
+        cpSync(join(skillsSource, file), targetFile);
+        console.info(`  create: .claude/skills/${skillName}/SKILL.md`);
+    }
+    // 2. Create CLAUDE.md
+    console.info("\n[Project files]");
+    const claudeMdPath = join(projectRoot, "CLAUDE.md");
+    if (existsSync(claudeMdPath)) {
+        console.info("  skip: CLAUDE.md (already exists)");
+    }
+    else {
+        cpSync(join(packageRoot, "templates/CLAUDE.md"), claudeMdPath);
+        console.info("  create: CLAUDE.md");
+    }
+    // 3. Create planning directory
+    const planningDir = join(projectRoot, "planning");
+    if (existsSync(planningDir)) {
+        console.info("  skip: planning/ (already exists)");
+    }
+    else {
+        mkdirSync(planningDir, { recursive: true });
+        console.info("  create: planning/");
+    }
+    // 4. Set up .mcp.json with both indusk and codegraphcontext
+    console.info("\n[MCP config]");
+    const mcpJsonPath = join(projectRoot, ".mcp.json");
+    const induskEntry = {
+        command: "npx",
+        args: ["@infinitedusky/indusk-mcp", "serve"],
+        env: { PROJECT_ROOT: "." },
+    };
+    const cgcEntry = {
+        command: "cgc",
+        args: ["mcp", "start"],
+        env: {
+            DATABASE_TYPE: "falkordb-remote",
+            FALKORDB_HOST: "localhost",
+            FALKORDB_PORT: "6379",
+            FALKORDB_GRAPH_NAME: projectName,
+        },
+    };
+    if (existsSync(mcpJsonPath)) {
+        const existing = JSON.parse(readFileSync(mcpJsonPath, "utf-8"));
+        let updated = false;
+        existing.mcpServers = existing.mcpServers || {};
+        if (!existing.mcpServers.indusk) {
+            existing.mcpServers.indusk = induskEntry;
+            console.info("  update: .mcp.json (added indusk entry)");
+            updated = true;
+        }
+        else {
+            console.info("  skip: .mcp.json indusk entry (already exists)");
+        }
+        if (!existing.mcpServers.codegraphcontext) {
+            existing.mcpServers.codegraphcontext = cgcEntry;
+            console.info(`  update: .mcp.json (added codegraphcontext, graph: ${projectName})`);
+            updated = true;
+        }
+        else {
+            console.info("  skip: .mcp.json codegraphcontext entry (already exists)");
+        }
+        if (updated) {
+            writeFileSync(mcpJsonPath, `${JSON.stringify(existing, null, "\t")}\n`);
+        }
+    }
+    else {
+        const mcpJson = {
+            mcpServers: {
+                indusk: induskEntry,
+                codegraphcontext: cgcEntry,
+            },
+        };
+        writeFileSync(mcpJsonPath, `${JSON.stringify(mcpJson, null, "\t")}\n`);
+        console.info("  create: .mcp.json (indusk + codegraphcontext)");
+    }
+    // 5. Generate .vscode/settings.json
+    console.info("\n[Editor]");
+    const vscodePath = join(projectRoot, ".vscode/settings.json");
+    if (existsSync(vscodePath)) {
+        console.info("  skip: .vscode/settings.json (already exists)");
+    }
+    else {
+        mkdirSync(join(projectRoot, ".vscode"), { recursive: true });
+        cpSync(join(packageRoot, "templates/vscode-settings.json"), vscodePath);
+        console.info("  create: .vscode/settings.json");
+    }
+    // 6. Create base biome.json
+    const biomePath = join(projectRoot, "biome.json");
+    if (existsSync(biomePath)) {
+        console.info("  skip: biome.json (already exists)");
+    }
+    else {
+        cpSync(join(packageRoot, "templates/biome.template.json"), biomePath);
+        console.info("  create: biome.json");
+    }
+    // 7. Create .cgcignore
+    createCgcIgnore(projectRoot);
+    // 8. Infrastructure: FalkorDB + CGC
+    console.info("\n[Infrastructure]");
+    const dockerAvailable = run("docker info") !== "";
+    if (dockerAvailable) {
+        ensureFalkorDB();
+    }
+    else {
+        console.info("  missing: Docker — install Docker or OrbStack to enable FalkorDB");
+    }
+    const cgcInstalled = checkCGC();
+    // Summary
+    console.info("\nDone!");
+    if (!cgcInstalled || !dockerAvailable) {
+        console.info("\nManual steps needed:");
+        if (!dockerAvailable) {
+            console.info("  1. Install Docker or OrbStack");
+            console.info("  2. Re-run init to set up FalkorDB");
+        }
+        if (!cgcInstalled) {
+            console.info("  - Install CGC: pipx install codegraphcontext");
+        }
+    }
+    console.info("\nNext steps:");
+    console.info("  1. Edit CLAUDE.md with your project details");
+    console.info("  2. Install Biome: pnpm add -D @biomejs/biome");
+    console.info("  3. Start a Claude Code session — MCP tools will be available");
+    console.info("  4. Start planning: /plan your-first-feature");
+}

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

@@ -0,0 +1 @@
+export declare function update(projectRoot: string): Promise<void>;

package/dist/bin/commands/update.js

@@ -0,0 +1,40 @@
+import { createHash } from "node:crypto";
+import { cpSync, existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { globSync } from "glob";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, "../../..");
+function fileHash(path) {
+    return createHash("sha256").update(readFileSync(path)).digest("hex").slice(0, 12);
+}
+export async function update(projectRoot) {
+    console.info("Checking for skill updates...\n");
+    const skillsSource = join(packageRoot, "skills");
+    const skillsTarget = join(projectRoot, ".claude/skills");
+    const skillFiles = globSync("*.md", { cwd: skillsSource });
+    let updated = 0;
+    let skipped = 0;
+    for (const file of skillFiles) {
+        const skillName = file.replace(".md", "");
+        const sourceFile = join(skillsSource, file);
+        const targetFile = join(skillsTarget, skillName, "SKILL.md");
+        if (!existsSync(targetFile)) {
+            console.info(`  skip: ${skillName} (not installed — run init first)`);
+            skipped++;
+            continue;
+        }
+        const sourceHash = fileHash(sourceFile);
+        const targetHash = fileHash(targetFile);
+        if (sourceHash === targetHash) {
+            console.info(`  current: ${skillName}`);
+            skipped++;
+        }
+        else {
+            cpSync(sourceFile, targetFile);
+            console.info(`  updated: ${skillName}`);
+            updated++;
+        }
+    }
+    console.info(`\n${updated} updated, ${skipped} current.`);
+}

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

@@ -0,0 +1,26 @@
+export declare const SECTION_NAMES: readonly ["What This Is", "Architecture", "Conventions", "Key Decisions", "Known Gotchas", "Current State"];
+export type SectionName = (typeof SECTION_NAMES)[number];
+export interface ContextSection {
+    name: SectionName;
+    content: string;
+}
+export interface ParsedContext {
+    title: string;
+    sections: ContextSection[];
+}
+export interface ContextValidation {
+    valid: boolean;
+    missing: SectionName[];
+    extra: string[];
+}
+/**
+ * Parse CLAUDE.md into its 6 canonical sections.
+ * Sections are split on `## ` headings. Content between the title (H1)
+ * and the first H2 is ignored (it's the intro line).
+ */
+export declare function parseContext(filePath: string): ParsedContext;
+export declare function parseContextString(raw: string): ParsedContext;
+export declare function validateContext(parsed: ParsedContext): ContextValidation;
+export declare function getSection(parsed: ParsedContext, name: SectionName): string | null;
+export declare function updateSection(filePath: string, name: SectionName, newContent: string): void;
+export declare function updateSectionString(raw: string, name: SectionName, newContent: string): string;

package/dist/lib/context-parser.js

@@ -0,0 +1,86 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+export const SECTION_NAMES = [
+    "What This Is",
+    "Architecture",
+    "Conventions",
+    "Key Decisions",
+    "Known Gotchas",
+    "Current State",
+];
+/**
+ * Parse CLAUDE.md into its 6 canonical sections.
+ * Sections are split on `## ` headings. Content between the title (H1)
+ * and the first H2 is ignored (it's the intro line).
+ */
+export function parseContext(filePath) {
+    if (!existsSync(filePath)) {
+        return { title: "", sections: [] };
+    }
+    const raw = readFileSync(filePath, "utf-8");
+    return parseContextString(raw);
+}
+export function parseContextString(raw) {
+    const lines = raw.split("\n");
+    // Extract H1 title
+    const titleLine = lines.find((l) => l.startsWith("# "));
+    const title = titleLine ? titleLine.replace(/^# /, "").trim() : "";
+    // Split on ## headings
+    const sections = [];
+    let currentName = null;
+    let currentLines = [];
+    for (const line of lines) {
+        if (line.startsWith("## ")) {
+            if (currentName !== null) {
+                sections.push({
+                    name: currentName,
+                    content: currentLines.join("\n").trim(),
+                });
+            }
+            currentName = line.replace(/^## /, "").trim();
+            currentLines = [];
+        }
+        else if (currentName !== null) {
+            currentLines.push(line);
+        }
+    }
+    // Push last section
+    if (currentName !== null) {
+        sections.push({
+            name: currentName,
+            content: currentLines.join("\n").trim(),
+        });
+    }
+    return { title, sections };
+}
+export function validateContext(parsed) {
+    const found = new Set(parsed.sections.map((s) => s.name));
+    const missing = SECTION_NAMES.filter((n) => !found.has(n));
+    const canonical = new Set(SECTION_NAMES);
+    const extra = parsed.sections.map((s) => s.name).filter((n) => !canonical.has(n));
+    return {
+        valid: missing.length === 0 && extra.length === 0,
+        missing: missing,
+        extra,
+    };
+}
+export function getSection(parsed, name) {
+    const section = parsed.sections.find((s) => s.name === name);
+    return section?.content ?? null;
+}
+export function updateSection(filePath, name, newContent) {
+    const raw = readFileSync(filePath, "utf-8");
+    const updated = updateSectionString(raw, name, newContent);
+    writeFileSync(filePath, updated);
+}
+export function updateSectionString(raw, name, newContent) {
+    const header = `## ${name}`;
+    const headerIdx = raw.indexOf(header);
+    if (headerIdx === -1) {
+        throw new Error(`Section "${name}" not found in CLAUDE.md`);
+    }
+    // Find the end of this section (next ## or EOF)
+    const afterHeader = headerIdx + header.length;
+    const nextSectionMatch = raw.slice(afterHeader).search(/\n## /);
+    const endIdx = nextSectionMatch === -1 ? raw.length : afterHeader + nextSectionMatch;
+    return `${raw.slice(0, afterHeader)}\n\n${newContent.trim()}\n${raw.slice(endIdx)}`;
+}

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

@@ -0,0 +1,31 @@
+export type GateType = "implementation" | "verification" | "context" | "document";
+export interface ChecklistItem {
+    checked: boolean;
+    text: string;
+}
+export interface PhaseGate {
+    type: GateType;
+    items: ChecklistItem[];
+}
+export interface ImplPhase {
+    number: number;
+    name: string;
+    gates: PhaseGate[];
+}
+export interface ParsedImpl {
+    title: string;
+    status: string;
+    phases: ImplPhase[];
+}
+export declare function parseImplString(raw: string): ParsedImpl;
+export declare function parseImpl(filePath: string): ParsedImpl;
+export interface PhaseCompletion {
+    phase: number;
+    name: string;
+    complete: boolean;
+    totalItems: number;
+    checkedItems: number;
+    uncheckedByGate: Record<GateType, string[]>;
+}
+export declare function getPhaseCompletion(phase: ImplPhase): PhaseCompletion;
+export declare function getAllPhaseCompletions(parsed: ParsedImpl): PhaseCompletion[];

package/dist/lib/impl-parser.js

@@ -0,0 +1,107 @@
+import { existsSync, readFileSync } from "node:fs";
+import matter from "gray-matter";
+const GATE_SUFFIXES = {
+    Verification: "verification",
+    Context: "context",
+    Document: "document",
+};
+function parseChecklistItems(lines) {
+    const items = [];
+    for (const line of lines) {
+        const match = line.match(/^-\s+\[([ x])\]\s+(.*)/);
+        if (match) {
+            items.push({
+                checked: match[1] === "x",
+                text: match[2].trim(),
+            });
+        }
+    }
+    return items;
+}
+export function parseImplString(raw) {
+    const { data, content } = matter(raw);
+    const title = data.title ?? "";
+    const status = data.status ?? "";
+    const lines = content.split("\n");
+    const phases = [];
+    let currentPhase = null;
+    let currentGateType = "implementation";
+    let currentGateLines = [];
+    function flushGate() {
+        if (!currentPhase)
+            return;
+        const items = parseChecklistItems(currentGateLines);
+        if (items.length > 0) {
+            currentPhase.gates.push({ type: currentGateType, items });
+        }
+        currentGateLines = [];
+    }
+    for (const line of lines) {
+        // Phase header: ### Phase N: Name
+        const phaseMatch = line.match(/^###\s+Phase\s+(\d+)[:\s]+(.*)/);
+        if (phaseMatch) {
+            flushGate();
+            if (currentPhase)
+                phases.push(currentPhase);
+            currentPhase = {
+                number: Number.parseInt(phaseMatch[1], 10),
+                name: phaseMatch[2].trim(),
+                gates: [],
+            };
+            currentGateType = "implementation";
+            currentGateLines = [];
+            continue;
+        }
+        // Gate header: #### Phase N Verification|Context|Document
+        const gateMatch = line.match(/^####\s+Phase\s+\d+\s+(Verification|Context|Document)\b/);
+        if (gateMatch) {
+            flushGate();
+            currentGateType = GATE_SUFFIXES[gateMatch[1]];
+            continue;
+        }
+        currentGateLines.push(line);
+    }
+    // Flush last gate and phase
+    flushGate();
+    if (currentPhase)
+        phases.push(currentPhase);
+    return { title, status, phases };
+}
+export function parseImpl(filePath) {
+    if (!existsSync(filePath)) {
+        return { title: "", status: "", phases: [] };
+    }
+    return parseImplString(readFileSync(filePath, "utf-8"));
+}
+export function getPhaseCompletion(phase) {
+    const uncheckedByGate = {
+        implementation: [],
+        verification: [],
+        context: [],
+        document: [],
+    };
+    let totalItems = 0;
+    let checkedItems = 0;
+    for (const gate of phase.gates) {
+        for (const item of gate.items) {
+            totalItems++;
+            if (item.checked) {
+                checkedItems++;
+            }
+            else {
+                uncheckedByGate[gate.type].push(item.text);
+            }
+        }
+    }
+    return {
+        phase: phase.number,
+        name: phase.name,
+        complete: checkedItems === totalItems,
+        totalItems,
+        checkedItems,
+        uncheckedByGate,
+    };
+}
+export function getAllPhaseCompletions(parsed) {
+    return parsed.phases.map(getPhaseCompletion);
+}

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

@@ -0,0 +1,16 @@
+export interface PlanFrontmatter {
+    title: string;
+    date: string;
+    status: string;
+}
+export type PlanStage = "research" | "brief" | "adr" | "impl" | "retrospective" | "unknown";
+export interface PlanSummary {
+    name: string;
+    stage: PlanStage;
+    stageStatus: string;
+    nextStep: string;
+    dependencies: string[];
+    documents: string[];
+}
+export declare function parsePlan(planDir: string): PlanSummary;
+export declare function parseAllPlans(projectRoot: string): PlanSummary[];

package/dist/lib/plan-parser.js

@@ -0,0 +1,82 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import matter from "gray-matter";
+const STAGE_ORDER = ["research", "brief", "adr", "impl", "retrospective"];
+function parseFrontmatter(filePath) {
+    if (!existsSync(filePath))
+        return null;
+    const raw = readFileSync(filePath, "utf-8");
+    const { data } = matter(raw);
+    return {
+        title: data.title ?? "",
+        date: data.date ?? "",
+        status: data.status ?? "",
+    };
+}
+function parseDependsOn(filePath) {
+    if (!existsSync(filePath))
+        return [];
+    const content = readFileSync(filePath, "utf-8");
+    const depsMatch = content.match(/## Depends On\s*\n([\s\S]*?)(?=\n## |\n$|$)/);
+    if (!depsMatch)
+        return [];
+    const deps = [];
+    for (const line of depsMatch[1].split("\n")) {
+        const match = line.match(/^-\s+`?planning\/([^/`]+)\/?`?/);
+        if (match) {
+            deps.push(match[1]);
+        }
+    }
+    return deps;
+}
+function determineStage(planDir, docs) {
+    // Walk stages in reverse to find the most advanced document
+    for (let i = STAGE_ORDER.length - 1; i >= 0; i--) {
+        const stage = STAGE_ORDER[i];
+        const file = `${stage}.md`;
+        if (docs.includes(file)) {
+            const fm = parseFrontmatter(join(planDir, file));
+            return { stage, stageStatus: fm?.status ?? "unknown" };
+        }
+    }
+    return { stage: "unknown", stageStatus: "unknown" };
+}
+function determineNextStep(stage, stageStatus) {
+    if (stage === "unknown")
+        return "Create a brief";
+    const idx = STAGE_ORDER.indexOf(stage);
+    if (stageStatus === "completed" || stageStatus === "accepted") {
+        const next = STAGE_ORDER[idx + 1];
+        if (next)
+            return `Create ${next}`;
+        return "Done";
+    }
+    if (stageStatus === "in-progress") {
+        return `Continue ${stage}`;
+    }
+    return `Review ${stage} (status: ${stageStatus})`;
+}
+export function parsePlan(planDir) {
+    const name = planDir.split("/").pop() ?? "";
+    const entries = readdirSync(planDir).filter((f) => f.endsWith(".md"));
+    const { stage, stageStatus } = determineStage(planDir, entries);
+    const dependencies = parseDependsOn(join(planDir, "brief.md"));
+    const nextStep = determineNextStep(stage, stageStatus);
+    return {
+        name,
+        stage,
+        stageStatus,
+        nextStep,
+        dependencies,
+        documents: entries,
+    };
+}
+export function parseAllPlans(projectRoot) {
+    const planningDir = join(projectRoot, "planning");
+    if (!existsSync(planningDir))
+        return [];
+    return readdirSync(planningDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => parsePlan(join(planningDir, d.name)))
+        .sort((a, b) => a.name.localeCompare(b.name));
+}

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export declare function startServer(): Promise<void>;

package/dist/server/index.js

@@ -0,0 +1,22 @@
+import { resolve } from "node:path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerContextTools } from "../tools/context-tools.js";
+import { registerDocumentTools } from "../tools/document-tools.js";
+import { registerPlanTools } from "../tools/plan-tools.js";
+import { registerQualityTools } from "../tools/quality-tools.js";
+import { registerSystemTools } from "../tools/system-tools.js";
+export async function startServer() {
+    const projectRoot = resolve(process.env.PROJECT_ROOT ?? ".");
+    const server = new McpServer({
+        name: "indusk",
+        version: "0.1.0",
+    });
+    registerPlanTools(server, projectRoot);
+    registerContextTools(server, projectRoot);
+    registerQualityTools(server, projectRoot);
+    registerDocumentTools(server, projectRoot);
+    registerSystemTools(server, projectRoot);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

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

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