nextworks 0.2.0-alpha.2 → 0.2.0-alpha.20

package/dist/commands/doctor.js

@@ -0,0 +1,696 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctor = doctor;
+exports.formatDoctorResult = formatDoctorResult;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const file_operations_1 = require("../utils/file-operations");
+const package_manager_1 = require("../utils/package-manager");
+const yarn_pnp_1 = require("../utils/yarn-pnp");
+const installation_tracker_1 = require("../utils/installation-tracker");
+const TEMPLATE_SLUGS = [
+    "productlaunch",
+    "saasdashboard",
+    "digitalagency",
+    "gallery",
+];
+const COLLISION_CANDIDATES = {
+    src: [
+        "src/components/app-providers.tsx",
+        "src/components/ui",
+        "src/components/sections",
+        "src/app/globals.css",
+        "src/app/tw-animate.css",
+        "src/lib/utils.ts",
+        "src/app/layout.tsx",
+        "src/pages/_app.tsx",
+        "src/pages/_document.tsx",
+    ],
+    root: [
+        "components/app-providers.tsx",
+        "components/ui",
+        "components/sections",
+        "app/globals.css",
+        "app/tw-animate.css",
+        "lib/utils.ts",
+        "app/layout.tsx",
+        "pages/_app.tsx",
+        "pages/_document.tsx",
+    ],
+};
+function hasTailwindDependency(pkg) {
+    return Boolean(pkg.dependencies?.tailwindcss || pkg.devDependencies?.tailwindcss);
+}
+function hasTypeScriptDependency(pkg) {
+    return Boolean(pkg.dependencies?.typescript || pkg.devDependencies?.typescript);
+}
+async function hasTsconfig(cwd) {
+    return (0, file_operations_1.fileExists)(path_1.default.join(cwd, "tsconfig.json"));
+}
+async function hasCssBasedTailwindUsage(cwd) {
+    const cssCandidates = [
+        path_1.default.join(cwd, "app", "globals.css"),
+        path_1.default.join(cwd, "src", "app", "globals.css"),
+        path_1.default.join(cwd, "styles", "globals.css"),
+        path_1.default.join(cwd, "src", "styles", "globals.css"),
+        path_1.default.join(cwd, "pages", "_app.tsx"),
+        path_1.default.join(cwd, "src", "pages", "_app.tsx"),
+    ];
+    for (const candidate of cssCandidates) {
+        if (!(await (0, file_operations_1.fileExists)(candidate))) {
+            continue;
+        }
+        try {
+            const content = await fs_extra_1.default.readFile(candidate, "utf8");
+            if (content.includes('@import "tailwindcss"') ||
+                content.includes("@import 'tailwindcss'") ||
+                content.includes("@theme")) {
+                return true;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+const MIN_MAJOR_NODE_VERSION = 20;
+const YARN_PNP_MESSAGE = "Set nodeLinker: node-modules in .yarnrc.yml";
+function createInitialDoctorResult() {
+    return {
+        projectSanity: {
+            hasPackageJson: false,
+            hasNext: false,
+            projectRoot: null,
+            routerType: null,
+            projectRootMode: null,
+        },
+        environmentChecks: {
+            nodeVersion: { status: "ok", message: "" },
+            packageManager: { pm: "pnpm", installCommand: "" },
+            yarnPnPDetection: {
+                isPnP: false,
+                message: YARN_PNP_MESSAGE,
+            },
+            tailwind: {
+                hasTailwindDependency: false,
+                hasCssBasedTailwindUsage: false,
+                detected: false,
+            },
+            typescript: {
+                hasTsconfig: false,
+                hasTypeScriptDependency: false,
+                detected: false,
+            },
+        },
+        projectRootWritability: {
+            path: "",
+            exists: false,
+            writable: null,
+        },
+        appProvidersShim: {
+            path: "",
+            exists: false,
+            target: null,
+            targetExists: null,
+            targetMatchesRouter: null,
+        },
+        collisions: {
+            paths: [],
+        },
+        recordedInstallState: {
+            installedKits: [],
+        },
+        blocksFilePresence: [],
+        routerPatchability: {
+            appLayout: {
+                path: "",
+                exists: false,
+                writable: false,
+                writableInfo: { status: "init" },
+                hasSuppressHydrationWarning: { status: "init" },
+            },
+            pagesApp: {
+                path: "",
+                exists: false,
+                writable: false,
+                writableInfo: { status: "init" },
+                hasSuppressHydrationWarning: { status: "init" },
+            },
+            pagesDocument: {
+                path: "",
+                exists: false,
+                writable: false,
+                writableInfo: { status: "init" },
+                hasSuppressHydrationWarning: { status: "init" },
+            },
+        },
+        warnings: [],
+        errors: [],
+    };
+}
+function getPackageJsonPath(cwd) {
+    return path_1.default.join(cwd, "package.json");
+}
+async function readPackageJson(cwd) {
+    return fs_extra_1.default.readJson(getPackageJsonPath(cwd));
+}
+function getNodeVersionCheck() {
+    const rawVersion = process.version;
+    const nodeVersion = process.versions.node;
+    const major = Number(nodeVersion.split(".")[0]);
+    if (!Number.isFinite(major)) {
+        return {
+            status: "error",
+            message: `Unable to determine Node.js version (reported: ${rawVersion})`,
+        };
+    }
+    if (major < MIN_MAJOR_NODE_VERSION) {
+        return {
+            status: "error",
+            message: `Node.js ${rawVersion} detected — nextworks requires Node.js >= ${MIN_MAJOR_NODE_VERSION}`,
+        };
+    }
+    return {
+        status: "ok",
+        message: `Node.js ${rawVersion} detected`,
+    };
+}
+function getProjectRootInfo(options) {
+    const { mode, hasAppRouter, hasPagesRouter } = options;
+    if (mode !== "src" && mode !== "root") {
+        return {
+            routerType: null,
+            projectRootMode: null,
+        };
+    }
+    let routerType = null;
+    let routerTypeLabel = null;
+    if (hasAppRouter && hasPagesRouter) {
+        routerType = "hybrid";
+        routerTypeLabel = "Hybrid router";
+    }
+    else if (hasAppRouter) {
+        routerType = "app";
+        routerTypeLabel = "App router";
+    }
+    else if (hasPagesRouter) {
+        routerType = "pages";
+        routerTypeLabel = "Pages router";
+    }
+    else {
+        return {
+            routerType: null,
+            projectRootMode: null,
+        };
+    }
+    const rootLabel = mode === "src" ? "with src folder" : "with no src folder";
+    return {
+        routerType,
+        projectRootMode: `${routerTypeLabel} ${rootLabel}`,
+    };
+}
+async function fileHasSuppressHydrationWarning(filePath) {
+    try {
+        const fileContent = await fs_extra_1.default.readFile(filePath, "utf8");
+        return fileContent.includes("suppressHydrationWarning")
+            ? { status: "found" }
+            : { status: "not-found" };
+    }
+    catch (error) {
+        return { status: "unreadable", error };
+    }
+}
+async function fileIsWritable(filePath) {
+    try {
+        await fs_extra_1.default.access(filePath, fs_extra_1.default.constants.W_OK);
+        return { status: "writable" };
+    }
+    catch (err) {
+        const errorCode = typeof err === "object" &&
+            err !== null &&
+            "code" in err &&
+            typeof err.code === "string"
+            ? err.code
+            : null;
+        if (errorCode === "EACCES" || errorCode === "EPERM") {
+            return { status: "not-writable" };
+        }
+        const parentDir = path_1.default.dirname(filePath);
+        try {
+            await fs_extra_1.default.access(parentDir, fs_extra_1.default.constants.W_OK);
+            return { status: "not-found-parent-writable" };
+        }
+        catch {
+            return { status: "not-found-parent-not-writable" };
+        }
+    }
+}
+async function directoryIsWritable(directoryPath) {
+    try {
+        const stats = await fs_extra_1.default.stat(directoryPath);
+        if (!stats.isDirectory()) {
+            return null;
+        }
+        await fs_extra_1.default.access(directoryPath, fs_extra_1.default.constants.W_OK);
+        return true;
+    }
+    catch (error) {
+        if (typeof error === "object" &&
+            error !== null &&
+            "code" in error &&
+            (error.code === "EACCES" || error.code === "EPERM")) {
+            return false;
+        }
+        return null;
+    }
+}
+async function getProjectRootWritability(cwd) {
+    const exists = await (0, file_operations_1.fileExists)(cwd);
+    if (!exists) {
+        return {
+            path: cwd,
+            exists: false,
+            writable: null,
+        };
+    }
+    return {
+        path: cwd,
+        exists: true,
+        writable: await directoryIsWritable(cwd),
+    };
+}
+async function getAppProvidersShimDiagnostics(cwd, routerType) {
+    const warnings = [];
+    const shimCandidates = [
+        path_1.default.join(cwd, "components", "app-providers.tsx"),
+        path_1.default.join(cwd, "src", "components", "app-providers.tsx"),
+    ];
+    let shimPath = shimCandidates[0];
+    for (const candidate of shimCandidates) {
+        if (await (0, file_operations_1.fileExists)(candidate)) {
+            shimPath = candidate;
+            break;
+        }
+    }
+    const exists = await (0, file_operations_1.fileExists)(shimPath);
+    const shim = {
+        path: shimPath,
+        exists,
+        target: null,
+        targetExists: null,
+        targetMatchesRouter: null,
+    };
+    if (!exists) {
+        return { shim, warnings };
+    }
+    const content = await fs_extra_1.default.readFile(shimPath, "utf8");
+    const match = content.match(/from\s+["']\.\/(app-providers\.(?:app|pages))["']/);
+    const target = match?.[1] ?? null;
+    shim.target = target;
+    if (!target) {
+        return { shim, warnings };
+    }
+    const targetPath = path_1.default.join(path_1.default.dirname(shimPath), `${target}.tsx`);
+    shim.targetExists = await (0, file_operations_1.fileExists)(targetPath);
+    if (shim.targetExists === false) {
+        warnings.push(`app-providers shim target file is missing: ${targetPath}`);
+    }
+    const expectedTarget = routerType === "app"
+        ? "app-providers.app"
+        : routerType === "pages"
+            ? "app-providers.pages"
+            : null;
+    shim.targetMatchesRouter = expectedTarget ? expectedTarget === target : null;
+    if (expectedTarget && expectedTarget !== target) {
+        warnings.push(`app-providers shim target does not match detected ${routerType} router mode: ${shimPath} -> ${target}`);
+    }
+    return { shim, warnings };
+}
+function getRouterPatchabilityDiagnostics(result) {
+    const warnings = [];
+    const errors = [];
+    const { routerType } = result.projectSanity;
+    if (routerType === "app" || routerType === "hybrid") {
+        const appLayout = result.routerPatchability.appLayout;
+        if (appLayout.exists && appLayout.writableInfo.status === "not-writable") {
+            errors.push(`App Router layout is not writable: ${appLayout.path}`);
+        }
+        if (appLayout.exists &&
+            appLayout.hasSuppressHydrationWarning.status === "not-found") {
+            warnings.push(`App Router layout is missing suppressHydrationWarning: ${appLayout.path}`);
+        }
+    }
+    if (routerType === "pages" || routerType === "hybrid") {
+        const pagesApp = result.routerPatchability.pagesApp;
+        const pagesDocument = result.routerPatchability.pagesDocument;
+        if (pagesApp.exists && pagesApp.writableInfo.status === "not-writable") {
+            errors.push(`Pages Router _app.tsx is not writable: ${pagesApp.path}`);
+        }
+        if (pagesDocument.exists &&
+            pagesDocument.writableInfo.status === "not-writable") {
+            errors.push(`Pages Router _document.tsx is not writable: ${pagesDocument.path}`);
+        }
+        if (pagesDocument.exists &&
+            pagesDocument.hasSuppressHydrationWarning.status === "not-found") {
+            warnings.push(`Pages Router _document.tsx is missing suppressHydrationWarning: ${pagesDocument.path}`);
+        }
+        if (!pagesDocument.exists &&
+            pagesDocument.writableInfo.status === "not-found-parent-writable") {
+            warnings.push(`Pages Router _document.tsx does not exist and will need to be created during install: ${pagesDocument.path}`);
+        }
+        if (!pagesDocument.exists &&
+            pagesDocument.writableInfo.status === "not-found-parent-not-writable") {
+            errors.push(`Pages Router _document.tsx does not exist and its parent directory is not writable: ${pagesDocument.path}`);
+        }
+    }
+    return { warnings, errors };
+}
+function collectCollisionChecks(cwd, mode, routerType) {
+    const candidates = [...COLLISION_CANDIDATES[mode]];
+    for (const slug of TEMPLATE_SLUGS) {
+        if (routerType === "pages" || routerType === "hybrid") {
+            if (mode === "src") {
+                candidates.push(`src/pages/templates/${slug}/index.tsx`);
+                candidates.push(`src/components/templates/${slug}`);
+            }
+            else {
+                candidates.push(`pages/templates/${slug}/index.tsx`);
+                candidates.push(`components/templates/${slug}`);
+            }
+        }
+        if (routerType === "app" || routerType === "hybrid") {
+            if (mode === "src") {
+                candidates.push(`src/app/templates/${slug}/page.tsx`);
+                candidates.push(`src/app/templates/${slug}`);
+            }
+            else {
+                candidates.push(`app/templates/${slug}/page.tsx`);
+                candidates.push(`app/templates/${slug}`);
+            }
+        }
+    }
+    return candidates.map((relativePath) => ({
+        path: path_1.default.join(cwd, relativePath),
+        exists: false,
+    }));
+}
+async function getCollisionDiagnostics(cwd, mode, routerType) {
+    const paths = collectCollisionChecks(cwd, mode, routerType);
+    for (const entry of paths) {
+        entry.exists = await (0, file_operations_1.fileExists)(entry.path);
+    }
+    return { paths };
+}
+async function getRecordedInstallState() {
+    const config = await (0, installation_tracker_1.getNextworksConfig)();
+    return {
+        installedKits: config.installedKits.map((kit) => ({
+            name: kit.name,
+            dependencies: [...kit.dependencies],
+            devDependencies: [...kit.devDependencies],
+            files: [...kit.files],
+            installedAt: kit.installedAt,
+        })),
+    };
+}
+function getBlocksInstalledFileChecks(cwd, manifest, recordedInstallState) {
+    const installedBlocksKit = recordedInstallState.installedKits.find((kit) => kit.name === manifest.name);
+    if (!installedBlocksKit) {
+        return [];
+    }
+    return installedBlocksKit.files.map((relativePath) => ({
+        path: path_1.default.join(cwd, relativePath),
+        exists: false,
+        required: true,
+    }));
+}
+async function doctor(options = {}) {
+    const cwd = process.cwd();
+    const result = createInitialDoctorResult();
+    const manifestPath = (0, file_operations_1.resolveAssetPath)("cli_manifests", "blocks_manifest.json");
+    const packageJsonPath = getPackageJsonPath(cwd);
+    const hasPackageJson = await (0, file_operations_1.fileExists)(packageJsonPath);
+    result.projectSanity.hasPackageJson = hasPackageJson;
+    if (!hasPackageJson) {
+        result.errors.push("package.json not found. Run nextworks from a Next.js project root.");
+    }
+    let packageJson = null;
+    if (hasPackageJson) {
+        const pkg = (await readPackageJson(cwd));
+        packageJson = pkg;
+        result.projectSanity.hasNext = Boolean(pkg.dependencies?.next || pkg.devDependencies?.next);
+        if (!result.projectSanity.hasNext) {
+            result.errors.push('Next.js dependency "next" not found in dependencies or devDependencies.');
+        }
+    }
+    const manifest = (await (0, file_operations_1.readJsonFile)(manifestPath));
+    const mode = await (0, file_operations_1.detectProjectRootMode)(cwd);
+    result.projectSanity.projectRoot = mode;
+    const detectedLayoutPath = mode === "src" ? "src/app/layout.tsx" : "app/layout.tsx";
+    const detectedPagesAppPath = mode === "src" ? "src/pages/_app.tsx" : "pages/_app.tsx";
+    const appRouterLayoutExists = await (0, file_operations_1.fileExists)(detectedLayoutPath);
+    const pagesRouterAppExists = await (0, file_operations_1.fileExists)(detectedPagesAppPath);
+    const { routerType, projectRootMode } = getProjectRootInfo({
+        mode,
+        hasAppRouter: appRouterLayoutExists,
+        hasPagesRouter: pagesRouterAppExists,
+    });
+    if (routerType) {
+        result.projectSanity.routerType = routerType;
+    }
+    if (projectRootMode) {
+        result.projectSanity.projectRootMode = projectRootMode;
+    }
+    else {
+        result.errors.push("No supported Next.js router entrypoint found. Expected app/layout.tsx, src/app/layout.tsx, pages/_app.tsx, or src/pages/_app.tsx.");
+    }
+    result.environmentChecks.nodeVersion = getNodeVersionCheck();
+    if (result.environmentChecks.nodeVersion.status === "error") {
+        result.errors.push(result.environmentChecks.nodeVersion.message);
+    }
+    const detectedPM = await (0, package_manager_1.detectPackageManager)(cwd);
+    const installCmd = (0, package_manager_1.getInstallCommand)(detectedPM);
+    result.environmentChecks.packageManager.pm = detectedPM;
+    result.environmentChecks.packageManager.installCommand = installCmd;
+    const isYarnPnP = await (0, yarn_pnp_1.isYarnPnPProject)(cwd);
+    result.environmentChecks.yarnPnPDetection.isPnP = isYarnPnP;
+    if (isYarnPnP) {
+        result.warnings.push(`Yarn Plug'n'Play detected. ${result.environmentChecks.yarnPnPDetection.message}`);
+    }
+    if (packageJson) {
+        result.environmentChecks.tailwind.hasTailwindDependency =
+            hasTailwindDependency(packageJson);
+        result.environmentChecks.typescript.hasTypeScriptDependency =
+            hasTypeScriptDependency(packageJson);
+    }
+    result.environmentChecks.tailwind.hasCssBasedTailwindUsage =
+        await hasCssBasedTailwindUsage(cwd);
+    result.environmentChecks.tailwind.detected =
+        result.environmentChecks.tailwind.hasTailwindDependency ||
+            result.environmentChecks.tailwind.hasCssBasedTailwindUsage;
+    if (!result.environmentChecks.tailwind.detected) {
+        result.warnings.push('Tailwind CSS was not detected. Blocks requires Tailwind CSS v4-style setup via a `tailwindcss` dependency or CSS imports such as `@import "tailwindcss"`.');
+    }
+    result.environmentChecks.typescript.hasTsconfig = await hasTsconfig(cwd);
+    result.environmentChecks.typescript.detected =
+        result.environmentChecks.typescript.hasTsconfig ||
+            result.environmentChecks.typescript.hasTypeScriptDependency;
+    if (!result.environmentChecks.typescript.detected) {
+        result.errors.push("TypeScript was not detected. Blocks requires a `tsconfig.json` file or a `typescript` dependency in dependencies or devDependencies.");
+    }
+    result.projectRootWritability = await getProjectRootWritability(cwd);
+    if (!result.projectRootWritability.exists) {
+        result.errors.push(`Project root does not exist: ${result.projectRootWritability.path}`);
+    }
+    else if (result.projectRootWritability.writable === false) {
+        result.errors.push(`Project root is not writable: ${result.projectRootWritability.path}`);
+    }
+    if (result.projectSanity.routerType === "app" ||
+        result.projectSanity.routerType === "hybrid") {
+        let layoutFilePath = "";
+        if (result.projectSanity.projectRoot === "src") {
+            layoutFilePath = path_1.default.join(process.cwd(), "src", "app", "layout.tsx");
+        }
+        else {
+            layoutFilePath = path_1.default.join(process.cwd(), "app", "layout.tsx");
+        }
+        result.routerPatchability.appLayout.path = layoutFilePath;
+        const layoutExists = await (0, file_operations_1.fileExists)(layoutFilePath);
+        result.routerPatchability.appLayout.exists = layoutExists;
+        const writableInfo = await fileIsWritable(layoutFilePath);
+        result.routerPatchability.appLayout.writableInfo = writableInfo;
+        const writableStatus = writableInfo.status;
+        if (writableStatus === "writable") {
+            result.routerPatchability.appLayout.writable = true;
+        }
+        else if (writableStatus === "not-writable") {
+            result.routerPatchability.appLayout.writable = false;
+        }
+        else {
+            result.routerPatchability.appLayout.writable = null;
+        }
+        const hasHydrationWarning = await fileHasSuppressHydrationWarning(layoutFilePath);
+        result.routerPatchability.appLayout.hasSuppressHydrationWarning =
+            hasHydrationWarning;
+    }
+    if (result.projectSanity.routerType === "pages" ||
+        result.projectSanity.routerType === "hybrid") {
+        let _appFilePath = "";
+        if (result.projectSanity.projectRoot === "src") {
+            _appFilePath = path_1.default.join(process.cwd(), "src", "pages", "_app.tsx");
+        }
+        else {
+            _appFilePath = path_1.default.join(process.cwd(), "pages", "_app.tsx");
+        }
+        result.routerPatchability.pagesApp.path = _appFilePath;
+        const _appExists = await (0, file_operations_1.fileExists)(_appFilePath);
+        result.routerPatchability.pagesApp.exists = _appExists;
+        const appWritableInfo = await fileIsWritable(_appFilePath);
+        result.routerPatchability.pagesApp.writableInfo = appWritableInfo;
+        const appWritableStatus = appWritableInfo.status;
+        if (appWritableStatus === "writable") {
+            result.routerPatchability.pagesApp.writable = true;
+        }
+        else if (appWritableStatus === "not-writable") {
+            result.routerPatchability.pagesApp.writable = false;
+        }
+        else {
+            result.routerPatchability.pagesApp.writable = null;
+        }
+        let _documentFilePath = "";
+        if (result.projectSanity.projectRoot === "src") {
+            _documentFilePath = path_1.default.join(process.cwd(), "src", "pages", "_document.tsx");
+        }
+        else {
+            _documentFilePath = path_1.default.join(process.cwd(), "pages", "_document.tsx");
+        }
+        result.routerPatchability.pagesDocument.path = _documentFilePath;
+        const _documentExists = await (0, file_operations_1.fileExists)(_documentFilePath);
+        result.routerPatchability.pagesDocument.exists = _documentExists;
+        const documentWritableInfo = await fileIsWritable(_documentFilePath);
+        result.routerPatchability.pagesDocument.writableInfo = documentWritableInfo;
+        const documentWritableStatus = documentWritableInfo.status;
+        if (documentWritableStatus === "writable") {
+            result.routerPatchability.pagesDocument.writable = true;
+        }
+        else if (documentWritableStatus === "not-writable") {
+            result.routerPatchability.pagesDocument.writable = false;
+        }
+        else {
+            result.routerPatchability.pagesDocument.writable = null;
+        }
+        const hasHydrationWarning = await fileHasSuppressHydrationWarning(_documentFilePath);
+        result.routerPatchability.pagesDocument.hasSuppressHydrationWarning =
+            hasHydrationWarning;
+    }
+    const shimDiagnostics = await getAppProvidersShimDiagnostics(cwd, result.projectSanity.routerType);
+    result.appProvidersShim = shimDiagnostics.shim;
+    result.warnings.push(...shimDiagnostics.warnings);
+    result.collisions = await getCollisionDiagnostics(cwd, mode ?? "root", result.projectSanity.routerType);
+    result.warnings.push(...result.collisions.paths
+        .filter((entry) => entry.exists)
+        .map((entry) => `Install collision detected: ${entry.path}`));
+    result.recordedInstallState = await getRecordedInstallState();
+    if (result.recordedInstallState.installedKits.length === 0) {
+        result.warnings.push("No recorded installed kits found in .nextworks/config.json.");
+    }
+    result.blocksFilePresence = getBlocksInstalledFileChecks(cwd, manifest, result.recordedInstallState);
+    for (const entry of result.blocksFilePresence) {
+        entry.exists = await (0, file_operations_1.fileExists)(entry.path);
+        if (!entry.exists) {
+            result.warnings.push(`Recorded Blocks install is missing expected file: ${entry.path}`);
+        }
+    }
+    const diagnostics = getRouterPatchabilityDiagnostics(result);
+    result.warnings.push(...diagnostics.warnings);
+    result.errors.push(...diagnostics.errors);
+    return result;
+}
+function formatDoctorResult(result) {
+    const lines = ["Doctor diagnostics"];
+    const iconFor = (status) => status === "ok" ? "✅" : status === "warning" ? "⚠️" : "❌";
+    lines.push("\nEnvironment");
+    lines.push(`  ${iconFor(result.environmentChecks.nodeVersion.status)} ${result.environmentChecks.nodeVersion.message}`);
+    lines.push(`  ✅ Package manager detected: ${result.environmentChecks.packageManager.pm} (${result.environmentChecks.packageManager.installCommand})`);
+    lines.push(`  ${result.environmentChecks.yarnPnPDetection.isPnP ? "⚠️" : "✅"} Yarn Plug'n'Play ${result.environmentChecks.yarnPnPDetection.isPnP ? "detected" : "not detected"}`);
+    if (result.environmentChecks.yarnPnPDetection.isPnP)
+        lines.push(`  ⚠️ ${result.environmentChecks.yarnPnPDetection.message}`);
+    lines.push("\nProject detection");
+    lines.push(`  ${result.projectSanity.hasPackageJson ? "✅" : "❌"} package.json ${result.projectSanity.hasPackageJson ? "found" : "not found"}`);
+    lines.push(`  ${result.projectSanity.hasNext ? "✅" : "❌"} Next.js dependency ${result.projectSanity.hasNext ? "found" : "not found"}`);
+    lines.push(`  ${result.projectSanity.projectRoot ? "✅" : "❌"} Project root mode: ${result.projectSanity.projectRoot ?? "not detected"}`);
+    lines.push(`  ${result.projectSanity.routerType ? "✅" : "❌"} Router type: ${result.projectSanity.routerType ?? "not detected"}`);
+    if (result.projectSanity.projectRootMode)
+        lines.push(`  ✅ ${result.projectSanity.projectRootMode}`);
+    lines.push("\nRouter / patch targets");
+    if (result.projectSanity.routerType === "app" ||
+        result.projectSanity.routerType === "hybrid") {
+        lines.push(`  ${result.routerPatchability.appLayout.exists ? "✅" : "⚠️"} app/layout.tsx: ${result.routerPatchability.appLayout.path}`);
+        lines.push(`  ${result.routerPatchability.appLayout.exists ? (result.routerPatchability.appLayout.writableInfo.status === "not-writable" ? "❌" : "✅") : "⚠️"} Writable: ${String(result.routerPatchability.appLayout.writable)}`);
+        lines.push(`  ${result.routerPatchability.appLayout.hasSuppressHydrationWarning.status === "found" ? "✅" : "⚠️"} suppressHydrationWarning: ${result.routerPatchability.appLayout.hasSuppressHydrationWarning.status}`);
+    }
+    if (result.projectSanity.routerType === "pages" ||
+        result.projectSanity.routerType === "hybrid") {
+        lines.push(`  ${result.routerPatchability.pagesApp.exists ? "✅" : "⚠️"} pages/_app.tsx: ${result.routerPatchability.pagesApp.path}`);
+        lines.push(`  ${result.routerPatchability.pagesApp.exists ? (result.routerPatchability.pagesApp.writableInfo.status === "not-writable" ? "❌" : "✅") : "⚠️"} Writable: ${String(result.routerPatchability.pagesApp.writable)}`);
+        lines.push(`  ${result.routerPatchability.pagesDocument.exists ? "✅" : "⚠️"} pages/_document.tsx: ${result.routerPatchability.pagesDocument.path}`);
+        lines.push(`  ${result.routerPatchability.pagesDocument.exists ? (result.routerPatchability.pagesDocument.writableInfo.status === "not-writable" || result.routerPatchability.pagesDocument.writableInfo.status === "not-found-parent-not-writable" ? "❌" : "✅") : "⚠️"} Writable: ${String(result.routerPatchability.pagesDocument.writable)}`);
+        lines.push(`  ${result.routerPatchability.pagesDocument.hasSuppressHydrationWarning.status === "found" ? "✅" : "⚠️"} suppressHydrationWarning: ${result.routerPatchability.pagesDocument.hasSuppressHydrationWarning.status}`);
+        lines.push(`  ${result.appProvidersShim.exists ? (result.appProvidersShim.targetMatchesRouter === false || result.appProvidersShim.targetExists === false ? "⚠️" : "✅") : "⚠️"} components/app-providers.tsx: ${result.appProvidersShim.path}`);
+    }
+    lines.push("\nKit prerequisites");
+    lines.push(`  ${result.environmentChecks.tailwind.detected ? "✅" : "⚠️"} Tailwind CSS ${result.environmentChecks.tailwind.detected ? "detected" : "not detected"}`);
+    lines.push(`  ${result.environmentChecks.typescript.detected ? "✅" : "❌"} TypeScript ${result.environmentChecks.typescript.detected ? "detected" : "not detected"}`);
+    lines.push("\nFilesystem / collisions");
+    lines.push(`  ${result.projectRootWritability.writable === false ? "❌" : result.projectRootWritability.exists ? "✅" : "❌"} Project root writable: ${String(result.projectRootWritability.writable)}`);
+    const existingCollisions = result.collisions.paths.filter((collision) => collision.exists);
+    if (existingCollisions.length === 0) {
+        lines.push("  ✅ No install collisions detected");
+    }
+    else {
+        for (const entry of existingCollisions) {
+            lines.push(`  ⚠️ Collision: ${entry.path}`);
+        }
+    }
+    lines.push("\nInstalled state");
+    if (result.recordedInstallState.installedKits.length === 0) {
+        lines.push("  ⚠️ No recorded installed kits found");
+    }
+    else {
+        for (const kit of result.recordedInstallState.installedKits) {
+            lines.push(`  ✅ Recorded kit: ${kit.name}`);
+        }
+    }
+    const missingRecordedFiles = result.blocksFilePresence.filter((file) => !file.exists);
+    if (missingRecordedFiles.length > 0) {
+        for (const entry of missingRecordedFiles) {
+            lines.push(`  ⚠️ Missing recorded file: ${entry.path}`);
+        }
+    }
+    lines.push("\nRecommendation");
+    if (result.errors.length === 0) {
+        lines.push("  ✅ Recommended next step: nextworks add blocks");
+    }
+    else {
+        const priorityError = result.errors[0];
+        lines.push(`  ❌ Fix blocking issues before install: ${priorityError}`);
+    }
+    if (result.warnings.length) {
+        lines.push("\nWarnings");
+        for (const warning of result.warnings) {
+            lines.push(`  ⚠️ ${warning}`);
+        }
+    }
+    if (result.errors.length) {
+        lines.push("\nErrors");
+        for (const error of result.errors) {
+            lines.push(`  ❌ ${error}`);
+        }
+    }
+    return lines;
+}
+//# sourceMappingURL=doctor.js.map