@intentius/chant 0.124.12 → 0.124.14

package/dist/cli/commands/describe.js

@@ -0,0 +1,85 @@
+import { resolve } from "path";
+import { discover } from "../../discovery/index.js";
+import { formatSuccess, formatBold } from "../format.js";
+/** Read a discovered entity's resolved props (same accessor the build pipeline uses). */
+function readProps(entity) {
+    return "props" in entity ? entity.props : undefined;
+}
+/**
+ * Find the entities a component name refers to. A composite instance is
+ * flattened at discovery: `WebApp(x)` exported as `foo` becomes `fooDeployment`,
+ * `fooService`, … — so an exact-name miss falls back to grouping entities whose
+ * name is the export prefix followed by a capitalized result key.
+ */
+function matchComponent(entities, component) {
+    const exact = entities.get(component);
+    if (exact)
+        return { matched: [[component, exact]], composite: false };
+    const grouped = [...entities].filter(([n]) => n.length > component.length &&
+        n.startsWith(component) &&
+        n.charAt(component.length) === n.charAt(component.length).toUpperCase() &&
+        n.charAt(component.length) !== n.charAt(component.length).toLowerCase());
+    grouped.sort((a, b) => a[0].localeCompare(b[0]));
+    return { matched: grouped, composite: grouped.length > 0 };
+}
+export async function describeCommand(options) {
+    const infraPath = resolve(options.path);
+    const result = await discover(infraPath);
+    if (result.errors.length > 0) {
+        return {
+            success: false,
+            component: options.component,
+            composite: false,
+            resources: [],
+            output: result.errors.map((e) => e.message).join("\n"),
+        };
+    }
+    const { matched, composite } = matchComponent(result.entities, options.component);
+    if (matched.length === 0) {
+        const known = [...result.entities.keys()].sort().join(", ");
+        return {
+            success: false,
+            component: options.component,
+            composite: false,
+            resources: [],
+            output: `No component "${options.component}" found.\nKnown components: ${known || "(none)"}`,
+        };
+    }
+    const resources = matched.map(([name, decl]) => ({
+        name,
+        lexicon: decl.lexicon ?? "",
+        entityType: decl.entityType ?? "",
+        kind: decl.kind ?? "resource",
+        props: readProps(decl),
+    }));
+    const output = options.format === "json"
+        ? JSON.stringify({ component: options.component, composite, resources }, null, 2)
+        : formatText(options.component, composite, resources);
+    return { success: true, component: options.component, composite, resources, output };
+}
+/** Human-readable effective-config view. */
+function formatText(component, composite, resources) {
+    const lines = [];
+    const header = composite
+        ? `${formatBold(component)} — composite instance, ${resources.length} resource(s)`
+        : `${formatBold(component)}`;
+    lines.push(header);
+    for (const r of resources) {
+        lines.push("");
+        lines.push(`  ${formatBold(r.name)}  (${r.entityType})`);
+        const propsJson = JSON.stringify(r.props ?? {}, null, 2)
+            .split("\n")
+            .map((l) => `    ${l}`)
+            .join("\n");
+        lines.push(propsJson);
+    }
+    return lines.join("\n");
+}
+/** Print a describe result to the console. */
+export function printDescribeResult(result) {
+    if (result.output)
+        console.log(result.output);
+    if (result.success) {
+        console.error(formatSuccess(`Described ${formatBold(result.component)}`));
+    }
+}

package/dist/cli/commands/diff.js

@@ -0,0 +1,175 @@
+import { resolve } from "path";
+import { readFileSync, existsSync } from "fs";
+import { build } from "../../build.js";
+import { formatSuccess, formatError } from "../format.js";
+/**
+ * Execute the diff command
+ */
+export async function diffCommand(options) {
+    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 = {};
+    const sortedLexiconNames = [...result.outputs.keys()].sort();
+    for (const lexiconName of sortedLexiconNames) {
+        const raw = result.outputs.get(lexiconName);
+        combined[lexiconName] = JSON.parse(typeof raw === "string" ? raw : raw.primary);
+    }
+    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, value) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
+    }
+    return value;
+}
+/**
+ * Simple line-by-line unified diff
+ */
+function unifiedDiff(previous, current, filename) {
+    const prevLines = previous ? previous.split("\n") : [];
+    const currLines = current.split("\n");
+    // Quick equality check
+    if (previous === current)
+        return "";
+    const lines = [];
+    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();
+    for (const i of removed)
+        allChangedLines.add(i);
+    // Map current line indices to approximate previous positions
+    let hunkLines = [];
+    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, curr) {
+    const prevSet = new Map();
+    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();
+    const removed = new Set(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, curr) {
+    // 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 = [];
+        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 = 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 = [];
+    let i = m;
+    let j = n;
+    const result = [];
+    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) {
+    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/dist/cli/commands/doctor.js

@@ -0,0 +1,350 @@
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { execSync } from "child_process";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { checkVersionCompatibility } from "../../lexicon-manifest.js";
+import { debug } from "../debug.js";
+import { loadPlugins, resolveProjectLexicons } from "../plugins.js";
+import { MCP_CONFIG_FILENAME, MCP_SETUP_COMMAND, mcpConfigPath } from "../mcp-config.js";
+import { loadCapabilityPlugin } from "../../components/capability-plugin-loader.js";
+import { isCapabilityPlugin } from "../../components/capability-plugin.js";
+import { findWorkspaceRoot } from "../../project-root.js";
+export async function doctorCommand(path) {
+    const checks = [];
+    const projectPath = path || ".";
+    // Check 0: Node.js is installed
+    try {
+        const nodeVersion = execSync("node --version", { encoding: "utf-8" }).trim();
+        checks.push({ name: "node-installed", status: "pass", message: nodeVersion });
+    }
+    catch (e) {
+        debug("node version check failed:", e);
+        checks.push({ name: "node-installed", status: "fail", message: "Node.js is not installed — see https://nodejs.org" });
+    }
+    // Check 1: Config exists and parses
+    const configPaths = [
+        join(projectPath, "chant.config.json"),
+        join(projectPath, "chant.config.ts"),
+    ];
+    let config = 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 }).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?.lexicons;
+    if (lexicons && Array.isArray(lexicons)) {
+        for (const lex of lexicons) {
+            // chant #2520 — a lexicon declared by module path is project source,
+            // not a package `chant update` copies types from.
+            if (typeof lex !== "string")
+                continue;
+            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) {
+                        let currentVersion = "0.0.8";
+                        try {
+                            const pkgDir = dirname(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))));
+                            const corePkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8"));
+                            currentVersion = corePkg.version ?? currentVersion;
+                        }
+                        catch { /* fallback */ }
+                        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 does NOT have paths (they break runtime resolution)
+    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 has compilerOptions.paths — these break runtime module resolution (tsx follows them). Remove the paths block." });
+            }
+            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 8b: package.json declares "type": "module" (#1421)
+    //
+    // Sibling of the tsconfig-paths check above, and filed for the same reason:
+    // both are project settings that silently break runtime module resolution.
+    //
+    // chant's core is ESM. When the project is CJS — `"type": "commonjs"`, or no
+    // `type` field at all — tsx loads project source through the CommonJS
+    // transform, so the project's `require` of `params.ts` and core's `import` of
+    // it produce two separate module records. `setBuildParams` mutates one object
+    // in place; project source reads the other, and sees `{}`.
+    //
+    // The result is a silent wrong answer, not a failure: chant prints
+    // `[param] tier = "prod" (cli)` and then emits the graph for the default. It
+    // hits `chant graph` (always the run path) and `chant build --no-fold`; plain
+    // `chant build` escapes only because folding substitutes parameters
+    // statically and never reads the shared object.
+    const projectPkgPath = join(projectPath, "package.json");
+    if (existsSync(projectPkgPath)) {
+        try {
+            const pkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
+            if (pkg.type === "module") {
+                checks.push({ name: "package-type-module", status: "pass" });
+            }
+            else {
+                const found = pkg.type ? `"type": "${pkg.type}"` : "no `type` field";
+                checks.push({
+                    name: "package-type-module",
+                    status: "warn",
+                    message: `package.json has ${found} — chant is ESM, and a CommonJS project reads build ` +
+                        `parameters as empty on the run path (\`chant graph\`, \`chant build --no-fold\`). ` +
+                        `Declarations conditioned on \`params.<name>\` silently take their default branch. ` +
+                        `Set "type": "module".`,
+                });
+            }
+        }
+        catch (e) {
+            debug("project package.json parse failed:", e);
+            checks.push({ name: "package-type-module", status: "warn", message: "Could not parse package.json" });
+        }
+    }
+    // Check 9: the project's MCP config exists and has a chant entry. Path and
+    // remediation both come from ../mcp-config.ts, so this check cannot drift
+    // away from what `chant init` and `chant update` write, and cannot name a
+    // command the registry does not have (chant #2383).
+    const mcpPath = mcpConfigPath(projectPath);
+    if (!existsSync(mcpPath)) {
+        checks.push({
+            name: "mcp-config",
+            status: "warn",
+            message: `${MCP_CONFIG_FILENAME} not found — run ${MCP_SETUP_COMMAND}`,
+        });
+    }
+    else {
+        try {
+            const mcp = JSON.parse(readFileSync(mcpPath, "utf-8"));
+            if (!mcp.mcpServers?.chant) {
+                checks.push({
+                    name: "mcp-config",
+                    status: "warn",
+                    message: `${MCP_CONFIG_FILENAME} missing mcpServers.chant entry — run ${MCP_SETUP_COMMAND}`,
+                });
+            }
+            else {
+                checks.push({ name: "mcp-config", status: "pass" });
+            }
+        }
+        catch (e) {
+            debug(`${MCP_CONFIG_FILENAME} parse failed:`, e);
+            checks.push({ name: "mcp-config", status: "fail", message: `${MCP_CONFIG_FILENAME} 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;
+            let missing = 0;
+            for (const skill of skills) {
+                if (!existsSync(join(projectPath, "skills", skill.name, "SKILL.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);
+    }
+    // Check: Capability plugin packages (#559, epic #551) — each name in
+    // config.capabilities must load and satisfy the CapabilityPlugin contract
+    // (../../components/capability-plugin.ts). A malformed capability package
+    // (missing/broken `capabilities()`, or the package failing to resolve at
+    // all) is reported as a `fail`, mirroring how a missing lexicon type
+    // directory fails above rather than warning.
+    const capabilityNames = config?.capabilities;
+    if (capabilityNames && Array.isArray(capabilityNames)) {
+        for (const name of capabilityNames) {
+            try {
+                const plugin = await loadCapabilityPlugin(name);
+                if (!isCapabilityPlugin(plugin)) {
+                    checks.push({
+                        name: `capability-${name}`,
+                        status: "fail",
+                        message: `Capability plugin "${name}" does not satisfy the CapabilityPlugin contract (missing name/version/capabilities())`,
+                    });
+                    continue;
+                }
+                const capabilities = plugin.capabilities();
+                if (!Array.isArray(capabilities)) {
+                    checks.push({
+                        name: `capability-${name}`,
+                        status: "fail",
+                        message: `Capability plugin "${name}": capabilities() did not return an array`,
+                    });
+                    continue;
+                }
+                checks.push({
+                    name: `capability-${name}`,
+                    status: "pass",
+                    message: `${capabilities.length} capability(ies) registered`,
+                });
+            }
+            catch (e) {
+                debug(`capability plugin check failed for ${name}:`, e);
+                checks.push({
+                    name: `capability-${name}`,
+                    status: "fail",
+                    message: `Capability plugin "${name}" could not be loaded: ${e instanceof Error ? e.message : String(e)}`,
+                });
+            }
+        }
+    }
+    // #2535: in a declared workspace, doctor shows the declaration checks, so
+    // a member of kind other shows as a warning. The walk up only tests
+    // whether files exist; nothing under workspace/ loads without a
+    // declaration, so level 0 is unchanged (#2525).
+    const workspace = findWorkspaceRoot(projectPath);
+    if (workspace) {
+        const { runDeclarationChecks } = await import("../../workspace/checks.js");
+        // The declaration and kind checks only: `chant workspace check` runs the
+        // member checks, which read every member's files.
+        const report = await runDeclarationChecks(workspace.dir, (file) => join(workspace.dir, file), { gather: false });
+        const shown = report.diagnostics.filter((d) => d.severity !== "info");
+        for (const d of shown) {
+            checks.push({ name: `workspace-${d.ruleId}`, status: d.severity === "error" ? "fail" : "warn", message: `${d.message} (${d.file}:${d.line})` });
+        }
+        if (shown.length === 0)
+            checks.push({ name: "workspace-declaration", status: "pass", message: report.file });
+    }
+    return {
+        checks,
+        success: checks.every(c => c.status !== "fail"),
+    };
+}