@intentius/chant 0.0.1

package/src/cli/mcp/server.ts

@@ -0,0 +1,402 @@
+import { createInterface } from "readline";
+import { resolve } from "node:path";
+import { buildTool, handleBuild } from "./tools/build";
+import { lintTool, handleLint } from "./tools/lint";
+import { importTool, handleImport } from "./tools/import";
+import { getContext } from "./resources/context";
+import type { LexiconPlugin } from "../../lexicon";
+import type { McpToolContribution, McpResourceContribution } from "../../mcp/types";
+
+/**
+ * MCP message types
+ */
+interface McpRequest {
+  jsonrpc: "2.0";
+  id: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface McpResponse {
+  jsonrpc: "2.0";
+  id: string | number;
+  result?: unknown;
+  error?: {
+    code: number;
+    message: string;
+    data?: unknown;
+  };
+}
+
+interface McpNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+/**
+ * Tool definition for MCP
+ */
+interface ToolDefinition {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+/**
+ * Resource definition for MCP
+ */
+interface ResourceDefinition {
+  uri: string;
+  name: string;
+  description: string;
+  mimeType?: string;
+}
+
+/**
+ * MCP Server implementation
+ */
+export class McpServer {
+  private tools: Map<string, ToolDefinition> = new Map();
+  private toolHandlers: Map<string, (params: Record<string, unknown>) => Promise<unknown>> = new Map();
+  private pluginResources: Map<string, { definition: ResourceDefinition; handler: () => Promise<string> }> = new Map();
+
+  constructor(plugins?: LexiconPlugin[]) {
+    // Register core tools
+    this.registerTool(buildTool, handleBuild);
+    this.registerTool(lintTool, handleLint);
+    this.registerTool(importTool, handleImport);
+
+    // Register plugin contributions
+    if (plugins) {
+      for (const plugin of plugins) {
+        this.registerPluginTools(plugin);
+        this.registerPluginResources(plugin);
+      }
+    }
+  }
+
+  /**
+   * Register tools contributed by a plugin, namespaced as `lexicon:toolName`
+   */
+  private registerPluginTools(plugin: LexiconPlugin): void {
+    const tools = plugin.mcpTools?.() ?? [];
+    for (const tool of tools) {
+      const namespacedName = `${plugin.name}:${tool.name}`;
+      this.registerTool(
+        {
+          name: namespacedName,
+          description: tool.description,
+          inputSchema: tool.inputSchema,
+        },
+        tool.handler,
+      );
+    }
+  }
+
+  /**
+   * Register resources contributed by a plugin, namespaced as `chant://lexicon/uri`
+   */
+  private registerPluginResources(plugin: LexiconPlugin): void {
+    const resources = plugin.mcpResources?.() ?? [];
+    for (const resource of resources) {
+      const namespacedUri = `chant://${plugin.name}/${resource.uri}`;
+      this.pluginResources.set(namespacedUri, {
+        definition: {
+          uri: namespacedUri,
+          name: resource.name,
+          description: resource.description,
+          mimeType: resource.mimeType,
+        },
+        handler: resource.handler,
+      });
+    }
+  }
+
+  /**
+   * Register a tool with its handler
+   */
+  private registerTool(
+    definition: ToolDefinition,
+    handler: (params: Record<string, unknown>) => Promise<unknown>
+  ): void {
+    this.tools.set(definition.name, definition);
+    this.toolHandlers.set(definition.name, handler);
+  }
+
+  /**
+   * Handle incoming MCP request
+   */
+  async handleRequest(request: McpRequest): Promise<McpResponse> {
+    try {
+      const result = await this.dispatch(request.method, request.params ?? {});
+      return {
+        jsonrpc: "2.0",
+        id: request.id,
+        result,
+      };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: request.id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error),
+        },
+      };
+    }
+  }
+
+  /**
+   * Dispatch request to appropriate handler
+   */
+  private async dispatch(method: string, params: Record<string, unknown>): Promise<unknown> {
+    switch (method) {
+      case "initialize":
+        return this.handleInitialize(params);
+
+      case "tools/list":
+        return this.handleToolsList();
+
+      case "tools/call":
+        return this.handleToolsCall(params);
+
+      case "resources/list":
+        return this.handleResourcesList();
+
+      case "resources/read":
+        return this.handleResourcesRead(params);
+
+      default:
+        throw new Error(`Unknown method: ${method}`);
+    }
+  }
+
+  /**
+   * Handle initialize request
+   */
+  private handleInitialize(params: Record<string, unknown>): unknown {
+    return {
+      protocolVersion: "2024-11-05",
+      capabilities: {
+        tools: {},
+        resources: {},
+      },
+      serverInfo: {
+        name: "chant",
+        version: "0.1.0",
+      },
+    };
+  }
+
+  /**
+   * Handle tools/list request
+   */
+  private handleToolsList(): unknown {
+    return {
+      tools: Array.from(this.tools.values()),
+    };
+  }
+
+  /**
+   * Handle tools/call request
+   */
+  private async handleToolsCall(params: Record<string, unknown>): Promise<unknown> {
+    const name = params.name as string;
+    const toolParams = (params.arguments ?? {}) as Record<string, unknown>;
+
+    const handler = this.toolHandlers.get(name);
+    if (!handler) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Unknown tool: ${name}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+
+    try {
+      const result = await handler(toolParams);
+      return {
+        content: [
+          {
+            type: "text",
+            text: typeof result === "string" ? result : JSON.stringify(result, null, 2),
+          },
+        ],
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  /**
+   * Handle resources/list request — merges core + plugin resources
+   */
+  private handleResourcesList(): unknown {
+    const resources: ResourceDefinition[] = [
+      {
+        uri: "chant://context",
+        name: "chant Context",
+        description: "Lexicon-specific instructions and patterns for chant development",
+        mimeType: "text/markdown",
+      },
+      {
+        uri: "chant://examples/list",
+        name: "Examples List",
+        description: "List of available chant examples",
+        mimeType: "application/json",
+      },
+    ];
+
+    // Merge plugin resources
+    for (const { definition } of this.pluginResources.values()) {
+      resources.push(definition);
+    }
+
+    return { resources };
+  }
+
+  /**
+   * Collect example resources from plugins whose URI contains "examples/"
+   */
+  private collectExamples(): Array<{ name: string; description: string }> {
+    const examples: Array<{ name: string; description: string }> = [];
+    for (const [uri, { definition }] of this.pluginResources.entries()) {
+      if (uri.includes("/examples/")) {
+        const name = uri.replace(/^chant:\/\/[^/]+\/examples\//, "");
+        examples.push({ name, description: definition.description });
+      }
+    }
+    return examples;
+  }
+
+  /**
+   * Handle resources/read request — checks plugin resources after core
+   */
+  private async handleResourcesRead(params: Record<string, unknown>): Promise<unknown> {
+    const uri = params.uri as string;
+
+    if (uri === "chant://context") {
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/markdown",
+            text: getContext(),
+          },
+        ],
+      };
+    }
+
+    if (uri === "chant://examples/list") {
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "application/json",
+            text: JSON.stringify(this.collectExamples()),
+          },
+        ],
+      };
+    }
+
+    if (uri.startsWith("chant://examples/")) {
+      // Look up example in plugin resources
+      const name = uri.replace("chant://examples/", "");
+      for (const [pluginUri, pluginResource] of this.pluginResources.entries()) {
+        if (pluginUri.endsWith(`/examples/${name}`)) {
+          const text = await pluginResource.handler();
+          return {
+            contents: [
+              {
+                uri,
+                mimeType: pluginResource.definition.mimeType ?? "text/typescript",
+                text,
+              },
+            ],
+          };
+        }
+      }
+      throw new Error(`Example not found: ${name}`);
+    }
+
+    // Check plugin resources
+    const pluginResource = this.pluginResources.get(uri);
+    if (pluginResource) {
+      const text = await pluginResource.handler();
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: pluginResource.definition.mimeType ?? "text/plain",
+            text,
+          },
+        ],
+      };
+    }
+
+    throw new Error(`Unknown resource: ${uri}`);
+  }
+
+  /**
+   * Start the MCP server on stdio
+   */
+  async start(): Promise<void> {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false,
+    });
+
+    rl.on("line", async (line) => {
+      try {
+        const request = JSON.parse(line) as McpRequest;
+        const response = await this.handleRequest(request);
+        console.log(JSON.stringify(response));
+      } catch (error) {
+        const errorResponse: McpResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: {
+            code: -32700,
+            message: "Parse error",
+          },
+        };
+        console.log(JSON.stringify(errorResponse));
+      }
+    });
+  }
+}
+
+/**
+ * Start MCP server, loading plugins from the project
+ */
+export async function startMcpServer(): Promise<void> {
+  let plugins: LexiconPlugin[] = [];
+  try {
+    const { resolveProjectLexicons, loadPlugins } = await import("../plugins");
+    const lexiconNames = await resolveProjectLexicons(resolve("."));
+    plugins = await loadPlugins(lexiconNames);
+  } catch {
+    // Start without plugins if resolution fails
+  }
+
+  const server = new McpServer(plugins);
+  server.start();
+}

package/src/cli/mcp/tools/build.ts

@@ -0,0 +1,117 @@
+import { build } from "../../../build";
+import { resolve } from "path";
+
+// Default lexicon serializer for MCP builds (fallback when no lexicon is detected)
+const defaultLexicon = {
+  name: "default",
+  rulePrefix: "DF",
+  serialize(entities: Map<string, unknown>): string {
+    const output: Record<string, unknown> = {};
+    for (const [name, entity] of entities) {
+      output[name] = entity;
+    }
+    return JSON.stringify(output, null, 2);
+  },
+};
+
+/**
+ * Build tool definition for MCP
+ */
+export const buildTool = {
+  name: "build",
+  description: "Build chant infrastructure code and generate output for the target lexicon",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the infrastructure directory or file to build",
+      },
+      output: {
+        type: "string",
+        description: "Output file path (optional, returns in response if not specified)",
+      },
+      format: {
+        type: "string",
+        enum: ["json", "yaml"],
+        description: "Output format (default: json)",
+      },
+    },
+    required: ["path"],
+  },
+};
+
+/**
+ * Handle build tool invocation
+ */
+export async function handleBuild(params: Record<string, unknown>): Promise<unknown> {
+  const path = params.path as string;
+  const format = (params.format as "json" | "yaml") ?? "json";
+
+  const infraPath = resolve(path);
+  const result = await build(infraPath, [defaultLexicon]);
+
+  if (result.errors.length > 0) {
+    throw new Error(result.errors.map((e) => e.message).join("; "));
+  }
+
+  // Combine all lexicon outputs
+  const combined: Record<string, unknown> = {};
+  for (const [lexiconName, lexiconOutput] of result.outputs) {
+    combined[lexiconName] = JSON.parse(lexiconOutput);
+  }
+
+  let output = JSON.stringify(combined, null, 2);
+  if (format === "yaml") {
+    // Basic YAML conversion
+    output = jsonToYaml(JSON.parse(output));
+  }
+
+  return {
+    success: true,
+    resourceCount: result.entities.size,
+    output,
+    format,
+  };
+}
+
+/**
+ * Simple JSON to YAML converter
+ */
+function jsonToYaml(obj: unknown, indent = 0): string {
+  const spaces = "  ".repeat(indent);
+
+  if (obj === null) return "null";
+  if (obj === undefined) return "~";
+  if (typeof obj === "boolean") return obj ? "true" : "false";
+  if (typeof obj === "number") return String(obj);
+  if (typeof obj === "string") {
+    if (obj.includes("\n") || obj.includes(":") || obj.includes("#")) {
+      return `"${obj.replace(/"/g, '\\"')}"`;
+    }
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    if (obj.length === 0) return "[]";
+    return obj
+      .map((item) => `${spaces}- ${jsonToYaml(item, indent + 1).trimStart()}`)
+      .join("\n");
+  }
+
+  if (typeof obj === "object") {
+    const entries = Object.entries(obj);
+    if (entries.length === 0) return "{}";
+    return entries
+      .map(([key, value]) => {
+        const yamlValue = jsonToYaml(value, indent + 1);
+        if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+          return `${spaces}${key}:\n${yamlValue}`;
+        }
+        return `${spaces}${key}: ${yamlValue.trimStart()}`;
+      })
+      .join("\n");
+  }
+
+  return String(obj);
+}

package/src/cli/mcp/tools/import.ts

@@ -0,0 +1,48 @@
+import { importCommand } from "../../commands/import";
+
+/**
+ * Import tool definition for MCP
+ */
+export const importTool = {
+  name: "import",
+  description: "Import external templates and convert them to chant TypeScript",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      source: {
+        type: "string",
+        description: "Path to the template file to import",
+      },
+      output: {
+        type: "string",
+        description: "Output directory (default: ./infra/)",
+      },
+    },
+    required: ["source"],
+  },
+};
+
+/**
+ * Handle import tool invocation
+ */
+export async function handleImport(params: Record<string, unknown>): Promise<unknown> {
+  const source = params.source as string;
+  const output = params.output as string | undefined;
+
+  const result = await importCommand({
+    templatePath: source,
+    output,
+    force: true,
+  });
+
+  if (!result.success) {
+    throw new Error(result.error ?? "Import failed");
+  }
+
+  return {
+    success: true,
+    lexicon: result.lexicon,
+    generatedFiles: result.generatedFiles,
+    warnings: result.warnings,
+  };
+}

package/src/cli/mcp/tools/lint.ts

@@ -0,0 +1,45 @@
+import { lintCommand } from "../../commands/lint";
+
+/**
+ * Lint tool definition for MCP
+ */
+export const lintTool = {
+  name: "lint",
+  description: "Lint chant infrastructure code and report issues",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the infrastructure directory or file to lint",
+      },
+      fix: {
+        type: "boolean",
+        description: "Automatically fix issues where possible",
+      },
+    },
+    required: ["path"],
+  },
+};
+
+/**
+ * Handle lint tool invocation
+ */
+export async function handleLint(params: Record<string, unknown>): Promise<unknown> {
+  const path = params.path as string;
+  const fix = (params.fix as boolean) ?? false;
+
+  const result = await lintCommand({
+    path,
+    fix,
+    format: "json",
+  });
+
+  return {
+    success: result.success,
+    errorCount: result.errorCount,
+    warningCount: result.warningCount,
+    diagnostics: result.diagnostics,
+    output: result.output,
+  };
+}

package/src/cli/plugins.test.ts

@@ -0,0 +1,31 @@
+import { describe, test, expect } from "bun:test";
+import { loadPlugin, loadPlugins } from "./plugins";
+import { isLexiconPlugin } from "../lexicon";
+
+describe("loadPlugin", () => {
+  test("loads aws plugin with full LexiconPlugin interface", async () => {
+    const plugin = await loadPlugin("aws");
+    expect(isLexiconPlugin(plugin)).toBe(true);
+    expect(plugin.name).toBe("aws");
+    expect(plugin.serializer.name).toBe("aws");
+    expect(typeof plugin.lintRules).toBe("function");
+    expect(typeof plugin.detectTemplate).toBe("function");
+  });
+
+  test("throws for unknown lexicon package", async () => {
+    await expect(loadPlugin("nonexistent")).rejects.toThrow();
+  });
+});
+
+describe("loadPlugins", () => {
+  test("loads multiple plugins", async () => {
+    const plugins = await loadPlugins(["aws"]);
+    expect(plugins).toHaveLength(1);
+    expect(plugins[0].name).toBe("aws");
+  });
+
+  test("returns empty array for no serializers", async () => {
+    const plugins = await loadPlugins([]);
+    expect(plugins).toHaveLength(0);
+  });
+});