@roboticela/devkit 1.0.2

package/dist/commands/add.d.ts

@@ -0,0 +1,6 @@
+interface AddOptions {
+    variant?: string;
+    dryRun?: boolean;
+}
+export declare function addCommand(names: string[], opts: AddOptions, cwd?: string): Promise<void>;
+export {};

package/dist/commands/add.js

@@ -0,0 +1,27 @@
+import ora from "ora";
+import chalk from "chalk";
+import { readConfig, isComponentInstalled } from "../lib/config.js";
+import { installComponent } from "../lib/installer.js";
+import { log } from "../lib/logger.js";
+export async function addCommand(names, opts, cwd = process.cwd()) {
+    const config = readConfig(cwd);
+    for (const nameAtVersion of names) {
+        const [name, version = "latest"] = nameAtVersion.split("@");
+        if (isComponentInstalled(name, cwd)) {
+            log.warn(`${name} is already installed. Run 'devkit update ${name}' to update.`);
+            continue;
+        }
+        if (opts.dryRun) {
+            log.info(`[dry-run] Would install: ${chalk.cyan(name)}@${version} (${config.template})`);
+            continue;
+        }
+        const spinner = ora({ text: `Installing ${chalk.cyan(name)}…`, color: "cyan" }).start();
+        try {
+            await installComponent(name, config.template, version, opts.variant, cwd);
+            spinner.succeed(chalk.green(`${name}@${version} installed`));
+        }
+        catch (e) {
+            spinner.fail(chalk.red(`Failed to install ${name}: ${e.message}`));
+        }
+    }
+}

package/dist/commands/create.d.ts

@@ -0,0 +1,11 @@
+interface CreateOptions {
+    template?: string;
+    preset?: string;
+    primary?: string;
+    git?: boolean;
+    install?: boolean;
+    add?: string;
+    yes?: boolean;
+}
+export declare function createCommand(projectName: string | undefined, opts: CreateOptions): Promise<void>;
+export {};

package/dist/commands/create.js

@@ -0,0 +1,181 @@
+import { intro, outro, text, select, multiselect, confirm, spinner } from "@clack/prompts";
+import chalk from "chalk";
+import { execSync } from "child_process";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { downloadTemplate } from "../lib/template.js";
+import { writeConfig, writeLock, defaultConfig } from "../lib/config.js";
+import { generateThemeCSS } from "../lib/theme.js";
+import { installComponent } from "../lib/installer.js";
+import { log } from "../lib/logger.js";
+const TEMPLATES = [
+    {
+        value: "nextjs-compact",
+        label: "NextJS Compact",
+        hint: "Next.js 16 · React 19 · TailwindCSS 4 — Web only, SSR/RSC",
+    },
+    {
+        value: "vite-express-tauri",
+        label: "Wide Express  (Vite + Express + Tauri)",
+        hint: "Vite 7 · React 19 · Express 5 · Tauri 2 — Web + Desktop",
+    },
+];
+const PRESETS = [
+    { value: "default", label: "Default    — Indigo + Amber    — Modern SaaS" },
+    { value: "minimal", label: "Minimal    — Slate + Sky       — Clean, editorial" },
+    { value: "bold", label: "Bold       — Violet + Pink     — Vibrant, expressive" },
+    { value: "playful", label: "Playful    — Emerald + Orange  — Friendly, rounded" },
+    { value: "corporate", label: "Corporate  — Blue + Gray       — Formal, enterprise" },
+];
+const COMPONENTS = [
+    { value: "auth", label: "auth          — Full authentication system" },
+    { value: "hero-section", label: "hero-section  — Landing page hero banner" },
+    { value: "profile", label: "profile       — User profile pages" },
+    { value: "pricing", label: "pricing       — Pricing table" },
+    { value: "dashboard", label: "dashboard     — App dashboard layout" },
+    { value: "contact-form", label: "contact-form  — Contact / support form" },
+];
+export async function createCommand(projectName, opts) {
+    console.log();
+    console.log(chalk.bold.white("  ┌─────────────────────────────────────────────────────┐"));
+    console.log(chalk.bold.white("  │      Roboticela DevKit — Create New Project         │"));
+    console.log(chalk.bold.white("  │                    v1.0.0                           │"));
+    console.log(chalk.bold.white("  └─────────────────────────────────────────────────────┘"));
+    console.log();
+    intro(chalk.cyan("Let's scaffold your project"));
+    // ── Collect answers ──────────────────────────────────────────────────────
+    const name = projectName ?? (opts.yes ? "my-app" : await text({
+        message: "Project name",
+        placeholder: "my-app",
+        validate: (v) => v.length < 1 ? "Name is required" : undefined,
+    }));
+    if (!name || typeof name !== "string") {
+        process.exit(0);
+    }
+    const template = (opts.template ?? (opts.yes ? "nextjs-compact" : await select({
+        message: "Select a template",
+        options: TEMPLATES,
+    })));
+    const siteName = opts.yes ? name : await text({
+        message: "Site display name",
+        initialValue: name,
+    });
+    const siteUrl = opts.yes ? `https://${name}.com` : await text({
+        message: "Site URL",
+        placeholder: "https://myapp.com",
+    });
+    const preset = opts.preset ?? (opts.yes ? "default" : await select({
+        message: "Theme preset",
+        options: PRESETS,
+    }));
+    const primaryColor = opts.primary ?? (opts.yes ? undefined : await text({
+        message: "Primary brand color (hex, leave blank to use preset)",
+        placeholder: "(leave blank for preset default)",
+        validate: (v) => v && !/^#[0-9a-fA-F]{6}$/.test(v) ? "Enter a valid hex like #6366f1 or leave blank" : undefined,
+    }));
+    const doGit = opts.git ?? (opts.yes ? true : await confirm({ message: "Initialize a git repository?" }));
+    const doInstall = opts.install ?? (opts.yes ? true : await confirm({ message: "Install npm dependencies now?" }));
+    const selectedComponents = opts.add
+        ? opts.add.split(",").map((s) => s.trim())
+        : (opts.yes ? [] : await multiselect({
+            message: "Add components now? (space to select, enter to confirm — you can always run 'devkit add' later)",
+            options: COMPONENTS,
+            required: false,
+        }));
+    // ── Build ────────────────────────────────────────────────────────────────
+    console.log();
+    log.header("Creating project…");
+    const destDir = join(process.cwd(), name);
+    if (existsSync(destDir)) {
+        log.error(`Directory '${name}' already exists.`);
+        process.exit(1);
+    }
+    mkdirSync(destDir, { recursive: true });
+    // 1. Download template
+    const s = spinner();
+    s.start(`Fetching template: ${chalk.cyan(template)}`);
+    try {
+        await downloadTemplate(template, destDir);
+        s.stop(chalk.green(`✓  Template fetched: ${template}`));
+    }
+    catch (e) {
+        s.stop(chalk.red(`✗  Failed to fetch template`));
+        log.error(e.message);
+        process.exit(1);
+    }
+    // 2. Write devkit.config.json
+    const config = defaultConfig(template, siteName, siteUrl);
+    config.theme.preset = preset;
+    if (primaryColor)
+        config.theme.colors = { ...config.theme.colors, primary: primaryColor };
+    writeConfig(config, destDir);
+    log.success("Created devkit.config.json");
+    // 3. Write devkit.lock.json
+    writeLock({ lockVersion: 1, template, components: {} }, destDir);
+    log.success("Created devkit.lock.json");
+    // 4. Generate theme CSS
+    const themeCss = generateThemeCSS(config);
+    const cssPath = template === "nextjs-compact"
+        ? join(destDir, "app", "globals.css")
+        : join(destDir, "src", "index.css");
+    if (existsSync(cssPath)) {
+        const existing = readFileSync(cssPath, "utf-8");
+        const withoutOldBlock = existing.replace(/\/\* ── DevKit Managed Theme Block[\s\S]*?── End DevKit Managed Theme Block ── \*\//, "").trimStart();
+        writeFileSync(cssPath, themeCss + withoutOldBlock);
+    }
+    else {
+        mkdirSync(join(destDir, template === "nextjs-compact" ? "app" : "src"), { recursive: true });
+        writeFileSync(cssPath, themeCss);
+    }
+    log.success(`Applied theme preset: ${preset}`);
+    // 5. npm install
+    if (doInstall) {
+        s.start("Installing npm dependencies…");
+        try {
+            execSync("npm install", { cwd: destDir, stdio: "pipe" });
+            s.stop(chalk.green("✓  npm install complete"));
+        }
+        catch {
+            s.stop(chalk.yellow("⚠  npm install failed — run it manually"));
+        }
+    }
+    // 6. git init
+    if (doGit) {
+        try {
+            execSync("git init", { cwd: destDir, stdio: "pipe" });
+            execSync('git add . && git commit -m "chore: init project with DevKit"', { cwd: destDir, stdio: "pipe" });
+            log.success("Initialized git repository");
+        }
+        catch {
+            log.warn("git init failed — git may not be installed");
+        }
+    }
+    // 7. Add selected components
+    for (const comp of selectedComponents) {
+        s.start(`Adding component: ${chalk.cyan(comp)}`);
+        try {
+            await installComponent(comp, template, "latest", undefined, destDir);
+            s.stop(chalk.green(`✓  Added: ${comp}`));
+        }
+        catch (e) {
+            s.stop(chalk.yellow(`⚠  Skipped ${comp}: ${e.message}`));
+        }
+    }
+    // ── Done ─────────────────────────────────────────────────────────────────
+    console.log();
+    outro(chalk.green("Project ready!"));
+    console.log();
+    console.log(`  ${chalk.bold("Location")}    ${name}/`);
+    console.log(`  ${chalk.bold("Template")}    ${template}`);
+    console.log(`  ${chalk.bold("Theme")}       ${preset}`);
+    if (selectedComponents.length > 0) {
+        console.log(`  ${chalk.bold("Components")}  ${selectedComponents.join(", ")}`);
+    }
+    console.log();
+    console.log(chalk.bold("  Next steps:"));
+    console.log(`    ${chalk.cyan("cd")} ${name}`);
+    console.log(`    ${chalk.cyan("cp")} .env.example .env    ${chalk.gray("# Fill in your secrets")}`);
+    console.log(`    ${chalk.cyan("devkit doctor")}           ${chalk.gray("# Check for missing config")}`);
+    console.log(`    ${chalk.cyan("npm run dev")}             ${chalk.gray("# Start the dev server")}`);
+    console.log();
+}

package/dist/commands/doctor.d.ts

@@ -0,0 +1 @@
+export declare function doctorCommand(cwd?: string): Promise<void>;

package/dist/commands/doctor.js

@@ -0,0 +1,76 @@
+import chalk from "chalk";
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { readConfig, readLock } from "../lib/config.js";
+import { log } from "../lib/logger.js";
+import { healthCheck } from "../lib/registry.js";
+export async function doctorCommand(cwd = process.cwd()) {
+    let ok = true;
+    log.blank();
+    log.header("DevKit Doctor");
+    // Config check
+    const configPath = join(cwd, "devkit.config.json");
+    if (existsSync(configPath)) {
+        log.success("devkit.config.json found");
+    }
+    else {
+        log.error("devkit.config.json not found — run 'devkit init'");
+        ok = false;
+    }
+    // Template check
+    try {
+        const config = readConfig(cwd);
+        log.success(`Template: ${config.template}`);
+        // Site config
+        if (!config.site.name) {
+            log.warn("site.name is empty");
+            ok = false;
+        }
+        if (!config.site.url) {
+            log.warn("site.url is empty");
+            ok = false;
+        }
+        // Installed components env vars
+        const lock = readLock(cwd);
+        for (const [name, entry] of Object.entries(lock.components)) {
+            const manifestPath = join(cwd, ".devkit", `${name}.manifest.json`);
+            if (!existsSync(manifestPath)) {
+                log.warn(`${name}@${entry.version} — manifest missing (reinstall with 'devkit add ${name}')`);
+                continue;
+            }
+            const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+            const envVars = manifest.envVars ?? [];
+            let compOk = true;
+            for (const envVar of envVars) {
+                if (!process.env[envVar]) {
+                    log.warn(`${name} — Missing env var: ${chalk.yellow(envVar)}`);
+                    compOk = false;
+                    ok = false;
+                }
+            }
+            if (compOk) {
+                log.success(`${name}@${entry.version} — OK`);
+            }
+        }
+    }
+    catch (e) {
+        log.error(e.message);
+        ok = false;
+    }
+    // Registry reachability
+    const registryOk = await healthCheck();
+    if (registryOk) {
+        log.success("Registry server reachable");
+    }
+    else {
+        log.warn("Registry server not reachable (offline mode)");
+    }
+    log.blank();
+    if (ok) {
+        log.success("Everything looks good!");
+    }
+    else {
+        log.warn("Some issues found — see above.");
+    }
+    log.blank();
+}

package/dist/commands/info.d.ts

@@ -0,0 +1 @@
+export declare function infoCommand(name: string): Promise<void>;

package/dist/commands/info.js

@@ -0,0 +1,53 @@
+import chalk from "chalk";
+import { getComponentInfo } from "../lib/registry.js";
+import { log } from "../lib/logger.js";
+export async function infoCommand(name) {
+    try {
+        const info = await getComponentInfo(name);
+        const versions = info["versions"];
+        const variants = info["variants"];
+        log.blank();
+        console.log(`  ${chalk.bold.white(info["displayName"])}  ${chalk.dim(`(${name})`)}`);
+        console.log(`  ${chalk.dim(info["description"])}`);
+        log.blank();
+        console.log(`  ${chalk.bold("Version")}     ${versions.latest}`);
+        console.log(`  ${chalk.bold("Category")}    ${info["category"]}`);
+        console.log(`  ${chalk.bold("Templates")}   ${info["templates"].join(", ")}`);
+        console.log(`  ${chalk.bold("Platforms")}   ${info["platforms"].join(", ")}`);
+        if (variants?.length) {
+            log.blank();
+            console.log(`  ${chalk.bold("Variants:")}`);
+            for (const v of variants) {
+                console.log(`    ${chalk.cyan(v.id.padEnd(18))} ${chalk.dim(v.description)}`);
+            }
+        }
+        const req = info["requiredConfig"];
+        const opt = info["optionalConfig"];
+        if (req?.length) {
+            log.blank();
+            console.log(`  ${chalk.bold("Required config:")}`);
+            for (const k of req)
+                console.log(`    ${chalk.yellow(k)}`);
+        }
+        if (opt?.length) {
+            console.log(`  ${chalk.bold("Optional config:")}`);
+            for (const k of opt)
+                console.log(`    ${chalk.dim(k)}`);
+        }
+        log.blank();
+        console.log(`  ${chalk.bold("Version history:")}`);
+        for (const v of versions.history) {
+            const tag = v.breaking ? chalk.red(" [breaking]") : "";
+            console.log(`    ${chalk.cyan(v.version)}  ${chalk.dim(v.releaseDate)}${tag}`);
+        }
+        log.blank();
+        console.log(`  ${chalk.dim("Install:")}  devkit add ${name}`);
+        if (variants?.length) {
+            console.log(`  ${chalk.dim("With variant:")}  devkit add ${name} --variant=${variants[0].id}`);
+        }
+        log.blank();
+    }
+    catch (e) {
+        log.error(`Component '${name}' not found: ${e.message}`);
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(cwd?: string): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,65 @@
+import { intro, outro, text, select } from "@clack/prompts";
+import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { detectTemplate } from "../lib/detector.js";
+import { writeConfig, writeLock, defaultConfig, configExists } from "../lib/config.js";
+import { generateThemeCSS } from "../lib/theme.js";
+import { log } from "../lib/logger.js";
+export async function initCommand(cwd = process.cwd()) {
+    if (configExists(cwd)) {
+        log.warn("DevKit is already initialized in this project.");
+        log.info("Run 'devkit doctor' to check configuration.");
+        return;
+    }
+    intro("DevKit Init");
+    const detected = detectTemplate(cwd);
+    const template = detected !== "unknown"
+        ? detected
+        : await select({
+            message: "Could not auto-detect template. Select manually:",
+            options: [
+                { value: "nextjs-compact", label: "NextJS Compact" },
+                { value: "vite-express-tauri", label: "Wide Express (Vite + Express + Tauri)" },
+            ],
+        });
+    if (detected !== "unknown") {
+        log.success(`Detected template: ${template}`);
+    }
+    const siteName = await text({ message: "Site name", placeholder: "My App" });
+    const siteUrl = await text({ message: "Site URL", placeholder: "https://myapp.com" });
+    const preset = await select({
+        message: "Theme preset",
+        options: [
+            { value: "default", label: "Default    — Indigo" },
+            { value: "minimal", label: "Minimal    — Slate" },
+            { value: "bold", label: "Bold       — Violet" },
+            { value: "playful", label: "Playful    — Emerald" },
+            { value: "corporate", label: "Corporate  — Blue" },
+        ],
+    });
+    // Write config
+    const config = defaultConfig(template, siteName, siteUrl);
+    config.theme.preset = preset;
+    writeConfig(config, cwd);
+    log.success("Created devkit.config.json");
+    // Write lock
+    writeLock({ lockVersion: 1, template, components: {} }, cwd);
+    log.success("Created devkit.lock.json");
+    // Generate theme CSS
+    const themeCss = generateThemeCSS(config);
+    const cssFile = template === "nextjs-compact" ? "app/globals.css" : "src/index.css";
+    const cssPath = join(cwd, cssFile);
+    if (existsSync(cssPath)) {
+        const old = readFileSync(cssPath, "utf-8");
+        const clean = old.replace(/\/\* ── DevKit Managed Theme Block[\s\S]*?── End DevKit Managed Theme Block ── \*\//, "").trimStart();
+        writeFileSync(cssPath, themeCss + clean);
+    }
+    else {
+        mkdirSync(join(cwd, template === "nextjs-compact" ? "app" : "src"), { recursive: true });
+        writeFileSync(cssPath, themeCss);
+    }
+    log.success(`Applied theme to ${cssFile}`);
+    // .devkit dir
+    mkdirSync(join(cwd, ".devkit"), { recursive: true });
+    outro("DevKit initialized! Run 'devkit list' to browse components.");
+}

package/dist/commands/list.d.ts

@@ -0,0 +1,7 @@
+interface ListOptions {
+    template?: string;
+    installed?: boolean;
+    category?: string;
+}
+export declare function listCommand(opts: ListOptions, cwd?: string): Promise<void>;
+export {};

package/dist/commands/list.js

@@ -0,0 +1,52 @@
+import chalk from "chalk";
+import { listComponents } from "../lib/registry.js";
+import { readConfig, readLock } from "../lib/config.js";
+import { log } from "../lib/logger.js";
+export async function listCommand(opts, cwd = process.cwd()) {
+    let template = opts.template;
+    if (!template) {
+        try {
+            template = readConfig(cwd).template;
+        }
+        catch { /* no config */ }
+    }
+    try {
+        const components = await listComponents(template);
+        const lock = (() => { try {
+            return readLock(cwd);
+        }
+        catch {
+            return { lockVersion: 1, template: "", components: {} };
+        } })();
+        const filtered = opts.installed
+            ? components.filter((c) => c.name in lock.components)
+            : opts.category
+                ? components.filter((c) => c.category === opts.category)
+                : components;
+        if (filtered.length === 0) {
+            log.info("No components found.");
+            return;
+        }
+        log.blank();
+        const col = (s, w) => s.padEnd(w).slice(0, w);
+        console.log(chalk.gray("  " + col("Component", 20) + col("Category", 16) + col("Templates", 36) + "Installed"));
+        console.log(chalk.gray("  " + "─".repeat(80)));
+        for (const comp of filtered) {
+            const installed = lock.components[comp.name];
+            const installedStr = installed ? chalk.green(`v${installed.version}`) : chalk.gray("-");
+            const templateStr = comp.templates.join(", ");
+            console.log("  " +
+                chalk.bold(col(comp.name, 20)) +
+                chalk.dim(col(comp.category, 16)) +
+                col(templateStr, 36) +
+                installedStr);
+        }
+        log.blank();
+        log.info(`${filtered.length} component(s). Run ${chalk.cyan("devkit info <name>")} for details.`);
+        log.blank();
+    }
+    catch (e) {
+        log.error(`Could not reach registry: ${e.message}`);
+        log.info("Is the registry server running? Start it with: cd registry && npm run dev");
+    }
+}

package/dist/commands/remove.d.ts

@@ -0,0 +1,3 @@
+export declare function removeCommand(name: string, opts: {
+    keepFiles?: boolean;
+}, cwd?: string): Promise<void>;

package/dist/commands/remove.js

@@ -0,0 +1,22 @@
+import { confirm } from "@clack/prompts";
+import { isComponentInstalled } from "../lib/config.js";
+import { removeComponent } from "../lib/installer.js";
+import { log } from "../lib/logger.js";
+export async function removeCommand(name, opts, cwd = process.cwd()) {
+    if (!isComponentInstalled(name, cwd)) {
+        log.error(`'${name}' is not installed.`);
+        process.exit(1);
+    }
+    const ok = await confirm({ message: `Remove ${name} and all its managed files?` });
+    if (!ok) {
+        log.info("Aborted.");
+        return;
+    }
+    try {
+        removeComponent(name, cwd);
+        log.success(`${name} removed.`);
+    }
+    catch (e) {
+        log.error(e.message);
+    }
+}

package/dist/commands/theme.d.ts

@@ -0,0 +1,6 @@
+export declare function themeApplyCommand(cwd?: string): void;
+export declare function themePreviewCommand(cwd?: string): void;
+export declare function themePresetCommand(preset: string, cwd?: string): void;
+export declare function themeSetCommand(key: string, value: string, cwd?: string): void;
+export declare function themeListCommand(cwd?: string): void;
+export declare function themeAuditCommand(_cwd?: string): void;

package/dist/commands/theme.js

@@ -0,0 +1,82 @@
+import { writeFileSync, readFileSync, existsSync } from "fs";
+import { join } from "path";
+import chalk from "chalk";
+import { readConfig, writeConfig } from "../lib/config.js";
+import { generateThemeCSS } from "../lib/theme.js";
+import { log } from "../lib/logger.js";
+function getCssPath(template, cwd) {
+    return template === "nextjs-compact"
+        ? join(cwd, "app", "globals.css")
+        : join(cwd, "src", "index.css");
+}
+function patchCss(cssPath, newBlock) {
+    const existing = existsSync(cssPath) ? readFileSync(cssPath, "utf-8") : "";
+    const userSection = existing
+        .replace(/\/\* ── DevKit Managed Theme Block[\s\S]*?── End DevKit Managed Theme Block ── \*\//, "")
+        .trimStart();
+    writeFileSync(cssPath, newBlock + userSection);
+}
+export function themeApplyCommand(cwd = process.cwd()) {
+    const config = readConfig(cwd);
+    const css = generateThemeCSS(config);
+    patchCss(getCssPath(config.template, cwd), css);
+    log.success("Theme applied to CSS.");
+}
+export function themePreviewCommand(cwd = process.cwd()) {
+    const config = readConfig(cwd);
+    const css = generateThemeCSS(config);
+    log.blank();
+    console.log(chalk.dim(css.split("\n").map((l) => "  " + l).join("\n")));
+}
+export function themePresetCommand(preset, cwd = process.cwd()) {
+    const VALID = ["default", "minimal", "bold", "playful", "corporate"];
+    if (!VALID.includes(preset)) {
+        log.error(`Unknown preset '${preset}'. Valid: ${VALID.join(", ")}`);
+        process.exit(1);
+    }
+    const config = readConfig(cwd);
+    config.theme = { ...config.theme, preset };
+    writeConfig(config, cwd);
+    themeApplyCommand(cwd);
+    log.success(`Switched to preset: ${preset}`);
+}
+export function themeSetCommand(key, value, cwd = process.cwd()) {
+    const config = readConfig(cwd);
+    // Only support: colors.primary, colors.secondary, fonts.sans, fonts.mono, radius, darkMode
+    if (key === "colors.primary")
+        config.theme.colors = { ...config.theme.colors, primary: value };
+    else if (key === "colors.secondary")
+        config.theme.colors = { ...config.theme.colors, secondary: value };
+    else if (key === "fonts.sans")
+        config.theme.fonts = { ...config.theme.fonts, sans: value };
+    else if (key === "fonts.mono")
+        config.theme.fonts = { ...config.theme.fonts, mono: value };
+    else if (key === "radius")
+        config.theme.radius = value;
+    else if (key === "darkMode")
+        config.theme.darkMode = value === "true";
+    else {
+        log.error(`Unknown theme key: ${key}`);
+        process.exit(1);
+    }
+    writeConfig(config, cwd);
+    themeApplyCommand(cwd);
+    log.success(`Set ${key} = ${chalk.cyan(value)}`);
+}
+export function themeListCommand(cwd = process.cwd()) {
+    const config = readConfig(cwd);
+    const t = config.theme ?? {};
+    log.blank();
+    console.log(`  ${chalk.bold("Preset")}          ${t.preset ?? "default"}`);
+    console.log(`  ${chalk.bold("Primary")}         ${chalk.hex(t.colors?.primary ?? "#6366f1")(t.colors?.primary ?? "#6366f1 (preset)")}`);
+    console.log(`  ${chalk.bold("Secondary")}       ${t.colors?.secondary ?? "(preset)"}`);
+    console.log(`  ${chalk.bold("Font sans")}       ${t.fonts?.sans ?? "Inter"}`);
+    console.log(`  ${chalk.bold("Font mono")}       ${t.fonts?.mono ?? "JetBrains Mono"}`);
+    console.log(`  ${chalk.bold("Radius")}          ${t.radius ?? "md"}`);
+    console.log(`  ${chalk.bold("Dark mode")}       ${t.darkMode !== false ? "enabled" : "disabled"}`);
+    log.blank();
+}
+export function themeAuditCommand(_cwd = process.cwd()) {
+    log.warn("Theme audit checks component files for hardcoded colors (not yet implemented in CLI).");
+    log.info("This runs automatically in registry CI when submitting a component.");
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,2 @@
+export declare function updateCommand(nameAtVersion: string, cwd?: string): Promise<void>;
+export declare function upgradeAllCommand(cwd?: string): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,45 @@
+import ora from "ora";
+import chalk from "chalk";
+import { readConfig, readLock, isComponentInstalled } from "../lib/config.js";
+import { installComponent } from "../lib/installer.js";
+import { log } from "../lib/logger.js";
+export async function updateCommand(nameAtVersion, cwd = process.cwd()) {
+    const [name, version = "latest"] = nameAtVersion.split("@");
+    const config = readConfig(cwd);
+    if (!isComponentInstalled(name, cwd)) {
+        log.error(`'${name}' is not installed. Use 'devkit add ${name}' to install.`);
+        process.exit(1);
+    }
+    const lock = readLock(cwd);
+    const current = lock.components[name];
+    log.info(`Updating ${chalk.cyan(name)} from v${current.version} → ${version}`);
+    const spinner = ora({ text: `Updating ${name}…`, color: "cyan" }).start();
+    try {
+        await installComponent(name, config.template, version, current.variant ?? undefined, cwd);
+        spinner.succeed(chalk.green(`${name} updated`));
+    }
+    catch (e) {
+        spinner.fail(chalk.red(`Update failed: ${e.message}`));
+    }
+}
+export async function upgradeAllCommand(cwd = process.cwd()) {
+    const config = readConfig(cwd);
+    const lock = readLock(cwd);
+    const names = Object.keys(lock.components);
+    if (names.length === 0) {
+        log.info("No components installed.");
+        return;
+    }
+    log.info(`Upgrading ${names.length} component(s)…`);
+    for (const name of names) {
+        const spinner = ora({ text: `Upgrading ${chalk.cyan(name)}…`, color: "cyan" }).start();
+        try {
+            const variant = lock.components[name].variant ?? undefined;
+            await installComponent(name, config.template, "latest", variant, cwd);
+            spinner.succeed(chalk.green(`${name} upgraded`));
+        }
+        catch (e) {
+            spinner.fail(chalk.yellow(`${name}: ${e.message}`));
+        }
+    }
+}