@intentius/chant 0.0.1

package/src/cli/commands/update.ts

@@ -0,0 +1,207 @@
+import { existsSync, mkdirSync, writeFileSync, cpSync, readdirSync, statSync } from "fs";
+import { join, resolve } from "path";
+import { formatSuccess, formatWarning, formatError } from "../format";
+import { loadChantConfig } from "../../config";
+import { loadPlugins } from "../plugins";
+
+/**
+ * Update command options
+ */
+export interface UpdateOptions {
+  /** Project directory (defaults to cwd) */
+  path: string;
+}
+
+/**
+ * Update command result
+ */
+export interface UpdateResult {
+  /** Whether update succeeded */
+  success: boolean;
+  /** Synced items */
+  synced: string[];
+  /** Warning messages */
+  warnings: string[];
+  /** Error message if failed */
+  error?: string;
+}
+
+/**
+ * Copy directory contents recursively, filtering to .ts and .d.ts files
+ */
+function copyTypeFiles(src: string, dest: string): number {
+  if (!existsSync(src)) return 0;
+  mkdirSync(dest, { recursive: true });
+
+  let count = 0;
+  const entries = readdirSync(src);
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+
+    if (stat.isDirectory()) {
+      // Skip node_modules, tests, examples
+      if (entry === "node_modules" || entry === "__test__") continue;
+      count += copyTypeFiles(srcPath, destPath);
+    } else if (
+      entry.endsWith(".d.ts") ||
+      entry.endsWith(".json")
+    ) {
+      cpSync(srcPath, destPath);
+      count++;
+    }
+  }
+
+  return count;
+}
+
+/**
+ * Resolve the path to a package in node_modules
+ */
+function resolvePackagePath(packageName: string, projectDir: string): string | undefined {
+  // Try resolve from project dir
+  try {
+    const entryPoint = require.resolve(packageName, { paths: [projectDir] });
+    // Walk up from entry point to find package root
+    let dir = entryPoint;
+    while (dir !== "/") {
+      dir = join(dir, "..");
+      if (existsSync(join(dir, "package.json"))) {
+        const pkg = JSON.parse(require("fs").readFileSync(join(dir, "package.json"), "utf-8"));
+        if (pkg.name === packageName) return dir;
+      }
+    }
+  } catch {
+    // Package not installed
+  }
+
+  // Fallback: check common node_modules locations
+  const candidates = [
+    join(projectDir, "node_modules", ...packageName.split("/")),
+    join(projectDir, "..", "node_modules", ...packageName.split("/")),
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(join(candidate, "package.json"))) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+/**
+ * Execute the update command — sync lexicon types into .chant/
+ */
+export async function updateCommand(options: UpdateOptions): Promise<UpdateResult> {
+  const projectDir = resolve(options.path);
+  const synced: string[] = [];
+  const warnings: string[] = [];
+
+  // Load config to get lexicons
+  const { config } = await loadChantConfig(projectDir);
+  const lexicons = config.lexicons ?? [];
+
+  if (lexicons.length === 0) {
+    return {
+      success: false,
+      synced: [],
+      warnings: [],
+      error: "No lexicons configured. Add lexicons to chant.config.ts.",
+    };
+  }
+
+  const typesDir = join(projectDir, ".chant", "types");
+
+  // Sync core types
+  const corePkgPath = resolvePackagePath("@intentius/chant", projectDir);
+  if (corePkgPath) {
+    const coreDestDir = join(typesDir, "core");
+    const srcDir = join(corePkgPath, "src");
+    if (existsSync(srcDir)) {
+      const count = copyTypeFiles(srcDir, coreDestDir);
+      // Also copy package.json
+      if (existsSync(join(corePkgPath, "package.json"))) {
+        cpSync(join(corePkgPath, "package.json"), join(coreDestDir, "package.json"));
+      }
+      synced.push(`@intentius/chant (${count} files)`);
+    }
+  } else {
+    warnings.push("@intentius/chant not found in node_modules");
+  }
+
+  // Sync each lexicon
+  for (const lexicon of lexicons) {
+    const pkgName = `@intentius/chant-lexicon-${lexicon}`;
+    const pkgPath = resolvePackagePath(pkgName, projectDir);
+
+    if (!pkgPath) {
+      warnings.push(`${pkgName} not found in node_modules. Run "npm install" first.`);
+      continue;
+    }
+
+    const lexiconDestDir = join(typesDir, `lexicon-${lexicon}`);
+    const srcDir = join(pkgPath, "src");
+    if (existsSync(srcDir)) {
+      const count = copyTypeFiles(srcDir, lexiconDestDir);
+      if (existsSync(join(pkgPath, "package.json"))) {
+        cpSync(join(pkgPath, "package.json"), join(lexiconDestDir, "package.json"));
+      }
+      synced.push(`${pkgName} (${count} files)`);
+    } else {
+      warnings.push(`${pkgName} has no src/ directory`);
+    }
+  }
+
+  // Install skills from plugins
+  try {
+    const plugins = await loadPlugins(lexicons);
+    for (const plugin of plugins) {
+      if (plugin.skills) {
+        const skills = plugin.skills();
+        if (skills.length > 0) {
+          const skillsDir = join(projectDir, ".chant", "skills", plugin.name);
+          mkdirSync(skillsDir, { recursive: true });
+          for (const skill of skills) {
+            writeFileSync(join(skillsDir, `${skill.name}.md`), skill.content);
+          }
+          synced.push(`${plugin.name} skills (${skills.length})`);
+        }
+      }
+    }
+  } catch {
+    // Skills are optional — don't fail the update if plugin loading fails
+    warnings.push("Could not load plugins for skill installation");
+  }
+
+  return {
+    success: true,
+    synced,
+    warnings,
+  };
+}
+
+/**
+ * Print update result
+ */
+export function printUpdateResult(result: UpdateResult): void {
+  if (!result.success) {
+    console.error(formatError({ message: result.error ?? "Update failed" }));
+    return;
+  }
+
+  for (const warning of result.warnings) {
+    console.error(formatWarning({ message: warning }));
+  }
+
+  if (result.synced.length > 0) {
+    console.log(formatSuccess("Synced types:"));
+    for (const item of result.synced) {
+      console.log(`  ${item}`);
+    }
+  } else {
+    console.log("No types synced.");
+  }
+}

package/src/cli/conflict-check.test.ts

@@ -0,0 +1,255 @@
+import { describe, test, expect } from "bun:test";
+import { checkConflicts } from "./conflict-check";
+import type { LexiconPlugin } from "../lexicon";
+
+const mockSerializer = { name: "test", serialize: () => ({}) } as any;
+
+const noopAsync = async () => {};
+
+function makePlugin(
+  name: string,
+  opts: {
+    rules?: { id: string }[];
+    skills?: { name: string }[];
+    mcpTools?: { name: string }[];
+    mcpResources?: { uri: string }[];
+  } = {},
+): LexiconPlugin {
+  const plugin: LexiconPlugin = {
+    name,
+    serializer: { ...mockSerializer, name },
+    generate: noopAsync,
+    validate: noopAsync,
+    coverage: noopAsync,
+    package: noopAsync,
+    rollback: noopAsync,
+  };
+
+  if (opts.rules) {
+    const rules = opts.rules.map((r) => ({
+      id: r.id,
+      severity: "error" as const,
+      category: "correctness" as const,
+      check: () => [],
+    }));
+    (plugin as any).lintRules = () => rules;
+  }
+
+  if (opts.skills) {
+    const skills = opts.skills.map((s) => ({
+      name: s.name,
+      description: "",
+      content: "",
+    }));
+    (plugin as any).skills = () => skills;
+  }
+
+  if (opts.mcpTools) {
+    const tools = opts.mcpTools.map((t) => ({
+      name: t.name,
+      description: "",
+      inputSchema: { type: "object" as const, properties: {} },
+      handler: async () => "",
+    }));
+    (plugin as any).mcpTools = () => tools;
+  }
+
+  if (opts.mcpResources) {
+    const resources = opts.mcpResources.map((r) => ({
+      uri: r.uri,
+      name: "",
+      description: "",
+      handler: async () => "",
+    }));
+    (plugin as any).mcpResources = () => resources;
+  }
+
+  return plugin;
+}
+
+describe("checkConflicts", () => {
+  // -----------------------------------------------------------------------
+  // No conflicts
+  // -----------------------------------------------------------------------
+
+  test("returns clean report when no conflicts exist", () => {
+    const plugins = [
+      makePlugin("aws", { rules: [{ id: "AWS001" }] }),
+      makePlugin("gcp", { rules: [{ id: "GCP001" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(0);
+    expect(report.warnings).toHaveLength(0);
+  });
+
+  test("handles plugins with no optional methods", () => {
+    const plugins = [
+      makePlugin("aws"),
+      makePlugin("gcp"),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(0);
+    expect(report.warnings).toHaveLength(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // Rule ID conflicts (hard)
+  // -----------------------------------------------------------------------
+
+  test("detects duplicate rule IDs as hard conflicts", () => {
+    const plugins = [
+      makePlugin("aws", { rules: [{ id: "SHARED001" }, { id: "AWS001" }] }),
+      makePlugin("gcp", { rules: [{ id: "SHARED001" }, { id: "GCP001" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(1);
+    expect(report.conflicts[0]).toEqual({
+      type: "rule-id",
+      key: "SHARED001",
+      plugins: ["aws", "gcp"],
+    });
+    expect(report.warnings).toHaveLength(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // Skill conflicts (warnings)
+  // -----------------------------------------------------------------------
+
+  test("detects duplicate skill names as warnings", () => {
+    const plugins = [
+      makePlugin("aws", { skills: [{ name: "scaffold" }] }),
+      makePlugin("gcp", { skills: [{ name: "scaffold" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(0);
+    expect(report.warnings).toHaveLength(1);
+    expect(report.warnings[0]).toEqual({
+      type: "skill-name",
+      key: "scaffold",
+      plugins: ["aws", "gcp"],
+    });
+  });
+
+  // -----------------------------------------------------------------------
+  // MCP tool conflicts (warnings)
+  // -----------------------------------------------------------------------
+
+  test("detects duplicate MCP tool names as warnings", () => {
+    const plugins = [
+      makePlugin("aws", { mcpTools: [{ name: "diff" }] }),
+      makePlugin("gcp", { mcpTools: [{ name: "diff" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(0);
+    expect(report.warnings).toHaveLength(1);
+    expect(report.warnings[0]).toEqual({
+      type: "mcp-tool",
+      key: "diff",
+      plugins: ["aws", "gcp"],
+    });
+  });
+
+  test("no MCP tool conflict when names differ", () => {
+    const plugins = [
+      makePlugin("aws", { mcpTools: [{ name: "diff" }] }),
+      makePlugin("gcp", { mcpTools: [{ name: "deploy" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.warnings.filter((w) => w.type === "mcp-tool")).toHaveLength(0);
+  });
+
+  test("MCP tool conflict across three plugins", () => {
+    const plugins = [
+      makePlugin("aws", { mcpTools: [{ name: "scan" }] }),
+      makePlugin("gcp", { mcpTools: [{ name: "scan" }] }),
+      makePlugin("azure", { mcpTools: [{ name: "scan" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    const toolWarnings = report.warnings.filter((w) => w.type === "mcp-tool");
+    expect(toolWarnings).toHaveLength(1);
+    expect(toolWarnings[0].plugins).toEqual(["aws", "gcp", "azure"]);
+  });
+
+  // -----------------------------------------------------------------------
+  // MCP resource conflicts (warnings)
+  // -----------------------------------------------------------------------
+
+  test("detects duplicate MCP resource URIs as warnings", () => {
+    const plugins = [
+      makePlugin("aws", { mcpResources: [{ uri: "catalog" }] }),
+      makePlugin("gcp", { mcpResources: [{ uri: "catalog" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(0);
+    expect(report.warnings).toHaveLength(1);
+    expect(report.warnings[0]).toEqual({
+      type: "mcp-resource",
+      key: "catalog",
+      plugins: ["aws", "gcp"],
+    });
+  });
+
+  test("no MCP resource conflict when URIs differ", () => {
+    const plugins = [
+      makePlugin("aws", { mcpResources: [{ uri: "aws-catalog" }] }),
+      makePlugin("gcp", { mcpResources: [{ uri: "gcp-catalog" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.warnings.filter((w) => w.type === "mcp-resource")).toHaveLength(0);
+  });
+
+  // -----------------------------------------------------------------------
+  // Combined
+  // -----------------------------------------------------------------------
+
+  test("detects multiple conflict types simultaneously", () => {
+    const plugins = [
+      makePlugin("aws", {
+        rules: [{ id: "DUPE_RULE" }],
+        skills: [{ name: "scaffold" }],
+      }),
+      makePlugin("gcp", {
+        rules: [{ id: "DUPE_RULE" }],
+        skills: [{ name: "scaffold" }],
+      }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(1);
+    expect(report.conflicts[0].type).toBe("rule-id");
+    expect(report.warnings).toHaveLength(1);
+    expect(report.warnings.map((w) => w.type)).toContain("skill-name");
+  });
+
+  test("detects all four conflict types at once", () => {
+    const plugins = [
+      makePlugin("aws", {
+        rules: [{ id: "SHARED" }],
+        skills: [{ name: "scaffold" }],
+        mcpTools: [{ name: "scan" }],
+        mcpResources: [{ uri: "catalog" }],
+      }),
+      makePlugin("gcp", {
+        rules: [{ id: "SHARED" }],
+        skills: [{ name: "scaffold" }],
+        mcpTools: [{ name: "scan" }],
+        mcpResources: [{ uri: "catalog" }],
+      }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(1);
+    expect(report.warnings).toHaveLength(3);
+    const warningTypes = report.warnings.map((w) => w.type).sort();
+    expect(warningTypes).toEqual(["mcp-resource", "mcp-tool", "skill-name"]);
+  });
+
+  test("detects conflict across three plugins", () => {
+    const plugins = [
+      makePlugin("aws", { rules: [{ id: "SHARED" }] }),
+      makePlugin("gcp", { rules: [{ id: "SHARED" }] }),
+      makePlugin("azure", { rules: [{ id: "SHARED" }] }),
+    ];
+    const report = checkConflicts(plugins);
+    expect(report.conflicts).toHaveLength(1);
+    expect(report.conflicts[0].plugins).toEqual(["aws", "gcp", "azure"]);
+  });
+});

package/src/cli/conflict-check.ts

@@ -0,0 +1,89 @@
+import type { LexiconPlugin } from "../lexicon";
+
+export interface ConflictEntry {
+  type: "rule-id" | "skill-name" | "mcp-tool" | "mcp-resource";
+  key: string;
+  plugins: string[];
+}
+
+export interface ConflictReport {
+  conflicts: ConflictEntry[];
+  warnings: ConflictEntry[];
+}
+
+/**
+ * Check loaded lexicon plugins for cross-lexicon conflicts.
+ *
+ * - Duplicate rule IDs are hard conflicts (should cause a throw at load time).
+ * - Duplicate skill, MCP tool, or MCP resource names are soft conflicts (warnings).
+ */
+export function checkConflicts(plugins: LexiconPlugin[]): ConflictReport {
+  const conflicts: ConflictEntry[] = [];
+  const warnings: ConflictEntry[] = [];
+
+  // Check rule ID conflicts (hard conflict)
+  const ruleIds = new Map<string, string[]>();
+  for (const plugin of plugins) {
+    const rules = plugin.lintRules?.() ?? [];
+    for (const rule of rules) {
+      const existing = ruleIds.get(rule.id) ?? [];
+      existing.push(plugin.name);
+      ruleIds.set(rule.id, existing);
+    }
+  }
+  for (const [id, owners] of ruleIds) {
+    if (owners.length > 1) {
+      conflicts.push({ type: "rule-id", key: id, plugins: owners });
+    }
+  }
+
+  // Check skill name conflicts (warning)
+  const skillNames = new Map<string, string[]>();
+  for (const plugin of plugins) {
+    const skills = plugin.skills?.() ?? [];
+    for (const skill of skills) {
+      const existing = skillNames.get(skill.name) ?? [];
+      existing.push(plugin.name);
+      skillNames.set(skill.name, existing);
+    }
+  }
+  for (const [name, owners] of skillNames) {
+    if (owners.length > 1) {
+      warnings.push({ type: "skill-name", key: name, plugins: owners });
+    }
+  }
+
+  // Check MCP tool name conflicts (warning)
+  const mcpToolNames = new Map<string, string[]>();
+  for (const plugin of plugins) {
+    const tools = plugin.mcpTools?.() ?? [];
+    for (const tool of tools) {
+      const existing = mcpToolNames.get(tool.name) ?? [];
+      existing.push(plugin.name);
+      mcpToolNames.set(tool.name, existing);
+    }
+  }
+  for (const [name, owners] of mcpToolNames) {
+    if (owners.length > 1) {
+      warnings.push({ type: "mcp-tool", key: name, plugins: owners });
+    }
+  }
+
+  // Check MCP resource URI conflicts (warning)
+  const mcpResourceUris = new Map<string, string[]>();
+  for (const plugin of plugins) {
+    const resources = plugin.mcpResources?.() ?? [];
+    for (const resource of resources) {
+      const existing = mcpResourceUris.get(resource.uri) ?? [];
+      existing.push(plugin.name);
+      mcpResourceUris.set(resource.uri, existing);
+    }
+  }
+  for (const [uri, owners] of mcpResourceUris) {
+    if (owners.length > 1) {
+      warnings.push({ type: "mcp-resource", key: uri, plugins: owners });
+    }
+  }
+
+  return { conflicts, warnings };
+}

package/src/cli/debug.ts

@@ -0,0 +1,8 @@
+/**
+ * Debug logger — outputs to stderr when CHANT_DEBUG env var or --verbose/-v flag is set.
+ */
+export function debug(...args: unknown[]): void {
+  if (process.env.CHANT_DEBUG || process.argv.includes("--verbose") || process.argv.includes("-v")) {
+    console.error("[chant:debug]", ...args);
+  }
+}

package/src/cli/format.test.ts

@@ -0,0 +1,140 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import {
+  formatError,
+  formatWarning,
+  formatSuccess,
+  formatInfo,
+  formatBold,
+} from "./format";
+
+describe("formatError", () => {
+  // Save original env
+  const originalNoColor = process.env.NO_COLOR;
+
+  beforeEach(() => {
+    // Enable colors for testing
+    delete process.env.NO_COLOR;
+  });
+
+  afterEach(() => {
+    // Restore original env
+    if (originalNoColor !== undefined) {
+      process.env.NO_COLOR = originalNoColor;
+    } else {
+      delete process.env.NO_COLOR;
+    }
+  });
+
+  test("formats error with file, line, and column", () => {
+    const result = formatError({
+      file: "test.ts",
+      line: 10,
+      column: 5,
+      message: "Something went wrong",
+    });
+
+    expect(result).toContain("test.ts:10:5");
+    expect(result).toContain("error");
+    expect(result).toContain("Something went wrong");
+  });
+
+  test("formats error with file and line only", () => {
+    const result = formatError({
+      file: "test.ts",
+      line: 10,
+      message: "Something went wrong",
+    });
+
+    expect(result).toContain("test.ts:10");
+    expect(result).not.toContain("test.ts:10:");
+    expect(result).toContain("error");
+  });
+
+  test("formats error with file only", () => {
+    const result = formatError({
+      file: "test.ts",
+      message: "Something went wrong",
+    });
+
+    expect(result).toContain("test.ts");
+    expect(result).toContain("error");
+  });
+
+  test("formats error with message only", () => {
+    const result = formatError({
+      message: "Something went wrong",
+    });
+
+    expect(result).toContain("error");
+    expect(result).toContain("Something went wrong");
+    // Should not have file location prefix (no " - " before error)
+    expect(result).not.toContain(" - ");
+  });
+
+  test("respects NO_COLOR environment variable", () => {
+    process.env.NO_COLOR = "1";
+
+    const result = formatError({
+      file: "test.ts",
+      line: 10,
+      message: "Something went wrong",
+    });
+
+    // Should not contain ANSI escape codes
+    expect(result).not.toContain("\x1b[");
+    expect(result).toContain("test.ts:10");
+    expect(result).toContain("error");
+  });
+});
+
+describe("formatWarning", () => {
+  beforeEach(() => {
+    delete process.env.NO_COLOR;
+  });
+
+  test("formats warning with location", () => {
+    const result = formatWarning({
+      file: "test.ts",
+      line: 10,
+      column: 5,
+      message: "Potential issue",
+    });
+
+    expect(result).toContain("test.ts:10:5");
+    expect(result).toContain("warning");
+    expect(result).toContain("Potential issue");
+  });
+
+  test("formats warning with message only", () => {
+    const result = formatWarning({
+      message: "Potential issue",
+    });
+
+    expect(result).toContain("warning");
+    expect(result).toContain("Potential issue");
+  });
+});
+
+describe("formatSuccess", () => {
+  test("formats success message", () => {
+    const result = formatSuccess("Build complete");
+
+    expect(result).toContain("Build complete");
+  });
+});
+
+describe("formatInfo", () => {
+  test("formats info message", () => {
+    const result = formatInfo("Processing files...");
+
+    expect(result).toContain("Processing files...");
+  });
+});
+
+describe("formatBold", () => {
+  test("formats bold text", () => {
+    const result = formatBold("Important");
+
+    expect(result).toContain("Important");
+  });
+});