whale-igniter 1.2.2 → 1.3.0

package/dist/commands/changes.js

@@ -0,0 +1,127 @@
+import { execSync } from "node:child_process";
+import { resolveTarget } from "../utils/paths.js";
+import { loadDecisions } from "../utils/decisions.js";
+import { loadComponents } from "../utils/components.js";
+import { loadRefinements } from "../utils/refinements.js";
+import { ui } from "../ui/index.js";
+const INTELLIGENCE_FILES = [
+    "intelligence/decisions.json",
+    "intelligence/components.json",
+    "intelligence/refinements.json",
+    "whale.config.json"
+];
+function gitDiffFiles(target, since) {
+    try {
+        const result = execSync(`git diff --name-only ${since} HEAD -- ${INTELLIGENCE_FILES.join(" ")}`, {
+            cwd: target,
+            encoding: "utf8"
+        });
+        return result.trim().split("\n").filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function gitFileAtRef(target, ref, file) {
+    try {
+        const raw = execSync(`git show ${ref}:${file}`, { cwd: target, encoding: "utf8" });
+        return JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+}
+export async function changesCommand(opts) {
+    const target = resolveTarget(opts.target);
+    const since = opts.since ?? "HEAD~1";
+    const changedFiles = gitDiffFiles(target, since);
+    if (changedFiles.length === 0) {
+        console.log(ui.note(`No intelligence store changes since ${since}`));
+        return;
+    }
+    console.log(ui.section(`Changes since ${since}`));
+    const summary = {
+        decisions: { added: [], removed: [], modified: [] },
+        components: { added: [], removed: [] },
+        refinements: { added: [], removed: [] },
+        configChanged: false
+    };
+    if (changedFiles.includes("whale.config.json")) {
+        summary.configChanged = true;
+    }
+    if (changedFiles.includes("intelligence/decisions.json")) {
+        const before = gitFileAtRef(target, since, "intelligence/decisions.json");
+        const after = await loadDecisions(target);
+        const beforeIds = new Map(before.map((d) => [d.id, d.title]));
+        const afterIds = new Map(after.map((d) => [d.id, d.title]));
+        for (const [id, title] of afterIds) {
+            if (!beforeIds.has(id))
+                summary.decisions.added.push(title);
+        }
+        for (const [id, title] of beforeIds) {
+            if (!afterIds.has(id))
+                summary.decisions.removed.push(title);
+            else if (afterIds.get(id) !== title)
+                summary.decisions.modified.push(title);
+        }
+    }
+    if (changedFiles.includes("intelligence/components.json")) {
+        const before = gitFileAtRef(target, since, "intelligence/components.json");
+        const after = await loadComponents(target);
+        const beforeNames = new Set(before.map((c) => c.name));
+        const afterNames = new Set(after.map((c) => c.name));
+        for (const name of afterNames) {
+            if (!beforeNames.has(name))
+                summary.components.added.push(name);
+        }
+        for (const name of beforeNames) {
+            if (!afterNames.has(name))
+                summary.components.removed.push(name);
+        }
+    }
+    if (changedFiles.includes("intelligence/refinements.json")) {
+        const before = gitFileAtRef(target, since, "intelligence/refinements.json");
+        const after = await loadRefinements(target);
+        const beforeIds = new Set(before.map((r) => r.id));
+        const afterIds = new Set(after.map((r) => r.id));
+        const beforeNotes = new Map(before.map((r) => [r.id, r.note]));
+        for (const r of after) {
+            if (!beforeIds.has(r.id))
+                summary.refinements.added.push(r.note);
+        }
+        for (const [id, note] of beforeNotes) {
+            if (!afterIds.has(id))
+                summary.refinements.removed.push(note);
+        }
+    }
+    // ---- Render ----------------------------------------------------------------
+    if (summary.configChanged) {
+        console.log(ui.note("whale.config.json changed"));
+    }
+    const { decisions: d } = summary;
+    if (d.added.length || d.removed.length || d.modified.length) {
+        console.log(ui.section("Decisions"));
+        for (const t of d.added)
+            console.log(ui.ok(`+ ${t}`));
+        for (const t of d.removed)
+            console.log(ui.fail(`- ${t}`));
+        for (const t of d.modified)
+            console.log(ui.warn(`~ ${t}`));
+    }
+    const { components: c } = summary;
+    if (c.added.length || c.removed.length) {
+        console.log(ui.section("Components"));
+        for (const n of c.added)
+            console.log(ui.ok(`+ ${n}`));
+        for (const n of c.removed)
+            console.log(ui.fail(`- ${n}`));
+    }
+    const { refinements: r } = summary;
+    if (r.added.length || r.removed.length) {
+        console.log(ui.section("Refinements"));
+        for (const n of r.added)
+            console.log(ui.ok(`+ ${n}`));
+        for (const n of r.removed)
+            console.log(ui.fail(`- ${n}`));
+    }
+}

package/dist/commands/ignite.js

@@ -5,6 +5,9 @@ import { loadConfig, saveConfig, DEFAULT_CONFIG } from "../utils/config.js";
 import { getPack, listPacks } from "../utils/registry.js";
 import { validateCss } from "../validators/cssValidator.js";
 import { generateWiki } from "../generators/wikiGenerator.js";
+import { appendDecision } from "../utils/decisions.js";
+import { getAiAvailability } from "../utils/aiAvailability.js";
+import { mapWizardAnswers, suggestUiCategories } from "../utils/wizardMapping.js";
 import { ui } from "../ui/index.js";
 import { PACKAGE_VERSION } from "../version.js";
 const OPINIONATED_PACKS = ["lighthouse", "forge", "scribe"];
@@ -20,8 +23,11 @@ export async function igniteCommand(projectName = "whale-project", options = {})
     console.log();
     // ---- Resolve config based on mode -----------------------------------------
     let config;
+    let projectIntentNote;
     if (mode === "interactive") {
-        config = await runWizard(projectName);
+        const result = await runWizard(projectName);
+        config = result.config;
+        projectIntentNote = result.projectIntentNote;
     }
     else if (mode === "minimal") {
         config = {
@@ -43,6 +49,16 @@ export async function igniteCommand(projectName = "whale-project", options = {})
     const target = await initCommand(projectName, { config, silent: true });
     const targetRel = path.relative(process.cwd(), target) || ".";
     console.log(ui.ok(`Workspace created at ${ui.path(targetRel)}`));
+    // ---- Step 1b: record free-text project intent as first decision ------------
+    if (projectIntentNote) {
+        await appendDecision(target, {
+            title: "Project intent",
+            category: "product",
+            context: "Captured at project creation via `whale ignite --interactive`.",
+            decision: projectIntentNote
+        });
+        console.log(ui.ok("Project intent recorded as first decision."));
+    }
     // ---- Step 2: confirm packs against registry -------------------------------
     console.log();
     console.log(ui.section("Packs"));
@@ -58,6 +74,9 @@ export async function igniteCommand(projectName = "whale-project", options = {})
         validPacks.push(name);
         packLines.push(`${ui.glyph.check} ${ui.code(name)} ${ui.muted(`(${pack.kind})`)} — ${pack.description}`);
     }
+    if (packLines.length === 0) {
+        packLines.push(ui.muted("(no packs selected)"));
+    }
     console.log(ui.indent(packLines.join("\n")));
     finalConfig.packs = validPacks;
     finalConfig.ignited = {
@@ -127,86 +146,133 @@ export async function igniteCommand(projectName = "whale-project", options = {})
     console.log();
 }
 // ---------------------------------------------------------------------------
-// Interactive wizard — unchanged logic, just uses ui for the header.
+// Interactive wizard — human-language questions, technical config is derived.
 // ---------------------------------------------------------------------------
 async function runWizard(defaultName) {
     console.log(ui.muted("Answer a few questions to shape your workspace. Ctrl+C to cancel."));
     console.log();
-    const allPacks = listPacks();
-    const answers = await prompts([
-        { type: "text", name: "projectName", message: "Project name:", initial: defaultName },
-        {
-            type: "select",
-            name: "projectType",
-            message: "Project type:",
-            choices: [
-                { title: "Landing page", value: "landing-page" },
-                { title: "Web app", value: "web-app" },
-                { title: "Component library", value: "component-library" },
-                { title: "Documentation site", value: "docs-site" },
-                { title: "Other", value: "other" }
-            ]
-        },
-        {
-            type: "select",
-            name: "stack",
-            message: "Styling stack:",
-            choices: [
-                { title: "Plain CSS", value: "css" },
-                { title: "Tailwind", value: "tailwind" },
-                { title: "SCSS / Sass", value: "scss" },
-                { title: "CSS-in-JS (styled-components, emotion, ...)", value: "css-in-js" }
-            ]
-        },
-        { type: "number", name: "grid", message: "Grid unit (px):", initial: 8, min: 1, max: 32 },
-        { type: "number", name: "radiusControl", message: "Radius for controls (buttons, inputs):", initial: 2, min: 0, max: 64 },
-        { type: "number", name: "radiusContainer", message: "Radius for containers (cards, modals):", initial: 4, min: 0, max: 64 },
-        {
-            type: "multiselect",
-            name: "packs",
-            message: "Packs to install:",
-            instructions: false,
-            hint: "space to toggle, enter to confirm",
-            choices: allPacks.map((p) => ({
-                title: `${p.name} (${p.kind})`,
-                description: p.description,
-                value: p.name,
-                selected: OPINIONATED_PACKS.includes(p.name)
-            }))
-        },
-        {
-            type: "multiselect",
-            name: "aiTargets",
-            message: "AI agents to generate context for:",
-            instructions: false,
-            hint: "space to toggle, enter to confirm",
-            choices: [
-                { title: "Claude (CLAUDE.md)", value: "claude", selected: true },
-                { title: "Codex / Generic agent (AGENTS.md)", value: "codex" },
-                { title: "Cursor (.cursorrules)", value: "cursor" },
-                { title: "GitHub Copilot (.github/copilot-instructions.md)", value: "copilot" }
-            ]
-        }
-    ], {
-        onCancel: () => {
-            console.log();
-            console.log(ui.warn("Ignite cancelled."));
-            process.exit(130);
+    const onCancel = () => {
+        console.log();
+        console.log(ui.warn("Ignite cancelled."));
+        process.exit(130);
+    };
+    // Q0: project name
+    const { projectName } = await prompts({ type: "text", name: "projectName", message: "Project name:", initial: defaultName }, { onCancel });
+    // Q1: what are you building?
+    const { projectType } = await prompts({
+        type: "select",
+        name: "projectType",
+        message: "What are you building?",
+        choices: [
+            { title: "Web app", value: "web-app" },
+            { title: "Marketing site", value: "marketing-site" },
+            { title: "Portfolio", value: "portfolio" },
+            { title: "Internal tool", value: "internal-tool" },
+            { title: "Prototype", value: "prototype" },
+            { title: "Something else", value: "other" }
+        ]
+    }, { onCancel });
+    let projectTypeOther;
+    if (projectType === "other") {
+        const { freeText } = await prompts({ type: "text", name: "freeText", message: "Describe it briefly:" }, { onCancel });
+        projectTypeOther = freeText;
+    }
+    // Q2: stack — choices reordered by what's most likely for this project type
+    const appFirstChoices = [
+        { title: "TypeScript + React", value: "react-ts" },
+        { title: "TypeScript + Vue", value: "vue-ts" },
+        { title: "TypeScript + Svelte", value: "svelte-ts" },
+        { title: "Plain HTML + CSS + JS", value: "html-css-js" },
+        { title: "Other", value: "other" }
+    ];
+    const staticFirstChoices = [
+        { title: "Plain HTML + CSS + JS", value: "html-css-js" },
+        { title: "TypeScript + React", value: "react-ts" },
+        { title: "TypeScript + Vue", value: "vue-ts" },
+        { title: "TypeScript + Svelte", value: "svelte-ts" },
+        { title: "Other", value: "other" }
+    ];
+    const stackChoices = projectType === "web-app" || projectType === "internal-tool"
+        ? appFirstChoices
+        : staticFirstChoices;
+    const { stack } = await prompts({
+        type: "select",
+        name: "stack",
+        message: "What language or framework?",
+        choices: stackChoices
+    }, { onCancel });
+    let stackOther;
+    if (stack === "other") {
+        const { freeText } = await prompts({ type: "text", name: "freeText", message: "Briefly describe it (we'll use plain CSS defaults):" }, { onCancel });
+        stackOther = freeText;
+    }
+    // Q3: team size
+    const { teamSize } = await prompts({
+        type: "select",
+        name: "teamSize",
+        message: "Who will work on this?",
+        choices: [
+            { title: "Just me", value: "solo" },
+            { title: "A small team (2–5 people)", value: "small" },
+            { title: "A larger team (6+)", value: "large" }
+        ]
+    }, { onCancel });
+    // Q4: UI references — only if AI is available
+    let uiCategories;
+    const ai = await getAiAvailability();
+    if (ai.available) {
+        const suggested = suggestUiCategories(projectType);
+        const { addRefs } = await prompts({
+            type: "confirm",
+            name: "addRefs",
+            message: "Add UI component references to this project?",
+            initial: true
+        }, { onCancel });
+        if (addRefs) {
+            const allCategories = ["forms", "navigation", "feedback", "surface", "layout", "data-display"];
+            const { selected } = await prompts({
+                type: "multiselect",
+                name: "selected",
+                message: "Which categories? (space to toggle, enter to confirm)",
+                instructions: false,
+                hint: "suggested for this project type are pre-selected",
+                choices: allCategories.map((cat) => ({
+                    title: cat,
+                    value: cat,
+                    selected: suggested.includes(cat)
+                }))
+            }, { onCancel });
+            uiCategories = selected ?? suggested;
         }
-    });
-    return {
-        ...DEFAULT_CONFIG,
-        projectName: answers.projectName,
-        projectType: answers.projectType,
-        stack: answers.stack,
-        packs: answers.packs && answers.packs.length > 0 ? answers.packs : OPINIONATED_PACKS,
-        aiTargets: answers.aiTargets && answers.aiTargets.length > 0 ? answers.aiTargets : ["claude"],
-        foundations: {
-            grid: answers.grid ?? 8,
-            radius: {
-                control: answers.radiusControl ?? 2,
-                container: answers.radiusContainer ?? 4
-            }
+        else {
+            uiCategories = [];
         }
+    }
+    // Q5: agent packs
+    const allPacks = listPacks();
+    const { agentPacks } = await prompts({
+        type: "multiselect",
+        name: "agentPacks",
+        message: "Which agent packs to install?",
+        instructions: false,
+        hint: "space to toggle, enter to confirm",
+        choices: allPacks.map((p) => ({
+            title: `${p.name} — ${p.description}`,
+            value: p.name,
+            selected: p.name === "selene"
+        }))
+    }, { onCancel });
+    // Map human answers to technical config
+    const wizardAnswers = {
+        projectType,
+        projectTypeOther,
+        stack,
+        stackOther,
+        teamSize,
+        uiCategories,
+        agentPacks
     };
+    const result = mapWizardAnswers(wizardAnswers);
+    result.config.projectName = projectName;
+    return result;
 }

package/dist/commands/insights.js

@@ -1,16 +1,23 @@
 import path from "node:path";
 import fs from "fs-extra";
 import ora from "ora";
+import prompts from "prompts";
 import { resolveTarget } from "../utils/paths.js";
 import { loadConfig } from "../utils/config.js";
-import { loadRefinements } from "../utils/refinements.js";
+import { loadRefinements, appendRefinement } from "../utils/refinements.js";
 import { loadDecisions } from "../utils/decisions.js";
 import { loadComponents } from "../utils/components.js";
-import { analyze } from "../analyzer/insights.js";
+import { analyze, analyzeSpacingDrift, analyzeColorDrift, analyzeRadiiDrift } from "../analyzer/insights.js";
 import { collectReferencedFiles, normalizePath } from "../analyzer/imports.js";
 import { scanComponents } from "../scanner/componentScanner.js";
 import { aggregateTailwind } from "../scanner/tailwindScanner.js";
+import { extractFromCssFiles } from "../scanner/extractors/css.js";
+import { extractFromInlineStyles } from "../scanner/extractors/inline.js";
+import { extractFromStyleBlocks } from "../scanner/extractors/styleBlocks.js";
 import { ui } from "../ui/index.js";
+import { writeJsonFile } from "../utils/writeJson.js";
+import { getAiAvailability } from "../utils/aiAvailability.js";
+import { randomUUID } from "node:crypto";
 const SEVERITY_RANK = { info: 0, warning: 1, critical: 2 };
 export async function insightsCommand(targetArg, options = {}) {
     const target = resolveTarget(targetArg);
@@ -34,18 +41,28 @@ export async function insightsCommand(targetArg, options = {}) {
     spin.succeed(`Loaded ${refinements.length} refinement(s), ${decisions.length} decision(s), ${components.length} component(s)`);
     let referencedFiles;
     let observations;
+    let styleObservations;
     if (!options.skipScan) {
-        const spinScan = ora({ text: "Scanning source for imports and Tailwind usage", stream: process.stderr }).start();
+        const spinScan = ora({ text: "Scanning source files", stream: process.stderr }).start();
         try {
-            const [refs, scanned] = await Promise.all([collectReferencedFiles(target), scanComponents(target)]);
+            const [refs, scanned, cssObs, inlineObs, blockObs] = await Promise.all([
+                collectReferencedFiles(target),
+                scanComponents(target),
+                extractFromCssFiles(target),
+                extractFromInlineStyles(target),
+                extractFromStyleBlocks(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)` : ""));
+            styleObservations = [...cssObs, ...inlineObs, ...blockObs];
+            spinScan.succeed(`Scanned ${refs.size} import(s)` +
+                (observations ? `, ${observations.length} Tailwind class(es)` : "") +
+                `, ${styleObservations.length} style observation(s)`);
         }
         catch (err) {
-            spinScan.warn(`Scan failed: ${err?.message ?? err}. Continuing without orphan/drift insights.`);
+            const msg = err instanceof Error ? err.message : String(err);
+            spinScan.warn(`Scan failed: ${msg}. Continuing without drift insights.`);
         }
     }
     const normalisedComponents = referencedFiles
@@ -57,10 +74,130 @@ export async function insightsCommand(targetArg, options = {}) {
         decisions,
         components: normalisedComponents,
         observations,
-        referencedFiles
+        referencedFiles,
+        styleObservations
     });
-    return printOrEmit(insights, options);
+    printOrEmit(insights, options);
+    if (!options.json) {
+        const ai = await getAiAvailability(target);
+        if (ai.available && insights.length > 0) {
+            console.log(ui.note("AI-generated UX hints available. Run `whale selene suggest --focus all` to get them."));
+            console.log();
+        }
+        else if (!ai.available) {
+            console.log(ui.muted("AI features available with Claude Code, Codex, or an API key."));
+            console.log();
+        }
+    }
+}
+export async function insightsDriftReviewCommand(category, opts) {
+    const validCategories = ["spacing", "color", "radii"];
+    if (!validCategories.includes(category)) {
+        console.log(ui.fail(`Unknown drift category: ${category}. Valid: ${validCategories.join(", ")}`));
+        process.exitCode = 1;
+        return;
+    }
+    const cat = category;
+    const target = resolveTarget(opts.target);
+    console.log();
+    console.log(ui.header("Whale Igniter", `insights drift ${cat}`));
+    console.log();
+    const spin = ora({ text: "Scanning source files", stream: process.stderr }).start();
+    const [config, refinements, cssObs, inlineObs, blockObs] = await Promise.all([
+        loadConfig(target),
+        loadRefinements(target),
+        extractFromCssFiles(target),
+        extractFromInlineStyles(target),
+        extractFromStyleBlocks(target)
+    ]);
+    const styleObservations = [...cssObs, ...inlineObs, ...blockObs];
+    spin.succeed(`${styleObservations.length} style observation(s) found`);
+    const driftInsights = cat === "spacing"
+        ? analyzeSpacingDrift(styleObservations, config, refinements)
+        : cat === "color"
+            ? analyzeColorDrift(styleObservations, config, refinements)
+            : analyzeRadiiDrift(styleObservations, config, refinements);
+    if (driftInsights.length === 0) {
+        console.log(ui.ok(`No ${cat} drift found.`));
+        console.log();
+        return;
+    }
+    console.log(ui.section(`${cat} drift — ${driftInsights.length} insight(s)`));
+    console.log();
+    if (!opts.review) {
+        for (const ins of driftInsights) {
+            console.log(ui.indent(ui.emphasis(ins.title)));
+            console.log(ui.indent(ui.muted(ins.detail), 1));
+            if (ins.evidence) {
+                for (const e of ins.evidence.slice(0, 5)) {
+                    console.log(ui.indent(ui.dot(e), 2));
+                }
+            }
+            console.log();
+        }
+        console.log(ui.muted("Use --review to enter the interactive review loop."));
+        console.log();
+        return;
+    }
+    // Interactive review loop
+    const refactorQueuePath = path.join(target, "intelligence", "refactor-queue.json");
+    const refactorQueue = (await fs.pathExists(refactorQueuePath))
+        ? await fs.readJson(refactorQueuePath)
+        : [];
+    let reviewed = 0;
+    for (const ins of driftInsights) {
+        console.log(ui.section(ins.title));
+        console.log(ui.indent(ui.muted(ins.detail)));
+        if (ins.evidence) {
+            for (const e of ins.evidence)
+                console.log(ui.indent(ui.dot(e), 1));
+        }
+        console.log();
+        const { action } = await prompts({
+            type: "select",
+            name: "action",
+            message: "What would you like to do?",
+            choices: [
+                { title: "Accept as refinement (suppress this drift)", value: "refine" },
+                { title: "Flag for refactor (add to queue)", value: "queue" },
+                { title: "Skip", value: "skip" },
+                { title: "Quit review", value: "quit" }
+            ]
+        });
+        if (!action || action === "quit")
+            break;
+        if (action === "refine") {
+            await appendRefinement(target, {
+                id: randomUUID(),
+                timestamp: new Date().toISOString(),
+                note: ins.title,
+                scope: { issueType: cat }
+            });
+            console.log(ui.ok("Recorded as refinement."));
+        }
+        else if (action === "queue") {
+            refactorQueue.push({
+                id: randomUUID(),
+                insightId: ins.id,
+                title: ins.title,
+                evidence: ins.evidence ?? [],
+                addedAt: new Date().toISOString()
+            });
+            console.log(ui.ok("Added to refactor queue."));
+        }
+        reviewed++;
+        console.log();
+    }
+    if (refactorQueue.length > 0) {
+        await fs.ensureDir(path.join(target, "intelligence"));
+        await writeJsonFile(refactorQueuePath, refactorQueue);
+    }
+    console.log(ui.accent(`Reviewed ${reviewed} insight(s).`));
+    console.log();
 }
+// ---------------------------------------------------------------------------
+// Shared rendering
+// ---------------------------------------------------------------------------
 function printOrEmit(insights, options) {
     let filtered = insights;
     if (options.category)