@specglass/cli 0.0.4 → 0.0.6

package/dist/migration/detector.js

@@ -0,0 +1,196 @@
+/**
+ * Source platform detection for migration.
+ *
+ * Detects which documentation platform is being used in a project
+ * by looking for platform-specific configuration files and content.
+ */
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+/** Supported source platforms for migration. */
+export const SUPPORTED_PLATFORMS = [
+    "mintlify",
+    "docusaurus",
+    "readme",
+    "gitbook",
+];
+// ─── Platform-specific detectors ────────────────────────────────────
+function collectContentFiles(dir, extensions = [".md", ".mdx"], maxDepth = 10) {
+    const files = [];
+    if (!existsSync(dir) || maxDepth <= 0)
+        return files;
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith(".")) {
+                files.push(...collectContentFiles(fullPath, extensions, maxDepth - 1));
+            }
+            else if (entry.isFile() &&
+                extensions.some((ext) => entry.name.endsWith(ext))) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch {
+        // Permission errors, etc. — skip silently
+    }
+    return files;
+}
+function detectMintlify(projectRoot) {
+    const mintJsonPath = join(projectRoot, "mint.json");
+    if (!existsSync(mintJsonPath)) {
+        return {
+            success: false,
+            failure: {
+                expectedFiles: ["mint.json"],
+                hint: "Mintlify projects have a mint.json configuration file in the project root.",
+            },
+        };
+    }
+    // Read mint.json to find the content directory
+    let docsDir = projectRoot;
+    try {
+        const mintConfig = JSON.parse(readFileSync(mintJsonPath, "utf-8"));
+        // Mintlify's navigation references page paths — content is usually in root or a subdirectory
+        if (mintConfig.pages) {
+            // pages array or navigation structure — content relative to root
+            docsDir = projectRoot;
+        }
+    }
+    catch {
+        // Malformed mint.json — still proceed with root as content dir
+    }
+    const contentFiles = collectContentFiles(docsDir);
+    return {
+        success: true,
+        detected: {
+            platform: "mintlify",
+            sourceDir: docsDir,
+            configPath: mintJsonPath,
+            navConfigPath: mintJsonPath, // Navigation is embedded in mint.json
+            contentFiles,
+        },
+    };
+}
+function detectDocusaurus(projectRoot) {
+    const configJsPath = join(projectRoot, "docusaurus.config.js");
+    const configTsPath = join(projectRoot, "docusaurus.config.ts");
+    const configPath = existsSync(configTsPath)
+        ? configTsPath
+        : existsSync(configJsPath)
+            ? configJsPath
+            : null;
+    if (!configPath) {
+        return {
+            success: false,
+            failure: {
+                expectedFiles: ["docusaurus.config.js", "docusaurus.config.ts"],
+                hint: "Docusaurus projects have a docusaurus.config.js or docusaurus.config.ts in the project root.",
+            },
+        };
+    }
+    const docsDir = join(projectRoot, "docs");
+    const sidebarsJs = join(projectRoot, "sidebars.js");
+    const sidebarsTs = join(projectRoot, "sidebars.ts");
+    const navConfigPath = existsSync(sidebarsTs)
+        ? sidebarsTs
+        : existsSync(sidebarsJs)
+            ? sidebarsJs
+            : null;
+    const contentFiles = collectContentFiles(docsDir);
+    return {
+        success: true,
+        detected: {
+            platform: "docusaurus",
+            sourceDir: docsDir,
+            configPath,
+            navConfigPath,
+            contentFiles,
+        },
+    };
+}
+function detectReadme(projectRoot) {
+    const readmeYmlPath = join(projectRoot, ".readme.yml");
+    const readmeYamlPath = join(projectRoot, ".readme.yaml");
+    const orderYamlPath = join(projectRoot, "_order.yaml");
+    // ReadMe projects can be identified by:
+    // 1. .readme.yml / .readme.yaml (ReadMe config file)
+    // 2. _order.yaml (rdme-cli docs-as-code sync format)
+    const configPath = existsSync(readmeYmlPath)
+        ? readmeYmlPath
+        : existsSync(readmeYamlPath)
+            ? readmeYamlPath
+            : existsSync(orderYamlPath)
+                ? orderYamlPath
+                : null;
+    if (!configPath) {
+        return {
+            success: false,
+            failure: {
+                expectedFiles: [".readme.yml", ".readme.yaml", "_order.yaml"],
+                hint: "ReadMe projects have a .readme.yml/.readme.yaml config file or an _order.yaml navigation file in the project root.",
+            },
+        };
+    }
+    // ReadMe content is typically in a docs/ directory or root
+    const docsDir = existsSync(join(projectRoot, "docs"))
+        ? join(projectRoot, "docs")
+        : projectRoot;
+    const contentFiles = collectContentFiles(docsDir);
+    // _order.yaml serves as both config and nav when it's the identifier
+    const navConfigPath = existsSync(orderYamlPath) ? orderYamlPath : null;
+    return {
+        success: true,
+        detected: {
+            platform: "readme",
+            sourceDir: docsDir,
+            configPath,
+            navConfigPath,
+            contentFiles,
+        },
+    };
+}
+function detectGitbook(projectRoot) {
+    const summaryPath = join(projectRoot, "SUMMARY.md");
+    const gitbookYaml = join(projectRoot, ".gitbook.yaml");
+    // GitBook requires SUMMARY.md (defines navigation), .gitbook.yaml is optional
+    if (!existsSync(summaryPath)) {
+        return {
+            success: false,
+            failure: {
+                expectedFiles: ["SUMMARY.md", ".gitbook.yaml"],
+                hint: "GitBook projects have a SUMMARY.md navigation file (required) and optionally a .gitbook.yaml config file.",
+            },
+        };
+    }
+    const configPath = existsSync(gitbookYaml) ? gitbookYaml : null;
+    const contentFiles = collectContentFiles(projectRoot);
+    return {
+        success: true,
+        detected: {
+            platform: "gitbook",
+            sourceDir: projectRoot,
+            configPath,
+            navConfigPath: summaryPath,
+            contentFiles,
+        },
+    };
+}
+// ─── Public API ─────────────────────────────────────────────────────
+const DETECTORS = {
+    mintlify: detectMintlify,
+    docusaurus: detectDocusaurus,
+    readme: detectReadme,
+    gitbook: detectGitbook,
+};
+/**
+ * Detect a source platform's content in the given project root.
+ *
+ * @param platform - Which platform to detect
+ * @param projectRoot - Absolute path to the project root (defaults to cwd)
+ * @returns Detection result — success with detected platform info, or failure with hints
+ */
+export function detectPlatform(platform, projectRoot = process.cwd()) {
+    const root = resolve(projectRoot);
+    return DETECTORS[platform](root);
+}

package/dist/migration/planner.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Migration planner — builds a plan for migrating content from a source platform
+ * to the specglass/ndocs format without executing the actual conversion.
+ *
+ * Used by both dry-run mode and the actual migration to preview planned changes.
+ */
+import type { DetectedPlatform, SupportedPlatform } from "./detector.js";
+/** A single file that will be migrated. */
+export interface PlannedFile {
+    /** Absolute path to the source file. */
+    sourcePath: string;
+    /** Relative target path within src/content/docs/ */
+    targetRelativePath: string;
+    /** Whether this file needs AI conversion (true) or is a simple copy (false). */
+    needsConversion: boolean;
+}
+/** A component mapping from source to ndocs equivalent. */
+export interface ComponentMapping {
+    /** Source platform component (e.g., "<Tip>") */
+    source: string;
+    /** ndocs equivalent component (e.g., "<Callout type=\"tip\">") */
+    target: string;
+}
+/** A navigation mapping from source config to ndocs _meta.json entries. */
+export interface NavigationMapping {
+    /** Source navigation label or path */
+    sourceLabel: string;
+    /** Target directory in ndocs content structure */
+    targetDir: string;
+}
+/** Complete migration plan. */
+export interface MigrationPlan {
+    /** Source platform. */
+    platform: SupportedPlatform;
+    /** Files to migrate. */
+    files: PlannedFile[];
+    /** Component conversions that will be applied. */
+    componentMappings: ComponentMapping[];
+    /** Navigation structure mapping. */
+    navigationMappings: NavigationMapping[];
+    /** Target content directory (absolute path). */
+    targetContentDir: string;
+    /** Number of files that need AI conversion. */
+    aiConversionCount: number;
+    /** Number of files that are simple copies (images, assets). */
+    simpleCopyCount: number;
+}
+/**
+ * Build a complete migration plan from a detected platform.
+ *
+ * @param detected - The detected platform information
+ * @param targetContentDir - Absolute path to the target content directory (default: src/content/docs)
+ * @returns Complete migration plan
+ */
+export declare function buildMigrationPlan(detected: DetectedPlatform, targetContentDir: string): MigrationPlan;

package/dist/migration/planner.js

@@ -0,0 +1,129 @@
+/**
+ * Migration planner — builds a plan for migrating content from a source platform
+ * to the specglass/ndocs format without executing the actual conversion.
+ *
+ * Used by both dry-run mode and the actual migration to preview planned changes.
+ */
+import { dirname, extname, join, relative } from "path";
+// ─── Component mappings per platform ────────────────────────────────
+const PLATFORM_COMPONENT_MAPPINGS = {
+    mintlify: [
+        { source: "<Tip>", target: '<Callout type="tip">' },
+        { source: "<Warning>", target: '<Callout type="warning">' },
+        { source: "<Note>", target: '<Callout>' },
+        { source: "<Info>", target: '<Callout>' },
+        { source: "<Check>", target: '<Callout type="tip">' },
+        { source: "<AccordionGroup>", target: "<Tabs>" },
+        { source: "<Accordion>", target: "<TabItem>" },
+        { source: "<CodeGroup>", target: "<Tabs>" },
+        { source: "<Card>", target: "<Card>" },
+        { source: "<CardGroup>", target: "div (grid container)" },
+    ],
+    docusaurus: [
+        { source: ":::note", target: "<Callout>" },
+        { source: ":::tip", target: '<Callout type="tip">' },
+        { source: ":::info", target: "<Callout>" },
+        { source: ":::caution", target: '<Callout type="warning">' },
+        { source: ":::danger", target: '<Callout type="danger">' },
+        { source: ":::warning", target: '<Callout type="warning">' },
+        { source: "<Tabs>", target: "<Tabs>" },
+        { source: "<TabItem>", target: "<TabItem>" },
+        {
+            source: "import CodeBlock",
+            target: "<CodeBlock> (auto-injected, no import needed)",
+        },
+    ],
+    readme: [
+        { source: "> 📘", target: "<Callout>" },
+        { source: "> ⚠️", target: '<Callout type="warning">' },
+        { source: "> 🚧", target: '<Callout type="danger">' },
+        { source: "> 👍", target: '<Callout type="tip">' },
+        { source: "[block:code]", target: "<CodeBlock>" },
+        { source: "[block:callout]", target: "<Callout>" },
+        { source: "[block:parameters]", target: "markdown table" },
+    ],
+    gitbook: [
+        { source: "{% hint style=\"info\" %}", target: "<Callout>" },
+        { source: "{% hint style=\"warning\" %}", target: "<Callout type=\"warning\">" },
+        { source: "{% hint style=\"danger\" %}", target: "<Callout type=\"danger\">" },
+        { source: "{% hint style=\"success\" %}", target: "<Callout type=\"tip\">" },
+        { source: "{% tabs %}", target: "<Tabs>" },
+        { source: "{% tab title=... %}", target: "<TabItem>" },
+        { source: "{% code ... %}", target: "<CodeBlock>" },
+        { source: "{% embed ... %}", target: "iframe or link" },
+    ],
+};
+// ─── Planning logic ─────────────────────────────────────────────────
+/**
+ * Determine the target relative path for a source file.
+ *
+ * Maps the source file path relative to the source content directory
+ * into the ndocs content structure, normalizing extensions to .mdx.
+ */
+function mapTargetPath(sourcePath, sourceDir) {
+    const rel = relative(sourceDir, sourcePath);
+    const ext = extname(rel);
+    // Convert .md to .mdx, keep .mdx as-is
+    if (ext === ".md") {
+        return rel.slice(0, -3) + ".mdx";
+    }
+    return rel;
+}
+/**
+ * Generate navigation mappings from directory structure.
+ *
+ * Each directory in the source content corresponds to a potential
+ * _meta.json in the ndocs target — we map these as navigation entries.
+ */
+function buildNavigationMappings(detected) {
+    const dirs = new Set();
+    for (const file of detected.contentFiles) {
+        const rel = relative(detected.sourceDir, file);
+        const dir = dirname(rel);
+        if (dir !== ".") {
+            dirs.add(dir);
+        }
+    }
+    // Root always gets a mapping
+    const mappings = [
+        { sourceLabel: "(root)", targetDir: "src/content/docs" },
+    ];
+    for (const dir of Array.from(dirs).sort()) {
+        mappings.push({
+            sourceLabel: dir,
+            targetDir: join("src/content/docs", dir),
+        });
+    }
+    return mappings;
+}
+/**
+ * Build a complete migration plan from a detected platform.
+ *
+ * @param detected - The detected platform information
+ * @param targetContentDir - Absolute path to the target content directory (default: src/content/docs)
+ * @returns Complete migration plan
+ */
+export function buildMigrationPlan(detected, targetContentDir) {
+    const markdownExts = [".md", ".mdx"];
+    const files = detected.contentFiles.map((sourcePath) => {
+        const ext = extname(sourcePath);
+        const needsConversion = markdownExts.includes(ext);
+        const targetRelativePath = mapTargetPath(sourcePath, detected.sourceDir);
+        return {
+            sourcePath,
+            targetRelativePath,
+            needsConversion,
+        };
+    });
+    const aiConversionCount = files.filter((f) => f.needsConversion).length;
+    const simpleCopyCount = files.filter((f) => !f.needsConversion).length;
+    return {
+        platform: detected.platform,
+        files,
+        componentMappings: PLATFORM_COMPONENT_MAPPINGS[detected.platform],
+        navigationMappings: buildNavigationMappings(detected),
+        targetContentDir,
+        aiConversionCount,
+        simpleCopyCount,
+    };
+}

package/dist/migration/writer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Migration writer — handles writing converted content, copying assets,
+ * and generating navigation config to the target ndocs content directory.
+ */
+import type { NavigationMapping } from "./planner.js";
+import type { ConversionResult } from "./converter.js";
+import type { PlannedFile } from "./planner.js";
+/** Result of writing files to the target directory. */
+export interface WriteResult {
+    /** Total files written successfully. */
+    filesWritten: number;
+    /** Total files that failed to write. */
+    filesFailed: number;
+    /** Total files copied (non-conversion assets). */
+    filesCopied: number;
+    /** Paths of successfully written files. */
+    writtenPaths: string[];
+    /** Errors from failed writes. */
+    errors: Array<{
+        path: string;
+        error: string;
+    }>;
+}
+/**
+ * Write a single converted file to the target content directory.
+ * Creates parent directories as needed.
+ */
+export declare function writeConvertedFile(targetContentDir: string, relativePath: string, content: string): Promise<void>;
+/**
+ * Copy a non-conversion file (e.g. image, asset) to the target content directory.
+ * Creates parent directories as needed.
+ */
+export declare function copyAssetFile(targetContentDir: string, file: PlannedFile): Promise<void>;
+/**
+ * Generate and write `_meta.json` files based on navigation mappings.
+ * Creates one `_meta.json` per directory level that has navigation entries.
+ */
+export declare function writeMetaJson(targetContentDir: string, navigationMappings: NavigationMapping[]): Promise<string[]>;
+/**
+ * Write all successfully converted files, copy assets, and generate navigation config.
+ */
+export declare function writeAll(targetContentDir: string, results: ConversionResult[], navigationMappings: NavigationMapping[], allFiles?: PlannedFile[]): Promise<WriteResult>;

package/dist/migration/writer.js

@@ -0,0 +1,150 @@
+/**
+ * Migration writer — handles writing converted content, copying assets,
+ * and generating navigation config to the target ndocs content directory.
+ */
+import { mkdir, writeFile, copyFile } from "fs/promises";
+import { dirname, join, relative } from "path";
+/**
+ * Write a single converted file to the target content directory.
+ * Creates parent directories as needed.
+ */
+export async function writeConvertedFile(targetContentDir, relativePath, content) {
+    const fullPath = join(targetContentDir, relativePath);
+    const dir = dirname(fullPath);
+    // Create parent directories recursively
+    await mkdir(dir, { recursive: true });
+    // Write the converted content
+    await writeFile(fullPath, content, "utf-8");
+}
+/**
+ * Copy a non-conversion file (e.g. image, asset) to the target content directory.
+ * Creates parent directories as needed.
+ */
+export async function copyAssetFile(targetContentDir, file) {
+    const fullPath = join(targetContentDir, file.targetRelativePath);
+    const dir = dirname(fullPath);
+    await mkdir(dir, { recursive: true });
+    await copyFile(file.sourcePath, fullPath);
+}
+/**
+ * Extract the relative path within the content directory from a NavigationMapping targetDir.
+ * Handles both absolute and src/content/docs/-relative paths dynamically.
+ */
+function resolveNavRelativePath(targetContentDir, targetDir) {
+    // If targetDir is absolute, compute relative to targetContentDir
+    if (targetDir.startsWith("/")) {
+        return relative(targetContentDir, targetDir);
+    }
+    // If it starts with the known prefix pattern, strip it
+    // Compute the expected prefix from targetContentDir (last 3 segments typically)
+    const contentDirSuffix = targetContentDir
+        .replace(/\/$/, "")
+        .split("/")
+        .slice(-3)
+        .join("/");
+    const regex = new RegExp(`^${contentDirSuffix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/?`);
+    if (regex.test(targetDir)) {
+        return targetDir.replace(regex, "");
+    }
+    // Fallback: strip common src/content/docs prefix
+    return targetDir.replace(/^src\/content\/docs\/?/, "");
+}
+/**
+ * Generate and write `_meta.json` files based on navigation mappings.
+ * Creates one `_meta.json` per directory level that has navigation entries.
+ */
+export async function writeMetaJson(targetContentDir, navigationMappings) {
+    const writtenPaths = [];
+    // Group entries by their parent directory
+    const dirEntries = new Map();
+    for (const mapping of navigationMappings) {
+        const relativeDir = resolveNavRelativePath(targetContentDir, mapping.targetDir);
+        const cleanRel = relativeDir.replace(/\/$/, "");
+        if (!cleanRel)
+            continue;
+        // Determine parent directory and entry name
+        const segments = cleanRel.split("/");
+        const entryName = segments[segments.length - 1];
+        const parentDir = segments.length > 1 ? segments.slice(0, -1).join("/") : ".";
+        if (!dirEntries.has(parentDir)) {
+            dirEntries.set(parentDir, {});
+        }
+        dirEntries.get(parentDir)[entryName] = mapping.sourceLabel;
+    }
+    // Write a _meta.json for each parent directory that has entries
+    for (const [dirKey, entries] of dirEntries) {
+        if (Object.keys(entries).length === 0)
+            continue;
+        const metaDir = dirKey === "." ? targetContentDir : join(targetContentDir, dirKey);
+        const metaPath = join(metaDir, "_meta.json");
+        await mkdir(metaDir, { recursive: true });
+        await writeFile(metaPath, JSON.stringify(entries, null, 2) + "\n", "utf-8");
+        writtenPaths.push(metaPath);
+    }
+    return writtenPaths;
+}
+/**
+ * Write all successfully converted files, copy assets, and generate navigation config.
+ */
+export async function writeAll(targetContentDir, results, navigationMappings, allFiles) {
+    const writeResult = {
+        filesWritten: 0,
+        filesFailed: 0,
+        filesCopied: 0,
+        writtenPaths: [],
+        errors: [],
+    };
+    // Write each successfully converted file
+    for (const result of results) {
+        if (!result.success) {
+            writeResult.filesFailed++;
+            writeResult.errors.push({
+                path: result.file.targetRelativePath,
+                error: result.error || "Conversion failed",
+            });
+            continue;
+        }
+        try {
+            await writeConvertedFile(targetContentDir, result.file.targetRelativePath, result.content);
+            writeResult.filesWritten++;
+            writeResult.writtenPaths.push(result.file.targetRelativePath);
+        }
+        catch (err) {
+            writeResult.filesFailed++;
+            writeResult.errors.push({
+                path: result.file.targetRelativePath,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+    // Copy non-conversion files (images, assets)
+    if (allFiles) {
+        const filesToCopy = allFiles.filter((f) => !f.needsConversion);
+        for (const file of filesToCopy) {
+            try {
+                await copyAssetFile(targetContentDir, file);
+                writeResult.filesCopied++;
+                writeResult.writtenPaths.push(file.targetRelativePath);
+            }
+            catch (err) {
+                writeResult.filesFailed++;
+                writeResult.errors.push({
+                    path: file.targetRelativePath,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+    }
+    // Generate _meta.json navigation files
+    try {
+        const metaPaths = await writeMetaJson(targetContentDir, navigationMappings);
+        writeResult.writtenPaths.push(...metaPaths.map((p) => relative(targetContentDir, p)));
+    }
+    catch (err) {
+        writeResult.errors.push({
+            path: "_meta.json",
+            error: err instanceof Error ? err.message : String(err),
+        });
+    }
+    return writeResult;
+}

package/dist/ui/check-results-display.d.ts

@@ -0,0 +1,6 @@
+import type { ValidationResult } from "@specglass/core";
+interface CheckResultsDisplayProps {
+    results: ValidationResult[];
+}
+export declare function CheckResultsDisplay({ results }: CheckResultsDisplayProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/ui/check-results-display.js

@@ -0,0 +1,50 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+const CATEGORIES = [
+    { label: "Links", icon: "🔗", prefix: "LINK_" },
+    { label: "Frontmatter", icon: "📝", prefix: "FRONTMATTER_" },
+    { label: "Spec Drift", icon: "📊", prefix: "SPEC_DRIFT_" },
+];
+/**
+ * Group validation results by category (code prefix).
+ * Results that don't match any known category are placed in "Other".
+ */
+function groupByCategory(results) {
+    const grouped = new Map();
+    for (const result of results) {
+        const category = CATEGORIES.find((c) => result.code.startsWith(c.prefix));
+        const key = category?.prefix ?? "OTHER_";
+        const def = category ?? { label: "Other", icon: "❓", prefix: "OTHER_" };
+        if (!grouped.has(key)) {
+            grouped.set(key, { def, items: [] });
+        }
+        grouped.get(key).items.push(result);
+    }
+    return grouped;
+}
+function ResultItem({ result }) {
+    const icon = result.severity === "error" ? "❌" : "⚠️";
+    const color = result.severity === "error" ? "red" : "yellow";
+    return (_jsxs(Box, { flexDirection: "column", marginLeft: 2, children: [_jsxs(Box, { children: [_jsxs(Text, { color: color, children: [icon, " [", result.code, "]"] }), _jsxs(Text, { children: [" ", result.message] })] }), _jsx(Box, { marginLeft: 2, children: _jsxs(Text, { dimColor: true, children: [result.filePath, result.line ? `:${result.line}` : ""] }) }), result.hint && (_jsx(Box, { marginLeft: 2, children: _jsxs(Text, { color: "cyan", children: ["Hint: ", result.hint] }) }))] }));
+}
+function CategorySection({ def, items }) {
+    const errorCount = items.filter((i) => i.severity === "error").length;
+    const warningCount = items.filter((i) => i.severity === "warning").length;
+    const parts = [];
+    if (errorCount > 0)
+        parts.push(`${errorCount} error${errorCount !== 1 ? "s" : ""}`);
+    if (warningCount > 0)
+        parts.push(`${warningCount} warning${warningCount !== 1 ? "s" : ""}`);
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsxs(Text, { bold: true, children: [def.icon, " ", def.label] }), _jsxs(Text, { dimColor: true, children: [" (", parts.join(", "), ")"] })] }), items.map((item, i) => (_jsx(ResultItem, { result: item }, `${item.code}-${item.filePath}-${i}`)))] }));
+}
+export function CheckResultsDisplay({ results }) {
+    if (results.length === 0) {
+        return (_jsx(Box, { paddingX: 1, children: _jsx(Text, { color: "green", bold: true, children: "\u2705 All checks passed" }) }));
+    }
+    const grouped = groupByCategory(results);
+    const totalErrors = results.filter((r) => r.severity === "error").length;
+    const totalWarnings = results.filter((r) => r.severity === "warning").length;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(Text, { bold: true, children: "Specglass Check Results" }), Array.from(grouped.values()).map(({ def, items }) => (_jsx(CategorySection, { def: def, items: items }, def.prefix))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { bold: true, color: totalErrors > 0 ? "red" : "yellow", children: totalErrors > 0
+                        ? `✗ ${totalErrors} error${totalErrors !== 1 ? "s" : ""}${totalWarnings > 0 ? `, ${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""}` : ""}`
+                        : `⚠ ${totalWarnings} warning${totalWarnings !== 1 ? "s" : ""} (no errors)` }) })] }));
+}

package/dist/ui/consent-prompt.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Consent prompt component for the migration command.
+ *
+ * Warns the user that content will be sent to an external AI API
+ * and requires explicit consent before proceeding.
+ */
+import type { MigrationPlan } from "../migration/planner.js";
+export interface ConsentPromptProps {
+    /** The migration plan to display. */
+    plan: MigrationPlan;
+    /** Whether consent was already given via --yes flag. */
+    autoConsent: boolean;
+    /** Called when user makes a consent decision. */
+    onDecision: (consented: boolean) => void;
+}
+/**
+ * Displays the AI consent warning and waits for user input.
+ *
+ * Shows:
+ * - Warning about external API usage
+ * - Summary of what will be sent (file count)
+ * - Y/N prompt
+ */
+export declare function ConsentPrompt({ plan, autoConsent, onDecision, }: ConsentPromptProps): import("react/jsx-runtime").JSX.Element;