whale-igniter 1.1.0

package/dist/commands/insights.js

@@ -0,0 +1,123 @@
+import path from "node:path";
+import fs from "fs-extra";
+import ora from "ora";
+import { resolveTarget } from "../utils/paths.js";
+import { loadConfig } from "../utils/config.js";
+import { loadRefinements } from "../utils/refinements.js";
+import { loadDecisions } from "../utils/decisions.js";
+import { loadComponents } from "../utils/components.js";
+import { analyze } from "../analyzer/insights.js";
+import { collectReferencedFiles, normalizePath } from "../analyzer/imports.js";
+import { scanComponents } from "../scanner/componentScanner.js";
+import { aggregateTailwind } from "../scanner/tailwindScanner.js";
+import { ui } from "../ui/index.js";
+const SEVERITY_RANK = { info: 0, warning: 1, critical: 2 };
+export async function insightsCommand(targetArg, options = {}) {
+    const target = resolveTarget(targetArg);
+    if (!(await fs.pathExists(path.join(target, "whale.config.json")))) {
+        console.log();
+        console.log(ui.warn("No whale.config.json found at this target. Run `whale ignite` or `whale adopt` first."));
+        process.exitCode = 1;
+        return;
+    }
+    const jsonMode = !!options.json;
+    if (!jsonMode) {
+        console.log();
+        console.log(ui.header("Whale Igniter", "insights"));
+        console.log();
+    }
+    const spin = ora({ text: "Loading intelligence stores", stream: process.stderr }).start();
+    const config = await loadConfig(target);
+    const refinements = await loadRefinements(target);
+    const decisions = await loadDecisions(target);
+    const components = await loadComponents(target);
+    spin.succeed(`Loaded ${refinements.length} refinement(s), ${decisions.length} decision(s), ${components.length} component(s)`);
+    let referencedFiles;
+    let observations;
+    if (!options.skipScan) {
+        const spinScan = ora({ text: "Scanning source for imports and Tailwind usage", stream: process.stderr }).start();
+        try {
+            const [refs, scanned] = await Promise.all([collectReferencedFiles(target), scanComponents(target)]);
+            referencedFiles = refs;
+            const allClassStrings = scanned.flatMap((c) => c.classNames);
+            observations = allClassStrings.length > 0 ? aggregateTailwind(allClassStrings) : undefined;
+            spinScan.succeed(`Scanned ${refs.size} import reference(s)` +
+                (observations ? ` and ${observations.length} class observation(s)` : ""));
+        }
+        catch (err) {
+            spinScan.warn(`Scan failed: ${err?.message ?? err}. Continuing without orphan/drift insights.`);
+        }
+    }
+    const normalisedComponents = referencedFiles
+        ? components.map((c) => ({ ...c, files: c.files?.map(normalizePath) }))
+        : components;
+    const insights = analyze({
+        config,
+        refinements,
+        decisions,
+        components: normalisedComponents,
+        observations,
+        referencedFiles
+    });
+    return printOrEmit(insights, options);
+}
+function printOrEmit(insights, options) {
+    let filtered = insights;
+    if (options.category)
+        filtered = filtered.filter((i) => i.category === options.category);
+    if (options.minSeverity) {
+        const min = SEVERITY_RANK[options.minSeverity];
+        filtered = filtered.filter((i) => SEVERITY_RANK[i.severity] >= min);
+    }
+    if (options.json) {
+        process.stdout.write(JSON.stringify(filtered, null, 2) + "\n");
+        return;
+    }
+    console.log();
+    if (filtered.length === 0) {
+        console.log(ui.ok("No insights to report. Stores look healthy."));
+        console.log();
+        return;
+    }
+    const groups = { critical: [], warning: [], info: [] };
+    for (const i of filtered)
+        groups[i.severity].push(i);
+    for (const sev of ["critical", "warning", "info"]) {
+        const items = groups[sev];
+        if (items.length === 0)
+            continue;
+        console.log(severityHeading(sev, items.length));
+        console.log();
+        for (const ins of items) {
+            console.log(ui.indent(ui.emphasis(ins.title)));
+            console.log(ui.indent(ui.muted(ins.detail), 1));
+            if (ins.evidence && ins.evidence.length > 0) {
+                console.log(ui.indent(ui.muted("Evidence"), 1));
+                for (const e of ins.evidence.slice(0, 5)) {
+                    console.log(ui.indent(ui.dot(e), 2));
+                }
+                if (ins.evidence.length > 5) {
+                    console.log(ui.indent(ui.muted(`… and ${ins.evidence.length - 5} more`), 2));
+                }
+            }
+            if (ins.action) {
+                console.log(ui.indent(`${ui.glyph.arrow} ${ins.action}`, 1));
+            }
+            console.log();
+        }
+    }
+    console.log(ui.summary([
+        { label: "total", value: filtered.length, tone: "muted" },
+        { label: "critical", value: groups.critical.length, tone: groups.critical.length > 0 ? "danger" : "muted" },
+        { label: "warning", value: groups.warning.length, tone: groups.warning.length > 0 ? "warn" : "muted" },
+        { label: "info", value: groups.info.length, tone: "muted" }
+    ]));
+    console.log();
+}
+function severityHeading(sev, count) {
+    const label = sev.toUpperCase();
+    const styled = sev === "critical" ? ui.danger(ui.emphasis(label))
+        : sev === "warning" ? ui.warning(ui.emphasis(label))
+            : ui.info(ui.emphasis(label));
+    return `${styled}  ${ui.muted("(" + count + ")")}`;
+}

package/dist/commands/mcp.js

@@ -0,0 +1,106 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { resolveTarget } from "../utils/paths.js";
+import { startMcpServer } from "../mcp/server.js";
+import { ui } from "../ui/index.js";
+/**
+ * `whale mcp serve` — start the MCP server on stdio.
+ *
+ * This is the long-running entry point invoked by AI clients (Claude
+ * Code, Cursor, Zed) via their MCP config. Never prints to stdout
+ * because stdout is the protocol channel.
+ */
+export async function mcpServeCommand() {
+    await startMcpServer();
+}
+export async function mcpConfigCommand(options = {}) {
+    const target = resolveTarget(options.project);
+    const exists = await fs.pathExists(path.join(target, "whale.config.json"));
+    if (!exists) {
+        console.log(ui.warn(`No whale.config.json found at ${ui.path(target)}.`));
+        console.log(ui.muted("  Run `whale ignite` or `whale adopt` first, then come back."));
+    }
+    const absTarget = path.resolve(target);
+    const client = options.client ?? "claude-code";
+    console.log(ui.header("Whale Igniter", `mcp config • ${client}`));
+    console.log();
+    switch (client) {
+        case "claude-code":
+            printClaudeCodeConfig(absTarget);
+            break;
+        case "cursor":
+            printCursorConfig(absTarget);
+            break;
+        case "zed":
+            printZedConfig(absTarget);
+            break;
+        case "raw":
+            printRawConfig(absTarget);
+            break;
+        default:
+            console.log(ui.fail(`Unknown client: ${client}`));
+            console.log(ui.muted("Try: --client claude-code | cursor | zed | raw"));
+            process.exitCode = 1;
+    }
+    console.log();
+    console.log(ui.muted("Replace `whale` with the absolute path to the binary if it isn't on your PATH."));
+    console.log(ui.muted(`The WHALE_PROJECT env var pins the workspace to ${absTarget}.`));
+}
+function printClaudeCodeConfig(target) {
+    console.log("Add this to your Claude Desktop config file:");
+    console.log(ui.muted("  macOS:  ~/Library/Application Support/Claude/claude_desktop_config.json"));
+    console.log(ui.muted("  Linux:  ~/.config/Claude/claude_desktop_config.json"));
+    console.log(ui.muted("  Win:    %APPDATA%\\Claude\\claude_desktop_config.json"));
+    console.log();
+    console.log("```json");
+    console.log(JSON.stringify({
+        mcpServers: {
+            "whale-igniter": {
+                command: "whale",
+                args: ["mcp", "serve"],
+                env: { WHALE_PROJECT: target }
+            }
+        }
+    }, null, 2));
+    console.log("```");
+}
+function printCursorConfig(target) {
+    console.log("Add this to `.cursor/mcp.json` in your project (or `~/.cursor/mcp.json` globally):");
+    console.log();
+    console.log("```json");
+    console.log(JSON.stringify({
+        mcpServers: {
+            "whale-igniter": {
+                command: "whale",
+                args: ["mcp", "serve"],
+                env: { WHALE_PROJECT: target }
+            }
+        }
+    }, null, 2));
+    console.log("```");
+}
+function printZedConfig(target) {
+    console.log("Zed reads MCP servers from `~/.config/zed/settings.json`:");
+    console.log();
+    console.log("```json");
+    console.log(JSON.stringify({
+        context_servers: {
+            "whale-igniter": {
+                command: { path: "whale", args: ["mcp", "serve"], env: { WHALE_PROJECT: target } }
+            }
+        }
+    }, null, 2));
+    console.log("```");
+}
+function printRawConfig(target) {
+    console.log("Raw stdio invocation — for clients that follow the MCP spec generically:");
+    console.log();
+    console.log(ui.accent("  Command:"));
+    console.log("    whale mcp serve");
+    console.log();
+    console.log(ui.accent("  Environment:"));
+    console.log(`    WHALE_PROJECT=${target}`);
+    console.log();
+    console.log(ui.accent("  Transport:"));
+    console.log("    stdio");
+}

package/dist/commands/refine.js

@@ -0,0 +1,36 @@
+import { randomUUID } from "node:crypto";
+import { resolveTarget } from "../utils/paths.js";
+import { appendRefinement, inferScope } from "../utils/refinements.js";
+import { generateWiki } from "../generators/wikiGenerator.js";
+import { ui } from "../ui/index.js";
+export async function refineCommand(note, options = {}) {
+    const target = resolveTarget();
+    const scope = inferScope(note);
+    const refinement = {
+        id: randomUUID(),
+        timestamp: new Date().toISOString(),
+        note,
+        scope
+    };
+    await appendRefinement(target, refinement);
+    console.log(ui.ok("Refinement recorded"));
+    if (scope) {
+        const parts = [];
+        if (scope.issueType)
+            parts.push(`type=${scope.issueType}`);
+        if (scope.selector)
+            parts.push(`selector=${scope.selector}`);
+        if (scope.file)
+            parts.push(`file=${scope.file}`);
+        console.log(`  ${ui.accent("Active scope:")} ${parts.join(", ")}`);
+        console.log(`  ${ui.muted("Matching issues will be suppressed in future validations.")}`);
+    }
+    else {
+        console.log(`  ${ui.muted("Note logged. No active scope inferred — will not affect validation.")}`);
+        console.log(`  ${ui.muted("Tip: mention an issue type (radius, spacing, hex, focus) to activate.")}`);
+    }
+    if (options.sync !== false) {
+        await generateWiki(target);
+        console.log(ui.muted(`${ui.glyph.check} AI context updated`));
+    }
+}