@intentius/chant 0.0.1

package/src/cli/commands/diff.ts

@@ -0,0 +1,221 @@
+import { resolve } from "path";
+import { readFileSync, existsSync } from "fs";
+import { build } from "../../build";
+import type { Serializer } from "../../serializer";
+import { formatSuccess, formatError, formatBold } from "../format";
+
+/**
+ * Diff command options
+ */
+export interface DiffOptions {
+  /** Path to infrastructure directory */
+  path: string;
+  /** Existing output file to diff against */
+  output?: string;
+  /** Serializers to use for serialization */
+  serializers: Serializer[];
+}
+
+/**
+ * Diff command result
+ */
+export interface DiffResult {
+  /** Whether the diff succeeded (no build errors) */
+  success: boolean;
+  /** Whether there are changes between current and previous */
+  hasChanges: boolean;
+  /** Unified diff output */
+  diff: string;
+}
+
+/**
+ * Execute the diff command
+ */
+export async function diffCommand(options: DiffOptions): Promise<DiffResult> {
+  const infraPath = resolve(options.path);
+
+  // Build current output
+  const result = await build(infraPath, options.serializers);
+
+  if (result.errors.length > 0) {
+    const messages = result.errors.map((e) => e.message).join("\n");
+    return { success: false, hasChanges: false, diff: messages };
+  }
+
+  // Combine lexicon outputs (sorted for determinism)
+  const combined: Record<string, unknown> = {};
+  const sortedLexiconNames = [...result.outputs.keys()].sort();
+  for (const lexiconName of sortedLexiconNames) {
+    combined[lexiconName] = JSON.parse(result.outputs.get(lexiconName)!);
+  }
+  const currentOutput = JSON.stringify(combined, sortedJsonReplacer, 2);
+
+  // Read previous output
+  let previousOutput = "";
+  if (options.output && existsSync(options.output)) {
+    previousOutput = readFileSync(resolve(options.output), "utf-8");
+  }
+
+  // Produce unified diff
+  const diff = unifiedDiff(previousOutput, currentOutput, options.output ?? "(none)");
+
+  return {
+    success: true,
+    hasChanges: diff.length > 0,
+    diff,
+  };
+}
+
+/**
+ * JSON.stringify replacer that sorts object keys for deterministic output
+ */
+function sortedJsonReplacer(_key: string, value: unknown): unknown {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>).sort(([a], [b]) => a.localeCompare(b))
+    );
+  }
+  return value;
+}
+
+/**
+ * Simple line-by-line unified diff
+ */
+function unifiedDiff(previous: string, current: string, filename: string): string {
+  const prevLines = previous ? previous.split("\n") : [];
+  const currLines = current.split("\n");
+
+  // Quick equality check
+  if (previous === current) return "";
+
+  const lines: string[] = [];
+  lines.push(`--- a/${filename}`);
+  lines.push(`+++ b/${filename}`);
+
+  // Simple diff: show removed then added lines using LCS-based approach
+  const { added, removed } = diffLines(prevLines, currLines);
+
+  if (removed.size === 0 && added.size === 0) return "";
+
+  // Build hunks
+  const allChangedLines = new Set<number>();
+  for (const i of removed) allChangedLines.add(i);
+
+  // Map current line indices to approximate previous positions
+  let hunkLines: string[] = [];
+  const contextSize = 3;
+
+  // Simple approach: output all removals then all additions with context
+  if (prevLines.length === 0) {
+    // Entirely new file
+    lines.push(`@@ -0,0 +1,${currLines.length} @@`);
+    for (const line of currLines) {
+      lines.push(`+${line}`);
+    }
+  } else {
+    // Use LCS result to produce interleaved diff
+    const { ops } = lcsOps(prevLines, currLines);
+    lines.push(`@@ -1,${prevLines.length} +1,${currLines.length} @@`);
+    for (const op of ops) {
+      lines.push(op);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Compute which lines were added and removed between two line arrays
+ */
+function diffLines(
+  prev: string[],
+  curr: string[]
+): { added: Set<number>; removed: Set<number> } {
+  const prevSet = new Map<string, number[]>();
+  for (let i = 0; i < prev.length; i++) {
+    const existing = prevSet.get(prev[i]) ?? [];
+    existing.push(i);
+    prevSet.set(prev[i], existing);
+  }
+
+  const added = new Set<number>();
+  const removed = new Set<number>(prev.map((_, i) => i));
+
+  for (let i = 0; i < curr.length; i++) {
+    const indices = prevSet.get(curr[i]);
+    if (indices && indices.length > 0) {
+      removed.delete(indices.shift()!);
+    } else {
+      added.add(i);
+    }
+  }
+
+  return { added, removed };
+}
+
+/**
+ * Produce diff operations using a simple LCS approach
+ */
+function lcsOps(prev: string[], curr: string[]): { ops: string[] } {
+  // For small diffs, use O(n*m) LCS; for large ones, fall back to simple
+  const maxSize = 10000;
+  if (prev.length * curr.length > maxSize) {
+    // Fall back to simple remove-all/add-all
+    const ops: string[] = [];
+    for (const line of prev) ops.push(`-${line}`);
+    for (const line of curr) ops.push(`+${line}`);
+    return { ops };
+  }
+
+  // Standard LCS DP
+  const m = prev.length;
+  const n = curr.length;
+  const dp: number[][] = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      if (prev[i - 1] === curr[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1;
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
+      }
+    }
+  }
+
+  // Backtrack to produce ops
+  const ops: string[] = [];
+  let i = m;
+  let j = n;
+  const result: string[] = [];
+
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && prev[i - 1] === curr[j - 1]) {
+      result.push(` ${prev[i - 1]}`);
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      result.push(`+${curr[j - 1]}`);
+      j--;
+    } else {
+      result.push(`-${prev[i - 1]}`);
+      i--;
+    }
+  }
+
+  return { ops: result.reverse() };
+}
+
+/**
+ * Print diff result to console
+ */
+export function printDiffResult(result: DiffResult): void {
+  if (!result.success) {
+    console.error(formatError({ message: result.diff }));
+    return;
+  }
+  if (result.diff) {
+    console.log(result.diff);
+  } else {
+    console.error(formatSuccess("No changes detected"));
+  }
+}

package/src/cli/commands/doctor.test.ts

@@ -0,0 +1,239 @@
+import { describe, test, expect } from "bun:test";
+import { doctorCommand } from "./doctor";
+import { withTestDir } from "@intentius/chant-test-utils";
+import { writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+
+describe("doctorCommand", () => {
+  test("config-exists fails when no config file present", async () => {
+    await withTestDir(async (testDir) => {
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "config-exists");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("fail");
+      expect(check!.message).toContain("No chant.config.json");
+    });
+  });
+
+  test("config-exists passes with chant.config.json", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(
+        join(testDir, "chant.config.json"),
+        JSON.stringify({ lexicons: ["aws"] }),
+      );
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "config-exists");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("pass");
+    });
+  });
+
+  test("config-exists passes with chant.config.ts", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(
+        join(testDir, "chant.config.ts"),
+        `export default { lexicons: ["aws"] };`,
+      );
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "config-exists");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("pass");
+    });
+  });
+
+  test("config-exists fails on invalid JSON", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "not valid json{{{");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "config-exists");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("fail");
+      expect(check!.message).toContain("Config parse error");
+    });
+  });
+
+  test("core-types fails when .chant/types/core/ missing", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "core-types");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("fail");
+      expect(check!.message).toContain("not found");
+    });
+  });
+
+  test("core-types passes when .chant/types/core/ has files", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      const coreDir = join(testDir, ".chant", "types", "core");
+      mkdirSync(coreDir, { recursive: true });
+      writeFileSync(join(coreDir, "index.d.ts"), "export {};");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "core-types");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("pass");
+    });
+  });
+
+  test("core-types fails when .chant/types/core/ is empty", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      const coreDir = join(testDir, ".chant", "types", "core");
+      mkdirSync(coreDir, { recursive: true });
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "core-types");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("fail");
+      expect(check!.message).toContain("empty");
+    });
+  });
+
+  test("detects stale/orphaned lexicon directories", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(
+        join(testDir, "chant.config.json"),
+        JSON.stringify({ lexicons: ["aws"] }),
+      );
+      const typesDir = join(testDir, ".chant", "types");
+      mkdirSync(join(typesDir, "core"), { recursive: true });
+      mkdirSync(join(typesDir, "lexicon-aws"), { recursive: true });
+      mkdirSync(join(typesDir, "lexicon-gcp"), { recursive: true });
+      writeFileSync(join(typesDir, "core", "index.d.ts"), "export {};");
+      writeFileSync(join(typesDir, "lexicon-aws", "index.d.ts"), "export {};");
+      writeFileSync(join(typesDir, "lexicon-gcp", "index.d.ts"), "export {};");
+
+      const report = await doctorCommand(testDir);
+      const staleCheck = report.checks.find((c) => c.name === "stale-lexicon-gcp");
+      expect(staleCheck).toBeDefined();
+      expect(staleCheck!.status).toBe("warn");
+      expect(staleCheck!.message).toContain("Orphaned");
+      expect(staleCheck!.message).toContain("gcp");
+    });
+  });
+
+  test("does not flag configured lexicon directories as stale", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(
+        join(testDir, "chant.config.json"),
+        JSON.stringify({ lexicons: ["aws"] }),
+      );
+      const typesDir = join(testDir, ".chant", "types");
+      mkdirSync(join(typesDir, "core"), { recursive: true });
+      mkdirSync(join(typesDir, "lexicon-aws"), { recursive: true });
+      writeFileSync(join(typesDir, "core", "index.d.ts"), "export {};");
+      writeFileSync(join(typesDir, "lexicon-aws", "index.d.ts"), "export {};");
+
+      const report = await doctorCommand(testDir);
+      const staleChecks = report.checks.filter((c) => c.name.startsWith("stale-"));
+      expect(staleChecks.length).toBe(0);
+    });
+  });
+
+  test("src-directory fails when missing", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "src-directory");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("fail");
+      expect(check!.message).toContain("not found");
+    });
+  });
+
+  test("src-directory passes with .ts files", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      mkdirSync(join(testDir, "src"), { recursive: true });
+      writeFileSync(join(testDir, "src", "main.ts"), "export {};");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "src-directory");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("pass");
+    });
+  });
+
+  test("report success is false when any check fails", async () => {
+    await withTestDir(async (testDir) => {
+      // No config, no src, no .chant — everything fails
+      const report = await doctorCommand(testDir);
+      expect(report.success).toBe(false);
+    });
+  });
+
+  test("report success is true when only warnings (no fails)", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      mkdirSync(join(testDir, "src"), { recursive: true });
+      writeFileSync(join(testDir, "src", "main.ts"), "export {};");
+      const coreDir = join(testDir, ".chant", "types", "core");
+      mkdirSync(coreDir, { recursive: true });
+      writeFileSync(join(coreDir, "index.d.ts"), "export {};");
+      // mcp-config will be a warn, but not a fail
+      const report = await doctorCommand(testDir);
+      expect(report.success).toBe(true);
+    });
+  });
+
+  test("lexicon-docs passes when docs/ exists in a lexicon project", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      mkdirSync(join(testDir, "src"), { recursive: true });
+      writeFileSync(join(testDir, "src", "plugin.ts"), "export {};");
+      mkdirSync(join(testDir, "docs"), { recursive: true });
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "lexicon-docs");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("pass");
+    });
+  });
+
+  test("lexicon-docs warns when docs/ is missing in a lexicon project", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      mkdirSync(join(testDir, "src"), { recursive: true });
+      writeFileSync(join(testDir, "src", "plugin.ts"), "export {};");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "lexicon-docs");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("warn");
+      expect(check!.message).toContain("docs/");
+    });
+  });
+
+  test("lexicon-docs check is skipped for non-lexicon projects", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      mkdirSync(join(testDir, "src"), { recursive: true });
+      writeFileSync(join(testDir, "src", "main.ts"), "export {};");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "lexicon-docs");
+      expect(check).toBeUndefined();
+    });
+  });
+
+  test("mcp-config warns when .mcp.json missing", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "mcp-config");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("warn");
+      expect(check!.message).toContain("not found");
+    });
+  });
+
+  test("mcp-config passes when .mcp.json has chant entry", async () => {
+    await withTestDir(async (testDir) => {
+      writeFileSync(join(testDir, "chant.config.json"), "{}");
+      writeFileSync(
+        join(testDir, ".mcp.json"),
+        JSON.stringify({ mcpServers: { chant: { command: "chant" } } }),
+      );
+      const report = await doctorCommand(testDir);
+      const check = report.checks.find((c) => c.name === "mcp-config");
+      expect(check).toBeDefined();
+      expect(check!.status).toBe("pass");
+    });
+  });
+});

package/src/cli/commands/doctor.ts

@@ -0,0 +1,224 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { execSync } from "child_process";
+import { join, resolve } from "path";
+import { checkVersionCompatibility } from "../../lexicon-manifest";
+import { debug } from "../debug";
+import { loadPlugins, resolveProjectLexicons } from "../plugins";
+
+export interface DoctorCheck {
+  name: string;
+  status: "pass" | "fail" | "warn";
+  message?: string;
+}
+
+export interface DoctorReport {
+  checks: DoctorCheck[];
+  success: boolean;
+}
+
+export async function doctorCommand(path: string): Promise<DoctorReport> {
+  const checks: DoctorCheck[] = [];
+  const projectPath = path || ".";
+
+  // Check 0: Bun is installed
+  try {
+    const bunVersion = execSync("bun --version", { encoding: "utf-8" }).trim();
+    checks.push({ name: "bun-installed", status: "pass", message: `v${bunVersion}` });
+  } catch (e) {
+    debug("bun version check failed:", e);
+    checks.push({ name: "bun-installed", status: "fail", message: "Bun is not installed — see https://bun.sh" });
+  }
+
+  // Check 1: Config exists and parses
+  const configPaths = [
+    join(projectPath, "chant.config.json"),
+    join(projectPath, "chant.config.ts"),
+  ];
+  let config: Record<string, unknown> | null = null;
+  const configFound = configPaths.find(p => existsSync(p));
+  if (!configFound) {
+    checks.push({ name: "config-exists", status: "fail", message: "No chant.config.json or chant.config.ts found" });
+  } else {
+    try {
+      if (configFound.endsWith(".json")) {
+        config = JSON.parse(readFileSync(configFound, "utf-8"));
+      }
+      checks.push({ name: "config-exists", status: "pass" });
+    } catch (err) {
+      checks.push({ name: "config-exists", status: "fail", message: `Config parse error: ${err instanceof Error ? err.message : String(err)}` });
+    }
+  }
+
+  // Check 2: src/ directory exists with .ts files
+  const srcDir = join(projectPath, "src");
+  if (!existsSync(srcDir)) {
+    checks.push({ name: "src-directory", status: "fail", message: "src/ directory not found" });
+  } else {
+    try {
+      const tsFiles = (readdirSync(srcDir, { recursive: true }) as string[]).filter(
+        (f) => f.endsWith(".ts")
+      );
+      if (tsFiles.length === 0) {
+        checks.push({ name: "src-directory", status: "warn", message: "src/ exists but contains no .ts files" });
+      } else {
+        checks.push({ name: "src-directory", status: "pass" });
+      }
+    } catch (e) {
+      debug("src directory read failed:", e);
+      checks.push({ name: "src-directory", status: "fail", message: "Cannot read src/ directory" });
+    }
+  }
+
+  // Check 3: .chant/types/core/ exists and is not empty
+  const coreTypesDir = join(projectPath, ".chant", "types", "core");
+  if (!existsSync(coreTypesDir)) {
+    checks.push({ name: "core-types", status: "fail", message: ".chant/types/core/ not found — run chant update" });
+  } else {
+    try {
+      const files = readdirSync(coreTypesDir);
+      if (files.length === 0) {
+        checks.push({ name: "core-types", status: "fail", message: ".chant/types/core/ is empty" });
+      } else {
+        checks.push({ name: "core-types", status: "pass" });
+      }
+    } catch (e) {
+      debug("core types directory read failed:", e);
+      checks.push({ name: "core-types", status: "fail", message: "Cannot read .chant/types/core/" });
+    }
+  }
+
+  // Check 4-6: Per-lexicon checks
+  const lexicons = (config as any)?.lexicons as string[] | undefined;
+  if (lexicons && Array.isArray(lexicons)) {
+    for (const lex of lexicons) {
+      const lexDir = join(projectPath, ".chant", "types", `lexicon-${lex}`);
+      if (!existsSync(lexDir)) {
+        checks.push({ name: `lexicon-${lex}-types`, status: "fail", message: `.chant/types/lexicon-${lex}/ not found — run chant update` });
+      } else {
+        const files = readdirSync(lexDir);
+        if (files.length === 0) {
+          checks.push({ name: `lexicon-${lex}-types`, status: "fail", message: `.chant/types/lexicon-${lex}/ is empty` });
+        } else {
+          checks.push({ name: `lexicon-${lex}-types`, status: "pass" });
+        }
+      }
+
+      // Check manifest version compatibility
+      const manifestPath = join(lexDir, "manifest.json");
+      if (existsSync(manifestPath)) {
+        try {
+          const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+          if (manifest.chantVersion) {
+            // Use a placeholder current version for now
+            const currentVersion = "0.1.0";
+            if (!checkVersionCompatibility(manifest.chantVersion, currentVersion)) {
+              checks.push({ name: `lexicon-${lex}-compat`, status: "warn", message: `Lexicon ${lex} requires chant ${manifest.chantVersion}` });
+            } else {
+              checks.push({ name: `lexicon-${lex}-compat`, status: "pass" });
+            }
+          }
+        } catch (e) {
+          debug(`manifest read failed for lexicon ${lex}:`, e);
+        }
+      }
+    }
+  }
+
+  // Check 7: No stale/orphaned lexicon directories
+  const typesDir = join(projectPath, ".chant", "types");
+  if (existsSync(typesDir)) {
+    try {
+      const dirs = readdirSync(typesDir);
+      for (const dir of dirs) {
+        if (dir === "core") continue;
+        if (!dir.startsWith("lexicon-")) continue;
+        const lexName = dir.replace("lexicon-", "");
+        if (lexicons && !lexicons.includes(lexName)) {
+          checks.push({ name: `stale-${dir}`, status: "warn", message: `Orphaned directory .chant/types/${dir}/ — lexicon "${lexName}" not in config` });
+        }
+      }
+    } catch (e) {
+      debug("types directory read failed:", e);
+    }
+  }
+
+  // Check 8: tsconfig.json has paths
+  const tsconfigPath = join(projectPath, "tsconfig.json");
+  if (existsSync(tsconfigPath)) {
+    try {
+      // Simple JSON parse — tsconfig may have comments, but we try
+      const raw = readFileSync(tsconfigPath, "utf-8");
+      // Strip single-line comments for basic parsing
+      const cleaned = raw.replace(/\/\/.*$/gm, "");
+      const tsconfig = JSON.parse(cleaned);
+      if (!tsconfig.compilerOptions?.paths) {
+        checks.push({ name: "tsconfig-paths", status: "warn", message: "tsconfig.json missing compilerOptions.paths" });
+      } else {
+        checks.push({ name: "tsconfig-paths", status: "pass" });
+      }
+    } catch (e) {
+      debug("tsconfig.json parse failed:", e);
+      checks.push({ name: "tsconfig-paths", status: "warn", message: "Could not parse tsconfig.json" });
+    }
+  }
+
+  // Check 9: .mcp.json exists and has chant entry
+  const mcpPath = join(projectPath, ".mcp.json");
+  if (!existsSync(mcpPath)) {
+    checks.push({ name: "mcp-config", status: "warn", message: ".mcp.json not found — run chant agent setup" });
+  } else {
+    try {
+      const mcp = JSON.parse(readFileSync(mcpPath, "utf-8"));
+      if (!mcp.mcpServers?.chant) {
+        checks.push({ name: "mcp-config", status: "warn", message: ".mcp.json missing mcpServers.chant entry" });
+      } else {
+        checks.push({ name: "mcp-config", status: "pass" });
+      }
+    } catch (e) {
+      debug(".mcp.json parse failed:", e);
+      checks.push({ name: "mcp-config", status: "fail", message: ".mcp.json is invalid JSON" });
+    }
+  }
+
+  // Check: Lexicon project docs/ directory
+  const isLexiconProject = existsSync(join(projectPath, "src", "plugin.ts"));
+  if (isLexiconProject) {
+    if (existsSync(join(projectPath, "docs"))) {
+      checks.push({ name: "lexicon-docs", status: "pass" });
+    } else {
+      checks.push({ name: "lexicon-docs", status: "warn", message: "docs/ directory not found — run `just docs` to generate" });
+    }
+  }
+
+  // Check: Skills installed for each plugin
+  try {
+    const lexiconNames = await resolveProjectLexicons(resolve(projectPath));
+    const plugins = await loadPlugins(lexiconNames);
+    for (const plugin of plugins) {
+      if (!plugin.skills) continue;
+      const skills = plugin.skills();
+      if (skills.length === 0) continue;
+      const skillsDir = join(projectPath, ".chant", "skills", plugin.name);
+      let missing = 0;
+      for (const skill of skills) {
+        if (!existsSync(join(skillsDir, `${skill.name}.md`))) {
+          missing++;
+        }
+      }
+      if (missing === 0) {
+        checks.push({ name: `skills-${plugin.name}`, status: "pass", message: `${skills.length} skill(s) installed` });
+      } else if (missing < skills.length) {
+        checks.push({ name: `skills-${plugin.name}`, status: "warn", message: `${missing}/${skills.length} skill(s) missing — run chant update` });
+      } else {
+        checks.push({ name: `skills-${plugin.name}`, status: "warn", message: `No skills installed — run chant update` });
+      }
+    }
+  } catch (e) {
+    debug("skills check failed:", e);
+  }
+
+  return {
+    checks,
+    success: checks.every(c => c.status !== "fail"),
+  };
+}