@intentius/chant 0.0.1

package/src/cli/plugins.ts

@@ -0,0 +1,94 @@
+import { isLexiconPlugin, type LexiconPlugin } from "../lexicon";
+import { loadChantConfig } from "../config";
+import { discover, detectLexicons } from "../index";
+import { checkConflicts } from "./conflict-check";
+
+/**
+ * Load a single lexicon plugin by lexicon name.
+ *
+ * Dynamically imports `@intentius/chant-lexicon-{name}` and looks for a
+ * LexiconPlugin export. Falls back to wrapping a raw Serializer export.
+ */
+export async function loadPlugin(lexiconName: string): Promise<LexiconPlugin> {
+  const packageName = `@intentius/chant-lexicon-${lexiconName}`;
+  const mod = await import(packageName);
+
+  // Look for an explicit LexiconPlugin export
+  for (const value of Object.values(mod)) {
+    if (isLexiconPlugin(value)) {
+      return value;
+    }
+  }
+
+  // Fallback: wrap a raw Serializer export into a minimal plugin
+  const serializer = mod.serializer ?? mod.default?.serializer ?? mod[`${lexiconName}Serializer`];
+  if (serializer && typeof serializer === "object" && "name" in serializer && "serialize" in serializer) {
+    const notSupported = (op: string) => async () => {
+      throw new Error(`${serializer.name}: ${op} is not supported (raw serializer fallback)`);
+    };
+    return {
+      name: serializer.name,
+      serializer,
+      generate: notSupported("generate"),
+      validate: notSupported("validate"),
+      coverage: notSupported("coverage"),
+      package: notSupported("package"),
+      rollback: notSupported("rollback"),
+    };
+  }
+
+  throw new Error(`Package ${packageName} does not export a LexiconPlugin or Serializer`);
+}
+
+/**
+ * Load plugins for all detected lexicon names.
+ * Calls `init()` on each plugin if present.
+ */
+export async function loadPlugins(lexiconNames: string[]): Promise<LexiconPlugin[]> {
+  const plugins: LexiconPlugin[] = [];
+  for (const name of lexiconNames) {
+    const plugin = await loadPlugin(name);
+    if (plugin.init) {
+      await plugin.init();
+    }
+    plugins.push(plugin);
+  }
+
+  // Cross-lexicon conflict detection
+  const report = checkConflicts(plugins);
+
+  for (const warning of report.warnings) {
+    console.warn(
+      `[chant] warning: ${warning.type} "${warning.key}" is provided by multiple lexicons: ${warning.plugins.join(", ")}`,
+    );
+  }
+
+  if (report.conflicts.length > 0) {
+    const details = report.conflicts
+      .map((c) => `  ${c.type} "${c.key}" from: ${c.plugins.join(", ")}`)
+      .join("\n");
+    throw new Error(
+      `Cross-lexicon conflicts detected:\n${details}`,
+    );
+  }
+
+  return plugins;
+}
+
+/**
+ * Resolve lexicon names for a project directory.
+ *
+ * Reads `lexicons` from `chant.config.ts` / `chant.config.json` if present.
+ * Falls back to source-file detection via `detectLexicons()`.
+ */
+export async function resolveProjectLexicons(projectPath: string): Promise<string[]> {
+  const { config } = await loadChantConfig(projectPath);
+
+  if (config.lexicons && config.lexicons.length > 0) {
+    return config.lexicons;
+  }
+
+  // Fallback: detect from source imports
+  const discoveryResult = await discover(projectPath);
+  return detectLexicons(discoveryResult.sourceFiles);
+}

package/src/cli/registry.ts

@@ -0,0 +1,73 @@
+import type { LexiconPlugin } from "../lexicon";
+import type { Serializer } from "../serializer";
+
+/**
+ * Parsed CLI arguments (output of parseArgs).
+ */
+export interface ParsedArgs {
+  command: string;
+  path: string;
+  extraPositional?: string;
+  extraPositional2?: string;
+  output?: string;
+  format: string;
+  force?: boolean;
+  fix: boolean;
+  lexicon?: string;
+  watch: boolean;
+  verbose: boolean;
+  help: boolean;
+}
+
+/**
+ * Declarative command definition for the CLI registry.
+ */
+export interface CommandDef {
+  /** Primary command name, e.g. "build", "dev generate", "serve lsp" */
+  name: string;
+  /** If true, load lexicon plugins before calling handler */
+  requiresPlugins?: boolean;
+  /** Command handler — returns exit code */
+  handler: (ctx: CommandContext) => Promise<number>;
+}
+
+/**
+ * Context passed to each command handler.
+ */
+export interface CommandContext {
+  args: ParsedArgs;
+  plugins: LexiconPlugin[];
+  serializers: Serializer[];
+}
+
+/**
+ * Result of resolving a command from CLI args against the registry.
+ */
+export interface ResolvedCommand {
+  def: CommandDef;
+  /** True if this was matched as a compound command (args.path was consumed as subcommand) */
+  compound: boolean;
+}
+
+/**
+ * Resolve a command from parsed CLI args against the registry.
+ *
+ * Supports compound commands like "dev generate" where args.command="dev"
+ * and args.path="generate". Falls back to simple command matching.
+ */
+export function resolveCommand(args: ParsedArgs, registry: CommandDef[]): ResolvedCommand | null {
+  // Try compound command first: "dev generate", "serve lsp", "init lexicon"
+  const compound = `${args.command} ${args.path}`;
+  const compoundMatch = registry.find((c) => c.name === compound);
+  if (compoundMatch) {
+    return { def: compoundMatch, compound: true };
+  }
+
+  // Try simple command
+  const simpleMatch = registry.find((c) => c.name === args.command);
+  if (simpleMatch) {
+    return { def: simpleMatch, compound: false };
+  }
+
+  return null;
+}

package/src/cli/reporters/stylish.test.ts

@@ -0,0 +1,282 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { formatStylish, formatSummary, formatJson, formatSarif } from "./stylish";
+import type { LintDiagnostic } from "../../lint/rule";
+
+describe("formatStylish", () => {
+  const originalNoColor = process.env.NO_COLOR;
+
+  beforeEach(() => {
+    process.env.NO_COLOR = "1"; // Disable colors for testing
+  });
+
+  afterEach(() => {
+    if (originalNoColor !== undefined) {
+      process.env.NO_COLOR = originalNoColor;
+    } else {
+      delete process.env.NO_COLOR;
+    }
+  });
+
+  test("returns empty string for no diagnostics", () => {
+    const result = formatStylish([]);
+    expect(result).toBe("");
+  });
+
+  test("formats single diagnostic", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "test.ts",
+        line: 10,
+        column: 5,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Something is wrong",
+      },
+    ];
+
+    const result = formatStylish(diagnostics);
+
+    expect(result).toContain("test.ts");
+    expect(result).toContain("10");
+    expect(result).toContain("5");
+    expect(result).toContain("warning");
+    expect(result).toContain("Something is wrong");
+    expect(result).toContain("COR001");
+  });
+
+  test("groups diagnostics by file", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "a.ts",
+        line: 1,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Issue 1",
+      },
+      {
+        file: "b.ts",
+        line: 1,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Issue 2",
+      },
+      {
+        file: "a.ts",
+        line: 2,
+        column: 1,
+        ruleId: "COR001",
+        severity: "error",
+        message: "Issue 3",
+      },
+    ];
+
+    const result = formatStylish(diagnostics);
+
+    // Both files should appear
+    expect(result).toContain("a.ts");
+    expect(result).toContain("b.ts");
+
+    // Summary should show 1 error, 2 warnings
+    expect(result).toContain("1 error");
+    expect(result).toContain("2 warnings");
+  });
+
+  test("sorts diagnostics by line then column", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "test.ts",
+        line: 20,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Line 20",
+      },
+      {
+        file: "test.ts",
+        line: 10,
+        column: 5,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Line 10 col 5",
+      },
+      {
+        file: "test.ts",
+        line: 10,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Line 10 col 1",
+      },
+    ];
+
+    const result = formatStylish(diagnostics);
+    const lines = result.split("\n");
+
+    // Find the diagnostic lines (contain "warning")
+    const diagLines = lines.filter((l) => l.includes("warning"));
+
+    expect(diagLines[0]).toContain("Line 10 col 1");
+    expect(diagLines[1]).toContain("Line 10 col 5");
+    expect(diagLines[2]).toContain("Line 20");
+  });
+});
+
+describe("formatSummary", () => {
+  beforeEach(() => {
+    process.env.NO_COLOR = "1";
+  });
+
+  test("formats errors only", () => {
+    const result = formatSummary(3, 0);
+    expect(result).toContain("3 errors");
+  });
+
+  test("formats warnings only", () => {
+    const result = formatSummary(0, 2);
+    expect(result).toContain("2 warnings");
+  });
+
+  test("formats both errors and warnings", () => {
+    const result = formatSummary(1, 2);
+    expect(result).toContain("1 error");
+    expect(result).toContain("2 warnings");
+  });
+
+  test("formats no problems", () => {
+    const result = formatSummary(0, 0);
+    expect(result).toContain("No problems");
+  });
+
+  test("uses singular for 1 error", () => {
+    const result = formatSummary(1, 0);
+    expect(result).toContain("1 error");
+    expect(result).not.toContain("1 errors");
+  });
+
+  test("uses singular for 1 warning", () => {
+    const result = formatSummary(0, 1);
+    expect(result).toContain("1 warning");
+    expect(result).not.toContain("1 warnings");
+  });
+});
+
+describe("formatJson", () => {
+  test("returns valid JSON", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "test.ts",
+        line: 10,
+        column: 5,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Something is wrong",
+      },
+    ];
+
+    const result = formatJson(diagnostics);
+
+    expect(() => JSON.parse(result)).not.toThrow();
+
+    const parsed = JSON.parse(result);
+    expect(parsed).toHaveLength(1);
+    expect(parsed[0].file).toBe("test.ts");
+  });
+});
+
+describe("formatSarif", () => {
+  test("returns valid SARIF JSON", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "test.ts",
+        line: 10,
+        column: 5,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Something is wrong",
+      },
+    ];
+
+    const result = formatSarif(diagnostics);
+
+    expect(() => JSON.parse(result)).not.toThrow();
+
+    const parsed = JSON.parse(result);
+    expect(parsed.version).toBe("2.1.0");
+    expect(parsed.runs).toHaveLength(1);
+    expect(parsed.runs[0].tool.driver.name).toBe("chant");
+    expect(parsed.runs[0].results).toHaveLength(1);
+  });
+
+  test("maps severity correctly", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "test.ts",
+        line: 1,
+        column: 1,
+        ruleId: "E001",
+        severity: "error",
+        message: "Error",
+      },
+      {
+        file: "test.ts",
+        line: 2,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Warning",
+      },
+      {
+        file: "test.ts",
+        line: 3,
+        column: 1,
+        ruleId: "I001",
+        severity: "info",
+        message: "Info",
+      },
+    ];
+
+    const result = formatSarif(diagnostics);
+    const parsed = JSON.parse(result);
+
+    expect(parsed.runs[0].results[0].level).toBe("error");
+    expect(parsed.runs[0].results[1].level).toBe("warning");
+    expect(parsed.runs[0].results[2].level).toBe("note");
+  });
+
+  test("extracts unique rules", () => {
+    const diagnostics: LintDiagnostic[] = [
+      {
+        file: "a.ts",
+        line: 1,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Issue 1",
+      },
+      {
+        file: "b.ts",
+        line: 1,
+        column: 1,
+        ruleId: "COR001",
+        severity: "warning",
+        message: "Issue 2",
+      },
+      {
+        file: "c.ts",
+        line: 1,
+        column: 1,
+        ruleId: "COR008",
+        severity: "warning",
+        message: "Issue 3",
+      },
+    ];
+
+    const result = formatSarif(diagnostics);
+    const parsed = JSON.parse(result);
+
+    // Should have 2 unique rules
+    expect(parsed.runs[0].tool.driver.rules).toHaveLength(2);
+  });
+});

package/src/cli/reporters/stylish.ts

@@ -0,0 +1,186 @@
+import type { LintDiagnostic } from "../../lint/rule";
+
+/**
+ * ANSI color codes
+ */
+const colors = {
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  underline: "\x1b[4m",
+};
+
+/**
+ * Check if colors should be used
+ */
+function useColors(): boolean {
+  return !process.env.NO_COLOR && process.stdout.isTTY !== false;
+}
+
+/**
+ * Apply color if enabled
+ */
+function color(text: string, colorCode: string): string {
+  if (!useColors()) return text;
+  return `${colorCode}${text}${colors.reset}`;
+}
+
+/**
+ * Format diagnostics in stylish format (similar to ESLint)
+ * Groups by file, shows severity, message, and rule ID
+ */
+export function formatStylish(diagnostics: LintDiagnostic[]): string {
+  if (diagnostics.length === 0) {
+    return "";
+  }
+
+  // Group by file
+  const byFile = new Map<string, LintDiagnostic[]>();
+  for (const diag of diagnostics) {
+    const existing = byFile.get(diag.file) ?? [];
+    existing.push(diag);
+    byFile.set(diag.file, existing);
+  }
+
+  const lines: string[] = [];
+  let errorCount = 0;
+  let warningCount = 0;
+
+  for (const [file, fileDiags] of byFile) {
+    // File header with underline
+    lines.push("");
+    lines.push(color(file, colors.underline));
+
+    // Sort by line, then column
+    fileDiags.sort((a, b) => {
+      if (a.line !== b.line) return a.line - b.line;
+      return a.column - b.column;
+    });
+
+    for (const diag of fileDiags) {
+      // Count errors and warnings
+      if (diag.severity === "error") {
+        errorCount++;
+      } else if (diag.severity === "warning") {
+        warningCount++;
+      }
+
+      // Format: "  line:col  severity  message  ruleId"
+      const location = color(
+        `${String(diag.line).padStart(4)}:${String(diag.column).padEnd(3)}`,
+        colors.gray
+      );
+
+      const severityColor = diag.severity === "error" ? colors.red : colors.yellow;
+      const severity = color(diag.severity.padEnd(7), severityColor);
+
+      const ruleId = color(diag.ruleId, colors.gray);
+
+      lines.push(`  ${location}  ${severity}  ${diag.message}  ${ruleId}`);
+    }
+  }
+
+  // Summary line
+  lines.push("");
+  const summary = formatSummary(errorCount, warningCount);
+  lines.push(summary);
+
+  return lines.join("\n");
+}
+
+/**
+ * Format the summary line
+ */
+export function formatSummary(errorCount: number, warningCount: number): string {
+  const parts: string[] = [];
+
+  if (errorCount > 0) {
+    parts.push(color(`${errorCount} error${errorCount === 1 ? "" : "s"}`, colors.red));
+  }
+
+  if (warningCount > 0) {
+    parts.push(color(`${warningCount} warning${warningCount === 1 ? "" : "s"}`, colors.yellow));
+  }
+
+  if (parts.length === 0) {
+    return color("✓ No problems found", colors.green);
+  }
+
+  const symbol = errorCount > 0 ? "✖" : "⚠";
+  return `${symbol} ${parts.join(", ")}`;
+}
+
+/**
+ * Format diagnostics as JSON
+ */
+export function formatJson(diagnostics: LintDiagnostic[]): string {
+  return JSON.stringify(diagnostics, null, 2);
+}
+
+/**
+ * Format diagnostics as SARIF (Static Analysis Results Interchange Format)
+ */
+export function formatSarif(diagnostics: LintDiagnostic[]): string {
+  const sarif = {
+    $schema: "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "chant",
+            version: "0.1.0",
+            informationUri: "https://chant.dev",
+            rules: getUniqueRules(diagnostics),
+          },
+        },
+        results: diagnostics.map((diag) => ({
+          ruleId: diag.ruleId,
+          level: diag.severity === "error" ? "error" : diag.severity === "warning" ? "warning" : "note",
+          message: {
+            text: diag.message,
+          },
+          locations: [
+            {
+              physicalLocation: {
+                artifactLocation: {
+                  uri: diag.file,
+                },
+                region: {
+                  startLine: diag.line,
+                  startColumn: diag.column,
+                },
+              },
+            },
+          ],
+        })),
+      },
+    ],
+  };
+
+  return JSON.stringify(sarif, null, 2);
+}
+
+/**
+ * Extract unique rules from diagnostics for SARIF
+ */
+function getUniqueRules(diagnostics: LintDiagnostic[]): Array<{ id: string; shortDescription: { text: string } }> {
+  const ruleIds = new Set<string>();
+  const rules: Array<{ id: string; shortDescription: { text: string } }> = [];
+
+  for (const diag of diagnostics) {
+    if (!ruleIds.has(diag.ruleId)) {
+      ruleIds.add(diag.ruleId);
+      rules.push({
+        id: diag.ruleId,
+        shortDescription: { text: diag.ruleId },
+      });
+    }
+  }
+
+  return rules;
+}

package/src/cli/watch.test.ts

@@ -0,0 +1,81 @@
+import { describe, test, expect } from "bun:test";
+import { shouldWatch, formatTimestamp, formatChangedFiles } from "./watch";
+
+describe("shouldWatch", () => {
+  const defaults = {
+    debounceMs: 300,
+    extensions: [".ts"],
+    ignoreDirs: ["node_modules", ".chant"],
+  };
+
+  test("accepts .ts files", () => {
+    expect(shouldWatch("src/bucket.ts", defaults)).toBe(true);
+  });
+
+  test("rejects non-.ts files", () => {
+    expect(shouldWatch("src/readme.md", defaults)).toBe(false);
+  });
+
+  test("rejects test files", () => {
+    expect(shouldWatch("src/bucket.test.ts", defaults)).toBe(false);
+    expect(shouldWatch("src/bucket.spec.ts", defaults)).toBe(false);
+  });
+
+  test("rejects node_modules", () => {
+    expect(shouldWatch("node_modules/foo/index.ts", defaults)).toBe(false);
+  });
+
+  test("rejects .chant directory", () => {
+    expect(shouldWatch(".chant/types/core/index.ts", defaults)).toBe(false);
+  });
+
+  test("rejects dotdirs", () => {
+    expect(shouldWatch(".git/hooks/pre-commit.ts", defaults)).toBe(false);
+    expect(shouldWatch(".vscode/settings.ts", defaults)).toBe(false);
+  });
+
+  test("accepts nested .ts files", () => {
+    expect(shouldWatch("src/infra/data-bucket.ts", defaults)).toBe(true);
+  });
+});
+
+describe("formatTimestamp", () => {
+  test("formats as HH:MM:SS", () => {
+    const date = new Date(2024, 0, 1, 9, 5, 3);
+    expect(formatTimestamp(date)).toBe("09:05:03");
+  });
+
+  test("pads single digits", () => {
+    const date = new Date(2024, 0, 1, 1, 2, 3);
+    expect(formatTimestamp(date)).toBe("01:02:03");
+  });
+
+  test("handles midnight", () => {
+    const date = new Date(2024, 0, 1, 0, 0, 0);
+    expect(formatTimestamp(date)).toBe("00:00:00");
+  });
+});
+
+describe("formatChangedFiles", () => {
+  test("shows all files when count <= maxShow", () => {
+    const result = formatChangedFiles(
+      ["/project/src/a.ts", "/project/src/b.ts"],
+      "/project",
+    );
+    expect(result).toBe("src/a.ts, src/b.ts");
+  });
+
+  test("truncates when count > maxShow", () => {
+    const result = formatChangedFiles(
+      ["/project/src/a.ts", "/project/src/b.ts", "/project/src/c.ts", "/project/src/d.ts"],
+      "/project",
+      2,
+    );
+    expect(result).toBe("src/a.ts, src/b.ts (+2 more)");
+  });
+
+  test("shows single file", () => {
+    const result = formatChangedFiles(["/project/src/a.ts"], "/project");
+    expect(result).toBe("src/a.ts");
+  });
+});