gladvn 0.2.22 → 0.2.27

package/bin/cli.js

@@ -16,6 +16,8 @@ if (process.argv.includes('--help') || process.argv.includes('-h')) {
   console.log(`
 Usage:
   npx gladvn init [destination]
+  npx gladvn add <component> [destination]
+  npx gladvn add-block <block> [destination]
 
 Options:
   [destination]   The folder where components will be copied. Defaults to "gladvn".
@@ -26,10 +28,28 @@ Options:
 
 // Find destination
 let userDest = "gladvn";
+let command = "init";
+let componentToAdd = null;
 const args = process.argv.slice(2);
 
 if (args[0] === "init") {
   if (args[1]) userDest = args[1];
+} else if (args[0] === "add") {
+  command = "add";
+  if (!args[1]) {
+    console.error(`\x1b[31m✖ Please specify a component to add (e.g. npx gladvn add button)\x1b[0m`);
+    process.exit(1);
+  }
+  componentToAdd = args[1];
+  if (args[2]) userDest = args[2];
+} else if (args[0] === "add-block") {
+  command = "add-block";
+  if (!args[1]) {
+    console.error(`\x1b[31m✖ Please specify a block to add (e.g. npx gladvn add-block auth)\x1b[0m`);
+    process.exit(1);
+  }
+  componentToAdd = args[1];
+  if (args[2]) userDest = args[2];
 } else if (args[0]) {
   userDest = args[0];
 }
@@ -121,178 +141,287 @@ async function selectOption(message, options) {
   });
 }
 
+async function selectMultipleOptions(message, options) {
+  return new Promise((resolve) => {
+    let selectedIndex = 0;
+    const selected = new Set();
+
+    const render = () => {
+      process.stdout.write('\x1B[?25l');
+      readline.cursorTo(process.stdout, 0);
+      readline.clearScreenDown(process.stdout);
+      
+      console.log(`\x1b[33m?\x1b[0m \x1b[1m${message}\x1b[0m \x1b[90m(Press <space> to select, <enter> to confirm)\x1b[0m`);
+      options.forEach((opt, index) => {
+        const isChecked = selected.has(index);
+        const checkbox = isChecked ? '\x1b[32m◉\x1b[0m' : '\x1b[90m◯\x1b[0m';
+        if (index === selectedIndex) {
+          console.log(`  \x1b[36m❯ ${checkbox} ${opt}\x1b[0m`);
+        } else {
+          console.log(`    ${checkbox} ${opt}`);
+        }
+      });
+      readline.moveCursor(process.stdout, 0, -(options.length + 1));
+    };
+
+    render();
+
+    const onKeyPress = (str, key) => {
+      if (key.name === 'up') {
+        selectedIndex = selectedIndex > 0 ? selectedIndex - 1 : options.length - 1;
+        render();
+      } else if (key.name === 'down') {
+        selectedIndex = selectedIndex < options.length - 1 ? selectedIndex + 1 : 0;
+        render();
+      } else if (key.name === 'space') {
+        if (selected.has(selectedIndex)) {
+          selected.delete(selectedIndex);
+        } else {
+          selected.add(selectedIndex);
+        }
+        render();
+      } else if (key.name === 'return' || key.name === 'enter') {
+        cleanup();
+        const results = Array.from(selected).map(idx => options[idx]);
+        console.log(`\x1b[32m✔\x1b[0m \x1b[1m${message}\x1b[0m \x1b[90m…\x1b[0m \x1b[36m${results.length} selected\x1b[0m`);
+        resolve(results);
+      } else if (key.name === 'c' && key.ctrl) {
+        cleanup();
+        console.log('\n\x1b[31m✖ Cancelled.\x1b[0m');
+        process.exit(1);
+      }
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('keypress', onKeyPress);
+      if (process.stdin.isTTY) process.stdin.setRawMode(false);
+      process.stdin.pause();
+      readline.moveCursor(process.stdout, 0, options.length + 1);
+      process.stdout.write('\x1B[?25h');
+      readline.moveCursor(process.stdout, 0, -(options.length + 1));
+      readline.clearScreenDown(process.stdout);
+    };
+
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('keypress', onKeyPress);
+  });
+}
+
 async function main() {
   console.log(`\n${cyan}╔══════════════════════════════════════════════════════════════════╗${reset}`);
-  console.log(`${cyan}║  ${bold}gladvn${reset}${cyan} — Initialization                                     ║${reset}`);
+  if (command === "add") {
+    console.log(`${cyan}║  ${bold}gladvn${reset}${cyan} — Add Component                                      ║${reset}`);
+  } else if (command === "add-block") {
+    console.log(`${cyan}║  ${bold}gladvn${reset}${cyan} — Add Block                                          ║${reset}`);
+  } else {
+    console.log(`${cyan}║  ${bold}gladvn${reset}${cyan} — Initialization                                     ║${reset}`);
+  }
   console.log(`${cyan}╚══════════════════════════════════════════════════════════════════╝${reset}\n`);
 
-  let targetCss = "app/globals.css";
-  const cssFilesFull = findCssFiles(process.cwd());
-  const cssFiles = cssFilesFull.map(f => path.relative(process.cwd(), f));
-
+  let hasErrors = false;
   const isTTY = process.stdin.isTTY;
 
-  if (cssFiles.length === 0) {
-    console.log(`\x1b[33m⚠ No CSS files found in the project.\x1b[0m`);
+  const componentsDir = path.join(srcDir, 'components');
+  let availableComponents = [];
+  
+  if (fs.existsSync(componentsDir)) {
+    const subDirs = ['micro', 'macro'];
+    for (const sub of subDirs) {
+      const subPath = path.join(componentsDir, sub);
+      if (fs.existsSync(subPath)) {
+        const files = fs.readdirSync(subPath);
+        for (const file of files) {
+          if (file.endsWith('.tsx') || file.endsWith('.ts')) {
+            availableComponents.push(`${sub}/${file}`);
+          }
+        }
+      }
+    }
+  }
+
+  const blocksDir = path.join(srcDir, 'blocks');
+  let availableBlocks = [];
+  
+  if (fs.existsSync(blocksDir)) {
+    const files = fs.readdirSync(blocksDir);
+    for (const file of files) {
+      if (file.endsWith('.tsx') || file.endsWith('.ts')) {
+        availableBlocks.push(file);
+      }
+    }
+  }
+
+  if (command === "add") {
+    console.log(`\x1b[36mAdding ${componentToAdd} to ${userDest}...\x1b[0m`);
+    const compMatches = availableComponents.filter(c => c.endsWith(`/${componentToAdd}.tsx`) || c.endsWith(`/${componentToAdd}.ts`));
+    if (compMatches.length === 0) {
+       console.error(`\x1b[31m✖ Component "${componentToAdd}" not found.\x1b[0m`);
+       process.exit(1);
+    }
     
-    let answer = 'y';
-    if (isTTY) {
-      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-      answer = await new Promise((resolve) => rl.question(`${yellow}? Do you want to create a new app/globals.css file? (Y/n)${reset} `, resolve));
-      rl.close();
+    if (!fs.existsSync(destPath)) {
+      fs.mkdirSync(destPath, { recursive: true });
+    }
+    const comp = compMatches[0];
+    const sourcePath = path.join(componentsDir, comp);
+    const targetPath = path.join(destPath, 'components', comp);
+    const targetDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    try {
+      fs.cpSync(sourcePath, targetPath, { force: true });
+      console.log(`\x1b[32m✔ Added ${comp}\x1b[0m`);
+    } catch (err) {
+      console.error(`\x1b[31m✖ Failed to add ${comp}: ${err.message}\x1b[0m`);
+      hasErrors = true;
+    }
+  } else if (command === "add-block") {
+    console.log(`\x1b[36mAdding block ${componentToAdd} to ${userDest}...\x1b[0m`);
+    const blockMatches = availableBlocks.filter(b => b === `${componentToAdd}.tsx` || b === `${componentToAdd}.ts`);
+    if (blockMatches.length === 0) {
+       console.error(`\x1b[31m✖ Block "${componentToAdd}" not found.\x1b[0m`);
+       process.exit(1);
     }
     
-    if (answer.trim().toLowerCase() !== 'n') {
-      targetCss = "app/globals.css";
-      const newCssPath = path.resolve(process.cwd(), targetCss);
-      if (!fs.existsSync(path.dirname(newCssPath))) {
-        fs.mkdirSync(path.dirname(newCssPath), { recursive: true });
-      }
-      fs.writeFileSync(newCssPath, `@import "tailwindcss";\n`);
-      console.log(`\x1b[32m✔\x1b[0m \x1b[1mCreated\x1b[0m \x1b[36m${targetCss}\x1b[0m`);
-    } else {
-      targetCss = null;
+    if (!fs.existsSync(destPath)) {
+      fs.mkdirSync(destPath, { recursive: true });
+    }
+    const block = blockMatches[0];
+    const sourcePath = path.join(blocksDir, block);
+    const targetPath = path.join(destPath, 'blocks', block);
+    const targetDir = path.dirname(targetPath);
+    if (!fs.existsSync(targetDir)) {
+      fs.mkdirSync(targetDir, { recursive: true });
+    }
+    try {
+      fs.cpSync(sourcePath, targetPath, { force: true });
+      console.log(`\x1b[32m✔ Added block ${block}\x1b[0m`);
+    } catch (err) {
+      console.error(`\x1b[31m✖ Failed to add block ${block}: ${err.message}\x1b[0m`);
+      hasErrors = true;
     }
-  } else if (!isTTY) {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
-    const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
-    const cssFile = await ask(
-      `${yellow}   📄 Path to your main CSS file? ${dim}(default: app/globals.css)${reset}\n   > `
-    );
-    targetCss = cssFile.trim() || "app/globals.css";
-    rl.close();
-  } else if (cssFiles.length === 1) {
-    targetCss = cssFiles[0];
-    console.log(`\x1b[32m✔\x1b[0m \x1b[1mFound global CSS file\x1b[0m \x1b[90m…\x1b[0m \x1b[36m${targetCss}\x1b[0m`);
   } else {
-    // We have more than 1 file, and environment is TTY
-    targetCss = await selectOption("Which CSS file should we inject gladvn styles into?", cssFiles);
-  }
+    // === INIT COMMAND ===
+    let targetCss = "app/globals.css";
+    const cssFilesFull = findCssFiles(process.cwd());
+    const cssFiles = cssFilesFull.map(f => path.relative(process.cwd(), f));
 
-  let cssFilePath = null;
-  if (targetCss) {
-    cssFilePath = path.resolve(process.cwd(), targetCss);
-  }
+    if (cssFiles.length === 0) {
+      console.log(`\x1b[33m⚠ No CSS files found in the project.\x1b[0m`);
+      
+      let answer = 'y';
+      if (isTTY) {
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        answer = await new Promise((resolve) => rl.question(`${yellow}? Do you want to create a new app/globals.css file? (Y/n)${reset} `, resolve));
+        rl.close();
+      }
+      
+      if (answer.trim().toLowerCase() !== 'n') {
+        targetCss = "app/globals.css";
+        const newCssPath = path.resolve(process.cwd(), targetCss);
+        if (!fs.existsSync(path.dirname(newCssPath))) {
+          fs.mkdirSync(path.dirname(newCssPath), { recursive: true });
+        }
+        fs.writeFileSync(newCssPath, `@import "tailwindcss";\n`);
+        console.log(`\x1b[32m✔\x1b[0m \x1b[1mCreated\x1b[0m \x1b[36m${targetCss}\x1b[0m`);
+      } else {
+        targetCss = null;
+      }
+    } else if (!isTTY) {
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      const ask = (question) => new Promise((resolve) => rl.question(question, resolve));
+      const cssFile = await ask(
+        `${yellow}   📄 Path to your main CSS file? ${dim}(default: app/globals.css)${reset}\n   > `
+      );
+      targetCss = cssFile.trim() || "app/globals.css";
+      rl.close();
+    } else if (cssFiles.length === 1) {
+      targetCss = cssFiles[0];
+      console.log(`\x1b[32m✔\x1b[0m \x1b[1mFound global CSS file\x1b[0m \x1b[90m…\x1b[0m \x1b[36m${targetCss}\x1b[0m`);
+    } else {
+      targetCss = await selectOption("Which CSS file should we inject gladvn styles into?", cssFiles);
+    }
 
-  // 1. Copy files
-  let dirsToCopy = [];
-  if (fs.existsSync(srcDir)) {
-    const excludeList = ['dev', 'test', 'vite-env.d.ts'];
-    dirsToCopy = fs.readdirSync(srcDir).filter(item => !excludeList.includes(item));
-  }
+    let cssFilePath = null;
+    if (targetCss) {
+      cssFilePath = path.resolve(process.cwd(), targetCss);
+    }
 
-  console.log(`\n\x1b[36mInitializing gladvn components into ${userDest}...\x1b[0m`);
+    // 1. Copy files
+    console.log(`\n\x1b[36mInitializing gladvn components into ${userDest}...\x1b[0m`);
 
-  if (!fs.existsSync(destPath)) {
-    fs.mkdirSync(destPath, { recursive: true });
-  }
+    if (!fs.existsSync(destPath)) {
+      fs.mkdirSync(destPath, { recursive: true });
+    }
 
-  let hasErrors = false;
+    // Always copy core directories
 
-  for (const dir of dirsToCopy) {
+  const coreDirs = ['hooks', 'lib', 'styles'];
+  for (const dir of coreDirs) {
     const sourcePath = path.join(srcDir, dir);
     const targetPath = path.join(destPath, dir);
-
     if (fs.existsSync(sourcePath)) {
       try {
         fs.cpSync(sourcePath, targetPath, { recursive: true, force: true });
-        console.log(`\x1b[32m✔ Copied ${dir}\x1b[0m`);
       } catch (err) {
-        console.error(`\x1b[31m✖ Failed to copy ${dir}/: ${err.message}\x1b[0m`);
+        console.error(`\x1b[31m✖ Failed to copy core ${dir}/: ${err.message}\x1b[0m`);
         hasErrors = true;
       }
-    } else {
-      console.warn(`\x1b[33m⚠ Source directory src/${dir} not found in package.\x1b[0m`);
     }
   }
+  console.log(`\x1b[32m✔ Copied core files (lib, hooks, styles)\x1b[0m`);
 
-  // 2. Inject CSS import
+  // 2. Inject CSS
   if (cssFilePath && fs.existsSync(cssFilePath)) {
-    const gladvnCssPath = path.resolve(destPath, "styles", "gladvn.css");
-    const tokensCssPath = path.resolve(destPath, "styles", "tokens.css");
-    const cssDir = path.dirname(cssFilePath);
-    
-    let relPath = path.relative(cssDir, gladvnCssPath);
+    const cssContent = fs.readFileSync(cssFilePath, 'utf8');
+    const cssTarget = path.join(destPath, 'styles', 'gladvn.css');
+    let relPath = path.relative(path.dirname(cssFilePath), cssTarget).replace(/\\/g, '/');
     if (!relPath.startsWith('.')) relPath = './' + relPath;
-    relPath = relPath.replace(/\\/g, '/');
-
-    let tokensRelPath = path.relative(cssDir, tokensCssPath);
-    if (!tokensRelPath.startsWith('.')) tokensRelPath = './' + tokensRelPath;
-    tokensRelPath = tokensRelPath.replace(/\\/g, '/');
-
-    let content = fs.readFileSync(cssFilePath, "utf8");
-    
-    if (content.includes(relPath)) {
-      console.log(`\x1b[90m⏭  CSS imports already exist in ${targetCss}\x1b[0m`);
-    } else {
-      const importStatement = `@import "${tokensRelPath}";\n@import "${relPath}";`;
-      
-      const tailwindPattern = /@import\s+["']tailwindcss["'];?\s*\n?/;
-      if (tailwindPattern.test(content)) {
-        content = content.replace(tailwindPattern, (match) => match + importStatement + '\n');
+    const importStmt = `@import "${relPath}";`;
+    if (!cssContent.includes(importStmt) && !cssContent.includes('gladvn.css')) {
+      if (cssContent.includes('@import "tailwindcss";')) {
+        fs.writeFileSync(cssFilePath, cssContent.replace('@import "tailwindcss";', `@import "tailwindcss";\n${importStmt}`));
+      } else if (cssContent.includes('@tailwind base;')) {
+        fs.writeFileSync(cssFilePath, cssContent.replace('@tailwind base;', `@tailwind base;\n${importStmt}`));
       } else {
-        content = importStatement + '\n' + content;
+        fs.writeFileSync(cssFilePath, `${importStmt}\n${cssContent}`);
       }
-      
-      fs.writeFileSync(cssFilePath, content);
-      console.log(`\x1b[32m✔ Injected CSS imports into ${targetCss}\x1b[0m`);
+      console.log(`\x1b[32m✔ Injected gladvn CSS into ${path.basename(cssFilePath)}\x1b[0m`);
     }
-  } else if (targetCss) {
-    console.log(`\x1b[33m⚠ CSS file not found at ${targetCss}. You will need to manually import ${userDest}/styles/gladvn.css\x1b[0m`);
-  } else {
-    console.log(`\x1b[33m⚠ No CSS file configured. You will need to manually import ${userDest}/styles/gladvn.css into your project.\x1b[0m`);
   }
 
-  // 2.5 Configure tsconfig.json
-  if (isTTY) {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    const answer = await new Promise((resolve) => rl.question(`\n${yellow}? Do you want to configure tsconfig.json to use the @gladvn/* alias? (Y/n)${reset} `, resolve));
-    rl.close();
-
-    if (answer.trim().toLowerCase() !== 'n') {
-      const tsconfigPath = path.resolve(process.cwd(), 'tsconfig.json');
-      if (fs.existsSync(tsconfigPath)) {
-        let tsContent = fs.readFileSync(tsconfigPath, 'utf8');
-        const aliasPath = `./${userDest}/*`;
-        const rootAliasPath = `./${userDest}`;
-
-        if (tsContent.includes('"@gladvn/*"')) {
-          if (!tsContent.includes(`"@gladvn":`)) {
-            const aliasRegex = /"@gladvn\/\*"\s*:/;
-            if (aliasRegex.test(tsContent)) {
-              tsContent = tsContent.replace(aliasRegex, `"@gladvn": ["${rootAliasPath}"],\n      "@gladvn/*":`);
-              fs.writeFileSync(tsconfigPath, tsContent);
-              console.log(`\x1b[32m✔ Injected @gladvn alias alongside existing @gladvn/*\x1b[0m`);
-            }
-          } else {
-            console.log(`\x1b[90m⏭  @gladvn aliases already exist in tsconfig.json\x1b[0m`);
-          }
-        } else {
-          const pathsRegex = /"paths"\s*:\s*\{/;
-          if (pathsRegex.test(tsContent)) {
-            tsContent = tsContent.replace(pathsRegex, `"paths": {\n      "@gladvn": ["${rootAliasPath}"],\n      "@gladvn/*": ["${aliasPath}"],`);
-            fs.writeFileSync(tsconfigPath, tsContent);
-            console.log(`\x1b[32m✔ Injected @gladvn alias into existing paths\x1b[0m`);
-          } else {
-            const compilerOptionsRegex = /"compilerOptions"\s*:\s*\{/;
-            if (compilerOptionsRegex.test(tsContent)) {
-              tsContent = tsContent.replace(compilerOptionsRegex, `"compilerOptions": {\n    "paths": {\n      "@gladvn": ["${rootAliasPath}"],\n      "@gladvn/*": ["${aliasPath}"]\n    },`);
-              fs.writeFileSync(tsconfigPath, tsContent);
-              console.log(`\x1b[32m✔ Injected paths object and @gladvn alias\x1b[0m`);
-            } else {
-              console.log(`\x1b[33m⚠ Could not find compilerOptions in tsconfig.json. Please add manually.\x1b[0m`);
-            }
-          }
-        }
-      } else {
-        console.log(`\x1b[33m⚠ tsconfig.json not found. Please configure alias manually if desired.\x1b[0m`);
+  // 3. Configure Path Alias
+  let tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+  if (!fs.existsSync(tsconfigPath)) tsconfigPath = path.join(process.cwd(), 'jsconfig.json');
+  
+  if (fs.existsSync(tsconfigPath)) {
+    let content = fs.readFileSync(tsconfigPath, 'utf8');
+    if (!content.includes('@gladvn/*')) {
+      const pathsEmptyRegex = /"paths"\s*:\s*\{\s*\}/;
+      const compilerOptionsEmptyRegex = /"compilerOptions"\s*:\s*\{\s*\}/;
+
+      if (pathsEmptyRegex.test(content)) {
+        content = content.replace(pathsEmptyRegex, `"paths": {\n      "@gladvn/*": ["./${userDest}/*"]\n    }`);
+      } else if (content.match(/"paths"\s*:\s*\{/)) {
+        content = content.replace(/"paths"\s*:\s*\{/, `"paths": {\n      "@gladvn/*": ["./${userDest}/*"],`);
+      } else if (compilerOptionsEmptyRegex.test(content)) {
+        content = content.replace(compilerOptionsEmptyRegex, `"compilerOptions": {\n    "paths": {\n      "@gladvn/*": ["./${userDest}/*"]\n    }\n  }`);
+      } else if (content.match(/"compilerOptions"\s*:\s*\{/)) {
+        content = content.replace(/"compilerOptions"\s*:\s*\{/, `"compilerOptions": {\n    "paths": {\n      "@gladvn/*": ["./${userDest}/*"]\n    },`);
       }
+      fs.writeFileSync(tsconfigPath, content);
+      console.log(`\x1b[32m✔ Configured path alias @gladvn/* in ${path.basename(tsconfigPath)}\x1b[0m`);
     }
   }
 
+  } // END OF INIT COMMAND
+
   // 3. Install dependencies
   try {
     const pkgPath = path.resolve(__dirname, "../package.json");
@@ -301,27 +430,94 @@ async function main() {
     const depsObj = pkg.dependencies || {};
     
     if (Object.keys(depsObj).length > 0) {
-      const depsToInstall = Object.entries(depsObj).map(([name, version]) => `${name}@"${version}"`);
+      // Scan copied files to determine which dependencies are actually used
+      function findSourceFiles(dir, fileList = []) {
+        if (!fs.existsSync(dir)) return fileList;
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+          const filePath = path.join(dir, file);
+          const stat = fs.statSync(filePath);
+          if (stat.isDirectory()) {
+            findSourceFiles(filePath, fileList);
+          } else if (file.match(/\.(tsx?|jsx?)$/)) {
+            fileList.push(filePath);
+          }
+        }
+        return fileList;
+      }
       
-      let pm = "npm";
-      let installCmd = "install";
+      const sourceFiles = findSourceFiles(destPath);
+      const usedDeps = new Set();
+      const importRegex = /(?:import(?: type)?|from|require)\s*\(?\s*['"]([^'"]+)['"]/g;
       
-      if (fs.existsSync(path.resolve(process.cwd(), "pnpm-lock.yaml"))) {
-        pm = "pnpm";
-        installCmd = "add";
-      } else if (fs.existsSync(path.resolve(process.cwd(), "yarn.lock"))) {
-        pm = "yarn";
-        installCmd = "add";
-      } else if (fs.existsSync(path.resolve(process.cwd(), "bun.lockb"))) {
-        pm = "bun";
-        installCmd = "add";
+      for (const file of sourceFiles) {
+        let content = fs.readFileSync(file, 'utf-8');
+        // Naively strip out comments to prevent false positive imports
+        content = content.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '');
+        let match;
+        while ((match = importRegex.exec(content)) !== null) {
+          const importPath = match[1];
+          // Check if the import path matches any of our dependencies
+          for (const dep of Object.keys(depsObj)) {
+            if (importPath === dep || importPath.startsWith(dep + '/')) {
+              usedDeps.add(dep);
+            }
+          }
+        }
       }
+      
+      if (usedDeps.size > 0) {
+        // Check user's package.json to see what is already installed
+        const userPkgPath = path.resolve(process.cwd(), 'package.json');
+        let userDeps = {};
+        if (fs.existsSync(userPkgPath)) {
+          try {
+            const userPkg = JSON.parse(fs.readFileSync(userPkgPath, 'utf8'));
+            userDeps = { ...userPkg.dependencies, ...userPkg.devDependencies };
+          } catch (e) {}
+        }
 
-      const fullCmd = `${pm} ${installCmd} ${depsToInstall.join(" ")}`;
+        const depsToInstall = [];
+        for (const dep of usedDeps) {
+          if (!userDeps[dep]) {
+            depsToInstall.push(`${dep}@"${depsObj[dep]}"`);
+          }
+        }
       
-      console.log(`\n\x1b[36mInstalling required dependencies using ${pm}...\x1b[0m`);
-      execSync(fullCmd, { stdio: "inherit", cwd: process.cwd() });
-      console.log(`\x1b[32m✔ Dependencies installed successfully!\x1b[0m`);
+        if (depsToInstall.length > 0) {
+          let pm = "npm";
+          let installCmd = "install";
+          
+          function hasLockfile(name) {
+            let dir = process.cwd();
+            while (true) {
+              if (fs.existsSync(path.join(dir, name))) return true;
+              const parent = path.dirname(dir);
+              if (parent === dir) return false;
+              dir = parent;
+            }
+          }
+          
+          if (hasLockfile("pnpm-lock.yaml")) {
+            pm = "pnpm";
+            installCmd = "add";
+          } else if (hasLockfile("yarn.lock")) {
+            pm = "yarn";
+            installCmd = "add";
+          } else if (hasLockfile("bun.lockb")) {
+            pm = "bun";
+            installCmd = "add";
+          }
+
+          const fullCmd = `${pm} ${installCmd} ${depsToInstall.join(" ")}`;
+          
+          console.log(`\n\x1b[36mInstalling missing dependencies using ${pm}...\x1b[0m`);
+          execSync(fullCmd, { stdio: "inherit", cwd: process.cwd() });
+          console.log(`\x1b[32m✔ Dependencies installed successfully!\x1b[0m`);
+        } else {
+          console.log(`\n\x1b[90m⏭  All required dependencies are already installed.\x1b[0m`);
+        }
+      }
     }
   } catch (err) {
     console.error(`\x1b[31m✖ Failed to install dependencies: ${err.message}\x1b[0m`);
@@ -329,7 +525,13 @@ async function main() {
   }
 
   if (!hasErrors) {
-    console.log(`\n\x1b[32m✨ Successfully initialized gladvn files in ${userDest}!\x1b[0m`);
+    if (command === "add") {
+      console.log(`\n\x1b[32m✨ Successfully added ${componentToAdd}!\x1b[0m`);
+    } else if (command === "add-block") {
+      console.log(`\n\x1b[32m✨ Successfully added block ${componentToAdd}!\x1b[0m`);
+    } else {
+      console.log(`\n\x1b[32m✨ Successfully initialized gladvn files in ${userDest}!\x1b[0m`);
+    }
   }
 }
 

package/llms.txt

@@ -3,12 +3,14 @@
 You are an AI Coding Assistant helping a developer use the `gladvn` UI library. 
 `gladvn` is a React component library built on top of Radix UI and Tailwind CSS, focusing on beautiful, accessible, and highly composable components.
 
-Follow these strict guidelines when generating or modifying code that uses `gladvn`:
+### Installation
+- Use `npx gladvn init` to scaffold components into a project.
+- **NEVER** use `npm install gladvn`. The components are copied directly into the project's source code, typically under a `@gladvn/` alias (e.g., `src/gladvn/`).
 
-## 1. Imports
-- **Always** import components directly from the package root:
-  `import { Button, Card, Dialog } from "gladvn";`
-- **Never** import from internal paths like `gladvn/dist/...` or `src/components/ui/...`.
+### Import Guidelines
+- **ALWAYS** import components using the local alias path.
+  - Correct: `import { Button } from "@/gladvn/components/micro/button"` or `import { Button } from "@gladvn/components/micro/button"` (depending on the project's setup).
+  - Incorrect: `import { Button } from "gladvn"`
 
 ## 2. Composition over Configuration
 `gladvn` heavily uses a composable architecture. When building complex UI, always use the provided sub-components rather than passing large configuration objects.