jsrepo 1.10.2 → 1.12.0

package/dist/index.js

@@ -1,17 +1,17 @@
 // src/index.ts
-import fs12 from "node:fs";
+import fs13 from "node:fs";
 import { fileURLToPath } from "node:url";
 import { program as program8 } from "commander";
-import path12 from "pathe";
+import path13 from "pathe";
 
 // src/commands/add.ts
-import fs6 from "node:fs";
+import fs7 from "node:fs";
 import { cancel, confirm, isCancel, multiselect, outro, spinner as spinner2, text } from "@clack/prompts";
 import color8 from "chalk";
 import { Command, program as program2 } from "commander";
 import { resolveCommand as resolveCommand2 } from "package-manager-detector/commands";
 import { detect } from "package-manager-detector/detect";
-import path6 from "pathe";
+import path7 from "pathe";
 import * as v5 from "valibot";
 
 // src/utils/ascii.ts
@@ -694,10 +694,12 @@ import * as v2 from "valibot";
 // src/utils/language-support.ts
 import fs2 from "node:fs";
 import { builtinModules } from "node:module";
+import { Biome, Distribution } from "@biomejs/js-api";
 import * as v from "@vue/compiler-sfc";
 import color2 from "chalk";
 import { walk } from "estree-walker";
 import path2 from "pathe";
+import * as prettier from "prettier";
 import * as sv from "svelte/compiler";
 import { Project } from "ts-morph";
 import validatePackageName from "validate-npm-package-name";
@@ -749,9 +751,9 @@ var findNearestPackageJson = (startDir, until) => {
   const segments = startDir.split(/[\/\\]/);
   return findNearestPackageJson(segments.slice(0, segments.length - 1).join("/"), until);
 };
-var getPackage = (path13) => {
-  if (!fs.existsSync(path13)) return Err(`${path13} doesn't exist`);
-  const contents = fs.readFileSync(path13).toString();
+var getPackage = (path14) => {
+  if (!fs.existsSync(path14)) return Err(`${path14} doesn't exist`);
+  const contents = fs.readFileSync(path14).toString();
   return Ok(JSON.parse(contents));
 };
 var returnShouldInstall = (dependencies, devDependencies, { cwd }) => {
@@ -800,7 +802,7 @@ var parsePackageName = (input) => {
 // src/utils/language-support.ts
 var typescript = {
   matches: (fileName) => fileName.endsWith(".ts") || fileName.endsWith(".js") || fileName.endsWith(".tsx") || fileName.endsWith(".jsx"),
-  resolveDependencies: ({ filePath, category, isSubDir, excludeDeps }) => {
+  resolveDependencies: ({ filePath, isSubDir, excludeDeps, cwd }) => {
     const project = new Project();
     const blockFile = project.addSourceFileAtPath(filePath);
     const imports = blockFile.getImportDeclarations();
@@ -810,8 +812,9 @@ var typescript = {
     const localDeps = /* @__PURE__ */ new Set();
     for (const relativeImport of relativeImports) {
       const mod = relativeImport.getModuleSpecifierValue();
-      const localDep = resolveLocalImport(mod, category, isSubDir);
-      if (localDep) localDeps.add(localDep);
+      const localDep = resolveLocalImport(mod, isSubDir, { filePath, cwd });
+      if (localDep.isErr()) return Err(localDep.unwrapErr());
+      if (localDep) localDeps.add(localDep.unwrap());
     }
     const deps = imports.filter((declaration) => !declaration.getModuleSpecifierValue().startsWith(".")).map((declaration) => declaration.getModuleSpecifierValue());
     const { devDependencies, dependencies } = resolveRemoteDeps(
@@ -826,14 +829,27 @@ var typescript = {
     });
   },
   comment: (content) => `/*
-${content}
-*/`
+${join(get(content), { prefix: () => "	" })}
+*/`,
+  format: async (code, { formatter, filePath, prettierOptions, biomeOptions }) => {
+    if (!formatter) return code;
+    if (formatter === "prettier") {
+      return await prettier.format(code, { filepath: filePath, ...prettierOptions });
+    }
+    const biome = await Biome.create({
+      distribution: Distribution.NODE
+    });
+    if (biomeOptions) {
+      biome.applyConfiguration(biomeOptions);
+    }
+    return biome.formatContent(code, { filePath }).content;
+  }
 };
 var svelte = {
   matches: (fileName) => fileName.endsWith(".svelte"),
-  resolveDependencies: ({ filePath, category, isSubDir, excludeDeps }) => {
+  resolveDependencies: ({ filePath, isSubDir, excludeDeps, cwd }) => {
     const sourceCode = fs2.readFileSync(filePath).toString();
-    const root = sv.parse(sourceCode, { modern: true });
+    const root = sv.parse(sourceCode, { modern: true, filename: filePath });
     if (!root.instance) return Ok({ dependencies: [], devDependencies: [], local: [] });
     const localDeps = /* @__PURE__ */ new Set();
     const deps = /* @__PURE__ */ new Set();
@@ -842,12 +858,12 @@ var svelte = {
         if (node.type === "ImportDeclaration") {
           if (typeof node.source.value === "string") {
             if (node.source.value.startsWith(".")) {
-              const localDep = resolveLocalImport(
-                node.source.value,
-                category,
-                isSubDir
-              );
-              if (localDep) localDeps.add(localDep);
+              const localDep = resolveLocalImport(node.source.value, isSubDir, {
+                filePath,
+                cwd
+              });
+              if (localDep.isErr()) return Err(localDep.unwrapErr());
+              if (localDep) localDeps.add(localDep.unwrap());
             } else {
               deps.add(node.source.value);
             }
@@ -866,25 +882,41 @@ var svelte = {
     });
   },
   comment: (content) => `<!--
-${content}
--->`
+${join(get(content), { prefix: () => "	" })}
+-->`,
+  format: async (code, { formatter, filePath, prettierOptions }) => {
+    if (!formatter) return code;
+    if (formatter === "prettier" && prettierOptions && prettierOptions.plugins?.find((plugin) => plugin === "prettier-plugin-svelte")) {
+      return await prettier.format(code, { filepath: filePath, ...prettierOptions });
+    }
+    return code;
+  }
 };
 var vue = {
   matches: (fileName) => fileName.endsWith(".vue"),
-  resolveDependencies: ({ filePath, category, isSubDir, excludeDeps }) => {
+  resolveDependencies: ({ filePath, isSubDir, excludeDeps, cwd }) => {
     const sourceCode = fs2.readFileSync(filePath).toString();
-    const parsed = v.parse(sourceCode);
+    const parsed = v.parse(sourceCode, { filename: filePath });
     if (!parsed.descriptor.script?.content && !parsed.descriptor.scriptSetup?.content)
       return Ok({ dependencies: [], devDependencies: [], local: [] });
     const localDeps = /* @__PURE__ */ new Set();
     const deps = /* @__PURE__ */ new Set();
-    const compiled = v.compileScript(parsed.descriptor, { id: "shut-it" });
+    let compiled;
+    try {
+      compiled = v.compileScript(parsed.descriptor, { id: "shut-it" });
+    } catch (err) {
+      return Err(`Compile error: ${err}`);
+    }
     if (!compiled.imports) return Ok({ dependencies: [], devDependencies: [], local: [] });
     const imports = Object.values(compiled.imports);
     for (const imp of imports) {
       if (imp.source.startsWith(".")) {
-        const localDep = resolveLocalImport(imp.source, category, isSubDir);
-        if (localDep) localDeps.add(localDep);
+        const localDep = resolveLocalImport(imp.source, isSubDir, {
+          filePath,
+          cwd
+        });
+        if (localDep.isErr()) return Err(localDep.unwrapErr());
+        if (localDep) localDeps.add(localDep.unwrap());
       } else {
         deps.add(imp.source);
       }
@@ -900,25 +932,43 @@ var vue = {
     });
   },
   comment: (content) => `<!--
-${content}
--->`
+${join(get(content), { prefix: () => "	" })}
+-->`,
+  format: async (code, { formatter, prettierOptions }) => {
+    if (!formatter) return code;
+    if (formatter === "prettier") {
+      return await prettier.format(code, { parser: "vue", ...prettierOptions });
+    }
+    return code;
+  }
 };
 var yaml = {
   matches: (fileName) => fileName.endsWith(".yml") || fileName.endsWith(".yaml"),
   resolveDependencies: () => Ok({ dependencies: [], local: [], devDependencies: [] }),
-  comment: (content) => join(get(content), { prefix: () => "# " })
-};
-var resolveLocalImport = (mod, category, isSubDir) => {
-  if (isSubDir && mod.startsWith("./")) return void 0;
-  if (mod.startsWith("./")) {
-    return `${category}/${path2.parse(path2.basename(mod)).name}`;
+  comment: (content) => join(get(content), { prefix: () => "# " }),
+  format: async (code, { formatter, prettierOptions }) => {
+    if (!formatter) return code;
+    if (formatter === "prettier") {
+      return await prettier.format(code, { parser: "yaml", ...prettierOptions });
+    }
+    return code;
   }
-  if (isSubDir && mod.startsWith("../") && !mod.startsWith("../.")) {
-    return `${category}/${path2.parse(path2.basename(mod)).name}`;
+};
+var resolveLocalImport = (mod, isSubDir, { filePath, cwd }) => {
+  const categoryDir = isSubDir ? path2.join(filePath, "../../") : path2.join(filePath, "../");
+  const modPath = path2.join(path2.join(filePath, "../"), mod);
+  const fullDir = path2.join(cwd, path2.join(categoryDir, "../"));
+  if (modPath.startsWith(fullDir)) {
+    let [category, block] = modPath.slice(fullDir.length).split("/");
+    if (block.includes(".")) {
+      block = block.slice(0, block.length - path2.parse(block).ext.length);
+    }
+    return Ok(`${category}/${block}`);
   }
-  const segments = mod.replaceAll("../", "").split("/");
-  if (segments.length < 2) return void 0;
-  return `${segments[0]}/${segments[1]}`;
+  return Err(
+    `${filePath}:
+${mod} references code not contained in ${categoryDir} and cannot be resolved.`
+  );
 };
 var resolveRemoteDeps = (deps, filePath, doNotInstall = []) => {
   const exemptDeps = new Set(doNotInstall);
@@ -1043,7 +1093,8 @@ var buildBlocksDirectory = (blocksPath, { cwd, excludeDeps, includeBlocks, inclu
           filePath: blockDir,
           category: categoryName,
           isSubDir: false,
-          excludeDeps
+          excludeDeps,
+          cwd
         }).match(
           (val) => val,
           (err) => {
@@ -1115,7 +1166,8 @@ var buildBlocksDirectory = (blocksPath, { cwd, excludeDeps, includeBlocks, inclu
             filePath: path3.join(blockDir, f),
             category: categoryName,
             isSubDir: true,
-            excludeDeps
+            excludeDeps,
+            cwd
           }).match(
             (val) => val,
             (err) => {
@@ -1469,12 +1521,14 @@ import fs5 from "node:fs";
 import path5 from "pathe";
 import * as v4 from "valibot";
 var CONFIG_NAME = "jsrepo.json";
+var formatterSchema = v4.union([v4.literal("prettier"), v4.literal("biome")]);
 var schema = v4.object({
   $schema: v4.string(),
   repos: v4.optional(v4.array(v4.string()), []),
   includeTests: v4.boolean(),
   path: v4.pipe(v4.string(), v4.minLength(1)),
-  watermark: v4.optional(v4.boolean(), true)
+  watermark: v4.optional(v4.boolean(), true),
+  formatter: v4.optional(formatterSchema)
 });
 var getConfig = (cwd) => {
   if (!fs5.existsSync(path5.join(cwd, CONFIG_NAME))) {
@@ -1521,11 +1575,36 @@ var installDependencies = async ({
   }
 };
 
+// src/utils/format.ts
+import fs6 from "node:fs";
+import path6 from "pathe";
+import * as prettier2 from "prettier";
+var loadFormatterConfig = async ({
+  formatter,
+  cwd
+}) => {
+  let prettierOptions = null;
+  if (formatter === "prettier") {
+    prettierOptions = await prettier2.resolveConfig(path6.join(cwd, ".prettierrc"));
+  }
+  let biomeOptions = null;
+  if (formatter === "biome") {
+    const configPath = path6.join(cwd, "biome.json");
+    if (fs6.existsSync(configPath)) {
+      biomeOptions = JSON.parse(fs6.readFileSync(configPath).toString());
+    }
+  }
+  return {
+    biomeOptions,
+    prettierOptions
+  };
+};
+
 // src/utils/get-watermark.ts
 var getWatermark = (version2, repoUrl) => {
-  return `	jsrepo ${version2}
-	Installed from ${repoUrl}
-	${(/* @__PURE__ */ new Date()).toLocaleDateString().replaceAll("/", "-")}`;
+  return `jsrepo ${version2}
+Installed from ${repoUrl}
+${(/* @__PURE__ */ new Date()).toLocaleDateString().replaceAll("/", "-")}`;
 };
 
 // src/utils/prompts.ts
@@ -1769,13 +1848,17 @@ var _add = async (blockNames, options) => {
       config.watermark = addWatermark;
     }
   }
+  const { prettierOptions, biomeOptions } = await loadFormatterConfig({
+    formatter: config.formatter,
+    cwd: options.cwd
+  });
   for (const { block } of installingBlocks) {
     const fullSpecifier = `${block.sourceRepo.url}/${block.category}/${block.name}`;
     const watermark = getWatermark(context.package.version, block.sourceRepo.url);
     const providerInfo = block.sourceRepo;
     verbose(`Setting up ${fullSpecifier}`);
-    const directory = path6.join(options.cwd, config.path, block.category);
-    const blockExists = !block.subdirectory && fs6.existsSync(path6.join(directory, block.files[0])) || block.subdirectory && fs6.existsSync(path6.join(directory, block.name));
+    const directory = path7.join(options.cwd, config.path, block.category);
+    const blockExists = !block.subdirectory && fs7.existsSync(path7.join(directory, block.files[0])) || block.subdirectory && fs7.existsSync(path7.join(directory, block.name));
     if (blockExists && !options.yes) {
       const result = await confirm({
         message: `${color8.bold(block.name)} already exists in your project would you like to overwrite it?`,
@@ -1791,7 +1874,7 @@ var _add = async (blockNames, options) => {
       completedMessage: `Added ${fullSpecifier}`,
       run: async () => {
         verbose(`Creating directory ${color8.bold(directory)}`);
-        fs6.mkdirSync(directory, { recursive: true });
+        fs7.mkdirSync(directory, { recursive: true });
         const files = [];
         const getSourceFile = async (filePath) => {
           const content = await providerInfo.provider.fetchRaw(providerInfo, filePath);
@@ -1805,36 +1888,42 @@ var _add = async (blockNames, options) => {
         };
         for (const sourceFile of block.files) {
           if (!config.includeTests && isTestFile(sourceFile)) continue;
-          const sourcePath = path6.join(block.directory, sourceFile);
+          const sourcePath = path7.join(block.directory, sourceFile);
           let destPath;
           if (block.subdirectory) {
-            destPath = path6.join(directory, block.name, sourceFile);
+            destPath = path7.join(directory, block.name, sourceFile);
           } else {
-            destPath = path6.join(directory, sourceFile);
+            destPath = path7.join(directory, sourceFile);
           }
           const content = await getSourceFile(sourcePath);
-          fs6.mkdirSync(destPath.slice(0, destPath.length - sourceFile.length), {
+          fs7.mkdirSync(destPath.slice(0, destPath.length - sourceFile.length), {
             recursive: true
           });
           files.push({ content, destPath });
         }
         for (const file of files) {
+          const lang = languages.find((lang2) => lang2.matches(file.destPath));
           let content = file.content;
-          if (config.watermark) {
-            const lang = languages.find((lang2) => lang2.matches(file.destPath));
-            if (lang) {
+          if (lang) {
+            if (config.watermark) {
               const comment = lang.comment(watermark);
               content = `${comment}
 
 ${content}`;
             }
+            content = await lang.format(content, {
+              filePath: file.destPath,
+              formatter: config.formatter,
+              prettierOptions,
+              biomeOptions
+            });
           }
-          fs6.writeFileSync(file.destPath, content);
+          fs7.writeFileSync(file.destPath, content);
         }
         if (config.includeTests) {
           verbose("Trying to include tests");
           const { devDependencies } = JSON.parse(
-            fs6.readFileSync(path6.join(options.cwd, "package.json")).toString()
+            fs7.readFileSync(path7.join(options.cwd, "package.json")).toString()
           );
           if (devDependencies.vitest === void 0) {
             devDeps.add("vitest");
@@ -2016,11 +2105,11 @@ var _auth = async (options) => {
 };
 
 // src/commands/build.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import { outro as outro3, spinner as spinner3 } from "@clack/prompts";
 import color10 from "chalk";
 import { Command as Command3, program as program3 } from "commander";
-import path7 from "pathe";
+import path8 from "pathe";
 import * as v7 from "valibot";
 var schema4 = v7.object({
   dirs: v7.array(v7.string()),
@@ -2049,11 +2138,11 @@ var build = new Command3("build").description(`Builds the provided --dirs in the
 var _build = async (options) => {
   const loading = spinner3();
   const categories = [];
-  const outFile = path7.join(options.cwd, OUTPUT_FILE);
+  const outFile = path8.join(options.cwd, OUTPUT_FILE);
   for (const dir of options.dirs) {
-    const dirPath = path7.join(options.cwd, dir);
+    const dirPath = path8.join(options.cwd, dir);
     loading.start(`Building ${color10.cyan(dirPath)}`);
-    if (options.output && fs7.existsSync(outFile)) fs7.rmSync(outFile);
+    if (options.output && fs8.existsSync(outFile)) fs8.rmSync(outFile);
     const builtCategories = buildBlocksDirectory(dirPath, { ...options });
     for (const category of builtCategories) {
       if (categories.find((cat) => cat.name === category.name) !== void 0) {
@@ -2127,18 +2216,18 @@ var _build = async (options) => {
   }
   if (options.output) {
     loading.start(`Writing output to \`${color10.cyan(outFile)}\``);
-    fs7.writeFileSync(outFile, JSON.stringify(categories, null, "	"));
+    fs8.writeFileSync(outFile, JSON.stringify(categories, null, "	"));
     loading.stop(`Wrote output to \`${color10.cyan(outFile)}\``);
   }
 };
 
 // src/commands/diff.ts
-import fs8 from "node:fs";
+import fs9 from "node:fs";
 import { cancel as cancel3, confirm as confirm3, isCancel as isCancel3, outro as outro4, spinner as spinner4 } from "@clack/prompts";
 import color12 from "chalk";
 import { Command as Command4, program as program4 } from "commander";
 import { diffLines } from "diff";
-import path8 from "pathe";
+import path9 from "pathe";
 import * as v8 from "valibot";
 
 // src/utils/diff.ts
@@ -2381,22 +2470,22 @@ var _diff = async (options) => {
         if (!config.includeTests && isTestFile(file)) continue;
         process.stdout.write(`${VERTICAL_LINE}
 `);
-        const sourcePath = path8.join(block.directory, file);
+        const sourcePath = path9.join(block.directory, file);
         const response = await providerInfo.provider.fetchRaw(providerInfo, sourcePath);
         if (response.isErr()) {
           program4.error(color12.red(`There was an error trying to get ${fullSpecifier}`));
         }
         let remoteContent = response.unwrap();
-        const directory = path8.join(options.cwd, config.path, block.category);
-        let localPath = path8.join(directory, file);
-        let prettyLocalPath = path8.join(config.path, block.category, file);
+        const directory = path9.join(options.cwd, config.path, block.category);
+        let localPath = path9.join(directory, file);
+        let prettyLocalPath = path9.join(config.path, block.category, file);
         if (block.subdirectory) {
-          localPath = path8.join(directory, block.name, file);
-          prettyLocalPath = path8.join(config.path, block.category, block.name, file);
+          localPath = path9.join(directory, block.name, file);
+          prettyLocalPath = path9.join(config.path, block.category, block.name, file);
         }
         let fileContent = "";
-        if (fs8.existsSync(localPath)) {
-          fileContent = fs8.readFileSync(localPath).toString();
+        if (fs9.existsSync(localPath)) {
+          fileContent = fs9.readFileSync(localPath).toString();
         }
         if (config.watermark) {
           const lang = languages.find((lang2) => lang2.matches(sourcePath));
@@ -2408,7 +2497,7 @@ ${remoteContent}`;
           }
         }
         const changes = diffLines(fileContent, remoteContent);
-        const from = path8.join(
+        const from = path9.join(
           `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}`,
           sourcePath
         );
@@ -2445,18 +2534,19 @@ ${prefix?.() ?? ""}
 };
 
 // src/commands/init.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import { cancel as cancel4, confirm as confirm4, isCancel as isCancel4, outro as outro5, password as password2, select as select2, spinner as spinner5, text as text2 } from "@clack/prompts";
 import color13 from "chalk";
-import { Command as Command5, program as program5 } from "commander";
+import { Command as Command5, Option as Option2, program as program5 } from "commander";
 import { detect as detect2, resolveCommand as resolveCommand3 } from "package-manager-detector";
-import path9 from "pathe";
+import path10 from "pathe";
 import * as v9 from "valibot";
 var schema6 = v9.object({
   path: v9.optional(v9.string()),
   repos: v9.optional(v9.array(v9.string())),
   watermark: v9.boolean(),
   tests: v9.optional(v9.boolean()),
+  formatter: v9.optional(formatterSchema),
   project: v9.optional(v9.boolean()),
   registry: v9.optional(v9.boolean()),
   script: v9.string(),
@@ -2466,7 +2556,12 @@ var schema6 = v9.object({
 var init = new Command5("init").description("Initializes your project with a configuration file.").option("--path <path>", "Path to install the blocks / Path to build the blocks from.").option("--repos [repos...]", "Repository to install the blocks from.").option(
   "--no-watermark",
   "Will not add a watermark to each file upon adding it to your project."
-).option("--tests", "Will include tests with the blocks.").option("-P, --project", "Takes you through the steps to initialize a project.").option("-R, --registry", "Takes you through the steps to initialize a registry.").option("--script <name>", "The name of the build script. (For Registry setup)", "build").option("-y, --yes", "Skip confirmation prompt.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (opts) => {
+).option("--tests", "Will include tests with the blocks.").addOption(
+  new Option2(
+    "--formatter <formatter>",
+    "What formatter to use when adding or updating blocks."
+  ).choices(["prettier", "biome"])
+).option("-P, --project", "Takes you through the steps to initialize a project.").option("-R, --registry", "Takes you through the steps to initialize a registry.").option("--script <name>", "The name of the build script. (For Registry setup)", "build").option("-y, --yes", "Skip confirmation prompt.", false).option("--cwd <path>", "The current working directory.", process.cwd()).action(async (opts) => {
   const options = v9.parse(schema6, opts);
   _intro(context.package.version);
   if (options.registry !== void 0 && options.project !== void 0) {
@@ -2575,26 +2670,51 @@ var _initProject = async (options) => {
       options.repos.push(result);
     }
   }
+  if (!options.formatter) {
+    let defaultFormatter = initialConfig.isErr() ? "none" : initialConfig.unwrap().formatter ?? "none";
+    if (fs10.existsSync(path10.join(options.cwd, ".prettierrc"))) {
+      defaultFormatter = "prettier";
+    }
+    if (fs10.existsSync(path10.join(options.cwd, "biome.json"))) {
+      defaultFormatter = "biome";
+    }
+    const response = await select2({
+      message: "What formatter would you like to use?",
+      options: ["Prettier", "Biome", "None"].map((val) => ({
+        value: val.toLowerCase(),
+        label: val
+      })),
+      initialValue: defaultFormatter
+    });
+    if (isCancel4(response)) {
+      cancel4("Canceled!");
+      process.exit(0);
+    }
+    if (response !== "none") {
+      options.formatter = response;
+    }
+  }
   const config = {
     $schema: `https://unpkg.com/jsrepo@${context.package.version}/schema.json`,
     repos: options.repos,
     path: options.path,
     includeTests: initialConfig.isOk() && options.tests === void 0 ? initialConfig.unwrap().includeTests : options.tests ?? false,
-    watermark: options.watermark
+    watermark: options.watermark,
+    formatter: options.formatter
   };
   loading.start(`Writing config to \`${CONFIG_NAME}\``);
-  fs9.writeFileSync(
-    path9.join(options.cwd, CONFIG_NAME),
+  fs10.writeFileSync(
+    path10.join(options.cwd, CONFIG_NAME),
     `${JSON.stringify(config, null, "	")}
 `
   );
-  fs9.mkdirSync(path9.join(options.cwd, config.path), { recursive: true });
+  fs10.mkdirSync(path10.join(options.cwd, config.path), { recursive: true });
   loading.stop(`Wrote config to \`${CONFIG_NAME}\`.`);
 };
 var _initRegistry = async (options) => {
   const loading = spinner5();
-  const packagePath = path9.join(options.cwd, "package.json");
-  if (!fs9.existsSync(packagePath)) {
+  const packagePath = path10.join(options.cwd, "package.json");
+  if (!fs10.existsSync(packagePath)) {
     program5.error(color13.red(`Couldn't find your ${color13.bold("package.json")}!`));
   }
   if (!options.path) {
@@ -2610,7 +2730,7 @@ var _initRegistry = async (options) => {
     }
     options.path = response;
   }
-  const pkg = JSON.parse(fs9.readFileSync(packagePath).toString());
+  const pkg = JSON.parse(fs10.readFileSync(packagePath).toString());
   const scriptAlreadyExists = pkg.scripts !== void 0 && pkg.scripts[options.script] !== void 0;
   if (!options.yes && scriptAlreadyExists) {
     const response = await confirm4({
@@ -2669,7 +2789,7 @@ var _initRegistry = async (options) => {
   pkg.scripts[options.script] = buildScript;
   loading.start(`Adding \`${color13.cyan(options.script)}\` to scripts in package.json`);
   try {
-    fs9.writeFileSync(packagePath, JSON.stringify(pkg, null, "	"));
+    fs10.writeFileSync(packagePath, JSON.stringify(pkg, null, "	"));
   } catch (err) {
     program5.error(color13.red(`Error writing to \`${color13.bold(packagePath)}\`. Error: ${err}`));
   }
@@ -2724,14 +2844,14 @@ var _initRegistry = async (options) => {
 };
 
 // src/commands/test.ts
-import fs10 from "node:fs";
+import fs11 from "node:fs";
 import { cancel as cancel5, confirm as confirm5, isCancel as isCancel5, outro as outro6, spinner as spinner6 } from "@clack/prompts";
 import color14 from "chalk";
 import { Argument, Command as Command6, program as program6 } from "commander";
 import { execa as execa2 } from "execa";
 import { resolveCommand as resolveCommand4 } from "package-manager-detector/commands";
 import { detect as detect3 } from "package-manager-detector/detect";
-import path10 from "pathe";
+import path11 from "pathe";
 import { Project as Project2 } from "ts-morph";
 import * as v10 from "valibot";
 var schema7 = v10.object({
@@ -2806,13 +2926,13 @@ var _test = async (blockNames, options) => {
   }
   verbose(`Retrieved blocks from ${color14.cyan(repoPaths.join(", "))}`);
   if (!options.verbose) loading.stop(`Retrieved blocks from ${color14.cyan(repoPaths.join(", "))}`);
-  const tempTestDirectory = path10.resolve(
-    path10.join(options.cwd, `blocks-tests-temp-${Date.now()}`)
+  const tempTestDirectory = path11.resolve(
+    path11.join(options.cwd, `blocks-tests-temp-${Date.now()}`)
   );
   verbose(`Trying to create the temp directory ${color14.bold(tempTestDirectory)}.`);
-  fs10.mkdirSync(tempTestDirectory, { recursive: true });
+  fs11.mkdirSync(tempTestDirectory, { recursive: true });
   const cleanUp = () => {
-    fs10.rmSync(tempTestDirectory, { recursive: true, force: true });
+    fs11.rmSync(tempTestDirectory, { recursive: true, force: true });
   };
   const installedBlocks = getInstalled(blocksMap, config, options.cwd).map(
     (val) => val.specifier
@@ -2897,9 +3017,9 @@ var _test = async (blockNames, options) => {
     verbose(`Downloading and copying test files for ${fullSpecifier}`);
     const testFiles = [];
     for (const testFile of block.files.filter((file) => isTestFile(file))) {
-      const content = await getSourceFile(path10.join(block.directory, testFile));
-      const destPath = path10.join(tempTestDirectory, testFile);
-      fs10.writeFileSync(destPath, content);
+      const content = await getSourceFile(path11.join(block.directory, testFile));
+      const destPath = path11.join(tempTestDirectory, testFile);
+      fs11.writeFileSync(destPath, content);
       testFiles.push(destPath);
     }
     const project = new Project2();
@@ -2911,7 +3031,7 @@ var _test = async (blockNames, options) => {
         let newModuleSpecifier = void 0;
         if (moduleSpecifier.startsWith(".")) {
           if (block.subdirectory) {
-            newModuleSpecifier = path10.join(
+            newModuleSpecifier = path11.join(
               "../",
               config.path,
               block.category,
@@ -2919,7 +3039,7 @@ var _test = async (blockNames, options) => {
               moduleSpecifier
             );
           } else {
-            newModuleSpecifier = path10.join(
+            newModuleSpecifier = path11.join(
               "../",
               config.path,
               block.category,
@@ -2975,14 +3095,14 @@ var _test = async (blockNames, options) => {
 };
 
 // src/commands/update.ts
-import fs11 from "node:fs";
+import fs12 from "node:fs";
 import { cancel as cancel6, confirm as confirm6, isCancel as isCancel6, multiselect as multiselect2, outro as outro7, spinner as spinner7 } from "@clack/prompts";
 import color15 from "chalk";
 import { Command as Command7, program as program7 } from "commander";
 import { diffLines as diffLines2 } from "diff";
 import { resolveCommand as resolveCommand5 } from "package-manager-detector/commands";
 import { detect as detect4 } from "package-manager-detector/detect";
-import path11 from "pathe";
+import path12 from "pathe";
 import * as v11 from "valibot";
 var schema8 = v11.object({
   all: v11.boolean(),
@@ -3051,6 +3171,13 @@ var _update = async (blockNames, options) => {
   if (!options.verbose) loading.stop(`Retrieved blocks from ${color15.cyan(repoPaths.join(", "))}`);
   verbose(`Retrieved blocks from ${color15.cyan(repoPaths.join(", "))}`);
   const installedBlocks = getInstalled(blocksMap, config, options.cwd);
+  if (installedBlocks.length === 0) {
+    program7.error(
+      color15.red(
+        `You haven't installed any blocks yet. Did you mean to \`${color15.bold("add")}\`?`
+      )
+    );
+  }
   let updatingBlockNames = blockNames;
   if (options.all) {
     updatingBlockNames = installedBlocks.map((block) => block.specifier);
@@ -3081,12 +3208,16 @@ var _update = async (blockNames, options) => {
   const tasks = [];
   let devDeps = /* @__PURE__ */ new Set();
   let deps = /* @__PURE__ */ new Set();
+  const { prettierOptions, biomeOptions } = await loadFormatterConfig({
+    formatter: config.formatter,
+    cwd: options.cwd
+  });
   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 directory = path12.join(options.cwd, config.path, block.category);
     const files = [];
     const getSourceFile = async (filePath) => {
       const content = await providerInfo.provider.fetchRaw(providerInfo, filePath);
@@ -3098,15 +3229,15 @@ var _update = async (blockNames, options) => {
     };
     for (const sourceFile of block.files) {
       if (!config.includeTests && isTestFile(sourceFile)) continue;
-      const sourcePath = path11.join(block.directory, sourceFile);
+      const sourcePath = path12.join(block.directory, sourceFile);
       let destPath;
       if (block.subdirectory) {
-        destPath = path11.join(directory, block.name, sourceFile);
+        destPath = path12.join(directory, block.name, sourceFile);
       } else {
-        destPath = path11.join(directory, sourceFile);
+        destPath = path12.join(directory, sourceFile);
       }
       const content = await getSourceFile(sourcePath);
-      fs11.mkdirSync(destPath.slice(0, destPath.length - sourceFile.length), {
+      fs12.mkdirSync(destPath.slice(0, destPath.length - sourceFile.length), {
         recursive: true
       });
       files.push({ content, destPath, fileName: sourceFile });
@@ -3116,30 +3247,36 @@ var _update = async (blockNames, options) => {
     process.stdout.write(`${VERTICAL_LINE}  ${fullSpecifier}
 `);
     for (const file of files) {
+      const lang = languages.find((lang2) => lang2.matches(file.destPath));
       let remoteContent = file.content;
-      if (config.watermark) {
-        const lang = languages.find((lang2) => lang2.matches(file.destPath));
-        if (lang) {
+      if (lang) {
+        if (config.watermark) {
           const comment = lang.comment(watermark);
           remoteContent = `${comment}
 
 ${remoteContent}`;
         }
+        remoteContent = await lang.format(remoteContent, {
+          filePath: file.destPath,
+          formatter: config.formatter,
+          prettierOptions,
+          biomeOptions
+        });
       }
       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();
+        if (fs12.existsSync(file.destPath)) {
+          localContent = fs12.readFileSync(file.destPath).toString();
         }
         const changes = diffLines2(localContent, remoteContent);
-        const from = path11.join(
+        const from = path12.join(
           `${providerInfo.name}/${providerInfo.owner}/${providerInfo.repoName}`,
           file.fileName
         );
-        const to = path11.relative(options.cwd, file.destPath);
+        const to = path12.relative(options.cwd, file.destPath);
         const formattedDiff = formatDiff({
           from,
           to,
@@ -3179,7 +3316,7 @@ ${prefix?.() ?? ""}
             {
               loadingMessage: `Writing changes to ${color15.cyan(file.destPath)}`,
               completedMessage: `Wrote changes to ${color15.cyan(file.destPath)}.`,
-              run: async () => fs11.writeFileSync(file.destPath, remoteContent)
+              run: async () => fs12.writeFileSync(file.destPath, remoteContent)
             }
           ],
           {
@@ -3191,7 +3328,7 @@ ${prefix?.() ?? ""}
     if (config.includeTests) {
       verbose("Trying to include tests");
       const { devDependencies } = JSON.parse(
-        fs11.readFileSync(path11.join(options.cwd, "package.json")).toString()
+        fs12.readFileSync(path12.join(options.cwd, "package.json")).toString()
       );
       if (devDependencies.vitest === void 0) {
         devDeps.add("vitest");
@@ -3290,10 +3427,10 @@ ${prefix?.() ?? ""}
 // src/index.ts
 var resolveRelativeToRoot = (p) => {
   const dirname = fileURLToPath(import.meta.url);
-  return path12.join(dirname, "../..", p);
+  return path13.join(dirname, "../..", p);
 };
 var { version, name, description, repository } = JSON.parse(
-  fs12.readFileSync(resolveRelativeToRoot("package.json"), "utf-8")
+  fs13.readFileSync(resolveRelativeToRoot("package.json"), "utf-8")
 );
 var context = {
   package: {