jsrepo 1.2.4 → 1.3.1

package/dist/index.js

@@ -1,35 +1,37 @@
 // src/index.ts
-import fs11 from "node:fs";
-import path11 from "node:path";
+import fs12 from "node:fs";
+import path12 from "node:path";
 import { fileURLToPath } from "node:url";
-import { program as program5 } from "commander";
+import { program as program6 } from "commander";
 
 // src/commands/add.ts
 import fs6 from "node:fs";
 import path6 from "node:path";
 import { cancel, confirm, isCancel, multiselect, outro, spinner as spinner2 } from "@clack/prompts";
-import color5 from "chalk";
+import color7 from "chalk";
 import { Command, program as program2 } from "commander";
-import { execa } from "execa";
-import { resolveCommand } from "package-manager-detector/commands";
+import { resolveCommand as resolveCommand2 } from "package-manager-detector/commands";
 import { detect } from "package-manager-detector/detect";
 import * as v4 from "valibot";
 
-// src/blocks/utils/map-to-array.ts
-var mapToArray = (map, fn) => {
-  const items = [];
-  for (const [key, value] of map) {
-    items.push(fn(key, value));
-  }
-  return items;
-};
+// src/utils/ascii.ts
+import color from "chalk";
+var VERTICAL_LINE = color.gray("\u2502");
+var HORIZONTAL_LINE = color.gray("\u2500");
+var TOP_RIGHT_CORNER = color.gray("\u2510");
+var BOTTOM_RIGHT_CORNER = color.gray("\u2518");
+var JUNCTION_RIGHT = color.gray("\u251C");
+var TOP_LEFT_CORNER = color.gray("\u250C");
+var BOTTOM_LEFT_CORNER = color.gray("\u2514");
+var WARN = color.bgRgb(245, 149, 66).white("WARN");
+var INFO = color.bgBlueBright.white("INFO");
 
-// src/config/index.ts
-import fs from "node:fs";
-import path from "node:path";
-import * as v from "valibot";
+// src/utils/blocks.ts
+import fs4 from "node:fs";
+import path4 from "node:path";
+import color4 from "chalk";
 
-// src/blocks/types/result.ts
+// src/utils/blocks/types/result.ts
 var Result = class {
   _result;
   constructor(result) {
@@ -667,46 +669,30 @@ var Err = (err) => {
   return new Result({ ok: false, err });
 };
 
-// src/config/index.ts
-var CONFIG_NAME = "jsrepo.json";
-var schema = v.object({
-  $schema: v.string(),
-  repos: v.optional(v.array(v.string()), []),
-  includeTests: v.boolean(),
-  path: v.pipe(v.string(), v.minLength(1)),
-  watermark: v.optional(v.boolean(), true)
-});
-var getConfig = (cwd) => {
-  if (!fs.existsSync(path.join(cwd, CONFIG_NAME))) {
-    return Err("Could not find your configuration file! Please run `init`.");
-  }
-  const config = v.safeParse(
-    schema,
-    JSON.parse(fs.readFileSync(path.join(cwd, CONFIG_NAME)).toString())
-  );
-  if (!config.success) {
-    return Err(`There was an error reading your \`${CONFIG_NAME}\` file!`);
+// src/utils/blocks/utils/map-to-array.ts
+var mapToArray = (map, fn) => {
+  const items = [];
+  for (const [key, value] of map) {
+    items.push(fn(key, value));
   }
-  return Ok(config.output);
+  return items;
 };
 
+// src/utils/git-providers.ts
+import { Octokit } from "octokit";
+import * as v2 from "valibot";
+
 // src/utils/build.ts
-import fs4 from "node:fs";
-import path4 from "node:path";
+import fs3 from "node:fs";
+import path3 from "node:path";
 import color3 from "chalk";
 import { program } from "commander";
-import * as v2 from "valibot";
-
-// src/utils/index.ts
-import color from "chalk";
-var OUTPUT_FILE = "jsrepo-manifest.json";
-var WARN = color.bgRgb(245, 149, 66).white("WARN");
-var INFO = color.bgBlueBright.white("INFO");
+import * as v from "valibot";
 
 // src/utils/language-support.ts
-import fs3 from "node:fs";
+import fs2 from "node:fs";
 import { builtinModules } from "node:module";
-import path3 from "node:path";
+import path2 from "node:path";
 import color2 from "chalk";
 import { walk } from "estree-walker";
 import * as sv from "svelte/compiler";
@@ -714,11 +700,11 @@ import { Project } from "ts-morph";
 import validatePackageName from "validate-npm-package-name";
 
 // src/utils/package.ts
-import fs2 from "node:fs";
-import path2 from "node:path";
+import fs from "node:fs";
+import path from "node:path";
 var findNearestPackageJson = (startDir, until) => {
-  const packagePath = path2.join(startDir, "package.json");
-  if (fs2.existsSync(packagePath)) return packagePath;
+  const packagePath = path.join(startDir, "package.json");
+  if (fs.existsSync(packagePath)) return packagePath;
   if (startDir === until) return void 0;
   const segments = startDir.split(/[\/\\]/);
   return findNearestPackageJson(segments.slice(0, segments.length - 1).join("/"), until);
@@ -768,7 +754,7 @@ ${content}
 var svelte = {
   matches: (fileName) => fileName.endsWith(".svelte"),
   resolveDependencies: (filePath, category, isSubDir) => {
-    const sourceCode = fs3.readFileSync(filePath).toString();
+    const sourceCode = fs2.readFileSync(filePath).toString();
     const root = sv.parse(sourceCode, { modern: true });
     if (!root.instance) return Ok({ dependencies: [], devDependencies: [], local: [] });
     const localDeps = /* @__PURE__ */ new Set();
@@ -805,10 +791,10 @@ ${content}
 var resolveLocalImport = (mod, category, isSubDir) => {
   if (isSubDir && mod.startsWith("./")) return void 0;
   if (mod.startsWith("./")) {
-    return `${category}/${path3.parse(path3.basename(mod)).name}`;
+    return `${category}/${path2.parse(path2.basename(mod)).name}`;
   }
   if (isSubDir && mod.startsWith("../") && !mod.startsWith("../.")) {
-    return `${category}/${path3.parse(path3.basename(mod)).name}`;
+    return `${category}/${path2.parse(path2.basename(mod)).name}`;
   }
   const segments = mod.replaceAll("../", "").split("/");
   if (segments.length !== 2) return void 0;
@@ -818,11 +804,11 @@ var resolveRemoteDeps = (deps, filePath) => {
   const filteredDeps = deps.filter(
     (dep) => !builtinModules.includes(dep) && !dep.startsWith("node:")
   );
-  const pkgPath = findNearestPackageJson(path3.dirname(filePath), "");
+  const pkgPath = findNearestPackageJson(path2.dirname(filePath), "");
   const dependencies = /* @__PURE__ */ new Set();
   const devDependencies = /* @__PURE__ */ new Set();
   if (pkgPath) {
-    const { devDependencies: packageDevDependencies, dependencies: packageDependencies } = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+    const { devDependencies: packageDevDependencies, dependencies: packageDependencies } = JSON.parse(fs2.readFileSync(pkgPath, "utf-8"));
     for (const dep of filteredDeps) {
       const parsed = parsePackageName(dep);
       if (parsed.isErr()) {
@@ -864,55 +850,55 @@ var resolveRemoteDeps = (deps, filePath) => {
 var languages = [typescript, svelte];
 
 // src/utils/build.ts
-var blockSchema = v2.object({
-  name: v2.string(),
-  category: v2.string(),
-  localDependencies: v2.array(v2.string()),
-  dependencies: v2.array(v2.string()),
-  devDependencies: v2.array(v2.string()),
-  tests: v2.boolean(),
+var blockSchema = v.object({
+  name: v.string(),
+  category: v.string(),
+  localDependencies: v.array(v.string()),
+  dependencies: v.array(v.string()),
+  devDependencies: v.array(v.string()),
+  tests: v.boolean(),
   /** Where to find the block relative to root */
-  directory: v2.string(),
-  subdirectory: v2.boolean(),
-  files: v2.array(v2.string())
+  directory: v.string(),
+  subdirectory: v.boolean(),
+  files: v.array(v.string())
 });
-var categorySchema = v2.object({
-  name: v2.string(),
-  blocks: v2.array(blockSchema)
+var categorySchema = v.object({
+  name: v.string(),
+  blocks: v.array(blockSchema)
 });
 var TEST_SUFFIXES = [".test.ts", "_test.ts", ".test.js", "_test.js"];
 var isTestFile = (file) => TEST_SUFFIXES.find((suffix) => file.endsWith(suffix)) !== void 0;
 var buildBlocksDirectory = (blocksPath, cwd) => {
   let paths;
   try {
-    paths = fs4.readdirSync(blocksPath);
+    paths = fs3.readdirSync(blocksPath);
   } catch {
     program.error(color3.red(`Couldn't read the ${color3.bold(blocksPath)} directory.`));
   }
   const categories = [];
   for (const categoryPath of paths) {
-    const categoryDir = path4.join(blocksPath, categoryPath);
-    if (fs4.statSync(categoryDir).isFile()) continue;
-    const categoryName = path4.basename(categoryPath);
+    const categoryDir = path3.join(blocksPath, categoryPath);
+    if (fs3.statSync(categoryDir).isFile()) continue;
+    const categoryName = path3.basename(categoryPath);
     const category = {
       name: categoryName,
       blocks: []
     };
-    const files = fs4.readdirSync(categoryDir);
+    const files = fs3.readdirSync(categoryDir);
     for (const file of files) {
-      const blockDir = path4.join(categoryDir, file);
-      if (fs4.statSync(blockDir).isFile()) {
+      const blockDir = path3.join(categoryDir, file);
+      if (fs3.statSync(blockDir).isFile()) {
         if (isTestFile(file)) continue;
         const lang = languages.find((resolver) => resolver.matches(file));
         if (!lang) {
           console.warn(
             `${WARN} Skipped \`${color3.bold(blockDir)}\` \`${color3.bold(
-              path4.parse(file).ext
+              path3.parse(file).ext
             )}\` files are not currently supported!`
           );
           continue;
         }
-        const name2 = path4.parse(path4.basename(file)).name;
+        const name2 = path3.parse(path3.basename(file)).name;
         const testsPath = files.find(
           (f) => TEST_SUFFIXES.find((suffix) => f === `${name2}${suffix}`)
         );
@@ -924,7 +910,7 @@ var buildBlocksDirectory = (blocksPath, cwd) => {
         );
         const block = {
           name: name2,
-          directory: path4.relative(cwd, categoryDir),
+          directory: path3.relative(cwd, categoryDir),
           category: categoryName,
           tests: testsPath !== void 0,
           subdirectory: false,
@@ -939,7 +925,7 @@ var buildBlocksDirectory = (blocksPath, cwd) => {
         category.blocks.push(block);
       } else {
         const blockName = file;
-        const blockFiles = fs4.readdirSync(blockDir);
+        const blockFiles = fs3.readdirSync(blockDir);
         const hasTests = blockFiles.findIndex((f) => isTestFile(f)) !== -1;
         const localDepsSet = /* @__PURE__ */ new Set();
         const depsSet = /* @__PURE__ */ new Set();
@@ -949,13 +935,13 @@ var buildBlocksDirectory = (blocksPath, cwd) => {
           const lang = languages.find((resolver) => resolver.matches(f));
           if (!lang) {
             console.warn(
-              `${WARN} Skipped \`${color3.bold(path4.join(blockDir, f))}\` \`${color3.bold(
-                path4.parse(file).ext
+              `${WARN} Skipped \`${color3.bold(path3.join(blockDir, f))}\` \`${color3.bold(
+                path3.parse(file).ext
               )}\` files are not currently supported!`
             );
             continue;
           }
-          const { local, dependencies, devDependencies } = lang.resolveDependencies(path4.join(blockDir, f), categoryName, true).match(
+          const { local, dependencies, devDependencies } = lang.resolveDependencies(path3.join(blockDir, f), categoryName, true).match(
             (val) => val,
             (err) => {
               program.error(color3.red(err));
@@ -973,7 +959,7 @@ var buildBlocksDirectory = (blocksPath, cwd) => {
         }
         const block = {
           name: blockName,
-          directory: path4.relative(cwd, blockDir),
+          directory: path3.relative(cwd, blockDir),
           category: categoryName,
           tests: hasTests,
           subdirectory: true,
@@ -990,36 +976,10 @@ var buildBlocksDirectory = (blocksPath, cwd) => {
   return categories;
 };
 
-// src/utils/get-installed-blocks.ts
-import fs5 from "node:fs";
-import path5 from "node:path";
-var getInstalledBlocks = (blocks, config, cwd) => {
-  const installedBlocks = [];
-  for (const [_, block] of blocks) {
-    const baseDir = path5.join(cwd, config.path, block.category);
-    let blockPath = path5.join(baseDir, block.files[0]);
-    if (block.subdirectory) {
-      blockPath = path5.join(baseDir, block.name);
-    }
-    if (fs5.existsSync(blockPath))
-      installedBlocks.push({
-        specifier: `${block.category}/${block.name}`,
-        path: blockPath
-      });
-  }
-  return installedBlocks;
-};
-
-// src/utils/get-watermark.ts
-var getWatermark = (version2, repoUrl) => {
-  return `	jsrepo ${version2}
-	Installed from ${repoUrl}
-	${(/* @__PURE__ */ new Date()).toLocaleDateString().replaceAll("/", "-")}`;
-};
+// src/utils/context.ts
+var OUTPUT_FILE = "jsrepo-manifest.json";
 
 // src/utils/git-providers.ts
-import { Octokit } from "octokit";
-import * as v3 from "valibot";
 var octokit = new Octokit({});
 var github = {
   name: () => "github",
@@ -1069,38 +1029,194 @@ var github = {
   },
   matches: (repoPath) => repoPath.toLowerCase().startsWith("https://github.com") || repoPath.toLowerCase().startsWith("github")
 };
+var providers = [github];
 var getProviderInfo = async (repo) => {
-  if (github.matches(repo)) {
-    return Ok(await github.info(repo));
+  const provider = providers.find((provider2) => provider2.matches(repo));
+  if (provider) {
+    return Ok(await provider.info(repo));
   }
   return Err("Only GitHub repositories are supported at this time!");
 };
 var getManifest = async (url) => {
+  const errorMessage = (err) => {
+    return Err(
+      `There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root.
+ Error: ${err}`
+    );
+  };
   try {
     const response = await fetch(url);
     if (!response.ok) {
-      return Err(
-        `There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
-      );
+      return errorMessage(`${response.status} ${response.text}`);
     }
-    const categories = v3.parse(v3.array(categorySchema), await response.json());
+    const categories = v2.parse(v2.array(categorySchema), await response.json());
     return Ok(categories);
+  } catch (err) {
+    return errorMessage(`${err}`);
+  }
+};
+var fetchBlocks = async (...repos) => {
+  const blocksMap = /* @__PURE__ */ new Map();
+  for (const repo of repos) {
+    const getProviderResult = await getProviderInfo(repo);
+    if (getProviderResult.isErr()) return Err({ message: getProviderResult.unwrapErr(), repo });
+    const providerInfo = getProviderResult.unwrap();
+    const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
+    const getManifestResult = await getManifest(manifestUrl);
+    if (getManifestResult.isErr()) return Err({ message: getManifestResult.unwrapErr(), repo });
+    const categories = getManifestResult.unwrap();
+    for (const category of categories) {
+      for (const block of category.blocks) {
+        blocksMap.set(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
+          {
+            ...block,
+            sourceRepo: providerInfo
+          }
+        );
+      }
+    }
+  }
+  return Ok(blocksMap);
+};
+
+// src/utils/blocks.ts
+var resolveTree = async (blockSpecifiers, blocksMap, repoPaths) => {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const blockSpecifier of blockSpecifiers) {
+    let block = void 0;
+    if (!blockSpecifier.startsWith("github")) {
+      if (repoPaths.length === 0) {
+        return Err(
+          color4.red(
+            `If your config doesn't repos then you must provide the repo in the block specifier ex: \`${color4.bold(
+              `github/<owner>/<name>/${blockSpecifier}`
+            )}\`!`
+          )
+        );
+      }
+      for (const repo of repoPaths) {
+        const providerInfo = (await getProviderInfo(repo)).unwrap();
+        const tempBlock = blocksMap.get(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier}`
+        );
+        if (tempBlock === void 0) continue;
+        block = tempBlock;
+        break;
+      }
+    } else {
+      block = blocksMap.get(blockSpecifier);
+    }
+    if (!block) {
+      return Err(`Invalid block! ${color4.bold(blockSpecifier)} does not exist!`);
+    }
+    const fullSpecifier = `${block.sourceRepo.url}/${block.category}/${block.name}`;
+    blocks.set(fullSpecifier, { name: fullSpecifier, subDependency: false, block });
+    if (block.localDependencies && block.localDependencies.length > 0) {
+      const subDeps = await resolveTree(
+        block.localDependencies.filter((dep) => !blocks.has(dep)),
+        blocksMap,
+        repoPaths
+      );
+      if (subDeps.isErr()) return Err(subDeps.unwrapErr());
+      for (const dep of subDeps.unwrap()) {
+        blocks.set(dep.name, dep);
+      }
+    }
+  }
+  return Ok(mapToArray(blocks, (_, val) => val));
+};
+var getInstalled = (blocks, config, cwd) => {
+  const installedBlocks = [];
+  for (const [_, block] of blocks) {
+    const baseDir = path4.join(cwd, config.path, block.category);
+    let blockPath = path4.join(baseDir, block.files[0]);
+    if (block.subdirectory) {
+      blockPath = path4.join(baseDir, block.name);
+    }
+    if (fs4.existsSync(blockPath))
+      installedBlocks.push({
+        specifier: `${block.category}/${block.name}`,
+        path: blockPath,
+        block
+      });
+  }
+  return installedBlocks;
+};
+
+// src/utils/config.ts
+import fs5 from "node:fs";
+import path5 from "node:path";
+import * as v3 from "valibot";
+var CONFIG_NAME = "jsrepo.json";
+var schema = v3.object({
+  $schema: v3.string(),
+  repos: v3.optional(v3.array(v3.string()), []),
+  includeTests: v3.boolean(),
+  path: v3.pipe(v3.string(), v3.minLength(1)),
+  watermark: v3.optional(v3.boolean(), true)
+});
+var getConfig = (cwd) => {
+  if (!fs5.existsSync(path5.join(cwd, CONFIG_NAME))) {
+    return Err("Could not find your configuration file! Please run `init`.");
+  }
+  const config = v3.safeParse(
+    schema,
+    JSON.parse(fs5.readFileSync(path5.join(cwd, CONFIG_NAME)).toString())
+  );
+  if (!config.success) {
+    return Err(`There was an error reading your \`${CONFIG_NAME}\` file!`);
+  }
+  return Ok(config.output);
+};
+
+// src/utils/dependencies.ts
+import color5 from "chalk";
+import { execa } from "execa";
+import { resolveCommand } from "package-manager-detector";
+var installDependencies = async ({
+  pm,
+  deps,
+  dev,
+  cwd
+}) => {
+  let add2;
+  if (dev) {
+    add2 = resolveCommand(pm, "install", [...deps, "-D"]);
+  } else {
+    add2 = resolveCommand(pm, "install", [...deps]);
+  }
+  if (add2 == null) return Err(color5.red(`Could not resolve add command for '${pm}'.`));
+  try {
+    await execa(add2.command, [...add2.args], { cwd });
+    return Ok(deps);
   } catch {
     return Err(
-      `There was an error fetching the \`${OUTPUT_FILE}\` from the repository \`${url.href}\` make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
+      color5.red(
+        `Failed to install ${color5.bold(deps.join(", "))}! Failed while running '${color5.bold(
+          `${add2.command} ${add2.args.join(" ")}`
+        )}'`
+      )
     );
   }
 };
 
+// src/utils/get-watermark.ts
+var getWatermark = (version2, repoUrl) => {
+  return `	jsrepo ${version2}
+	Installed from ${repoUrl}
+	${(/* @__PURE__ */ new Date()).toLocaleDateString().replaceAll("/", "-")}`;
+};
+
 // src/utils/prompts.ts
 import { intro, spinner } from "@clack/prompts";
-import color4 from "chalk";
+import color6 from "chalk";
 
-// src/blocks/utils/strip-ansi.ts
+// src/utils/blocks/utils/strip-ansi.ts
 import ansiRegex from "ansi-regex";
 var stripAsni = (str) => str.replace(ansiRegex(), "");
 
-// src/blocks/utils/pad.ts
+// src/utils/blocks/utils/pad.ts
 var leftPadMin = (str, length, padWith = " ") => {
   if (stripAsni(str).length > length)
     throw new Error("String length is greater than the length provided.");
@@ -1116,21 +1232,25 @@ var rightPadMin = (str, length, padWith = " ") => {
 };
 
 // src/utils/prompts.ts
-var VERTICAL_BORDER = color4.gray("\u2502");
-var HORIZONTAL_BORDER = color4.gray("\u2500");
-var TOP_RIGHT_CORNER = color4.gray("\u2510");
-var BOTTOM_RIGHT_CORNER = color4.gray("\u2518");
-var JUNCTION_RIGHT = color4.gray("\u251C");
-var runTasks = async (tasks, { verbose = false }) => {
+var runTasks = async (tasks, { verbose = void 0 }) => {
   const loading = spinner();
   for (const task of tasks) {
-    if (!verbose) loading.start(task.loadingMessage);
+    if (verbose) {
+      verbose(task.loadingMessage);
+    } else {
+      loading.start(task.loadingMessage);
+    }
     try {
       await task.run();
     } catch (err) {
+      loading.stop(`Error while ${task.loadingMessage}`);
       console.error(err);
     }
-    if (!verbose) loading.stop(task.completedMessage);
+    if (verbose) {
+      verbose(task.completedMessage);
+    } else {
+      loading.stop(task.completedMessage);
+    }
   }
 };
 var nextSteps = (steps) => {
@@ -1140,40 +1260,44 @@ var nextSteps = (steps) => {
     if (reset.length > max) max = reset.length;
   });
   const NEXT_STEPS = "Next Steps";
-  let result = `${VERTICAL_BORDER}
+  let result = `${VERTICAL_LINE}
 `;
-  result += `${JUNCTION_RIGHT}  ${NEXT_STEPS} ${HORIZONTAL_BORDER.repeat(
+  result += `${JUNCTION_RIGHT}  ${NEXT_STEPS} ${HORIZONTAL_LINE.repeat(
     max - NEXT_STEPS.length - 1
   )}${TOP_RIGHT_CORNER}
 `;
-  result += `${VERTICAL_BORDER} ${" ".repeat(max)} ${VERTICAL_BORDER}
+  result += `${VERTICAL_LINE} ${" ".repeat(max)} ${VERTICAL_LINE}
 `;
   steps.map((step) => {
-    result += `${VERTICAL_BORDER}  ${rightPadMin(step, max - 1)} ${VERTICAL_BORDER}
+    result += `${VERTICAL_LINE}  ${rightPadMin(step, max - 1)} ${VERTICAL_LINE}
 `;
   });
-  result += `${VERTICAL_BORDER} ${" ".repeat(max)} ${VERTICAL_BORDER}
+  result += `${VERTICAL_LINE} ${" ".repeat(max)} ${VERTICAL_LINE}
 `;
-  result += `${JUNCTION_RIGHT}${HORIZONTAL_BORDER.repeat(max + 2)}${BOTTOM_RIGHT_CORNER}
+  result += `${JUNCTION_RIGHT}${HORIZONTAL_LINE.repeat(max + 2)}${BOTTOM_RIGHT_CORNER}
 `;
   return result;
 };
-var _intro = (version2) => intro(`${color4.bgHex("#f7df1e").black(" jsrepo ")}${color4.gray(` v${version2} `)}`);
+var _intro = (version2) => intro(`${color6.bgHex("#f7df1e").black(" jsrepo ")}${color6.gray(` v${version2} `)}`);
 
 // src/commands/add.ts
 var schema2 = v4.object({
-  yes: v4.boolean(),
-  verbose: v4.boolean(),
   repo: v4.optional(v4.string()),
   allow: v4.boolean(),
+  yes: v4.boolean(),
+  verbose: v4.boolean(),
   cwd: v4.string()
 });
-var add = new Command("add").argument("[blocks...]", "Names of the blocks you want to add to your project.").option("-y, --yes", "Add and install any required dependencies.", false).option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("--repo <repo>", "Repository to download the blocks from.").option("--verbose", "Include debug logs.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (blockNames, opts) => {
+var add = new Command("add").argument(
+  "[blocks...]",
+  "Names of the blocks you want to add to your project. ex: (utils/math, github/ieedan/std/utils/math)"
+).option("--repo <repo>", "Repository to download the blocks from.").option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("-y, --yes", "Skip confirmation prompt.", false).option("--verbose", "Include debug logs.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (blockNames, opts) => {
   const options = v4.parse(schema2, opts);
+  _intro(context.package.version);
   await _add(blockNames, options);
+  outro(color7.green("All done!"));
 });
 var _add = async (blockNames, options) => {
-  _intro(context.package.version);
   const verbose = (msg) => {
     if (options.verbose) {
       console.info(`${INFO} ${msg}`);
@@ -1183,9 +1307,8 @@ var _add = async (blockNames, options) => {
   const loading = spinner2();
   const config = getConfig(options.cwd).match(
     (val) => val,
-    (err) => program2.error(color5.red(err))
+    (err) => program2.error(color7.red(err))
   );
-  const blocksMap = /* @__PURE__ */ new Map();
   let repoPaths = config.repos;
   if (options.repo) repoPaths = [options.repo];
   for (const blockSpecifier of blockNames) {
@@ -1200,7 +1323,7 @@ var _add = async (blockNames, options) => {
     if (!repoPaths.find((repoPath) => repoPath === repo)) {
       if (!options.allow) {
         const result = await confirm({
-          message: `Allow ${color5.cyan("jsrepo")} to download and run code from ${color5.cyan(repo)}?`,
+          message: `Allow ${color7.cyan("jsrepo")} to download and run code from ${color7.cyan(repo)}?`,
           initialValue: true
         });
         if (isCancel(result) || !result) {
@@ -1213,7 +1336,7 @@ var _add = async (blockNames, options) => {
   }
   if (!options.allow && options.repo) {
     const result = await confirm({
-      message: `Allow ${color5.cyan("jsrepo")} to download and run code from ${color5.cyan(options.repo)}?`,
+      message: `Allow ${color7.cyan("jsrepo")} to download and run code from ${color7.cyan(options.repo)}?`,
       initialValue: true
     });
     if (isCancel(result) || !result) {
@@ -1221,40 +1344,25 @@ var _add = async (blockNames, options) => {
       process.exit(0);
     }
   }
-  verbose(`Fetching blocks from ${color5.cyan(repoPaths.join(", "))}`);
-  if (!options.verbose) loading.start(`Fetching blocks from ${color5.cyan(repoPaths.join(", "))}`);
-  for (const repo of repoPaths) {
-    const providerInfo = (await getProviderInfo(repo)).match(
-      (info) => info,
-      (err) => {
-        loading.stop(`Failed fetching blocks from ${color5.cyan(repo)}`);
-        program2.error(color5.red(err));
-      }
+  if (repoPaths.length === 0) {
+    program2.error(
+      color7.red(
+        `There were no repos present in your config and you didn't provide the \`${color7.bold("--repo")}\` flag with a repo.`
+      )
     );
-    const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
-    verbose(`Got info for provider ${color5.cyan(providerInfo.name)}`);
-    const categories = (await getManifest(manifestUrl)).match(
-      (val) => val,
-      (err) => {
-        loading.stop(`Failed fetching blocks from ${color5.cyan(repo)}`);
-        program2.error(color5.red(err));
-      }
-    );
-    for (const category of categories) {
-      for (const block of category.blocks) {
-        blocksMap.set(
-          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
-          {
-            ...block,
-            sourceRepo: providerInfo
-          }
-        );
-      }
-    }
   }
-  verbose(`Retrieved blocks from ${color5.cyan(repoPaths.join(", "))}`);
-  if (!options.verbose) loading.stop(`Retrieved blocks from ${color5.cyan(repoPaths.join(", "))}`);
-  const installedBlocks = getInstalledBlocks(blocksMap, config, options.cwd).map(
+  verbose(`Fetching blocks from ${color7.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.start(`Fetching blocks from ${color7.cyan(repoPaths.join(", "))}`);
+  const blocksMap = (await fetchBlocks(...repoPaths)).match(
+    (val) => val,
+    ({ repo, message }) => {
+      loading.stop(`Failed fetching blocks from ${color7.cyan(repo)}`);
+      program2.error(color7.red(message));
+    }
+  );
+  if (!options.verbose) loading.stop(`Retrieved blocks from ${color7.cyan(repoPaths.join(", "))}`);
+  verbose(`Retrieved blocks from ${color7.cyan(repoPaths.join(", "))}`);
+  const installedBlocks = getInstalled(blocksMap, config, options.cwd).map(
     (val) => val.specifier
   );
   let installingBlockNames = blockNames;
@@ -1266,14 +1374,14 @@ var _add = async (blockNames, options) => {
         const blockExists = installedBlocks.findIndex((block) => block === shortName) !== -1;
         let label;
         if (repoPaths.length > 1) {
-          label = `${color5.cyan(
+          label = `${color7.cyan(
             `${value.sourceRepo.name}/${value.sourceRepo.owner}/${value.sourceRepo.repoName}/${value.category}`
           )}/${value.name}`;
         } else {
-          label = `${color5.cyan(value.category)}/${value.name}`;
+          label = `${color7.cyan(value.category)}/${value.name}`;
         }
         return {
-          label: blockExists ? color5.gray(label) : label,
+          label: blockExists ? color7.gray(label) : label,
           value: key,
           // show hint for `Installed` if block is already installed
           hint: blockExists ? "Installed" : void 0
@@ -1287,9 +1395,12 @@ var _add = async (blockNames, options) => {
     }
     installingBlockNames = promptResult;
   }
-  verbose(`Installing blocks ${color5.cyan(installingBlockNames.join(", "))}`);
+  verbose(`Installing blocks ${color7.cyan(installingBlockNames.join(", "))}`);
   if (options.verbose) console.log("Blocks map: ", blocksMap);
-  const installingBlocks = await getBlocks(installingBlockNames, blocksMap, repoPaths, options);
+  const installingBlocks = (await resolveTree(installingBlockNames, blocksMap, repoPaths)).match(
+    (val) => val,
+    program2.error
+  );
   const pm = (await detect({ cwd: process.cwd() }))?.agent ?? "npm";
   const tasks = [];
   const devDeps = /* @__PURE__ */ new Set();
@@ -1298,13 +1409,12 @@ var _add = async (blockNames, options) => {
     const fullSpecifier = `${block.sourceRepo.url}/${block.category}/${block.name}`;
     const watermark = getWatermark(context.package.version, block.sourceRepo.url);
     const providerInfo = block.sourceRepo;
-    verbose(`Attempting to add ${fullSpecifier}`);
+    verbose(`Setting up ${fullSpecifier}`);
     const directory = path6.join(options.cwd, config.path, block.category);
-    verbose(`Creating directory ${color5.bold(directory)}`);
     const blockExists = !block.subdirectory && fs6.existsSync(path6.join(directory, block.files[0])) || block.subdirectory && fs6.existsSync(path6.join(directory, block.name));
     if (blockExists && !options.yes) {
       const result = await confirm({
-        message: `${color5.bold(block.name)} already exists in your project would you like to overwrite it?`,
+        message: `${color7.bold(block.name)} already exists in your project would you like to overwrite it?`,
         initialValue: false
       });
       if (isCancel(result) || !result) {
@@ -1316,15 +1426,16 @@ var _add = async (blockNames, options) => {
       loadingMessage: `Adding ${fullSpecifier}`,
       completedMessage: `Added ${fullSpecifier}`,
       run: async () => {
+        verbose(`Creating directory ${color7.bold(directory)}`);
         fs6.mkdirSync(directory, { recursive: true });
         const files = [];
         const getSourceFile = async (filePath) => {
           const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, filePath);
           const response = await fetch(rawUrl);
           if (!response.ok) {
-            loading.stop(color5.red(`Error fetching ${color5.bold(rawUrl.href)}`));
+            loading.stop(color7.red(`Error fetching ${color7.bold(rawUrl.href)}`));
             program2.error(
-              color5.red(`There was an error trying to get ${fullSpecifier}`)
+              color7.red(`There was an error trying to get ${fullSpecifier}`)
             );
           }
           return await response.text();
@@ -1375,31 +1486,7 @@ ${content}`;
       }
     });
   }
-  await runTasks(tasks, { verbose: options.verbose });
-  const installDependencies = async (deps2, dev) => {
-    if (!options.verbose) loading.start(`Installing dependencies with ${color5.cyan(pm)}`);
-    let add2;
-    if (dev) {
-      add2 = resolveCommand(pm, "install", [...deps2, "-D"]);
-    } else {
-      add2 = resolveCommand(pm, "install", [...deps2]);
-    }
-    if (add2 == null) {
-      program2.error(color5.red(`Could not resolve add command for '${pm}'.`));
-    }
-    try {
-      await execa(add2.command, [...add2.args], { cwd: options.cwd });
-    } catch {
-      program2.error(
-        color5.red(
-          `Failed to install ${color5.bold("vitest")}! Failed while running '${color5.bold(
-            `${add2.command} ${add2.args.join(" ")}`
-          )}'`
-        )
-      );
-    }
-    if (!options.verbose) loading.stop(`Installed ${color5.cyan(deps2.join(", "))}`);
-  };
+  await runTasks(tasks, { verbose: options.verbose ? verbose : void 0 });
   const hasDependencies = deps.size > 0 || devDeps.size > 0;
   if (hasDependencies) {
     let install = options.yes;
@@ -1416,24 +1503,56 @@ ${content}`;
     }
     if (install) {
       if (deps.size > 0) {
-        await installDependencies(Array.from(deps), false);
+        if (!options.verbose)
+          loading.start(`Installing dependencies with ${color7.cyan(pm)}`);
+        (await installDependencies({
+          pm,
+          deps: Array.from(deps),
+          dev: false,
+          cwd: options.cwd
+        })).match(
+          (installed) => {
+            if (!options.verbose)
+              loading.stop(`Installed ${color7.cyan(installed.join(", "))}`);
+          },
+          (err) => {
+            if (!options.verbose) loading.stop("Failed to install dependencies");
+            program2.error(err);
+          }
+        );
       }
       if (devDeps.size > 0) {
-        await installDependencies(Array.from(devDeps), true);
+        if (!options.verbose)
+          loading.start(`Installing dependencies with ${color7.cyan(pm)}`);
+        (await installDependencies({
+          pm,
+          deps: Array.from(devDeps),
+          dev: true,
+          cwd: options.cwd
+        })).match(
+          (installed) => {
+            if (!options.verbose)
+              loading.stop(`Installed ${color7.cyan(installed.join(", "))}`);
+          },
+          (err) => {
+            if (!options.verbose) loading.stop("Failed to install dev dependencies");
+            program2.error(err);
+          }
+        );
       }
     }
     let steps = [];
     if (!install) {
       if (deps.size > 0) {
-        const cmd = resolveCommand(pm, "install", [...deps]);
+        const cmd = resolveCommand2(pm, "install", [...deps]);
         steps.push(
-          `Install dependencies \`${color5.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
+          `Install dependencies \`${color7.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
         );
       }
       if (devDeps.size > 0) {
-        const cmd = resolveCommand(pm, "install", [...devDeps, "-D"]);
+        const cmd = resolveCommand2(pm, "install", [...devDeps, "-D"]);
         steps.push(
-          `Install dev dependencies \`${color5.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
+          `Install dev dependencies \`${color7.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
         );
       }
     }
@@ -1441,88 +1560,41 @@ ${content}`;
     if (!install) {
       steps.push("");
     }
-    steps.push(`Import the blocks from \`${color5.cyan(config.path)}\``);
+    steps.push(`Import the blocks from \`${color7.cyan(config.path)}\``);
     const next = nextSteps(steps);
     process.stdout.write(next);
   }
-  outro(color5.green("All done!"));
-};
-var getBlocks = async (blockSpecifiers, blocksMap, repoPaths, options) => {
-  const blocks = /* @__PURE__ */ new Map();
-  for (const blockSpecifier of blockSpecifiers) {
-    let block = void 0;
-    if (!blockSpecifier.startsWith("github")) {
-      if (repoPaths.length === 0) {
-        program2.error(
-          color5.red(
-            `If your config doesn't repos then you must provide the repo in the block specifier ex: \`${color5.bold(
-              `github/<owner>/<name>/${blockSpecifier}`
-            )}\`!`
-          )
-        );
-      }
-      for (const repo of repoPaths) {
-        const providerInfo = (await getProviderInfo(repo)).unwrap();
-        const tempBlock = blocksMap.get(
-          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier}`
-        );
-        if (tempBlock === void 0) continue;
-        block = tempBlock;
-        break;
-      }
-    } else {
-      block = blocksMap.get(blockSpecifier);
-    }
-    if (!block) {
-      program2.error(
-        color5.red(`Invalid block! ${color5.bold(blockSpecifier)} does not exist!`)
-      );
-    }
-    const fullSpecifier = `${block.sourceRepo.url}/${block.category}/${block.name}`;
-    blocks.set(fullSpecifier, { name: fullSpecifier, subDependency: false, block });
-    if (block.localDependencies && block.localDependencies.length > 0) {
-      const subDeps = await getBlocks(
-        block.localDependencies.filter((dep) => !blocks.has(dep)),
-        blocksMap,
-        repoPaths,
-        options
-      );
-      for (const dep of subDeps) {
-        blocks.set(dep.name, dep);
-      }
-    }
-  }
-  return mapToArray(blocks, (_, val) => val);
 };
 
 // src/commands/build.ts
 import fs7 from "node:fs";
 import path7 from "node:path";
 import { outro as outro2, spinner as spinner3 } from "@clack/prompts";
-import color6 from "chalk";
+import color8 from "chalk";
 import { Command as Command2 } from "commander";
 import * as v5 from "valibot";
 var schema3 = v5.object({
-  verbose: v5.boolean(),
-  output: v5.boolean(),
   dirs: v5.array(v5.string()),
+  output: v5.boolean(),
+  verbose: v5.boolean(),
   cwd: v5.string()
 });
 var build = new Command2("build").description(`Builds the provided --dirs in the project root into a \`${OUTPUT_FILE}\` file.`).option("--dirs [dirs...]", "The directories containing the blocks.", ["./blocks"]).option("--no-output", `Do not output a \`${OUTPUT_FILE}\` file.`).option("--verbose", "Include debug logs.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (opts) => {
   const options = v5.parse(schema3, opts);
+  _intro(context.package.version);
   await _build(options);
+  outro2(color8.green("All done!"));
 });
 var _build = async (options) => {
-  _intro(context.package.version);
   const loading = spinner3();
   const categories = [];
   const outFile = path7.join(options.cwd, OUTPUT_FILE);
   for (const dir of options.dirs) {
     const dirPath = path7.join(options.cwd, dir);
-    loading.start(`Building ${color6.cyan(dirPath)}`);
+    loading.start(`Building ${color8.cyan(dirPath)}`);
     if (options.output && fs7.existsSync(outFile)) fs7.rmSync(outFile);
     categories.push(...buildBlocksDirectory(dirPath, options.cwd));
-    loading.stop(`Built ${color6.cyan(dirPath)}`);
+    loading.stop(`Built ${color8.cyan(dirPath)}`);
   }
   const categoriesMap = /* @__PURE__ */ new Map();
   for (const category of categories) {
@@ -1539,23 +1611,22 @@ var _build = async (options) => {
   } else {
     loading.stop("Built successfully!");
   }
-  outro2(color6.green("All done!"));
 };
 
 // src/commands/diff.ts
 import fs8 from "node:fs";
 import path8 from "node:path";
 import { cancel as cancel2, confirm as confirm2, isCancel as isCancel2, outro as outro3, spinner as spinner4 } from "@clack/prompts";
-import color8 from "chalk";
+import color10 from "chalk";
 import { Command as Command3, program as program3 } from "commander";
 import { diffLines } from "diff";
 import * as v6 from "valibot";
 
 // src/utils/diff.ts
-import color7 from "chalk";
+import color9 from "chalk";
 import { diffChars } from "diff";
 
-// src/blocks/utils/array-sum.ts
+// src/utils/blocks/utils/array-sum.ts
 var arraySum = (arr, fn) => {
   let total = 0;
   for (const item of arr) {
@@ -1564,7 +1635,7 @@ var arraySum = (arr, fn) => {
   return total;
 };
 
-// src/blocks/utils/lines.ts
+// src/utils/blocks/utils/lines.ts
 import os from "node:os";
 var NEW_LINE_REGEX = /\n|\r\n/g;
 var get = (str) => str.split(NEW_LINE_REGEX);
@@ -1601,10 +1672,10 @@ var formatDiff = ({
   changes,
   expand = false,
   maxUnchanged = 5,
-  colorRemoved = color7.red,
-  colorAdded = color7.green,
-  colorCharsRemoved = color7.bgRed,
-  colorCharsAdded = color7.bgGreen,
+  colorRemoved = color9.red,
+  colorAdded = color9.green,
+  colorCharsRemoved = color9.bgRed,
+  colorCharsAdded = color9.bgGreen,
   prefix,
   onUnchanged,
   intro: intro2
@@ -1638,7 +1709,7 @@ var formatDiff = ({
     onUnchanged,
     intro: intro2
   });
-  const linePrefix = (line) => color7.gray(`${prefix?.() ?? ""}${leftPadMin(`${line + 1 + lineOffset} `, length)} `);
+  const linePrefix = (line) => color9.gray(`${prefix?.() ?? ""}${leftPadMin(`${line + 1 + lineOffset} `, length)} `);
   for (let i = 0; i < changes.length; i++) {
     const change = changes[i];
     const hasPreviousChange = changes[i - 1]?.added || changes[i - 1]?.removed;
@@ -1668,8 +1739,8 @@ var formatDiff = ({
           const count = ls.length - shownLines;
           result += `${join(
             get(
-              color7.gray(
-                `+ ${count} more unchanged (${color7.italic("-E to expand")})`
+              color9.gray(
+                `+ ${count} more unchanged (${color9.italic("-E to expand")})`
               )
             ),
             {
@@ -1743,37 +1814,36 @@ var formatDiff = ({
 };
 
 // src/commands/diff.ts
-var L = color8.gray("\u2502");
 var schema4 = v6.object({
-  allow: v6.boolean(),
   expand: v6.boolean(),
   maxUnchanged: v6.number(),
   repo: v6.optional(v6.string()),
+  allow: v6.boolean(),
   cwd: v6.string()
 });
-var diff = new Command3("diff").description("Compares local blocks to the blocks in the provided repository.").option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("-E, --expand", "Expands the diff so you see everything.", false).option("--repo <repo>", "Repository to download the blocks from.").option(
+var diff = new Command3("diff").description("Compares local blocks to the blocks in the provided repository.").option("-E, --expand", "Expands the diff so you see everything.", false).option(
   "--max-unchanged <number>",
   "Maximum unchanged lines that will show without being collapsed.",
   (val) => Number.parseInt(val),
   // this is such a dumb api thing
   3
-).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (opts) => {
+).option("--repo <repo>", "Repository to download the blocks from.").option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (opts) => {
   const options = v6.parse(schema4, opts);
+  _intro(context.package.version);
   await _diff(options);
+  outro3(color10.green("All done!"));
 });
 var _diff = async (options) => {
-  _intro(context.package.version);
   const loading = spinner4();
   const config = getConfig(options.cwd).match(
     (val) => val,
-    (err) => program3.error(color8.red(err))
+    (err) => program3.error(color10.red(err))
   );
-  const blocksMap = /* @__PURE__ */ new Map();
   let repoPaths = config.repos;
   if (options.repo) repoPaths = [options.repo];
   if (!options.allow && options.repo) {
     const result = await confirm2({
-      message: `Allow ${color8.cyan("jsrepo")} to download and run code from ${color8.cyan(options.repo)}?`,
+      message: `Allow ${color10.cyan("jsrepo")} to download and run code from ${color10.cyan(options.repo)}?`,
       initialValue: true
     });
     if (isCancel2(result) || !result) {
@@ -1781,31 +1851,16 @@ var _diff = async (options) => {
       process.exit(0);
     }
   }
-  loading.start(`Fetching blocks from ${color8.cyan(repoPaths.join(", "))}`);
-  for (const repo of repoPaths) {
-    const providerInfo = (await getProviderInfo(repo)).match(
-      (info) => info,
-      (err) => program3.error(color8.red(err))
-    );
-    const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
-    const categories = (await getManifest(manifestUrl)).match(
-      (val) => val,
-      (err) => program3.error(color8.red(err))
-    );
-    for (const category of categories) {
-      for (const block of category.blocks) {
-        blocksMap.set(
-          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${category.name}/${block.name}`,
-          {
-            ...block,
-            sourceRepo: providerInfo
-          }
-        );
-      }
+  loading.start(`Fetching blocks from ${color10.cyan(repoPaths.join(", "))}`);
+  const blocksMap = (await fetchBlocks(...repoPaths)).match(
+    (val) => val,
+    ({ repo, message }) => {
+      loading.stop(`Failed fetching blocks from ${color10.cyan(repo)}`);
+      program3.error(color10.red(message));
     }
-  }
-  loading.stop(`Retrieved blocks from ${color8.cyan(repoPaths.join(", "))}`);
-  const installedBlocks = getInstalledBlocks(blocksMap, config, options.cwd);
+  );
+  loading.stop(`Retrieved blocks from ${color10.cyan(repoPaths.join(", "))}`);
+  const installedBlocks = getInstalled(blocksMap, config, options.cwd);
   for (const blockSpecifier of installedBlocks) {
     let found = false;
     for (const repo of repoPaths) {
@@ -1813,21 +1868,21 @@ var _diff = async (options) => {
       const fullSpecifier = `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}/${blockSpecifier.specifier}`;
       const block = blocksMap.get(fullSpecifier);
       if (block === void 0) continue;
+      const watermark = getWatermark(context.package.version, repo);
       found = true;
-      process.stdout.write(`${L}
+      process.stdout.write(`${VERTICAL_LINE}
 `);
-      process.stdout.write(`${L}  ${fullSpecifier}
+      process.stdout.write(`${VERTICAL_LINE}  ${fullSpecifier}
 `);
-      fullSpecifier;
       for (const file of block.files) {
         if (!config.includeTests && isTestFile(file)) continue;
-        process.stdout.write(`${L}
+        process.stdout.write(`${VERTICAL_LINE}
 `);
         const sourcePath = path8.join(block.directory, file);
         const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, sourcePath);
         const response = await fetch(rawUrl);
         if (!response.ok) {
-          program3.error(color8.red(`There was an error trying to get ${fullSpecifier}`));
+          program3.error(color10.red(`There was an error trying to get ${fullSpecifier}`));
         }
         let remoteContent = await response.text();
         const directory = path8.join(options.cwd, config.path, block.category);
@@ -1844,7 +1899,6 @@ var _diff = async (options) => {
         if (config.watermark) {
           const lang = languages.find((lang2) => lang2.matches(sourcePath));
           if (lang) {
-            const watermark = getWatermark(context.package.version, repo);
             const comment = lang.comment(watermark);
             remoteContent = `${comment}
 
@@ -1863,16 +1917,16 @@ ${remoteContent}`;
           changes,
           expand: options.expand,
           maxUnchanged: options.maxUnchanged,
-          colorAdded: color8.greenBright,
-          colorRemoved: color8.redBright,
-          colorCharsAdded: color8.bgGreenBright,
-          colorCharsRemoved: color8.bgRedBright,
-          prefix: () => `${L}  `,
-          onUnchanged: ({ from: from2, to: to2, prefix }) => `${prefix?.() ?? ""}${color8.cyan(from2)} \u2192 ${color8.gray(to2)} ${color8.gray("(unchanged)")}
+          colorAdded: color10.greenBright,
+          colorRemoved: color10.redBright,
+          colorCharsAdded: color10.bgGreenBright,
+          colorCharsRemoved: color10.bgRedBright,
+          prefix: () => `${VERTICAL_LINE}  `,
+          onUnchanged: ({ from: from2, to: to2, prefix }) => `${prefix?.() ?? ""}${color10.cyan(from2)} \u2192 ${color10.gray(to2)} ${color10.gray("(unchanged)")}
 `,
           intro: ({ from: from2, to: to2, changes: changes2, prefix }) => {
             const totalChanges = changes2.filter((a) => a.added).length;
-            return `${prefix?.() ?? ""}${color8.cyan(from2)} \u2192 ${color8.gray(to2)} (${totalChanges} change${totalChanges === 1 ? "" : "s"})
+            return `${prefix?.() ?? ""}${color10.cyan(from2)} \u2192 ${color10.gray(to2)} (${totalChanges} change${totalChanges === 1 ? "" : "s"})
 ${prefix?.() ?? ""}
 `;
           }
@@ -1883,25 +1937,24 @@ ${prefix?.() ?? ""}
     }
     if (!found) {
       program3.error(
-        color8.red(`Invalid block! ${color8.bold(blockSpecifier)} does not exist!`)
+        color10.red(`Invalid block! ${color10.bold(blockSpecifier)} does not exist!`)
       );
     }
   }
-  outro3(color8.green("All done!"));
 };
 
 // src/commands/init.ts
 import fs9 from "node:fs";
 import path9 from "node:path";
 import { cancel as cancel3, confirm as confirm3, isCancel as isCancel3, outro as outro4, spinner as spinner5, text } from "@clack/prompts";
-import color9 from "chalk";
+import color11 from "chalk";
 import { Command as Command4 } from "commander";
 import * as v7 from "valibot";
 var schema5 = v7.object({
   path: v7.optional(v7.string()),
-  tests: v7.optional(v7.boolean()),
   repos: v7.optional(v7.array(v7.string())),
   watermark: v7.boolean(),
+  tests: v7.optional(v7.boolean()),
   cwd: v7.string()
 });
 var init = new Command4("init").description("Initializes your project with a configuration file.").option("--path <path>", "Path to install the blocks.").option("--repos [repos...]", "Repository to install the blocks from.").option(
@@ -1909,10 +1962,11 @@ var init = new Command4("init").description("Initializes your project with a con
   "Will not add a watermark to each file upon adding it to your project."
 ).option("--tests", "Will include tests with the blocks.").option("--cwd <path>", "The current working directory.", process.cwd()).action(async (opts) => {
   const options = v7.parse(schema5, opts);
+  _intro(context.package.version);
   await _init(options);
+  outro4(color11.green("All done!"));
 });
 var _init = async (options) => {
-  _intro(context.package.version);
   const initialConfig = getConfig(options.cwd);
   const loading = spinner5();
   if (!options.path) {
@@ -1934,7 +1988,8 @@ var _init = async (options) => {
     while (true) {
       const confirmResult = await confirm3({
         message: `Add ${options.repos.length > 0 ? "another" : "a"} repo?`,
-        initialValue: false
+        initialValue: options.repos.length === 0
+        // default to yes for first repo
       });
       if (isCancel3(confirmResult)) {
         cancel3("Canceled!");
@@ -1946,7 +2001,7 @@ var _init = async (options) => {
         placeholder: "github/ieedan/std",
         validate: (val) => {
           if (!val.startsWith("https://github.com") && !val.startsWith("github/")) {
-            return `Must be a ${color9.bold("GitHub")} repository!`;
+            return `Must be a ${color11.bold("GitHub")} repository!`;
           }
         }
       });
@@ -1972,33 +2027,33 @@ var _init = async (options) => {
   );
   fs9.mkdirSync(path9.join(options.cwd, config.path), { recursive: true });
   loading.stop(`Wrote config to \`${CONFIG_NAME}\`.`);
-  outro4(color9.green("All done!"));
 };
 
 // src/commands/test.ts
 import fs10 from "node:fs";
 import path10 from "node:path";
 import { cancel as cancel4, confirm as confirm4, isCancel as isCancel4, outro as outro5, spinner as spinner6 } from "@clack/prompts";
-import color10 from "chalk";
+import color12 from "chalk";
 import { Argument, Command as Command5, program as program4 } from "commander";
 import { execa as execa2 } from "execa";
-import { resolveCommand as resolveCommand2 } from "package-manager-detector/commands";
+import { resolveCommand as resolveCommand3 } from "package-manager-detector/commands";
 import { detect as detect2 } from "package-manager-detector/detect";
 import { Project as Project2 } from "ts-morph";
 import * as v8 from "valibot";
 var schema6 = v8.object({
-  debug: v8.boolean(),
-  verbose: v8.boolean(),
   repo: v8.optional(v8.string()),
   allow: v8.boolean(),
+  debug: v8.boolean(),
+  verbose: v8.boolean(),
   cwd: v8.string()
 });
-var test = new Command5("test").description("Tests local blocks against most recent remote tests.").addArgument(new Argument("[blocks...]", "The blocks you want to test.").default([])).option("--verbose", "Include debug logs.", false).option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("--repo <repo>", "Repository to download the blocks from.").option("--debug", "Leaves the temp test file around for debugging upon failure.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (blockNames, opts) => {
+var test = new Command5("test").description("Tests local blocks against most recent remote tests.").addArgument(new Argument("[blocks...]", "The blocks you want to test.").default([])).option("--repo <repo>", "Repository to download the blocks from.").option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("--debug", "Leaves the temp test file around for debugging upon failure.", false).option("--verbose", "Include debug logs.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (blockNames, opts) => {
   const options = v8.parse(schema6, opts);
+  _intro(context.package.version);
   await _test(blockNames, options);
+  outro5(color12.green("All done!"));
 });
 var _test = async (blockNames, options) => {
-  _intro(context.package.version);
   const verbose = (msg) => {
     if (options.verbose) {
       console.info(`${INFO} ${msg}`);
@@ -2007,7 +2062,7 @@ var _test = async (blockNames, options) => {
   verbose(`Attempting to test ${JSON.stringify(blockNames)}`);
   const config = getConfig(options.cwd).match(
     (val) => val,
-    (err) => program4.error(color10.red(err))
+    (err) => program4.error(color12.red(err))
   );
   const loading = spinner6();
   const blocksMap = /* @__PURE__ */ new Map();
@@ -2015,7 +2070,7 @@ var _test = async (blockNames, options) => {
   if (options.repo) repoPaths = [options.repo];
   if (!options.allow && options.repo) {
     const result = await confirm4({
-      message: `Allow ${color10.cyan("jsrepo")} to download and run code from ${color10.cyan(options.repo)}?`,
+      message: `Allow ${color12.cyan("jsrepo")} to download and run code from ${color12.cyan(options.repo)}?`,
       initialValue: true
     });
     if (isCancel4(result) || !result) {
@@ -2023,21 +2078,21 @@ var _test = async (blockNames, options) => {
       process.exit(0);
     }
   }
-  verbose(`Fetching blocks from ${color10.cyan(repoPaths.join(", "))}`);
-  if (!options.verbose) loading.start(`Fetching blocks from ${color10.cyan(repoPaths.join(", "))}`);
+  verbose(`Fetching blocks from ${color12.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.start(`Fetching blocks from ${color12.cyan(repoPaths.join(", "))}`);
   for (const repo of repoPaths) {
     const providerInfo = (await getProviderInfo(repo)).match(
       (info) => info,
-      (err) => program4.error(color10.red(err))
+      (err) => program4.error(color12.red(err))
     );
     const manifestUrl = await providerInfo.provider.resolveRaw(providerInfo, OUTPUT_FILE);
-    verbose(`Got info for provider ${color10.cyan(providerInfo.name)}`);
+    verbose(`Got info for provider ${color12.cyan(providerInfo.name)}`);
     const response = await fetch(manifestUrl);
     if (!response.ok) {
-      if (!options.verbose) loading.stop(`Error fetching ${color10.cyan(manifestUrl.href)}`);
+      if (!options.verbose) loading.stop(`Error fetching ${color12.cyan(manifestUrl.href)}`);
       program4.error(
-        color10.red(
-          `There was an error fetching the \`${OUTPUT_FILE}\` from the repository ${color10.cyan(
+        color12.red(
+          `There was an error fetching the \`${OUTPUT_FILE}\` from the repository ${color12.cyan(
             repo
           )} make sure the target repository has a \`${OUTPUT_FILE}\` in its root?`
         )
@@ -2056,17 +2111,17 @@ var _test = async (blockNames, options) => {
       }
     }
   }
-  verbose(`Retrieved blocks from ${color10.cyan(repoPaths.join(", "))}`);
-  if (!options.verbose) loading.stop(`Retrieved blocks from ${color10.cyan(repoPaths.join(", "))}`);
+  verbose(`Retrieved blocks from ${color12.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.stop(`Retrieved blocks from ${color12.cyan(repoPaths.join(", "))}`);
   const tempTestDirectory = path10.resolve(
     path10.join(options.cwd, `blocks-tests-temp-${Date.now()}`)
   );
-  verbose(`Trying to create the temp directory ${color10.bold(tempTestDirectory)}.`);
+  verbose(`Trying to create the temp directory ${color12.bold(tempTestDirectory)}.`);
   fs10.mkdirSync(tempTestDirectory, { recursive: true });
   const cleanUp = () => {
     fs10.rmSync(tempTestDirectory, { recursive: true, force: true });
   };
-  const installedBlocks = getInstalledBlocks(blocksMap, config, options.cwd).map(
+  const installedBlocks = getInstalled(blocksMap, config, options.cwd).map(
     (val) => val.specifier
   );
   let testingBlocks = blockNames;
@@ -2075,7 +2130,7 @@ var _test = async (blockNames, options) => {
   }
   if (testingBlocks.length === 0) {
     cleanUp();
-    program4.error(color10.red("There were no blocks found in your project!"));
+    program4.error(color12.red("There were no blocks found in your project!"));
   }
   const testingBlocksMapped = [];
   for (const blockSpecifier of testingBlocks) {
@@ -2101,7 +2156,7 @@ var _test = async (blockNames, options) => {
         }
         const providerInfo = (await getProviderInfo(repo)).match(
           (val) => val,
-          (err) => program4.error(color10.red(err))
+          (err) => program4.error(color12.red(err))
         );
         const manifestUrl = await providerInfo.provider.resolveRaw(
           providerInfo,
@@ -2109,7 +2164,7 @@ var _test = async (blockNames, options) => {
         );
         const categories = (await getManifest(manifestUrl)).match(
           (val) => val,
-          (err) => program4.error(color10.red(err))
+          (err) => program4.error(color12.red(err))
         );
         for (const category of categories) {
           for (const block2 of category.blocks) {
@@ -2127,7 +2182,7 @@ var _test = async (blockNames, options) => {
     }
     if (!block) {
       program4.error(
-        color10.red(`Invalid block! ${color10.bold(blockSpecifier)} does not exist!`)
+        color12.red(`Invalid block! ${color12.bold(blockSpecifier)} does not exist!`)
       );
     }
     testingBlocksMapped.push({ name: blockSpecifier, block });
@@ -2135,18 +2190,18 @@ var _test = async (blockNames, options) => {
   for (const { name: specifier, block } of testingBlocksMapped) {
     const providerInfo = block.sourceRepo;
     if (!options.verbose) {
-      loading.start(`Setting up test file for ${color10.cyan(specifier)}`);
+      loading.start(`Setting up test file for ${color12.cyan(specifier)}`);
     }
     if (!block.tests) {
-      loading.stop(`No tests found for ${color10.cyan(specifier)}`);
+      loading.stop(`No tests found for ${color12.cyan(specifier)}`);
       continue;
     }
     const getSourceFile = async (filePath) => {
       const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, filePath);
       const response = await fetch(rawUrl);
       if (!response.ok) {
-        loading.stop(color10.red(`Error fetching ${color10.bold(rawUrl.href)}`));
-        program4.error(color10.red(`There was an error trying to get ${specifier}`));
+        loading.stop(color12.red(`Error fetching ${color12.bold(rawUrl.href)}`));
+        program4.error(color12.red(`There was an error trying to get ${specifier}`));
       }
       return await response.text();
     };
@@ -2189,19 +2244,19 @@ var _test = async (blockNames, options) => {
       }
     }
     project.saveSync();
-    verbose(`Completed ${color10.cyan.bold(specifier)} test file`);
+    verbose(`Completed ${color12.cyan.bold(specifier)} test file`);
     if (!options.verbose) {
-      loading.stop(`Completed setup for ${color10.bold(specifier)}`);
+      loading.stop(`Completed setup for ${color12.bold(specifier)}`);
     }
   }
   verbose("Beginning testing");
   const pm = await detect2({ cwd: options.cwd });
   if (pm == null) {
-    program4.error(color10.red("Could not detect package manager"));
+    program4.error(color12.red("Could not detect package manager"));
   }
-  const resolved = resolveCommand2(pm.agent, "execute", ["vitest", "run", tempTestDirectory]);
+  const resolved = resolveCommand3(pm.agent, "execute", ["vitest", "run", tempTestDirectory]);
   if (resolved == null) {
-    program4.error(color10.red(`Could not resolve add command for '${pm.agent}'.`));
+    program4.error(color12.red(`Could not resolve add command for '${pm.agent}'.`));
   }
   const { command, args } = resolved;
   const testCommand = `${command} ${args.join(" ")}`;
@@ -2215,11 +2270,10 @@ var _test = async (blockNames, options) => {
   try {
     await testingProcess;
     cleanUp();
-    outro5(color10.green("All done!"));
   } catch (err) {
     if (options.debug) {
       console.info(
-        `${color10.bold("--debug")} flag provided. Skipping cleanup. Run '${color10.bold(
+        `${color12.bold("--debug")} flag provided. Skipping cleanup. Run '${color12.bold(
           testCommand
         )}' to retry tests.
 `
@@ -2227,17 +2281,328 @@ var _test = async (blockNames, options) => {
     } else {
       cleanUp();
     }
-    program4.error(color10.red(`Tests failed! Error ${err}`));
+    program4.error(color12.red(`Tests failed! Error ${err}`));
+  }
+};
+
+// src/commands/update.ts
+import fs11 from "node:fs";
+import path11 from "node:path";
+import { cancel as cancel5, confirm as confirm5, isCancel as isCancel5, multiselect as multiselect2, outro as outro6, spinner as spinner7 } from "@clack/prompts";
+import color13 from "chalk";
+import { Command as Command6, program as program5 } from "commander";
+import { diffLines as diffLines2 } from "diff";
+import { resolveCommand as resolveCommand4 } from "package-manager-detector/commands";
+import { detect as detect3 } from "package-manager-detector/detect";
+import * as v9 from "valibot";
+var schema7 = v9.object({
+  all: v9.boolean(),
+  expand: v9.boolean(),
+  maxUnchanged: v9.number(),
+  repo: v9.optional(v9.string()),
+  allow: v9.boolean(),
+  yes: v9.boolean(),
+  verbose: v9.boolean(),
+  cwd: v9.string()
+});
+var update = new Command6("update").argument("[blocks...]", "Names of the blocks you want to update. ex: (utils/math)").option("--all", "Update all installed components.", false).option("-E, --expand", "Expands the diff so you see everything.", false).option(
+  "--max-unchanged <number>",
+  "Maximum unchanged lines that will show without being collapsed.",
+  (val) => Number.parseInt(val),
+  // this is such a dumb api thing
+  3
+).option("--repo <repo>", "Repository to download the blocks from.").option("-A, --allow", "Allow jsrepo to download code from the provided repo.", false).option("-y, --yes", "Skip confirmation prompt.", false).option("--verbose", "Include debug logs.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (blockNames, opts) => {
+  const options = v9.parse(schema7, opts);
+  _intro(context.package.version);
+  await _update(blockNames, options);
+  outro6(color13.green("All done!"));
+});
+var _update = async (blockNames, options) => {
+  const verbose = (msg) => {
+    if (options.verbose) {
+      console.info(`${INFO} ${msg}`);
+    }
+  };
+  verbose(`Attempting to update ${JSON.stringify(blockNames)}`);
+  const loading = spinner7();
+  const config = getConfig(options.cwd).match(
+    (val) => val,
+    (err) => program5.error(color13.red(err))
+  );
+  let repoPaths = config.repos;
+  if (options.repo) repoPaths = [options.repo];
+  for (const blockSpecifier of blockNames) {
+    if (blockSpecifier.startsWith("github")) {
+      program5.error(
+        color13.red(
+          `Invalid value provided for block names \`${color13.bold(blockSpecifier)}\`. Block names are expected to be provided in the format of \`${color13.bold("<category>/<name>")}\``
+        )
+      );
+    }
+  }
+  if (!options.allow && options.repo) {
+    const result = await confirm5({
+      message: `Allow ${color13.cyan("jsrepo")} to download and run code from ${color13.cyan(options.repo)}?`,
+      initialValue: true
+    });
+    if (isCancel5(result) || !result) {
+      cancel5("Canceled!");
+      process.exit(0);
+    }
+  }
+  verbose(`Fetching blocks from ${color13.cyan(repoPaths.join(", "))}`);
+  if (!options.verbose) loading.start(`Fetching blocks from ${color13.cyan(repoPaths.join(", "))}`);
+  const blocksMap = (await fetchBlocks(...repoPaths)).match(
+    (val) => val,
+    ({ repo, message }) => {
+      loading.stop(`Failed fetching blocks from ${color13.cyan(repo)}`);
+      program5.error(color13.red(message));
+    }
+  );
+  if (!options.verbose) loading.stop(`Retrieved blocks from ${color13.cyan(repoPaths.join(", "))}`);
+  verbose(`Retrieved blocks from ${color13.cyan(repoPaths.join(", "))}`);
+  const installedBlocks = getInstalled(blocksMap, config, options.cwd);
+  let updatingBlockNames = blockNames;
+  if (options.all) {
+    updatingBlockNames = installedBlocks.map((block) => block.specifier);
+  }
+  if (updatingBlockNames.length === 0) {
+    const promptResult = await multiselect2({
+      message: "Which blocks would you like to update?",
+      options: installedBlocks.map((block) => {
+        return {
+          label: `${color13.cyan(block.block.category)}/${block.block.name}`,
+          value: block.specifier
+        };
+      }),
+      required: true
+    });
+    if (isCancel5(promptResult)) {
+      cancel5("Canceled!");
+      process.exit(0);
+    }
+    updatingBlockNames = promptResult;
+  }
+  verbose(`Preparing to update ${color13.cyan(updatingBlockNames.join(", "))}`);
+  const updatingBlocks = (await resolveTree(updatingBlockNames, blocksMap, repoPaths)).match(
+    (val) => val,
+    program5.error
+  );
+  const pm = (await detect3({ cwd: process.cwd() }))?.agent ?? "npm";
+  const tasks = [];
+  const devDeps = /* @__PURE__ */ new Set();
+  const deps = /* @__PURE__ */ new Set();
+  for (const { block } of updatingBlocks) {
+    const fullSpecifier = `${block.sourceRepo.url}/${block.category}/${block.name}`;
+    const watermark = getWatermark(context.package.version, block.sourceRepo.url);
+    const providerInfo = block.sourceRepo;
+    verbose(`Attempting to add ${fullSpecifier}`);
+    const directory = path11.join(options.cwd, config.path, block.category);
+    const files = [];
+    const getSourceFile = async (filePath) => {
+      const rawUrl = await providerInfo.provider.resolveRaw(providerInfo, filePath);
+      const response = await fetch(rawUrl);
+      if (!response.ok) {
+        loading.stop(color13.red(`Error fetching ${color13.bold(rawUrl.href)}`));
+        program5.error(color13.red(`There was an error trying to get ${fullSpecifier}`));
+      }
+      return await response.text();
+    };
+    for (const sourceFile of block.files) {
+      if (!config.includeTests && isTestFile(sourceFile)) continue;
+      const sourcePath = path11.join(block.directory, sourceFile);
+      let destPath;
+      if (block.subdirectory) {
+        destPath = path11.join(directory, block.name, sourceFile);
+      } else {
+        destPath = path11.join(directory, sourceFile);
+      }
+      const content = await getSourceFile(sourcePath);
+      fs11.mkdirSync(destPath.slice(0, destPath.length - sourceFile.length), {
+        recursive: true
+      });
+      files.push({ content, destPath, fileName: sourceFile });
+    }
+    process.stdout.write(`${VERTICAL_LINE}
+`);
+    process.stdout.write(`${VERTICAL_LINE}  ${fullSpecifier}
+`);
+    for (const file of files) {
+      let remoteContent = file.content;
+      if (config.watermark) {
+        const lang = languages.find((lang2) => lang2.matches(file.destPath));
+        if (lang) {
+          const comment = lang.comment(watermark);
+          remoteContent = `${comment}
+
+${remoteContent}`;
+        }
+      }
+      let acceptedChanges = options.yes;
+      if (!options.yes) {
+        process.stdout.write(`${VERTICAL_LINE}
+`);
+        let localContent = "";
+        if (fs11.existsSync(file.destPath)) {
+          localContent = fs11.readFileSync(file.destPath).toString();
+        }
+        const changes = diffLines2(localContent, remoteContent);
+        const from = path11.join(
+          `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}`,
+          file.fileName
+        ).replaceAll("\\", "/");
+        const to = path11.relative(options.cwd, file.destPath).replaceAll("\\", "/");
+        const formattedDiff = formatDiff({
+          from,
+          to,
+          changes,
+          expand: options.expand,
+          maxUnchanged: options.maxUnchanged,
+          colorAdded: color13.greenBright,
+          colorRemoved: color13.redBright,
+          colorCharsAdded: color13.bgGreenBright,
+          colorCharsRemoved: color13.bgRedBright,
+          prefix: () => `${VERTICAL_LINE}  `,
+          onUnchanged: ({ from: from2, to: to2, prefix }) => `${prefix?.() ?? ""}${color13.cyan(from2)} \u2192 ${color13.gray(to2)} ${color13.gray("(unchanged)")}
+`,
+          intro: ({ from: from2, to: to2, changes: changes2, prefix }) => {
+            const totalChanges = changes2.filter((a) => a.added).length;
+            return `${prefix?.() ?? ""}${color13.cyan(from2)} \u2192 ${color13.gray(to2)} (${totalChanges} change${totalChanges === 1 ? "" : "s"})
+${prefix?.() ?? ""}
+`;
+          }
+        });
+        process.stdout.write(formattedDiff);
+        if (changes.length > 1) {
+          const confirmResult = await confirm5({
+            message: "Accept changes?",
+            initialValue: true
+          });
+          if (isCancel5(confirmResult)) {
+            cancel5("Canceled!");
+            process.exit(0);
+          }
+          acceptedChanges = confirmResult;
+        }
+      }
+      if (acceptedChanges) {
+        await runTasks(
+          [
+            {
+              loadingMessage: `Writing changes to ${color13.cyan(file.destPath)}`,
+              completedMessage: `Wrote changes to ${color13.cyan(file.destPath)}.`,
+              run: async () => fs11.writeFileSync(file.destPath, remoteContent)
+            }
+          ],
+          {
+            verbose: options.verbose ? verbose : void 0
+          }
+        );
+      }
+    }
+    if (config.includeTests) {
+      verbose("Trying to include tests");
+      const { devDependencies } = JSON.parse(
+        fs11.readFileSync(path11.join(options.cwd, "package.json")).toString()
+      );
+      if (devDependencies.vitest === void 0) {
+        devDeps.add("vitest");
+      }
+    }
+    for (const dep of block.devDependencies) {
+      devDeps.add(dep);
+    }
+    for (const dep of block.dependencies) {
+      deps.add(dep);
+    }
+  }
+  await runTasks(tasks, { verbose: options.verbose ? verbose : void 0 });
+  const hasDependencies = deps.size > 0 || devDeps.size > 0;
+  if (hasDependencies) {
+    let install = options.yes;
+    if (!options.yes) {
+      const result = await confirm5({
+        message: "Would you like to install dependencies?",
+        initialValue: true
+      });
+      if (isCancel5(result)) {
+        cancel5("Canceled!");
+        process.exit(0);
+      }
+      install = result;
+    }
+    if (install) {
+      if (deps.size > 0) {
+        if (!options.verbose)
+          loading.start(`Installing dependencies with ${color13.cyan(pm)}`);
+        (await installDependencies({
+          pm,
+          deps: Array.from(deps),
+          dev: false,
+          cwd: options.cwd
+        })).match(
+          (installed) => {
+            if (!options.verbose)
+              loading.stop(`Installed ${color13.cyan(installed.join(", "))}`);
+          },
+          (err) => {
+            if (!options.verbose) loading.stop("Failed to install dependencies");
+            program5.error(err);
+          }
+        );
+      }
+      if (devDeps.size > 0) {
+        if (!options.verbose)
+          loading.start(`Installing dependencies with ${color13.cyan(pm)}`);
+        (await installDependencies({
+          pm,
+          deps: Array.from(devDeps),
+          dev: true,
+          cwd: options.cwd
+        })).match(
+          (installed) => {
+            if (!options.verbose)
+              loading.stop(`Installed ${color13.cyan(installed.join(", "))}`);
+          },
+          (err) => {
+            if (!options.verbose) loading.stop("Failed to install dev dependencies");
+            program5.error(err);
+          }
+        );
+      }
+    }
+    let steps = [];
+    if (!install) {
+      if (deps.size > 0) {
+        const cmd = resolveCommand4(pm, "install", [...deps]);
+        steps.push(
+          `Install dependencies \`${color13.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
+        );
+      }
+      if (devDeps.size > 0) {
+        const cmd = resolveCommand4(pm, "install", [...devDeps, "-D"]);
+        steps.push(
+          `Install dev dependencies \`${color13.cyan(`${cmd?.command} ${cmd?.args.join(" ")}`)}\``
+        );
+      }
+    }
+    steps = steps.map((step, i) => `${i + 1}. ${step}`);
+    if (!install) {
+      steps.push("");
+    }
+    steps.push(`Import the blocks from \`${color13.cyan(config.path)}\``);
+    const next = nextSteps(steps);
+    process.stdout.write(next);
   }
 };
 
 // src/index.ts
 var resolveRelativeToRoot = (p) => {
   const dirname = fileURLToPath(import.meta.url);
-  return path11.join(dirname, "../..", p);
+  return path12.join(dirname, "../..", p);
 };
 var { version, name, description, repository } = JSON.parse(
-  fs11.readFileSync(resolveRelativeToRoot("package.json"), "utf-8")
+  fs12.readFileSync(resolveRelativeToRoot("package.json"), "utf-8")
 );
 var context = {
   package: {
@@ -2248,8 +2613,8 @@ var context = {
   },
   resolveRelativeToRoot
 };
-program5.name(name).description(description).version(version).addCommand(add).addCommand(init).addCommand(test).addCommand(build).addCommand(diff);
-program5.parse();
+program6.name(name).description(description).version(version).addCommand(add).addCommand(init).addCommand(test).addCommand(build).addCommand(update).addCommand(diff);
+program6.parse();
 export {
   context
 };