@aibloom/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,847 @@
+#!/usr/bin/env node
+import fs from "node:fs/promises";
+import path from "node:path";
+import { cac } from "cac";
+import { ConflictDetector, DesignDocParser, DesignSystemSynthesizer, FileChangeApplier, FusionOptionGenerator, ProjectStateStore, RunRecordStore, StyleFingerprintExtractor, TaskStore, VibeUIError, readJsonFile, writeJsonFile, } from "@aibloom/core";
+import { DesignReferenceDocumentSchema, FusionDecisionSchema, FusionOptionSchema, HostTaskResultSchema, HostTaskSchema, SCHEMA_VERSION, StyleConflictReportSchema, StyleFingerprintSchema, VibeUIConfigSchema, } from "@aibloom/schemas";
+import { allDetections, adapterById, detectFramework } from "./adapters.js";
+import { createImplementationPlan, createPageShape, createProductSpec, pageArtifactDir, slugify, } from "./page-planner.js";
+import { renderImplementationPlanMarkdown, renderImplementationPrompt, renderPageShapeMarkdown, renderProductMarkdown, } from "./markdown.js";
+import { verifyPage } from "./verification.js";
+const cli = cac("vibeui");
+const DEFAULT_VIEWPORTS = [
+    { name: "mobile", width: 390, height: 844 },
+    { name: "tablet", width: 768, height: 1024 },
+    { name: "desktop", width: 1440, height: 1000 },
+];
+function now() {
+    return new Date().toISOString();
+}
+async function recordRun(projectRoot, run) {
+    const runStore = new RunRecordStore(projectRoot);
+    await runStore.append({ schemaVersion: SCHEMA_VERSION, ...run });
+    const store = new ProjectStateStore(projectRoot);
+    await store.update((state) => ({ ...state, runs: [...state.runs.filter((id) => id !== run.id), run.id] }));
+}
+function defaultConfig(framework) {
+    return VibeUIConfigSchema.parse({
+        schemaVersion: SCHEMA_VERSION,
+        framework,
+        packageManager: "pnpm",
+        verification: {
+            lint: true,
+            typecheck: true,
+            unitTest: true,
+            build: true,
+            playwright: true,
+            accessibility: true,
+            viewports: DEFAULT_VIEWPORTS,
+        },
+        safety: {
+            allowedWriteRoots: ["app", "src", "components", "pages", "."],
+            confirmDependencyInstall: true,
+            maxRepairAttempts: 3,
+        },
+    });
+}
+async function readConfig(projectRoot) {
+    const configPath = path.join(projectRoot, ".vibeui", "config.json");
+    try {
+        return await readJsonFile(configPath, VibeUIConfigSchema);
+    }
+    catch {
+        const state = await new ProjectStateStore(projectRoot).read();
+        const config = defaultConfig(state.framework);
+        await writeJsonFile(configPath, config);
+        return config;
+    }
+}
+function handleError(error) {
+    if (error instanceof VibeUIError) {
+        console.error(`${error.code}: ${error.message}`);
+        if (error.details)
+            console.error(error.details);
+    }
+    else if (error instanceof Error) {
+        console.error(error.message);
+    }
+    else {
+        console.error(String(error));
+    }
+    process.exitCode = 1;
+}
+async function ensureInitialized(projectRoot) {
+    const store = new ProjectStateStore(projectRoot);
+    const state = await store.read();
+    if (state.projectStage === "uninitialized") {
+        throw new VibeUIError("NOT_INITIALIZED", "No Aibloom project initialized. Run `aibloom init` first.");
+    }
+    return state;
+}
+function pageBySlug(pages, slugOrId) {
+    if (!slugOrId)
+        return pages[pages.length - 1];
+    return pages.find((page) => page.slug === slugOrId || page.id === slugOrId);
+}
+function optionList(value) {
+    if (!value)
+        return [];
+    return Array.isArray(value) ? value : [value];
+}
+function fusionAlias(value) {
+    if (value === "primary-accent")
+        return "primary-plus-accent";
+    if (value === "derived-system")
+        return "new-derived-system";
+    return value;
+}
+async function initializeProject(projectRoot, options) {
+    const detection = await detectFramework(projectRoot, options.framework).catch(() => null);
+    const framework = detection?.context.framework ?? null;
+    await fs.mkdir(path.join(projectRoot, ".vibeui", "artifacts", "design-references"), { recursive: true });
+    await fs.mkdir(path.join(projectRoot, ".vibeui", "tasks"), { recursive: true });
+    await fs.mkdir(path.join(projectRoot, "docs"), { recursive: true });
+    await writeJsonFile(path.join(projectRoot, ".vibeui", "config.json"), defaultConfig(framework));
+    const state = await new ProjectStateStore(projectRoot).initialize(options.name, framework);
+    await recordRun(projectRoot, {
+        id: `run-${Date.now()}`,
+        command: "vibeui init",
+        projectStage: state.projectStage,
+        status: "completed",
+        startedAt: now(),
+        completedAt: now(),
+        artifacts: [".vibeui/state.json", ".vibeui/config.json"],
+        errors: [],
+    });
+    return state;
+}
+async function ensureProjectReady(projectRoot, framework) {
+    const store = new ProjectStateStore(projectRoot);
+    const state = await store.read();
+    if (state.projectStage === "uninitialized") {
+        return initializeProject(projectRoot, { framework });
+    }
+    return state;
+}
+async function importDesignReference(projectRoot, file, name) {
+    await ensureInitialized(projectRoot);
+    const parser = new DesignDocParser();
+    const doc = await parser.parse({
+        path: path.resolve(projectRoot, file),
+        name,
+        sourceType: "manual",
+    });
+    const artifactsDir = path.join(projectRoot, ".vibeui", "artifacts", "design-references");
+    await fs.mkdir(artifactsDir, { recursive: true });
+    const docPath = path.join(artifactsDir, `${doc.id}.json`);
+    await writeJsonFile(docPath, doc);
+    await new ProjectStateStore(projectRoot).addDesignReference({
+        id: doc.id,
+        name: doc.name,
+        sourceType: "manual",
+        role: "candidate",
+        status: "parsed",
+        importedAt: now(),
+    });
+    return { doc, docPath };
+}
+async function analyzeDesignReferences(projectRoot) {
+    const state = await ensureInitialized(projectRoot);
+    const extractor = new StyleFingerprintExtractor();
+    const fingerprints = [];
+    for (const ref of state.designReferences) {
+        const doc = await readJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "design-references", `${ref.id}.json`), DesignReferenceDocumentSchema);
+        fingerprints.push(StyleFingerprintSchema.parse(extractor.extract(doc)));
+    }
+    await writeJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "style-fingerprints.json"), fingerprints);
+    await new ProjectStateStore(projectRoot).update((current) => ({
+        ...current,
+        projectStage: "design_references_analyzed",
+        designReferences: current.designReferences.map((ref) => ({ ...ref, status: "analyzed" })),
+    }));
+    return fingerprints;
+}
+async function detectDesignConflicts(projectRoot) {
+    await ensureInitialized(projectRoot);
+    const fingerprints = await readJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "style-fingerprints.json"), StyleFingerprintSchema.array());
+    const detector = new ConflictDetector();
+    const report = StyleConflictReportSchema.parse(detector.detect(fingerprints));
+    const options = new FusionOptionGenerator().generate(fingerprints, report);
+    await writeJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "style-conflict-report.json"), report);
+    await writeJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "fusion-options.json"), options);
+    if (report.conflicts.length > 0 && fingerprints.length > 1) {
+        await new ProjectStateStore(projectRoot).setProjectStage("fusion_decision_required");
+    }
+    return { fingerprints, report, options };
+}
+function createFusionDecision(fingerprints, selected) {
+    const primary = selected?.primaryReference
+        ? fingerprints.find((fingerprint) => fingerprint.id === selected.primaryReference)
+        : fingerprints[0];
+    const primaryId = primary?.id ?? fingerprints[0]?.id ?? "unknown";
+    return FusionDecisionSchema.parse({
+        schemaVersion: SCHEMA_VERSION,
+        selectedStrategy: selected?.strategy ?? "primary-plus-accent",
+        selectedOptionId: selected?.id ?? "single-reference",
+        userInstruction: selected?.description ?? `Use ${primary?.name ?? "the only design reference"} as the project design system.`,
+        timestamp: now(),
+        finalReferenceRoles: Object.fromEntries(fingerprints.map((fingerprint) => [
+            fingerprint.id,
+            fingerprint.id === primaryId ? "primary" : "secondary",
+        ])),
+        rejectedRules: selected?.rejectedRules ?? [],
+        conditionalRules: selected?.risks ?? [],
+        notes: selected
+            ? [`Selected option: ${selected.label}`]
+            : [`Primary default: ${primary?.name ?? "n/a"}`],
+    });
+}
+async function recordFusionDecision(projectRoot, decision) {
+    await writeJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "fusion-decision.json"), decision);
+    await new ProjectStateStore(projectRoot).update((state) => ({
+        ...state,
+        fusionDecision: {
+            strategy: decision.selectedStrategy,
+            selectedOptionId: decision.selectedOptionId,
+            recordedAt: now(),
+        },
+    }));
+}
+function selectFusionOption(options, strategy) {
+    if (!strategy)
+        return options[0];
+    const normalized = fusionAlias(strategy);
+    return options.find((item) => item.id === normalized || item.strategy === normalized);
+}
+async function synthesizeProjectDesign(projectRoot) {
+    await ensureInitialized(projectRoot);
+    const fingerprints = await readJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "style-fingerprints.json"), StyleFingerprintSchema.array());
+    const decision = await readJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "fusion-decision.json"), FusionDecisionSchema);
+    const synthesized = new DesignSystemSynthesizer().synthesize(fingerprints, decision);
+    await fs.writeFile(path.join(projectRoot, "DESIGN.md"), synthesized.content, "utf-8");
+    const brief = `# Design Fusion Brief
+
+## Selected Strategy
+
+${decision.selectedStrategy}
+
+## User Instruction
+
+${decision.userInstruction}
+
+## Conditional Rules
+
+${decision.conditionalRules.map((rule) => `- ${rule}`).join("\n") || "- None"}
+
+## Source Decisions
+
+${synthesized.decisions.map((item) => `- ${item.decisionId}: ${item.dimension} -> ${item.finalRule}`).join("\n")}
+`;
+    const briefPath = path.join(projectRoot, "DESIGN_FUSION_BRIEF.md");
+    const sourceMapPath = path.join(projectRoot, "docs", "ui", "design-source-map.json");
+    await fs.mkdir(path.dirname(sourceMapPath), { recursive: true });
+    await fs.writeFile(briefPath, brief, "utf-8");
+    await writeJsonFile(sourceMapPath, {
+        schemaVersion: SCHEMA_VERSION,
+        projectDesignPath: "DESIGN.md",
+        decisions: synthesized.decisions,
+    });
+    await new ProjectStateStore(projectRoot).update((state) => ({
+        ...state,
+        activeDesignSystem: "DESIGN.md",
+        projectStage: "design_system_synthesized",
+    }));
+    return {
+        designPath: "DESIGN.md",
+        fusionBriefPath: "DESIGN_FUSION_BRIEF.md",
+        sourceMapPath: "docs/ui/design-source-map.json",
+        decisions: synthesized.decisions,
+    };
+}
+async function prepareDesignSystem(projectRoot, input) {
+    await ensureProjectReady(projectRoot, input.framework);
+    const importedDesigns = [];
+    for (const [index, designPath] of input.designs.entries()) {
+        const imported = await importDesignReference(projectRoot, designPath, `design-${index + 1}`);
+        importedDesigns.push(path.relative(projectRoot, imported.docPath));
+    }
+    const state = await ensureInitialized(projectRoot);
+    if (state.designReferences.length === 0) {
+        throw new VibeUIError("DESIGN_SYSTEM_REQUIRED", "Pass at least one --design path or synthesize a DESIGN.md first.");
+    }
+    const fingerprints = await analyzeDesignReferences(projectRoot);
+    const { report, options } = await detectDesignConflicts(projectRoot);
+    const requiresChoice = fingerprints.length > 1 && report.conflicts.length > 0 && !input.fusionStrategy;
+    if (requiresChoice) {
+        return {
+            status: "needs_fusion_choice",
+            nextAction: "select-fusion-strategy",
+            importedDesigns,
+            conflictReport: report,
+            fusionOptions: options,
+            artifacts: [
+                ".vibeui/artifacts/style-fingerprints.json",
+                ".vibeui/artifacts/style-conflict-report.json",
+                ".vibeui/artifacts/fusion-options.json",
+            ],
+        };
+    }
+    const selected = selectFusionOption(options, input.fusionStrategy);
+    if (input.fusionStrategy && !selected) {
+        throw new VibeUIError("INVALID_STATE", `Unknown fusion strategy: ${input.fusionStrategy}`);
+    }
+    const decision = createFusionDecision(fingerprints, selected);
+    await recordFusionDecision(projectRoot, decision);
+    const synthesized = await synthesizeProjectDesign(projectRoot);
+    return {
+        status: "completed",
+        nextAction: "create-page",
+        importedDesigns,
+        conflictReport: report,
+        fusionOptions: options,
+        selectedFusion: decision,
+        artifacts: [
+            ...importedDesigns,
+            ".vibeui/artifacts/style-fingerprints.json",
+            ".vibeui/artifacts/style-conflict-report.json",
+            ".vibeui/artifacts/fusion-options.json",
+            ".vibeui/artifacts/fusion-decision.json",
+            synthesized.designPath,
+            synthesized.fusionBriefPath,
+            synthesized.sourceMapPath,
+        ],
+    };
+}
+async function createPageTask(projectRoot, input) {
+    const state = await ensureInitialized(projectRoot);
+    if (!state.activeDesignSystem) {
+        throw new VibeUIError("DESIGN_SYSTEM_REQUIRED", "Run `aibloom prepare-design --design <path>` before creating pages.");
+    }
+    const { adapter, context } = await detectFramework(projectRoot, input.framework);
+    const slug = slugify(input.prompt);
+    const pageId = `page-${slug}`;
+    const artifactDir = pageArtifactDir(slug);
+    const pageDir = path.join(projectRoot, artifactDir);
+    await fs.mkdir(pageDir, { recursive: true });
+    const product = createProductSpec(input.prompt, slug);
+    const shape = await createPageShape(pageId, input.prompt, context.framework);
+    const plan = await createImplementationPlan(shape, adapter, context);
+    const pageShapePath = path.join(artifactDir, "PAGE_SHAPE.md");
+    const implementationPlanPath = path.join(artifactDir, "IMPLEMENTATION_PLAN.md");
+    const implementationPromptPath = path.join(artifactDir, "IMPLEMENTATION_PROMPT.md");
+    await writeJsonFile(path.join(pageDir, "product.json"), product);
+    await fs.writeFile(path.join(projectRoot, "PRODUCT.md"), renderProductMarkdown(product), "utf-8");
+    await writeJsonFile(path.join(pageDir, "page-shape.json"), shape);
+    await fs.writeFile(path.join(projectRoot, pageShapePath), renderPageShapeMarkdown(shape), "utf-8");
+    await writeJsonFile(path.join(pageDir, "implementation-plan.json"), plan);
+    await fs.writeFile(path.join(projectRoot, implementationPlanPath), renderImplementationPlanMarkdown(plan), "utf-8");
+    await fs.writeFile(path.join(projectRoot, implementationPromptPath), renderImplementationPrompt(pageShapePath, implementationPlanPath), "utf-8");
+    const taskId = `task-${Date.now()}-${slug}`;
+    const page = {
+        id: pageId,
+        name: shape.pageName,
+        slug,
+        route: shape.route,
+        framework: context.framework,
+        stage: "implementation_pending",
+        prompt: input.prompt,
+        artifactDir,
+        shapePath: pageShapePath,
+        implementationPlanPath,
+        implementationPromptPath,
+        activeTaskId: taskId,
+        repairAttempts: 0,
+        lastVerificationReport: null,
+        createdAt: now(),
+        updatedAt: now(),
+    };
+    const taskInputs = [
+        { kind: "product", path: "PRODUCT.md", required: true },
+        { kind: "design-system", path: "DESIGN.md", required: true },
+        { kind: "page-shape", path: pageShapePath, required: true },
+        { kind: "implementation-plan", path: implementationPlanPath, required: true },
+    ];
+    if (input.prototype) {
+        taskInputs.push({ kind: "prototype", path: input.prototype, required: false });
+    }
+    const task = HostTaskSchema.parse({
+        schemaVersion: SCHEMA_VERSION,
+        id: taskId,
+        type: "implement-page",
+        pageId,
+        status: "pending",
+        createdAt: now(),
+        inputs: taskInputs,
+        constraints: {
+            projectRoot,
+            allowedWritePaths: plan.targetFiles.map((file) => file.path),
+            forbiddenPaths: [".git", "node_modules", ".env", ".env.local"],
+            maxRepairAttempts: 3,
+            requirePlanBeforeWrite: true,
+        },
+        expectedOutputs: [
+            { kind: "file-change", description: "Implement all target files in IMPLEMENTATION_PLAN.md" },
+            { kind: "task-result", description: "Write a HostTaskResult for `aibloom task complete`" },
+            { kind: "verification-pass", description: "Aibloom verify passes after implementation" },
+        ],
+    });
+    await new TaskStore(projectRoot).create(task);
+    await new ProjectStateStore(projectRoot).upsertPage(page);
+    return { page, task, pageShapePath, implementationPlanPath, implementationPromptPath };
+}
+cli.help().version("0.2.0");
+cli
+    .command("init", "Initialize or update an Aibloom project")
+    .option("--name <name>", "Project name")
+    .option("--framework <framework>", "next, vite-react, or auto", { default: "auto" })
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    try {
+        const state = await initializeProject(projectRoot, options);
+        console.log("Aibloom initialized.");
+        console.log(`  Project: ${state.projectName ?? "(unnamed)"}`);
+        console.log(`  Framework: ${state.framework ?? "(not detected)"}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("prepare-design", "Prepare a project DESIGN.md from one or more design references")
+    .option("--design <path>", "DESIGN.md reference path; repeat for multiple references")
+    .option("--fusion-strategy <strategy>", "Fusion option id or strategy")
+    .option("--framework <framework>", "next, vite-react, or auto", { default: "auto" })
+    .option("--json", "Print JSON")
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    try {
+        const result = await prepareDesignSystem(projectRoot, {
+            designs: optionList(options.design),
+            fusionStrategy: options.fusionStrategy,
+            framework: options.framework,
+        });
+        if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.status === "needs_fusion_choice") {
+            console.log("Design references need a fusion choice.");
+            console.log(`  Compatibility score: ${result.conflictReport.compatibilityScore}`);
+            console.log("Fusion options:");
+            for (const option of result.fusionOptions) {
+                console.log(`  ${option.id}. ${option.label} (${option.strategy})`);
+            }
+            return;
+        }
+        console.log("Project design system prepared.");
+        for (const artifact of result.artifacts)
+            console.log(`  ${artifact}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("prepare-page <prompt>", "Prepare design artifacts and a host task for a page")
+    .option("--design <path>", "DESIGN.md reference path; repeat for multiple references")
+    .option("--prototype <path>", "Optional prototype UI image path for the host agent")
+    .option("--fusion-strategy <strategy>", "Fusion option id or strategy")
+    .option("--framework <framework>", "next, vite-react, or auto", { default: "auto" })
+    .option("--json", "Print JSON")
+    .action(async (prompt, options) => {
+    const projectRoot = process.cwd();
+    try {
+        await ensureProjectReady(projectRoot, options.framework);
+        const state = await ensureInitialized(projectRoot);
+        const designs = optionList(options.design);
+        const rootDesignPath = path.join(projectRoot, "DESIGN.md");
+        const rootDesignExists = await fs.access(rootDesignPath).then(() => true, () => false);
+        if (!state.activeDesignSystem) {
+            const designInputs = designs.length > 0 ? designs : rootDesignExists ? ["DESIGN.md"] : [];
+            const designResult = await prepareDesignSystem(projectRoot, {
+                designs: designInputs,
+                fusionStrategy: options.fusionStrategy,
+                framework: options.framework,
+            });
+            if (designResult.status === "needs_fusion_choice") {
+                const response = {
+                    ...designResult,
+                    pageSlug: null,
+                    taskId: null,
+                    taskPath: null,
+                    requiredInputs: [],
+                    allowedWritePaths: [],
+                };
+                if (options.json)
+                    console.log(JSON.stringify(response, null, 2));
+                else {
+                    console.log("Design references need a fusion choice before page planning.");
+                    for (const option of designResult.fusionOptions) {
+                        console.log(`  ${option.id}. ${option.label} (${option.strategy})`);
+                    }
+                }
+                return;
+            }
+        }
+        else if (designs.length > 0) {
+            const designResult = await prepareDesignSystem(projectRoot, {
+                designs,
+                fusionStrategy: options.fusionStrategy,
+                framework: options.framework,
+            });
+            if (designResult.status === "needs_fusion_choice") {
+                const response = {
+                    ...designResult,
+                    pageSlug: null,
+                    taskId: null,
+                    taskPath: null,
+                    requiredInputs: [],
+                    allowedWritePaths: [],
+                };
+                if (options.json)
+                    console.log(JSON.stringify(response, null, 2));
+                else
+                    console.log("Design references need a fusion choice before page planning.");
+                return;
+            }
+        }
+        const created = await createPageTask(projectRoot, {
+            prompt,
+            framework: options.framework,
+            prototype: options.prototype,
+        });
+        const response = {
+            status: "completed",
+            nextAction: "run-host-task",
+            pageSlug: created.page.slug,
+            taskId: created.task.id,
+            taskPath: path.join(".vibeui", "tasks", created.task.id, "task.json"),
+            requiredInputs: created.task.inputs,
+            allowedWritePaths: created.task.constraints.allowedWritePaths,
+            artifacts: [
+                "PRODUCT.md",
+                created.pageShapePath,
+                created.implementationPlanPath,
+                created.implementationPromptPath,
+            ],
+        };
+        if (options.json) {
+            console.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        console.log(`Page prepared: ${created.page.slug}`);
+        console.log(`  Task: ${created.task.id}`);
+        console.log(`  Next: vibeui task next --json`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("doctor", "Inspect Aibloom, framework, package manager, and browser dependencies")
+    .action(async () => {
+    const projectRoot = process.cwd();
+    try {
+        const detections = await allDetections(projectRoot);
+        const checks = [];
+        checks.push({ checkType: "manual_review_required", status: "pass", message: `Node ${process.version}` });
+        for (const item of detections) {
+            checks.push({
+                checkType: "manual_review_required",
+                status: item.detection.detected ? "pass" : "skip",
+                message: `${item.adapter}: confidence ${item.detection.confidence}`,
+                details: item.detection.evidence.join("\n"),
+            });
+        }
+        try {
+            await Function("specifier", "return import(specifier)")("@playwright/test");
+            checks.push({ checkType: "playwright", status: "pass", message: "@playwright/test importable" });
+        }
+        catch {
+            checks.push({ checkType: "playwright", status: "skip", message: "@playwright/test not installed" });
+        }
+        console.log("Aibloom doctor:");
+        for (const check of checks) {
+            console.log(`  ${check.status.toUpperCase()} ${check.message}`);
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("report", "View current project status")
+    .option("--json", "Print JSON")
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    try {
+        const state = await new ProjectStateStore(projectRoot).read();
+        const tasks = await new TaskStore(projectRoot).list();
+        if (options.json) {
+            console.log(JSON.stringify({ state, tasks }, null, 2));
+            return;
+        }
+        if (state.projectStage === "uninitialized") {
+            console.log("Aibloom project not initialized. Run `aibloom init`.");
+            return;
+        }
+        console.log("Aibloom Project Report");
+        console.log(`  Project: ${state.projectName ?? "(unnamed)"}`);
+        console.log(`  Project stage: ${state.projectStage}`);
+        console.log(`  Framework: ${state.framework ?? "(not detected)"}`);
+        console.log(`  Design system: ${state.activeDesignSystem ?? "(missing)"}`);
+        console.log(`  Design references: ${state.designReferences.length}`);
+        console.log(`  Pages: ${state.pages.length}`);
+        for (const page of state.pages) {
+            console.log(`    ${page.slug}: ${page.stage} (${page.framework})`);
+        }
+        const nextTask = tasks.find((task) => task.status === "pending");
+        console.log(`  Next task: ${nextTask ? nextTask.id : "(none)"}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("import-design <file>", "Advanced: import a DESIGN.md reference document")
+    .option("--name <name>", "Reference name")
+    .action(async (file, options) => {
+    const projectRoot = process.cwd();
+    try {
+        const { doc, docPath } = await importDesignReference(projectRoot, file, options.name);
+        console.log(`Imported design reference: ${doc.name}`);
+        console.log(`  ${docPath}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("analyze-designs", "Advanced: extract style fingerprints from imported DESIGN.md references")
+    .action(async () => {
+    const projectRoot = process.cwd();
+    try {
+        const fingerprints = await analyzeDesignReferences(projectRoot);
+        console.log(`Analyzed ${fingerprints.length} design reference(s).`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("design-conflicts", "Advanced: detect conflicts between imported design references")
+    .action(async () => {
+    const projectRoot = process.cwd();
+    try {
+        const { report, options } = await detectDesignConflicts(projectRoot);
+        console.log(`Compatibility score: ${report.compatibilityScore}`);
+        console.log(`Conflicts: ${report.conflicts.length}`);
+        console.log("Fusion options:");
+        for (const option of options) {
+            console.log(`  ${option.id}. ${option.label} (${option.strategy})`);
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("fuse-designs", "Advanced: select a design fusion strategy")
+    .option("--strategy <strategy>", "Fusion strategy or option id")
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    try {
+        await ensureInitialized(projectRoot);
+        if (!options.strategy) {
+            throw new VibeUIError("INVALID_STATE", "Pass --strategy with an option id or strategy name.");
+        }
+        const fingerprints = await readJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "style-fingerprints.json"), StyleFingerprintSchema.array());
+        const fusionOptions = await readJsonFile(path.join(projectRoot, ".vibeui", "artifacts", "fusion-options.json"), FusionOptionSchema.array());
+        const selected = selectFusionOption(fusionOptions, options.strategy);
+        if (!selected)
+            throw new VibeUIError("INVALID_STATE", `Unknown fusion strategy: ${options.strategy}`);
+        const decision = createFusionDecision(fingerprints, selected);
+        await recordFusionDecision(projectRoot, decision);
+        console.log(`Fusion decision recorded: ${selected.label}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("synthesize-design", "Advanced: generate project-level DESIGN.md from fusion decision")
+    .action(async () => {
+    const projectRoot = process.cwd();
+    try {
+        await synthesizeProjectDesign(projectRoot);
+        console.log("Project design system synthesized.");
+        console.log("  DESIGN.md");
+        console.log("  DESIGN_FUSION_BRIEF.md");
+        console.log("  docs/ui/design-source-map.json");
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("create-page <prompt>", "Advanced: create structured page artifacts and a host implementation task")
+    .option("--framework <framework>", "next, vite-react, or auto", { default: "auto" })
+    .action(async (prompt, options) => {
+    const projectRoot = process.cwd();
+    try {
+        const created = await createPageTask(projectRoot, { prompt, framework: options.framework });
+        console.log(`Page planned: ${created.page.slug}`);
+        console.log(`  Task: ${created.task.id}`);
+        console.log(`  ${created.pageShapePath}`);
+        console.log(`  ${created.implementationPlanPath}`);
+        console.log(`  ${created.implementationPromptPath}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("task <subcommand> [taskId]", "Inspect or complete host tasks")
+    .option("--json", "Print JSON for task next")
+    .option("--result <path>", "Path to HostTaskResult JSON for task complete")
+    .action(async (subcommand, taskId, options) => {
+    const projectRoot = process.cwd();
+    try {
+        await ensureInitialized(projectRoot);
+        const taskStore = new TaskStore(projectRoot);
+        if (subcommand === "next") {
+            const task = await taskStore.next();
+            if (options.json)
+                console.log(JSON.stringify(task, null, 2));
+            else
+                console.log(task ? `${task.id} ${task.type} ${task.status}` : "No pending task.");
+            return;
+        }
+        if (subcommand === "complete") {
+            if (!taskId)
+                throw new VibeUIError("TASK_NOT_FOUND", "Pass a task id.");
+            if (!options.result)
+                throw new VibeUIError("TASK_NOT_FOUND", "Pass --result <path>.");
+            const task = await taskStore.get(taskId);
+            const result = await readJsonFile(path.resolve(projectRoot, options.result), HostTaskResultSchema);
+            if (result.taskId !== task.id) {
+                throw new VibeUIError("TASK_NOT_FOUND", `Result taskId ${result.taskId} does not match ${task.id}`);
+            }
+            await new FileChangeApplier(projectRoot).apply(task.id, result.changedFiles, task.constraints.allowedWritePaths);
+            await taskStore.saveResult(result);
+            await new ProjectStateStore(projectRoot).update((state) => ({
+                ...state,
+                pages: state.pages.map((page) => page.id === task.pageId
+                    ? { ...page, stage: result.status === "completed" ? "implemented" : "blocked", activeTaskId: null, updatedAt: now() }
+                    : page),
+            }));
+            console.log(`Task completed: ${task.id}`);
+            return;
+        }
+        throw new VibeUIError("TASK_NOT_FOUND", `Unknown task subcommand: ${subcommand}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("verify", "Run verification checks on current project state")
+    .option("--page <slug>", "Verify a specific page")
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    try {
+        const state = await ensureInitialized(projectRoot);
+        const config = await readConfig(projectRoot);
+        const page = pageBySlug(state.pages, options.page);
+        const framework = page?.framework ?? state.framework;
+        if (!framework)
+            throw new VibeUIError("FRAMEWORK_NOT_DETECTED", "No framework known. Run `aibloom init --framework auto`.");
+        const adapter = adapterById(framework);
+        const context = await adapter.inspect(projectRoot);
+        const report = await verifyPage({
+            projectRoot,
+            adapter,
+            context,
+            page,
+            viewports: config.verification.viewports,
+            reportDir: path.join(projectRoot, ".vibeui", "reports"),
+        });
+        await new ProjectStateStore(projectRoot).update((current) => ({
+            ...current,
+            pages: current.pages.map((item) => page && item.id === page.id
+                ? {
+                    ...item,
+                    stage: report.requiredChecksPassed ? "completed" : "verification_failed",
+                    lastVerificationReport: path.join(".vibeui", "reports", `${report.runId}.json`),
+                    updatedAt: now(),
+                }
+                : item),
+        }));
+        console.log(`Verification: ${report.status.toUpperCase()}`);
+        console.log(`  ${report.summary}`);
+        if (report.issues.length > 0) {
+            for (const issue of report.issues)
+                console.log(`  - ${issue}`);
+        }
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli
+    .command("repair", "Create a structured repair task from the latest failed verification")
+    .option("--page <slug>", "Page slug")
+    .action(async (options) => {
+    const projectRoot = process.cwd();
+    try {
+        const state = await ensureInitialized(projectRoot);
+        const page = pageBySlug(state.pages, options.page);
+        if (!page)
+            throw new VibeUIError("INVALID_STATE", "No page available to repair.");
+        if (page.repairAttempts >= 3) {
+            throw new VibeUIError("INVALID_STATE", `Repair limit reached for ${page.slug}`);
+        }
+        const taskId = `task-${Date.now()}-repair-${page.slug}`;
+        const task = HostTaskSchema.parse({
+            schemaVersion: SCHEMA_VERSION,
+            id: taskId,
+            type: "repair",
+            pageId: page.id,
+            status: "pending",
+            createdAt: now(),
+            inputs: [
+                { kind: "verification-report", path: page.lastVerificationReport ?? ".vibeui/reports/VERIFICATION_REPORT.md", required: true },
+                { kind: "page-shape", path: page.shapePath, required: true },
+                { kind: "implementation-plan", path: page.implementationPlanPath, required: true },
+            ],
+            constraints: {
+                projectRoot,
+                allowedWritePaths: [page.artifactDir, "app", "src", "components"],
+                forbiddenPaths: [".git", "node_modules", ".env", ".env.local"],
+                maxRepairAttempts: 3 - page.repairAttempts,
+                requirePlanBeforeWrite: true,
+            },
+            expectedOutputs: [
+                { kind: "file-change", description: "Apply minimal changes that address the verification failures" },
+                { kind: "task-result", description: "Write a HostTaskResult for `aibloom task complete`" },
+            ],
+        });
+        await new TaskStore(projectRoot).create(task);
+        await new ProjectStateStore(projectRoot).update((current) => ({
+            ...current,
+            pages: current.pages.map((item) => item.id === page.id
+                ? { ...item, stage: "repair_pending", repairAttempts: item.repairAttempts + 1, activeTaskId: taskId, updatedAt: now() }
+                : item),
+        }));
+        console.log(`Repair task created: ${taskId}`);
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+cli.on("command:*", () => {
+    console.error("Unknown command. Run `aibloom --help` for available commands.");
+    process.exitCode = 1;
+});
+cli.parse();
+//# sourceMappingURL=index.js.map