@intentius/chant 0.0.1

package/src/cli/lsp/server.ts

@@ -0,0 +1,393 @@
+import type { LexiconPlugin } from "../../lexicon";
+import type { CompletionContext, HoverContext, CodeActionContext } from "../../lsp/types";
+import { computeCapabilities } from "./capabilities";
+import { toLspDiagnostics } from "./diagnostics";
+
+/**
+ * JSON-RPC message types
+ */
+interface JsonRpcRequest {
+  jsonrpc: "2.0";
+  id: string | number;
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+interface JsonRpcResponse {
+  jsonrpc: "2.0";
+  id: string | number;
+  result?: unknown;
+  error?: { code: number; message: string; data?: unknown };
+}
+
+interface JsonRpcNotification {
+  jsonrpc: "2.0";
+  method: string;
+  params?: Record<string, unknown>;
+}
+
+/**
+ * stdio LSP server using Content-Length framing.
+ * Delegates completions, hover, and code actions to lexicon plugins.
+ */
+export class LspServer {
+  private plugins: LexiconPlugin[];
+  openDocuments: Map<string, string> = new Map();
+  private buffer = "";
+  /** Captured notifications for testing — only populated when captureNotifications is true */
+  sentNotifications: Array<{ method: string; params: Record<string, unknown> }> = [];
+  private captureNotifications = false;
+
+  constructor(plugins: LexiconPlugin[], options?: { captureNotifications?: boolean }) {
+    this.plugins = plugins;
+    this.captureNotifications = options?.captureNotifications ?? false;
+  }
+
+  /**
+   * Start reading from stdin with Content-Length framing
+   */
+  async start(): Promise<void> {
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk: string) => {
+      this.buffer += chunk;
+      this.processBuffer();
+    });
+  }
+
+  /**
+   * Process the incoming buffer, extracting complete messages
+   */
+  private processBuffer(): void {
+    while (true) {
+      const headerEnd = this.buffer.indexOf("\r\n\r\n");
+      if (headerEnd === -1) break;
+
+      const header = this.buffer.slice(0, headerEnd);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        // Skip malformed header
+        this.buffer = this.buffer.slice(headerEnd + 4);
+        continue;
+      }
+
+      const contentLength = parseInt(match[1], 10);
+      const messageStart = headerEnd + 4;
+      const messageEnd = messageStart + contentLength;
+
+      if (this.buffer.length < messageEnd) break; // Wait for more data
+
+      const body = this.buffer.slice(messageStart, messageEnd);
+      this.buffer = this.buffer.slice(messageEnd);
+
+      try {
+        const message = JSON.parse(body);
+        if ("id" in message) {
+          this.handleRequest(message as JsonRpcRequest);
+        } else {
+          this.handleNotification(message as JsonRpcNotification);
+        }
+      } catch {
+        // Ignore malformed JSON
+      }
+    }
+  }
+
+  /**
+   * Send a request and return the response directly (for testing).
+   */
+  async sendRequest(method: string, params?: Record<string, unknown>): Promise<JsonRpcResponse> {
+    try {
+      const result = await this.dispatch(method, params ?? {});
+      return { jsonrpc: "2.0", id: 0, result };
+    } catch (error) {
+      return {
+        jsonrpc: "2.0",
+        id: 0,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error),
+        },
+      };
+    }
+  }
+
+  /**
+   * Handle a JSON-RPC request (has id, expects response)
+   */
+  async handleRequest(request: JsonRpcRequest): Promise<void> {
+    try {
+      const result = await this.dispatch(request.method, request.params ?? {});
+      this.sendResponse({ jsonrpc: "2.0", id: request.id, result });
+    } catch (error) {
+      this.sendResponse({
+        jsonrpc: "2.0",
+        id: request.id,
+        error: {
+          code: -32603,
+          message: error instanceof Error ? error.message : String(error),
+        },
+      });
+    }
+  }
+
+  /**
+   * Handle a JSON-RPC notification (no id, no response).
+   * Public to allow direct testing without stdio.
+   */
+  handleNotification(notification: JsonRpcNotification): void {
+    switch (notification.method) {
+      case "initialized":
+        // Client acknowledged initialization
+        break;
+
+      case "textDocument/didOpen": {
+        const params = notification.params as {
+          textDocument: { uri: string; text: string };
+        };
+        this.openDocuments.set(params.textDocument.uri, params.textDocument.text);
+        this.publishDiagnostics(params.textDocument.uri, params.textDocument.text);
+        break;
+      }
+
+      case "textDocument/didChange": {
+        const params = notification.params as {
+          textDocument: { uri: string };
+          contentChanges: Array<{ text: string }>;
+        };
+        // Full sync: take the last content change
+        const text = params.contentChanges[params.contentChanges.length - 1]?.text ?? "";
+        this.openDocuments.set(params.textDocument.uri, text);
+        this.publishDiagnostics(params.textDocument.uri, text);
+        break;
+      }
+
+      case "textDocument/didClose": {
+        const params = notification.params as {
+          textDocument: { uri: string };
+        };
+        this.openDocuments.delete(params.textDocument.uri);
+        // Clear diagnostics for closed document
+        this.sendNotification("textDocument/publishDiagnostics", {
+          uri: params.textDocument.uri,
+          diagnostics: [],
+        });
+        break;
+      }
+    }
+  }
+
+  /**
+   * Dispatch request to appropriate handler
+   */
+  private async dispatch(method: string, params: Record<string, unknown>): Promise<unknown> {
+    switch (method) {
+      case "initialize":
+        return this.handleInitialize();
+
+      case "textDocument/completion":
+        return this.handleCompletion(params);
+
+      case "textDocument/hover":
+        return this.handleHover(params);
+
+      case "textDocument/codeAction":
+        return this.handleCodeAction(params);
+
+      case "textDocument/diagnostic":
+        return this.handleDiagnostic(params);
+
+      case "shutdown":
+        return null;
+
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * Handle initialize request
+   */
+  private handleInitialize(): unknown {
+    return {
+      capabilities: computeCapabilities(this.plugins),
+      serverInfo: {
+        name: "chant",
+        version: "0.1.0",
+      },
+    };
+  }
+
+  /**
+   * Handle textDocument/completion
+   */
+  private handleCompletion(params: Record<string, unknown>): unknown {
+    const textDocument = params.textDocument as { uri: string };
+    const position = params.position as { line: number; character: number };
+    const content = this.openDocuments.get(textDocument.uri) ?? "";
+
+    const lines = content.split("\n");
+    const line = lines[position.line] ?? "";
+    const linePrefix = line.slice(0, position.character);
+
+    // Extract word at cursor
+    const wordMatch = linePrefix.match(/(\w+)$/);
+    const wordAtCursor = wordMatch?.[1] ?? "";
+
+    const ctx: CompletionContext = {
+      uri: textDocument.uri,
+      content,
+      position,
+      wordAtCursor,
+      linePrefix,
+    };
+
+    const items = [];
+    for (const plugin of this.plugins) {
+      if (plugin.completionProvider) {
+        items.push(...plugin.completionProvider(ctx));
+      }
+    }
+
+    return { isIncomplete: false, items };
+  }
+
+  /**
+   * Handle textDocument/hover
+   */
+  private handleHover(params: Record<string, unknown>): unknown {
+    const textDocument = params.textDocument as { uri: string };
+    const position = params.position as { line: number; character: number };
+    const content = this.openDocuments.get(textDocument.uri) ?? "";
+
+    const lines = content.split("\n");
+    const lineText = lines[position.line] ?? "";
+
+    // Extract word at position
+    let start = position.character;
+    let end = position.character;
+    while (start > 0 && /\w/.test(lineText[start - 1])) start--;
+    while (end < lineText.length && /\w/.test(lineText[end])) end++;
+    const word = lineText.slice(start, end);
+
+    const ctx: HoverContext = {
+      uri: textDocument.uri,
+      content,
+      position,
+      word,
+      lineText,
+    };
+
+    // First plugin to return info wins
+    for (const plugin of this.plugins) {
+      if (plugin.hoverProvider) {
+        const info = plugin.hoverProvider(ctx);
+        if (info) {
+          return {
+            contents: { kind: "markdown", value: info.contents },
+            range: info.range,
+          };
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Handle textDocument/codeAction
+   */
+  private handleCodeAction(params: Record<string, unknown>): unknown {
+    const textDocument = params.textDocument as { uri: string };
+    const range = params.range as { start: { line: number; character: number }; end: { line: number; character: number } };
+    const context = params.context as { diagnostics?: Array<{ code?: string; message: string; range: unknown; severity?: number }> } | undefined;
+    const content = this.openDocuments.get(textDocument.uri) ?? "";
+
+    const ctx: CodeActionContext = {
+      uri: textDocument.uri,
+      content,
+      range,
+      diagnostics: (context?.diagnostics ?? []).map((d) => ({
+        range: d.range as CodeActionContext["diagnostics"][0]["range"],
+        message: d.message,
+        ruleId: typeof d.code === "string" ? d.code : undefined,
+        severity: d.severity === 1 ? "error" : d.severity === 2 ? "warning" : "info",
+      })),
+    };
+
+    const actions = [];
+    for (const plugin of this.plugins) {
+      if (plugin.codeActionProvider) {
+        actions.push(...plugin.codeActionProvider(ctx));
+      }
+    }
+
+    return actions;
+  }
+
+  /**
+   * Handle textDocument/diagnostic (pull model)
+   */
+  private async handleDiagnostic(params: Record<string, unknown>): Promise<unknown> {
+    const textDocument = params.textDocument as { uri: string };
+    const content = this.openDocuments.get(textDocument.uri) ?? "";
+    const diagnostics = await this.computeDiagnostics(textDocument.uri, content);
+    return { kind: "full", items: diagnostics };
+  }
+
+  /**
+   * Publish diagnostics for a document (push model)
+   */
+  private async publishDiagnostics(uri: string, content: string): Promise<void> {
+    const diagnostics = await this.computeDiagnostics(uri, content);
+    this.sendNotification("textDocument/publishDiagnostics", {
+      uri,
+      diagnostics,
+    });
+  }
+
+  /**
+   * Run lint engine and convert to LSP diagnostics
+   */
+  private async computeDiagnostics(uri: string, content: string): Promise<unknown[]> {
+    // Only lint .ts files
+    const filePath = uri.startsWith("file://") ? uri.slice(7) : uri;
+    if (!filePath.endsWith(".ts")) return [];
+
+    try {
+      const { runLint } = await import("../../lint/engine");
+      const rules = [];
+      for (const plugin of this.plugins) {
+        rules.push(...(plugin.lintRules?.() ?? []));
+      }
+
+      if (rules.length === 0) return [];
+
+      const diagnostics = await runLint([filePath], rules);
+      return toLspDiagnostics(diagnostics);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Send a JSON-RPC response with Content-Length framing
+   */
+  private sendResponse(response: JsonRpcResponse): void {
+    const body = JSON.stringify(response);
+    const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+    process.stdout.write(header + body);
+  }
+
+  /**
+   * Send a JSON-RPC notification with Content-Length framing
+   */
+  private sendNotification(method: string, params: Record<string, unknown>): void {
+    if (this.captureNotifications) {
+      this.sentNotifications.push({ method, params });
+      return;
+    }
+    const body = JSON.stringify({ jsonrpc: "2.0", method, params });
+    const header = `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n`;
+    process.stdout.write(header + body);
+  }
+}

package/src/cli/main.test.ts

@@ -0,0 +1,257 @@
+import { describe, test, expect } from "bun:test";
+import { parseArgs } from "./main";
+import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
+
+describe("parseArgs", () => {
+  test("parses command as first positional arg", () => {
+    const result = parseArgs(["build"]);
+    expect(result.command).toBe("build");
+    expect(result.path).toBe(".");
+    expect(result.help).toBe(false);
+  });
+
+  test("parses path as second positional arg (defaults to '.')", () => {
+    const result = parseArgs(["build", "./infra"]);
+    expect(result.command).toBe("build");
+    expect(result.path).toBe("./infra");
+  });
+
+  test("defaults path to '.' when not provided", () => {
+    const result = parseArgs(["build"]);
+    expect(result.path).toBe(".");
+  });
+
+  test("parses --help flag", () => {
+    const result = parseArgs(["--help"]);
+    expect(result.help).toBe(true);
+  });
+
+  test("parses -h flag", () => {
+    const result = parseArgs(["-h"]);
+    expect(result.help).toBe(true);
+  });
+
+  test("parses --output with value", () => {
+    const result = parseArgs(["build", "--output", "stack.json"]);
+    expect(result.output).toBe("stack.json");
+    expect(result.command).toBe("build");
+  });
+
+  test("parses -o with value", () => {
+    const result = parseArgs(["build", "-o", "stack.json"]);
+    expect(result.output).toBe("stack.json");
+  });
+
+  test("parses --format with json value", () => {
+    const result = parseArgs(["build", "--format", "json"]);
+    expect(result.format).toBe("json");
+  });
+
+  test("parses --format with yaml value", () => {
+    const result = parseArgs(["build", "--format", "yaml"]);
+    expect(result.format).toBe("yaml");
+  });
+
+  test("parses -f with json value", () => {
+    const result = parseArgs(["build", "-f", "json"]);
+    expect(result.format).toBe("json");
+  });
+
+  test("parses -f with yaml value", () => {
+    const result = parseArgs(["build", "-f", "yaml"]);
+    expect(result.format).toBe("yaml");
+  });
+
+  test("accepts any format value (validation done per-command)", () => {
+    const result = parseArgs(["build", "--format", "xml"]);
+    expect(result.format).toBe("xml"); // format is passed as-is to main
+  });
+
+  test("accepts invalid format values (validation done per-command)", () => {
+    const result = parseArgs(["build", "-f", "invalid"]);
+    expect(result.format).toBe("invalid"); // format is passed as-is to main
+  });
+
+  test("combines multiple options", () => {
+    const result = parseArgs([
+      "build",
+      "./infra",
+      "--output",
+      "stack.json",
+      "--format",
+      "yaml",
+      "--help",
+    ]);
+    expect(result.command).toBe("build");
+    expect(result.path).toBe("./infra");
+    expect(result.output).toBe("stack.json");
+    expect(result.format).toBe("yaml");
+    expect(result.help).toBe(true);
+  });
+
+  test("handles options in different order", () => {
+    const result = parseArgs([
+      "--output",
+      "stack.json",
+      "build",
+      "--format",
+      "yaml",
+      "./infra",
+    ]);
+    expect(result.command).toBe("build");
+    expect(result.path).toBe("./infra");
+    expect(result.output).toBe("stack.json");
+    expect(result.format).toBe("yaml");
+  });
+
+  test("handles empty args array", () => {
+    const result = parseArgs([]);
+    expect(result.command).toBe("");
+    expect(result.path).toBe(".");
+    expect(result.output).toBe(undefined);
+    expect(result.format).toBe(""); // no format specified, defaults applied per-command in main()
+    expect(result.help).toBe(false);
+  });
+
+  test("ignores unknown flags", () => {
+    const result = parseArgs(["build", "--unknown", "value"]);
+    expect(result.command).toBe("build");
+    // Unknown flags are silently ignored
+  });
+
+  test("parses --watch flag", () => {
+    const result = parseArgs(["build", "--watch"]);
+    expect(result.watch).toBe(true);
+    expect(result.command).toBe("build");
+  });
+
+  test("parses -w flag", () => {
+    const result = parseArgs(["build", "-w"]);
+    expect(result.watch).toBe(true);
+  });
+
+  test("watch defaults to false", () => {
+    const result = parseArgs(["build"]);
+    expect(result.watch).toBe(false);
+  });
+
+  test("combines --watch with other options", () => {
+    const result = parseArgs(["build", "./infra", "--watch", "--format", "yaml"]);
+    expect(result.watch).toBe(true);
+    expect(result.command).toBe("build");
+    expect(result.path).toBe("./infra");
+    expect(result.format).toBe("yaml");
+  });
+
+  test("parses --watch with lint command", () => {
+    const result = parseArgs(["lint", "./infra/", "-w"]);
+    expect(result.watch).toBe(true);
+    expect(result.command).toBe("lint");
+    expect(result.path).toBe("./infra/");
+  });
+
+  test("parses extraPositional as third positional arg", () => {
+    const result = parseArgs(["init", "lexicon", "k8s"]);
+    expect(result.command).toBe("init");
+    expect(result.path).toBe("lexicon");
+    expect(result.extraPositional).toBe("k8s");
+  });
+
+  test("parses extraPositional2 as fourth positional arg", () => {
+    const result = parseArgs(["init", "lexicon", "k8s", "./my-path"]);
+    expect(result.command).toBe("init");
+    expect(result.path).toBe("lexicon");
+    expect(result.extraPositional).toBe("k8s");
+    expect(result.extraPositional2).toBe("./my-path");
+  });
+
+  test("extraPositional2 is undefined when only 3 positional args", () => {
+    const result = parseArgs(["dev", "generate", "."]);
+    expect(result.command).toBe("dev");
+    expect(result.path).toBe("generate");
+    expect(result.extraPositional).toBe(".");
+    expect(result.extraPositional2).toBe(undefined);
+  });
+});
+
+// ── resolveCommand tests ──────────────────────────────────────────
+
+describe("resolveCommand", () => {
+  const noop = async () => 0;
+
+  const testRegistry: CommandDef[] = [
+    { name: "build", handler: noop },
+    { name: "dev generate", requiresPlugins: true, handler: noop },
+    { name: "dev publish", requiresPlugins: true, handler: noop },
+    { name: "serve lsp", handler: noop },
+    { name: "init", handler: noop },
+    { name: "init lexicon", handler: noop },
+    { name: "dev", handler: noop },
+  ];
+
+  function makeArgs(overrides: Partial<ParsedArgs>): ParsedArgs {
+    return {
+      command: "",
+      path: ".",
+      format: "",
+      fix: false,
+      watch: false,
+      verbose: false,
+      help: false,
+      ...overrides,
+    };
+  }
+
+  test("resolves simple command", () => {
+    const result = resolveCommand(makeArgs({ command: "build" }), testRegistry);
+    expect(result).not.toBeNull();
+    expect(result!.def.name).toBe("build");
+    expect(result!.compound).toBe(false);
+  });
+
+  test("resolves compound command (dev generate)", () => {
+    const result = resolveCommand(makeArgs({ command: "dev", path: "generate" }), testRegistry);
+    expect(result).not.toBeNull();
+    expect(result!.def.name).toBe("dev generate");
+    expect(result!.compound).toBe(true);
+  });
+
+  test("resolves compound command (serve lsp)", () => {
+    const result = resolveCommand(makeArgs({ command: "serve", path: "lsp" }), testRegistry);
+    expect(result).not.toBeNull();
+    expect(result!.def.name).toBe("serve lsp");
+    expect(result!.compound).toBe(true);
+  });
+
+  test("resolves compound command (init lexicon)", () => {
+    const result = resolveCommand(makeArgs({ command: "init", path: "lexicon" }), testRegistry);
+    expect(result).not.toBeNull();
+    expect(result!.def.name).toBe("init lexicon");
+    expect(result!.compound).toBe(true);
+  });
+
+  test("falls back to simple when compound doesn't match", () => {
+    const result = resolveCommand(makeArgs({ command: "dev", path: "unknown" }), testRegistry);
+    expect(result).not.toBeNull();
+    expect(result!.def.name).toBe("dev");
+    expect(result!.compound).toBe(false);
+  });
+
+  test("resolves init without lexicon subcommand", () => {
+    const result = resolveCommand(makeArgs({ command: "init", path: "." }), testRegistry);
+    expect(result).not.toBeNull();
+    expect(result!.def.name).toBe("init");
+    expect(result!.compound).toBe(false);
+  });
+
+  test("returns null for unknown command", () => {
+    const result = resolveCommand(makeArgs({ command: "foobar" }), testRegistry);
+    expect(result).toBeNull();
+  });
+
+  test("compound takes priority over simple match", () => {
+    const result = resolveCommand(makeArgs({ command: "dev", path: "generate" }), testRegistry);
+    expect(result!.def.name).toBe("dev generate");
+    expect(result!.compound).toBe(true);
+  });
+});