lattice-ui 0.4.3

package/dist/commands/init.js

@@ -0,0 +1,547 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInitCommand = runInitCommand;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const errors_1 = require("../core/errors");
+const copy_1 = require("../core/fs/copy");
+const logger_1 = require("../core/logger");
+const latest_1 = require("../core/npm/latest");
+const output_1 = require("../core/output");
+const detect_1 = require("../core/pm/detect");
+const findRoot_1 = require("../core/project/findRoot");
+const readPackageJson_1 = require("../core/project/readPackageJson");
+const writePackageJson_1 = require("../core/project/writePackageJson");
+const prompt_1 = require("../core/prompt");
+const SUPPORTED_TEMPLATE = "rbxts";
+const GITIGNORE_ENTRIES = [
+    "node_modules",
+    "out",
+    "include",
+    "*.rbxl",
+    "*.rbxlx",
+    "*.rbxm",
+    "*.rbxmx",
+    "*.rbxl.lock",
+    "*.rbxlx.lock",
+    "*.rbxm.lock",
+    "*.rbxmx.lock",
+    "*.tsbuildinfo",
+    ".pnpm-store",
+    ".DS_Store",
+];
+const PROJECT_DIRECTORIES = ["include", "out/shared", "out/server", "out/client"];
+const PNPM_NPMRC_PATH = ".npmrc";
+const PNPM_NODE_LINKER_LINE = "node-linker=hoisted";
+const CORE_VERSION_PACKAGES = {
+    latticeStyle: "@lattice-ui/style",
+    latticeCli: "@lattice-ui/cli",
+    rbxtsReact: "@rbxts/react",
+    rbxtsReactRoblox: "@rbxts/react-roblox",
+    rbxtsCompilerTypes: "@rbxts/compiler-types",
+    rbxtsTypes: "@rbxts/types",
+    robloxTs: "roblox-ts",
+    typescript: "typescript",
+};
+const LINT_VERSION_PACKAGES = {
+    eslint: "eslint",
+    eslintEslintrc: "@eslint/eslintrc",
+    eslintJs: "@eslint/js",
+    eslintConfigPrettier: "eslint-config-prettier",
+    eslintPluginPrettier: "eslint-plugin-prettier",
+    eslintPluginRobloxTs: "eslint-plugin-roblox-ts",
+    typescriptEslintPlugin: "@typescript-eslint/eslint-plugin",
+    typescriptEslintParser: "@typescript-eslint/parser",
+    prettier: "prettier",
+};
+function normalizeTemplate(template) {
+    const value = template?.trim();
+    if (!value || value.length === 0) {
+        return SUPPORTED_TEMPLATE;
+    }
+    return value;
+}
+async function selectTemplate(providedTemplate) {
+    const normalized = normalizeTemplate(providedTemplate);
+    if (normalized !== SUPPORTED_TEMPLATE) {
+        throw (0, errors_1.usageError)(`Unknown template: ${normalized}. Supported template: ${SUPPORTED_TEMPLATE}.`);
+    }
+    return normalized;
+}
+async function selectLintEnabled(runtime, providedLint, promptConfirmFn) {
+    if (providedLint !== undefined) {
+        return providedLint;
+    }
+    if (runtime.yes) {
+        return false;
+    }
+    return promptConfirmFn(runtime, "Set up ESLint + Prettier?", { defaultValue: false });
+}
+async function readTemplateJson(templateDir, fileName, replacements) {
+    const filePath = path.join(templateDir, fileName);
+    const raw = await node_fs_1.promises.readFile(filePath, "utf8");
+    let content = raw;
+    for (const [from, to] of Object.entries(replacements)) {
+        content = content.split(from).join(to);
+    }
+    return JSON.parse(content);
+}
+function sortStringRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([left], [right]) => left.localeCompare(right)));
+}
+function mergeMissingRecord(current, incoming, options) {
+    if (!incoming || Object.keys(incoming).length === 0) {
+        return {
+            changed: false,
+            next: current,
+            added: [],
+        };
+    }
+    const next = { ...(current ?? {}) };
+    const added = [];
+    for (const [key, value] of Object.entries(incoming)) {
+        if (next[key] !== undefined) {
+            continue;
+        }
+        next[key] = value;
+        added.push(key);
+    }
+    if (added.length === 0) {
+        return {
+            changed: false,
+            next: current,
+            added,
+        };
+    }
+    return {
+        changed: true,
+        next: options?.sortKeys ? sortStringRecord(next) : next,
+        added,
+    };
+}
+function planManifestChanges(currentManifest, templates) {
+    let nextManifest = { ...currentManifest };
+    const addedScripts = [];
+    const addedDependencies = [];
+    const addedDevDependencies = [];
+    let changed = false;
+    for (const template of templates) {
+        const scripts = mergeMissingRecord(nextManifest.scripts, template.scripts);
+        if (scripts.changed) {
+            nextManifest = {
+                ...nextManifest,
+                scripts: scripts.next,
+            };
+            addedScripts.push(...scripts.added);
+            changed = true;
+        }
+        const dependencies = mergeMissingRecord(nextManifest.dependencies, template.dependencies, { sortKeys: true });
+        if (dependencies.changed) {
+            nextManifest = {
+                ...nextManifest,
+                dependencies: dependencies.next,
+            };
+            addedDependencies.push(...dependencies.added);
+            changed = true;
+        }
+        const devDependencies = mergeMissingRecord(nextManifest.devDependencies, template.devDependencies, {
+            sortKeys: true,
+        });
+        if (devDependencies.changed) {
+            nextManifest = {
+                ...nextManifest,
+                devDependencies: devDependencies.next,
+            };
+            addedDevDependencies.push(...devDependencies.added);
+            changed = true;
+        }
+    }
+    return {
+        changed,
+        nextManifest,
+        addedScripts: [...new Set(addedScripts)],
+        addedDependencies: [...new Set(addedDependencies)],
+        addedDevDependencies: [...new Set(addedDevDependencies)],
+    };
+}
+async function planGitignore(projectRoot) {
+    const gitignorePath = path.join(projectRoot, ".gitignore");
+    let currentContent = "";
+    let exists = true;
+    try {
+        currentContent = await node_fs_1.promises.readFile(gitignorePath, "utf8");
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT") {
+            throw error;
+        }
+        exists = false;
+    }
+    const existingEntries = new Set(currentContent
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0));
+    const addedEntries = GITIGNORE_ENTRIES.filter((entry) => !existingEntries.has(entry));
+    if (addedEntries.length === 0) {
+        return {
+            changed: false,
+            created: false,
+            addedEntries: [],
+            nextContent: currentContent,
+        };
+    }
+    let nextContent = currentContent;
+    if (nextContent.length > 0 && !nextContent.endsWith("\n")) {
+        nextContent += "\n";
+    }
+    nextContent += `${addedEntries.join("\n")}\n`;
+    return {
+        changed: true,
+        created: !exists,
+        addedEntries,
+        nextContent,
+    };
+}
+async function ensureProjectDirectories(projectRoot) {
+    await Promise.all(PROJECT_DIRECTORIES.map((directory) => node_fs_1.promises.mkdir(path.join(projectRoot, directory), { recursive: true })));
+}
+function inferProjectName(projectRoot, manifest) {
+    const packageName = manifest.name?.trim();
+    if (packageName && packageName.length > 0) {
+        return packageName;
+    }
+    return path.basename(projectRoot);
+}
+function buildVersionReplacements(projectName, versions) {
+    return {
+        __PROJECT_NAME__: projectName,
+        __LATTICE_STYLE_VERSION__: versions[CORE_VERSION_PACKAGES.latticeStyle],
+        __LATTICE_CLI_VERSION__: versions[CORE_VERSION_PACKAGES.latticeCli],
+        __RBXTS_REACT_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsReact],
+        __RBXTS_REACT_ROBLOX_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsReactRoblox],
+        __RBXTS_COMPILER_TYPES_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsCompilerTypes],
+        __RBXTS_TYPES_VERSION__: versions[CORE_VERSION_PACKAGES.rbxtsTypes],
+        __ROBLOX_TS_VERSION__: versions[CORE_VERSION_PACKAGES.robloxTs],
+        __TYPESCRIPT_VERSION__: versions[CORE_VERSION_PACKAGES.typescript],
+        __ESLINT_VERSION__: versions[LINT_VERSION_PACKAGES.eslint] ?? "",
+        __ESLINT_ESLINTRC_VERSION__: versions[LINT_VERSION_PACKAGES.eslintEslintrc] ?? "",
+        __ESLINT_JS_VERSION__: versions[LINT_VERSION_PACKAGES.eslintJs] ?? "",
+        __ESLINT_CONFIG_PRETTIER_VERSION__: versions[LINT_VERSION_PACKAGES.eslintConfigPrettier] ?? "",
+        __ESLINT_PLUGIN_PRETTIER_VERSION__: versions[LINT_VERSION_PACKAGES.eslintPluginPrettier] ?? "",
+        __ESLINT_PLUGIN_ROBLOX_TS_VERSION__: versions[LINT_VERSION_PACKAGES.eslintPluginRobloxTs] ?? "",
+        __TYPESCRIPT_ESLINT_PLUGIN_VERSION__: versions[LINT_VERSION_PACKAGES.typescriptEslintPlugin] ?? "",
+        __TYPESCRIPT_ESLINT_PARSER_VERSION__: versions[LINT_VERSION_PACKAGES.typescriptEslintParser] ?? "",
+        __PRETTIER_VERSION__: versions[LINT_VERSION_PACKAGES.prettier] ?? "",
+    };
+}
+async function planPnpmNpmrc(projectRoot, packageManager) {
+    if (packageManager !== "pnpm") {
+        return {
+            changed: false,
+            created: false,
+            nextContent: "",
+        };
+    }
+    const npmrcPath = path.join(projectRoot, PNPM_NPMRC_PATH);
+    let currentContent = "";
+    let exists = true;
+    try {
+        currentContent = await node_fs_1.promises.readFile(npmrcPath, "utf8");
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code !== "ENOENT") {
+            throw error;
+        }
+        exists = false;
+    }
+    const eol = currentContent.includes("\r\n") ? "\r\n" : "\n";
+    const lines = currentContent.length > 0 ? currentContent.split(/\r?\n/) : [];
+    const nodeLinkerIndex = lines.findIndex((line) => /^\s*node-linker\s*=/.test(line));
+    if (nodeLinkerIndex >= 0) {
+        if (lines[nodeLinkerIndex].trim() === PNPM_NODE_LINKER_LINE) {
+            return {
+                changed: false,
+                created: false,
+                nextContent: currentContent,
+            };
+        }
+        lines[nodeLinkerIndex] = PNPM_NODE_LINKER_LINE;
+        return {
+            changed: true,
+            created: false,
+            nextContent: lines.join(eol),
+        };
+    }
+    if (!exists) {
+        return {
+            changed: true,
+            created: true,
+            nextContent: `${PNPM_NODE_LINKER_LINE}\n`,
+        };
+    }
+    return {
+        changed: true,
+        created: false,
+        nextContent: currentContent.endsWith("\n")
+            ? `${currentContent}${PNPM_NODE_LINKER_LINE}${eol}`
+            : `${currentContent}${eol}${PNPM_NODE_LINKER_LINE}${eol}`,
+    };
+}
+function collectChangedFiles(templateReport, lintReport, manifestPlan, gitignorePlan, npmrcPlan) {
+    const files = [
+        ...templateReport.created,
+        ...templateReport.merged,
+        ...(lintReport ? [...lintReport.created, ...lintReport.merged] : []),
+    ];
+    if (manifestPlan.changed) {
+        files.push("package.json");
+    }
+    if (gitignorePlan.changed) {
+        files.push(".gitignore");
+    }
+    if (npmrcPlan.changed) {
+        files.push(PNPM_NPMRC_PATH);
+    }
+    return [...new Set(files)].sort((left, right) => left.localeCompare(right));
+}
+function countCreatedFiles(templateReport, lintReport, gitignorePlan, npmrcPlan) {
+    return (templateReport.created.length +
+        (lintReport?.created.length ?? 0) +
+        (gitignorePlan.created ? 1 : 0) +
+        (npmrcPlan.created ? 1 : 0));
+}
+function countMergedFiles(templateReport, lintReport, manifestPlan, gitignorePlan, npmrcPlan) {
+    return (templateReport.merged.length +
+        (lintReport?.merged.length ?? 0) +
+        (manifestPlan.changed ? 1 : 0) +
+        (gitignorePlan.changed && !gitignorePlan.created ? 1 : 0) +
+        (npmrcPlan.changed && !npmrcPlan.created ? 1 : 0));
+}
+async function runInitCommand(input, runtimeOverrides) {
+    const detectPackageManagerFn = runtimeOverrides?.detectPackageManagerFn ?? detect_1.detectPackageManager;
+    const resolveLatestVersionsFn = runtimeOverrides?.resolveLatestVersionsFn ?? latest_1.resolveLatestVersions;
+    const createLoggerFn = runtimeOverrides?.createLoggerFn ?? logger_1.createLogger;
+    const promptSelectFn = runtimeOverrides?.promptSelectFn ?? prompt_1.promptSelect;
+    const promptConfirmFn = runtimeOverrides?.promptConfirmFn ?? prompt_1.promptConfirm;
+    const runtime = { yes: input.yes };
+    const cwd = path.resolve(input.cwd);
+    const projectRoot = await (0, findRoot_1.findRoot)(cwd);
+    if (!projectRoot) {
+        throw (0, errors_1.projectNotFoundError)(cwd);
+    }
+    const template = await selectTemplate(input.template);
+    const lintEnabled = await selectLintEnabled(runtime, input.lint, promptConfirmFn);
+    const resolvedPm = await detectPackageManagerFn(projectRoot, input.pm, {
+        runtime,
+        promptSelectFn,
+    });
+    let packageManagerSourceLabel;
+    switch (resolvedPm.source) {
+        case "override":
+            packageManagerSourceLabel = "explicit --pm";
+            break;
+        case "lockfile":
+            packageManagerSourceLabel = "lockfile";
+            break;
+        case "installed":
+            packageManagerSourceLabel = "only installed package manager";
+            break;
+        case "prompt":
+            packageManagerSourceLabel = "interactive selection";
+            break;
+    }
+    const logger = createLoggerFn({
+        verbose: false,
+        yes: input.yes,
+    });
+    logger.section("Inspecting");
+    logger.kv("Project", projectRoot);
+    logger.kv("Template", template);
+    logger.kv("Resolved package manager", resolvedPm.name);
+    logger.kv("Package manager source", packageManagerSourceLabel);
+    logger.kv("Lint/format", lintEnabled ? "enabled" : "disabled");
+    const currentManifest = await (0, readPackageJson_1.readPackageJson)(projectRoot);
+    const packagesToResolve = [
+        ...Object.values(CORE_VERSION_PACKAGES),
+        ...(lintEnabled ? Object.values(LINT_VERSION_PACKAGES) : []),
+    ];
+    const versions = await resolveLatestVersionsFn(packagesToResolve);
+    const replacements = buildVersionReplacements(inferProjectName(projectRoot, currentManifest), versions);
+    const templateDir = path.resolve(__dirname, "../../templates/init");
+    const lintTemplateDir = path.resolve(__dirname, "../../templates/init-lint");
+    const templateManifest = await readTemplateJson(templateDir, "package.json", replacements);
+    const lintManifest = lintEnabled
+        ? await readTemplateJson(lintTemplateDir, "package.json", replacements)
+        : undefined;
+    const templateReport = await (0, copy_1.copyTemplateSafe)(templateDir, projectRoot, {
+        dryRun: true,
+        logger,
+        replacements,
+        shouldIncludeFile: (relativePath) => relativePath !== "package.json",
+    });
+    const lintReport = lintEnabled
+        ? await (0, copy_1.copyTemplateSafe)(lintTemplateDir, projectRoot, {
+            dryRun: true,
+            logger,
+            replacements,
+            shouldIncludeFile: (relativePath) => relativePath !== "package.json",
+        })
+        : undefined;
+    const manifestPlan = planManifestChanges(currentManifest, lintManifest ? [templateManifest, lintManifest] : [templateManifest]);
+    const gitignorePlan = await planGitignore(projectRoot);
+    const npmrcPlan = await planPnpmNpmrc(projectRoot, resolvedPm.name);
+    const changedFiles = collectChangedFiles(templateReport, lintReport, manifestPlan, gitignorePlan, npmrcPlan);
+    const addedPackages = [...new Set([...manifestPlan.addedDependencies, ...manifestPlan.addedDevDependencies])].sort((left, right) => left.localeCompare(right));
+    const createdCount = countCreatedFiles(templateReport, lintReport, gitignorePlan, npmrcPlan);
+    const mergedCount = countMergedFiles(templateReport, lintReport, manifestPlan, gitignorePlan, npmrcPlan);
+    const localLattice = (0, output_1.resolveLocalLatticeCommand)(resolvedPm.name);
+    const installRequired = manifestPlan.changed || npmrcPlan.changed;
+    logger.section("Planning");
+    logger.kv("Files to create", String(createdCount));
+    logger.kv("Files to merge", String(mergedCount));
+    logger.kv("Scripts to add", String(manifestPlan.addedScripts.length));
+    logger.kv("Packages to add", String(addedPackages.length));
+    const changedFileSummary = (0, output_1.summarizeItems)(changedFiles);
+    if (changedFileSummary.total > 0) {
+        logger.list(changedFileSummary.visible);
+        if (changedFileSummary.hidden > 0) {
+            logger.step(`...and ${changedFileSummary.hidden} more`);
+        }
+    }
+    if (manifestPlan.addedScripts.length > 0) {
+        const scriptSummary = (0, output_1.summarizeItems)(manifestPlan.addedScripts);
+        logger.kv("New scripts", String(scriptSummary.total));
+        logger.list(scriptSummary.visible);
+        if (scriptSummary.hidden > 0) {
+            logger.step(`...and ${scriptSummary.hidden} more`);
+        }
+    }
+    if (addedPackages.length > 0) {
+        const packageSummary = (0, output_1.summarizeItems)(addedPackages);
+        logger.kv("New dependencies", String(packageSummary.total));
+        logger.list(packageSummary.visible);
+        if (packageSummary.hidden > 0) {
+            logger.step(`...and ${packageSummary.hidden} more`);
+        }
+    }
+    if (input.dryRun) {
+        logger.section("Dry Run");
+        if (changedFiles.length === 0) {
+            logger.step("[dry-run] No file changes required.");
+        }
+        else {
+            for (const filePath of changedFileSummary.visible) {
+                logger.step(`[dry-run] update ${filePath}`);
+            }
+            if (changedFileSummary.hidden > 0) {
+                logger.step(`[dry-run] ...and ${changedFileSummary.hidden} more file changes`);
+            }
+        }
+        if (installRequired) {
+            logger.step(`[dry-run] ${resolvedPm.name} install`);
+        }
+        else {
+            logger.step("[dry-run] No install required.");
+        }
+    }
+    else {
+        logger.section("Applying");
+        if (changedFiles.length === 0) {
+            logger.step("Project already has the required Lattice bootstrap files.");
+        }
+        else {
+            const confirmed = await logger.confirm(`Apply ${changedFiles.length} planned change(s) in ${projectRoot}?`);
+            if (!confirmed) {
+                logger.section("Result");
+                logger.warn("Init command cancelled.");
+                logger.section("Next Steps");
+                logger.step(`${localLattice} doctor`);
+                return;
+            }
+            await (0, copy_1.copyTemplateSafe)(templateDir, projectRoot, {
+                dryRun: false,
+                logger,
+                replacements,
+                shouldIncludeFile: (relativePath) => relativePath !== "package.json",
+            });
+            if (lintEnabled) {
+                await (0, copy_1.copyTemplateSafe)(lintTemplateDir, projectRoot, {
+                    dryRun: false,
+                    logger,
+                    replacements,
+                    shouldIncludeFile: (relativePath) => relativePath !== "package.json",
+                });
+            }
+            if (manifestPlan.changed) {
+                await (0, writePackageJson_1.writePackageJson)(projectRoot, manifestPlan.nextManifest);
+            }
+            await ensureProjectDirectories(projectRoot);
+            if (gitignorePlan.changed) {
+                await node_fs_1.promises.writeFile(path.join(projectRoot, ".gitignore"), gitignorePlan.nextContent, "utf8");
+            }
+            if (npmrcPlan.changed) {
+                await node_fs_1.promises.writeFile(path.join(projectRoot, PNPM_NPMRC_PATH), npmrcPlan.nextContent, "utf8");
+            }
+            if (installRequired) {
+                const installSpinner = logger.spinner(`Installing dependencies with ${resolvedPm.name}...`);
+                await resolvedPm.manager.install(projectRoot);
+                installSpinner.succeed("Dependencies installed.");
+            }
+            else {
+                logger.step("No dependency installation required.");
+            }
+        }
+    }
+    logger.section("Result");
+    if (changedFiles.length === 0) {
+        logger.success("Project already matches the Lattice init template.");
+    }
+    else if (input.dryRun) {
+        logger.success(`Dry run complete. Planned ${changedFiles.length} file change(s).`);
+    }
+    else {
+        logger.success(`Initialized Lattice in ${path.basename(projectRoot)}.`);
+    }
+    logger.kv("Files created", String(createdCount));
+    logger.kv("Files merged", String(mergedCount));
+    logger.kv("Dependencies added", String(addedPackages.length));
+    logger.section("Next Steps");
+    logger.step(`${localLattice} doctor`);
+    logger.step(`${resolvedPm.name} run build`);
+    logger.step(`${localLattice} add --preset form`);
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,3 @@
+import type { CliContext } from "../ctx";
+import { type SelectionInput } from "./selection";
+export declare function runRemoveCommand(ctx: CliContext, input: SelectionInput): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRemoveCommand = runRemoveCommand;
+const errors_1 = require("../core/errors");
+const patch_1 = require("../core/fs/patch");
+const output_1 = require("../core/output");
+const readPackageJson_1 = require("../core/project/readPackageJson");
+const prompt_1 = require("../core/prompt");
+const selection_1 = require("./selection");
+function normalizeList(values) {
+    return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+async function runRemoveCommand(ctx, input) {
+    const localLattice = (0, output_1.resolveLocalLatticeCommand)(ctx.pmName);
+    ctx.logger.section("Selecting");
+    ctx.logger.kv("Project", ctx.projectRoot);
+    const packageJson = await (0, readPackageJson_1.readPackageJson)(ctx.projectRoot);
+    const installedDependencies = (0, patch_1.getDependencyNames)(packageJson);
+    let components;
+    if (input.names.length > 0 || input.presets.length > 0) {
+        components = (0, selection_1.resolveComponentSelection)(ctx, input);
+    }
+    else {
+        if (ctx.options.yes) {
+            throw (0, errors_1.usageError)("No components selected. Provide component names or --preset when using --yes.");
+        }
+        const installedComponents = Object.keys(ctx.registry.packages)
+            .filter((componentName) => installedDependencies.has(ctx.registry.packages[componentName].npm))
+            .sort((left, right) => left.localeCompare(right));
+        if (installedComponents.length === 0) {
+            ctx.logger.section("Result");
+            ctx.logger.warn("No installed registry components found to remove.");
+            ctx.logger.section("Next Steps");
+            ctx.logger.step(`${localLattice} doctor`);
+            return;
+        }
+        components = await (0, prompt_1.promptMultiSelect)({ yes: ctx.options.yes }, "Select installed components to remove", installedComponents.map((componentName) => ({
+            label: componentName,
+            value: componentName,
+        })), {
+            allowEmpty: false,
+        });
+    }
+    const selectedSummary = (0, output_1.summarizeItems)(components);
+    const specs = normalizeList(components.map((component) => ctx.registry.packages[component].npm));
+    const plannedSpecs = specs.filter((spec) => installedDependencies.has(spec));
+    const missingComponents = normalizeList(components.filter((component) => !installedDependencies.has(ctx.registry.packages[component].npm)));
+    const removedComponents = normalizeList(components.filter((component) => installedDependencies.has(ctx.registry.packages[component].npm)));
+    ctx.logger.section("Planning");
+    ctx.logger.kv("Selected components", String(selectedSummary.total));
+    if (selectedSummary.total > 0) {
+        ctx.logger.list(selectedSummary.visible);
+        if (selectedSummary.hidden > 0) {
+            ctx.logger.step(`...and ${selectedSummary.hidden} more`);
+        }
+    }
+    const plannedSummary = (0, output_1.summarizeItems)(plannedSpecs);
+    ctx.logger.kv("Packages to remove", String(plannedSummary.total));
+    if (plannedSummary.total > 0) {
+        ctx.logger.list(plannedSummary.visible);
+        if (plannedSummary.hidden > 0) {
+            ctx.logger.step(`...and ${plannedSummary.hidden} more`);
+        }
+    }
+    if (missingComponents.length > 0) {
+        const missingSummary = (0, output_1.summarizeItems)(missingComponents);
+        ctx.logger.kv("Missing selected", String(missingSummary.total));
+        ctx.logger.list(missingSummary.visible);
+        if (missingSummary.hidden > 0) {
+            ctx.logger.step(`...and ${missingSummary.hidden} more`);
+        }
+    }
+    if (ctx.options.dryRun) {
+        ctx.logger.section("Dry Run");
+        if (plannedSpecs.length > 0) {
+            ctx.logger.step(`[dry-run] ${ctx.pmName} remove ${plannedSpecs.join(" ")}`);
+        }
+        else {
+            ctx.logger.step("[dry-run] No remove actions required.");
+        }
+        ctx.logger.step("No files were changed.");
+    }
+    else {
+        ctx.logger.section("Applying");
+        if (plannedSpecs.length > 0) {
+            ctx.logger.step(`${ctx.pmName} remove ${plannedSpecs.join(" ")}`);
+            const confirmed = await ctx.logger.confirm(`Remove ${plannedSpecs.length} package(s) in ${ctx.projectRoot}?`);
+            if (!confirmed) {
+                ctx.logger.section("Result");
+                ctx.logger.warn("Remove command cancelled.");
+                ctx.logger.section("Next Steps");
+                ctx.logger.step(`${localLattice} doctor`);
+                return;
+            }
+            const spinner = ctx.logger.spinner(`Removing ${plannedSpecs.length} package(s)...`);
+            await ctx.pm.remove(plannedSpecs, ctx.projectRoot);
+            spinner.succeed("Dependencies removed.");
+        }
+        else {
+            ctx.logger.step("No removal required.");
+        }
+    }
+    ctx.logger.section("Result");
+    if (plannedSpecs.length === 0) {
+        ctx.logger.warn("No installed package matched remove selection.");
+    }
+    else {
+        ctx.logger.success(`Removed components: ${removedComponents.join(", ")}`);
+    }
+    ctx.logger.kv("Removed packages", String(plannedSpecs.length));
+    ctx.logger.section("Next Steps");
+    ctx.logger.step(`${localLattice} doctor`);
+}

package/dist/commands/selection.d.ts

@@ -0,0 +1,6 @@
+import type { CliContext } from "../ctx";
+export interface SelectionInput {
+    names: string[];
+    presets: string[];
+}
+export declare function resolveComponentSelection(ctx: CliContext, input: SelectionInput): string[];