@hellocrossman/mcp-sdk 0.2.0 → 0.3.1

package/dist/cli.js

@@ -1,9 +1,10 @@
 #!/usr/bin/env node
 import fs from "fs";
 import path from "path";
+import readline from "readline";
+import { scanAllRoutes } from "./route-scan.js";
 const IMPORT_LINE_ESM = `import { createMcpServer } from '@hellocrossman/mcp-sdk';`;
 const IMPORT_LINE_CJS = `const { createMcpServer } = require('@hellocrossman/mcp-sdk');`;
-const SETUP_LINE = `createMcpServer({ app });`;
 const COMMON_ENTRY_FILES = [
     "server/index.ts",
     "server/index.js",
@@ -28,12 +29,49 @@ const EXPRESS_PATTERNS = [
 ];
 const APP_VAR_PATTERN = /(?:const|let|var)\s+(\w+)\s*=\s*express\(\)/;
 const LISTEN_PATTERN = /(?:app|server|httpServer)\s*\.listen\s*\(/;
+const COLORS = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    white: "\x1b[37m",
+    gray: "\x1b[90m",
+    bgGreen: "\x1b[42m",
+    bgYellow: "\x1b[43m",
+};
+function c(color, text) {
+    return `${COLORS[color]}${text}${COLORS.reset}`;
+}
+function createPrompt() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        ask: (question) => new Promise((resolve) => {
+            rl.question(question, (answer) => resolve(answer.trim()));
+        }),
+        confirm: async (question, defaultYes = true) => {
+            const hint = defaultYes ? "Y/n" : "y/N";
+            const answer = await new Promise((resolve) => {
+                rl.question(`${question} ${c("dim", `(${hint})`)} `, (a) => resolve(a.trim().toLowerCase()));
+            });
+            if (answer === "")
+                return defaultYes;
+            return answer === "y" || answer === "yes";
+        },
+        close: () => rl.close(),
+    };
+}
 function findProjectRoot() {
     let dir = process.cwd();
     while (dir !== path.dirname(dir)) {
-        if (fs.existsSync(path.join(dir, "package.json"))) {
+        if (fs.existsSync(path.join(dir, "package.json")))
             return dir;
-        }
         dir = path.dirname(dir);
     }
     return process.cwd();
@@ -43,9 +81,8 @@ function findExpressEntryFile(root) {
         const fullPath = path.join(root, file);
         if (fs.existsSync(fullPath)) {
             const content = fs.readFileSync(fullPath, "utf-8");
-            if (EXPRESS_PATTERNS.some((p) => p.test(content))) {
+            if (EXPRESS_PATTERNS.some((p) => p.test(content)))
                 return fullPath;
-            }
         }
     }
     const srcDirs = ["server", "src", "."];
@@ -57,14 +94,13 @@ function findExpressEntryFile(root) {
         for (const file of files) {
             const fullPath = path.join(dirPath, file);
             const content = fs.readFileSync(fullPath, "utf-8");
-            if (EXPRESS_PATTERNS.some((p) => p.test(content))) {
+            if (EXPRESS_PATTERNS.some((p) => p.test(content)))
                 return fullPath;
-            }
         }
     }
     return null;
 }
-function isESM(filePath, root) {
+function checkIsESM(filePath, root) {
     if (filePath.endsWith(".ts") || filePath.endsWith(".mjs"))
         return true;
     try {
@@ -76,20 +112,322 @@ function isESM(filePath, root) {
     }
 }
 function alreadySetup(content) {
-    return (content.includes("createMcpServer") ||
-        content.includes("@hellocrossman/mcp-sdk") ||
-        content.includes("hellocrossman/mcp-sdk"));
+    return content.includes("createMcpServer") || content.includes("@hellocrossman/mcp-sdk");
 }
-function injectMcpSetup(filePath, root) {
-    const content = fs.readFileSync(filePath, "utf-8");
+function checkPgInstalled(root) {
+    return fs.existsSync(path.join(root, "node_modules", "pg"));
+}
+function detectPackageManager(root) {
+    if (fs.existsSync(path.join(root, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (fs.existsSync(path.join(root, "yarn.lock")))
+        return "yarn";
+    return "npm";
+}
+function printHeader() {
+    console.log();
+    console.log(`  ${c("bold", "@hellocrossman/mcp-sdk")}`);
+    console.log(`  ${c("dim", "Turn your Express API into an MCP server")}`);
+    console.log();
+}
+function printStep(step, total, title) {
+    console.log();
+    console.log(`  ${c("cyan", `[${step}/${total}]`)} ${c("bold", title)}`);
+    console.log(`  ${c("dim", "─".repeat(50))}`);
+}
+function printToolTable(tools) {
+    const routeTools = tools.filter((t) => t.source === "route");
+    const dbTools = tools.filter((t) => t.source === "database");
+    if (routeTools.length > 0) {
+        console.log(`\n  ${c("dim", "API Routes:")}`);
+        for (const t of routeTools) {
+            const status = t.enabled ? c("green", "ON ") : c("dim", "OFF");
+            const method = t.method.padEnd(6);
+            console.log(`    ${status}  ${c("yellow", method)} ${t.name} ${c("dim", `- ${t.description}`)}`);
+        }
+    }
+    if (dbTools.length > 0) {
+        console.log(`\n  ${c("dim", "Database Tables:")}`);
+        for (const t of dbTools) {
+            const status = t.enabled ? c("green", "ON ") : c("dim", "OFF");
+            const method = t.method.padEnd(6);
+            console.log(`    ${status}  ${c("magenta", method)} ${t.name} ${c("dim", `- ${t.description}`)}`);
+        }
+    }
+}
+async function stepDetectApp(state, prompt, specifiedFile) {
+    printStep(1, 5, "Detecting Express app");
+    let entryFile = null;
+    if (specifiedFile) {
+        const resolved = path.resolve(state.root, specifiedFile);
+        if (fs.existsSync(resolved)) {
+            entryFile = resolved;
+        }
+        else {
+            console.log(`  ${c("yellow", "!")} File not found: ${specifiedFile}`);
+            return false;
+        }
+    }
+    else {
+        entryFile = findExpressEntryFile(state.root);
+    }
+    if (!entryFile) {
+        console.log(`  ${c("yellow", "!")} Could not find an Express app file.`);
+        const custom = await prompt.ask(`  Enter the path to your Express app file: `);
+        if (custom) {
+            const resolved = path.resolve(state.root, custom);
+            if (fs.existsSync(resolved)) {
+                entryFile = resolved;
+            }
+            else {
+                console.log(`  ${c("yellow", "!")} File not found: ${custom}`);
+                return false;
+            }
+        }
+        else {
+            return false;
+        }
+    }
+    const content = fs.readFileSync(entryFile, "utf-8");
     if (alreadySetup(content)) {
-        return { success: true, message: "MCP SDK is already set up in this file." };
+        console.log(`  ${c("green", "+")} MCP SDK is already set up in ${path.relative(state.root, entryFile)}`);
+        console.log(`  ${c("dim", "  Remove the existing createMcpServer() call to reconfigure.")}`);
+        return false;
     }
-    const esm = isESM(filePath, root);
-    const importLine = esm ? IMPORT_LINE_ESM : IMPORT_LINE_CJS;
     const appMatch = content.match(APP_VAR_PATTERN);
-    const appVarName = appMatch ? appMatch[1] : "app";
-    const setupCode = `createMcpServer({ app: ${appVarName} });`;
+    state.entryFile = entryFile;
+    state.appVarName = appMatch ? appMatch[1] : "app";
+    state.isESM = checkIsESM(entryFile, state.root);
+    console.log(`  ${c("green", "+")} Found Express app: ${c("bold", path.relative(state.root, entryFile))}`);
+    console.log(`  ${c("dim", `  Variable: ${state.appVarName}, Module: ${state.isESM ? "ESM" : "CommonJS"}`)}`);
+    return true;
+}
+async function stepScanRoutes(state) {
+    printStep(2, 5, "Scanning API routes");
+    state.routes = scanAllRoutes(state.entryFile, state.routePrefix);
+    if (state.routes.length === 0) {
+        console.log(`  ${c("dim", "  No routes found under")} ${state.routePrefix}`);
+        console.log(`  ${c("dim", "  Routes will be discovered at runtime when your app starts.")}`);
+        return;
+    }
+    console.log(`  ${c("green", "+")} Found ${c("bold", String(state.routes.length))} API routes:\n`);
+    for (const route of state.routes) {
+        const method = route.method.padEnd(6);
+        console.log(`    ${c("yellow", method)} ${route.path}`);
+    }
+    for (const route of state.routes) {
+        const name = generateToolName(route.method, route.path);
+        const description = generateToolDescription(route.method, route.path);
+        state.tools.push({
+            name,
+            description,
+            method: route.method,
+            path: route.path,
+            source: "route",
+            enabled: true,
+        });
+    }
+}
+async function stepScanDatabase(state, prompt) {
+    printStep(3, 5, "Database discovery");
+    const wantDb = await prompt.confirm(`  Scan your database for tables to expose as tools?`);
+    if (!wantDb) {
+        state.databaseEnabled = false;
+        console.log(`  ${c("dim", "  Skipping database discovery.")}`);
+        return;
+    }
+    let dbUrl = process.env.DATABASE_URL || process.env.POSTGRES_URL || process.env.PG_CONNECTION_STRING;
+    if (!dbUrl) {
+        console.log(`  ${c("yellow", "!")} No DATABASE_URL found in environment.`);
+        dbUrl = (await prompt.ask(`  Enter your PostgreSQL connection string (or press Enter to skip): `)) || undefined;
+        if (!dbUrl) {
+            state.databaseEnabled = false;
+            console.log(`  ${c("dim", "  Skipping database discovery.")}`);
+            return;
+        }
+    }
+    if (!checkPgInstalled(state.root)) {
+        console.log(`  ${c("yellow", "!")} The 'pg' package is required for database features.`);
+        const pm = detectPackageManager(state.root);
+        const installCmd = pm === "yarn" ? "yarn add pg" : pm === "pnpm" ? "pnpm add pg" : "npm install pg";
+        const installPg = await prompt.confirm(`  Install pg now? (${c("dim", installCmd)})`);
+        if (installPg) {
+            console.log(`  ${c("dim", `  Running ${installCmd}...`)}`);
+            const { execSync } = await import("child_process");
+            try {
+                execSync(installCmd, { cwd: state.root, stdio: "pipe" });
+                console.log(`  ${c("green", "+")} pg installed successfully.`);
+            }
+            catch {
+                console.log(`  ${c("yellow", "!")} Failed to install pg. Run '${installCmd}' manually.`);
+                state.databaseEnabled = false;
+                return;
+            }
+        }
+        else {
+            console.log(`  ${c("dim", `  Run '${installCmd}' to enable database features later.`)}`);
+            state.databaseEnabled = false;
+            return;
+        }
+    }
+    try {
+        const { introspectDatabase } = await import("./db-introspect.js");
+        const { isSensitiveTable } = await import("./db-tool-generator.js");
+        console.log(`  ${c("dim", "  Connecting to database...")}`);
+        const result = await introspectDatabase(dbUrl);
+        const safeTables = result.tables.filter((t) => !isSensitiveTable(t.name));
+        const hiddenTables = result.tables.filter((t) => isSensitiveTable(t.name));
+        state.dbTables = safeTables;
+        state.databaseEnabled = true;
+        console.log(`  ${c("green", "+")} Found ${c("bold", String(result.tables.length))} tables (${safeTables.length} safe, ${hiddenTables.length} hidden)\n`);
+        if (hiddenTables.length > 0) {
+            console.log(`  ${c("dim", "  Auto-hidden (sensitive):")} ${hiddenTables.map((t) => t.name).join(", ")}`);
+        }
+        console.log(`\n  ${c("dim", "  Available tables:")}`);
+        for (const table of safeTables) {
+            const colCount = table.columns.length;
+            const pk = table.columns.find((col) => col.isPrimary);
+            console.log(`    ${c("magenta", table.name)} ${c("dim", `(${colCount} columns${pk ? `, pk: ${pk.name}` : ""})`)}`);
+            state.tools.push({
+                name: `list_${table.name}`,
+                description: `List all ${formatTableName(table.name)} records with filtering and pagination`,
+                method: "QUERY",
+                path: `db://${table.name}`,
+                source: "database",
+                enabled: true,
+                tableName: table.name,
+            });
+            if (pk) {
+                state.tools.push({
+                    name: `get_${table.name}_by_${pk.name}`,
+                    description: `Get a specific ${formatTableName(table.name)} record by ${pk.name}`,
+                    method: "QUERY",
+                    path: `db://${table.name}/${pk.name}`,
+                    source: "database",
+                    enabled: true,
+                    tableName: table.name,
+                });
+            }
+        }
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(`  ${c("yellow", "!")} Database scan failed: ${msg}`);
+        state.databaseEnabled = false;
+    }
+}
+async function stepEnrichAndReview(state, prompt) {
+    printStep(4, 5, "AI enrichment & tool review");
+    if (state.tools.length === 0) {
+        console.log(`  ${c("dim", "  No tools discovered. Routes will be discovered at runtime.")}`);
+        state.enrichmentEnabled = true;
+        return;
+    }
+    const wantEnrich = await prompt.confirm(`  Use AI to improve tool names and descriptions?`);
+    if (wantEnrich) {
+        console.log(`  ${c("dim", "  Contacting enrichment service...")}`);
+        try {
+            const { enrichTools } = await import("./enrichment.js");
+            const toolSummaries = state.tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                method: t.method === "QUERY" ? "DB_QUERY" : t.method,
+                path: t.path,
+                inputSchema: {},
+                params: [],
+            }));
+            const enriched = await enrichTools(toolSummaries);
+            let enrichCount = 0;
+            for (let i = 0; i < state.tools.length; i++) {
+                if (enriched[i]) {
+                    if (enriched[i].name)
+                        state.tools[i].name = enriched[i].name;
+                    if (enriched[i].description)
+                        state.tools[i].description = enriched[i].description;
+                    enrichCount++;
+                }
+            }
+            console.log(`  ${c("green", "+")} Enhanced ${enrichCount} tool descriptions.`);
+            state.enrichmentEnabled = true;
+        }
+        catch {
+            console.log(`  ${c("yellow", "!")} Enrichment service unavailable. Using auto-generated names.`);
+            state.enrichmentEnabled = false;
+        }
+    }
+    else {
+        state.enrichmentEnabled = false;
+    }
+    console.log(`\n  ${c("bold", "Discovered tools:")}`);
+    printToolTable(state.tools);
+    console.log();
+    const reviewMode = await prompt.ask(`  Enable all tools, or review individually? ${c("dim", "(all/review)")} `);
+    if (reviewMode.toLowerCase() === "review" || reviewMode.toLowerCase() === "r") {
+        console.log();
+        for (let i = 0; i < state.tools.length; i++) {
+            const t = state.tools[i];
+            const source = t.source === "route" ? c("yellow", t.method) : c("magenta", "DB");
+            const enabled = await prompt.confirm(`  ${source} ${c("bold", t.name)} ${c("dim", `- ${t.description}`)}\n      Enable this tool?`);
+            state.tools[i].enabled = enabled;
+        }
+        const enabledCount = state.tools.filter((t) => t.enabled).length;
+        console.log(`\n  ${c("green", "+")} ${enabledCount} of ${state.tools.length} tools enabled.`);
+    }
+    else {
+        console.log(`  ${c("green", "+")} All ${state.tools.length} tools enabled.`);
+    }
+    if (state.databaseEnabled) {
+        const wantWrites = await prompt.confirm(`\n  Enable write operations (create/insert) for database tables?`, false);
+        state.includeWrites = wantWrites;
+    }
+}
+async function stepGenerate(state) {
+    printStep(5, 5, "Generating MCP server");
+    const content = fs.readFileSync(state.entryFile, "utf-8");
+    const importLine = state.isESM ? IMPORT_LINE_ESM : IMPORT_LINE_CJS;
+    const disabledRoutePaths = state.tools
+        .filter((t) => t.source === "route" && !t.enabled)
+        .map((t) => t.path);
+    const enabledRoutePaths = new Set(state.tools
+        .filter((t) => t.source === "route" && t.enabled)
+        .map((t) => t.path));
+    const disabledRoutes = disabledRoutePaths.filter((p) => !enabledRoutePaths.has(p));
+    const disabledTables = new Set();
+    const dbTools = state.tools.filter((t) => t.source === "database");
+    const tableNames = [...new Set(dbTools.map((t) => t.tableName))];
+    for (const tableName of tableNames) {
+        const tableTools = dbTools.filter((t) => t.tableName === tableName);
+        const allDisabled = tableTools.every((t) => !t.enabled);
+        if (allDisabled)
+            disabledTables.add(tableName);
+    }
+    const configParts = [];
+    configParts.push(`app: ${state.appVarName}`);
+    if (disabledRoutes.length > 0) {
+        configParts.push(`excludeRoutes: ${JSON.stringify(disabledRoutes)}`);
+    }
+    if (!state.databaseEnabled) {
+        configParts.push(`database: false`);
+    }
+    else {
+        if (disabledTables.size > 0) {
+            configParts.push(`excludeTables: ${JSON.stringify([...disabledTables])}`);
+        }
+        if (state.includeWrites) {
+            configParts.push(`includeWrites: true`);
+        }
+    }
+    if (!state.enrichmentEnabled) {
+        configParts.push(`enrichment: false`);
+    }
+    let setupCode;
+    if (configParts.length <= 2) {
+        setupCode = `createMcpServer({ ${configParts.join(", ")} });`;
+    }
+    else {
+        const indent = "  ";
+        setupCode = `createMcpServer({\n${configParts.map((p) => `${indent}${p},`).join("\n")}\n});`;
+    }
     const lines = content.split("\n");
     let lastImportIndex = -1;
     for (let i = 0; i < lines.length; i++) {
@@ -97,8 +435,7 @@ function injectMcpSetup(filePath, root) {
             lastImportIndex = i;
         }
     }
-    const insertImportAt = lastImportIndex + 1;
-    lines.splice(insertImportAt, 0, importLine);
+    lines.splice(lastImportIndex + 1, 0, importLine);
     let listenIndex = -1;
     for (let i = lines.length - 1; i >= 0; i--) {
         if (LISTEN_PATTERN.test(lines[i])) {
@@ -106,72 +443,140 @@ function injectMcpSetup(filePath, root) {
             break;
         }
     }
+    const commentLine = `// MCP server - exposes your API to AI assistants (Claude, ChatGPT, Cursor)`;
     if (listenIndex >= 0) {
-        lines.splice(listenIndex, 0, "", `// MCP server - auto-discovered from your Express routes and database`, setupCode);
+        lines.splice(listenIndex, 0, "", commentLine, setupCode);
     }
     else {
-        lines.push("");
-        lines.push(`// MCP server - auto-discovered from your Express routes and database`);
-        lines.push(setupCode);
+        lines.push("", commentLine, setupCode);
     }
-    fs.writeFileSync(filePath, lines.join("\n"));
-    return {
-        success: true,
-        message: `Added MCP setup to ${path.relative(root, filePath)}`,
+    fs.writeFileSync(state.entryFile, lines.join("\n"));
+    const relPath = path.relative(state.root, state.entryFile);
+    const enabledCount = state.tools.filter((t) => t.enabled).length;
+    console.log(`  ${c("green", "+")} Updated ${c("bold", relPath)}`);
+    console.log();
+    console.log(`  ${c("dim", "  Configuration:")}`);
+    console.log(`    Tools enabled:     ${c("bold", String(enabledCount))}`);
+    console.log(`    Database:          ${state.databaseEnabled ? c("green", "enabled") : c("dim", "disabled")}`);
+    console.log(`    AI enrichment:     ${state.enrichmentEnabled ? c("green", "enabled") : c("dim", "disabled")}`);
+    console.log(`    Write operations:  ${state.includeWrites ? c("green", "enabled") : c("dim", "disabled")}`);
+    console.log();
+    console.log(`  ${c("bold", "Next steps:")}`);
+    console.log(`    1. Restart your app`);
+    console.log(`    2. Visit ${c("cyan", "http://localhost:3000/mcp")} to see your tools`);
+    console.log(`    3. Connect Claude, ChatGPT, or Cursor to your /mcp endpoint`);
+    console.log();
+    console.log(`  ${c("dim", "Full guide:")} ${c("cyan", "https://mcp-skill-scanner.replit.app/guide")}`);
+    console.log();
+}
+function generateToolName(method, routePath) {
+    const segments = routePath
+        .replace(/^\/api\/?/, "")
+        .split("/")
+        .filter((s) => s && !s.startsWith(":"));
+    const resource = segments.join("_") || "root";
+    const paramSegments = routePath.split("/").filter((s) => s.startsWith(":"));
+    switch (method.toUpperCase()) {
+        case "GET":
+            return paramSegments.length > 0
+                ? `get_${resource}_by_${paramSegments[0].slice(1)}`
+                : `list_${resource}`;
+        case "POST":
+            return `create_${resource}`;
+        case "PUT":
+        case "PATCH":
+            return `update_${resource}`;
+        case "DELETE":
+            return `delete_${resource}`;
+        default:
+            return `${method.toLowerCase()}_${resource}`;
+    }
+}
+function generateToolDescription(method, routePath) {
+    const segments = routePath
+        .replace(/^\/api\/?/, "")
+        .split("/")
+        .filter((s) => s && !s.startsWith(":"));
+    const resource = segments.map((s) => s.replace(/[-_]/g, " ")).join(" ") || "resource";
+    const paramSegments = routePath.split("/").filter((s) => s.startsWith(":"));
+    switch (method.toUpperCase()) {
+        case "GET":
+            return paramSegments.length > 0
+                ? `Get ${resource} by ${paramSegments[0].slice(1)}`
+                : `List all ${resource}`;
+        case "POST":
+            return `Create a new ${resource}`;
+        case "PUT":
+        case "PATCH":
+            return `Update ${resource}`;
+        case "DELETE":
+            return `Delete ${resource}`;
+        default:
+            return `${method} ${resource}`;
+    }
+}
+function formatTableName(name) {
+    return name.replace(/_/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+}
+async function runWizard(specifiedFile) {
+    printHeader();
+    const prompt = createPrompt();
+    const state = {
+        root: findProjectRoot(),
+        entryFile: "",
+        appVarName: "app",
+        isESM: false,
+        routePrefix: "/api",
+        routes: [],
+        dbTables: [],
+        tools: [],
+        databaseEnabled: true,
+        enrichmentEnabled: true,
+        includeWrites: false,
     };
+    try {
+        const found = await stepDetectApp(state, prompt, specifiedFile);
+        if (!found) {
+            prompt.close();
+            return;
+        }
+        await stepScanRoutes(state);
+        await stepScanDatabase(state, prompt);
+        await stepEnrichAndReview(state, prompt);
+        await stepGenerate(state);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes("readline was closed")) {
+            console.log(`\n  ${c("dim", "Setup cancelled.")}\n`);
+        }
+        else {
+            throw err;
+        }
+    }
+    finally {
+        prompt.close();
+    }
 }
 function main() {
     const args = process.argv.slice(2);
     if (args[0] !== "init") {
         console.log(`
-  @hellocrossman/mcp-sdk CLI
+  ${c("bold", "@hellocrossman/mcp-sdk")}
 
   Usage:
-    npx @hellocrossman/mcp-sdk init    Auto-detect Express app and add MCP server
+    npx @hellocrossman/mcp-sdk init    Interactive setup wizard
 
   Options:
     --file <path>                      Specify the Express app file manually
 `);
         return;
     }
-    console.log("\n  @hellocrossman/mcp-sdk\n");
-    console.log("  Setting up MCP server...\n");
-    const root = findProjectRoot();
     const fileArgIndex = args.indexOf("--file");
-    let entryFile = null;
-    if (fileArgIndex >= 0 && args[fileArgIndex + 1]) {
-        const specified = path.resolve(root, args[fileArgIndex + 1]);
-        if (fs.existsSync(specified)) {
-            entryFile = specified;
-        }
-        else {
-            console.error(`  Error: File not found: ${args[fileArgIndex + 1]}`);
-            process.exit(1);
-        }
-    }
-    else {
-        entryFile = findExpressEntryFile(root);
-    }
-    if (!entryFile) {
-        console.error("  Could not find an Express app file.");
-        console.error("  Try: npx @hellocrossman/mcp-sdk init --file server/index.ts\n");
-        process.exit(1);
-    }
-    console.log(`  Found Express app: ${path.relative(root, entryFile)}`);
-    const result = injectMcpSetup(entryFile, root);
-    if (result.success) {
-        console.log(`  ${result.message}`);
-        console.log("");
-        console.log("  Your MCP server will be available at /mcp when you start your app.");
-        console.log("  It auto-discovers Express routes and database tables.");
-        console.log("  Sensitive tables (users, sessions, etc.) are hidden by default.");
-        console.log("");
-        console.log("  Restart your app to see it in action.\n");
-    }
-    else {
-        console.error(`  Error: ${result.message}\n`);
+    const specifiedFile = fileArgIndex >= 0 ? args[fileArgIndex + 1] : undefined;
+    runWizard(specifiedFile).catch((err) => {
+        console.error(`\n  Error: ${err instanceof Error ? err.message : String(err)}\n`);
         process.exit(1);
-    }
+    });
 }
 main();
 //# sourceMappingURL=cli.js.map