inai-react-components 0.1.7 → 1.4.0

package/dist/commands/mcp.js

@@ -0,0 +1,289 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { runList } from "./list.js";
+import { runDiff } from "./diff.js";
+import { runAdd } from "./add.js";
+import { runUpdate } from "./update.js";
+import { runStatus } from "./status.js";
+import { THEMES } from "../utils/themes.js";
+import { resolveRegistryDir } from "../utils/registry-resolver.js";
+import { readRegistryJson } from "./status.js";
+// eslint-disable-next-line no-control-regex
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+function stripAnsi(s) {
+    return s.replace(ANSI_RE, "");
+}
+const MCP_CONFIG_SNIPPET = {
+    mcpServers: {
+        "inai-ui": {
+            command: "inai-ui",
+            args: ["mcp"],
+        },
+    },
+};
+/**
+ * Print the JSON config fragment that users must drop into their Claude
+ * Desktop or Cursor `mcpServers` block. Invoked from `inai-ui mcp init`.
+ */
+export function printMcpConfig() {
+    console.log(JSON.stringify(MCP_CONFIG_SNIPPET, null, 2));
+}
+function textResult(text, isError = false) {
+    return {
+        content: [{ type: "text", text: stripAnsi(text) }],
+        ...(isError ? { isError: true } : {}),
+    };
+}
+export async function handleListComponents(args, cwd) {
+    const registryDir = resolveRegistryDir(cwd);
+    const registryPath = path.join(registryDir, "registry.json");
+    const output = await runList(registryPath, { category: args?.category });
+    return textResult(output);
+}
+export async function handleViewComponent(args, cwd) {
+    const name = args?.name;
+    if (!name)
+        return textResult("Error: 'name' argument is required.", true);
+    const registryDir = resolveRegistryDir(cwd);
+    const registryPath = path.join(registryDir, "registry.json");
+    const registry = readRegistryJson(registryPath);
+    if (!registry)
+        return textResult("Error: Registry not found.", true);
+    const all = [
+        ...registry.components,
+        ...registry.blocks,
+        ...registry.templates,
+    ];
+    const component = all.find((c) => c.name === name);
+    if (!component) {
+        return textResult(`Error: Component "${name}" not found in registry.`, true);
+    }
+    const sections = [
+        `# ${component.name} (${component.type})`,
+        component.description,
+        "",
+    ];
+    for (const rel of component.files) {
+        const abs = path.join(registryDir, rel);
+        if (!fs.existsSync(abs))
+            continue;
+        const src = fs.readFileSync(abs, "utf-8");
+        sections.push(`## ${rel}`, "```tsx", src, "```", "");
+    }
+    return textResult(sections.join("\n"));
+}
+export async function handleAddComponent(args, cwd) {
+    const name = args?.name;
+    if (!name)
+        return textResult("Error: 'name' argument is required.", true);
+    const result = await runAdd(name, cwd, { force: args?.force });
+    if (!result.added)
+        return textResult(result.message, true);
+    const lines = [result.message];
+    if (result.files.length > 0) {
+        lines.push("Files:");
+        for (const f of result.files)
+            lines.push(`  - ${f}`);
+    }
+    if (result.resolvedDeps && result.resolvedDeps.length > 0) {
+        lines.push("Resolved registry dependencies:");
+        for (const d of result.resolvedDeps)
+            lines.push(`  - ${d}`);
+    }
+    if (result.npmDeps.length > 0) {
+        lines.push(`npm deps: ${result.npmDeps.join(", ")}`);
+    }
+    return textResult(lines.join("\n"));
+}
+export async function handleDiffComponent(args, cwd) {
+    const name = args?.name;
+    if (!name)
+        return textResult("Error: 'name' argument is required.", true);
+    const output = stripAnsi(await runDiff(name, cwd));
+    // Count +/- lines so Claude Desktop / Cursor can see the magnitude of the
+    // change at a glance without re-parsing the diff body.
+    let added = 0;
+    let removed = 0;
+    for (const line of output.split("\n")) {
+        if (/^\+(?!\+\+)/.test(line))
+            added++;
+        else if (/^-(?!--)/.test(line))
+            removed++;
+    }
+    const lower = output.toLowerCase();
+    const hasNoChanges = lower.includes("no differences") || lower.includes("no changes");
+    const summary = hasNoChanges
+        ? "_No differences between local and registry versions._"
+        : `**${added} line${added === 1 ? "" : "s"} added, ${removed} line${removed === 1 ? "" : "s"} removed.**`;
+    const markdown = [
+        `### Diff: \`${name}\``,
+        "",
+        summary,
+        "",
+        "```diff",
+        output,
+        "```",
+    ].join("\n");
+    return {
+        content: [{ type: "text", text: markdown }],
+    };
+}
+export async function handleUpdateComponent(args, cwd) {
+    const name = args?.name;
+    if (!name)
+        return textResult("Error: 'name' argument is required.", true);
+    // Non-interactive: the MCP transport cannot drive prompts. The update
+    // path will do a 3-way merge via the saved snapshot when available.
+    const result = await runUpdate(name, cwd, true);
+    const lines = [result.message];
+    if (result.cleanMerges && result.cleanMerges.length > 0) {
+        lines.push("Merged cleanly:");
+        for (const f of result.cleanMerges)
+            lines.push(`  - ${f}`);
+    }
+    if (result.conflictedFiles && result.conflictedFiles.length > 0) {
+        lines.push("Merged with conflicts (manual resolution required):");
+        for (const f of result.conflictedFiles)
+            lines.push(`  ! ${f}`);
+    }
+    return textResult(lines.join("\n"), !result.updated);
+}
+export async function handleListThemes() {
+    return textResult(JSON.stringify(THEMES, null, 2));
+}
+export async function handleStatus(args, cwd) {
+    const output = await runStatus(cwd, { json: args?.json ?? true });
+    return textResult(output);
+}
+// ─── MCP server bootstrap ────────────────────────────────────────────
+export const MCP_TOOLS = [
+    {
+        name: "list_components",
+        description: "List all available components, blocks and templates in the InAI UI registry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                category: {
+                    type: "string",
+                    description: "Optional type filter (e.g. 'component', 'form', 'block').",
+                },
+            },
+        },
+    },
+    {
+        name: "view_component",
+        description: "View the source code of a component from the registry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Component name" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "add_component",
+        description: "Install a component (and its transitive registry dependencies) into the current project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Component name" },
+                force: {
+                    type: "boolean",
+                    description: "Overwrite existing files without prompting.",
+                },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "diff_component",
+        description: "Show a unified diff between the locally-installed component and the registry version.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Component name" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "update_component",
+        description: "Update an installed component to the latest registry version using a 3-way merge against the snapshot captured at install time. Emits conflict markers when local and registry edits overlap.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Component name" },
+            },
+            required: ["name"],
+        },
+    },
+    {
+        name: "list_themes",
+        description: "List the available InAI UI themes with their categories and descriptions.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "project_status",
+        description: "Return the InAI UI project status (HEALTHY / DRIFT / OUTDATED / MISSING per component).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                json: { type: "boolean", description: "Return JSON payload (default true)." },
+            },
+        },
+    },
+];
+export async function runMcp(cwd = process.cwd()) {
+    const server = new Server({ name: "inai-ui-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: MCP_TOOLS.map((t) => ({ ...t })),
+    }));
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    server.setRequestHandler(CallToolRequestSchema, (async (req) => {
+        const { name, arguments: args } = req.params;
+        try {
+            switch (name) {
+                case "list_components":
+                    return await handleListComponents(args, cwd);
+                case "view_component":
+                    return await handleViewComponent(args, cwd);
+                case "add_component":
+                    return await handleAddComponent(args, cwd);
+                case "diff_component":
+                    return await handleDiffComponent(args, cwd);
+                case "update_component":
+                    return await handleUpdateComponent(args, cwd);
+                case "list_themes":
+                    return await handleListThemes();
+                case "project_status":
+                    return await handleStatus(args, cwd);
+                default:
+                    return {
+                        content: [{ type: "text", text: `Unknown tool: ${name}` }],
+                        isError: true,
+                    };
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return {
+                content: [{ type: "text", text: `Tool "${name}" failed: ${msg}` }],
+                isError: true,
+            };
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }));
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+export async function mcpCommand(subcommand) {
+    if (subcommand === "init") {
+        printMcpConfig();
+        return;
+    }
+    await runMcp();
+}

package/dist/commands/migrate.d.ts

@@ -0,0 +1,41 @@
+/**
+ * A single rename rule applied by the `inai-ui migrate` codemod.
+ *
+ * The patterns are anchored on a word boundary and an `=` or whitespace
+ * followed by `=` so they match JSX props (`inputSize="md"`, `inputSize={x}`)
+ * without touching unrelated identifiers that happen to share the prefix.
+ */
+export interface MigrationRule {
+    name: string;
+    pattern: RegExp;
+    replacement: string;
+    description: string;
+}
+export declare const MIGRATION_RULES: MigrationRule[];
+export interface MigrateOptions {
+    dryRun?: boolean;
+    files?: string[];
+    cwd?: string;
+}
+export interface MigrateResult {
+    filesAffected: number;
+    totalReplacements: number;
+    perRule: Record<string, number>;
+    touchedFiles: string[];
+}
+/**
+ * Recursively walk `root` and collect every `.ts`/`.tsx`/`.js`/`.jsx` file
+ * outside of the standard ignore list. Exported so tests can drive discovery
+ * deterministically against a tmpdir fixture.
+ */
+export declare function discoverSourceFiles(root: string): Promise<string[]>;
+export declare function runMigrate(options?: MigrateOptions): Promise<MigrateResult>;
+/**
+ * CLI entry point — wraps `runMigrate` with console output. Kept separate
+ * from `runMigrate` so tests can assert on the structured result without
+ * parsing stdout.
+ */
+export declare function migrateCommand(options?: {
+    dryRun?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/commands/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../../src/commands/migrate.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,eAAe,EAAE,aAAa,EAyB1C,CAAC;AAEF,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAeD;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAqBzE;AAED,wBAAsB,UAAU,CAC9B,OAAO,GAAE,cAAmB,GAC3B,OAAO,CAAC,aAAa,CAAC,CA8CxB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,OAAO,CAAA;CAAO,GACjC,OAAO,CAAC,IAAI,CAAC,CAwBf"}

package/dist/commands/migrate.js

@@ -0,0 +1,139 @@
+import { readFile, writeFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import chalk from "chalk";
+export const MIGRATION_RULES = [
+    {
+        name: "inputSize-to-size",
+        pattern: /\binputSize(\s*=)/g,
+        replacement: "size$1",
+        description: "Input: inputSize prop renamed to size",
+    },
+    {
+        name: "selectSize-to-size",
+        pattern: /\bselectSize(\s*=)/g,
+        replacement: "size$1",
+        description: "Select: selectSize prop renamed to size",
+    },
+    {
+        name: "comboBoxSize-to-size",
+        pattern: /\bcomboBoxSize(\s*=)/g,
+        replacement: "size$1",
+        description: "ComboBox: comboBoxSize prop renamed to size",
+    },
+    {
+        name: "checkboxState-to-state",
+        pattern: /\bcheckboxState(\s*=)/g,
+        replacement: "state$1",
+        description: "Checkbox: checkboxState prop renamed to state",
+    },
+];
+const IGNORE_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "dist",
+    "build",
+    ".next",
+    ".turbo",
+    ".inai-ui",
+    "coverage",
+    ".vercel",
+    ".cache",
+]);
+/**
+ * Recursively walk `root` and collect every `.ts`/`.tsx`/`.js`/`.jsx` file
+ * outside of the standard ignore list. Exported so tests can drive discovery
+ * deterministically against a tmpdir fixture.
+ */
+export async function discoverSourceFiles(root) {
+    const out = [];
+    async function walk(dir) {
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await walk(full);
+            }
+            else if (/\.(tsx?|jsx?)$/.test(entry.name)) {
+                out.push(full);
+            }
+        }
+    }
+    await walk(root);
+    return out;
+}
+export async function runMigrate(options = {}) {
+    const { dryRun = false, files, cwd = process.cwd() } = options;
+    const targets = files && files.length > 0 ? files : await discoverSourceFiles(cwd);
+    const perRule = {};
+    const touchedFiles = [];
+    let totalReplacements = 0;
+    for (const file of targets) {
+        let content;
+        try {
+            content = await readFile(file, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        let modified = content;
+        let fileHadChanges = false;
+        for (const rule of MIGRATION_RULES) {
+            // Reset lastIndex is unnecessary for a new `match()` call, but using
+            // `exec` in a loop would require it — stick with a single `match`.
+            const matches = modified.match(rule.pattern);
+            if (matches && matches.length > 0) {
+                modified = modified.replace(rule.pattern, rule.replacement);
+                perRule[rule.name] = (perRule[rule.name] ?? 0) + matches.length;
+                totalReplacements += matches.length;
+                fileHadChanges = true;
+            }
+        }
+        if (fileHadChanges) {
+            touchedFiles.push(file);
+            if (!dryRun) {
+                await writeFile(file, modified, "utf-8");
+            }
+        }
+    }
+    return {
+        filesAffected: touchedFiles.length,
+        totalReplacements,
+        perRule,
+        touchedFiles,
+    };
+}
+/**
+ * CLI entry point — wraps `runMigrate` with console output. Kept separate
+ * from `runMigrate` so tests can assert on the structured result without
+ * parsing stdout.
+ */
+export async function migrateCommand(options = {}) {
+    const result = await runMigrate({ dryRun: !!options.dryRun });
+    for (const file of result.touchedFiles) {
+        if (options.dryRun) {
+            console.log(chalk.dim(`[dry-run] would update ${file}`));
+        }
+        else {
+            console.log(chalk.green(`\u2713 ${file}`));
+        }
+    }
+    console.log("");
+    console.log(chalk.bold(`Migration complete${options.dryRun ? " (dry run)" : ""}:`));
+    console.log(`  files affected: ${result.filesAffected}`);
+    console.log(`  replacements:   ${result.totalReplacements}`);
+    for (const [name, count] of Object.entries(result.perRule)) {
+        console.log(`    ${name}: ${count}`);
+    }
+    if (options.dryRun && result.totalReplacements > 0) {
+        console.log("");
+        console.log(chalk.yellow("Run without --dry-run to apply changes."));
+    }
+}

package/dist/commands/registries.d.ts

@@ -0,0 +1,46 @@
+import type { RegistrySource } from "../types/registry.js";
+export interface RegistriesListResult {
+    output: string;
+    count: number;
+}
+/**
+ * Render the list of configured registries as a human-readable block.
+ * Tests call `runRegistriesList` for the returned string; the CLI
+ * action prints it.
+ */
+export declare function runRegistriesList(cwd?: string): Promise<RegistriesListResult>;
+export interface RegistriesAddOptions {
+    cwd?: string;
+    name: string;
+    source?: RegistrySource;
+    url?: string;
+    path?: string;
+    branch?: string;
+    tokenEnv?: string;
+    tokenFile?: string;
+    default?: boolean;
+}
+export interface RegistriesMutationResult {
+    ok: boolean;
+    message: string;
+}
+/**
+ * Append a new registry to `components.json`. Enforces unique names
+ * and basic source-specific field validation so the resulting
+ * configuration is resolvable.
+ */
+export declare function runRegistriesAdd(options: RegistriesAddOptions): Promise<RegistriesMutationResult>;
+/** Remove a registry by name. Refuses to remove the last registry. */
+export declare function runRegistriesRemove(name: string, cwd?: string): Promise<RegistriesMutationResult>;
+export declare function registriesListCommand(): Promise<void>;
+export declare function registriesAddCommand(name: string, opts: {
+    source?: string;
+    url?: string;
+    path?: string;
+    branch?: string;
+    tokenEnv?: string;
+    tokenFile?: string;
+    default?: boolean;
+}): Promise<void>;
+export declare function registriesRemoveCommand(name: string): Promise<void>;
+//# sourceMappingURL=registries.d.ts.map

package/dist/commands/registries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registries.d.ts","sourceRoot":"","sources":["../../src/commands/registries.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAY,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAErE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CACrC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,oBAAoB,CAAC,CA0B/B;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,cAAc,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,wBAAwB;IACvC,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,wBAAwB,CAAC,CA8DnC;AAED,sEAAsE;AACtE,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EACZ,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,wBAAwB,CAAC,CAmBnC;AAED,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3D;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE;IACJ,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,GACA,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQzE"}

package/dist/commands/registries.js

@@ -0,0 +1,152 @@
+import chalk from "chalk";
+import { loadRegistries, saveRegistries, getRegistryByName, } from "../utils/registry-config.js";
+/**
+ * Render the list of configured registries as a human-readable block.
+ * Tests call `runRegistriesList` for the returned string; the CLI
+ * action prints it.
+ */
+export async function runRegistriesList(cwd = process.cwd()) {
+    const registries = await loadRegistries(cwd);
+    if (registries.length === 0) {
+        return {
+            output: chalk.yellow("No registries configured. Run `inai-ui init` first."),
+            count: 0,
+        };
+    }
+    const lines = [];
+    lines.push(chalk.bold(`\nConfigured registries (${registries.length}):\n`));
+    for (const r of registries) {
+        const defaultMark = r.default ? chalk.cyan(" [default]") : "";
+        const lock = r.auth ? chalk.dim(" [auth]") : "";
+        lines.push(`  ${chalk.bold(r.name)}${defaultMark}${lock}`);
+        lines.push(`    source: ${r.source}`);
+        if (r.path)
+            lines.push(`    path:   ${r.path}`);
+        if (r.url)
+            lines.push(`    url:    ${r.url}`);
+        if (r.branch)
+            lines.push(`    branch: ${r.branch}`);
+        if (r.auth?.tokenEnv)
+            lines.push(`    token:  env:${r.auth.tokenEnv}`);
+        else if (r.auth?.tokenFile)
+            lines.push(`    token:  file:${r.auth.tokenFile}`);
+        lines.push("");
+    }
+    return { output: lines.join("\n"), count: registries.length };
+}
+/**
+ * Append a new registry to `components.json`. Enforces unique names
+ * and basic source-specific field validation so the resulting
+ * configuration is resolvable.
+ */
+export async function runRegistriesAdd(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const source = options.source ?? "git";
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(options.name)) {
+        return {
+            ok: false,
+            message: `Invalid registry name "${options.name}" — use lowercase letters, numbers, and hyphens.`,
+        };
+    }
+    const registries = await loadRegistries(cwd);
+    if (getRegistryByName(registries, options.name)) {
+        return {
+            ok: false,
+            message: `Registry "${options.name}" already exists.`,
+        };
+    }
+    if ((source === "git" || source === "https") && !options.url) {
+        return {
+            ok: false,
+            message: `Registry source "${source}" requires --url.`,
+        };
+    }
+    if (source === "local" && !options.path) {
+        return {
+            ok: false,
+            message: `Registry source "local" requires --path.`,
+        };
+    }
+    const next = {
+        name: options.name,
+        source,
+        ...(options.path ? { path: options.path } : {}),
+        ...(options.url ? { url: options.url } : {}),
+        ...(source === "git" ? { branch: options.branch ?? "main" } : {}),
+        ...(options.tokenEnv || options.tokenFile
+            ? {
+                auth: {
+                    type: "bearer",
+                    ...(options.tokenEnv ? { tokenEnv: options.tokenEnv } : {}),
+                    ...(options.tokenFile ? { tokenFile: options.tokenFile } : {}),
+                },
+            }
+            : {}),
+        ...(options.default ? { default: true } : {}),
+    };
+    // If caller marked this as default, clear any prior default.
+    let updated = registries;
+    if (next.default) {
+        updated = registries.map((r) => ({ ...r, default: false }));
+    }
+    updated = [...updated, next];
+    saveRegistries(cwd, updated);
+    return {
+        ok: true,
+        message: `Registry "${options.name}" added.`,
+    };
+}
+/** Remove a registry by name. Refuses to remove the last registry. */
+export async function runRegistriesRemove(name, cwd = process.cwd()) {
+    const registries = await loadRegistries(cwd);
+    if (!getRegistryByName(registries, name)) {
+        return { ok: false, message: `Registry "${name}" not found.` };
+    }
+    const filtered = registries.filter((r) => r.name !== name);
+    if (filtered.length === 0) {
+        return {
+            ok: false,
+            message: `Cannot remove the last registry — add another one first.`,
+        };
+    }
+    // If we removed the default, promote the first remaining to default.
+    const removed = registries.find((r) => r.name === name);
+    if (removed.default && !filtered.some((r) => r.default)) {
+        filtered[0] = { ...filtered[0], default: true };
+    }
+    saveRegistries(cwd, filtered);
+    return { ok: true, message: `Registry "${name}" removed.` };
+}
+export async function registriesListCommand() {
+    const { output } = await runRegistriesList();
+    console.log(output);
+}
+export async function registriesAddCommand(name, opts) {
+    const result = await runRegistriesAdd({
+        name,
+        source: opts.source ?? "git",
+        url: opts.url,
+        path: opts.path,
+        branch: opts.branch,
+        tokenEnv: opts.tokenEnv,
+        tokenFile: opts.tokenFile,
+        default: opts.default,
+    });
+    if (result.ok) {
+        console.log(chalk.green(result.message));
+    }
+    else {
+        console.error(chalk.red(result.message));
+        process.exit(1);
+    }
+}
+export async function registriesRemoveCommand(name) {
+    const result = await runRegistriesRemove(name);
+    if (result.ok) {
+        console.log(chalk.green(result.message));
+    }
+    else {
+        console.error(chalk.red(result.message));
+        process.exit(1);
+    }
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,11 @@
+export interface RemoveOptions {
+    force?: boolean;
+}
+export interface RemoveResult {
+    removed: boolean;
+    message: string;
+    deletedFiles: string[];
+}
+export declare function runRemove(componentName: string, rootDir: string, options?: RemoveOptions): Promise<RemoveResult>;
+export declare function removeCommand(componentName: string, options?: RemoveOptions): Promise<void>;
+//# sourceMappingURL=remove.d.ts.map