@mkrlbs/mcp-adonisjs 1.0.2 → 1.1.1

package/src/index.ts

@@ -1,264 +1,480 @@
 #!/usr/bin/env node
-
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
+    CallToolRequestSchema,
+    ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
 import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
 
 /**
  * Blacklisted commands that are considered dangerous
  */
 const BLACKLISTED_COMMANDS = [
-  "db:wipe",
-  "migration:fresh",
-  "migration:refresh",
-  "migration:reset",
+    "migration:fresh",
 ];
 
 /**
  * Shell injection characters that are not allowed in command arguments
  */
-const SHELL_INJECTION_PATTERN = /[;&|`$(){}[\]<>\\]/;
+const SHELL_INJECTION_PATTERN = /[;&|`$<>\\]/;
 
 /**
  * Validates that command arguments don't contain shell injection characters
  */
 function validateArguments(args: string[]): void {
-  for (const arg of args) {
-    if (SHELL_INJECTION_PATTERN.test(arg)) {
-      throw new Error(
-        `Invalid argument "${arg}": contains potentially dangerous characters`
-      );
+    for (const arg of args) {
+        if (SHELL_INJECTION_PATTERN.test(arg)) {
+            throw new Error(
+                `Invalid argument "${arg}": contains potentially dangerous characters`
+            );
+        }
     }
-  }
 }
 
 /**
  * Checks if a command is blacklisted
  */
 function isBlacklisted(command: string): boolean {
-  return BLACKLISTED_COMMANDS.includes(command);
+    return BLACKLISTED_COMMANDS.includes(command);
 }
 
 /**
- * Executes an Ace command safely
+ * Verify that we are in an AdonisJS project
  */
-function executeAceCommand(command: string, args: string[] = []): string {
-  // Check blacklist
-  if (isBlacklisted(command)) {
-    throw new Error(
-      `Command "${command}" is blacklisted for security reasons. Blocked commands: ${BLACKLISTED_COMMANDS.join(", ")}`
-    );
-  }
-
-  // Validate arguments
-  validateArguments(args);
-
-  // Build the command
-  const fullCommand = `node ace ${command} ${args.join(" ")}`.trim();
-
-  try {
-    const output = execSync(fullCommand, {
-      cwd: process.cwd(),
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    return output;
-  } catch (error: any) {
-    throw new Error(
-      `Command execution failed: ${error.message}\nStderr: ${error.stderr || "N/A"}`
-    );
-  }
+function verifyAdonisProject(): void {
+    const acePath = path.join(process.cwd(), "ace");
+    const aceJsPath = path.join(process.cwd(), "ace.js");
+
+    if (!fs.existsSync(acePath) && !fs.existsSync(aceJsPath)) {
+        throw new Error(
+            `AdonisJS 'ace' entry point not found in current directory (${process.cwd()}).\n` +
+            `Please ensure the MCP server is running in the root of your AdonisJS project.`
+        );
+    }
 }
 
 /**
- * Schema definitions for tool arguments
+ * Executes an Ace command safely
  */
+function executeAceCommand(command: string, args: string[] = []): string {
+    verifyAdonisProject();
+
+    if (isBlacklisted(command)) {
+        throw new Error(
+            `Command "${command}" is blacklisted for security reasons. Blocked commands: ${BLACKLISTED_COMMANDS.join(", ")}`
+        );
+    }
+
+    validateArguments(args);
+
+    const fullCommand = `node ace ${command} ${args.join(" ")}`.trim();
+
+    try {
+        const output = execSync(fullCommand, {
+            cwd: process.cwd(),
+            encoding: "utf-8",
+            timeout: 30_000,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        return output;
+    } catch (error: any) {
+        throw new Error(
+            `Command execution failed: ${error.message}\nStderr: ${error.stderr || "N/A"}`
+        );
+    }
+}
+
+// ─── Schema Definitions ─────────────────────────────────────────────────────
+
 const MakeControllerArgsSchema = z.object({
-  name: z.string().describe("Name of the controller to create"),
-  resource: z
-    .boolean()
-    .optional()
-    .default(false)
-    .describe("Whether to create a resource controller"),
+    name: z.string().describe("Name of the controller to create"),
+    resource: z.boolean().optional().default(false).describe("Whether to create a resource controller"),
 });
 
 const MakeServiceArgsSchema = z.object({
-  name: z.string().describe("Name of the service to create"),
+    name: z.string().describe("Name of the service to create"),
+});
+
+const MakeMigrationArgsSchema = z.object({
+    name: z.string().describe("Name of the migration (e.g., 'create_projects_table')"),
+    withModel: z.boolean().optional().default(false).describe("Also create the corresponding model (-m flag)"),
+});
+
+const MakeModelArgsSchema = z.object({
+    name: z.string().describe("Name of the model to create (e.g., 'Project')"),
+});
+
+const MakeValidatorArgsSchema = z.object({
+    name: z.string().describe("Name of the validator to create (e.g., 'project')"),
+});
+
+const MakeSeederArgsSchema = z.object({
+    name: z.string().describe("Name of the seeder to create (e.g., 'project')"),
+});
+
+const MakeExceptionArgsSchema = z.object({
+    name: z.string().describe("Name of the exception to create (e.g., 'UnauthorizedException')"),
+});
+
+const MakeMiddlewareArgsSchema = z.object({
+    name: z.string().describe("Name of the middleware to create (e.g., 'auth')"),
+});
+
+const MakeTestArgsSchema = z.object({
+    name: z.string().describe("Name of the test file to create (e.g., 'users/list')"),
+    suite: z.enum(["unit", "functional", "browser"]).optional().describe("Test suite to create the test in"),
+});
+
+const MakeFactoryArgsSchema = z.object({
+    name: z.string().describe("Name of the factory to create (e.g., 'User')"),
+});
+
+const MakePolicyArgsSchema = z.object({
+    name: z.string().describe("Name of the policy to create (e.g., 'project')"),
+});
+
+const MakeEventArgsSchema = z.object({
+    name: z.string().describe("Name of the event to create (e.g., 'UserRegistered')"),
+});
+
+const MakeListenerArgsSchema = z.object({
+    name: z.string().describe("Name of the listener to create (e.g., 'SendWelcomeEmail')"),
+});
+
+const MakeMailerArgsSchema = z.object({
+    name: z.string().describe("Name of the mailer to create (e.g., 'VerificationMailer')"),
+});
+
+const MakeCommandArgsSchema = z.object({
+    name: z.string().describe("Name of the command to create (e.g., 'SyncUsers')"),
+});
+
+const MigrationRunArgsSchema = z.object({
+    force: z.boolean().optional().default(false).describe("Force run in production"),
+});
+
+const MigrationRollbackArgsSchema = z.object({
+    batch: z.number().optional().describe("Batch number to rollback to (default: last batch)"),
+});
+
+const DbSeedArgsSchema = z.object({
+    files: z.string().optional().describe("Specific seeder file to run (e.g., 'database/seeders/user_seeder')"),
 });
 
 const RunAceCommandArgsSchema = z.object({
-  command: z.string().describe("The Ace command to run (e.g., 'make:model')"),
-  args: z
-    .array(z.string())
-    .optional()
-    .default([])
-    .describe("Arguments to pass to the command"),
+    command: z.string().describe("The Ace command to run (e.g., 'make:model')"),
+    args: z.array(z.string()).optional().default([]).describe("Arguments to pass to the command"),
 });
 
-/**
- * Initialize the MCP server
- */
-const server = new Server(
-  {
-    name: "adonisjs-mcp-server",
-    version: "0.1.0",
-  },
-  {
-    capabilities: {
-      tools: {},
-    },
-  }
-);
+// ─── Tool Definitions ────────────────────────────────────────────────────────
 
-/**
- * Handler for listing available tools
- */
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
+interface ToolDef {
+    name: string;
+    description: string;
+    inputSchema: Record<string, any>;
+}
+
+function simpleNameTool(name: string, description: string, paramDesc: string): ToolDef {
+    return {
+        name,
+        description,
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: paramDesc },
+            },
+            required: ["name"],
+        },
+    };
+}
+
+const TOOLS: ToolDef[] = [
+    {
         name: "make_controller",
-        description:
-          "Creates an AdonisJS controller using the 'node ace make:controller' command",
+        description: "Creates an AdonisJS controller using 'node ace make:controller'",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the controller to create" },
+                resource: { type: "boolean", description: "Whether to create a resource controller", default: false },
+            },
+            required: ["name"],
+        },
+    },
+    simpleNameTool("make_service", "Creates an AdonisJS service using 'node ace make:service'", "Name of the service"),
+    {
+        name: "make_migration",
+        description: "Creates an AdonisJS migration using 'node ace make:migration'. Use withModel to also create the model (-m flag).",
         inputSchema: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Name of the controller to create",
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the migration (e.g., 'create_projects_table')" },
+                withModel: { type: "boolean", description: "Also create the corresponding model (-m flag)", default: false },
             },
-            resource: {
-              type: "boolean",
-              description: "Whether to create a resource controller",
-              default: false,
+            required: ["name"],
+        },
+    },
+    simpleNameTool("make_model", "Creates an AdonisJS Lucid model using 'node ace make:model'", "Name of the model (e.g., 'Project')"),
+    simpleNameTool("make_validator", "Creates an AdonisJS VineJS validator using 'node ace make:validator'", "Name of the validator (e.g., 'project')"),
+    simpleNameTool("make_seeder", "Creates an AdonisJS database seeder using 'node ace make:seeder'", "Name of the seeder (e.g., 'project')"),
+    simpleNameTool("make_exception", "Creates an AdonisJS custom exception using 'node ace make:exception'", "Name of the exception (e.g., 'UnauthorizedException')"),
+    simpleNameTool("make_middleware", "Creates an AdonisJS middleware using 'node ace make:middleware'", "Name of the middleware (e.g., 'auth')"),
+    {
+        name: "make_test",
+        description: "Creates a Japa test file using 'node ace make:test'",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Name of the test (e.g., 'users/list')" },
+                suite: { type: "string", enum: ["unit", "functional", "browser"], description: "Test suite" },
             },
-          },
-          required: ["name"],
+            required: ["name"],
         },
-      },
-      {
-        name: "make_service",
-        description:
-          "Creates an AdonisJS service using the 'node ace make:service' command",
+    },
+    simpleNameTool("make_factory", "Creates a Lucid model factory using 'node ace make:factory'", "Name of the factory (e.g., 'User')"),
+    simpleNameTool("make_policy", "Creates a bouncer policy using 'node ace make:policy'", "Name of the policy (e.g., 'project')"),
+    simpleNameTool("make_event", "Creates an AdonisJS event using 'node ace make:event'", "Name of the event (e.g., 'UserRegistered')"),
+    simpleNameTool("make_listener", "Creates an AdonisJS event listener using 'node ace make:listener'", "Name of the listener (e.g., 'SendWelcomeEmail')"),
+    simpleNameTool("make_mailer", "Creates an AdonisJS mailer using 'node ace make:mailer'", "Name of the mailer (e.g., 'VerificationMailer')"),
+    simpleNameTool("make_command", "Creates an AdonisJS Ace command using 'node ace make:command'", "Name of the command (e.g., 'SyncUsers')"),
+    {
+        name: "migration_run",
+        description: "Runs pending database migrations using 'node ace migration:run'. Auto-generates database/schema.ts.",
         inputSchema: {
-          type: "object",
-          properties: {
-            name: {
-              type: "string",
-              description: "Name of the service to create",
+            type: "object",
+            properties: {
+                force: { type: "boolean", description: "Force run in production", default: false },
             },
-          },
-          required: ["name"],
         },
-      },
-      {
-        name: "run_ace_command",
-        description:
-          "Executes an AdonisJS Ace command with security checks. Blacklisted commands: " +
-          BLACKLISTED_COMMANDS.join(", "),
+    },
+    {
+        name: "migration_rollback",
+        description: "Rolls back the last batch of migrations using 'node ace migration:rollback'",
         inputSchema: {
-          type: "object",
-          properties: {
-            command: {
-              type: "string",
-              description: "The Ace command to run (e.g., 'make:model')",
+            type: "object",
+            properties: {
+                batch: { type: "number", description: "Batch number to rollback to (default: last batch)" },
             },
-            args: {
-              type: "array",
-              items: {
-                type: "string",
-              },
-              description: "Arguments to pass to the command",
-              default: [],
+        },
+    },
+    {
+        name: "migration_status",
+        description: "Shows the status of all migrations using 'node ace migration:status'",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "db_seed",
+        description: "Runs database seeders using 'node ace db:seed'",
+        inputSchema: {
+            type: "object",
+            properties: {
+                files: { type: "string", description: "Specific seeder file to run (e.g., 'database/seeders/user_seeder')" },
             },
-          },
-          required: ["command"],
         },
-      },
-    ],
-  };
+    },
+    {
+        name: "list_routes",
+        description: "Lists all registered routes using 'node ace list:routes'",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "run_ace_command",
+        description: "Executes any AdonisJS Ace command with security checks. Use this for commands without a dedicated tool. Blacklisted: " + BLACKLISTED_COMMANDS.join(", "),
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The Ace command to run" },
+                args: { type: "array", items: { type: "string" }, description: "Arguments to pass", default: [] },
+            },
+            required: ["command"],
+        },
+    },
+];
+
+// ─── Server Setup ────────────────────────────────────────────────────────────
+
+const server = new Server(
+    { name: "adonisjs-mcp-server", version: "1.1.1" },
+    { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: TOOLS };
 });
 
-/**
- * Handler for executing tools
- */
+// ─── Tool Handlers ───────────────────────────────────────────────────────────
+
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  try {
-    const { name, arguments: args } = request.params;
-
-    switch (name) {
-      case "make_controller": {
-        const parsed = MakeControllerArgsSchema.parse(args);
-        const commandArgs = parsed.resource ? [parsed.name, "--resource"] : [parsed.name];
-        const output = executeAceCommand("make:controller", commandArgs);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Controller created successfully:\n${output}`,
-            },
-          ],
-        };
-      }
+    try {
+        const { name, arguments: args } = request.params;
 
-      case "make_service": {
-        const parsed = MakeServiceArgsSchema.parse(args);
-        const output = executeAceCommand("make:service", [parsed.name]);
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Service created successfully:\n${output}`,
-            },
-          ],
-        };
-      }
+        switch (name) {
+            case "make_controller": {
+                const parsed = MakeControllerArgsSchema.parse(args);
+                const cmdArgs = parsed.resource ? [parsed.name, "--resource"] : [parsed.name];
+                const output = executeAceCommand("make:controller", cmdArgs);
+                return { content: [{ type: "text", text: `Controller created successfully:\n${output}` }] };
+            }
+
+            case "make_service": {
+                const parsed = MakeServiceArgsSchema.parse(args);
+                const output = executeAceCommand("make:service", [parsed.name]);
+                return { content: [{ type: "text", text: `Service created successfully:\n${output}` }] };
+            }
+
+            case "make_migration": {
+                const parsed = MakeMigrationArgsSchema.parse(args);
+                const cmdArgs = parsed.withModel ? [parsed.name, "-m"] : [parsed.name];
+                const output = executeAceCommand("make:migration", cmdArgs);
+                return { content: [{ type: "text", text: `Migration created successfully:\n${output}` }] };
+            }
+
+            case "make_model": {
+                const parsed = MakeModelArgsSchema.parse(args);
+                const output = executeAceCommand("make:model", [parsed.name]);
+                return { content: [{ type: "text", text: `Model created successfully:\n${output}` }] };
+            }
+
+            case "make_validator": {
+                const parsed = MakeValidatorArgsSchema.parse(args);
+                const output = executeAceCommand("make:validator", [parsed.name]);
+                return { content: [{ type: "text", text: `Validator created successfully:\n${output}` }] };
+            }
+
+            case "make_seeder": {
+                const parsed = MakeSeederArgsSchema.parse(args);
+                const output = executeAceCommand("make:seeder", [parsed.name]);
+                return { content: [{ type: "text", text: `Seeder created successfully:\n${output}` }] };
+            }
+
+            case "make_exception": {
+                const parsed = MakeExceptionArgsSchema.parse(args);
+                const output = executeAceCommand("make:exception", [parsed.name]);
+                return { content: [{ type: "text", text: `Exception created successfully:\n${output}` }] };
+            }
+
+            case "make_middleware": {
+                const parsed = MakeMiddlewareArgsSchema.parse(args);
+                const output = executeAceCommand("make:middleware", [parsed.name]);
+                return { content: [{ type: "text", text: `Middleware created successfully:\n${output}` }] };
+            }
+
+            case "make_test": {
+                const parsed = MakeTestArgsSchema.parse(args);
+                const cmdArgs = [parsed.name];
+                if (parsed.suite) cmdArgs.push("--suite", parsed.suite);
+                const output = executeAceCommand("make:test", cmdArgs);
+                return { content: [{ type: "text", text: `Test created successfully:\n${output}` }] };
+            }
+
+            case "make_factory": {
+                const parsed = MakeFactoryArgsSchema.parse(args);
+                const output = executeAceCommand("make:factory", [parsed.name]);
+                return { content: [{ type: "text", text: `Factory created successfully:\n${output}` }] };
+            }
+
+            case "make_policy": {
+                const parsed = MakePolicyArgsSchema.parse(args);
+                const output = executeAceCommand("make:policy", [parsed.name]);
+                return { content: [{ type: "text", text: `Policy created successfully:\n${output}` }] };
+            }
+
+            case "make_event": {
+                const parsed = MakeEventArgsSchema.parse(args);
+                const output = executeAceCommand("make:event", [parsed.name]);
+                return { content: [{ type: "text", text: `Event created successfully:\n${output}` }] };
+            }
+
+            case "make_listener": {
+                const parsed = MakeListenerArgsSchema.parse(args);
+                const output = executeAceCommand("make:listener", [parsed.name]);
+                return { content: [{ type: "text", text: `Listener created successfully:\n${output}` }] };
+            }
+
+            case "make_mailer": {
+                const parsed = MakeMailerArgsSchema.parse(args);
+                const output = executeAceCommand("make:mailer", [parsed.name]);
+                return { content: [{ type: "text", text: `Mailer created successfully:\n${output}` }] };
+            }
+
+            case "make_command": {
+                const parsed = MakeCommandArgsSchema.parse(args);
+                const output = executeAceCommand("make:command", [parsed.name]);
+                return { content: [{ type: "text", text: `Command created successfully:\n${output}` }] };
+            }
 
-      case "run_ace_command": {
-        const parsed = RunAceCommandArgsSchema.parse(args);
-        const output = executeAceCommand(parsed.command, parsed.args);
+            case "migration_run": {
+                const parsed = MigrationRunArgsSchema.parse(args);
+                const cmdArgs = parsed.force ? ["--force"] : [];
+                const output = executeAceCommand("migration:run", cmdArgs);
+                return { content: [{ type: "text", text: `Migrations executed successfully:\n${output}` }] };
+            }
+
+            case "migration_rollback": {
+                const parsed = MigrationRollbackArgsSchema.parse(args);
+                const cmdArgs = parsed.batch ? ["--batch", String(parsed.batch)] : [];
+                const output = executeAceCommand("migration:rollback", cmdArgs);
+                return { content: [{ type: "text", text: `Rollback completed:\n${output}` }] };
+            }
+
+            case "migration_status": {
+                const output = executeAceCommand("migration:status");
+                return { content: [{ type: "text", text: `Migration status:\n${output}` }] };
+            }
+
+            case "db_seed": {
+                const parsed = DbSeedArgsSchema.parse(args);
+                const cmdArgs = parsed.files ? ["--files", parsed.files] : [];
+                const output = executeAceCommand("db:seed", cmdArgs);
+                return { content: [{ type: "text", text: `Seeding completed:\n${output}` }] };
+            }
+
+            case "list_routes": {
+                const output = executeAceCommand("list:routes");
+                return { content: [{ type: "text", text: `Routes:\n${output}` }] };
+            }
+
+            case "run_ace_command": {
+                const parsed = RunAceCommandArgsSchema.parse(args);
+                const output = executeAceCommand(parsed.command, parsed.args);
+                return { content: [{ type: "text", text: `Command executed successfully:\n${output}` }] };
+            }
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    } catch (error: any) {
         return {
-          content: [
-            {
-              type: "text",
-              text: `Command executed successfully:\n${output}`,
-            },
-          ],
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
         };
-      }
-
-      default:
-        throw new Error(`Unknown tool: ${name}`);
     }
-  } catch (error: any) {
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Error: ${error.message}`,
-        },
-      ],
-      isError: true,
-    };
-  }
 });
 
-/**
- * Start the server
- */
+// ─── Start ───────────────────────────────────────────────────────────────────
+
 async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  // Use stderr for logging since stdout is used for MCP protocol communication
-  console.error("AdonisJS MCP Server running on stdio");
+    const targetCwd = process.env.cwd || process.env.CWD;
+    if (targetCwd) {
+        try {
+            process.chdir(targetCwd);
+            console.error(`Changed working directory to: ${targetCwd}`);
+        } catch (err) {
+            console.error(`Failed to change working directory to ${targetCwd}:`, err);
+        }
+    }
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("AdonisJS MCP Server running on stdio");
+    console.error(`Current working directory: ${process.cwd()}`);
 }
 
 main().catch((error) => {
-  console.error("Fatal error:", error);
-  process.exit(1);
+    console.error("Fatal error:", error);
+    process.exit(1);
 });