materialme-cli 0.0.1

package/dist/commands/add.d.ts

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

package/dist/commands/add.js

@@ -0,0 +1,100 @@
+import fs from "fs-extra";
+import path from "path";
+import prompts from "prompts";
+import { fetchRegistryIndex, fetchComponent, getRegistryDependencies } from "../registry/index.js";
+const CONFIG_FILE = "components.json";
+export async function addCommand(componentName) {
+    const projectRoot = process.cwd();
+    const configPath = path.join(projectRoot, CONFIG_FILE);
+    // Load config
+    if (!await fs.pathExists(configPath)) {
+        console.error("Error: components.json not found. Run 'materialme init' first.");
+        return;
+    }
+    const config = await fs.readJSON(configPath);
+    // Fetch registry index
+    let index;
+    try {
+        index = await fetchRegistryIndex(config.registry);
+    }
+    catch (error) {
+        console.error(error);
+        return;
+    }
+    // If no component specified, show available components
+    if (!componentName) {
+        const components = Object.keys(index);
+        if (components.length === 0) {
+            console.log("No components available in registry.");
+            return;
+        }
+        const response = await prompts({
+            type: "multiselect",
+            name: "components",
+            message: "Which components would you like to add?",
+            choices: components.map((name) => ({ title: name, value: name })),
+        });
+        if (!response.components || response.components.length === 0) {
+            return;
+        }
+        for (const name of response.components) {
+            await installComponent(name, index, config, projectRoot);
+        }
+    }
+    else {
+        await installComponent(componentName, index, config, projectRoot);
+    }
+    console.log("\n✓ Done!");
+}
+async function installComponent(name, index, config, projectRoot) {
+    const component = await fetchComponent(name, config.registry);
+    if (!component) {
+        console.error(`Component "${name}" not found in registry.`);
+        return;
+    }
+    console.log(`\nInstalling ${name}...`);
+    // Get all registry dependencies
+    const deps = getRegistryDependencies(component, index);
+    const allComponents = [component, ...deps];
+    // Install npm dependencies
+    if (component.dependencies && component.dependencies.length > 0) {
+        console.log(`Installing npm dependencies: ${component.dependencies.join(", ")}`);
+        const { execSync } = await import("child_process");
+        try {
+            execSync(`npm install ${component.dependencies.join(" ")}`, {
+                stdio: "inherit",
+                cwd: projectRoot,
+            });
+        }
+        catch (error) {
+            console.error("Failed to install dependencies");
+        }
+    }
+    // Create directories and write files
+    for (const comp of allComponents) {
+        for (const file of comp.files) {
+            const targetPath = path.join(projectRoot, file.path);
+            const targetDir = path.dirname(targetPath);
+            await fs.ensureDir(targetDir);
+            if (file.url) {
+                // Fetch from URL
+                try {
+                    const response = await fetch(file.url);
+                    const content = await response.text();
+                    await fs.writeFile(targetPath, content);
+                    console.log(`  ✓ ${file.path}`);
+                }
+                catch (error) {
+                    console.error(`  ✗ Failed to fetch ${file.url}`);
+                }
+            }
+            else if (file.content) {
+                await fs.writeFile(targetPath, file.content);
+                console.log(`  ✓ ${file.path}`);
+            }
+            else {
+                console.log(`  ⚠ ${file.path} (no content)`);
+            }
+        }
+    }
+}

package/dist/commands/init.d.ts

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

package/dist/commands/init.js

@@ -0,0 +1,108 @@
+import fs from "fs-extra";
+import path from "path";
+import prompts from "prompts";
+const DEFAULT_CONFIG = {
+    style: "default",
+    tailwind: {
+        config: "tailwind.config.js",
+        css: "src/app/globals.css",
+        baseColor: "slate",
+    },
+    aliases: {
+        utils: "@/lib/utils",
+        components: "@/components",
+        lib: "@/lib",
+    },
+};
+export async function initCommand() {
+    console.log("Initializing materialme components...\n");
+    const projectRoot = process.cwd();
+    // Check if package.json exists
+    const packageJsonPath = path.join(projectRoot, "package.json");
+    if (!await fs.pathExists(packageJsonPath)) {
+        console.error("Error: package.json not found. Run 'npm init' first.");
+        return;
+    }
+    // Ask for configuration options
+    const response = await prompts([
+        {
+            type: "select",
+            name: "style",
+            message: "Which style would you like to use?",
+            choices: [
+                { title: "Default", value: "default" },
+                { title: "New York", value: "new-york" },
+            ],
+            initial: 0,
+        },
+        {
+            type: "text",
+            name: "componentsDir",
+            message: "Components directory:",
+            initial: "components",
+        },
+        {
+            type: "text",
+            name: "utilsDir",
+            message: "Utils directory:",
+            initial: "lib",
+        },
+        {
+            type: "text",
+            name: "registryUrl",
+            message: "Registry URL (optional):",
+            initial: "",
+        },
+    ]);
+    const config = {
+        style: response.style || "default",
+        tailwind: DEFAULT_CONFIG.tailwind,
+        aliases: {
+            utils: `@/${response.utilsDir || "lib"}/utils`,
+            components: `@/${response.componentsDir || "components"}`,
+            lib: `@/${response.utilsDir || "lib"}`,
+        },
+        registry: response.registryUrl || undefined,
+    };
+    // Create components.json
+    const configPath = path.join(projectRoot, "components.json");
+    await fs.writeJSON(configPath, config, { spaces: 2 });
+    console.log(`✓ Created components.json`);
+    // Create component directories
+    const componentsPath = path.join(projectRoot, response.componentsDir || "components");
+    const utilsPath = path.join(projectRoot, response.utilsDir || "lib");
+    await fs.ensureDir(componentsPath);
+    console.log(`✓ Created components directory: ${componentsPath}`);
+    await fs.ensureDir(utilsPath);
+    console.log(`✓ Created utils directory: ${utilsPath}`);
+    // Create utils.ts if it doesn't exist
+    const utilsFilePath = path.join(utilsPath, "utils.ts");
+    if (!await fs.pathExists(utilsFilePath)) {
+        const utilsContent = `import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(...inputs))
+}
+`;
+        await fs.writeFile(utilsFilePath, utilsContent);
+        console.log(`✓ Created utils.ts`);
+    }
+    // Install dependencies
+    console.log("\nInstalling dependencies...");
+    const { execSync } = await import("child_process");
+    try {
+        execSync("npm install -D tailwind-merge clsx class-variance-authority", {
+            stdio: "inherit",
+            cwd: projectRoot,
+        });
+        console.log("✓ Dependencies installed");
+    }
+    catch (error) {
+        console.error("Failed to install dependencies. Please install manually:");
+        console.error("  npm install -D tailwind-merge clsx class-variance-authority");
+    }
+    console.log("\n✓ Initialization complete!");
+    console.log("\nYou can now add components with:");
+    console.log("  npx materialme add <component-name>");
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { initCommand } from "./commands/init.js";
+import { addCommand } from "./commands/add.js";
+const [, , cmd] = process.argv;
+if (cmd === "init") {
+    initCommand();
+}
+else if (cmd === "add") {
+    addCommand();
+}
+else {
+    console.log("Usage: materialme <init|add>");
+}

package/dist/registry/index.d.ts

@@ -0,0 +1,4 @@
+import { RegistryIndex, RegistryComponent } from "../types.js";
+export declare function fetchRegistryIndex(registryUrl?: string): Promise<RegistryIndex>;
+export declare function fetchComponent(name: string, registryUrl?: string): Promise<RegistryComponent | null>;
+export declare function getRegistryDependencies(component: RegistryComponent, index: RegistryIndex): RegistryComponent[];

package/dist/registry/index.js

@@ -0,0 +1,36 @@
+const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/vladislavkors/materialme/main/registry.json";
+export async function fetchRegistryIndex(registryUrl) {
+    const url = registryUrl || DEFAULT_REGISTRY_URL;
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch registry from ${url}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Could not fetch registry index: ${error.message}`);
+        }
+        throw new Error(`Could not fetch registry index`);
+    }
+}
+export async function fetchComponent(name, registryUrl) {
+    const index = await fetchRegistryIndex(registryUrl);
+    return index[name] || null;
+}
+export function getRegistryDependencies(component, index) {
+    const deps = [];
+    if (!component.registryDependencies) {
+        return deps;
+    }
+    for (const depName of component.registryDependencies) {
+        const dep = index[depName];
+        if (dep) {
+            deps.push(dep);
+            deps.push(...getRegistryDependencies(dep, index));
+        }
+    }
+    return deps;
+}

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+export interface ComponentConfig {
+    style: "default" | "new-york";
+    tailwind: {
+        config: string;
+        css: string;
+        baseColor: string;
+    };
+    aliases: {
+        utils: string;
+        components: string;
+        lib: string;
+    };
+    registry?: string;
+}
+export interface RegistryComponent {
+    name: string;
+    type: "component" | "hook" | "util" | "style";
+    files: RegistryFile[];
+    dependencies?: string[];
+    registryDependencies?: string[];
+}
+export interface RegistryFile {
+    path: string;
+    type: "component" | "util" | "style";
+    content?: string;
+    url?: string;
+}
+export interface RegistryIndex {
+    [name: string]: RegistryComponent;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "materialme-cli",
+  "version": "0.0.1",
+  "description": "Material Me CLI for adding components",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vladislavkors/materialme.git"
+  },
+  "bin": {
+    "materialme": "dist/index.js"
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "fs-extra": "^11.1.1",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.11.0",
+    "@types/prompts": "^2.4.9",
+    "typescript": "^5.3.3"
+  }
+}