composter-cli 1.0.0

package/bin/composter.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../src/index.js' 

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "composter-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "CLI tool to manage and sync React components to your personal component vault",
+  "main": "src/index.js",
+  "bin": {
+    "composter": "./bin/composter.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["react", "components", "cli", "vault", "library", "shadcn"],
+  "author": "binit2-1",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/binit2-1/Composter"
+  },
+  "dependencies": {
+    "commander": "^14.0.2",
+    "dotenv": "^16.4.5",
+    "inquirer": "^13.0.1",
+    "node-fetch": "^3.3.2"
+  }
+}

package/src/commands/listCat.js

@@ -0,0 +1,61 @@
+import { apiRequest } from "../utils/request.js";
+import { loadSession } from "../utils/session.js";
+
+export async function listCategories() {
+  const session = loadSession();
+  if (!session || !session.jwt) {
+    console.log("You must be logged in. Run: composter login");
+    return;
+  }
+
+  try{
+    const res = await apiRequest("/categories", {
+        method: "GET",
+        headers: { "Content-Type": "application/json" },
+    });
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+      // Ignore if no JSON
+    }
+
+    // Handle auth failure
+    if (res.status === 401) {
+      console.log("Session expired. Run composter login again.");
+      return;
+    }
+
+    // Handle server errors
+    if (res.status >= 500) {
+      console.log("Server error. Try again later.");
+      return;
+    }
+
+    // Handle success
+    if (res.ok) {
+      const categories = body?.categories || [];
+      if (categories.length === 0) {
+        console.log("No categories found.");
+        return;
+      }
+      categories.forEach((cat) => {
+        //list them adjacent to each other with tab space between
+        process.stdout.write(`${cat.name}\t\t`);
+      });
+      console.log();
+      return;
+    }
+
+    // Handle other errors
+    const errorMessage =
+      (body && (body.message || body.error || JSON.stringify(body))) ||
+      res.statusText ||
+      `HTTP ${res.status}`;
+    console.log("Error listing categories:", errorMessage);
+    return;
+  } catch (error) {
+    console.log("Error fetching categories:", error);
+    return;
+  }
+}

package/src/commands/login.js

@@ -0,0 +1,71 @@
+import inquirer from "inquirer";
+import fetch from "node-fetch";
+import { saveSession } from "../utils/session.js";
+import dotenv from "dotenv";
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+dotenv.config({ path: join(__dirname, '../../.env') });
+
+const BASE_URL = `${process.env.BASE_URL || "https://composter.onrender.com/api"}/auth`;
+
+export async function login() {
+  console.log("=== Composter Login ===");
+
+  const { email, password } = await inquirer.prompt([
+    { type: "input", name: "email", message: "Email:" },
+    { type: "password", name: "password", message: "Password:" }
+  ]);
+
+  // Step 1 — Sign in
+  const res = await fetch(`${BASE_URL}/sign-in/email`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, password })
+  });
+
+  if (!res.ok) {
+    // try to parse JSON error body, fall back to statusText
+    let errBody = null;
+    try {
+      errBody = await res.json();
+    } catch (e) {
+      // body wasn't JSON or couldn't be parsed
+    }
+    const message =
+      (errBody && (errBody.message || errBody.error || JSON.stringify(errBody))) ||
+      res.statusText ||
+      `HTTP ${res.status}`;
+    console.log("\nLogin failed:", message);
+    return;
+  }
+
+  // Step 2 — Extract session cookie
+  const cookie = res.headers.get("set-cookie");
+  if (!cookie) {
+    console.log("Failed: No session cookie returned.");
+    return;
+  }
+
+  // Step 3 — Fetch JWT token
+  const tokenRes = await fetch(`${BASE_URL}/token`, {
+    method: "GET",
+    headers: { "Cookie": cookie }
+  });
+
+  let token = null;
+  if (tokenRes.ok) {
+    const json = await tokenRes.json();
+    token = json.token;
+  }
+
+  // Step 4 — Save session + jwt locally
+  saveSession({
+    cookies: cookie,
+    jwt: token
+  });
+
+  console.log("\nLogged in successfully!");
+}

package/src/commands/mkcat.js

@@ -0,0 +1,71 @@
+import { apiRequest } from "../utils/request.js";
+import { loadSession } from "../utils/session.js";
+
+export async function mkcat(categoryName) {
+  // Validate input
+  if (
+    !categoryName ||
+    categoryName.trim() === "" ||
+    categoryName.includes(" ") ||
+    categoryName.length > 10
+  ) {
+    console.log(
+      "Invalid category name. It must be non-empty, without spaces, and ≤ 10 characters."
+    );
+    return;
+  }
+
+  // Check session
+  const session = loadSession();
+  if (!session || !session.jwt) {
+    console.log("You must be logged in. Run: composter login");
+    return;
+  }
+
+  try {
+    // Send request
+    const res = await apiRequest("/categories", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: categoryName }),
+    });
+
+    // Parse JSON once
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+      // Ignore if no JSON
+    }
+
+    // Handle auth failure
+    if (res.status === 401) {
+      console.log("Session expired. Run composter login again.");
+      return;
+    }
+
+    // Handle server errors
+    if (res.status >= 500) {
+      console.log("Server error. Try again later.");
+      return;
+    }
+
+    // Handle success
+    if (res.ok) {
+      console.log(`Category '${categoryName}' created successfully!`);
+      console.log("ID:", body?.category?.id);
+      return;
+    }
+
+    // Handle other errors
+    const msg =
+      body?.error ||
+      body?.message ||
+      JSON.stringify(body) ||
+      `HTTP ${res.status}`;
+
+    console.log("Failed to create category:", msg);
+  } catch (err) {
+    console.log("Network or unexpected error:", err.message);
+  }
+}

package/src/commands/pull.js

@@ -0,0 +1,141 @@
+import { apiRequest } from "../utils/request.js";
+import { loadSession } from "../utils/session.js";
+import fs from "fs";
+import path from "path";
+
+export async function pullComponent(category, title, targetDir) { 
+    // 1. Validate Input
+    if (!category?.trim() || !title?.trim() || !targetDir?.trim()) {
+        console.log("❌ Category, title, and target directory are required.");
+        return;
+    }
+ 
+    // 2. Resolve Target Directory
+    // In multi-file mode, the target is usually a FOLDER, not a specific file.
+    const absoluteRoot = path.resolve(targetDir);
+ 
+    // 3. Check Session
+    const session = loadSession();
+    if (!session || !session.jwt) {
+        console.log("❌ You must be logged in. Run: composter login");
+        return;
+    }
+ 
+    try {
+        console.log(`⏳ Fetching '${title}' from '${category}'...`);
+
+        const res = await apiRequest(`/components?category=${encodeURIComponent(category)}&title=${encodeURIComponent(title)}`, {
+            method: "GET",
+            headers: { "Content-Type": "application/json" },
+        });
+
+        // Parse Body
+        let body = null;
+        try { body = await res.json(); } catch {}
+
+        if (res.status === 401) {
+            console.log("❌ Session expired. Run composter login again.");
+            return;
+        }
+        if (res.status === 404) {
+            console.log(`❌ Component '${title}' not found.`);
+            return;
+        }
+        if (!res.ok) {
+            console.log("❌ Server error:", body?.error || res.statusText);
+            return;
+        }
+
+        const component = body.component;
+
+        // --- STEP 4: PARSE FILES (Handle JSON vs String) ---
+        let filesMap = {};
+        try {
+            // Try to parse new multi-file format
+            filesMap = JSON.parse(component.code);
+        } catch (e) {
+            // Fallback for old single-file components
+            // We'll create a default filename based on the title
+            let fileName = `${title}.jsx`; 
+            // If the user pointed to a specific file (e.g. ./src/Button.js), use that name
+            if (path.extname(absoluteRoot)) {
+                fileName = path.basename(absoluteRoot);
+            }
+            filesMap[`/${fileName}`] = component.code;
+        }
+
+        // --- STEP 5: WRITE FILES TO DISK ---
+        console.log(`📦 Unpacking ${Object.keys(filesMap).length} file(s) into: ${absoluteRoot}`);
+
+        // Ensure the root target folder exists
+        if (!fs.existsSync(absoluteRoot)) {
+            fs.mkdirSync(absoluteRoot, { recursive: true });
+        }
+
+        const createdFiles = [];
+
+        for (const [virtualPath, content] of Object.entries(filesMap)) {
+            // Remove leading slash (e.g. "/ui/Button.tsx" -> "ui/Button.tsx")
+            const relPath = virtualPath.startsWith('/') ? virtualPath.slice(1) : virtualPath;
+            
+            // Construct full system path
+            const writePath = path.join(absoluteRoot, relPath);
+            const writeDir = path.dirname(writePath);
+
+            // Create sub-folders if needed
+            if (!fs.existsSync(writeDir)) {
+                fs.mkdirSync(writeDir, { recursive: true });
+            }
+
+            // Write file
+            fs.writeFileSync(writePath, content, "utf-8");
+            createdFiles.push(relPath);
+            console.log(`   + ${relPath}`);
+        }
+
+        // --- STEP 6: CHECK DEPENDENCIES ---
+        if (component.dependencies && Object.keys(component.dependencies).length > 0) {
+            checkDependencies(component.dependencies);
+        }
+
+        console.log(`\n✅ Component '${title}' pulled successfully!`);
+
+    } catch (err) {
+        console.log("❌ Error pulling component:", err);
+    }
+}
+
+/**
+ * Helper to check local package.json against required dependencies
+ */
+function checkDependencies(requiredDeps) {
+    const localPkgPath = path.resolve(process.cwd(), "package.json");
+    
+    // If no package.json, we can't check, so just list them all
+    if (!fs.existsSync(localPkgPath)) {
+        console.log("\n⚠️  This component requires these packages:");
+        Object.entries(requiredDeps).forEach(([pkg, ver]) => console.log(`   - ${pkg}@${ver}`));
+        return;
+    }
+
+    try {
+        const localPkg = JSON.parse(fs.readFileSync(localPkgPath, "utf-8"));
+        const installed = { ...localPkg.dependencies, ...localPkg.devDependencies };
+        const missing = [];
+
+        for (const [pkg, version] of Object.entries(requiredDeps)) {
+            if (!installed[pkg]) {
+                missing.push(`${pkg}@${version}`);
+            }
+        }
+
+        if (missing.length > 0) {
+            console.log("\n⚠️  Missing Dependencies (Run this to fix):");
+            console.log(`   npm install ${missing.map(d => d.split('@')[0]).join(" ")}`);
+        } else {
+            console.log("\n✨ All dependencies are already installed.");
+        }
+    } catch (e) {
+        // Ignore JSON parse errors
+    }
+}

package/src/commands/push.js

@@ -0,0 +1,73 @@
+import { apiRequest } from "../utils/request.js";
+import { loadSession } from "../utils/session.js";
+import fs from "fs";
+import path from "path";
+// IMPORT THE NEW SPIDER
+import { scanComponent } from "../utils/crawler.js"; 
+
+export async function pushComponent(category, title, filepath) { 
+    // 1. Validate Input
+    if (!category?.trim() || !title?.trim() || !filepath?.trim()) {
+        console.log("❌ Category, title, and filepath are required.");
+        return;
+    }
+
+    // 2. Validate Entry File
+    const absolutePath = path.resolve(filepath);
+    if (!fs.existsSync(absolutePath)) {
+        console.log(`❌ File not found: ${absolutePath}`);
+        return;
+    }
+
+    // 3. Check Session
+    const session = loadSession();
+    if (!session || !session.jwt) {
+        console.log("❌ You must be logged in. Run: composter login");
+        return;
+    }
+
+    // 4. RUN THE CRAWLER
+    console.log(`Scanning ${path.basename(absolutePath)} and its dependencies...`);
+    
+    const { files, dependencies } = scanComponent(absolutePath);
+    
+    const fileCount = Object.keys(files).length;
+    const depCount = Object.keys(dependencies).length;
+
+    console.log(`📦 Bundled ${fileCount} file(s) and detected ${depCount} external package(s).`);
+
+    try {
+        // 5. Send Request
+        // We send 'files' as a JSON string because your DB 'code' column is a String.
+        const res = await apiRequest("/components", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ 
+                title, 
+                category,
+                code: JSON.stringify(files), 
+                dependencies: dependencies   
+            }),
+        });
+
+        // 6. Handle Response
+        let body = null;
+        try { body = await res.json(); } catch {}
+
+        if (res.status === 401) {
+            console.log("❌ Session expired. Run composter login again.");
+            return;
+        }
+
+        if (res.ok) {
+            console.log(`✅ Success! Component '${title}' pushed to '${category}'.`);
+            return;
+        }
+
+        const errorMessage = body?.message || body?.error || res.statusText;
+        console.log("❌ Error pushing component:", errorMessage);
+
+    } catch (error) {
+        console.log("❌ Network Error:", error.message);
+    }
+}

package/src/index.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { login } from "./commands/login.js";
+import { mkcat } from "./commands/mkcat.js";
+import { listCategories } from "./commands/listCat.js";
+import { pushComponent } from "./commands/push.js";
+import { pullComponent } from "./commands/pull.js";
+
+const program = new Command();
+
+program
+  .name("composter")
+  .description("CLI for Composter Platform")
+  .version("0.1.0");
+
+program
+  .command("login")
+  .description("Log into your Composter account")
+  .action(login);
+
+program
+  .command("mkcat <category-name>")
+  .description("Create a new category")
+  .action((categoryName) => mkcat(categoryName));
+
+program 
+  .command("ls")
+  .description("List categories")
+  .action(() => {
+    listCategories();
+  });
+
+program
+  .command("push <category-name> <component-title> <file-path>")
+  .description("Push a new component")
+  .action((category, title, filepath) => {
+    pushComponent(category, title, filepath);
+  });
+
+program
+  .command("pull <category-name> <component-title> <file-path>")
+  .description("Pull a component")
+  .action((category, title, filepath) => {
+    pullComponent(category, title, filepath);
+  });
+
+program.parse(process.argv);

package/src/utils/crawler.js

@@ -0,0 +1,129 @@
+import fs from "fs";
+import path from "path";
+
+const IMPORT_REGEX = /(?:import|export)\s+(?:[\w*\s{},]*\s+from\s+)?['"]([^'"]+)['"]/g;
+
+// Helper: Find the nearest package.json starting from a file's directory
+function findPackageRoot(startDir) {
+  let current = startDir;
+  const root = path.parse(current).root;
+
+  while (current !== root) {
+    if (fs.existsSync(path.join(current, "package.json"))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  // Fallback: If no package.json, use the directory of the entry file itself
+  return startDir;
+}
+
+export function scanComponent(entryFilePath) {
+  const absoluteEntry = path.resolve(entryFilePath);
+  
+  // FIX: Anchor the root to the package.json folder
+  // This ensures paths are like "src/Button.jsx", not "frontend/src/Button.jsx"
+  const projectRoot = findPackageRoot(path.dirname(absoluteEntry));
+  
+  const filesMap = {};       
+  const npmDependencies = {}; 
+  const processed = new Set();
+  const queue = [absoluteEntry];
+
+  // Load package.json for versions
+  const localPkgPath = path.join(projectRoot, "package.json");
+  let localPkg = { dependencies: {}, devDependencies: {} };
+  try {
+    if (fs.existsSync(localPkgPath)) {
+      localPkg = JSON.parse(fs.readFileSync(localPkgPath, "utf-8"));
+    }
+  } catch (e) {}
+
+  while (queue.length > 0) {
+    const fullPath = queue.shift();
+    if (processed.has(fullPath)) continue;
+    
+    if (!fs.existsSync(fullPath)) {
+      console.warn(`⚠️  Warning: File not found: ${fullPath}`);
+      continue;
+    }
+
+    const content = fs.readFileSync(fullPath, "utf-8");
+    processed.add(fullPath);
+
+    // --- CLEAN PATH GENERATION ---
+    // Calculate path relative to the PROJECT ROOT (package.json location)
+    let relativePath = path.relative(projectRoot, fullPath);
+    
+    // Normalize slashes for Sandpack
+    relativePath = relativePath.split(path.sep).join("/");
+
+    // SANITY CHECK: If path still starts with "..", force it into a virtual root
+    // This handles cases where you import a file OUTSIDE your project root
+    if (relativePath.startsWith("..")) {
+        // Strip the dots: "../external/File.js" -> "/_external/File.js"
+        relativePath = relativePath.replace(/^(\.\.\/)+/, "_external/");
+    }
+
+    const virtualPath = `/${relativePath}`; 
+    filesMap[virtualPath] = content;
+
+    // --- SCAN IMPORTS ---
+    let match;
+    IMPORT_REGEX.lastIndex = 0; 
+    while ((match = IMPORT_REGEX.exec(content)) !== null) {
+        const importPath = match[1];
+
+        if (importPath.startsWith(".")) {
+            // CASE A: Relative Import (e.g. "./button")
+            const currentFileDir = path.dirname(fullPath);
+            const resolvedPath = resolveLocalImport(currentFileDir, importPath);
+            if (resolvedPath && !processed.has(resolvedPath)) {
+                queue.push(resolvedPath);
+            }
+        } else if (importPath.startsWith("@/")) {
+            // CASE B: Alias Import (e.g. "@/components/ui/button")
+            // We assume "@/" maps to "<projectRoot>/src/" (Standard Shadcn/Vite convention)
+            const pathInsideSrc = importPath.slice(2); // Remove "@/"
+            const srcDir = path.join(projectRoot, "src");
+            
+            const resolvedPath = resolveLocalImport(srcDir, pathInsideSrc);
+            if (resolvedPath && !processed.has(resolvedPath)) {
+                queue.push(resolvedPath);
+            }
+        } else {
+            // CASE C: External Package (e.g. "lucide-react")
+             const pkgName = getPackageName(importPath);
+             const version = 
+               localPkg.dependencies?.[pkgName] || 
+               localPkg.devDependencies?.[pkgName] || 
+               "latest";
+             npmDependencies[pkgName] = version;
+        }
+    }
+  }
+
+  return { files: filesMap, dependencies: npmDependencies };
+}
+
+function resolveLocalImport(dir, importPath) {
+  const extensions = [".tsx", ".ts", ".jsx", ".js", ".css"];
+  const base = path.join(dir, importPath);
+  if (fs.existsSync(base) && fs.statSync(base).isFile()) return base;
+  for (const ext of extensions) {
+    if (fs.existsSync(base + ext)) return base + ext;
+  }
+  for (const ext of extensions) {
+    const indexPath = path.join(base, `index${ext}`);
+    if (fs.existsSync(indexPath)) return indexPath;
+  }
+  return null;
+}
+
+function getPackageName(importPath) {
+  if (importPath.startsWith("@")) {
+    const parts = importPath.split("/");
+    return `${parts[0]}/${parts[1]}`;
+  }
+  return importPath.split("/")[0];
+}

package/src/utils/paths.js

@@ -0,0 +1,13 @@
+import os from "os";
+import path from "path";
+import fs from "fs";
+
+export const CONFIG_DIR = path.join(os.homedir(), ".config", "composter");
+
+export function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+export const SESSION_PATH = path.join(CONFIG_DIR, "session.json");

package/src/utils/request.js

@@ -0,0 +1,22 @@
+import fetch from "node-fetch";
+import { loadSession } from "./session.js";
+import dotenv from "dotenv";
+dotenv.config({ silent: true });
+
+const BASE_URL = process.env.BASE_URL || "https://composter.onrender.com/api";
+
+export async function apiRequest(path, options = {}) {
+  const session = loadSession();
+  const headers = options.headers || {};
+
+  if (session?.jwt) {
+    headers["Authorization"] = `Bearer ${session.jwt}`;
+  }
+
+  const res = await fetch(`${BASE_URL}${path}`, {
+    ...options,
+    headers,
+  });
+
+  return res;
+}

package/src/utils/session.js

@@ -0,0 +1,16 @@
+import fs from "fs";
+import { SESSION_PATH, ensureConfigDir } from "./paths.js";
+
+export function saveSession(sessionData) {
+  ensureConfigDir();
+  fs.writeFileSync(SESSION_PATH, JSON.stringify(sessionData, null, 2), "utf-8");
+}
+
+export function loadSession() {
+  if (!fs.existsSync(SESSION_PATH)) return null;
+  return JSON.parse(fs.readFileSync(SESSION_PATH, "utf-8"));
+}
+
+export function clearSession() {
+  if (fs.existsSync(SESSION_PATH)) fs.unlinkSync(SESSION_PATH);
+}