code-brick 0.1.0 → 0.2.0

package/README.md

@@ -312,6 +312,77 @@ import 'package:go_router/go_router.dart';
 
 The command auto-detects the project name from `pubspec.yaml`, `package.json`, or `pyproject.toml`.
 
+### `brick export <name|index>`
+
+Export a template as a shareable `.brick` file. Perfect for sharing templates with teammates or between machines.
+
+```bash
+# Export to current directory
+brick export nestjs-auth
+
+# By index
+brick export 0
+
+# Specify output path
+brick export 0 --output ~/Desktop/my-auth.brick
+```
+
+**Options:**
+
+- `-o, --output <path>` — Output file path (default: `./<name>.brick`)
+
+**Example output:**
+
+```
+┌ 🧱 Exporting template
+│  ● Template: nestjs-auth
+│  ● Files: 5 files
+│  ● Output: /Users/you/nestjs-auth.brick
+│
+│  ◇ Export complete!
+│    Size: 12.34 KB
+│
+│  Share this file and import with:
+│    brick import nestjs-auth.brick
+└
+```
+
+### `brick import <file>`
+
+Import a template from a `.brick` file.
+
+```bash
+# Import from .brick file
+brick import nestjs-auth.brick
+
+# Import with custom name
+brick import nestjs-auth.brick --name my-auth-v2
+
+# Force overwrite existing template
+brick import nestjs-auth.brick --force
+```
+
+**Options:**
+
+- `-n, --name <name>` — Custom name for the imported template
+- `-f, --force` — Overwrite existing template without prompting
+
+**Example output:**
+
+```
+┌ 🧱 Importing template
+│  ● File: /Users/you/nestjs-auth.brick
+│  ● Template: nestjs-auth
+│  ● Description: JWT authentication module
+│  ● Files: 5 files
+│
+│  ◇ Import complete!
+│
+│  View structure: brick tree nestjs-auth
+│  Apply template: brick apply nestjs-auth
+└
+```
+
 ## Smart Ignore System
 
 Brick **automatically ignores** common dependency directories, build outputs, and generated files across all frameworks. This keeps your templates clean and portable.
@@ -449,6 +520,20 @@ brick clean 2          # Remove local imports
 brick delete 1 --force
 ```
 
+### Share Templates with Your Team
+
+```bash
+# Export a template to share
+brick export nestjs-auth
+# Creates: nestjs-auth.brick (shareable file)
+
+# Send the .brick file to your teammate, then they run:
+brick import nestjs-auth.brick
+
+# Or import with a custom name
+brick import nestjs-auth.brick --name company-auth
+```
+
 ## Contributing
 
 Contributions are welcome! Please open an issue or submit a pull request.

package/dist/index.js

@@ -2,7 +2,7 @@
 
 // src/index.ts
 import { Command } from "commander";
-import pc13 from "picocolors";
+import pc15 from "picocolors";
 
 // src/commands/init.ts
 import * as p from "@clack/prompts";
@@ -518,16 +518,16 @@ async function saveCommand(name, sourcePath, options) {
   }
   let files;
   if (options.include) {
-    const patterns = options.include.split(",").map((p12) => p12.trim());
+    const patterns = options.include.split(",").map((p13) => p13.trim());
     files = await fg(patterns, {
       cwd: resolvedPath,
       dot: false,
-      ignore: options.exclude?.split(",").map((p12) => p12.trim()) || []
+      ignore: options.exclude?.split(",").map((p13) => p13.trim()) || []
     });
   } else {
     files = await getFilesRecursive(resolvedPath);
     if (options.exclude) {
-      const excludePatterns = options.exclude.split(",").map((p12) => p12.trim());
+      const excludePatterns = options.exclude.split(",").map((p13) => p13.trim());
       const excluded = await fg(excludePatterns, {
         cwd: resolvedPath,
         dot: false
@@ -1811,11 +1811,229 @@ async function cleanCommand(nameOrIndex, options) {
   p11.outro("Template cleaned successfully! \u2713");
 }
 
+// src/commands/export.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+import archiver from "archiver";
+import pc13 from "picocolors";
+async function exportCommand(templateNameOrIndex, options) {
+  if (!await isInitialized()) {
+    console.log(pc13.red("CodeBrick is not initialized. Run: brick init"));
+    process.exit(1);
+  }
+  const templateName = await resolveTemplateName(templateNameOrIndex);
+  if (!templateName) {
+    console.log(pc13.red(`Template '${templateNameOrIndex}' not found`));
+    process.exit(1);
+  }
+  const template = await getTemplate(templateName);
+  if (!template) {
+    console.log(pc13.red(`Template '${templateName}' not found`));
+    process.exit(1);
+  }
+  if (template.type !== "local") {
+    console.log(
+      pc13.red("Only local templates can be exported. Remote templates must be pulled first.")
+    );
+    process.exit(1);
+  }
+  const templatePath = getTemplatePath(templateName);
+  if (!await fs8.pathExists(templatePath)) {
+    console.log(pc13.red(`Template files not found at: ${templatePath}`));
+    process.exit(1);
+  }
+  const metadata = await loadTemplateMetadata(templateName);
+  if (!metadata) {
+    console.log(pc13.red("Template metadata not found"));
+    process.exit(1);
+  }
+  const outputFileName = `${templateName}.brick`;
+  const outputPath = options.output ? path8.resolve(options.output) : path8.join(process.cwd(), outputFileName);
+  await fs8.ensureDir(path8.dirname(outputPath));
+  console.log(pc13.cyan("\u250C \u{1F9F1} Exporting template"));
+  console.log(pc13.gray(`\u2502  \u25CF Template: ${pc13.white(templateName)}`));
+  console.log(pc13.gray(`\u2502  \u25CF Files: ${pc13.white(metadata.files.length.toString())} files`));
+  console.log(pc13.gray(`\u2502  \u25CF Output: ${pc13.white(outputPath)}`));
+  try {
+    await createBrickArchive(templatePath, outputPath, metadata);
+    const stats = await fs8.stat(outputPath);
+    const sizeKB = (stats.size / 1024).toFixed(2);
+    console.log(pc13.gray("\u2502"));
+    console.log(pc13.green(`\u2502  \u25C7 Export complete!`));
+    console.log(pc13.gray(`\u2502    Size: ${pc13.white(sizeKB + " KB")}`));
+    console.log(pc13.gray("\u2502"));
+    console.log(pc13.gray(`\u2502  Share this file and import with:`));
+    console.log(pc13.cyan(`\u2502    brick import ${outputFileName}`));
+    console.log(pc13.cyan("\u2514"));
+    console.log();
+    console.log(pc13.green(`\u2713 Template '${templateName}' exported to ${outputPath}`));
+  } catch (error) {
+    console.log(pc13.red(`\u2502  \u2717 Export failed: ${error.message}`));
+    console.log(pc13.cyan("\u2514"));
+    process.exit(1);
+  }
+}
+async function createBrickArchive(templatePath, outputPath, metadata) {
+  return new Promise((resolve, reject) => {
+    const output = fs8.createWriteStream(outputPath);
+    const archive = archiver("tar", {
+      gzip: true,
+      gzipOptions: { level: 9 }
+    });
+    output.on("close", () => resolve());
+    output.on("error", (err) => reject(err));
+    archive.on("error", (err) => reject(err));
+    archive.on("warning", (err) => {
+      if (err.code !== "ENOENT") {
+        reject(err);
+      }
+    });
+    archive.pipe(output);
+    archive.directory(templatePath, "template", (entry) => {
+      if (entry.name === "brick.json") {
+        return false;
+      }
+      return entry;
+    });
+    const metadataBuffer = Buffer.from(JSON.stringify(metadata, null, 2));
+    archive.append(metadataBuffer, { name: "brick.json" });
+    archive.finalize();
+  });
+}
+
+// src/commands/import.ts
+import fs9 from "fs-extra";
+import path9 from "path";
+import * as tar from "tar";
+import pc14 from "picocolors";
+import * as p12 from "@clack/prompts";
+async function importCommand(filePath, options) {
+  if (!await isInitialized()) {
+    console.log(pc14.red("CodeBrick is not initialized. Run: brick init"));
+    process.exit(1);
+  }
+  const absolutePath = path9.resolve(filePath);
+  if (!await fs9.pathExists(absolutePath)) {
+    console.log(pc14.red(`File not found: ${absolutePath}`));
+    process.exit(1);
+  }
+  if (!absolutePath.endsWith(".brick")) {
+    console.log(pc14.yellow("\u26A0 Warning: File does not have .brick extension"));
+  }
+  console.log(pc14.cyan("\u250C \u{1F9F1} Importing template"));
+  console.log(pc14.gray(`\u2502  \u25CF File: ${pc14.white(absolutePath)}`));
+  try {
+    const tempDir = path9.join(
+      process.cwd(),
+      `.brick-import-${Date.now()}`
+    );
+    await fs9.ensureDir(tempDir);
+    try {
+      await tar.extract({
+        file: absolutePath,
+        cwd: tempDir
+      });
+      const metadataPath = path9.join(tempDir, "brick.json");
+      if (!await fs9.pathExists(metadataPath)) {
+        throw new Error("Invalid .brick file: missing brick.json metadata");
+      }
+      const metadata = await fs9.readJson(metadataPath);
+      let templateName = options.name || metadata.name;
+      console.log(pc14.gray(`\u2502  \u25CF Template: ${pc14.white(templateName)}`));
+      console.log(pc14.gray(`\u2502  \u25CF Description: ${pc14.white(metadata.description || "No description")}`));
+      console.log(pc14.gray(`\u2502  \u25CF Files: ${pc14.white(metadata.files.length.toString())} files`));
+      if (await templateExists(templateName)) {
+        if (options.force) {
+          console.log(pc14.yellow(`\u2502  \u26A0 Overwriting existing template '${templateName}'`));
+        } else {
+          console.log(pc14.gray("\u2502"));
+          const shouldOverwrite = await p12.confirm({
+            message: `Template '${templateName}' already exists. Overwrite?`
+          });
+          if (p12.isCancel(shouldOverwrite) || !shouldOverwrite) {
+            const newName = await p12.text({
+              message: "Enter a new name for the template:",
+              placeholder: `${templateName}-imported`,
+              validate: (value) => {
+                if (!value) return "Name is required";
+                if (!/^[a-z0-9-_]+$/i.test(value)) {
+                  return "Name can only contain letters, numbers, hyphens, and underscores";
+                }
+              }
+            });
+            if (p12.isCancel(newName)) {
+              console.log(pc14.yellow("\u2502  Import cancelled"));
+              console.log(pc14.cyan("\u2514"));
+              await fs9.remove(tempDir);
+              return;
+            }
+            templateName = newName;
+            console.log(pc14.gray(`\u2502  \u25CF New name: ${pc14.white(templateName)}`));
+          }
+        }
+      }
+      const templateDir = getTemplatePath(templateName);
+      const sourceTemplateDir = path9.join(tempDir, "template");
+      if (await fs9.pathExists(templateDir)) {
+        await fs9.remove(templateDir);
+      }
+      if (await fs9.pathExists(sourceTemplateDir)) {
+        await fs9.copy(sourceTemplateDir, templateDir);
+      } else {
+        await fs9.ensureDir(templateDir);
+        const entries = await fs9.readdir(tempDir);
+        for (const entry of entries) {
+          if (entry !== "brick.json") {
+            await fs9.copy(
+              path9.join(tempDir, entry),
+              path9.join(templateDir, entry)
+            );
+          }
+        }
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const updatedMetadata = {
+        ...metadata,
+        name: templateName,
+        updatedAt: now,
+        source: {
+          origin: "local",
+          path: `imported from ${path9.basename(absolutePath)}`
+        }
+      };
+      await saveTemplateMetadata(templateName, updatedMetadata);
+      const storeEntry = {
+        type: "local",
+        path: templateDir,
+        description: metadata.description || "",
+        tags: metadata.tags || [],
+        createdAt: metadata.createdAt || now,
+        updatedAt: now
+      };
+      await addTemplateToStore(templateName, storeEntry);
+      console.log(pc14.gray("\u2502"));
+      console.log(pc14.green(`\u2502  \u25C7 Import complete!`));
+      console.log(pc14.gray("\u2502"));
+      console.log(pc14.gray(`\u2502  View structure: ${pc14.cyan(`brick tree ${templateName}`)}`));
+      console.log(pc14.gray(`\u2502  Apply template: ${pc14.cyan(`brick apply ${templateName}`)}`));
+      console.log(pc14.cyan("\u2514"));
+      console.log();
+      console.log(pc14.green(`\u2713 Template '${templateName}' imported successfully!`));
+    } finally {
+      await fs9.remove(tempDir);
+    }
+  } catch (error) {
+    console.log(pc14.red(`\u2502  \u2717 Import failed: ${error.message}`));
+    console.log(pc14.cyan("\u2514"));
+    process.exit(1);
+  }
+}
+
 // 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");
+  pc15.cyan("\u{1F9F1} CodeBrick") + " - A framework-agnostic CLI for managing reusable code templates"
+).version("0.2.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);
@@ -1827,4 +2045,6 @@ program.command("remove-file <name> <files...>").description("Remove files from
 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.command("export <name>").description("Export a template as a shareable .brick file").option("-o, --output <path>", "Output file path (default: ./<name>.brick)").action(exportCommand);
+program.command("import <file>").description("Import a template from a .brick file").option("-n, --name <name>", "Custom name for the imported template").option("-f, --force", "Overwrite existing template without prompting").action(importCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-brick",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "A framework-agnostic CLI tool for managing reusable code templates. Save, manage, and apply code snippets across projects.",
   "type": "module",
   "main": "dist/index.js",
@@ -39,14 +39,18 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.7.0",
+    "archiver": "^7.0.1",
     "commander": "^12.0.0",
+    "fast-glob": "^3.3.2",
     "fs-extra": "^11.2.0",
     "picocolors": "^1.0.0",
-    "fast-glob": "^3.3.2"
+    "tar": "^7.5.2"
   },
   "devDependencies": {
+    "@types/archiver": "^7.0.0",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.11.0",
+    "@types/tar": "^6.1.13",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3"
   },