code-brick 0.1.0

package/dist/index.js

@@ -0,0 +1,1830 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import pc13 from "picocolors";
+
+// src/commands/init.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+
+// src/lib/storage.ts
+import fs from "fs-extra";
+import path from "path";
+import os from "os";
+var CODEBRICK_DIR = path.join(os.homedir(), ".codebrick");
+var CONFIG_FILE = path.join(CODEBRICK_DIR, "config.json");
+var STORE_FILE = path.join(CODEBRICK_DIR, "store.json");
+var TEMPLATES_DIR = path.join(CODEBRICK_DIR, "templates");
+async function isInitialized() {
+  return fs.pathExists(CODEBRICK_DIR);
+}
+async function initializeStorage() {
+  await fs.ensureDir(CODEBRICK_DIR);
+  await fs.ensureDir(TEMPLATES_DIR);
+  if (!await fs.pathExists(CONFIG_FILE)) {
+    const defaultConfig = {
+      defaultRef: "main"
+    };
+    await fs.writeJson(CONFIG_FILE, defaultConfig, { spaces: 2 });
+  }
+  if (!await fs.pathExists(STORE_FILE)) {
+    const defaultStore = {
+      version: "1.0",
+      templates: {}
+    };
+    await fs.writeJson(STORE_FILE, defaultStore, { spaces: 2 });
+  }
+}
+async function loadStore() {
+  if (!await fs.pathExists(STORE_FILE)) {
+    return { version: "1.0", templates: {} };
+  }
+  return fs.readJson(STORE_FILE);
+}
+async function saveStore(store) {
+  await fs.writeJson(STORE_FILE, store, { spaces: 2 });
+}
+function getTemplatePath(name) {
+  return path.join(TEMPLATES_DIR, name);
+}
+function getTemplateMetadataPath(name) {
+  return path.join(getTemplatePath(name), "brick.json");
+}
+async function loadTemplateMetadata(name) {
+  const metadataPath = getTemplateMetadataPath(name);
+  if (!await fs.pathExists(metadataPath)) {
+    return null;
+  }
+  return fs.readJson(metadataPath);
+}
+async function saveTemplateMetadata(name, metadata) {
+  const metadataPath = getTemplateMetadataPath(name);
+  await fs.writeJson(metadataPath, metadata, { spaces: 2 });
+}
+async function templateExists(name) {
+  const store = await loadStore();
+  return name in store.templates;
+}
+async function getTemplate(name) {
+  const store = await loadStore();
+  return store.templates[name] || null;
+}
+async function addTemplateToStore(name, template) {
+  const store = await loadStore();
+  store.templates[name] = template;
+  await saveStore(store);
+}
+async function removeTemplateFromStore(name) {
+  const store = await loadStore();
+  delete store.templates[name];
+  await saveStore(store);
+}
+async function deleteTemplateFiles(name) {
+  const templatePath = getTemplatePath(name);
+  if (await fs.pathExists(templatePath)) {
+    await fs.remove(templatePath);
+  }
+}
+async function resolveTemplateName(nameOrIndex) {
+  const store = await loadStore();
+  const names = Object.keys(store.templates);
+  const index = parseInt(nameOrIndex, 10);
+  if (!isNaN(index) && index >= 0 && index < names.length) {
+    return names[index];
+  }
+  if (nameOrIndex in store.templates) {
+    return nameOrIndex;
+  }
+  return null;
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  p.intro(pc.cyan("\u{1F9F1} CodeBrick"));
+  const alreadyInitialized = await isInitialized();
+  if (alreadyInitialized) {
+    p.log.warn("CodeBrick is already initialized!");
+    p.log.info(`Storage location: ${pc.dim(CODEBRICK_DIR)}`);
+    p.outro("Run " + pc.cyan("brick list") + " to see your templates");
+    return;
+  }
+  const spinner8 = p.spinner();
+  spinner8.start("Initializing CodeBrick...");
+  try {
+    await initializeStorage();
+    spinner8.stop("CodeBrick initialized successfully!");
+    console.log();
+    console.log(`  Storage location: ${pc.dim(CODEBRICK_DIR)}`);
+    console.log();
+    console.log(pc.bold("  Quick Start:"));
+    console.log(
+      `    ${pc.cyan("brick save")} my-auth ./src/auth    Save a template`
+    );
+    console.log(
+      `    ${pc.cyan("brick list")}                       View all templates`
+    );
+    console.log(
+      `    ${pc.cyan("brick apply")} my-auth              Apply to current project`
+    );
+    console.log();
+    p.outro("Happy templating! \u{1F389}");
+  } catch (error) {
+    spinner8.stop("Failed to initialize CodeBrick");
+    p.log.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/save.ts
+import * as p2 from "@clack/prompts";
+import pc3 from "picocolors";
+import fs3 from "fs-extra";
+import path3 from "path";
+import fg from "fast-glob";
+
+// src/lib/utils.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import pc2 from "picocolors";
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+  // Node.js / JavaScript
+  "node_modules",
+  ".npm",
+  ".pnpm-store",
+  ".yarn",
+  ".pnp",
+  "bower_components",
+  // Flutter / Dart
+  ".dart_tool",
+  ".pub-cache",
+  ".pub",
+  "build",
+  // Python
+  "__pycache__",
+  ".venv",
+  "venv",
+  "env",
+  ".env",
+  ".eggs",
+  "*.egg-info",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".tox",
+  ".nox",
+  "site-packages",
+  // Go
+  "vendor",
+  // Rust
+  "target",
+  // Java / Kotlin / Android
+  ".gradle",
+  ".idea",
+  "out",
+  ".cxx",
+  // Ruby
+  ".bundle",
+  // PHP
+  "vendor",
+  // .NET / C#
+  "bin",
+  "obj",
+  "packages",
+  // iOS / macOS
+  "Pods",
+  ".symlinks",
+  "DerivedData",
+  // General build outputs
+  "dist",
+  "build",
+  "out",
+  "output",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".vercel",
+  ".netlify",
+  // Caches
+  ".cache",
+  ".parcel-cache",
+  ".turbo",
+  ".temp",
+  ".tmp",
+  "tmp",
+  "temp",
+  "coverage",
+  ".nyc_output",
+  // Version control
+  ".git",
+  ".svn",
+  ".hg",
+  // IDE / Editor
+  ".vscode",
+  ".idea",
+  ".vs",
+  ".settings",
+  "*.swp",
+  "*.swo"
+]);
+var IGNORED_FILES = /* @__PURE__ */ new Set([
+  ".DS_Store",
+  "Thumbs.db",
+  ".gitignore",
+  ".gitattributes",
+  ".editorconfig",
+  "brick.json",
+  ".env",
+  ".env.local",
+  ".env.development",
+  ".env.production",
+  "*.log",
+  "npm-debug.log",
+  "yarn-error.log",
+  ".flutter-plugins",
+  ".flutter-plugins-dependencies",
+  ".packages",
+  "pubspec.lock",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  "Podfile.lock",
+  "Gemfile.lock",
+  "poetry.lock",
+  "Cargo.lock",
+  "go.sum"
+]);
+function shouldIgnoreDirectory(name) {
+  if (name.startsWith(".")) {
+    return true;
+  }
+  return IGNORED_DIRECTORIES.has(name);
+}
+function shouldIgnoreFile(name) {
+  if (name.startsWith(".")) {
+    return true;
+  }
+  if (IGNORED_FILES.has(name)) {
+    return true;
+  }
+  for (const pattern of IGNORED_FILES) {
+    if (pattern.startsWith("*")) {
+      const ext = pattern.slice(1);
+      if (name.endsWith(ext)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function formatSize(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function formatDate(dateString) {
+  const date = new Date(dateString);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+async function getFilesRecursive(dir, baseDir = dir) {
+  const files = [];
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    const relativePath = path2.relative(baseDir, fullPath);
+    if (entry.isDirectory()) {
+      if (shouldIgnoreDirectory(entry.name)) {
+        continue;
+      }
+      const subFiles = await getFilesRecursive(fullPath, baseDir);
+      files.push(...subFiles);
+    } else {
+      if (!shouldIgnoreFile(entry.name)) {
+        files.push(relativePath);
+      }
+    }
+  }
+  return files.sort();
+}
+async function getDirectoryStats(dir) {
+  let files = 0;
+  let directories = 0;
+  let totalSize = 0;
+  const processDir = async (currentDir) => {
+    const entries = await fs2.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!shouldIgnoreDirectory(entry.name)) {
+          directories++;
+          await processDir(fullPath);
+        }
+      } else {
+        if (!shouldIgnoreFile(entry.name)) {
+          files++;
+          const stat = await fs2.stat(fullPath);
+          totalSize += stat.size;
+        }
+      }
+    }
+  };
+  await processDir(dir);
+  return { files, directories, totalSize };
+}
+async function buildTree(dir, includeSize = false) {
+  const entries = await fs2.readdir(dir, { withFileTypes: true });
+  const nodes = [];
+  const sortedEntries = entries.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (const entry of sortedEntries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (shouldIgnoreDirectory(entry.name)) continue;
+      const children = await buildTree(fullPath, includeSize);
+      nodes.push({
+        name: entry.name,
+        type: "directory",
+        children
+      });
+    } else {
+      if (shouldIgnoreFile(entry.name)) continue;
+      const node = {
+        name: entry.name,
+        type: "file"
+      };
+      if (includeSize) {
+        const stat = await fs2.stat(fullPath);
+        node.size = stat.size;
+      }
+      nodes.push(node);
+    }
+  }
+  return nodes;
+}
+function renderTree(nodes, prefix = "", isLast = true, showSize = false) {
+  let output = "";
+  nodes.forEach((node, index) => {
+    const isLastNode = index === nodes.length - 1;
+    const connector = isLastNode ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const sizeStr = showSize && node.size !== void 0 ? pc2.dim(` (${formatSize(node.size)})`) : "";
+    if (node.type === "directory") {
+      output += `${prefix}${connector}${pc2.blue(node.name)}/
+`;
+      if (node.children && node.children.length > 0) {
+        const newPrefix = prefix + (isLastNode ? "    " : "\u2502   ");
+        output += renderTree(node.children, newPrefix, isLastNode, showSize);
+      }
+    } else {
+      output += `${prefix}${connector}${node.name}${sizeStr}
+`;
+    }
+  });
+  return output;
+}
+function createBox(title, content, width = 60) {
+  const lines = [];
+  const innerWidth = width - 4;
+  lines.push(pc2.dim("\u250C" + "\u2500".repeat(width - 2) + "\u2510"));
+  const titlePadding = Math.max(0, innerWidth - stripAnsi(title).length);
+  lines.push(pc2.dim("\u2502") + "  " + title + " ".repeat(titlePadding) + pc2.dim("\u2502"));
+  lines.push(pc2.dim("\u251C" + "\u2500".repeat(width - 2) + "\u2524"));
+  for (const line of content) {
+    const stripped = stripAnsi(line);
+    const padding = Math.max(0, innerWidth - stripped.length);
+    lines.push(pc2.dim("\u2502") + "  " + line + " ".repeat(padding) + pc2.dim("\u2502"));
+  }
+  lines.push(pc2.dim("\u2514" + "\u2500".repeat(width - 2) + "\u2518"));
+  return lines.join("\n");
+}
+function stripAnsi(str) {
+  return str.replace(
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    ""
+  );
+}
+function padEnd(str, width) {
+  const stripped = stripAnsi(str);
+  const padding = Math.max(0, width - stripped.length);
+  return str + " ".repeat(padding);
+}
+function truncate(str, maxLength) {
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength - 3) + "...";
+}
+function createTable(headers, rows, columnWidths) {
+  const lines = [];
+  const topBorder = "\u250C" + columnWidths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2510";
+  lines.push(pc2.dim(topBorder));
+  const headerRow = pc2.dim("\u2502") + headers.map((h, i) => " " + pc2.bold(padEnd(h, columnWidths[i])) + " ").join(pc2.dim("\u2502")) + pc2.dim("\u2502");
+  lines.push(headerRow);
+  const headerSep = "\u251C" + columnWidths.map((w) => "\u2500".repeat(w + 2)).join("\u253C") + "\u2524";
+  lines.push(pc2.dim(headerSep));
+  for (const row of rows) {
+    const dataRow = pc2.dim("\u2502") + row.map((cell, i) => " " + padEnd(cell, columnWidths[i]) + " ").join(pc2.dim("\u2502")) + pc2.dim("\u2502");
+    lines.push(dataRow);
+  }
+  const bottomBorder = "\u2514" + columnWidths.map((w) => "\u2500".repeat(w + 2)).join("\u2534") + "\u2518";
+  lines.push(pc2.dim(bottomBorder));
+  return lines.join("\n");
+}
+async function detectPackageManager(dir) {
+  if (await fs2.pathExists(path2.join(dir, "bun.lockb"))) return "bun";
+  if (await fs2.pathExists(path2.join(dir, "pnpm-lock.yaml"))) return "pnpm";
+  if (await fs2.pathExists(path2.join(dir, "yarn.lock"))) return "yarn";
+  if (await fs2.pathExists(path2.join(dir, "package-lock.json"))) return "npm";
+  if (await fs2.pathExists(path2.join(dir, "package.json"))) return "npm";
+  return null;
+}
+function detectDependencies(content, filename) {
+  const deps = /* @__PURE__ */ new Set();
+  if (filename.endsWith(".ts") || filename.endsWith(".tsx") || filename.endsWith(".js") || filename.endsWith(".jsx")) {
+    const importRegex = /import\s+.*?\s+from\s+['"]([^'"./][^'"]*)['"]/g;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const pkg = match[1].split("/")[0];
+      if (!pkg.startsWith("@")) {
+        deps.add(pkg);
+      } else {
+        const parts = match[1].split("/");
+        if (parts.length >= 2) {
+          deps.add(`${parts[0]}/${parts[1]}`);
+        }
+      }
+    }
+    const requireRegex = /require\s*\(\s*['"]([^'"./][^'"]*)['"]\s*\)/g;
+    while ((match = requireRegex.exec(content)) !== null) {
+      const pkg = match[1].split("/")[0];
+      if (!pkg.startsWith("@")) {
+        deps.add(pkg);
+      } else {
+        const parts = match[1].split("/");
+        if (parts.length >= 2) {
+          deps.add(`${parts[0]}/${parts[1]}`);
+        }
+      }
+    }
+  }
+  if (filename.endsWith(".py")) {
+    const importRegex = /^(?:from|import)\s+(\w+)/gm;
+    let match;
+    while ((match = importRegex.exec(content)) !== null) {
+      const pkg = match[1];
+      if (!["os", "sys", "json", "re", "typing", "dataclasses"].includes(pkg)) {
+        deps.add(pkg);
+      }
+    }
+  }
+  return Array.from(deps);
+}
+
+// src/commands/save.ts
+async function saveCommand(name, sourcePath, options) {
+  p2.intro(pc3.cyan("\u{1F9F1} Saving template"));
+  if (!await isInitialized()) {
+    p2.log.error(
+      "CodeBrick is not initialized. Run " + pc3.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const resolvedPath = sourcePath ? path3.resolve(sourcePath) : process.cwd();
+  if (!await fs3.pathExists(resolvedPath)) {
+    p2.log.error(`Path does not exist: ${resolvedPath}`);
+    process.exit(1);
+  }
+  const stat = await fs3.stat(resolvedPath);
+  if (!stat.isDirectory()) {
+    p2.log.error("Source path must be a directory");
+    process.exit(1);
+  }
+  if (await templateExists(name)) {
+    const shouldOverwrite = await p2.confirm({
+      message: `Template '${name}' already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p2.isCancel(shouldOverwrite) || !shouldOverwrite) {
+      p2.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    const existingPath = getTemplatePath(name);
+    await fs3.remove(existingPath);
+  }
+  let files;
+  if (options.include) {
+    const patterns = options.include.split(",").map((p12) => p12.trim());
+    files = await fg(patterns, {
+      cwd: resolvedPath,
+      dot: false,
+      ignore: options.exclude?.split(",").map((p12) => p12.trim()) || []
+    });
+  } else {
+    files = await getFilesRecursive(resolvedPath);
+    if (options.exclude) {
+      const excludePatterns = options.exclude.split(",").map((p12) => p12.trim());
+      const excluded = await fg(excludePatterns, {
+        cwd: resolvedPath,
+        dot: false
+      });
+      const excludeSet = new Set(excluded);
+      files = files.filter((f) => !excludeSet.has(f));
+    }
+  }
+  if (files.length === 0) {
+    p2.log.error("No files found in the specified path");
+    process.exit(1);
+  }
+  const stats = await getDirectoryStats(resolvedPath);
+  p2.log.info(`Source: ${pc3.dim(resolvedPath)}`);
+  p2.log.info(
+    `Files: ${pc3.green(files.length.toString())} files` + (stats.directories > 0 ? `, ${stats.directories} directories` : "")
+  );
+  let detectedDeps = [];
+  if (options.detectDeps) {
+    const spinner9 = p2.spinner();
+    spinner9.start("Detecting dependencies...");
+    for (const file of files) {
+      const filePath = path3.join(resolvedPath, file);
+      try {
+        const content = await fs3.readFile(filePath, "utf-8");
+        const deps = detectDependencies(content, file);
+        detectedDeps.push(...deps);
+      } catch {
+      }
+    }
+    detectedDeps = [...new Set(detectedDeps)];
+    spinner9.stop(`Detected ${detectedDeps.length} dependencies`);
+    if (detectedDeps.length > 0) {
+      p2.log.info(`Dependencies: ${pc3.dim(detectedDeps.join(", "))}`);
+      const addDeps = await p2.confirm({
+        message: "Add these to template metadata?",
+        initialValue: true
+      });
+      if (p2.isCancel(addDeps)) {
+        p2.cancel("Operation cancelled");
+        process.exit(0);
+      }
+      if (!addDeps) {
+        detectedDeps = [];
+      }
+    }
+  }
+  let description = options.description;
+  if (!description) {
+    const descInput = await p2.text({
+      message: "Template description (optional):",
+      placeholder: "A reusable code template"
+    });
+    if (p2.isCancel(descInput)) {
+      p2.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    description = descInput || "";
+  }
+  const tags = options.tags ? options.tags.split(",").map((t) => t.trim()).filter(Boolean) : [];
+  const spinner8 = p2.spinner();
+  spinner8.start("Copying files...");
+  const templatePath = getTemplatePath(name);
+  await fs3.ensureDir(templatePath);
+  for (const file of files) {
+    const sourcefile = path3.join(resolvedPath, file);
+    const destFile = path3.join(templatePath, file);
+    await fs3.ensureDir(path3.dirname(destFile));
+    await fs3.copy(sourcefile, destFile);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = {
+    name,
+    type: "local",
+    version: "1.0.0",
+    description: description || "",
+    createdAt: now,
+    updatedAt: now,
+    source: {
+      origin: "local",
+      path: resolvedPath
+    },
+    files,
+    tags
+  };
+  if (detectedDeps.length > 0) {
+    metadata.dependencies = {};
+    for (const dep of detectedDeps) {
+      metadata.dependencies[dep] = "*";
+    }
+  }
+  await saveTemplateMetadata(name, metadata);
+  const template = {
+    type: "local",
+    path: `templates/${name}`,
+    description: description || "",
+    tags,
+    createdAt: now,
+    updatedAt: now
+  };
+  await addTemplateToStore(name, template);
+  spinner8.stop("Template saved!");
+  console.log();
+  console.log(`  View structure: ${pc3.cyan(`brick tree ${name}`)}`);
+  console.log(`  Apply template: ${pc3.cyan(`brick apply ${name}`)}`);
+  console.log();
+  p2.outro(`Template '${pc3.green(name)}' saved successfully!`);
+}
+
+// src/commands/list.ts
+import * as p3 from "@clack/prompts";
+import pc4 from "picocolors";
+async function listCommand(options) {
+  if (!await isInitialized()) {
+    p3.log.error(
+      "CodeBrick is not initialized. Run " + pc4.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const store = await loadStore();
+  let templates = Object.entries(store.templates);
+  if (options.local) {
+    templates = templates.filter(([, t]) => t.type === "local");
+  } else if (options.remote) {
+    templates = templates.filter(([, t]) => t.type === "remote");
+  }
+  if (options.tag) {
+    templates = templates.filter(
+      ([, t]) => t.tags.some((tag) => tag.toLowerCase() === options.tag?.toLowerCase())
+    );
+  }
+  if (templates.length === 0) {
+    console.log();
+    if (options.tag) {
+      console.log(pc4.dim(`  No templates found with tag '${options.tag}'`));
+    } else if (options.local) {
+      console.log(pc4.dim("  No local templates found"));
+    } else if (options.remote) {
+      console.log(pc4.dim("  No remote templates found"));
+    } else {
+      console.log(pc4.dim("  No templates saved yet"));
+      console.log();
+      console.log(
+        `  Get started: ${pc4.cyan("brick save")} my-template ./path/to/code`
+      );
+    }
+    console.log();
+    return;
+  }
+  if (options.detailed) {
+    await renderDetailedList(templates);
+  } else {
+    renderTableList(templates);
+  }
+  const localCount = templates.filter(([, t]) => t.type === "local").length;
+  const remoteCount = templates.filter(([, t]) => t.type === "remote").length;
+  console.log();
+  if (localCount > 0 && remoteCount > 0) {
+    console.log(
+      pc4.dim(`Total: ${templates.length} templates (${localCount} local, ${remoteCount} remote)`)
+    );
+  } else {
+    console.log(pc4.dim(`Total: ${templates.length} template${templates.length === 1 ? "" : "s"}`));
+  }
+  console.log();
+  console.log(pc4.dim("Tip: Use index or name with commands, e.g., brick tree 0"));
+  console.log();
+}
+function renderTableList(templates) {
+  const headers = ["#", "Name", "Type", "Description"];
+  const columnWidths = [3, 28, 8, 36];
+  const rows = templates.map(([name, template], index) => {
+    const typeColor = template.type === "local" ? pc4.green : pc4.blue;
+    return [
+      pc4.yellow(index.toString()),
+      truncate(name, columnWidths[1]),
+      typeColor(template.type),
+      truncate(template.description || "-", columnWidths[3])
+    ];
+  });
+  console.log();
+  console.log(createTable(headers, rows, columnWidths));
+}
+async function renderDetailedList(templates) {
+  const localTemplates = templates.filter(([, t]) => t.type === "local");
+  const remoteTemplates = templates.filter(([, t]) => t.type === "remote");
+  let globalIndex = 0;
+  console.log();
+  if (localTemplates.length > 0) {
+    console.log(pc4.bold("LOCAL TEMPLATES"));
+    console.log(pc4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    for (const [name, template] of localTemplates) {
+      const metadata = await loadTemplateMetadata(name);
+      const fileCount = metadata?.files.length || 0;
+      console.log(pc4.yellow(`[${globalIndex}]`) + " " + pc4.bold(pc4.green(name)));
+      console.log(`    Type:        ${pc4.dim("local")}`);
+      console.log(`    Description: ${template.description || pc4.dim("No description")}`);
+      console.log(`    Files:       ${fileCount} files`);
+      if (template.tags.length > 0) {
+        console.log(`    Tags:        ${template.tags.join(", ")}`);
+      }
+      console.log(`    Created:     ${formatDate(template.createdAt)}`);
+      console.log(`    Updated:     ${formatDate(template.updatedAt)}`);
+      console.log();
+      globalIndex++;
+    }
+  }
+  if (remoteTemplates.length > 0) {
+    if (localTemplates.length > 0) {
+      console.log();
+    }
+    console.log(pc4.bold("REMOTE TEMPLATES (GitHub)"));
+    console.log(pc4.dim("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log();
+    for (const [name, template] of remoteTemplates) {
+      const remote = template;
+      const source = `github:${remote.github.owner}/${remote.github.repo}/${remote.github.path}`;
+      const ref = remote.github.commit ? `${remote.github.ref} @ ${remote.github.commit.slice(0, 7)}` : remote.github.ref;
+      console.log(pc4.yellow(`[${globalIndex}]`) + " " + pc4.bold(pc4.blue(name)));
+      console.log(`    Type:        ${pc4.dim("remote")}`);
+      console.log(`    Source:      ${source}`);
+      console.log(`    Ref:         ${ref}`);
+      console.log(`    Description: ${template.description || pc4.dim("No description")}`);
+      if (template.tags.length > 0) {
+        console.log(`    Tags:        ${template.tags.join(", ")}`);
+      }
+      console.log(`    Linked:      ${formatDate(template.createdAt)}`);
+      console.log();
+      globalIndex++;
+    }
+  }
+}
+
+// src/commands/tree.ts
+import * as p4 from "@clack/prompts";
+import pc5 from "picocolors";
+async function treeCommand(nameOrIndex, options) {
+  if (!await isInitialized()) {
+    p4.log.error(
+      "CodeBrick is not initialized. Run " + pc5.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p4.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc5.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p4.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  if (template.type === "remote") {
+    console.log();
+    console.log(pc5.bold(pc5.blue(name)) + pc5.dim(" (remote)"));
+    console.log(
+      pc5.dim(
+        `Source: github:${template.github.owner}/${template.github.repo}/${template.github.path}`
+      )
+    );
+    console.log();
+    console.log(
+      pc5.yellow(
+        "Remote template files are fetched on-demand. Use " + pc5.cyan(`brick pull ${name}`) + " to download locally."
+      )
+    );
+    console.log();
+    return;
+  }
+  const templatePath = getTemplatePath(name);
+  const tree = await buildTree(templatePath, options.size);
+  const stats = await getDirectoryStats(templatePath);
+  console.log();
+  if (options.size) {
+    console.log(pc5.bold(pc5.green(name)) + pc5.dim(` (${formatSize(stats.totalSize)})`));
+  } else {
+    console.log(pc5.bold(pc5.green(name)));
+  }
+  const treeOutput = renderTree(tree, "", true, options.size);
+  console.log(treeOutput);
+  const summary = [];
+  if (stats.files > 0) {
+    summary.push(`${stats.files} file${stats.files === 1 ? "" : "s"}`);
+  }
+  if (stats.directories > 0) {
+    summary.push(`${stats.directories} director${stats.directories === 1 ? "y" : "ies"}`);
+  }
+  if (options.size && stats.totalSize > 0) {
+    summary.push(`${formatSize(stats.totalSize)} total`);
+  }
+  console.log(pc5.dim(summary.join(", ")));
+  console.log();
+}
+
+// src/commands/apply.ts
+import * as p5 from "@clack/prompts";
+import pc6 from "picocolors";
+import fs4 from "fs-extra";
+import path4 from "path";
+async function applyCommand(nameOrIndex, destination, options) {
+  p5.intro(pc6.cyan("\u{1F9F1} Applying template"));
+  if (!await isInitialized()) {
+    p5.log.error(
+      "CodeBrick is not initialized. Run " + pc6.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p5.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc6.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p5.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  if (template.type === "remote") {
+    p5.log.error(
+      "Remote template support coming soon. Use " + pc6.cyan(`brick pull ${name}`) + " to download locally first."
+    );
+    process.exit(1);
+  }
+  const destPath = destination ? path4.resolve(destination) : process.cwd();
+  const metadata = await loadTemplateMetadata(name);
+  if (!metadata) {
+    p5.log.error("Failed to load template metadata");
+    process.exit(1);
+  }
+  p5.log.info(`Destination: ${pc6.dim(destPath)}`);
+  const templatePath = getTemplatePath(name);
+  const conflicts = [];
+  const filesToCopy = [];
+  for (const file of metadata.files) {
+    const destFile = path4.join(destPath, file);
+    if (await fs4.pathExists(destFile)) {
+      conflicts.push(file);
+    }
+    filesToCopy.push(file);
+  }
+  console.log();
+  console.log(pc6.bold(`  ${filesToCopy.length} files will be created:`));
+  for (const file of filesToCopy.slice(0, 10)) {
+    const isConflict = conflicts.includes(file);
+    const prefix = isConflict ? pc6.yellow("~") : pc6.green("+");
+    console.log(`    ${prefix} ${file}`);
+  }
+  if (filesToCopy.length > 10) {
+    console.log(pc6.dim(`    ... and ${filesToCopy.length - 10} more`));
+  }
+  console.log();
+  if (conflicts.length > 0 && !options.force && !options.skipExisting) {
+    console.log(pc6.yellow(`  \u26A0 ${conflicts.length} file(s) already exist:`));
+    for (const file of conflicts.slice(0, 5)) {
+      console.log(pc6.dim(`    - ${file}`));
+    }
+    if (conflicts.length > 5) {
+      console.log(pc6.dim(`    ... and ${conflicts.length - 5} more`));
+    }
+    console.log();
+    const conflictAction = await p5.select({
+      message: "How would you like to handle existing files?",
+      options: [
+        { value: "overwrite", label: "Overwrite all" },
+        { value: "skip", label: "Skip existing files" },
+        { value: "cancel", label: "Cancel" }
+      ]
+    });
+    if (p5.isCancel(conflictAction) || conflictAction === "cancel") {
+      p5.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    if (conflictAction === "skip") {
+      options.skipExisting = true;
+    } else {
+      options.force = true;
+    }
+  }
+  const hasDeps = metadata.dependencies && Object.keys(metadata.dependencies).length > 0;
+  const hasDevDeps = metadata.devDependencies && Object.keys(metadata.devDependencies).length > 0;
+  if ((hasDeps || hasDevDeps) && options.deps !== false) {
+    const allDeps = {
+      ...metadata.dependencies,
+      ...metadata.devDependencies
+    };
+    console.log(pc6.bold("  Dependencies required:"));
+    for (const [dep, version] of Object.entries(allDeps)) {
+      console.log(`    ${pc6.cyan(dep)} ${pc6.dim(version)}`);
+    }
+    console.log();
+    const versionChoice = await p5.select({
+      message: "How would you like to handle dependency versions?",
+      options: [
+        { value: "template", label: "Use template versions (recommended)" },
+        { value: "latest", label: "Use @latest for all packages" },
+        { value: "skip", label: "Skip dependency installation" }
+      ]
+    });
+    if (p5.isCancel(versionChoice)) {
+      p5.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    if (versionChoice === "latest") {
+      options.latest = true;
+    }
+  }
+  if (options.dryRun) {
+    console.log(pc6.yellow("  Dry run - no files will be written"));
+    console.log();
+    p5.outro("Dry run complete");
+    return;
+  }
+  const confirmed = await p5.confirm({
+    message: "Proceed with installation?",
+    initialValue: true
+  });
+  if (p5.isCancel(confirmed) || !confirmed) {
+    p5.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const spinner8 = p5.spinner();
+  spinner8.start("Creating files...");
+  let copiedCount = 0;
+  let skippedCount = 0;
+  for (const file of metadata.files) {
+    const sourceFile = path4.join(templatePath, file);
+    const destFile = path4.join(destPath, file);
+    if (options.skipExisting && await fs4.pathExists(destFile)) {
+      skippedCount++;
+      continue;
+    }
+    await fs4.ensureDir(path4.dirname(destFile));
+    await fs4.copy(sourceFile, destFile, { overwrite: options.force });
+    copiedCount++;
+  }
+  spinner8.stop("Files created!");
+  console.log();
+  console.log(pc6.green(`  \u2713 ${copiedCount} file(s) created`));
+  if (skippedCount > 0) {
+    console.log(pc6.yellow(`  \u2298 ${skippedCount} file(s) skipped`));
+  }
+  if ((hasDeps || hasDevDeps) && options.deps !== false) {
+    const pm = await detectPackageManager(destPath);
+    const installCmd = pm === "yarn" ? "yarn add" : pm === "pnpm" ? "pnpm add" : pm === "bun" ? "bun add" : "npm install";
+    console.log();
+    console.log(pc6.dim("  To install dependencies, run:"));
+    const deps = Object.entries(metadata.dependencies || {}).map(
+      ([dep, version]) => options.latest ? dep : `${dep}@${version}`
+    );
+    const devDeps = Object.entries(metadata.devDependencies || {}).map(
+      ([dep, version]) => options.latest ? dep : `${dep}@${version}`
+    );
+    if (deps.length > 0) {
+      console.log(`    ${pc6.cyan(installCmd)} ${deps.join(" ")}`);
+    }
+    if (devDeps.length > 0) {
+      const devFlag = pm === "yarn" ? "--dev" : pm === "bun" ? "--dev" : "-D";
+      console.log(`    ${pc6.cyan(installCmd)} ${devFlag} ${devDeps.join(" ")}`);
+    }
+  }
+  console.log();
+  p5.outro("Template applied successfully! \u{1F389}");
+}
+
+// src/commands/info.ts
+import * as p6 from "@clack/prompts";
+import pc7 from "picocolors";
+async function infoCommand(nameOrIndex) {
+  if (!await isInitialized()) {
+    p6.log.error(
+      "CodeBrick is not initialized. Run " + pc7.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p6.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc7.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p6.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  console.log();
+  if (template.type === "local") {
+    const metadata = await loadTemplateMetadata(name);
+    const templatePath = getTemplatePath(name);
+    const stats = await getDirectoryStats(templatePath);
+    const content = [
+      "",
+      `Description:  ${metadata?.description || pc7.dim("No description")}`,
+      `Version:      ${metadata?.version || "1.0.0"}`,
+      `Created:      ${formatDate(template.createdAt)}`,
+      `Updated:      ${formatDate(template.updatedAt)}`,
+      "",
+      `Source:       ${metadata?.source?.path || pc7.dim("Unknown")}`,
+      `Storage:      ${pc7.dim(`~/.codebrick/templates/${name}`)}`,
+      ""
+    ];
+    if (template.tags.length > 0) {
+      content.push(`Tags:         ${template.tags.join(", ")}`);
+      content.push("");
+    }
+    content.push(
+      `Files:        ${stats.files} file${stats.files === 1 ? "" : "s"}` + (stats.directories > 0 ? `, ${stats.directories} director${stats.directories === 1 ? "y" : "ies"}` : "")
+    );
+    content.push("");
+    if (metadata?.dependencies && Object.keys(metadata.dependencies).length > 0) {
+      content.push("Dependencies:");
+      for (const [dep, version] of Object.entries(metadata.dependencies)) {
+        content.push(`  ${dep.padEnd(20)} ${pc7.dim(version)}`);
+      }
+      content.push("");
+    }
+    if (metadata?.devDependencies && Object.keys(metadata.devDependencies).length > 0) {
+      content.push("Dev Dependencies:");
+      for (const [dep, version] of Object.entries(metadata.devDependencies)) {
+        content.push(`  ${dep.padEnd(20)} ${pc7.dim(version)}`);
+      }
+      content.push("");
+    }
+    const title = pc7.bold(pc7.green(name));
+    console.log(createBox(title, content, 60));
+  } else {
+    const github = template.github;
+    const source = `github:${github.owner}/${github.repo}/${github.path}`;
+    const ref = github.commit ? `${github.ref} @ ${github.commit.slice(0, 7)}` : github.ref;
+    const content = [
+      "",
+      `Description:  ${template.description || pc7.dim("No description")}`,
+      `Linked:       ${formatDate(template.createdAt)}`,
+      "",
+      `Source:       ${source}`,
+      `Ref:          ${ref}`,
+      ""
+    ];
+    if (template.tags.length > 0) {
+      content.push(`Tags:         ${template.tags.join(", ")}`);
+      content.push("");
+    }
+    content.push(pc7.yellow("This is a remote template."));
+    content.push(pc7.yellow("Files are fetched from GitHub on-demand."));
+    content.push("");
+    const title = pc7.bold(pc7.blue(name)) + pc7.dim(" (remote)");
+    console.log(createBox(title, content, 60));
+  }
+  console.log();
+  console.log(pc7.bold("Commands:"));
+  console.log(`  ${pc7.cyan(`brick tree ${name}`)}     View file structure`);
+  console.log(`  ${pc7.cyan(`brick apply ${name}`)}    Apply to project`);
+  if (template.type === "local") {
+    console.log(`  ${pc7.cyan(`brick add ${name}`)}      Add files to template`);
+  } else {
+    console.log(`  ${pc7.cyan(`brick pull ${name}`)}     Download locally`);
+  }
+  console.log();
+}
+
+// src/commands/add.ts
+import * as p7 from "@clack/prompts";
+import pc8 from "picocolors";
+import fs5 from "fs-extra";
+import path5 from "path";
+import fg2 from "fast-glob";
+async function addCommand(nameOrIndex, filePatterns) {
+  p7.intro(pc8.cyan("\u{1F9F1} Adding files to template"));
+  if (!await isInitialized()) {
+    p7.log.error(
+      "CodeBrick is not initialized. Run " + pc8.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p7.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc8.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p7.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  if (template.type === "remote") {
+    p7.log.error(
+      "Cannot add files to remote templates. Use " + pc8.cyan(`brick pull ${name}`) + " to convert to local first."
+    );
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const filesToAdd = [];
+  for (const pattern of filePatterns) {
+    const resolved = path5.resolve(pattern);
+    if (await fs5.pathExists(resolved)) {
+      const stat = await fs5.stat(resolved);
+      if (stat.isDirectory()) {
+        const files = await fg2("**/*", {
+          cwd: resolved,
+          dot: false,
+          onlyFiles: true
+        });
+        const relativeDirPath = path5.relative(cwd, resolved);
+        const basePath = relativeDirPath.startsWith("..") ? path5.basename(resolved) : relativeDirPath;
+        for (const file of files) {
+          filesToAdd.push({
+            source: path5.join(resolved, file),
+            relative: path5.join(basePath, file)
+          });
+        }
+      } else {
+        const relativeFilePath = path5.relative(cwd, resolved);
+        filesToAdd.push({
+          source: resolved,
+          relative: relativeFilePath.startsWith("..") ? path5.basename(resolved) : relativeFilePath
+          // Inside cwd, preserve path
+        });
+      }
+    } else {
+      const matches = await fg2(pattern, {
+        cwd,
+        dot: false,
+        onlyFiles: true
+      });
+      for (const match of matches) {
+        filesToAdd.push({
+          source: path5.join(cwd, match),
+          relative: match
+        });
+      }
+    }
+  }
+  if (filesToAdd.length === 0) {
+    p7.log.error("No files found matching the specified patterns");
+    process.exit(1);
+  }
+  console.log();
+  console.log(pc8.bold(`  Files to add:`));
+  for (const file of filesToAdd.slice(0, 10)) {
+    console.log(`    ${pc8.green("+")} ${file.relative}`);
+  }
+  if (filesToAdd.length > 10) {
+    console.log(pc8.dim(`    ... and ${filesToAdd.length - 10} more`));
+  }
+  console.log();
+  const confirmed = await p7.confirm({
+    message: `Confirm adding ${filesToAdd.length} file(s)?`,
+    initialValue: true
+  });
+  if (p7.isCancel(confirmed) || !confirmed) {
+    p7.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const spinner8 = p7.spinner();
+  spinner8.start("Adding files...");
+  const templatePath = getTemplatePath(name);
+  const metadata = await loadTemplateMetadata(name);
+  if (!metadata) {
+    spinner8.stop("Failed to load template metadata");
+    process.exit(1);
+  }
+  const existingFiles = new Set(metadata.files);
+  let addedCount = 0;
+  for (const file of filesToAdd) {
+    const destPath = path5.join(templatePath, file.relative);
+    await fs5.ensureDir(path5.dirname(destPath));
+    await fs5.copy(file.source, destPath, { overwrite: true });
+    if (!existingFiles.has(file.relative)) {
+      metadata.files.push(file.relative);
+      existingFiles.add(file.relative);
+    }
+    addedCount++;
+  }
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTemplateMetadata(name, metadata);
+  const updatedTemplate = {
+    ...template,
+    updatedAt: metadata.updatedAt
+  };
+  await addTemplateToStore(name, updatedTemplate);
+  spinner8.stop(`Added ${addedCount} file(s)`);
+  console.log();
+  console.log(
+    `  Template now has ${pc8.green(metadata.files.length.toString())} files`
+  );
+  console.log();
+  p7.outro("Template updated! \u2713");
+}
+
+// src/commands/remove-file.ts
+import * as p8 from "@clack/prompts";
+import pc9 from "picocolors";
+import fs6 from "fs-extra";
+import path6 from "path";
+async function removeFileCommand(nameOrIndex, filePatterns) {
+  p8.intro(pc9.cyan("\u{1F9F1} Removing files from template"));
+  if (!await isInitialized()) {
+    p8.log.error(
+      "CodeBrick is not initialized. Run " + pc9.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p8.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc9.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p8.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  if (template.type === "remote") {
+    p8.log.error(
+      "Cannot remove files from remote templates. Use " + pc9.cyan(`brick pull ${name}`) + " to convert to local first."
+    );
+    process.exit(1);
+  }
+  const metadata = await loadTemplateMetadata(name);
+  if (!metadata) {
+    p8.log.error("Failed to load template metadata");
+    process.exit(1);
+  }
+  const filesToRemove = [];
+  const templatePath = getTemplatePath(name);
+  for (const pattern of filePatterns) {
+    if (metadata.files.includes(pattern)) {
+      filesToRemove.push(pattern);
+      continue;
+    }
+    const dirPattern = pattern.endsWith("/") ? pattern : pattern + "/";
+    const matchingFiles = metadata.files.filter(
+      (f) => f === pattern || f.startsWith(dirPattern)
+    );
+    if (matchingFiles.length > 0) {
+      filesToRemove.push(...matchingFiles);
+      continue;
+    }
+    const regexPattern = pattern.replace(/\./g, "\\.").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexPattern}$`);
+    const matches = metadata.files.filter((f) => regex.test(f));
+    filesToRemove.push(...matches);
+  }
+  const uniqueFilesToRemove = [...new Set(filesToRemove)];
+  if (uniqueFilesToRemove.length === 0) {
+    p8.log.error("No matching files found in template");
+    p8.log.info(`Template files: ${metadata.files.join(", ")}`);
+    process.exit(1);
+  }
+  console.log();
+  console.log(pc9.bold(`  Files to remove:`));
+  for (const file of uniqueFilesToRemove.slice(0, 10)) {
+    console.log(`    ${pc9.red("-")} ${file}`);
+  }
+  if (uniqueFilesToRemove.length > 10) {
+    console.log(pc9.dim(`    ... and ${uniqueFilesToRemove.length - 10} more`));
+  }
+  console.log();
+  const confirmed = await p8.confirm({
+    message: `Confirm removing ${uniqueFilesToRemove.length} file(s)?`,
+    initialValue: true
+  });
+  if (p8.isCancel(confirmed) || !confirmed) {
+    p8.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const spinner8 = p8.spinner();
+  spinner8.start("Removing files...");
+  let removedCount = 0;
+  for (const file of uniqueFilesToRemove) {
+    const filePath = path6.join(templatePath, file);
+    if (await fs6.pathExists(filePath)) {
+      await fs6.remove(filePath);
+    }
+    const index = metadata.files.indexOf(file);
+    if (index > -1) {
+      metadata.files.splice(index, 1);
+    }
+    removedCount++;
+  }
+  const cleanEmptyDirs = async (dir) => {
+    const entries = await fs6.readdir(dir);
+    for (const entry of entries) {
+      const entryPath = path6.join(dir, entry);
+      const stat = await fs6.stat(entryPath);
+      if (stat.isDirectory()) {
+        await cleanEmptyDirs(entryPath);
+        const subEntries = await fs6.readdir(entryPath);
+        if (subEntries.length === 0) {
+          await fs6.remove(entryPath);
+        }
+      }
+    }
+  };
+  await cleanEmptyDirs(templatePath);
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTemplateMetadata(name, metadata);
+  const updatedTemplate = {
+    ...template,
+    updatedAt: metadata.updatedAt
+  };
+  await addTemplateToStore(name, updatedTemplate);
+  spinner8.stop(`Removed ${removedCount} file(s)`);
+  console.log();
+  console.log(
+    `  Template now has ${pc9.green(metadata.files.length.toString())} files remaining`
+  );
+  console.log();
+  p8.outro("Template updated! \u2713");
+}
+
+// src/commands/delete.ts
+import * as p9 from "@clack/prompts";
+import pc10 from "picocolors";
+async function deleteCommand(nameOrIndex, options) {
+  if (!await isInitialized()) {
+    p9.log.error(
+      "CodeBrick is not initialized. Run " + pc10.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p9.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc10.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p9.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  let fileCount = 0;
+  if (template.type === "local") {
+    const metadata = await loadTemplateMetadata(name);
+    fileCount = metadata?.files.length || 0;
+  }
+  if (!options.force) {
+    console.log();
+    console.log(pc10.yellow(`  Delete template '${name}'?`));
+    console.log();
+    console.log("  This will permanently remove:");
+    if (template.type === "local") {
+      console.log(`    - ${fileCount} file${fileCount === 1 ? "" : "s"}`);
+    }
+    console.log("    - All metadata");
+    console.log();
+    const confirmName = await p9.text({
+      message: `Type '${name}' to confirm:`,
+      placeholder: name,
+      validate: (value) => {
+        if (value !== name) {
+          return `Please type '${name}' to confirm deletion`;
+        }
+      }
+    });
+    if (p9.isCancel(confirmName)) {
+      p9.cancel("Operation cancelled");
+      process.exit(0);
+    }
+  }
+  const spinner8 = p9.spinner();
+  spinner8.start("Deleting template...");
+  try {
+    if (template.type === "local") {
+      await deleteTemplateFiles(name);
+    }
+    await removeTemplateFromStore(name);
+    spinner8.stop("Template deleted");
+    console.log();
+    p9.outro(`Template '${pc10.red(name)}' has been deleted`);
+  } catch (error) {
+    spinner8.stop("Failed to delete template");
+    p9.log.error(
+      error instanceof Error ? error.message : "Unknown error occurred"
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/size.ts
+import * as p10 from "@clack/prompts";
+import pc11 from "picocolors";
+async function sizeCommand(nameOrIndex) {
+  if (!await isInitialized()) {
+    p10.log.error(
+      "CodeBrick is not initialized. Run " + pc11.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  if (nameOrIndex !== void 0) {
+    await showSingleTemplateSize(nameOrIndex);
+  } else {
+    await showAllTemplateSizes();
+  }
+}
+async function showSingleTemplateSize(nameOrIndex) {
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p10.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc11.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p10.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  if (template.type === "remote") {
+    console.log();
+    console.log(pc11.bold(pc11.blue(name)) + pc11.dim(" (remote)"));
+    console.log();
+    console.log(
+      pc11.yellow("Remote templates don't use local disk space.")
+    );
+    console.log(
+      pc11.dim("Files are fetched from GitHub on-demand when applied.")
+    );
+    console.log();
+    return;
+  }
+  const templatePath = getTemplatePath(name);
+  const stats = await getDirectoryStats(templatePath);
+  console.log();
+  console.log(pc11.bold(pc11.green(name)));
+  console.log();
+  console.log(`  Files:       ${stats.files}`);
+  console.log(`  Directories: ${stats.directories}`);
+  console.log(`  Total Size:  ${pc11.cyan(formatSize(stats.totalSize))}`);
+  console.log();
+}
+async function showAllTemplateSizes() {
+  const store = await loadStore();
+  const templates = Object.entries(store.templates);
+  if (templates.length === 0) {
+    console.log();
+    console.log(pc11.dim("  No templates saved yet"));
+    console.log();
+    return;
+  }
+  const headers = ["#", "Name", "Type", "Files", "Size"];
+  const columnWidths = [3, 28, 8, 8, 12];
+  const rows = [];
+  let totalSize = 0;
+  let totalFiles = 0;
+  for (let index = 0; index < templates.length; index++) {
+    const [name, template] = templates[index];
+    const typeColor = template.type === "local" ? pc11.green : pc11.blue;
+    if (template.type === "local") {
+      const templatePath = getTemplatePath(name);
+      const stats = await getDirectoryStats(templatePath);
+      totalSize += stats.totalSize;
+      totalFiles += stats.files;
+      rows.push([
+        pc11.yellow(index.toString()),
+        truncate(name, columnWidths[1]),
+        typeColor(template.type),
+        stats.files.toString(),
+        formatSize(stats.totalSize)
+      ]);
+    } else {
+      rows.push([
+        pc11.yellow(index.toString()),
+        truncate(name, columnWidths[1]),
+        typeColor(template.type),
+        pc11.dim("-"),
+        pc11.dim("remote")
+      ]);
+    }
+  }
+  console.log();
+  console.log(createTable(headers, rows, columnWidths));
+  console.log();
+  console.log(
+    pc11.dim(`Total: ${totalFiles} files, ${pc11.cyan(formatSize(totalSize))}`)
+  );
+  console.log();
+}
+
+// src/commands/clean.ts
+import * as p11 from "@clack/prompts";
+import pc12 from "picocolors";
+import fs7 from "fs-extra";
+import path7 from "path";
+var LOCAL_IMPORT_PATTERNS = {
+  // Dart/Flutter: package:project_name/... imports
+  ".dart": [
+    /^import\s+['"]package:[^\/]+\/[^'"]+['"]\s*;?\s*$/gm,
+    /^export\s+['"]package:[^\/]+\/[^'"]+['"]\s*;?\s*$/gm
+  ],
+  // TypeScript/JavaScript: relative imports
+  ".ts": [
+    /^import\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^import\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^export\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm
+  ],
+  ".tsx": [
+    /^import\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^import\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^export\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm
+  ],
+  ".js": [
+    /^import\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^import\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^export\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^const\s+\w+\s*=\s*require\s*\(\s*['"]\.\.?\/[^'"]+['"]\s*\)\s*;?\s*$/gm
+  ],
+  ".jsx": [
+    /^import\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^import\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm,
+    /^export\s+.*from\s+['"]\.\.?\/[^'"]+['"]\s*;?\s*$/gm
+  ],
+  // Python: relative imports
+  ".py": [
+    /^from\s+\.\S*\s+import\s+.*$/gm,
+    /^import\s+\.\S+.*$/gm
+  ],
+  // Go: project-specific imports (anything not from standard lib or known packages)
+  ".go": [
+    // Will be handled with custom pattern
+  ],
+  // Rust: crate-relative imports
+  ".rs": [
+    /^use\s+crate::.*;\s*$/gm,
+    /^use\s+super::.*;\s*$/gm
+  ],
+  // Swift: no standard local import pattern, handled by custom pattern
+  ".swift": [],
+  // Kotlin: project-specific imports
+  ".kt": []
+};
+var EXTERNAL_PREFIXES = {
+  ".dart": [
+    "package:flutter/",
+    "package:flutter_",
+    "package:dart:",
+    "package:go_router/",
+    "package:dio/",
+    "package:http/",
+    "package:provider/",
+    "package:bloc/",
+    "package:flutter_bloc/",
+    "package:get/",
+    "package:riverpod/",
+    "package:hooks_riverpod/",
+    "package:freezed_annotation/",
+    "package:json_annotation/",
+    "package:equatable/",
+    "package:dartz/",
+    "package:injectable/",
+    "package:get_it/",
+    "package:shared_preferences/",
+    "package:path_provider/",
+    "package:sqflite/",
+    "package:hive/",
+    "package:firebase_",
+    "package:cloud_firestore/",
+    "package:intl/",
+    "package:cached_network_image/",
+    "package:image_picker/",
+    "package:url_launcher/",
+    "package:connectivity",
+    "package:permission_handler/",
+    "package:auto_route/",
+    "package:mockito/",
+    "package:test/",
+    "package:flutter_test/"
+  ]
+};
+function isExternalImport(line, ext) {
+  const prefixes = EXTERNAL_PREFIXES[ext] || [];
+  return prefixes.some((prefix) => line.includes(prefix));
+}
+function detectProjectName(templatePath) {
+  const pubspecPath = path7.join(templatePath, "pubspec.yaml");
+  if (fs7.existsSync(pubspecPath)) {
+    try {
+      const content = fs7.readFileSync(pubspecPath, "utf-8");
+      const match = content.match(/^name:\s*(\S+)/m);
+      if (match) return match[1];
+    } catch {
+    }
+  }
+  const packageJsonPath = path7.join(templatePath, "package.json");
+  if (fs7.existsSync(packageJsonPath)) {
+    try {
+      const content = JSON.parse(fs7.readFileSync(packageJsonPath, "utf-8"));
+      if (content.name) return content.name.replace(/^@[^/]+\//, "");
+    } catch {
+    }
+  }
+  const pyprojectPath = path7.join(templatePath, "pyproject.toml");
+  if (fs7.existsSync(pyprojectPath)) {
+    try {
+      const content = fs7.readFileSync(pyprojectPath, "utf-8");
+      const match = content.match(/name\s*=\s*["']([^"']+)["']/);
+      if (match) return match[1];
+    } catch {
+    }
+  }
+  return null;
+}
+function cleanFileContent(content, ext, customPattern, projectName, keepExternal = true) {
+  let cleaned = content;
+  let removedCount = 0;
+  const lines = content.split("\n");
+  const cleanedLines = [];
+  for (const line of lines) {
+    let shouldRemove = false;
+    if (customPattern) {
+      const regex = new RegExp(customPattern);
+      if (regex.test(line)) {
+        shouldRemove = true;
+      }
+    }
+    if (!shouldRemove && ext === ".dart" && projectName) {
+      const projectImportPattern = new RegExp(
+        `^(import|export)\\s+['"]package:${projectName}/`
+      );
+      if (projectImportPattern.test(line.trim())) {
+        if (keepExternal && isExternalImport(line, ext)) {
+          shouldRemove = false;
+        } else {
+          shouldRemove = true;
+        }
+      }
+    }
+    if (!shouldRemove) {
+      const patterns = LOCAL_IMPORT_PATTERNS[ext] || [];
+      for (const pattern of patterns) {
+        pattern.lastIndex = 0;
+        if (pattern.test(line.trim())) {
+          if (keepExternal && isExternalImport(line, ext)) {
+            shouldRemove = false;
+          } else {
+            shouldRemove = true;
+          }
+          break;
+        }
+      }
+    }
+    if (shouldRemove) {
+      removedCount++;
+    } else {
+      cleanedLines.push(line);
+    }
+  }
+  cleaned = cleanedLines.join("\n").replace(/\n{3,}/g, "\n\n");
+  return { cleaned, removedCount };
+}
+async function cleanCommand(nameOrIndex, options) {
+  p11.intro(pc12.cyan("\u{1F9F9} Cleaning template imports"));
+  if (!await isInitialized()) {
+    p11.log.error(
+      "CodeBrick is not initialized. Run " + pc12.cyan("brick init") + " first."
+    );
+    process.exit(1);
+  }
+  const name = await resolveTemplateName(nameOrIndex);
+  if (!name) {
+    p11.log.error(
+      `Template '${nameOrIndex}' not found. Run ${pc12.cyan("brick list")} to see available templates.`
+    );
+    process.exit(1);
+  }
+  const template = await getTemplate(name);
+  if (!template) {
+    p11.log.error(`Template '${name}' not found.`);
+    process.exit(1);
+  }
+  if (template.type === "remote") {
+    p11.log.error(
+      "Cannot clean remote templates. Use " + pc12.cyan(`brick pull ${name}`) + " to convert to local first."
+    );
+    process.exit(1);
+  }
+  const templatePath = getTemplatePath(name);
+  const metadata = await loadTemplateMetadata(name);
+  if (!metadata) {
+    p11.log.error("Failed to load template metadata.");
+    process.exit(1);
+  }
+  const projectName = detectProjectName(templatePath);
+  if (projectName) {
+    p11.log.info(`Detected project name: ${pc12.cyan(projectName)}`);
+  }
+  if (options.pattern) {
+    p11.log.info(`Using custom pattern: ${pc12.cyan(options.pattern)}`);
+  }
+  const filesToClean = [];
+  let totalRemovals = 0;
+  for (const file of metadata.files) {
+    const ext = path7.extname(file).toLowerCase();
+    const filePath = path7.join(templatePath, file);
+    if (!LOCAL_IMPORT_PATTERNS[ext] && !options.pattern) continue;
+    try {
+      const content = await fs7.readFile(filePath, "utf-8");
+      const { removedCount } = cleanFileContent(
+        content,
+        ext,
+        options.pattern,
+        projectName || void 0,
+        options.keepExternal !== false
+      );
+      if (removedCount > 0) {
+        filesToClean.push({ file, ext, removals: removedCount });
+        totalRemovals += removedCount;
+      }
+    } catch {
+    }
+  }
+  if (filesToClean.length === 0) {
+    p11.log.info("No local imports found to clean.");
+    p11.outro("Template is already clean! \u2713");
+    return;
+  }
+  console.log();
+  console.log(pc12.bold(`  Files to clean:`));
+  for (const { file, removals } of filesToClean.slice(0, 15)) {
+    console.log(`    ${pc12.yellow(file)} ${pc12.dim(`(${removals} imports)`)}`);
+  }
+  if (filesToClean.length > 15) {
+    console.log(pc12.dim(`    ... and ${filesToClean.length - 15} more files`));
+  }
+  console.log();
+  console.log(
+    `  Total: ${pc12.red(totalRemovals.toString())} local imports to remove`
+  );
+  console.log();
+  if (options.dryRun) {
+    p11.log.info(pc12.yellow("Dry run - no changes made"));
+    p11.outro("Run without --dry-run to apply changes");
+    return;
+  }
+  const confirmed = await p11.confirm({
+    message: `Remove ${totalRemovals} local imports from ${filesToClean.length} files?`,
+    initialValue: true
+  });
+  if (p11.isCancel(confirmed) || !confirmed) {
+    p11.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const spinner8 = p11.spinner();
+  spinner8.start("Cleaning imports...");
+  let cleanedFiles = 0;
+  for (const { file, ext } of filesToClean) {
+    const filePath = path7.join(templatePath, file);
+    try {
+      const content = await fs7.readFile(filePath, "utf-8");
+      const { cleaned } = cleanFileContent(
+        content,
+        ext,
+        options.pattern,
+        projectName || void 0,
+        options.keepExternal !== false
+      );
+      await fs7.writeFile(filePath, cleaned, "utf-8");
+      cleanedFiles++;
+    } catch {
+    }
+  }
+  metadata.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveTemplateMetadata(name, metadata);
+  spinner8.stop(`Cleaned ${cleanedFiles} files`);
+  console.log();
+  console.log(`  ${pc12.green("\u2713")} Removed ${totalRemovals} local imports`);
+  console.log();
+  p11.outro("Template cleaned successfully! \u2713");
+}
+
+// src/index.ts
+var program = new Command();
+program.name("brick").description(
+  pc13.cyan("\u{1F9F1} CodeBrick") + " - A framework-agnostic CLI for managing reusable code templates"
+).version("0.1.0");
+program.command("init").description("Initialize CodeBrick in the system").action(initCommand);
+program.command("save <name> [path]").description("Create a new LOCAL template from files").option("-d, --description <desc>", "Template description").option("-t, --tags <tags>", "Comma-separated tags").option("--include <patterns>", "Glob patterns to include").option("--exclude <patterns>", "Glob patterns to exclude").option("--detect-deps", "Auto-detect dependencies from imports").action(saveCommand);
+program.command("list").alias("ls").description("List all saved templates").option("--local", "Show only local templates").option("--remote", "Show only remote templates").option("--tag <tag>", "Filter by tag").option("--detailed", "Show detailed view").action(listCommand);
+program.command("tree <name>").description("Display template file structure").option("--size", "Show file sizes").option("--preview", "Show content preview").action(treeCommand);
+program.command("apply <name> [destination]").description("Apply template to current/specified directory").option("-f, --force", "Overwrite existing files without prompting").option("--skip-existing", "Skip files that already exist").option("--dry-run", "Preview changes without writing files").option("--latest", "Use @latest for all dependency versions").option("--no-deps", "Don't prompt for dependency installation").action(applyCommand);
+program.command("info <name>").description("Show detailed template information").action(infoCommand);
+program.command("add <name> <files...>").description("Add files to an existing LOCAL template").action(addCommand);
+program.command("remove-file <name> <files...>").description("Remove files from a LOCAL template").action(removeFileCommand);
+program.command("delete <name>").alias("rm").description("Delete a template entirely").option("-f, --force", "Skip confirmation").action(deleteCommand);
+program.command("size [name]").description("Show template size(s) - all templates if no name provided").action(sizeCommand);
+program.command("clean <name>").description("Remove local/project-specific imports from template files").option("-p, --pattern <regex>", "Custom regex pattern to match imports to remove").option("--dry-run", "Preview changes without modifying files").option("--no-keep-external", "Also remove external package imports").action(cleanCommand);
+program.parse();