blockend-cli 1.5.0 → 2.0.0

package/dist/index.js

@@ -5,9 +5,9 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/add.ts
 import path, { join, dirname } from "path";
-import fs, { readFile } from "fs/promises";
+import fs from "fs/promises";
 import { exec } from "child_process";
-import { intro, outro, select, spinner, confirm, isCancel, log } from "@clack/prompts";
+import { intro, outro, select, multiselect, spinner, confirm, isCancel, log } from "@clack/prompts";
 import pc from "picocolors";
 var REPO_OWNER = "codewithnuh";
 var REPO_NAME = "blockend";
@@ -20,17 +20,85 @@ function blockSupportsEnv(block, envKey) {
   }
   return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
 }
-var getMissingDependencies = (deps, installed) => [...new Set(deps)].filter((dep) => !(dep in installed));
+function parseDepSpec(dep) {
+  const atIndex = dep.lastIndexOf("@");
+  if (atIndex > 0) {
+    return { name: dep.slice(0, atIndex), versionRange: dep.slice(atIndex + 1) };
+  }
+  return { name: dep, versionRange: null };
+}
+function semverSatisfies(installed, range) {
+  const parse = (v) => {
+    const clean = v.replace(/^[~^>=<]+/, "");
+    const parts = clean.split(".").map(Number);
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+  };
+  const [iMajor, iMinor, iPatch] = parse(installed);
+  const raw = range.replace(/^[~^>=<]+/, "");
+  const [rMajor, rMinor, rPatch] = parse(raw);
+  if (range.startsWith("^")) {
+    return (iMajor > rMajor || iMajor === rMajor && (iMinor > rMinor || iMinor === rMinor && iPatch >= rPatch)) && iMajor === rMajor;
+  }
+  if (range.startsWith("~")) {
+    return iMajor === rMajor && iMinor === rMinor && iPatch >= rPatch;
+  }
+  if (range.startsWith(">=")) {
+    return iMajor > rMajor || iMajor === rMajor && (iMinor > rMinor || iMinor === rMinor && iPatch >= rPatch);
+  }
+  return installed === raw;
+}
+function getVersionConflicts(deps, installed) {
+  const conflicts = [];
+  for (const dep of deps) {
+    const { name, versionRange } = parseDepSpec(dep);
+    if (versionRange && name in installed) {
+      const installedVersion = installed[name];
+      if (!semverSatisfies(installedVersion, versionRange)) {
+        conflicts.push(`${name}: block requires ${versionRange}, you have ${installedVersion}`);
+      }
+    }
+  }
+  return conflicts;
+}
+var getMissingDependencies = (deps, installed, forceLatest = false) => {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const dep of deps) {
+    const { name, versionRange } = parseDepSpec(dep);
+    if (seen.has(name)) continue;
+    seen.add(name);
+    if (!(name in installed)) {
+      result.push(dep);
+    } else if (versionRange && !semverSatisfies(installed[name], versionRange)) {
+      result.push(dep);
+    } else if (!versionRange && forceLatest) {
+      result.push(`${name}@latest`);
+    }
+  }
+  return result;
+};
 function resolveAdapterContext(block, envKey) {
   return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
 }
-function rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase, strategy) {
+function resolveIndexImport(importPath, sourceFileDir, downloadedFiles) {
+  const resolved = path.resolve(sourceFileDir, importPath);
+  for (const downloaded of downloadedFiles) {
+    const downloadedAbs = path.resolve(sourceFileDir, downloaded);
+    const dirOfDownloaded = dirname(downloadedAbs);
+    const basenameOfDownloaded = path.basename(downloadedAbs);
+    if (dirOfDownloaded === resolved && basenameOfDownloaded.startsWith("index.")) {
+      return `${importPath}/index`;
+    }
+  }
+  return null;
+}
+function rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase, strategy, downloadedFiles = /* @__PURE__ */ new Set()) {
   const importRegex = /((?:from|import)\s*)(['"`])(\.\.?\/[^'"` \n\r]+)(['"`])/g;
   const fileDir = dirname(writtenFilePath);
-  return fileContent.replace(importRegex, (match, keyword, openQuote, relativePath, closeQuote) => {
-    let targetPath = relativePath;
+  return fileContent.replace(importRegex, (match, keyword, openQuote, importPath, closeQuote) => {
+    let targetPath = importPath;
     if (aliasBase && !aliasBase.startsWith(".")) {
-      const absoluteTarget = path.resolve(fileDir, relativePath);
+      const absoluteTarget = path.resolve(fileDir, importPath);
       const fromBlocksRoot = path.relative(blocksRoot, absoluteTarget).replace(/\\/g, "/");
       if (!fromBlocksRoot.startsWith("..")) {
         targetPath = `${aliasBase}/${fromBlocksRoot}`.replace(/\/+/g, "/");
@@ -39,6 +107,12 @@ function rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase,
     const hasJsExt = targetPath.endsWith(".js");
     if (strategy === "rewrite" && !hasJsExt) {
       targetPath = targetPath.replace(/\.(ts|tsx|mts|cts)$/, "");
+      if (downloadedFiles.size > 0) {
+        const indexResolved = resolveIndexImport(targetPath, fileDir, downloadedFiles);
+        if (indexResolved) {
+          targetPath = indexResolved;
+        }
+      }
       targetPath = `${targetPath}.js`;
     } else if (strategy === "remove" && hasJsExt) {
       targetPath = targetPath.slice(0, -3);
@@ -81,87 +155,17 @@ async function findUp(filename, startDir) {
   }
   return null;
 }
-async function addCommand(blockName, options = {}) {
+async function addSingleBlock(targetBlock, blockMap, config, rootDir, physicalBlocksPath, blocksRootAbsolute, aliasBase, envKey, rewriteStrategy, options) {
   const { yes = false, json = false } = options;
-  if (!json) {
-    console.log("");
-    intro(`${pc.bgCyan(pc.black(" blockend "))} ${pc.dim("add")}`);
-  }
-  const cwd = process.cwd();
-  const configPath = await findUp("blockend.json", cwd);
-  if (!configPath) {
-    outputError(json, "blockend.json not found. Run 'npx blockend init' first.");
-    return;
-  }
-  const rootDir = dirname(configPath);
-  let config;
-  try {
-    config = JSON.parse(await fs.readFile(configPath, "utf-8"));
-  } catch (err) {
-    outputError(json, "Failed to parse blockend.json.");
-    if (!json) log.error(pc.dim(String(err)));
-    return;
-  }
-  if (config.language !== "typescript") {
-    outputError(json, "Blockend currently only supports TypeScript projects.");
-    return;
-  }
-  const physicalBlocksPath = config.paths.blocks;
-  const blocksRootAbsolute = path.resolve(rootDir, physicalBlocksPath);
-  const aliasBase = config.aliases.blocks;
-  const envKey = config.environment;
-  const rewriteStrategy = config.importRewriteStrategy ?? "remove";
   const s = spinner();
-  if (!json) s.start("Fetching registry...");
-  let registry;
-  try {
-    const res = await fetch(MANIFEST_URL);
-    if (!res.ok) throw new Error(`HTTP ${res.status}`);
-    registry = await res.json();
-    if (!json) s.stop("Registry synced.");
-  } catch (err) {
-    if (!json) {
-      s.stop("Failed to fetch registry.");
-      log.error(pc.dim(String(err)));
-    } else outputError(json, "Failed to fetch registry from GitHub.");
-    return;
-  }
-  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
-  if (yes && !blockName) {
-    outputError(json, "Block name required with --yes. Usage: blockend add <block> --yes");
-    return;
-  }
-  let targetBlock = blockName;
-  if (!targetBlock) {
-    const available = Object.entries(blockMap).filter(
-      ([, block]) => block != null && blockSupportsEnv(block, envKey)
-    );
-    if (available.length === 0) {
-      outputError(json, `No blocks available for environment: ${envKey}`);
-      if (!json) outro(pc.dim("Exiting."));
-      return;
-    }
-    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
-    const selectPrompt = await select({
-      message: "Which block would you like to add?",
-      options: available.map(([key, block], i) => ({
-        value: key,
-        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(pc.cyan(key.padEnd(maxKeyLen + 4)))}${pc.dim(
-          block.description.length > 60 ? `${block.description.slice(0, 60)}...` : block.description
-        )}`
-      }))
-    });
-    handleCancel(selectPrompt);
-    targetBlock = selectPrompt;
-  }
   const blockMeta = blockMap[targetBlock];
   if (!blockMeta) {
     outputError(json, `Block "${targetBlock}" not found in the registry.`);
-    return;
+    return { success: false, filesWritten: [], message: `Block "${targetBlock}" not found` };
   }
   if (!blockSupportsEnv(blockMeta, envKey)) {
     outputError(json, `Block "${targetBlock}" does not support environment: ${envKey}`);
-    return;
+    return { success: false, filesWritten: [], message: `Block "${targetBlock}" incompatible` };
   }
   const adapterContext = resolveAdapterContext(blockMeta, envKey);
   if (!adapterContext) {
@@ -169,12 +173,12 @@ async function addCommand(blockName, options = {}) {
       json,
       `Block "${targetBlock}" has no adapter or environment entry for: ${envKey}. This is a registry configuration issue \u2014 please open an issue.`
     );
-    return;
+    return { success: false, filesWritten: [], message: `No adapter for "${targetBlock}"` };
   }
   const variantKeys = Object.keys(adapterContext.variants ?? {});
   if (variantKeys.length === 0) {
     outputError(json, `No variants found for "${targetBlock}" / "${envKey}".`);
-    return;
+    return { success: false, filesWritten: [], message: `No variants for "${targetBlock}"` };
   }
   let selectedVariant;
   if (yes) {
@@ -185,7 +189,7 @@ async function addCommand(blockName, options = {}) {
     selectedVariant = variantKeys[0];
   } else {
     const variantPrompt = await select({
-      message: "Select a storage variant:",
+      message: `Select a storage variant for ${targetBlock}:`,
       options: variantKeys.map((v) => ({ value: v, label: v.toUpperCase() }))
     });
     handleCancel(variantPrompt);
@@ -196,7 +200,7 @@ async function addCommand(blockName, options = {}) {
   const packageJsonPath = await findUp("package.json", rootDir);
   if (!packageJsonPath) {
     outputError(json, "Could not locate package.json.");
-    return;
+    return { success: false, filesWritten: [], message: "package.json not found" };
   }
   const packageJsonDir = dirname(packageJsonPath);
   let packageJson;
@@ -205,34 +209,42 @@ async function addCommand(blockName, options = {}) {
   } catch (err) {
     outputError(json, "Failed to parse package.json.");
     if (!json) log.error(pc.dim(String(err)));
-    return;
+    return { success: false, filesWritten: [], message: "Failed to parse package.json" };
   }
   const installedDeps = {
     ...packageJson.dependencies ?? {},
     ...packageJson.devDependencies ?? {}
   };
-  const missingProd = getMissingDependencies(
-    [
-      ...blockMeta.dependencies ?? [],
-      ...adapterContext.dependencies ?? [],
-      ...variantMeta?.dependencies ?? []
-    ],
-    installedDeps
-  );
-  const missingDev = getMissingDependencies(
-    [
-      ...blockMeta.devDependencies ?? [],
-      ...adapterContext.devDependencies ?? [],
-      ...variantMeta?.devDependencies ?? []
-    ],
-    installedDeps
-  );
+  const allBlockDeps = [
+    ...blockMeta.dependencies ?? [],
+    ...adapterContext.dependencies ?? [],
+    ...variantMeta?.dependencies ?? []
+  ];
+  const allBlockDevDeps = [
+    ...blockMeta.devDependencies ?? [],
+    ...adapterContext.devDependencies ?? [],
+    ...variantMeta?.devDependencies ?? []
+  ];
+  const missingProd = getMissingDependencies(allBlockDeps, installedDeps, true);
+  const missingDev = getMissingDependencies(allBlockDevDeps, installedDeps, true);
+  const prodConflicts = getVersionConflicts(allBlockDeps, installedDeps);
+  const devConflicts = getVersionConflicts(allBlockDevDeps, installedDeps);
+  const allConflicts = [...prodConflicts, ...devConflicts];
+  if (allConflicts.length > 0 && !json) {
+    log.warn(`Version conflicts detected:`);
+    for (const conflict of allConflicts) {
+      log.warn(`  ${pc.yellow("!")} ${conflict}`);
+    }
+  }
   if (missingProd.length > 0 || missingDev.length > 0) {
     if (!json) log.warn(`Missing: ${pc.cyan([...missingProd, ...missingDev].join(", "))}`);
-    const shouldInstall = yes ? true : await confirm({ message: "Install missing dependencies?", initialValue: true });
+    const shouldInstall = yes ? true : await confirm({
+      message: `Install missing dependencies for ${targetBlock}?`,
+      initialValue: true
+    });
     if (!yes) handleCancel(shouldInstall);
     if (shouldInstall) {
-      const pm = await readFile(join(packageJsonDir, "blockend.json"), "utf8").then((data) => JSON.parse(data).packageManager).catch(() => "npm");
+      const pm = await fs.readFile(join(packageJsonDir, "blockend.json"), "utf8").then((data) => JSON.parse(data).packageManager).catch(() => "npm");
       if (!json) s.start(`Installing via ${pm}...`);
       const tasks = [];
       if (missingProd.length > 0) {
@@ -268,7 +280,7 @@ async function addCommand(blockName, options = {}) {
           s.stop("Installation failed.");
           log.error(pc.dim(String(err)));
         } else outputError(json, "Dependency installation failed.");
-        return;
+        return { success: false, filesWritten: [], message: "Dependency installation failed" };
       }
     }
   }
@@ -305,43 +317,215 @@ async function addCommand(blockName, options = {}) {
     });
     if (!yes) handleCancel(overwrite);
     if (!overwrite) {
-      outputResult(json, { success: false, reason: "aborted", message: "Local files preserved." });
-      return;
+      return { success: false, filesWritten: [], message: "Local files preserved." };
     }
   }
   if (!json) s.start(`Downloading ${targetBlock}...`);
   const filesWritten = [];
+  const downloadedTargets = /* @__PURE__ */ new Set();
   try {
+    const fileBatches = [];
     for (const fm of filesToDownload) {
-      const res = await fetch(`${MANIFEST_URL}/${fm.source}`);
+      const res = await fetch(`${RAW_CDN_BASE}/${fm.source}`);
       if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
-      let content = await res.text();
+      fileBatches.push({ fm, raw: await res.text() });
+      downloadedTargets.add(fm.target);
+    }
+    let contentHash = 0;
+    for (const { fm, raw } of fileBatches) {
       const writtenFilePath = path.join(targetFolder, fm.target);
-      content = rewriteFileImports(
-        content,
+      const content = rewriteFileImports(
+        raw,
         writtenFilePath,
         blocksRootAbsolute,
         aliasBase,
-        rewriteStrategy
+        rewriteStrategy,
+        downloadedTargets
       );
       await fs.mkdir(dirname(writtenFilePath), { recursive: true });
       await fs.writeFile(writtenFilePath, content, "utf-8");
       filesWritten.push(writtenFilePath);
+      for (let i = 0; i < content.length; i++) {
+        contentHash = (contentHash << 5) - contentHash + content.charCodeAt(i) | 0;
+      }
+    }
+    const blockVersion = blockMeta.version ?? "0.0.0";
+    const installedRecord = {
+      name: targetBlock,
+      version: blockVersion,
+      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      files: filesWritten.map((f) => path.relative(targetFolder, f).replace(/\\/g, "/")),
+      contentHash: contentHash.toString(16)
+    };
+    try {
+      const blockendPath = join(rootDir, "blockend.json");
+      const cfgRaw = await fs.readFile(blockendPath, "utf-8");
+      const cfgData = JSON.parse(cfgRaw);
+      if (!Array.isArray(cfgData.installed)) cfgData.installed = [];
+      cfgData.installed = cfgData.installed.filter((b) => b.name !== targetBlock);
+      cfgData.installed.push(installedRecord);
+      await fs.writeFile(blockendPath, JSON.stringify(cfgData, null, 2), "utf-8");
+    } catch {
     }
     if (!json) s.stop("Files written.");
-    outputResult(json, {
+    return {
       success: true,
-      block: targetBlock,
       filesWritten,
-      dependenciesInstalled: [...missingProd, ...missingDev],
       message: `${targetBlock} added to ${physicalBlocksPath}/${targetBlock}`
-    });
+    };
   } catch (err) {
     if (!json) {
       s.stop("Failed.");
       log.error(pc.dim(String(err)));
     } else outputError(json, "Fatal error while writing block files.");
+    return { success: false, filesWritten: [], message: `Failed to add ${targetBlock}` };
+  }
+}
+async function addCommand(blockName, options = {}) {
+  const { yes = false, json = false, multi = false } = options;
+  if (!json) {
+    console.log("");
+    intro(`${pc.bgCyan(pc.black(" blockend "))} ${pc.dim("add")}`);
+  }
+  const cwd = process.cwd();
+  const configPath = await findUp("blockend.json", cwd);
+  if (!configPath) {
+    outputError(json, "blockend.json not found. Run 'npx blockend init' first.");
+    return;
+  }
+  const rootDir = dirname(configPath);
+  let config;
+  try {
+    config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+  } catch (err) {
+    outputError(json, "Failed to parse blockend.json.");
+    if (!json) log.error(pc.dim(String(err)));
+    return;
+  }
+  if (config.language !== "typescript") {
+    outputError(json, "Blockend currently only supports TypeScript projects.");
+    return;
+  }
+  const physicalBlocksPath = config.paths.blocks;
+  const blocksRootAbsolute = path.resolve(rootDir, physicalBlocksPath);
+  const aliasBase = config.aliases.blocks;
+  const envKey = config.environment;
+  const rewriteStrategy = config.importRewriteStrategy ?? "remove";
+  const s = spinner();
+  if (!json) s.start("Fetching registry...");
+  let registry;
+  try {
+    const res = await fetch(MANIFEST_URL);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    registry = await res.json();
+    if (!json) s.stop("Registry synced.");
+  } catch (err) {
+    if (!json) {
+      s.stop("Failed to fetch registry.");
+      log.error(pc.dim(String(err)));
+    } else outputError(json, "Failed to fetch registry from GitHub.");
+    return;
+  }
+  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
+  if (yes && !blockName) {
+    outputError(json, "Block name required with --yes. Usage: blockend add <block> --yes");
+    return;
+  }
+  if (multi && !blockName) {
+    const available = Object.entries(blockMap).filter(
+      ([, block]) => block != null && blockSupportsEnv(block, envKey)
+    );
+    if (available.length === 0) {
+      outputError(json, `No blocks available for environment: ${envKey}`);
+      if (!json) outro(pc.dim("Exiting."));
+      return;
+    }
+    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
+    const multiSelectPrompt = await multiselect({
+      message: "Select blocks to add (space to select, enter to confirm):",
+      options: available.map(([key, block], i) => ({
+        value: key,
+        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(pc.cyan(key.padEnd(maxKeyLen + 4)))}${pc.dim(
+          block.description.length > 60 ? `${block.description.slice(0, 60)}...` : block.description
+        )}`
+      }))
+    });
+    handleCancel(multiSelectPrompt);
+    const selectedBlocks = multiSelectPrompt;
+    if (selectedBlocks.length === 0) {
+      outputError(json, "No blocks selected.");
+      return;
+    }
+    if (!json) log.info(`
+Adding ${selectedBlocks.length} block(s)...
+`);
+    const results = [];
+    for (const block of selectedBlocks) {
+      const result2 = await addSingleBlock(
+        block,
+        blockMap,
+        config,
+        rootDir,
+        physicalBlocksPath,
+        blocksRootAbsolute,
+        aliasBase,
+        envKey,
+        rewriteStrategy,
+        options
+      );
+      if (result2.success) {
+        results.push(result2.message);
+      }
+    }
+    if (json) {
+      process.stdout.write(JSON.stringify({ success: true, blocks: results }) + "\n");
+    } else {
+      outro(pc.green(`
+\u2728 Added ${results.length} block(s) successfully!`));
+    }
+    return;
   }
+  let targetBlock = blockName;
+  if (!targetBlock) {
+    const available = Object.entries(blockMap).filter(
+      ([, block]) => block != null && blockSupportsEnv(block, envKey)
+    );
+    if (available.length === 0) {
+      outputError(json, `No blocks available for environment: ${envKey}`);
+      if (!json) outro(pc.dim("Exiting."));
+      return;
+    }
+    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
+    const selectPrompt = await select({
+      message: "Which block would you like to add?",
+      options: available.map(([key, block], i) => ({
+        value: key,
+        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(pc.cyan(key.padEnd(maxKeyLen + 4)))}${pc.dim(
+          block.description.length > 60 ? `${block.description.slice(0, 60)}...` : block.description
+        )}`
+      }))
+    });
+    handleCancel(selectPrompt);
+    targetBlock = selectPrompt;
+  }
+  const result = await addSingleBlock(
+    targetBlock,
+    blockMap,
+    config,
+    rootDir,
+    physicalBlocksPath,
+    blocksRootAbsolute,
+    aliasBase,
+    envKey,
+    rewriteStrategy,
+    options
+  );
+  outputResult(json, {
+    success: result.success,
+    block: targetBlock,
+    filesWritten: result.filesWritten,
+    message: result.message
+  });
 }
 
 // src/commands/init.ts
@@ -355,12 +539,12 @@ import pc3 from "picocolors";
 import { join as join6 } from "path";
 
 // src/detectors/readers/package.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile } from "fs/promises";
 import { join as join2 } from "path";
 async function readPackageJson(cwd) {
   const pkgPath = join2(cwd, "package.json");
   try {
-    const content = await readFile2(pkgPath, "utf-8");
+    const content = await readFile(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error(`No package.json found at ${pkgPath}. Run blockend from your project root.`);
@@ -368,14 +552,14 @@ async function readPackageJson(cwd) {
 }
 
 // src/detectors/readers/tsconfig.ts
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { existsSync } from "fs";
 import { join as join3 } from "path";
 async function readTsConfig(cwd) {
   const tsconfigPath = join3(cwd, "tsconfig.json");
   if (!existsSync(tsconfigPath)) return null;
   try {
-    const content = await readFile3(tsconfigPath, "utf-8");
+    const content = await readFile2(tsconfigPath, "utf-8");
     const cleanLines = content.split(/\r?\n/).filter((line) => {
       const trimmed = line.trim();
       return !trimmed.startsWith("//") && !trimmed.startsWith("/*");
@@ -958,7 +1142,7 @@ async function mcpStartCommand() {
   );
   server.tool(
     "detect_project",
-    "Analyzes a project context.",
+    "Analyzes a project context: framework, language, package manager, etc.",
     {
       projectPath: z.string().describe("Absolute path to the project root")
     },
@@ -969,25 +1153,97 @@ async function mcpStartCommand() {
       return { content: [{ type: "text", text: result.text }], isError: result.isError };
     }
   );
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-async function mcpInitCommand(options) {
-  const cwd = process.cwd();
-  let chosenClient = options.client;
-  if (!chosenClient) {
-    if (options.yes) {
-      chosenClient = "claude";
-    } else {
-      const selection = await select3({
-        message: "Select target AI client layout profile:",
-        options: Object.entries(CLIENT_MATRIX).map(([key, value]) => ({
-          value: key,
-          label: value.label
-        }))
+  server.tool(
+    "diff_block",
+    "Preview what files a block would generate without writing to disk. Shows new/modified/unchanged files.",
+    {
+      blockName: z.string().describe("Block name to preview, e.g. rate-limiter, pino-logger"),
+      projectPath: z.string().describe("Absolute path to the project root")
+    },
+    async ({ blockName, projectPath }) => {
+      const result = await safeExec(
+        "npx",
+        ["--no-install", "blockend", "diff", blockName, "--json"],
+        { cwd: projectPath }
+      );
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  server.tool(
+    "doctor",
+    "Check project health: validates blockend.json, detects framework, checks for issues.",
+    {
+      projectPath: z.string().describe("Absolute path to the project root")
+    },
+    async ({ projectPath }) => {
+      const result = await safeExec("npx", ["--no-install", "blockend", "doctor", "--json"], {
+        cwd: projectPath
       });
-      if (typeof selection === "symbol") return;
-      chosenClient = selection;
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  server.tool(
+    "update_check",
+    "Check for available updates to installed blocks. Shows version comparison and diffs.",
+    {
+      projectPath: z.string().describe("Absolute path to the project root")
+    },
+    async ({ projectPath }) => {
+      const result = await safeExec("npx", ["--no-install", "blockend", "update", "--json"], {
+        cwd: projectPath
+      });
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  server.tool(
+    "update_apply",
+    "Apply updates to all installed blocks. Downloads new versions, rewrites imports, and updates blockend.json.",
+    {
+      projectPath: z.string().describe("Absolute path to the project root")
+    },
+    async ({ projectPath }) => {
+      const result = await safeExec(
+        "npx",
+        ["--no-install", "blockend", "update", "--apply", "--yes", "--json"],
+        { cwd: projectPath }
+      );
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  server.tool(
+    "add_blocks",
+    "Install multiple blocks at once via interactive selection.",
+    {
+      projectPath: z.string().describe("Absolute path to the project root")
+    },
+    async ({ projectPath }) => {
+      const result = await safeExec(
+        "npx",
+        ["--no-install", "blockend", "add", "--multi", "--yes", "--json"],
+        { cwd: projectPath }
+      );
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+async function mcpInitCommand(options) {
+  const cwd = process.cwd();
+  let chosenClient = options.client;
+  if (!chosenClient) {
+    if (options.yes) {
+      chosenClient = "claude";
+    } else {
+      const selection = await select3({
+        message: "Select target AI client layout profile:",
+        options: Object.entries(CLIENT_MATRIX).map(([key, value]) => ({
+          value: key,
+          label: value.label
+        }))
+      });
+      if (typeof selection === "symbol") return;
+      chosenClient = selection;
     }
   }
   const meta = CLIENT_MATRIX[chosenClient];
@@ -1060,6 +1316,840 @@ async function mcpInitCommand(options) {
   }
 }
 
+// src/commands/diff.ts
+import path4, { join as join10, dirname as dirname3 } from "path";
+import fs5 from "fs/promises";
+import { intro as intro3, outro as outro6, spinner as spinner5, log as log3 } from "@clack/prompts";
+import pc7 from "picocolors";
+var REPO_OWNER3 = "codewithnuh";
+var REPO_NAME3 = "blockend";
+var BRANCH3 = "master";
+var RAW_CDN_BASE2 = `https://raw.githubusercontent.com/${REPO_OWNER3}/${REPO_NAME3}/${BRANCH3}`;
+var MANIFEST_URL3 = `${RAW_CDN_BASE2}/registry/index.json`;
+function blockSupportsEnv2(block, envKey) {
+  if (block.frameworks && block.frameworks.length > 0) {
+    return block.frameworks.includes("*") || block.frameworks.includes(envKey);
+  }
+  return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
+}
+function resolveAdapterContext2(block, envKey) {
+  return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
+}
+async function findUp3(filename, startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join10(dir, filename);
+    try {
+      await fs5.access(candidate);
+      return candidate;
+    } catch {
+      const parent = dirname3(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+async function fileExists(filePath) {
+  try {
+    await fs5.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function diffCommand(blockName, options = {}) {
+  const { json = false } = options;
+  if (!json) {
+    console.log("");
+    intro3(`${pc7.bgCyan(pc7.black(" blockend "))} ${pc7.dim("diff")}`);
+  }
+  if (!blockName) {
+    return { block: "", files: [], error: "Block name is required. Usage: blockend diff <block>" };
+  }
+  const cwd = process.cwd();
+  const configPath = await findUp3("blockend.json", cwd);
+  if (!configPath) {
+    const error = "blockend.json not found. Run 'npx blockend init' first.";
+    if (json) {
+      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
+    } else {
+      log3.error(error);
+    }
+    return { block: blockName, files: [], error };
+  }
+  const rootDir = dirname3(configPath);
+  let config;
+  try {
+    config = JSON.parse(await fs5.readFile(configPath, "utf-8"));
+  } catch {
+    const error = "Failed to parse blockend.json.";
+    if (json) {
+      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
+    } else {
+      log3.error(error);
+    }
+    return { block: blockName, files: [], error };
+  }
+  const physicalBlocksPath = config.paths.blocks;
+  const blocksRootAbsolute = path4.resolve(rootDir, physicalBlocksPath);
+  const envKey = config.environment;
+  const s = spinner5();
+  if (!json) s.start("Fetching registry...");
+  let registry;
+  try {
+    const res = await fetch(MANIFEST_URL3);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    registry = await res.json();
+    if (!json) s.stop("Registry synced.");
+  } catch (err) {
+    const error = `Failed to fetch registry: ${String(err)}`;
+    if (!json) {
+      s.stop("Failed.");
+      log3.error(error);
+    }
+    return { block: blockName, files: [], error };
+  }
+  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
+  const blockMeta = blockMap[blockName];
+  if (!blockMeta) {
+    const error = `Block "${blockName}" not found in the registry.`;
+    if (json) {
+      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
+    } else {
+      log3.error(error);
+      outro6(pc7.dim("Block not found."));
+    }
+    return { block: blockName, files: [], error };
+  }
+  if (!blockSupportsEnv2(blockMeta, envKey)) {
+    const error = `Block "${blockName}" does not support environment: ${envKey}`;
+    if (json) {
+      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
+    } else {
+      log3.error(error);
+    }
+    return { block: blockName, files: [], error };
+  }
+  const adapterContext = resolveAdapterContext2(blockMeta, envKey);
+  if (!adapterContext) {
+    const error = `Block "${blockName}" has no adapter for: ${envKey}`;
+    if (json) {
+      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
+    } else {
+      log3.error(error);
+    }
+    return { block: blockName, files: [], error };
+  }
+  const variantKeys = Object.keys(adapterContext.variants ?? {});
+  if (variantKeys.length === 0) {
+    const error = `No variants found for "${blockName}" / "${envKey}".`;
+    if (json) {
+      process.stdout.write(JSON.stringify({ block: blockName, files: [], error }) + "\n");
+    } else {
+      log3.error(error);
+    }
+    return { block: blockName, files: [], error };
+  }
+  const selectedVariant = variantKeys[0];
+  const variantMeta = adapterContext.variants[selectedVariant];
+  const targetFolder = path4.resolve(blocksRootAbsolute, blockName);
+  const filesToDownload = [];
+  if (blockMeta.baseFiles?.length) {
+    filesToDownload.push(...blockMeta.baseFiles);
+  }
+  if (adapterContext.core) {
+    filesToDownload.push({
+      source: adapterContext.core,
+      target: path4.basename(adapterContext.core)
+    });
+  }
+  if (variantMeta && Array.isArray(variantMeta.files)) {
+    for (const entry of variantMeta.files) {
+      filesToDownload.push(
+        typeof entry === "string" ? { source: entry, target: path4.basename(entry) } : entry
+      );
+    }
+  }
+  if (!json) s.start(`Comparing ${blockName} files...`);
+  const diffFiles = [];
+  try {
+    for (const fm of filesToDownload) {
+      const res = await fetch(`${RAW_CDN_BASE2}/${fm.source}`);
+      if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
+      const newContent = await res.text();
+      const targetPath = path4.join(targetFolder, fm.target);
+      let existingContent = null;
+      let status = "new";
+      if (await fileExists(targetPath)) {
+        try {
+          existingContent = await fs5.readFile(targetPath, "utf-8");
+          status = existingContent === newContent ? "unchanged" : "modified";
+        } catch {
+        }
+      }
+      diffFiles.push({
+        name: fm.target,
+        sourcePath: fm.source,
+        targetPath,
+        existingContent,
+        newContent,
+        status
+      });
+    }
+    if (!json) s.stop("Comparison complete.");
+    if (!json) {
+      console.log(`
+  ${pc7.bold(pc7.cyan(blockName))} \u2014 ${pc7.dim(selectedVariant)} variant
+`);
+      for (const file of diffFiles) {
+        const icon = file.status === "new" ? pc7.green("+") : file.status === "modified" ? pc7.yellow("~") : pc7.dim("=");
+        const label = file.status === "new" ? pc7.green("new") : file.status === "modified" ? pc7.yellow("modified") : pc7.dim("unchanged");
+        console.log(`  ${icon} ${pc7.bold(file.name)} ${pc7.dim(`(${label})`)}`);
+        if (file.status === "modified" && file.existingContent !== null) {
+          const oldLines = file.existingContent.split("\n");
+          const newLines = file.newContent.split("\n");
+          const maxLines = Math.max(oldLines.length, newLines.length);
+          for (let i = 0; i < Math.min(maxLines, 20); i++) {
+            const oldLine = oldLines[i];
+            const newLine = newLines[i];
+            if (oldLine !== newLine) {
+              if (oldLine !== void 0) {
+                console.log(`    ${pc7.red(`- ${oldLine}`)}`);
+              }
+              if (newLine !== void 0) {
+                console.log(`    ${pc7.green(`+ ${newLine}`)}`);
+              }
+            }
+          }
+          if (maxLines > 20) {
+            console.log(`    ${pc7.dim(`... ${maxLines - 20} more lines`)}`);
+          }
+        }
+      }
+      console.log("");
+      const newCount = diffFiles.filter((f) => f.status === "new").length;
+      const modCount = diffFiles.filter((f) => f.status === "modified").length;
+      const unchangedCount = diffFiles.filter((f) => f.status === "unchanged").length;
+      outro6(
+        `${pc7.green(`${newCount} new`)} | ${pc7.yellow(`${modCount} modified`)} | ${pc7.dim(`${unchangedCount} unchanged`)}`
+      );
+    }
+    const result = { block: blockName, files: diffFiles };
+    if (json) {
+      process.stdout.write(JSON.stringify(result) + "\n");
+    }
+    return result;
+  } catch (err) {
+    const error = `Failed during diff: ${String(err)}`;
+    if (!json) {
+      s.stop("Failed.");
+      log3.error(error);
+    }
+    const result = { block: blockName, files: diffFiles, error };
+    if (json) {
+      process.stdout.write(JSON.stringify(result) + "\n");
+    }
+    return result;
+  }
+}
+
+// src/commands/doctor.ts
+import path5, { join as join11, dirname as dirname4 } from "path";
+import fs6 from "fs/promises";
+import { existsSync as existsSync5 } from "fs";
+import { intro as intro4, outro as outro7, spinner as spinner6 } from "@clack/prompts";
+import pc8 from "picocolors";
+function outputDoctorResult(json, result) {
+  if (json) {
+    process.stdout.write(
+      JSON.stringify({
+        success: result.errors.length === 0,
+        checks: result.checks,
+        warnings: result.warnings,
+        errors: result.errors
+      }) + "\n"
+    );
+  } else {
+    console.log("");
+    for (const check of result.checks) {
+      const icon = check.status === "ok" ? pc8.green("\u2714") : check.status === "warning" ? pc8.yellow("\u26A0") : pc8.red("\u2716");
+      const msg = check.status === "ok" ? pc8.dim(check.message) : check.status === "warning" ? pc8.yellow(check.message) : pc8.red(check.message);
+      console.log(`  ${icon} ${pc8.bold(check.name)}: ${msg}`);
+    }
+    console.log("");
+    if (result.errors.length > 0) {
+      outro7(pc8.red(`Found ${result.errors.length} error(s). Please fix the issues above.`));
+    } else if (result.warnings.length > 0) {
+      outro7(pc8.yellow(`Found ${result.warnings.length} warning(s). Everything looks functional.`));
+    } else {
+      outro7(pc8.green("All checks passed! Your project is healthy."));
+    }
+  }
+}
+async function findUp4(filename, startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join11(dir, filename);
+    try {
+      await fs6.access(candidate);
+      return candidate;
+    } catch {
+      const parent = dirname4(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+async function doctorCommand(options = {}) {
+  const { json = false } = options;
+  if (!json) {
+    console.log("");
+    intro4(`${pc8.bgCyan(pc8.black(" blockend "))} ${pc8.dim("doctor")}`);
+  }
+  const cwd = process.cwd();
+  const checks = [];
+  const warnings = [];
+  const errors = [];
+  function addCheck(check) {
+    checks.push(check);
+    if (check.status === "warning") warnings.push(check);
+    if (check.status === "error") errors.push(check);
+  }
+  const s = spinner6();
+  if (!json) s.start("Scanning project health...");
+  const packageJsonPath = await findUp4("package.json", cwd);
+  if (packageJsonPath) {
+    addCheck({ name: "package.json", status: "ok", message: "Found" });
+  } else {
+    addCheck({
+      name: "package.json",
+      status: "error",
+      message: "Not found. Run 'npm init' or 'pnpm init' first."
+    });
+  }
+  const configPath = await findUp4("blockend.json", cwd);
+  if (configPath) {
+    addCheck({ name: "blockend.json", status: "ok", message: "Found" });
+  } else {
+    addCheck({
+      name: "blockend.json",
+      status: "error",
+      message: "Not found. Run 'npx blockend init' first."
+    });
+  }
+  const tsConfigPath = await findUp4("tsconfig.json", cwd);
+  if (tsConfigPath) {
+    addCheck({ name: "tsconfig.json", status: "ok", message: "Found" });
+  } else {
+    addCheck({
+      name: "tsconfig.json",
+      status: "warning",
+      message: "Not found. TypeScript projects typically need one."
+    });
+  }
+  const hasPnpmLock = existsSync5(join11(cwd, "pnpm-lock.yaml"));
+  const hasYarnLock = existsSync5(join11(cwd, "yarn.lock"));
+  const hasBunLock = existsSync5(join11(cwd, "bun.lockb"));
+  const hasNpmLock = existsSync5(join11(cwd, "package-lock.json"));
+  if (hasPnpmLock || hasYarnLock || hasBunLock || hasNpmLock) {
+    const pmName = hasPnpmLock ? "pnpm" : hasYarnLock ? "yarn" : hasBunLock ? "bun" : "npm";
+    addCheck({ name: "Lockfile", status: "ok", message: `${pmName} lockfile found` });
+  } else {
+    addCheck({
+      name: "Lockfile",
+      status: "warning",
+      message: "No lockfile detected. Run your package manager to generate one."
+    });
+  }
+  try {
+    const context = await detectProject(cwd);
+    if (context.framework !== "none") {
+      addCheck({
+        name: "Framework",
+        status: "ok",
+        message: `Detected: ${context.framework}`
+      });
+    } else {
+      addCheck({
+        name: "Framework",
+        status: "warning",
+        message: "No framework detected. Blockend works best with Express, Fastify, Hono, or Next.js."
+      });
+    }
+    addCheck({
+      name: "Package manager",
+      status: "ok",
+      message: `Detected: ${context.packageManager}`
+    });
+    if (context.hasRedis) {
+      addCheck({ name: "Redis", status: "ok", message: "Redis client detected" });
+    }
+    if (context.hasPrisma) {
+      addCheck({ name: "Prisma", status: "ok", message: "Prisma ORM detected" });
+    }
+    if (context.hasDrizzle) {
+      addCheck({ name: "Drizzle", status: "ok", message: "Drizzle ORM detected" });
+    }
+  } catch (err) {
+    addCheck({
+      name: "Project detection",
+      status: "error",
+      message: `Failed to scan project: ${String(err)}`
+    });
+  }
+  if (configPath) {
+    try {
+      const raw = await fs6.readFile(configPath, "utf-8");
+      const config = JSON.parse(raw);
+      if (!config.environment) {
+        addCheck({
+          name: "Config: environment",
+          status: "error",
+          message: "Missing 'environment' field in blockend.json"
+        });
+      } else {
+        addCheck({
+          name: "Config: environment",
+          status: "ok",
+          message: `Set to '${config.environment}'`
+        });
+      }
+      if (!config.paths?.blocks) {
+        addCheck({
+          name: "Config: blocks path",
+          status: "error",
+          message: "Missing 'paths.blocks' in blockend.json"
+        });
+      } else {
+        const blocksDir = path5.resolve(dirname4(configPath), config.paths.blocks);
+        if (existsSync5(blocksDir)) {
+          addCheck({
+            name: "Config: blocks directory",
+            status: "ok",
+            message: `Exists: ${config.paths.blocks}`
+          });
+        } else {
+          addCheck({
+            name: "Config: blocks directory",
+            status: "warning",
+            message: `Directory '${config.paths.blocks}' does not exist yet. Blocks will create it on first add.`
+          });
+        }
+      }
+    } catch {
+      addCheck({
+        name: "Config: parse",
+        status: "error",
+        message: "Failed to parse blockend.json \u2014 file may be corrupted."
+      });
+    }
+  }
+  if (!json) s.stop("Scan complete.");
+  const result = { checks, warnings, errors };
+  outputDoctorResult(json, result);
+  if (errors.length > 0 && !json) {
+    process.exit(1);
+  }
+  return result;
+}
+
+// src/commands/update.ts
+import path6, { join as join12, dirname as dirname5 } from "path";
+import fs7 from "fs/promises";
+import { intro as intro5, outro as outro8, spinner as spinner7, log as log4, multiselect as multiselect2, confirm as confirm4, isCancel as isCancel3 } from "@clack/prompts";
+import pc9 from "picocolors";
+var REPO_OWNER4 = "codewithnuh";
+var REPO_NAME4 = "blockend";
+var BRANCH4 = "master";
+var RAW_CDN_BASE3 = `https://raw.githubusercontent.com/${REPO_OWNER4}/${REPO_NAME4}/${BRANCH4}`;
+var MANIFEST_URL4 = `${RAW_CDN_BASE3}/registry/index.json`;
+function blockSupportsEnv3(block, envKey) {
+  if (block.frameworks && block.frameworks.length > 0) {
+    return block.frameworks.includes("*") || block.frameworks.includes(envKey);
+  }
+  return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
+}
+function resolveAdapterContext3(block, envKey) {
+  return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
+}
+async function findUp5(filename, startDir) {
+  let dir = startDir;
+  while (true) {
+    const candidate = join12(dir, filename);
+    try {
+      await fs7.access(candidate);
+      return candidate;
+    } catch {
+      const parent = dirname5(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+function computeLineDiff(oldContent, newContent) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  const m = oldLines.length;
+  const n = newLines.length;
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++) {
+    for (let j2 = 1; j2 <= n; j2++) {
+      if (oldLines[i2 - 1] === newLines[j2 - 1]) {
+        dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1;
+      } else {
+        dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+      }
+    }
+  }
+  let i = m, j = n;
+  const raw = [];
+  while (i > 0 || j > 0) {
+    if (i > 0 && j > 0 && oldLines[i - 1] === newLines[j - 1]) {
+      raw.unshift({ type: "context", oldLine: i, newLine: j, content: oldLines[i - 1] });
+      i--;
+      j--;
+    } else if (j > 0 && (i === 0 || dp[i][j - 1] >= dp[i - 1][j])) {
+      raw.unshift({ type: "added", newLine: j, content: newLines[j - 1] });
+      j--;
+    } else {
+      raw.unshift({ type: "removed", oldLine: i, content: oldLines[i - 1] });
+      i--;
+    }
+  }
+  const result = [];
+  for (let k = 0; k < raw.length; k++) {
+    const r = raw[k];
+    const nearChange = raw.slice(Math.max(0, k - 3), k + 4).some((x) => x.type !== "context");
+    if (r.type !== "context" || nearChange) {
+      result.push({
+        type: r.type,
+        content: r.content,
+        oldLineNo: r.oldLine,
+        newLineNo: r.newLine
+      });
+    }
+  }
+  return result;
+}
+function handleCancel2(value) {
+  if (isCancel3(value)) {
+    outro8(pc9.dim("Operation cancelled."));
+    process.exit(0);
+  }
+}
+function printDiff(diff2) {
+  for (const file of diff2) {
+    if (file.status === "unchanged") continue;
+    const icon = file.status === "added" ? pc9.green("+") : file.status === "removed" ? pc9.red("-") : pc9.yellow("~");
+    const label = file.status === "added" ? pc9.green("new") : file.status === "removed" ? pc9.red("deleted") : pc9.yellow("modified");
+    console.log(`
+  ${icon} ${pc9.bold(file.name)} ${pc9.dim(`(${label})`)}`);
+    if (file.lines.length === 0) continue;
+    let lastShownLine = -1;
+    for (let idx = 0; idx < file.lines.length; idx++) {
+      const line = file.lines[idx];
+      if (lastShownLine >= 0 && idx - lastShownLine > 1) {
+        console.log(`    ${pc9.dim("...")}`);
+      }
+      lastShownLine = idx;
+      const lineNo = line.type === "removed" ? String(line.oldLineNo ?? "").padStart(4) : String(line.newLineNo ?? "").padStart(4);
+      const prefix = line.type === "added" ? "+" : line.type === "removed" ? "-" : " ";
+      const color = line.type === "added" ? pc9.green : line.type === "removed" ? pc9.red : pc9.dim;
+      console.log(`    ${pc9.dim(lineNo)} ${color(`${prefix} ${line.content}`)}`);
+    }
+  }
+}
+function outputUpdateResult(json, result) {
+  if (json) {
+    process.stdout.write(JSON.stringify(result) + "\n");
+    return;
+  }
+  console.log("");
+  if (result.blocks.length === 0) {
+    console.log(pc9.dim("  No blocks tracked. Run 'npx blockend add <block>' to get started."));
+    console.log("");
+    return;
+  }
+  const upToDate = result.blocks.filter((b) => b.status === "up-to-date");
+  const updates = result.blocks.filter((b) => b.status === "update-available");
+  if (updates.length > 0) {
+    console.log(`  ${pc9.bold(pc9.yellow("Updates available:"))}
+`);
+    for (const block of updates) {
+      console.log(
+        `    ${pc9.yellow("~")} ${pc9.bold(block.name)} ${pc9.dim(`${block.localVersion} \u2192 ${block.remoteVersion}`)}`
+      );
+    }
+    console.log("");
+  }
+  if (upToDate.length > 0) {
+    console.log(`  ${pc9.bold(pc9.green("Up to date:"))}`);
+    for (const block of upToDate) {
+      console.log(`    ${pc9.green("\u2714")} ${block.name} ${pc9.dim(`v${block.localVersion}`)}`);
+    }
+    console.log("");
+  }
+  if (result.diffs && Object.keys(result.diffs).length > 0) {
+    console.log(`  ${pc9.bold(pc9.cyan("Change details:"))}`);
+    for (const [blockName, diffs] of Object.entries(result.diffs)) {
+      console.log(`
+  ${pc9.bold(pc9.cyan(`\u25B8 ${blockName}`))}`);
+      printDiff(diffs);
+    }
+    console.log("");
+  }
+  if (result.applied && result.applied.length > 0) {
+    outro8(pc9.green(`\u2728 Updated ${result.applied.length} block(s) successfully.`));
+  } else if (updates.length > 0) {
+    outro8(`${pc9.yellow(`${updates.length} block(s) have updates.`)} Run with --apply to update.`);
+  } else {
+    outro8(pc9.green("All tracked blocks are up to date."));
+  }
+}
+function resolveBlockFiles(blockMeta, envKey) {
+  const adapterContext = resolveAdapterContext3(blockMeta, envKey);
+  if (!adapterContext) return null;
+  const variantKeys = Object.keys(adapterContext.variants ?? {});
+  if (variantKeys.length === 0) return null;
+  const selectedVariant = variantKeys[0];
+  const variantMeta = adapterContext.variants[selectedVariant];
+  const expectedFiles = [];
+  if (blockMeta.baseFiles?.length) expectedFiles.push(...blockMeta.baseFiles);
+  if (adapterContext.core) {
+    expectedFiles.push({ source: adapterContext.core, target: path6.basename(adapterContext.core) });
+  }
+  if (variantMeta && Array.isArray(variantMeta.files)) {
+    for (const entry of variantMeta.files) {
+      expectedFiles.push(
+        typeof entry === "string" ? { source: entry, target: path6.basename(entry) } : entry
+      );
+    }
+  }
+  return { files: expectedFiles, variant: selectedVariant };
+}
+async function updateCommand(options = {}) {
+  const { json = false, diff: diff2 = true, apply = false } = options;
+  if (!json) {
+    console.log("");
+    intro5(`${pc9.bgCyan(pc9.black(" blockend "))} ${pc9.dim("update")}`);
+  }
+  const cwd = process.cwd();
+  const configPath = await findUp5("blockend.json", cwd);
+  if (!configPath) {
+    const error = "blockend.json not found. Run 'npx blockend init' first.";
+    if (json) process.stdout.write(JSON.stringify({ blocks: [], error }) + "\n");
+    else log4.error(error);
+    return { blocks: [], error };
+  }
+  const rootDir = dirname5(configPath);
+  let config;
+  try {
+    config = JSON.parse(await fs7.readFile(configPath, "utf-8"));
+  } catch {
+    const error = "Failed to parse blockend.json.";
+    if (json) process.stdout.write(JSON.stringify({ blocks: [], error }) + "\n");
+    else log4.error(error);
+    return { blocks: [], error };
+  }
+  const physicalBlocksPath = config.paths.blocks;
+  const blocksRootAbsolute = path6.resolve(rootDir, physicalBlocksPath);
+  const envKey = config.environment;
+  const aliasBase = config.aliases.blocks;
+  const rewriteStrategy = config.importRewriteStrategy ?? "remove";
+  const installedRecords = Array.isArray(config.installed) ? config.installed : [];
+  const s = spinner7();
+  if (!json) s.start("Fetching registry...");
+  let registry;
+  try {
+    const res = await fetch(MANIFEST_URL4);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    registry = await res.json();
+    if (!json) s.stop("Registry synced.");
+  } catch (err) {
+    const error = `Failed to fetch registry: ${String(err)}`;
+    if (!json) {
+      s.stop("Failed.");
+      log4.error(error);
+    }
+    return { blocks: [], error };
+  }
+  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
+  if (!json) s.start("Comparing versions...");
+  const blockResults = [];
+  const diffs = {};
+  for (const record of installedRecords) {
+    const blockMeta = blockMap[record.name];
+    const remoteVersion = blockMeta?.version ?? "0.0.0";
+    if (!blockMeta || !blockSupportsEnv3(blockMeta, envKey)) {
+      blockResults.push({
+        name: record.name,
+        localVersion: record.version,
+        remoteVersion: "?",
+        status: "not-tracked"
+      });
+      continue;
+    }
+    const hasUpdate = record.version !== remoteVersion || record.contentHash === "0";
+    blockResults.push({
+      name: record.name,
+      localVersion: record.version,
+      remoteVersion,
+      status: hasUpdate ? "update-available" : "up-to-date"
+    });
+    if (hasUpdate && diff2) {
+      const resolved = resolveBlockFiles(blockMeta, envKey);
+      if (!resolved) continue;
+      const targetFolder = path6.resolve(blocksRootAbsolute, record.name);
+      const fileDiffs = [];
+      for (const fm of resolved.files) {
+        const localPath = join12(targetFolder, fm.target);
+        let localContent = "";
+        let localExists = false;
+        try {
+          localContent = await fs7.readFile(localPath, "utf-8");
+          localExists = true;
+        } catch {
+          localContent = "";
+        }
+        let remoteContent = "";
+        try {
+          const res = await fetch(`${RAW_CDN_BASE3}/${fm.source}`);
+          if (res.ok) remoteContent = await res.text();
+        } catch {
+          remoteContent = "";
+        }
+        if (!localExists) {
+          fileDiffs.push({
+            name: fm.target,
+            file: fm.target,
+            status: "added",
+            lines: remoteContent.split("\n").map((l, i) => ({
+              type: "added",
+              content: l,
+              newLineNo: i + 1
+            }))
+          });
+        } else if (localContent !== remoteContent) {
+          fileDiffs.push({
+            name: fm.target,
+            file: fm.target,
+            status: "modified",
+            lines: computeLineDiff(localContent, remoteContent)
+          });
+        } else {
+          fileDiffs.push({
+            name: fm.target,
+            file: fm.target,
+            status: "unchanged",
+            lines: []
+          });
+        }
+      }
+      diffs[record.name] = fileDiffs;
+    }
+  }
+  if (!json) s.stop("Comparison complete.");
+  const updateableBlocks = blockResults.filter((b) => b.status === "update-available");
+  if (apply && updateableBlocks.length > 0) {
+    let selectedNames;
+    if (json) {
+      selectedNames = updateableBlocks.map((b) => b.name);
+    } else {
+      const multiPrompt = await multiselect2({
+        message: "Select blocks to update (space to select, enter to confirm):",
+        options: updateableBlocks.map((b) => ({
+          value: b.name,
+          label: `${pc9.bold(pc9.cyan(b.name))} ${pc9.dim(`${b.localVersion} \u2192 ${b.remoteVersion}`)}`
+        }))
+      });
+      handleCancel2(multiPrompt);
+      selectedNames = multiPrompt;
+    }
+    if (selectedNames.length === 0) {
+      if (!json) outro8(pc9.dim("No blocks selected."));
+      return { blocks: blockResults, diffs };
+    }
+    if (!json) {
+      const proceed = await confirm4({
+        message: `Update ${selectedNames.length} block(s)? This will overwrite local files.`,
+        initialValue: true
+      });
+      handleCancel2(proceed);
+      if (!proceed) {
+        outro8(pc9.dim("Update cancelled."));
+        return { blocks: blockResults, diffs };
+      }
+    }
+    const applied = [];
+    for (const blockName of selectedNames) {
+      const blockMeta = blockMap[blockName];
+      if (!blockMeta) continue;
+      const resolved = resolveBlockFiles(blockMeta, envKey);
+      if (!resolved) continue;
+      const targetFolder = path6.resolve(blocksRootAbsolute, blockName);
+      const downloadedTargets = /* @__PURE__ */ new Set();
+      try {
+        const fileBatches = [];
+        for (const fm of resolved.files) {
+          const res = await fetch(`${RAW_CDN_BASE3}/${fm.source}`);
+          if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
+          fileBatches.push({ fm, raw: await res.text() });
+          downloadedTargets.add(fm.target);
+        }
+        let contentHash = 0;
+        for (const { fm, raw } of fileBatches) {
+          const writtenFilePath = path6.join(targetFolder, fm.target);
+          const content = rewriteFileImports(
+            raw,
+            writtenFilePath,
+            blocksRootAbsolute,
+            aliasBase,
+            rewriteStrategy,
+            downloadedTargets
+          );
+          await fs7.mkdir(dirname5(writtenFilePath), { recursive: true });
+          await fs7.writeFile(writtenFilePath, content, "utf-8");
+          for (let i = 0; i < content.length; i++) {
+            contentHash = (contentHash << 5) - contentHash + content.charCodeAt(i) | 0;
+          }
+        }
+        const blockVersion = blockMeta.version ?? "0.0.0";
+        const installedRecord = {
+          name: blockName,
+          version: blockVersion,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          files: resolved.files.map((f) => f.target),
+          contentHash: contentHash.toString(16)
+        };
+        try {
+          const cfgRaw = await fs7.readFile(configPath, "utf-8");
+          const cfgData = JSON.parse(cfgRaw);
+          if (!Array.isArray(cfgData.installed)) cfgData.installed = [];
+          cfgData.installed = cfgData.installed.filter(
+            (b) => b.name !== blockName
+          );
+          cfgData.installed.push(installedRecord);
+          await fs7.writeFile(configPath, JSON.stringify(cfgData, null, 2), "utf-8");
+        } catch {
+        }
+        applied.push(blockName);
+        if (!json) log4.info(`  ${pc9.green("\u2714")} ${blockName} updated to v${blockVersion}`);
+      } catch (err) {
+        if (!json) log4.error(`  ${pc9.red("\u2716")} ${blockName}: ${String(err)}`);
+      }
+    }
+    const result2 = { blocks: blockResults, applied, diffs };
+    outputUpdateResult(json, result2);
+    return result2;
+  }
+  const result = { blocks: blockResults, diffs };
+  outputUpdateResult(json, result);
+  return result;
+}
+
 // src/index.ts
 var mcpInit = defineCommand({
   meta: {
@@ -1165,10 +2255,16 @@ var add = defineCommand({
       type: "boolean",
       default: false,
       description: "Output streaming machine-readable JSON payloads for automation systems"
+    },
+    multi: {
+      type: "boolean",
+      alias: "m",
+      default: false,
+      description: "Select and add multiple blocks at once via interactive multiselect"
     }
   },
   async run({ args }) {
-    await addCommand(args.block, { yes: args.yes, json: args.json });
+    await addCommand(args.block, { yes: args.yes, json: args.json, multi: args.multi });
   }
 });
 var detect = defineCommand({
@@ -1187,12 +2283,75 @@ var detect = defineCommand({
     await detectCommand({ json: args.json });
   }
 });
+var diff = defineCommand({
+  meta: {
+    name: "diff",
+    description: "Preview generated files for a block without writing to disk"
+  },
+  args: {
+    block: {
+      type: "positional",
+      required: true,
+      description: "Block name to preview"
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output diff results as JSON"
+    }
+  },
+  async run({ args }) {
+    await diffCommand(args.block, { json: args.json });
+  }
+});
+var doctor = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Detect configuration and project issues affecting Blockend"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output health check results as JSON"
+    }
+  },
+  async run({ args }) {
+    await doctorCommand({ json: args.json });
+  }
+});
+var update = defineCommand({
+  meta: {
+    name: "update",
+    description: "Compare installed blocks with newer available versions and show diffs"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output update status as JSON"
+    },
+    diff: {
+      type: "boolean",
+      default: true,
+      description: "Show git-diff style file comparison for blocks with updates"
+    },
+    apply: {
+      type: "boolean",
+      default: false,
+      description: "Select blocks to update (multiselect) and apply updates with import rewriting"
+    }
+  },
+  async run({ args }) {
+    await updateCommand({ json: args.json, diff: args.diff, apply: args.apply });
+  }
+});
 var main = defineCommand({
   meta: {
     name: "blockend",
     version: "0.1.0",
     description: "Blockend CLI - Core architectural blocks straight into your repository layout primitives"
   },
-  subCommands: { init, add, detect, list, mcp }
+  subCommands: { init, add, detect, list, diff, doctor, update, mcp }
 });
 runMain(main);