@matchkit.io/cli 0.1.6 → 0.2.0

package/dist/commands/add.d.ts

@@ -1 +1,5 @@
-export declare function addCommand(componentName: string): Promise<void>;
+interface AddOptions {
+    all?: boolean;
+}
+export declare function addCommand(componentNames: string[], options: AddOptions): Promise<void>;
+export {};

package/dist/commands/add.js

@@ -4,75 +4,129 @@ import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readConfig } from "../utils/config.js";
 import { fetchComponent, fetchRegistry, isComponentInstalled, } from "../utils/registry.js";
-export async function addCommand(componentName) {
+export async function addCommand(componentNames, options) {
     const s = p.spinner();
     try {
         const config = readConfig();
-        // 1. Fetch the registry to find the component
-        s.start(`Resolving ${pc.cyan(componentName)}...`);
+        // Fetch the registry
+        s.start("Resolving components...");
         const registry = await fetchRegistry(config);
-        const component = registry.components.find((c) => c.name === componentName);
-        if (!component) {
-            s.stop(`Component ${pc.red(componentName)} not found`);
-            const available = registry.components.map((c) => c.name).join(", ");
-            p.log.error(`Component "${componentName}" not found in the ${config.theme} registry.\n\nAvailable: ${pc.dim(available)}`);
+        // Determine what to install
+        let targets;
+        if (options.all) {
+            targets = registry.components.map((c) => c.name);
+            s.stop(`Found ${pc.cyan(targets.length.toString())} components`);
+        }
+        else if (componentNames.length === 0) {
+            s.stop("No component specified");
+            p.log.error(`Specify component names: ${pc.cyan("matchkit add button card")}\nOr install everything: ${pc.cyan("matchkit add --all")}`);
             process.exit(1);
         }
-        // 2. Check if already installed
-        if (isComponentInstalled(config.skillDir, component.file)) {
-            s.stop(`${pc.yellow(componentName)} already installed`);
-            const overwrite = await p.confirm({
-                message: `${componentName} is already installed. Overwrite?`,
-            });
-            if (p.isCancel(overwrite) || !overwrite) {
-                p.cancel("Cancelled.");
-                process.exit(0);
+        else {
+            // Validate all names exist in registry
+            const available = new Set(registry.components.map((c) => c.name));
+            const invalid = componentNames.filter((n) => !available.has(n));
+            if (invalid.length > 0) {
+                s.stop(`Not found: ${pc.red(invalid.join(", "))}`);
+                p.log.error(`Unknown component(s): ${invalid.join(", ")}\n\nAvailable: ${pc.dim(Array.from(available).join(", "))}`);
+                process.exit(1);
             }
-            s.start(`Fetching ${pc.cyan(componentName)}...`);
+            targets = componentNames;
+            s.stop(`Resolved ${pc.cyan(targets.length.toString())} component(s)`);
         }
-        // 3. Resolve registry dependencies (install those first)
-        const toInstall = [];
-        if (component.registryDependencies.length > 0) {
-            for (const dep of component.registryDependencies) {
-                if (!isComponentInstalled(config.skillDir, `components/${dep}.tsx`)) {
-                    toInstall.push(dep);
-                }
+        // Resolve all registry dependencies
+        const toInstall = new Set();
+        const registryMap = new Map(registry.components.map((c) => [c.name, c]));
+        function addWithDeps(name) {
+            if (toInstall.has(name))
+                return;
+            const comp = registryMap.get(name);
+            if (!comp)
+                return;
+            // Add dependencies first
+            for (const dep of comp.registryDependencies) {
+                addWithDeps(dep);
+            }
+            toInstall.add(name);
+        }
+        for (const name of targets) {
+            addWithDeps(name);
+        }
+        // Check what's already installed (skip unless --all)
+        const alreadyInstalled = [];
+        const needsInstall = [];
+        for (const name of toInstall) {
+            const comp = registryMap.get(name);
+            if (isComponentInstalled(config.skillDir, comp.file)) {
+                alreadyInstalled.push(name);
+            }
+            else {
+                needsInstall.push(name);
             }
         }
-        // 4. Fetch and write the component (and deps)
-        const allComponents = [componentName, ...toInstall];
+        if (!options.all && alreadyInstalled.length > 0 && needsInstall.length === 0) {
+            p.log.info(`All ${alreadyInstalled.length} component(s) already installed. Use ${pc.cyan("matchkit add --all")} to overwrite.`);
+            return;
+        }
+        // For --all, overwrite everything. Otherwise only install missing.
+        const installList = options.all ? Array.from(toInstall) : needsInstall;
+        if (installList.length === 0) {
+            p.log.success("Everything is up to date.");
+            return;
+        }
+        // Fetch and write each component
+        s.start(`Installing ${installList.length} component(s)...`);
         const installed = [];
-        const npmDeps = [...component.dependencies];
-        for (const name of allComponents) {
+        const allNpmDeps = new Set();
+        for (const name of installList) {
             const data = await fetchComponent(config, name);
+            // Write to skill dir
             const targetPath = join(process.cwd(), config.skillDir, `components/${name}.tsx`);
-            // Ensure directory exists
             const dir = dirname(targetPath);
             if (!existsSync(dir)) {
                 mkdirSync(dir, { recursive: true });
             }
             writeFileSync(targetPath, data.source);
             installed.push(name);
-            // Collect npm dependencies
-            for (const d of data.dependencies) {
-                if (!npmDeps.includes(d)) {
-                    npmDeps.push(d);
+            // Also write to output dir if different from skill dir
+            if (config.outputDir) {
+                const outputPath = join(process.cwd(), config.outputDir, `${name}.tsx`);
+                const outputDir = dirname(outputPath);
+                if (!existsSync(outputDir)) {
+                    mkdirSync(outputDir, { recursive: true });
                 }
+                writeFileSync(outputPath, data.source);
+            }
+            for (const d of data.dependencies) {
+                allNpmDeps.add(d);
             }
         }
         s.stop(`Installed ${pc.green(installed.length.toString())} component(s)`);
-        // 5. Summary
-        const lines = [
-            `${pc.cyan("Component:")}  ${componentName} (Layer ${component.layer})`,
-            `${pc.cyan("Path:")}       ${config.skillDir}/components/${componentName}.tsx`,
-        ];
-        if (toInstall.length > 0) {
-            lines.push(`${pc.cyan("Dependencies:")} ${toInstall.map((d) => pc.dim(d)).join(", ")}`);
+        // Summary
+        const lines = [];
+        if (installed.length <= 5) {
+            for (const name of installed) {
+                const comp = registryMap.get(name);
+                lines.push(`  ${pc.green("+")} ${name} ${pc.dim(`(Layer ${comp?.layer ?? "?"})`)}`);
+            }
+        }
+        else {
+            lines.push(`  ${pc.green("+")} ${installed.length} components installed`);
+            lines.push(`  ${pc.dim(installed.slice(0, 5).join(", "))}${installed.length > 5 ? `, +${installed.length - 5} more` : ""}`);
+        }
+        if (alreadyInstalled.length > 0 && !options.all) {
+            lines.push("");
+            lines.push(`  ${pc.dim(`${alreadyInstalled.length} already installed (skipped)`)}`);
+        }
+        lines.push("");
+        lines.push(`${pc.cyan("Skill dir:")}   ${config.skillDir}/components/`);
+        if (config.outputDir) {
+            lines.push(`${pc.cyan("Output dir:")}  ${config.outputDir}/`);
         }
-        if (npmDeps.length > 0) {
+        if (allNpmDeps.size > 0) {
             lines.push("");
-            lines.push(`${pc.yellow("npm dependencies needed:")}`);
-            lines.push(`  npm install ${npmDeps.join(" ")}`);
+            lines.push(`${pc.yellow("npm dependencies:")}`);
+            lines.push(`  npm install ${Array.from(allNpmDeps).join(" ")}`);
         }
         p.note(lines.join("\n"), "Added");
     }

package/dist/commands/diff.js

@@ -1,12 +1,13 @@
-import { existsSync } from "node:fs";
+import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
+import { createHash } from "node:crypto";
 import * as p from "@clack/prompts";
 import pc from "picocolors";
 import { readConfig, configExists } from "../utils/config.js";
-import { fetchRegistry } from "../utils/registry.js";
+import { fetchRegistry, loadLocalHashes } from "../utils/registry.js";
 export async function diffCommand() {
     if (!configExists()) {
-        p.log.error("No .matchkit/config.json found. Run `matchkit init` first.");
+        p.log.error("No matchkit.json found. Run `matchkit init` first.");
         process.exit(1);
     }
     const config = readConfig();
@@ -14,33 +15,75 @@ export async function diffCommand() {
     s.start("Comparing local vs registry...");
     try {
         const registry = await fetchRegistry(config);
-        s.stop("Registry fetched");
-        const results = {
-            missing: [],
-            installed: [],
-        };
+        const remoteHashes = registry.componentHashes ?? {};
+        const localHashes = loadLocalHashes(config.skillDir);
+        const missing = [];
+        const modified = [];
+        const upToDate = [];
         for (const component of registry.components) {
             const localPath = join(process.cwd(), config.skillDir, component.file);
-            if (existsSync(localPath)) {
-                results.installed.push(component);
+            if (!existsSync(localPath)) {
+                missing.push(component);
+                continue;
+            }
+            // Compare via content hashes if available (fast path)
+            const remoteHash = remoteHashes[component.name]?.hash;
+            const localHash = localHashes?.[component.name]?.hash;
+            if (remoteHash && localHash) {
+                // Both have hashes — fast comparison
+                if (remoteHash !== localHash) {
+                    modified.push(component);
+                }
+                else {
+                    upToDate.push(component);
+                }
+            }
+            else if (remoteHash) {
+                // Remote has hash, compute local hash on the fly
+                const localContent = readFileSync(localPath, "utf-8");
+                const computedHash = createHash("sha256").update(localContent).digest("hex").slice(0, 16);
+                if (computedHash !== remoteHash) {
+                    modified.push(component);
+                }
+                else {
+                    upToDate.push(component);
+                }
             }
             else {
-                results.missing.push(component);
+                // No hashes available — treat as up to date (can't compare)
+                upToDate.push(component);
             }
         }
+        s.stop("Comparison complete");
         console.log("");
-        console.log(`  ${pc.cyan(config.theme + "-ui")} · ${results.installed.length} installed, ${results.missing.length} missing`);
+        console.log(`  ${pc.cyan(config.preset + "-ui")} · ${upToDate.length} current, ${modified.length} modified, ${missing.length} missing`);
         console.log("");
-        if (results.missing.length > 0) {
-            console.log(`  ${pc.yellow("Missing components:")}`);
-            for (const c of results.missing) {
+        if (modified.length > 0) {
+            console.log(`  ${pc.yellow("Modified (remote has updates):")}`);
+            for (const c of modified) {
+                console.log(`    ${pc.yellow("~")} ${c.name}`);
+            }
+            console.log("");
+        }
+        if (missing.length > 0) {
+            console.log(`  ${pc.red("Missing (not installed):")}`);
+            for (const c of missing) {
                 console.log(`    ${pc.dim("○")} ${c.name}`);
             }
             console.log("");
-            console.log(`  Run ${pc.cyan("matchkit add <name>")} to install missing components.`);
+        }
+        if (modified.length === 0 && missing.length === 0) {
+            console.log(`  ${pc.green("Everything is up to date.")}`);
         }
         else {
-            console.log(`  ${pc.green("All components are installed.")} Your skill is complete.`);
+            const suggestions = [];
+            if (modified.length > 0) {
+                suggestions.push(`  ${pc.cyan("matchkit update")}              Update modified components`);
+            }
+            if (missing.length > 0) {
+                suggestions.push(`  ${pc.cyan("matchkit add --all")}           Install everything`);
+            }
+            console.log(suggestions.join("\n"));
         }
         console.log("");
     }

package/dist/commands/init.d.ts

@@ -1 +1,4 @@
-export declare function initCommand(): Promise<void>;
+export declare function initCommand(options?: {
+    preset?: string;
+    accent?: string;
+}): Promise<void>;

package/dist/commands/init.js

@@ -1,12 +1,14 @@
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import { configExists, writeConfig, createDefaultConfig } from "../utils/config.js";
+import { configExists, writeConfig, createDefaultConfig, getLegacyConfigPath } from "../utils/config.js";
 import { isAuthenticated, authFetch, API_BASE_URL } from "../utils/auth.js";
-const THEMES = [
-    { value: "clarity", label: "Clarity UI", hint: "Free — Sharp, structured B2B SaaS" },
-    { value: "soft", label: "Soft UI", hint: "Pro — Warm-minimal for AI tools" },
-    { value: "brutal", label: "Brutal UI", hint: "Pro — Neobrutalism — bold, graphic" },
-    { value: "glass", label: "Glass UI", hint: "Pro — Technical, translucent" },
+import { existsSync, unlinkSync, rmSync } from "node:fs";
+import { dirname } from "node:path";
+const PRESETS = [
+    { value: "clarity", label: "Clarity", hint: "Free — Sharp, structured B2B SaaS" },
+    { value: "soft", label: "Soft", hint: "Pro — Warm-minimal for AI tools" },
+    { value: "brutal", label: "Brutal", hint: "Pro — Neobrutalism — bold, graphic" },
+    { value: "glass", label: "Glass", hint: "Pro — Technical, translucent" },
 ];
 const ACCENT_PRESETS = [
     { value: "#4F46E5", label: "Indigo" },
@@ -18,29 +20,54 @@ const ACCENT_PRESETS = [
     { value: "#EC4899", label: "Pink" },
     { value: "custom", label: "Custom hex" },
 ];
-export async function initCommand() {
+export async function initCommand(options) {
+    const nonInteractive = !!options?.preset;
     p.intro(pc.bgCyan(pc.black(" matchkit init ")));
-    if (configExists()) {
+    if (configExists() && !nonInteractive) {
         const shouldOverwrite = await p.confirm({
-            message: "A .matchkit/config.json already exists. Overwrite it?",
+            message: "A matchkit.json already exists. Overwrite it?",
         });
         if (p.isCancel(shouldOverwrite) || !shouldOverwrite) {
             p.cancel("Init cancelled.");
             process.exit(0);
         }
     }
-    // Step 1: Pick theme
-    const theme = await p.select({
-        message: "Pick a theme:",
-        options: THEMES,
+    // Non-interactive: skip prompts when --preset is provided
+    if (nonInteractive) {
+        const presetId = options.preset;
+        const validPresets = PRESETS.map((p) => p.value);
+        if (!validPresets.includes(presetId)) {
+            p.log.error(`Unknown preset: ${pc.red(presetId)}. Valid: ${validPresets.join(", ")}`);
+            process.exit(1);
+        }
+        if (presetId !== "clarity" && !isAuthenticated()) {
+            p.log.warn(`${pc.bold(presetId)} is a premium preset. Run ${pc.bold("matchkit login")} first.`);
+            p.outro(`Or use ${pc.bold("--preset clarity")} (free).`);
+            process.exit(0);
+        }
+        const accent = options.accent ?? (presetId === "clarity" ? "#4F46E5" : "#4F46E5");
+        const config = createDefaultConfig(presetId, accent);
+        writeConfig(config);
+        p.log.success(`Initialized ${pc.bold(presetId + "-ui")} with accent ${pc.cyan(accent)}`);
+        p.log.info(`Config: ${pc.dim("matchkit.json")}`);
+        p.log.info(`Skill dir: ${pc.dim(config.skillDir)}`);
+        p.log.info("");
+        p.log.info(`Next: ${pc.green("matchkit add button")} or ${pc.green("matchkit add --all")}`);
+        p.outro(pc.green("MatchKit initialized!"));
+        return;
+    }
+    // Step 1: Pick preset
+    const preset = await p.select({
+        message: "Pick a preset:",
+        options: PRESETS,
     });
-    if (p.isCancel(theme)) {
+    if (p.isCancel(preset)) {
         p.cancel("Init cancelled.");
         process.exit(0);
     }
-    // Premium themes require authentication
-    if (theme !== "clarity" && !isAuthenticated()) {
-        p.log.warn(`${pc.bold(String(theme))} is a premium theme. Run ${pc.bold("matchkit login")} first.`);
+    // Premium presets require authentication
+    if (preset !== "clarity" && !isAuthenticated()) {
+        p.log.warn(`${pc.bold(String(preset))} is a premium preset. Run ${pc.bold("matchkit login")} first.`);
         p.log.info(`Get your API key at ${pc.cyan("matchkit.io/app/keys")}`);
         p.outro(`Or use ${pc.bold("clarity")} (free) — all 27 components, no account needed.`);
         process.exit(0);
@@ -72,7 +99,7 @@ export async function initCommand() {
     }
     // Step 3: Use default axes or customize
     const useDefaults = await p.confirm({
-        message: "Use default axis settings for this theme?",
+        message: "Use default axis settings for this preset?",
         initialValue: true,
     });
     if (p.isCancel(useDefaults)) {
@@ -125,22 +152,32 @@ export async function initCommand() {
             "spacing-density": density,
         };
     }
-    // Write local config first
-    const config = createDefaultConfig(theme, accent, overrides);
+    // Write config to project root (matchkit.json)
+    const config = createDefaultConfig(preset, accent, overrides);
     writeConfig(config);
+    // Clean up legacy config if it exists
+    const legacyPath = getLegacyConfigPath();
+    if (existsSync(legacyPath)) {
+        unlinkSync(legacyPath);
+        // Remove .matchkit dir if empty
+        try {
+            rmSync(dirname(legacyPath), { recursive: false });
+        }
+        catch { /* not empty, that's fine */ }
+        p.log.info(pc.dim("Migrated .matchkit/config.json → matchkit.json"));
+    }
     // Step 4: Link to a server-side project (premium + authenticated only)
     let linkedConfigId;
-    if (theme !== "clarity" && isAuthenticated()) {
+    if (preset !== "clarity" && isAuthenticated()) {
         const s = p.spinner();
         s.start("Checking your projects...");
         try {
             const res = await authFetch(`${API_BASE_URL}/api/v1/configs`);
             if (res.ok) {
                 const userConfigs = (await res.json());
-                // Filter to configs matching the selected theme
-                const matching = userConfigs.filter((c) => c.theme === theme);
+                const matching = userConfigs.filter((c) => c.theme === preset);
                 s.stop(matching.length > 0
-                    ? `Found ${matching.length} ${theme} project${matching.length > 1 ? "s" : ""}`
+                    ? `Found ${matching.length} ${preset} project${matching.length > 1 ? "s" : ""}`
                     : "No projects found");
                 if (matching.length > 0) {
                     const choice = await p.select({
@@ -163,7 +200,7 @@ export async function initCommand() {
                     }
                 }
                 else {
-                    p.log.info(`No ${pc.bold(String(theme))} projects found. Create one at ${pc.cyan("matchkit.io/app")}`);
+                    p.log.info(`No ${pc.bold(String(preset))} projects found. Create one at ${pc.cyan("matchkit.io/app")}`);
                 }
             }
             else {
@@ -173,7 +210,6 @@ export async function initCommand() {
         catch {
             s.stop("Offline — skipping project linking");
         }
-        // Update config with configId if linked
         if (linkedConfigId) {
             const updatedConfig = { ...config, configId: linkedConfigId };
             writeConfig(updatedConfig);
@@ -182,29 +218,30 @@ export async function initCommand() {
     }
     // Summary
     const summaryLines = [
-        `${pc.cyan("Theme:")}        ${theme}`,
-        `${pc.cyan("Accent:")}       ${accent}`,
-        `${pc.cyan("Overrides:")}    ${Object.keys(overrides).length === 0 ? "defaults" : Object.entries(overrides).map(([k, v]) => `${k}=${v}`).join(", ")}`,
-        `${pc.cyan("Config:")}       .matchkit/config.json`,
-        `${pc.cyan("Skill dir:")}    ${config.skillDir}`,
+        `${pc.cyan("Preset:")}      ${preset}`,
+        `${pc.cyan("Accent:")}      ${accent}`,
+        `${pc.cyan("Overrides:")}   ${Object.keys(overrides).length === 0 ? "defaults" : Object.entries(overrides).map(([k, v]) => `${k}=${v}`).join(", ")}`,
+        `${pc.cyan("Config:")}      matchkit.json`,
+        `${pc.cyan("Skill dir:")}   ${config.skillDir}`,
+        `${pc.cyan("Output dir:")}  ${config.outputDir}`,
     ];
     if (linkedConfigId) {
-        summaryLines.push(`${pc.cyan("Project ID:")}   ${linkedConfigId}`);
+        summaryLines.push(`${pc.cyan("Project ID:")}  ${linkedConfigId}`);
         summaryLines.push("");
         summaryLines.push(`Next steps:`);
         summaryLines.push(`  ${pc.green("matchkit pull")}          Sync your design system`);
-        summaryLines.push(`  ${pc.green("matchkit list")}          See all available components`);
+        summaryLines.push(`  ${pc.green("matchkit add button")}    Add your first component`);
     }
     else {
         summaryLines.push("");
         summaryLines.push(`Next steps:`);
         summaryLines.push(`  ${pc.green("matchkit add button")}    Add your first component`);
-        summaryLines.push(`  ${pc.green("matchkit list")}          See all available components`);
+        summaryLines.push(`  ${pc.green("matchkit add --all")}     Add all 27 components`);
+        summaryLines.push(`  ${pc.green("matchkit list")}          See available components`);
     }
     p.note(summaryLines.join("\n"), "Configuration saved");
-    // Gentle upsell for free users
-    if (theme === "clarity" && !isAuthenticated()) {
-        p.log.info(pc.dim("Unlock 3 more themes + custom axes → ") +
+    if (preset === "clarity" && !isAuthenticated()) {
+        p.log.info(pc.dim("Unlock 3 more presets + custom axes → ") +
             pc.cyan("matchkit.io/configure"));
     }
     p.outro(pc.green("MatchKit initialized!"));

package/dist/commands/list.js

@@ -4,7 +4,7 @@ import { readConfig, configExists } from "../utils/config.js";
 import { loadLocalRegistry, isComponentInstalled, fetchRegistry, } from "../utils/registry.js";
 export async function listCommand() {
     if (!configExists()) {
-        p.log.error("No .matchkit/config.json found. Run `matchkit init` first.");
+        p.log.error("No matchkit.json found. Run `matchkit init` first.");
         process.exit(1);
     }
     const config = readConfig();
@@ -41,7 +41,7 @@ export async function listCommand() {
     };
     const installedCount = components.filter((c) => isComponentInstalled(config.skillDir, c.file)).length;
     console.log("");
-    console.log(`  ${pc.cyan(config.theme + "-ui")} · ${pc.dim(`${installedCount}/${components.length} installed`)}`);
+    console.log(`  ${pc.cyan(config.preset + "-ui")} · ${pc.dim(`${installedCount}/${components.length} installed`)}`);
     console.log("");
     console.log(`  ${pc.bold("Layer 1 — Primitives")} (${layer1.length})`);
     for (const c of layer1) {

package/dist/commands/pull.js

@@ -213,7 +213,7 @@ export async function pullCommand(options) {
                 cs.stop("Project found");
                 const newConfig = createDefaultConfig(data.theme, data.accent ?? "#4F46E5", (data.overrides ?? {}));
                 writeConfig({ ...newConfig, configId: options.configId });
-                p.log.success(`Created .matchkit/config.json for ${pc.bold(data.theme + "-ui")}`);
+                p.log.success(`Created matchkit.json for ${pc.bold(data.theme + "-ui")}`);
             }
             catch {
                 cs.stop("Failed");
@@ -229,7 +229,7 @@ export async function pullCommand(options) {
     }
     // Check config
     if (!configExists()) {
-        p.log.error("No .matchkit/config.json found. Use " +
+        p.log.error("No matchkit.json found. Use " +
             pc.bold("--config-id <id>") +
             " or run " +
             pc.bold("matchkit init") +
@@ -239,7 +239,7 @@ export async function pullCommand(options) {
     const config = readConfig();
     const configId = config.configId;
     if (!configId) {
-        p.log.error("No configId in .matchkit/config.json. Use " +
+        p.log.error("No configId in matchkit.json. Use " +
             pc.bold("matchkit pull --config-id <id>") +
             " to link a project.");
         process.exit(1);
@@ -266,7 +266,7 @@ export async function pullCommand(options) {
             zipBuffer = await pullRes.arrayBuffer();
             buildId = pullRes.headers.get("x-build-id") ?? "unknown";
             version = parseInt(pullRes.headers.get("x-version") ?? "0", 10);
-            theme = pullRes.headers.get("x-theme") ?? config.theme;
+            theme = pullRes.headers.get("x-theme") ?? config.preset;
         }
         else {
             // Server returned JSON with R2 download URL
@@ -317,10 +317,12 @@ export async function pullCommand(options) {
             writeFileSync(fullPath, content);
             fileCount++;
         }
-        // Update local config version
+        // Update local config with pull metadata
         const updatedConfig = {
             ...config,
             configId,
+            buildId,
+            lastPull: new Date().toISOString(),
         };
         writeConfig(updatedConfig);
         s.stop(`Extracted ${fileCount} files`);

package/dist/commands/status.js

@@ -6,16 +6,19 @@ export async function statusCommand() {
     p.intro(pc.bold("matchkit status"));
     // Check config
     if (!configExists()) {
-        p.log.error("No .matchkit/config.json found. Run " +
+        p.log.error("No matchkit.json found. Run " +
             pc.bold("matchkit init") +
             " first.");
         process.exit(1);
     }
     const config = readConfig();
     const configId = config.configId;
-    p.log.info(`Theme:  ${pc.bold(config.theme)}`);
+    p.log.info(`Preset: ${pc.bold(config.preset)}`);
     p.log.info(`Accent: ${pc.bold(config.accent)}`);
     p.log.info(`Dir:    ${pc.dim(config.skillDir)}`);
+    if (config.buildId) {
+        p.log.info(`Build:  ${pc.dim(config.buildId)}`);
+    }
     if (!configId) {
         p.log.warn("No configId — this is a local-only config (free tier).");
         p.outro("Upgrade at " + pc.cyan("matchkit.io/configure") + " for premium themes + CLI sync.");

package/dist/commands/update.d.ts

@@ -0,0 +1 @@
+export declare function updateCommand(componentNames: string[]): Promise<void>;

package/dist/commands/update.js

@@ -0,0 +1,100 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { createHash } from "node:crypto";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { readConfig } from "../utils/config.js";
+import { fetchRegistry, fetchComponent, loadLocalHashes, } from "../utils/registry.js";
+export async function updateCommand(componentNames) {
+    const s = p.spinner();
+    try {
+        const config = readConfig();
+        s.start("Checking for updates...");
+        const registry = await fetchRegistry(config);
+        const registryMap = new Map(registry.components.map((c) => [c.name, c]));
+        const remoteHashes = registry.componentHashes ?? {};
+        const localHashes = loadLocalHashes(config.skillDir);
+        // Determine what to update
+        let targets;
+        if (componentNames.length > 0) {
+            // Update specific components
+            const invalid = componentNames.filter((n) => !registryMap.has(n));
+            if (invalid.length > 0) {
+                s.stop(`Not found: ${pc.red(invalid.join(", "))}`);
+                process.exit(1);
+            }
+            targets = componentNames;
+        }
+        else {
+            // Find all installed components that have changes (via hashes)
+            targets = [];
+            for (const component of registry.components) {
+                const localPath = join(process.cwd(), config.skillDir, component.file);
+                if (!existsSync(localPath))
+                    continue;
+                const remoteHash = remoteHashes[component.name]?.hash;
+                if (!remoteHash)
+                    continue; // Can't compare without remote hash
+                const localHash = localHashes?.[component.name]?.hash;
+                if (localHash && localHash === remoteHash)
+                    continue; // Up to date
+                // No local hash — compute on the fly
+                if (!localHash) {
+                    const localContent = readFileSync(localPath, "utf-8");
+                    const computed = createHash("sha256").update(localContent).digest("hex").slice(0, 16);
+                    if (computed === remoteHash)
+                        continue; // Up to date
+                }
+                targets.push(component.name);
+            }
+        }
+        if (targets.length === 0) {
+            s.stop("Everything is up to date");
+            p.log.success("No updates available.");
+            return;
+        }
+        s.stop(`Found ${targets.length} component(s) to update`);
+        // Confirm update
+        if (componentNames.length === 0) {
+            const confirm = await p.confirm({
+                message: `Update ${targets.length} component(s)? ${pc.dim(targets.join(", "))}`,
+            });
+            if (p.isCancel(confirm) || !confirm) {
+                p.cancel("Update cancelled.");
+                process.exit(0);
+            }
+        }
+        // Fetch and overwrite
+        const updated = [];
+        const s2 = p.spinner();
+        s2.start(`Updating ${targets.length} component(s)...`);
+        for (const name of targets) {
+            const data = await fetchComponent(config, name);
+            const targetPath = join(process.cwd(), config.skillDir, `components/${name}.tsx`);
+            const dir = dirname(targetPath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            writeFileSync(targetPath, data.source);
+            // Also update output dir if configured
+            if (config.outputDir) {
+                const outputPath = join(process.cwd(), config.outputDir, `${name}.tsx`);
+                const outputDir = dirname(outputPath);
+                if (!existsSync(outputDir)) {
+                    mkdirSync(outputDir, { recursive: true });
+                }
+                writeFileSync(outputPath, data.source);
+            }
+            updated.push(name);
+        }
+        s2.stop(`Updated ${pc.green(updated.length.toString())} component(s)`);
+        for (const name of updated) {
+            console.log(`  ${pc.green("~")} ${name}`);
+        }
+        console.log("");
+    }
+    catch (err) {
+        p.log.error(err instanceof Error ? err.message : "An unknown error occurred");
+        process.exit(1);
+    }
+}

package/dist/index.js

@@ -7,6 +7,7 @@ import { initCommand } from "./commands/init.js";
 import { addCommand } from "./commands/add.js";
 import { listCommand } from "./commands/list.js";
 import { diffCommand } from "./commands/diff.js";
+import { updateCommand } from "./commands/update.js";
 import { loginCommand } from "./commands/login.js";
 import { pullCommand } from "./commands/pull.js";
 import { statusCommand } from "./commands/status.js";
@@ -20,11 +21,14 @@ program
 program
     .command("init")
     .description("Initialize a MatchKit design system in your project")
+    .option("-p, --preset <preset>", "Preset name (skip interactive selection)")
+    .option("--accent <color>", "Accent color hex (e.g. #4F46E5)")
     .action(initCommand);
 program
     .command("add")
-    .description("Add a component to your project")
-    .argument("<component>", "Component name (e.g. button, data-table)")
+    .description("Add component(s) to your project")
+    .argument("[components...]", "Component name(s) (e.g. button data-table)")
+    .option("-a, --all", "Install all components")
     .action(addCommand);
 program
     .command("list")
@@ -34,6 +38,11 @@ program
     .command("diff")
     .description("Show changes between local components and the registry")
     .action(diffCommand);
+program
+    .command("update")
+    .description("Update installed component(s) to latest version")
+    .argument("[components...]", "Component name(s) to update (omit for all)")
+    .action(updateCommand);
 program
     .command("login")
     .description("Authenticate with MatchKit (opens browser)")

package/dist/utils/config.d.ts

@@ -1,17 +1,30 @@
 export interface MatchKitConfig {
     $schema?: string;
-    version: string;
-    theme: string;
+    /** Preset/theme id (e.g. "clarity", "soft", "brutal", "glass") */
+    preset: string;
+    /** Accent color hex */
     accent: string;
+    /** Axis overrides from preset defaults */
     overrides: Record<string, string>;
-    componentsDir: string;
+    /** Where to write component TSX files */
+    outputDir: string;
+    /** Where the skill directory lives (SKILL.md, tokens, etc.) */
     skillDir: string;
+    /** Registry API base URL */
     registryUrl: string;
-    /** Server config ID for authenticated pull (premium themes) */
+    /** Server config ID for authenticated pull (premium presets) */
     configId?: string;
+    /** Last pull timestamp (ISO 8601) */
+    lastPull?: string;
+    /** Build ID from last pull/generate */
+    buildId?: string;
 }
 export declare function getConfigPath(cwd?: string): string;
+export declare function getLegacyConfigPath(cwd?: string): string;
 export declare function configExists(cwd?: string): boolean;
+/**
+ * Read config, auto-migrating from legacy format if needed.
+ */
 export declare function readConfig(cwd?: string): MatchKitConfig;
 export declare function writeConfig(config: MatchKitConfig, cwd?: string): void;
-export declare function createDefaultConfig(theme: string, accent: string, overrides?: Record<string, string>): MatchKitConfig;
+export declare function createDefaultConfig(preset: string, accent: string, overrides?: Record<string, string>): MatchKitConfig;

package/dist/utils/config.js

@@ -1,36 +1,65 @@
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
-const CONFIG_FILE = ".matchkit/config.json";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+// New config location (project root, ShadCN-style)
+const CONFIG_FILE = "matchkit.json";
+// Legacy config location
+const LEGACY_CONFIG_FILE = ".matchkit/config.json";
 export function getConfigPath(cwd = process.cwd()) {
     return join(cwd, CONFIG_FILE);
 }
+export function getLegacyConfigPath(cwd = process.cwd()) {
+    return join(cwd, LEGACY_CONFIG_FILE);
+}
 export function configExists(cwd = process.cwd()) {
-    return existsSync(getConfigPath(cwd));
+    return existsSync(getConfigPath(cwd)) || existsSync(getLegacyConfigPath(cwd));
 }
+/**
+ * Read config, auto-migrating from legacy format if needed.
+ */
 export function readConfig(cwd = process.cwd()) {
-    const path = getConfigPath(cwd);
-    if (!existsSync(path)) {
-        throw new Error("No .matchkit/config.json found. Run `matchkit init` first.");
+    const newPath = getConfigPath(cwd);
+    const legacyPath = getLegacyConfigPath(cwd);
+    let raw;
+    if (existsSync(newPath)) {
+        raw = JSON.parse(readFileSync(newPath, "utf-8"));
+    }
+    else if (existsSync(legacyPath)) {
+        raw = JSON.parse(readFileSync(legacyPath, "utf-8"));
+    }
+    else {
+        throw new Error("No matchkit.json found. Run `matchkit init` first.");
     }
-    return JSON.parse(readFileSync(path, "utf-8"));
+    // Auto-migrate legacy fields
+    return migrateLegacyConfig(raw);
+}
+/** Migrate legacy config fields to new format */
+function migrateLegacyConfig(raw) {
+    const legacy = raw;
+    return {
+        $schema: raw.$schema ?? "https://matchkit.io/schemas/config.json",
+        preset: legacy.theme ?? raw.preset ?? "clarity",
+        accent: raw.accent ?? "#4F46E5",
+        overrides: raw.overrides ?? {},
+        outputDir: legacy.componentsDir ?? raw.outputDir ?? "src/components/ui",
+        skillDir: raw.skillDir ?? `.claude/skills/${(legacy.theme ?? raw.preset ?? "clarity")}-ui`,
+        registryUrl: raw.registryUrl ?? "https://www.matchkit.io/api/registry",
+        configId: raw.configId,
+        lastPull: raw.lastPull,
+        buildId: raw.buildId,
+    };
 }
 export function writeConfig(config, cwd = process.cwd()) {
     const path = getConfigPath(cwd);
-    const dir = dirname(path);
-    if (!existsSync(dir)) {
-        mkdirSync(dir, { recursive: true });
-    }
     writeFileSync(path, JSON.stringify(config, null, 2) + "\n");
 }
-export function createDefaultConfig(theme, accent, overrides = {}) {
+export function createDefaultConfig(preset, accent, overrides = {}) {
     return {
         $schema: "https://matchkit.io/schemas/config.json",
-        version: "1.0.0",
-        theme,
+        preset,
         accent,
         overrides,
-        componentsDir: "src/components/ui",
-        skillDir: `.claude/skills/${theme}-ui`,
+        outputDir: "src/components/ui",
+        skillDir: `.claude/skills/${preset}-ui`,
         registryUrl: "https://www.matchkit.io/api/registry",
     };
 }

package/dist/utils/registry.d.ts

@@ -10,13 +10,22 @@ export interface RegistryComponent {
     dependencies: string[];
     registryDependencies: string[];
 }
+/** Per-component content hash for incremental updates */
+export interface ComponentHashEntry {
+    hash: string;
+    file: string;
+}
 export interface RegistryData {
     $schema: string;
     basePath: string;
     components: RegistryComponent[];
+    /** Content hashes per component (for incremental CLI updates) */
+    componentHashes?: Record<string, ComponentHashEntry>;
+    /** Build ID associated with these hashes */
+    buildId?: string;
 }
 /**
- * Fetch the full registry for a theme from the registry API.
+ * Fetch the full registry for a preset from the registry API.
  */
 export declare function fetchRegistry(config: MatchKitConfig): Promise<RegistryData>;
 /**
@@ -31,6 +40,10 @@ export declare function fetchComponent(config: MatchKitConfig, name: string): Pr
  * Load a local registry.json from the skill directory.
  */
 export declare function loadLocalRegistry(skillDir: string): RegistryData | null;
+/**
+ * Load local component hashes from component-hashes.json.
+ */
+export declare function loadLocalHashes(skillDir: string): Record<string, ComponentHashEntry> | null;
 /**
  * Check if a component is installed locally.
  */

package/dist/utils/registry.js

@@ -2,12 +2,11 @@ import { readFileSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { getAuthHeaders } from "./auth.js";
 /**
- * Fetch the full registry for a theme from the registry API.
+ * Fetch the full registry for a preset from the registry API.
  */
 export async function fetchRegistry(config) {
-    const url = `${config.registryUrl}?theme=${encodeURIComponent(config.theme)}`;
-    // Include auth headers for premium themes (clarity is free, no auth needed)
-    const headers = config.theme !== "clarity" ? getAuthHeaders() : {};
+    const url = `${config.registryUrl}?theme=${encodeURIComponent(config.preset)}`;
+    const headers = config.preset !== "clarity" ? getAuthHeaders() : {};
     const res = await fetch(url, { headers });
     if (!res.ok) {
         throw new Error(`Failed to fetch registry: ${res.status} ${res.statusText}`);
@@ -18,8 +17,8 @@ export async function fetchRegistry(config) {
  * Fetch a single component's source code from the registry API.
  */
 export async function fetchComponent(config, name) {
-    const url = `${config.registryUrl}/component?theme=${encodeURIComponent(config.theme)}&name=${encodeURIComponent(name)}`;
-    const headers = config.theme !== "clarity" ? getAuthHeaders() : {};
+    const url = `${config.registryUrl}/component?theme=${encodeURIComponent(config.preset)}&name=${encodeURIComponent(name)}`;
+    const headers = config.preset !== "clarity" ? getAuthHeaders() : {};
     const res = await fetch(url, { headers });
     if (!res.ok) {
         throw new Error(`Failed to fetch component "${name}": ${res.status} ${res.statusText}`);
@@ -41,6 +40,21 @@ export function loadLocalRegistry(skillDir) {
         return null;
     }
 }
+/**
+ * Load local component hashes from component-hashes.json.
+ */
+export function loadLocalHashes(skillDir) {
+    const hashesPath = join(process.cwd(), skillDir, "component-hashes.json");
+    if (!existsSync(hashesPath))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(hashesPath, "utf-8"));
+        return data.components ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Check if a component is installed locally.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matchkit.io/cli",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "CLI for MatchKit design system skills. Init projects, add components, manage your design system.",
   "type": "module",
   "main": "dist/index.js",