lattice-ui 0.4.3

package/dist/core/project/readPackageJson.d.ts

@@ -0,0 +1,13 @@
+export type PackageJson = {
+    name?: string;
+    version?: string;
+    private?: boolean;
+    packageManager?: string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    optionalDependencies?: Record<string, string>;
+    [key: string]: unknown;
+};
+export declare function readPackageJson(projectRoot: string): Promise<PackageJson>;

package/dist/core/project/readPackageJson.js

@@ -0,0 +1,41 @@
+"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.readPackageJson = readPackageJson;
+const path = __importStar(require("node:path"));
+const json_1 = require("../fs/json");
+async function readPackageJson(projectRoot) {
+    return (0, json_1.readJsonFile)(path.join(projectRoot, "package.json"));
+}

package/dist/core/project/writePackageJson.d.ts

@@ -0,0 +1,2 @@
+import type { PackageJson } from "./readPackageJson";
+export declare function writePackageJson(projectRoot: string, manifest: PackageJson): Promise<void>;

package/dist/core/project/writePackageJson.js

@@ -0,0 +1,41 @@
+"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.writePackageJson = writePackageJson;
+const path = __importStar(require("node:path"));
+const json_1 = require("../fs/json");
+async function writePackageJson(projectRoot, manifest) {
+    await (0, json_1.writeJsonFile)(path.join(projectRoot, "package.json"), manifest, false);
+}

package/dist/core/prompt.d.ts

@@ -0,0 +1,23 @@
+export interface PromptRuntime {
+    yes: boolean;
+    stdin?: NodeJS.ReadStream;
+    stdout?: NodeJS.WriteStream;
+}
+export interface PromptOption<T> {
+    label: string;
+    value: T;
+}
+export declare function promptInput(runtime: PromptRuntime, message: string, config?: {
+    defaultValue?: string;
+    required?: boolean;
+}): Promise<string>;
+export declare function promptConfirm(runtime: PromptRuntime, message: string, config?: {
+    defaultValue?: boolean;
+}): Promise<boolean>;
+export declare function promptSelect<T>(runtime: PromptRuntime, message: string, options: PromptOption<T>[], config?: {
+    defaultIndex?: number;
+}): Promise<T>;
+export declare function promptMultiSelect<T>(runtime: PromptRuntime, message: string, options: PromptOption<T>[], config?: {
+    allowEmpty?: boolean;
+    defaultIndices?: number[];
+}): Promise<T[]>;

package/dist/core/prompt.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptInput = promptInput;
+exports.promptConfirm = promptConfirm;
+exports.promptSelect = promptSelect;
+exports.promptMultiSelect = promptMultiSelect;
+const promises_1 = require("node:readline/promises");
+const errors_1 = require("./errors");
+const ANSI = {
+    reset: "\u001b[0m",
+    cyan: "\u001b[36m",
+    magenta: "\u001b[35m",
+    gray: "\u001b[90m",
+    bold: "\u001b[1m",
+};
+const ICONS = {
+    tty: {
+        question: "?",
+        guide: "›",
+    },
+    plain: {
+        question: "[?]",
+        guide: "[>]",
+    },
+};
+function supportsColor(stdout) {
+    return Boolean(stdout.isTTY);
+}
+function supportsUnicodeIcons(stdout) {
+    return Boolean(stdout.isTTY);
+}
+function colorize(enabled, color, text) {
+    if (!enabled) {
+        return text;
+    }
+    return `${color}${text}${ANSI.reset}`;
+}
+function getRuntimeStreams(runtime) {
+    const stdin = runtime.stdin ?? process.stdin;
+    const stdout = runtime.stdout ?? process.stdout;
+    return { stdin, stdout };
+}
+function getPromptIcon(stdout, kind) {
+    if (supportsUnicodeIcons(stdout)) {
+        return ICONS.tty[kind];
+    }
+    return ICONS.plain[kind];
+}
+function ensureInteractive(runtime) {
+    const { stdin, stdout } = getRuntimeStreams(runtime);
+    if (runtime.yes) {
+        return { stdin, stdout };
+    }
+    if (!stdin.isTTY || !stdout.isTTY) {
+        throw (0, errors_1.usageError)("Interactive prompts require a TTY. Re-run with --yes and explicit options.");
+    }
+    return { stdin, stdout };
+}
+function printPromptHeader(stdout, message) {
+    const useColor = supportsColor(stdout);
+    const icon = colorize(useColor, ANSI.magenta, getPromptIcon(stdout, "question"));
+    const heading = colorize(useColor, ANSI.bold, message);
+    stdout.write(`\n${icon} ${heading}\n`);
+}
+function printPromptGuide(stdout, message) {
+    const useColor = supportsColor(stdout);
+    const icon = colorize(useColor, ANSI.cyan, getPromptIcon(stdout, "guide"));
+    const text = colorize(useColor, ANSI.gray, message);
+    stdout.write(`${icon} ${text}\n`);
+}
+function parseCsvIndices(input, optionCount) {
+    if (input.trim().length === 0) {
+        return [];
+    }
+    const output = [];
+    const parts = input
+        .split(",")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0);
+    for (const part of parts) {
+        const parsed = Number(part);
+        if (!Number.isInteger(parsed) || parsed < 1 || parsed > optionCount) {
+            throw (0, errors_1.usageError)(`Invalid selection "${part}". Choose numbers between 1 and ${optionCount}.`);
+        }
+        const index = parsed - 1;
+        if (!output.includes(index)) {
+            output.push(index);
+        }
+    }
+    return output;
+}
+async function promptInput(runtime, message, config) {
+    const required = config?.required ?? true;
+    const defaultValue = config?.defaultValue;
+    if (runtime.yes) {
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        if (required) {
+            throw (0, errors_1.usageError)(`Missing required value for prompt: ${message}`);
+        }
+        return "";
+    }
+    const { stdin, stdout } = ensureInteractive(runtime);
+    printPromptHeader(stdout, message);
+    const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+    try {
+        const suffix = defaultValue !== undefined ? ` (default: ${defaultValue})` : "";
+        const answer = await rl.question(`${getPromptIcon(stdout, "guide")} Value${suffix}: `);
+        const trimmed = answer.trim();
+        if (trimmed.length > 0) {
+            return trimmed;
+        }
+        if (defaultValue !== undefined) {
+            return defaultValue;
+        }
+        if (required) {
+            throw (0, errors_1.usageError)(`Missing required value for prompt: ${message}`);
+        }
+        return "";
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptConfirm(runtime, message, config) {
+    const defaultValue = config?.defaultValue ?? false;
+    if (runtime.yes) {
+        return defaultValue;
+    }
+    const { stdin, stdout } = ensureInteractive(runtime);
+    printPromptHeader(stdout, message);
+    const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+    try {
+        const hint = defaultValue ? "Y/n" : "y/N";
+        const answer = (await rl.question(`${getPromptIcon(stdout, "guide")} Confirm (${hint}): `)).trim().toLowerCase();
+        if (answer.length === 0) {
+            return defaultValue;
+        }
+        if (answer === "y" || answer === "yes") {
+            return true;
+        }
+        if (answer === "n" || answer === "no") {
+            return false;
+        }
+        throw (0, errors_1.usageError)(`Invalid confirmation response "${answer}".`);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptSelect(runtime, message, options, config) {
+    if (options.length === 0) {
+        throw (0, errors_1.usageError)(`Prompt "${message}" has no options.`);
+    }
+    const defaultIndex = config?.defaultIndex ?? 0;
+    if (defaultIndex < 0 || defaultIndex >= options.length) {
+        throw (0, errors_1.usageError)(`Prompt "${message}" has an invalid default index.`);
+    }
+    if (runtime.yes) {
+        return options[defaultIndex].value;
+    }
+    const { stdin, stdout } = ensureInteractive(runtime);
+    printPromptHeader(stdout, message);
+    options.forEach((option, index) => {
+        stdout.write(`  ${index + 1}) ${option.label}\n`);
+    });
+    printPromptGuide(stdout, `Enter a number (default: ${defaultIndex + 1})`);
+    const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+    try {
+        const answer = (await rl.question(`${getPromptIcon(stdout, "guide")} Select one: `)).trim();
+        const indices = parseCsvIndices(answer, options.length);
+        if (indices.length === 0) {
+            return options[defaultIndex].value;
+        }
+        if (indices.length > 1) {
+            throw (0, errors_1.usageError)("Select exactly one option.");
+        }
+        return options[indices[0]].value;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptMultiSelect(runtime, message, options, config) {
+    if (options.length === 0) {
+        return [];
+    }
+    const allowEmpty = config?.allowEmpty ?? false;
+    const defaultIndices = (config?.defaultIndices ?? []).filter((index) => index >= 0 && index < options.length);
+    if (runtime.yes) {
+        return defaultIndices.map((index) => options[index].value);
+    }
+    const { stdin, stdout } = ensureInteractive(runtime);
+    printPromptHeader(stdout, message);
+    options.forEach((option, index) => {
+        stdout.write(`  ${index + 1}) ${option.label}\n`);
+    });
+    const defaultText = defaultIndices.length > 0
+        ? `default: ${defaultIndices.map((index) => index + 1).join(",")}`
+        : allowEmpty
+            ? "press enter to skip"
+            : "select at least one item";
+    printPromptGuide(stdout, `Enter comma-separated numbers (${defaultText})`);
+    const rl = (0, promises_1.createInterface)({ input: stdin, output: stdout });
+    try {
+        const answer = (await rl.question(`${getPromptIcon(stdout, "guide")} Select one or more: `)).trim();
+        const indices = answer.length > 0 ? parseCsvIndices(answer, options.length) : defaultIndices;
+        if (indices.length === 0 && !allowEmpty) {
+            throw (0, errors_1.usageError)("At least one option must be selected.");
+        }
+        return indices.map((index) => options[index].value);
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/core/registry/load.d.ts

@@ -0,0 +1,3 @@
+import { type Registry } from "./schema";
+export declare function resolveRegistryDir(baseDir?: string): string;
+export declare function loadRegistry(registryDir?: string): Promise<Registry>;

package/dist/core/registry/load.js

@@ -0,0 +1,59 @@
+"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.resolveRegistryDir = resolveRegistryDir;
+exports.loadRegistry = loadRegistry;
+const path = __importStar(require("node:path"));
+const errors_1 = require("../errors");
+const json_1 = require("../fs/json");
+const schema_1 = require("./schema");
+function resolveRegistryDir(baseDir = __dirname) {
+    return path.resolve(baseDir, "../../../registry");
+}
+async function loadRegistry(registryDir = resolveRegistryDir()) {
+    const componentsPath = path.join(registryDir, "components.json");
+    const presetsPath = path.join(registryDir, "presets.json");
+    try {
+        const componentsSource = await (0, json_1.readJsonFile)(componentsPath);
+        const presetsSource = await (0, json_1.readJsonFile)(presetsPath);
+        return (0, schema_1.validateRegistry)(componentsSource, presetsSource);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw (0, errors_1.registryInvalidError)(`Failed to load registry: ${error.message}`, error);
+        }
+        throw (0, errors_1.registryInvalidError)("Failed to load registry.", error);
+    }
+}

package/dist/core/registry/schema.d.ts

@@ -0,0 +1,18 @@
+export interface RegistryPackageEntry {
+    npm: string;
+    peers?: string[];
+    providers?: string[];
+    notes?: string[];
+}
+export interface Registry {
+    packages: Record<string, RegistryPackageEntry>;
+    presets: Record<string, string[]>;
+}
+export interface ProviderRequirement {
+    raw: string;
+    packageName: string;
+    providerName?: string;
+    optional: boolean;
+}
+export declare function parseProviderRequirement(rawValue: string): ProviderRequirement;
+export declare function validateRegistry(componentsSource: unknown, presetsSource: unknown): Registry;

package/dist/core/registry/schema.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseProviderRequirement = parseProviderRequirement;
+exports.validateRegistry = validateRegistry;
+const errors_1 = require("../errors");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function readStringArray(value, path) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!isStringArray(value)) {
+        throw (0, errors_1.registryInvalidError)(`${path} must be an array of strings.`);
+    }
+    return value.slice();
+}
+function parseProviderRequirement(rawValue) {
+    const optional = rawValue.endsWith("?");
+    const normalized = optional ? rawValue.slice(0, -1) : rawValue;
+    const [packageName, providerName] = normalized.split(":");
+    if (!packageName || packageName.trim().length === 0) {
+        throw (0, errors_1.registryInvalidError)(`Invalid provider requirement "${rawValue}".`);
+    }
+    return {
+        raw: rawValue,
+        packageName,
+        providerName: providerName && providerName.length > 0 ? providerName : undefined,
+        optional,
+    };
+}
+function validateRegistry(componentsSource, presetsSource) {
+    if (!isRecord(componentsSource)) {
+        throw (0, errors_1.registryInvalidError)("components.json must be an object.");
+    }
+    if (!isRecord(presetsSource)) {
+        throw (0, errors_1.registryInvalidError)("presets.json must be an object.");
+    }
+    const packagesSource = componentsSource.packages;
+    if (!isRecord(packagesSource)) {
+        throw (0, errors_1.registryInvalidError)("components.json.packages must be an object.");
+    }
+    const packages = {};
+    for (const [componentName, rawEntry] of Object.entries(packagesSource)) {
+        if (!isRecord(rawEntry)) {
+            throw (0, errors_1.registryInvalidError)(`components.json.packages.${componentName} must be an object.`);
+        }
+        if (typeof rawEntry.npm !== "string" || rawEntry.npm.length === 0) {
+            throw (0, errors_1.registryInvalidError)(`components.json.packages.${componentName}.npm must be a non-empty string.`);
+        }
+        const peers = readStringArray(rawEntry.peers, `components.json.packages.${componentName}.peers`);
+        const providers = readStringArray(rawEntry.providers, `components.json.packages.${componentName}.providers`);
+        const notes = readStringArray(rawEntry.notes, `components.json.packages.${componentName}.notes`);
+        if (providers) {
+            for (const provider of providers) {
+                parseProviderRequirement(provider);
+            }
+        }
+        packages[componentName] = {
+            npm: rawEntry.npm,
+            peers,
+            providers,
+            notes,
+        };
+    }
+    const presetsContainer = presetsSource.presets;
+    if (!isRecord(presetsContainer)) {
+        throw (0, errors_1.registryInvalidError)("presets.json.presets must be an object.");
+    }
+    const presets = {};
+    for (const [presetName, rawPreset] of Object.entries(presetsContainer)) {
+        if (!isStringArray(rawPreset)) {
+            throw (0, errors_1.registryInvalidError)(`presets.json.presets.${presetName} must be an array of component names.`);
+        }
+        const presetMembers = rawPreset.slice();
+        for (const componentName of presetMembers) {
+            if (!packages[componentName]) {
+                throw (0, errors_1.registryInvalidError)(`presets.json.presets.${presetName} references unknown component "${componentName}".`);
+            }
+        }
+        presets[presetName] = presetMembers;
+    }
+    return { packages, presets };
+}

package/dist/ctx.d.ts

@@ -0,0 +1,27 @@
+import { type Logger } from "./core/logger";
+import { type PackageManagerResolutionSource } from "./core/pm/detect";
+import type { PackageManager, PackageManagerName } from "./core/pm/types";
+import type { Registry } from "./core/registry/schema";
+export interface ContextOptions {
+    cwd: string;
+    pm?: string;
+    dryRun: boolean;
+    yes: boolean;
+    verbose?: boolean;
+}
+export interface CliContext {
+    cwd: string;
+    projectRoot: string;
+    packageJsonPath: string;
+    options: ContextOptions;
+    logger: Logger;
+    pm: PackageManager;
+    pmName: PackageManagerName;
+    detectedLockfiles: PackageManagerName[];
+    installedPackageManagers: PackageManagerName[];
+    pmResolutionSource: PackageManagerResolutionSource;
+    registry: Registry;
+}
+export declare function createContext(options: ContextOptions, config?: {
+    allowMissingProject?: boolean;
+}): Promise<CliContext>;

package/dist/ctx.js

@@ -0,0 +1,75 @@
+"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.createContext = createContext;
+const path = __importStar(require("node:path"));
+const errors_1 = require("./core/errors");
+const logger_1 = require("./core/logger");
+const detect_1 = require("./core/pm/detect");
+const findRoot_1 = require("./core/project/findRoot");
+const load_1 = require("./core/registry/load");
+async function createContext(options, config) {
+    const cwd = path.resolve(options.cwd);
+    const allowMissingProject = config?.allowMissingProject ?? false;
+    const projectRoot = (await (0, findRoot_1.findRoot)(cwd)) ?? (allowMissingProject ? cwd : undefined);
+    if (!projectRoot) {
+        throw (0, errors_1.projectNotFoundError)(cwd);
+    }
+    const logger = (0, logger_1.createLogger)({
+        verbose: options.verbose ?? false,
+        yes: options.yes,
+    });
+    const pm = await (0, detect_1.detectPackageManager)(projectRoot, options.pm, {
+        runtime: {
+            yes: options.yes,
+            stdin: process.stdin,
+            stdout: process.stdout,
+        },
+    });
+    const registry = await (0, load_1.loadRegistry)();
+    return {
+        cwd,
+        projectRoot,
+        packageJsonPath: path.join(projectRoot, "package.json"),
+        options,
+        logger,
+        pm: pm.manager,
+        pmName: pm.name,
+        detectedLockfiles: pm.lockfiles,
+        installedPackageManagers: pm.installed,
+        pmResolutionSource: pm.source,
+        registry,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("./cli");
+const errors_1 = require("./core/errors");
+async function main() {
+    try {
+        await (0, cli_1.runCli)(process.argv.slice(2));
+    }
+    catch (error) {
+        const cliError = (0, errors_1.toCliError)(error);
+        process.stderr.write(`Error: ${cliError.message}\n`);
+        if (cliError.kind === "Unexpected" && cliError.cause instanceof Error) {
+            process.stderr.write(`${cliError.cause.stack ?? cliError.cause.message}\n`);
+        }
+        process.exitCode = cliError.exitCode;
+        return;
+    }
+    process.exitCode = errors_1.ExitCode.Success;
+}
+void main();

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "lattice-ui",
+  "version": "0.4.3",
+  "private": false,
+  "description": "Lattice UI CLI",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "registry",
+    "templates"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "bin": {
+    "lattice-ui": "dist/index.js",
+    "lattice": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prebuild": "node ./scripts/clean-dist.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "watch": "tsc -p tsconfig.json -w"
+  }
+}