@intentius/chant 0.0.1

package/src/cli/format.ts

@@ -0,0 +1,133 @@
+/**
+ * ANSI color codes for terminal output
+ */
+const colors = {
+  red: "\x1b[31m",
+  yellow: "\x1b[33m",
+  green: "\x1b[32m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+};
+
+/**
+ * Check if colors should be used (respects NO_COLOR env var)
+ */
+function useColors(): boolean {
+  return !process.env.NO_COLOR && process.stdout.isTTY !== false;
+}
+
+/**
+ * Apply color if colors are enabled
+ */
+function color(text: string, colorCode: string): string {
+  if (!useColors()) return text;
+  return `${colorCode}${text}${colors.reset}`;
+}
+
+/**
+ * Format an error with ANSI colors
+ * Shows file:line:column in cyan, error in red
+ */
+export function formatError(error: {
+  file?: string;
+  line?: number;
+  column?: number;
+  message: string;
+  name?: string;
+  hint?: string;
+}): string {
+  const parts: string[] = [];
+
+  // Location prefix
+  if (error.file) {
+    let location = error.file;
+    if (error.line !== undefined) {
+      location += `:${error.line}`;
+      if (error.column !== undefined) {
+        location += `:${error.column}`;
+      }
+    }
+    parts.push(color(location, colors.cyan));
+    parts.push(" - ");
+  }
+
+  // Error type
+  parts.push(color("error", colors.red));
+  parts.push(": ");
+
+  // Message
+  parts.push(error.message);
+
+  // Hint
+  if (error.hint) {
+    parts.push("\n  ");
+    parts.push(color(error.hint, colors.gray));
+  }
+
+  return parts.join("");
+}
+
+/**
+ * Format a warning with ANSI colors
+ * Shows file:line:column in cyan, warning in yellow
+ */
+export function formatWarning(warning: {
+  file?: string;
+  line?: number;
+  column?: number;
+  message: string;
+  hint?: string;
+}): string {
+  const parts: string[] = [];
+
+  // Location prefix
+  if (warning.file) {
+    let location = warning.file;
+    if (warning.line !== undefined) {
+      location += `:${warning.line}`;
+      if (warning.column !== undefined) {
+        location += `:${warning.column}`;
+      }
+    }
+    parts.push(color(location, colors.cyan));
+    parts.push(" - ");
+  }
+
+  // Warning type
+  parts.push(color("warning", colors.yellow));
+  parts.push(": ");
+
+  // Message
+  parts.push(warning.message);
+
+  // Hint
+  if (warning.hint) {
+    parts.push("\n  ");
+    parts.push(color(warning.hint, colors.gray));
+  }
+
+  return parts.join("");
+}
+
+/**
+ * Format a success message in green
+ */
+export function formatSuccess(message: string): string {
+  return color(message, colors.green);
+}
+
+/**
+ * Format an info message in gray
+ */
+export function formatInfo(message: string): string {
+  return color(message, colors.gray);
+}
+
+/**
+ * Format a count/stat in bold
+ */
+export function formatBold(text: string): string {
+  return color(text, colors.bold);
+}

package/src/cli/handlers/build.ts

@@ -0,0 +1,58 @@
+import { buildCommand, buildCommandWatch, printErrors, printWarnings } from "../commands/build";
+import { formatInfo } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runBuild(ctx: CommandContext): Promise<number> {
+  const { args, plugins } = ctx;
+  let { serializers } = ctx;
+
+  // Filter to a single lexicon when --lexicon is specified
+  if (args.lexicon) {
+    serializers = serializers.filter((s) => s.name === args.lexicon);
+    if (serializers.length === 0) {
+      console.error(`No serializer found for lexicon "${args.lexicon}". Available: ${ctx.serializers.map((s) => s.name).join(", ")}`);
+      return 1;
+    }
+  }
+
+  const buildFormat = (args.format || "json") as "json" | "yaml";
+  if (buildFormat !== "json" && buildFormat !== "yaml") {
+    console.error(`Invalid format for build: ${buildFormat}. Expected 'json' or 'yaml'.`);
+    return 1;
+  }
+
+  if (args.watch) {
+    const cleanup = buildCommandWatch({
+      path: args.path,
+      output: args.output,
+      format: buildFormat,
+      serializers,
+      plugins,
+    });
+    process.on("SIGINT", () => {
+      cleanup();
+      console.error(formatInfo("\nWatch mode stopped."));
+      process.exit(0);
+    });
+    await new Promise(() => {});
+  }
+
+  const result = await buildCommand({
+    path: args.path,
+    output: args.output,
+    format: buildFormat,
+    serializers,
+    plugins,
+    verbose: args.verbose,
+  });
+
+  // When --lexicon filters to a subset, suppress "No serializer" warnings for excluded lexicons
+  let warnings = result.warnings;
+  if (args.lexicon) {
+    warnings = warnings.filter((w) => !w.includes('No serializer found for lexicon'));
+  }
+  printWarnings(warnings);
+  printErrors(result.errors);
+
+  return result.success ? 0 : 1;
+}

package/src/cli/handlers/dev.ts

@@ -0,0 +1,38 @@
+import { formatError, formatSuccess } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runDevGenerate(ctx: CommandContext): Promise<number> {
+  for (const plugin of ctx.plugins) {
+    await plugin.generate({ verbose: ctx.args.verbose });
+    console.error(formatSuccess(`${plugin.name}: generate complete`));
+    await plugin.validate({ verbose: ctx.args.verbose });
+    console.error(formatSuccess(`${plugin.name}: validate complete`));
+    await plugin.coverage({ verbose: ctx.args.verbose });
+    console.error(formatSuccess(`${plugin.name}: coverage complete`));
+  }
+  return 0;
+}
+
+export async function runDevPublish(ctx: CommandContext): Promise<number> {
+  for (const plugin of ctx.plugins) {
+    await plugin.package({ verbose: ctx.args.verbose, force: ctx.args.force });
+    console.error(formatSuccess(`${plugin.name}: publish complete`));
+  }
+  return 0;
+}
+
+export async function runDevRollback(ctx: CommandContext): Promise<number> {
+  for (const plugin of ctx.plugins) {
+    await plugin.rollback({ verbose: ctx.args.verbose });
+    console.error(formatSuccess(`${plugin.name}: rollback complete`));
+  }
+  return 0;
+}
+
+export async function runDevUnknown(ctx: CommandContext): Promise<number> {
+  console.error(formatError({
+    message: `Unknown dev subcommand: ${ctx.args.path}`,
+    hint: "Available: chant dev generate, chant dev publish, chant dev rollback",
+  }));
+  return 1;
+}

package/src/cli/handlers/init.ts

@@ -0,0 +1,46 @@
+import { formatError } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runInit(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+
+  if (!args.lexicon) {
+    console.error(formatError({
+      message: "Missing --lexicon flag",
+      hint: "Usage: chant init --lexicon <name>",
+    }));
+    return 1;
+  }
+
+  const { initCommand, printInitResult } = await import("../commands/init");
+  const result = await initCommand({
+    path: args.path === "." ? undefined : args.path,
+    lexicon: args.lexicon,
+    force: args.force,
+    skipInstall: true,
+  });
+  await printInitResult(result, { skipInstall: false, cwd: args.path });
+  return result.success ? 0 : 1;
+}
+
+export async function runInitLexicon(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+
+  const name = args.extraPositional;
+  if (!name) {
+    console.error(formatError({
+      message: "Missing lexicon name",
+      hint: "Usage: chant init lexicon <name> [path]",
+    }));
+    return 1;
+  }
+
+  const { initLexiconCommand, printInitLexiconResult } = await import("../commands/init-lexicon");
+  const result = await initLexiconCommand({
+    name,
+    path: args.extraPositional2,
+    force: args.force,
+  });
+  await printInitLexiconResult(result);
+  return result.success ? 0 : 1;
+}

package/src/cli/handlers/lint.ts

@@ -0,0 +1,36 @@
+import { lintCommand, lintCommandWatch, printLintResult } from "../commands/lint";
+import { formatInfo } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runLint(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+
+  const lintFormat = (args.format || "stylish") as "stylish" | "json" | "sarif";
+  if (lintFormat !== "stylish" && lintFormat !== "json" && lintFormat !== "sarif") {
+    console.error(`Invalid format for lint: ${lintFormat}. Expected 'stylish', 'json', or 'sarif'.`);
+    return 1;
+  }
+
+  if (args.watch) {
+    const cleanup = lintCommandWatch({
+      path: args.path,
+      fix: args.fix,
+      format: lintFormat,
+    });
+    process.on("SIGINT", () => {
+      cleanup();
+      console.error(formatInfo("\nWatch mode stopped."));
+      process.exit(0);
+    });
+    await new Promise(() => {});
+  }
+
+  const result = await lintCommand({
+    path: args.path,
+    fix: args.fix,
+    format: lintFormat,
+  });
+
+  printLintResult(result);
+  return result.success ? 0 : 1;
+}

package/src/cli/handlers/misc.ts

@@ -0,0 +1,57 @@
+import { listCommand, printListResult } from "../commands/list";
+import { importCommand, printImportResult } from "../commands/import";
+import { formatError, formatSuccess } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runList(ctx: CommandContext): Promise<number> {
+  const { args } = ctx;
+  const listFormat = (args.format || "text") as "text" | "json";
+  if (listFormat !== "text" && listFormat !== "json") {
+    console.error(`Invalid format for list: ${listFormat}. Expected 'text' or 'json'.`);
+    return 1;
+  }
+
+  const result = await listCommand({
+    path: args.path,
+    format: listFormat,
+  });
+
+  printListResult(result);
+  return result.success ? 0 : 1;
+}
+
+export async function runImport(ctx: CommandContext): Promise<number> {
+  const result = await importCommand({
+    templatePath: ctx.args.path,
+    output: ctx.args.output,
+    force: ctx.args.force,
+  });
+
+  printImportResult(result);
+  return result.success ? 0 : 1;
+}
+
+export async function runUpdate(ctx: CommandContext): Promise<number> {
+  const { updateCommand, printUpdateResult } = await import("../commands/update");
+  const result = await updateCommand({ path: ctx.args.path });
+  printUpdateResult(result);
+  return result.success ? 0 : 1;
+}
+
+export async function runDoctor(ctx: CommandContext): Promise<number> {
+  const { doctorCommand } = await import("../commands/doctor");
+  const report = await doctorCommand(ctx.args.path);
+
+  for (const check of report.checks) {
+    const icon = check.status === "pass" ? "OK" : check.status === "warn" ? "WARN" : "FAIL";
+    const msg = check.message ? ` — ${check.message}` : "";
+    console.error(`  [${icon}] ${check.name}${msg}`);
+  }
+
+  if (!report.success) {
+    console.error(formatError({ message: "Doctor found issues" }));
+  } else {
+    console.error(formatSuccess("All checks passed"));
+  }
+  return report.success ? 0 : 1;
+}

package/src/cli/handlers/serve.ts

@@ -0,0 +1,26 @@
+import { formatError } from "../format";
+import type { CommandContext } from "../registry";
+
+export async function runServeLsp(ctx: CommandContext): Promise<number> {
+  const { LspServer } = await import("../lsp/server");
+  const server = new LspServer(ctx.plugins);
+  await server.start();
+  await new Promise(() => {});
+  return 0; // unreachable
+}
+
+export async function runServeMcp(ctx: CommandContext): Promise<number> {
+  const { McpServer } = await import("../mcp/server");
+  const server = new McpServer(ctx.plugins);
+  await server.start();
+  await new Promise(() => {});
+  return 0; // unreachable
+}
+
+export async function runServeUnknown(ctx: CommandContext): Promise<number> {
+  console.error(formatError({
+    message: `Unknown serve subcommand: ${ctx.args.path}`,
+    hint: "Available: chant serve lsp, chant serve mcp",
+  }));
+  return 1;
+}

package/src/cli/index.ts

@@ -0,0 +1,3 @@
+export { parseArgs } from "./main";
+export { loadPlugin, loadPlugins, resolveProjectLexicons } from "./plugins";
+export { checkConflicts } from "./conflict-check";

package/src/cli/lsp/capabilities.ts

@@ -0,0 +1,46 @@
+import type { LexiconPlugin } from "../../lexicon";
+
+/**
+ * LSP server capabilities, conditionally advertised based on loaded plugins.
+ */
+export interface LspCapabilities {
+  textDocumentSync: number;
+  completionProvider?: { triggerCharacters: string[] };
+  hoverProvider?: boolean;
+  codeActionProvider?: boolean;
+  diagnosticProvider?: { interFileDependencies: boolean; workspaceDiagnostics: boolean };
+}
+
+/**
+ * Compute LSP capabilities based on which plugins implement providers.
+ */
+export function computeCapabilities(plugins: LexiconPlugin[]): LspCapabilities {
+  const hasCompletion = plugins.some((p) => p.completionProvider !== undefined);
+  const hasHover = plugins.some((p) => p.hoverProvider !== undefined);
+  const hasCodeAction = plugins.some((p) => p.codeActionProvider !== undefined);
+
+  const capabilities: LspCapabilities = {
+    // Full sync — client sends full document content on open/change
+    textDocumentSync: 1,
+    diagnosticProvider: {
+      interFileDependencies: false,
+      workspaceDiagnostics: false,
+    },
+  };
+
+  if (hasCompletion) {
+    capabilities.completionProvider = {
+      triggerCharacters: [".", " ", '"', "'", "`", "("],
+    };
+  }
+
+  if (hasHover) {
+    capabilities.hoverProvider = true;
+  }
+
+  if (hasCodeAction) {
+    capabilities.codeActionProvider = true;
+  }
+
+  return capabilities;
+}

package/src/cli/lsp/diagnostics.ts

@@ -0,0 +1,52 @@
+import type { LintDiagnostic, Severity } from "../../lint/rule";
+
+/**
+ * LSP diagnostic as returned in textDocument/publishDiagnostics.
+ */
+export interface LspDiagnostic {
+  range: {
+    start: { line: number; character: number };
+    end: { line: number; character: number };
+  };
+  severity: number;
+  code?: string;
+  source: string;
+  message: string;
+  data?: { ruleId: string; fix?: unknown };
+}
+
+/**
+ * Map chant severity to LSP DiagnosticSeverity (1=Error, 2=Warning, 3=Info, 4=Hint)
+ */
+function toLspSeverity(severity: Severity): number {
+  switch (severity) {
+    case "error":
+      return 1;
+    case "warning":
+      return 2;
+    case "info":
+      return 3;
+  }
+}
+
+/**
+ * Convert chant LintDiagnostics to LSP diagnostics.
+ * Converts 1-based lines/columns to 0-based.
+ */
+export function toLspDiagnostics(diagnostics: LintDiagnostic[]): LspDiagnostic[] {
+  return diagnostics.map((d) => {
+    const line = Math.max(0, d.line - 1);
+    const character = Math.max(0, d.column - 1);
+    return {
+      range: {
+        start: { line, character },
+        end: { line, character },
+      },
+      severity: toLspSeverity(d.severity),
+      code: d.ruleId,
+      source: "chant",
+      message: d.message,
+      data: d.fix ? { ruleId: d.ruleId, fix: d.fix } : { ruleId: d.ruleId },
+    };
+  });
+}