@roboticela/devkit 1.0.2

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import chalk from "chalk";
+import { createCommand } from "./commands/create.js";
+import { initCommand } from "./commands/init.js";
+import { addCommand } from "./commands/add.js";
+import { removeCommand } from "./commands/remove.js";
+import { listCommand } from "./commands/list.js";
+import { infoCommand } from "./commands/info.js";
+import { updateCommand, upgradeAllCommand } from "./commands/update.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { themeApplyCommand, themePreviewCommand, themePresetCommand, themeSetCommand, themeListCommand, themeAuditCommand, } from "./commands/theme.js";
+const program = new Command();
+program
+    .name("devkit")
+    .description("Roboticela DevKit — scaffold and extend full-stack projects")
+    .version("1.0.0");
+// ── devkit create ─────────────────────────────────────────────────────────────
+program
+    .command("create [name]")
+    .description("Create a new project from a DevKit template")
+    .option("--template <id>", "Template ID (nextjs-compact | vite-express-tauri)")
+    .option("--preset <name>", "Theme preset (default | minimal | bold | playful | corporate)")
+    .option("--primary <hex>", "Primary brand color override (e.g. #e11d48)")
+    .option("--git", "Initialize git repository")
+    .option("--no-git", "Skip git initialization")
+    .option("--install", "Run npm install after scaffolding")
+    .option("--no-install", "Skip npm install")
+    .option("--add <components>", "Comma-separated components to add immediately (e.g. auth,hero-section)")
+    .option("-y, --yes", "Accept all defaults, skip prompts")
+    .action((name, opts) => createCommand(name, opts));
+// ── devkit init ───────────────────────────────────────────────────────────────
+program
+    .command("init")
+    .description("Initialize DevKit in an existing project")
+    .action(() => initCommand());
+// ── devkit add ────────────────────────────────────────────────────────────────
+program
+    .command("add <components...>")
+    .description("Install one or more components (e.g. devkit add auth hero-section)")
+    .option("--variant <id>", "Variant to install for components that have variants")
+    .option("--dry-run", "Preview what would be installed without writing files")
+    .action((names, opts) => addCommand(names, opts));
+// ── devkit remove ─────────────────────────────────────────────────────────────
+program
+    .command("remove <name>")
+    .description("Uninstall a component and its managed files")
+    .option("--keep-files", "Remove from DevKit tracking but keep the files")
+    .action((name, opts) => removeCommand(name, opts));
+// ── devkit list ───────────────────────────────────────────────────────────────
+program
+    .command("list")
+    .description("List all available components from the registry")
+    .option("--template <id>", "Filter by template")
+    .option("--category <cat>", "Filter by category")
+    .option("--installed", "Show only installed components")
+    .action((opts) => listCommand(opts));
+// ── devkit info ───────────────────────────────────────────────────────────────
+program
+    .command("info <name>")
+    .description("Show details about a component")
+    .action((name) => infoCommand(name));
+// ── devkit update ─────────────────────────────────────────────────────────────
+program
+    .command("update [component]")
+    .description("Update a component (or all components with --all)")
+    .option("--all", "Update all installed components")
+    .action((comp, opts) => {
+    if (opts.all || !comp)
+        return upgradeAllCommand();
+    return updateCommand(comp);
+});
+// ── devkit upgrade ────────────────────────────────────────────────────────────
+program
+    .command("upgrade")
+    .description("Upgrade all installed components to their latest versions")
+    .action(() => upgradeAllCommand());
+// ── devkit doctor ─────────────────────────────────────────────────────────────
+program
+    .command("doctor")
+    .description("Check project configuration and installed components for issues")
+    .action(() => doctorCommand());
+// ── devkit theme ──────────────────────────────────────────────────────────────
+const theme = program.command("theme").description("Manage the global design token system");
+theme.command("apply")
+    .description("Regenerate globals.css from current devkit.config.json theme settings")
+    .action(() => themeApplyCommand());
+theme.command("preview")
+    .description("Preview the generated CSS without writing it")
+    .action(() => themePreviewCommand());
+theme.command("preset <name>")
+    .description("Switch to a named theme preset (default | minimal | bold | playful | corporate)")
+    .action((name) => themePresetCommand(name));
+theme.command("set <key> <value>")
+    .description("Set a single theme token (e.g. colors.primary #e11d48)")
+    .action((key, value) => themeSetCommand(key, value));
+theme.command("list")
+    .description("Show all current theme settings")
+    .action(() => themeListCommand());
+theme.command("audit")
+    .description("Scan component files for hardcoded colors (anti-pattern detector)")
+    .action(() => themeAuditCommand());
+// ── devkit install (CI use) ───────────────────────────────────────────────────
+program
+    .command("install")
+    .description("Install all components from devkit.lock.json (for CI/deployment)")
+    .action(async () => {
+    const { readLock, readConfig } = await import("./lib/config.js");
+    const { installComponent } = await import("./lib/installer.js");
+    const { log } = await import("./lib/logger.js");
+    const lock = readLock();
+    const config = readConfig();
+    for (const [name, entry] of Object.entries(lock.components)) {
+        const s = (await import("ora")).default(`Installing ${name}…`).start();
+        try {
+            await installComponent(name, config.template, entry.version, entry.variant ?? undefined);
+            s.succeed(`${name}@${entry.version}`);
+        }
+        catch (e) {
+            s.fail(`${name}: ${e.message}`);
+        }
+    }
+    log.success("All components installed.");
+});
+// ── devkit eject ──────────────────────────────────────────────────────────────
+program
+    .command("eject <name>")
+    .description("Stop DevKit from tracking a component (files are kept, no more updates via DevKit)")
+    .action(async (name) => {
+    const { readLock, writeLock } = await import("./lib/config.js");
+    const { unlinkSync, existsSync } = await import("fs");
+    const { join } = await import("path");
+    const { log } = await import("./lib/logger.js");
+    const manifestPath = join(process.cwd(), ".devkit", `${name}.manifest.json`);
+    if (existsSync(manifestPath))
+        unlinkSync(manifestPath);
+    const lock = readLock();
+    delete lock.components[name];
+    writeLock(lock);
+    log.success(`${name} ejected. Files are yours — DevKit will no longer manage them.`);
+});
+// ── Help footer ───────────────────────────────────────────────────────────────
+program.addHelpText("after", `
+${chalk.bold("Examples:")}
+  ${chalk.cyan("devkit create my-app")}                       Interactive project creation
+  ${chalk.cyan("devkit create my-app --template=nextjs-compact --yes")}   Non-interactive
+  ${chalk.cyan("devkit add auth")}                            Install auth component
+  ${chalk.cyan("devkit add hero-section --variant=split-image")}
+  ${chalk.cyan("devkit theme set colors.primary #e11d48")}   Change primary color
+  ${chalk.cyan("devkit doctor")}                              Check configuration
+  ${chalk.cyan("devkit list")}                                Browse all components
+
+${chalk.dim("Registry:")} ${process.env.DEVKIT_REGISTRY ?? "https://api.devkit.roboticela.com"}
+`);
+program.parse();

package/dist/lib/config.d.ts

@@ -0,0 +1,51 @@
+export interface DevKitConfig {
+    $schema?: string;
+    devkit: string;
+    template: "nextjs-compact" | "vite-express-tauri";
+    site: {
+        name: string;
+        url: string;
+        icon?: string;
+        description?: string;
+    };
+    theme?: {
+        preset?: string;
+        colors?: {
+            primary?: string;
+            secondary?: string;
+        };
+        fonts?: {
+            sans?: string;
+            mono?: string;
+            display?: string;
+        };
+        radius?: string;
+        darkMode?: boolean;
+        darkModeStrategy?: "class" | "media";
+    };
+    auth?: Record<string, unknown>;
+    subscriptions?: Record<string, unknown>;
+    storage?: Record<string, unknown>;
+    database?: {
+        url?: string;
+    };
+}
+export interface DevKitLock {
+    lockVersion: number;
+    template: string;
+    components: Record<string, {
+        version: string;
+        variant?: string | null;
+        resolved: string;
+        integrity?: string;
+        installedAt: string;
+    }>;
+}
+export declare function configExists(cwd?: string): boolean;
+export declare function readConfig(cwd?: string): DevKitConfig;
+export declare function writeConfig(config: DevKitConfig, cwd?: string): void;
+export declare function readLock(cwd?: string): DevKitLock;
+export declare function writeLock(lock: DevKitLock, cwd?: string): void;
+export declare function getInstalledComponents(cwd?: string): string[];
+export declare function isComponentInstalled(name: string, cwd?: string): boolean;
+export declare function defaultConfig(template: DevKitConfig["template"], siteName: string, siteUrl: string): DevKitConfig;

package/dist/lib/config.js

@@ -0,0 +1,48 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+const CONFIG_FILE = "devkit.config.json";
+const LOCK_FILE = "devkit.lock.json";
+export function configExists(cwd = process.cwd()) {
+    return existsSync(join(cwd, CONFIG_FILE));
+}
+export function readConfig(cwd = process.cwd()) {
+    const path = join(cwd, CONFIG_FILE);
+    if (!existsSync(path))
+        throw new Error(`devkit.config.json not found. Run 'devkit init' first.`);
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function writeConfig(config, cwd = process.cwd()) {
+    writeFileSync(join(cwd, CONFIG_FILE), JSON.stringify(config, null, 2) + "\n");
+}
+export function readLock(cwd = process.cwd()) {
+    const path = join(cwd, LOCK_FILE);
+    if (!existsSync(path))
+        return { lockVersion: 1, template: "", components: {} };
+    return JSON.parse(readFileSync(path, "utf-8"));
+}
+export function writeLock(lock, cwd = process.cwd()) {
+    writeFileSync(join(cwd, LOCK_FILE), JSON.stringify(lock, null, 2) + "\n");
+}
+export function getInstalledComponents(cwd = process.cwd()) {
+    const lock = readLock(cwd);
+    return Object.keys(lock.components);
+}
+export function isComponentInstalled(name, cwd = process.cwd()) {
+    return name in readLock(cwd).components;
+}
+export function defaultConfig(template, siteName, siteUrl) {
+    return {
+        $schema: "https://registry.roboticela.com/schemas/devkit-config.json",
+        devkit: "1.0",
+        template,
+        site: { name: siteName, url: siteUrl },
+        theme: {
+            preset: "default",
+            colors: { primary: "#6366f1", secondary: "#f59e0b" },
+            fonts: { sans: "Inter", mono: "JetBrains Mono", display: "Inter" },
+            radius: "md",
+            darkMode: true,
+            darkModeStrategy: "class",
+        },
+    };
+}

package/dist/lib/detector.d.ts

@@ -0,0 +1,2 @@
+export type TemplateId = "nextjs-compact" | "vite-express-tauri" | "unknown";
+export declare function detectTemplate(cwd?: string): TemplateId;

package/dist/lib/detector.js

@@ -0,0 +1,18 @@
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+export function detectTemplate(cwd = process.cwd()) {
+    const pkgPath = join(cwd, "package.json");
+    if (!existsSync(pkgPath))
+        return "unknown";
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    const deps = { ...(pkg["dependencies"] ?? {}), ...(pkg["devDependencies"] ?? {}) };
+    // Next.js check
+    if ("next" in deps)
+        return "nextjs-compact";
+    // Vite + Tauri check
+    if ("vite" in deps && existsSync(join(cwd, "src-tauri")))
+        return "vite-express-tauri";
+    if ("vite" in deps && existsSync(join(cwd, "server")))
+        return "vite-express-tauri";
+    return "unknown";
+}

package/dist/lib/installer.d.ts

@@ -0,0 +1,2 @@
+export declare function installComponent(name: string, template: string, version: string | undefined, variant: string | undefined, cwd?: string): Promise<void>;
+export declare function removeComponent(name: string, cwd?: string): void;

package/dist/lib/installer.js

@@ -0,0 +1,178 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, createWriteStream } from "fs";
+import { join, dirname } from "path";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import { x as extractTar } from "tar";
+import { pipeline } from "stream/promises";
+import { getManifest } from "./registry.js";
+import { readLock, writeLock } from "./config.js";
+import { log } from "./logger.js";
+const REGISTRY_URL = process.env.DEVKIT_REGISTRY ?? "https://api.devkit.roboticela.com";
+function hashFile(path) {
+    const content = readFileSync(path);
+    return createHash("sha256").update(content).digest("hex");
+}
+export async function installComponent(name, template, version = "latest", variant, cwd = process.cwd()) {
+    // 1. Fetch manifest from registry
+    const result = await getManifest(name, template, version, variant);
+    const manifest = result.manifest;
+    const resolvedVersion = result.version;
+    // 2. Download component files from registry
+    const tmpDir = join(cwd, ".devkit", `.tmp-${name}`);
+    await downloadComponentFiles(name, template, resolvedVersion, variant, tmpDir);
+    // 3. Copy files into project
+    const managedFiles = [];
+    for (const fileEntry of manifest.files) {
+        const src = join(tmpDir, fileEntry.source);
+        const dest = join(cwd, fileEntry.destination);
+        // Check if file exists and was user-modified
+        let userModified = false;
+        if (existsSync(dest)) {
+            const existingHash = hashFile(dest);
+            const lock = readLock(cwd);
+            const lockedComp = lock.components[name];
+            if (lockedComp) {
+                const manifestPath = join(cwd, ".devkit", `${name}.manifest.json`);
+                if (existsSync(manifestPath)) {
+                    const existingManifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+                    const tracked = (existingManifest.managedFiles ?? []).find((f) => f.path === fileEntry.destination);
+                    if (tracked && tracked.hash !== existingHash)
+                        userModified = true;
+                }
+            }
+        }
+        if (userModified) {
+            log.warn(`Skipped (user-modified): ${fileEntry.destination}`);
+        }
+        else {
+            mkdirSync(dirname(dest), { recursive: true });
+            if (existsSync(src)) {
+                cpSync(src, dest);
+                const hash = hashFile(dest);
+                managedFiles.push({ path: fileEntry.destination, hash, userModified: false });
+                log.step(`Created ${fileEntry.destination}`);
+            }
+        }
+    }
+    // 4. Apply injections
+    for (const injection of manifest.injections ?? []) {
+        applyInjection(injection, cwd);
+    }
+    // 5. Install npm dependencies
+    const deps = manifest.dependencies ?? {};
+    if ((deps.frontend?.length ?? 0) > 0) {
+        log.step(`npm install ${deps.frontend.join(" ")}`);
+        execSync(`npm install ${deps.frontend.join(" ")}`, { cwd, stdio: "inherit" });
+    }
+    if ((deps.devFrontend?.length ?? 0) > 0) {
+        execSync(`npm install -D ${deps.devFrontend.join(" ")}`, { cwd, stdio: "inherit" });
+    }
+    if ((deps.backend?.length ?? 0) > 0 && existsSync(join(cwd, "server"))) {
+        log.step(`npm install (server) ${deps.backend.join(" ")}`);
+        execSync(`npm install ${deps.backend.join(" ")}`, { cwd: join(cwd, "server"), stdio: "inherit" });
+    }
+    // 6. Write component manifest
+    const compManifest = {
+        name,
+        version: resolvedVersion,
+        template,
+        variant: variant ?? null,
+        installedAt: new Date().toISOString(),
+        managedFiles,
+        injections: manifest.injections ?? [],
+        dependencies: manifest.dependencies ?? {},
+        envVars: manifest.envVars ?? [],
+    };
+    mkdirSync(join(cwd, ".devkit"), { recursive: true });
+    writeFileSync(join(cwd, ".devkit", `${name}.manifest.json`), JSON.stringify(compManifest, null, 2) + "\n");
+    // 7. Update lock file
+    const lock = readLock(cwd);
+    lock.components[name] = {
+        version: resolvedVersion,
+        variant: variant ?? null,
+        resolved: `${REGISTRY_URL}/api/v1/components/${name}/download/${resolvedVersion}/${template}`,
+        installedAt: new Date().toISOString(),
+    };
+    writeLock(lock, cwd);
+    // 8. Print required env vars
+    if ((manifest.envVars?.length ?? 0) > 0) {
+        log.blank();
+        log.warn(`Required env vars for ${name}:`);
+        for (const envVar of manifest.envVars) {
+            log.step(envVar);
+        }
+    }
+    // Cleanup temp dir
+    const { rmSync } = await import("fs");
+    rmSync(tmpDir, { recursive: true, force: true });
+}
+export function removeComponent(name, cwd = process.cwd()) {
+    const manifestPath = join(cwd, ".devkit", `${name}.manifest.json`);
+    if (!existsSync(manifestPath))
+        throw new Error(`Component '${name}' is not installed.`);
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
+    for (const file of manifest.managedFiles ?? []) {
+        if (!file.userModified && existsSync(join(cwd, file.path))) {
+            unlinkSync(join(cwd, file.path));
+            log.step(`Removed ${file.path}`);
+        }
+        else if (file.userModified) {
+            log.warn(`Kept (user-modified): ${file.path}`);
+        }
+    }
+    unlinkSync(manifestPath);
+    const lock = readLock(cwd);
+    delete lock.components[name];
+    writeLock(lock, cwd);
+}
+async function downloadComponentFiles(name, template, version, variant, tmpDir) {
+    mkdirSync(tmpDir, { recursive: true });
+    // For local development with the registry server, we serve files directly.
+    // In production this would stream a tarball. For now we copy from local registry.
+    const registryDir = join(dirname(new URL(import.meta.url).pathname), "../../../registry/components");
+    const major = `v${version.split(".")[0]}`;
+    const compDir = variant
+        ? join(registryDir, name, template, major, "variants", variant)
+        : join(registryDir, name, template, major);
+    if (existsSync(compDir)) {
+        cpSync(compDir, tmpDir, { recursive: true });
+    }
+    else {
+        // Fallback: try to fetch a tarball from registry
+        const qs = new URLSearchParams({ template, version });
+        if (variant)
+            qs.set("variant", variant);
+        const url = `${REGISTRY_URL}/api/v1/components/${name}/download?${qs}`;
+        const res = await fetch(url);
+        if (!res.ok)
+            throw new Error(`Failed to download component ${name}: HTTP ${res.status}`);
+        const tmpTar = join(tmpDir, ".component.tar.gz");
+        const writer = createWriteStream(tmpTar);
+        // @ts-expect-error — Node stream
+        await pipeline(res.body, writer);
+        await extractTar({ file: tmpTar, cwd: tmpDir, strip: 0 });
+        const { unlinkSync } = await import("fs");
+        unlinkSync(tmpTar);
+    }
+}
+function applyInjection(injection, cwd) {
+    const filePath = join(cwd, injection.file);
+    if (!existsSync(filePath)) {
+        log.warn(`Injection target not found: ${injection.file} — add manually`);
+        return;
+    }
+    let content = readFileSync(filePath, "utf-8");
+    // Add import if not present
+    if (injection.importLine && !content.includes(injection.importLine)) {
+        content = injection.importLine + "\n" + content;
+    }
+    // Add route or component line at marker
+    if (injection.marker && injection.routeLine && content.includes(injection.marker)) {
+        content = content.replace(injection.marker, `${injection.marker}\n      ${injection.routeLine}`);
+    }
+    if (injection.marker && injection.componentLine && content.includes(injection.marker)) {
+        content = content.replace(injection.marker, `${injection.marker}\n      ${injection.componentLine}`);
+    }
+    writeFileSync(filePath, content);
+    log.step(`Injected into ${injection.file}`);
+}

package/dist/lib/logger.d.ts

@@ -0,0 +1,10 @@
+export declare const log: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    step: (msg: string) => void;
+    blank: () => void;
+    header: (msg: string) => void;
+    divider: () => void;
+};

package/dist/lib/logger.js

@@ -0,0 +1,15 @@
+import chalk from "chalk";
+export const log = {
+    info: (msg) => console.log(`  ${chalk.cyan("ℹ")}  ${msg}`),
+    success: (msg) => console.log(`  ${chalk.green("✓")}  ${msg}`),
+    warn: (msg) => console.log(`  ${chalk.yellow("⚠")}  ${msg}`),
+    error: (msg) => console.log(`  ${chalk.red("✗")}  ${msg}`),
+    step: (msg) => console.log(`  ${chalk.gray("→")}  ${chalk.dim(msg)}`),
+    blank: () => console.log(),
+    header: (msg) => {
+        console.log();
+        console.log(chalk.bold.white(`  ${msg}`));
+        console.log();
+    },
+    divider: () => console.log(chalk.gray("  " + "─".repeat(56))),
+};

package/dist/lib/registry.d.ts

@@ -0,0 +1,26 @@
+export interface ComponentEntry {
+    name: string;
+    displayName: string;
+    description: string;
+    category: string;
+    templates: string[];
+    platforms: string[];
+    hasVariants: boolean;
+    variants?: {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+    latestVersion: string;
+    tags: string[];
+}
+export declare function listComponents(template?: string): Promise<ComponentEntry[]>;
+export declare function getComponentInfo(name: string): Promise<Record<string, unknown>>;
+export declare function getManifest(name: string, template: string, version?: string, variant?: string): Promise<{
+    name: string;
+    template: string;
+    version: string;
+    variant: string | null;
+    manifest: Record<string, unknown>;
+}>;
+export declare function healthCheck(): Promise<boolean>;

package/dist/lib/registry.js

@@ -0,0 +1,30 @@
+const REGISTRY_URL = process.env.DEVKIT_REGISTRY ?? "https://api.devkit.roboticela.com";
+async function get(path) {
+    const res = await fetch(`${REGISTRY_URL}${path}`);
+    if (!res.ok)
+        throw new Error(`Registry error ${res.status}: ${path}`);
+    return res.json();
+}
+export async function listComponents(template) {
+    const qs = template ? `?template=${template}` : "";
+    const data = await get(`/api/v1/components${qs}`);
+    return data.components;
+}
+export async function getComponentInfo(name) {
+    return get(`/api/v1/components/${name}`);
+}
+export async function getManifest(name, template, version = "latest", variant) {
+    const qs = new URLSearchParams({ template, version });
+    if (variant)
+        qs.set("variant", variant);
+    return get(`/api/v1/components/${name}/manifest?${qs}`);
+}
+export async function healthCheck() {
+    try {
+        await get("/health");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/lib/template.d.ts

@@ -0,0 +1 @@
+export declare function downloadTemplate(templateId: string, destDir: string): Promise<void>;

package/dist/lib/template.js

@@ -0,0 +1,56 @@
+import { createWriteStream, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { pipeline } from "stream/promises";
+import { x as extractTar } from "tar";
+import { execSync } from "child_process";
+const TEMPLATE_REPOS = {
+    "nextjs-compact": "Roboticela/NextJS-Template-DevKit",
+    "vite-express-tauri": "Roboticela/Vite-ExpressJS-Tauri-Template-DevKit",
+};
+export async function downloadTemplate(templateId, destDir) {
+    const repo = TEMPLATE_REPOS[templateId];
+    if (!repo)
+        throw new Error(`Unknown template: ${templateId}`);
+    const tarballUrl = `https://api.github.com/repos/${repo}/tarball/main`;
+    // Try GitHub tarball API first
+    try {
+        await downloadViaTarball(tarballUrl, destDir);
+        return;
+    }
+    catch (e) {
+        console.warn(`  Tarball download failed, falling back to git clone... (${e.message})`);
+    }
+    // Fallback: git clone --depth=1
+    try {
+        await cloneViaGit(`https://github.com/${repo}.git`, destDir);
+    }
+    catch {
+        throw new Error(`Failed to download template '${templateId}'. Check your internet connection.`);
+    }
+}
+async function downloadViaTarball(url, destDir) {
+    const response = await fetch(url, {
+        redirect: "follow",
+        headers: { "User-Agent": "@roboticela/devkit" },
+    });
+    if (!response.ok)
+        throw new Error(`HTTP ${response.status}`);
+    if (!response.body)
+        throw new Error("Empty response body");
+    if (!existsSync(destDir))
+        mkdirSync(destDir, { recursive: true });
+    const tmpTar = join(destDir, ".devkit-template.tar.gz");
+    const writer = createWriteStream(tmpTar);
+    await pipeline(response.body, writer);
+    // Extract, stripping the top-level GitHub-generated folder prefix
+    await extractTar({ file: tmpTar, cwd: destDir, strip: 1 });
+    // Clean up
+    const { unlinkSync } = await import("fs");
+    unlinkSync(tmpTar);
+}
+async function cloneViaGit(repoUrl, destDir) {
+    execSync(`git clone --depth=1 ${repoUrl} "${destDir}"`, { stdio: "inherit" });
+    // Remove .git history so the user starts fresh
+    const { rmSync } = await import("fs");
+    rmSync(join(destDir, ".git"), { recursive: true, force: true });
+}

package/dist/lib/theme.d.ts

@@ -0,0 +1,2 @@
+import { DevKitConfig } from "./config.js";
+export declare function generateThemeCSS(config: DevKitConfig): string;