blockend-cli 1.4.0 → 1.4.2

package/dist/index.js

@@ -1,229 +1,49 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command } from "commander";
+import { defineCommand, runMain } from "citty";
 
-// src/commands/init.ts
-import path, { join } from "path";
+// src/commands/add.ts
+import path, { join, dirname } from "path";
 import fs from "fs/promises";
-import { existsSync } from "fs";
-import { intro, outro, select, text, confirm, spinner, isCancel } from "@clack/prompts";
-import { detectProject } from "@blockend/detector";
-
-// src/ui/theme.ts
+import { exec } from "child_process";
+import { intro, outro, select, spinner, confirm, isCancel } from "@clack/prompts";
 import pc from "picocolors";
-var theme = {
-  brand: {
-    primary: pc.blue,
-    title: pc.bold,
-    logo: pc.white
-  },
-  text: {
-    normal: pc.white,
-    muted: pc.dim,
-    subtle: pc.gray
-  },
-  state: {
-    success: pc.green,
-    warning: pc.yellow,
-    error: pc.red,
-    info: pc.blue
-  },
-  emphasis: {
-    strong: pc.bold,
-    dim: pc.dim
-  }
-};
-
-// src/ui/format.ts
-var format = {
-  title: (text2) => theme.brand.primary(theme.brand.title(text2)),
-  success: (text2) => theme.state.success(`\u2714 ${text2}`),
-  error: (text2) => theme.state.error(`\u2716 ${text2}`),
-  warning: (text2) => theme.state.warning(text2),
-  muted: (text2) => theme.text.muted(text2),
-  info: (text2) => theme.state.info(text2)
-};
-
-// src/commands/init.ts
-async function resolveTsConfigPaths(cwd) {
-  const possiblePaths = [join(cwd, "tsconfig.json"), join(cwd, "jsconfig.json")];
-  for (const configPath of possiblePaths) {
-    if (existsSync(configPath)) {
-      try {
-        const rawContent = await fs.readFile(configPath, "utf-8");
-        const cleanJsonContent = rawContent.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
-        const parsed = JSON.parse(cleanJsonContent);
-        const baseUrl = parsed.compilerOptions?.baseUrl || ".";
-        const paths = parsed.compilerOptions?.paths || {};
-        return { baseUrl, paths };
-      } catch {
-      }
-    }
+var REPO_OWNER = "codewithnuh";
+var REPO_NAME = "blockend";
+var BRANCH = "master";
+var RAW_CDN_BASE = `https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/${BRANCH}`;
+var MANIFEST_URL = `${RAW_CDN_BASE}/registry/index.json`;
+function outputError(json, message) {
+  if (json) {
+    process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
+  } else {
+    outro(pc.red(`\u2716 ${message}`));
   }
-  return { baseUrl: ".", paths: {} };
 }
-async function initCommand() {
-  const cwd = process.cwd();
-  const configPath = join(cwd, "blockend.json");
-  console.log(`
-\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557         \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551        \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551        \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551
-\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551        \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551
-\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
-\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D
-`);
-  intro(theme.brand.primary(" Blockend \xB7 Intelligent Backend Blocks Setup "));
-  if (existsSync(configPath)) {
-    const action = await select({
-      message: "blockend.json already exists. What do you want to do?",
-      options: [
-        { value: "keep", label: "Keep existing config (cancel init)" },
-        { value: "overwrite", label: "Overwrite config" },
-        { value: "regenerate", label: "Delete and regenerate" }
-      ]
-    });
-    if (isCancel(action) || action === "keep") {
-      outro(format.muted("Initialization cancelled. Existing config preserved."));
-      return;
-    }
-    if (action === "regenerate") {
-      await fs.unlink(configPath);
-      console.log(format.error("Existing config deleted"));
-    }
-  }
-  const s = spinner();
-  s.start("Scanning project layout...");
-  const context = await detectProject(cwd);
-  const hasSrcDir = existsSync(join(cwd, "src"));
-  const tsConfig = await resolveTsConfigPaths(cwd);
-  s.stop(format.success("Project architecture scanned"));
-  let framework = context.framework;
-  if (framework) {
-    console.log(
-      `${format.success("\u2714")} Framework environment detected: ${theme.state.info(framework)}`
-    );
+function outputResult(json, result) {
+  if (json) {
+    process.stdout.write(JSON.stringify(result) + "\n");
   } else {
-    const frameworkSelect = await select({
-      message: "Framework could not be auto-detected. Select framework environment manually:",
-      options: [
-        { value: "express", label: "Express.js" },
-        { value: "fastify", label: "Fastify" },
-        { value: "next", label: "Next.js (App Router)" },
-        { value: "hono", label: "Hono" }
-      ]
-    });
-    if (isCancel(frameworkSelect)) {
-      outro(format.muted("Initialization cancelled."));
-      return;
-    }
-    framework = frameworkSelect;
-  }
-  const defaultDir = hasSrcDir ? "src/blocks" : "blocks";
-  const directoryPrompt = await text({
-    message: "Configure the targeted physical directory destination for blocks:",
-    placeholder: defaultDir,
-    initialValue: defaultDir,
-    validate(value) {
-      if (value?.trim().length === 0) return "Physical path location directory cannot be empty.";
-    }
-  });
-  if (isCancel(directoryPrompt)) {
-    outro(format.muted("Initialization cancelled."));
-    return;
-  }
-  const rawPhysicalInput = String(directoryPrompt).trim();
-  const relativeBlocksPath = path.relative(cwd, path.resolve(cwd, rawPhysicalInput));
-  let finalPath = relativeBlocksPath.replace(/\\/g, "/");
-  if (!finalPath.startsWith(".") && !finalPath.startsWith("/")) {
-    finalPath = `./${finalPath}`;
-  }
-  let finalBlockAlias = "@/blocks";
-  const configuredAliases = Object.keys(tsConfig.paths);
-  if (configuredAliases.length > 0) {
-    const matchedAliasKey = configuredAliases.find((alias) => {
-      const targets = tsConfig.paths[alias];
-      if (Array.isArray(targets) && targets.length > 0) {
-        const targetSubPath = targets[0].replace(/\*$/, "").replace(/\\/g, "/");
-        return finalPath.replace(/^\.\//, "").startsWith(targetSubPath);
-      }
-      return false;
-    });
-    if (matchedAliasKey) {
-      const cleanKey = matchedAliasKey.replace(/\*$/, "");
-      const targets = tsConfig.paths[matchedAliasKey];
-      const targetSubPath = targets[0].replace(/\*$/, "").replace(/\\/g, "/");
-      const relativeSuffix = finalPath.replace(/^\.\//, "").replace(targetSubPath, "");
-      finalBlockAlias = `${cleanKey}${relativeSuffix}`.replace(/\/$/, "");
+    if (result.success) {
+      outro(pc.cyan(`\u2728 ${result.message}`));
     } else {
-      const primaryAlias = configuredAliases.find((k) => k.startsWith("@")) || configuredAliases[0];
-      const inferredBaseAlias = primaryAlias.replace(/\*$/, "");
-      const folderSegmentName = path.basename(finalPath);
-      finalBlockAlias = `${inferredBaseAlias}${folderSegmentName}`;
-    }
-  } else {
-    const folderSegmentName = path.basename(finalPath);
-    finalBlockAlias = `@/${folderSegmentName}`;
-  }
-  let includeRedis = false;
-  if (context.hasRedis) {
-    const redisConfirm = await confirm({
-      message: "Redis detected. Enable Redis-backed block variants automatically?",
-      initialValue: true
-    });
-    if (!isCancel(redisConfirm)) {
-      includeRedis = Boolean(redisConfirm);
-    }
-  }
-  const configPayload = {
-    $schema: "https://blockend.dev/schema.json",
-    environment: framework || "express",
-    language: context.language || "typescript",
-    includeRedis,
-    aliases: {
-      blocks: finalBlockAlias
-    },
-    paths: {
-      blocks: finalPath
+      outro(pc.yellow(`\u2139 ${result.message}`));
     }
-  };
-  const writeSpinner = spinner();
-  writeSpinner.start("Finalizing configuration...");
-  try {
-    await fs.writeFile(configPath, JSON.stringify(configPayload, null, 2), "utf-8");
-    writeSpinner.stop(format.success("blockend.json ready"));
-    outro(
-      theme.state.success("\u2728 Blockend initialized successfully. Run: npx blockend add <block>")
-    );
-  } catch {
-    writeSpinner.stop(format.error("Failed to write configuration"));
   }
 }
-
-// src/commands/add.ts
-import path2, { join as join2, dirname } from "path";
-import fs2 from "fs/promises";
-import { exec } from "child_process";
-import { intro as intro2, outro as outro2, select as select2, spinner as spinner2, confirm as confirm2, isCancel as isCancel2 } from "@clack/prompts";
-import pc2 from "picocolors";
-var REPO_OWNER = "codewithnuh";
-var REPO_NAME = "blockend";
-var BRANCH = "master";
-var RAW_CDN_BASE = `https://raw.githubusercontent.com/${REPO_OWNER}/${REPO_NAME}/${BRANCH}`;
-var MANIFEST_URL = `${RAW_CDN_BASE}/registry/index.json`;
 function handleCancel(value) {
-  if (isCancel2(value)) {
-    outro2(pc2.yellow("\u26A0 Operation cancelled. Exiting Blockend CLI cleanly."));
+  if (isCancel(value)) {
+    outro(pc.yellow("\u26A0 Operation cancelled. Exiting Blockend CLI cleanly."));
     process.exit(0);
   }
 }
 async function findUp(filename, startDir) {
   let dir = startDir;
   while (true) {
-    const checkPath = join2(dir, filename);
+    const checkPath = join(dir, filename);
     try {
-      await fs2.access(checkPath);
+      await fs.access(checkPath);
       return checkPath;
     } catch {
       const parent = dirname(dir);
@@ -233,44 +53,60 @@ async function findUp(filename, startDir) {
   }
   return null;
 }
-async function addCommand(blockName) {
-  intro2(pc2.bgBlack(pc2.magenta(" Blockend Component Ingestion ")));
+async function addCommand(blockName, options = {}) {
+  const { yes = false, json = false } = options;
+  if (!json) {
+    intro(pc.bgBlack(pc.magenta(" Blockend Component Ingestion ")));
+  }
   const cwd = process.cwd();
   const configPath = await findUp("blockend.json", cwd);
   if (!configPath) {
-    outro2(pc2.red("\u2716 blockend.json not found. Run 'npx blockend init' first."));
+    outputError(json, "blockend.json not found. Run 'npx blockend init' first.");
     return;
   }
   const rootDir = dirname(configPath);
   let config;
   try {
-    const configFile = await fs2.readFile(configPath, "utf-8");
+    const configFile = await fs.readFile(configPath, "utf-8");
     config = JSON.parse(configFile);
   } catch (error) {
-    outro2(pc2.red("\u2716 Failed to parse blockend.json layout configuration."));
-    console.error(pc2.dim(String(error)));
+    outputError(json, "Failed to parse blockend.json layout configuration.");
+    if (!json) console.error(pc.dim(String(error)));
     return;
   }
   if (config.language !== "typescript") {
-    outro2(
-      pc2.yellow(
-        `
+    if (json) {
+      outputError(
+        json,
+        "Blockend forces modern architectural standards. Registry exclusively supports TypeScript."
+      );
+    } else {
+      outro(
+        pc.yellow(
+          `
 \u2139 Blockend forces modern architectural standards. Registry exclusively supports TypeScript.`
-      )
-    );
+        )
+      );
+    }
     return;
   }
-  const s = spinner2();
-  s.start("Connecting to remote Blockend Registry manifest...");
+  const s = spinner();
+  if (!json) {
+    s.start("Connecting to remote Blockend Registry manifest...");
+  }
   let registry;
   try {
     const response = await fetch(MANIFEST_URL);
     if (!response.ok) throw new Error(`HTTP Error Status: ${response.status}`);
     registry = await response.json();
-    s.stop(pc2.green("\u2714 Remote manifest synchronization complete."));
+    if (!json) s.stop(pc.green("\u2714 Remote manifest synchronization complete."));
   } catch (error) {
-    s.stop(pc2.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
-    console.error(pc2.dim(String(error)));
+    if (!json) {
+      s.stop(pc.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
+      console.error(pc.dim(String(error)));
+    } else {
+      outputError(json, "Failed to fetch the component registry from GitHub network paths.");
+    }
     return;
   }
   let blockMap = {};
@@ -281,6 +117,13 @@ async function addCommand(blockName) {
   }
   const envKey = String(config.environment);
   let targetBlock = blockName;
+  if (yes && !targetBlock) {
+    outputError(
+      json,
+      "Block name required when using --yes flag. Usage: blockend add <block> --yes"
+    );
+    return;
+  }
   if (!targetBlock) {
     const availableOptions = Object.entries(blockMap).filter(([_, block]) => {
       if (!block) return false;
@@ -289,17 +132,24 @@ async function addCommand(blockName) {
       return hasAdapter || hasEnvironment;
     }).map(([key, block]) => ({
       value: key,
-      label: `${key} - ${pc2.dim(block.description)}`
+      label: `${key} - ${pc.dim(block.description)}`
     }));
     if (availableOptions.length === 0) {
-      outro2(
-        pc2.yellow(
-          `\u26A0 No backend blocks are currently available for your framework layer: [${envKey}].`
-        )
-      );
+      if (json) {
+        outputError(
+          json,
+          `No backend blocks are currently available for your framework layer: [${envKey}].`
+        );
+      } else {
+        outro(
+          pc.yellow(
+            `\u26A0 No backend blocks are currently available for your framework layer: [${envKey}].`
+          )
+        );
+      }
       return;
     }
-    const selectBlockPrompt = await select2({
+    const selectBlockPrompt = await select({
       message: "Which backend block would you like to inject?",
       options: availableOptions
     });
@@ -308,28 +158,34 @@ async function addCommand(blockName) {
   }
   const blockMeta = blockMap[targetBlock];
   if (!blockMeta) {
-    outro2(pc2.red(`\u2716 Block "${targetBlock}" does not exist in the remote registry.`));
+    outputError(json, `Block "${targetBlock}" does not exist in the remote registry.`);
     return;
   }
   const adapterContext = blockMeta.adapters?.[envKey] ?? blockMeta.environments?.[envKey];
   if (!adapterContext) {
-    outro2(
-      pc2.red(`\u2716 The block "${targetBlock}" does not support your environment layout: ${envKey}`)
+    outputError(
+      json,
+      `The block "${targetBlock}" does not support your environment layout: ${envKey}`
     );
     return;
   }
   let selectedVariant;
   const variantKeys = Object.keys(adapterContext.variants || {});
   if (variantKeys.length === 0) {
-    outro2(pc2.red(`\u2716 No architecture storage layout variants found for block framework: ${envKey}`));
+    outputError(
+      json,
+      `No architecture storage layout variants found for block framework: ${envKey}`
+    );
     return;
   }
-  if (variantKeys.includes("redis") && config.redisEnabled) {
+  if (yes) {
+    selectedVariant = variantKeys.includes("memory") ? "memory" : variantKeys[0];
+  } else if (variantKeys.includes("redis") && config.redisEnabled) {
     selectedVariant = "redis";
   } else if (variantKeys.length === 1) {
     selectedVariant = variantKeys[0];
   } else {
-    const selectVariantPrompt = await select2({
+    const selectVariantPrompt = await select({
       message: "Which architectural storage variant do you want to back this block?",
       options: variantKeys.map((vKey) => ({
         value: vKey,
@@ -344,20 +200,20 @@ async function addCommand(blockName) {
   if (physicalPath.startsWith("@")) {
     physicalPath = "./src/blocks";
   }
-  const targetFolder = path2.resolve(rootDir, physicalPath, targetBlock);
+  const targetFolder = path.resolve(rootDir, physicalPath, targetBlock);
   const packageJsonPath = await findUp("package.json", rootDir);
   if (!packageJsonPath) {
-    outro2(pc2.red("\u2716 Could not locate package.json in your current directory layout hierarchy."));
+    outputError(json, "Could not locate package.json in your current directory layout hierarchy.");
     return;
   }
   const packageJsonDir = dirname(packageJsonPath);
   let packageJson;
   try {
-    const packageJsonContent = await fs2.readFile(packageJsonPath, "utf-8");
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
     packageJson = JSON.parse(packageJsonContent);
   } catch (error) {
-    outro2(pc2.red("\u2716 Failed parsing file data configurations from target package.json location."));
-    console.error(pc2.dim(String(error)));
+    outputError(json, "Failed parsing file data configurations from target package.json location.");
+    if (!json) console.error(pc.dim(String(error)));
     return;
   }
   const installedDeps = {
@@ -369,18 +225,20 @@ async function addCommand(blockName) {
   const hasMissingDeps = missingProdDeps.length > 0 || missingDevDeps.length > 0;
   if (hasMissingDeps) {
     const allMissingNames = [...missingProdDeps, ...missingDevDeps];
-    console.log(
-      pc2.yellow(`
+    if (!json) {
+      console.log(
+        pc.yellow(`
 \u26A0\uFE0F Missing required infrastructure packages: ${allMissingNames.join(", ")}`)
-    );
-    const shouldInstallPrompt = await confirm2({
+      );
+    }
+    const shouldInstallPrompt = yes ? true : await confirm({
       message: "Would you like the CLI to automatically install these dependencies?",
       initialValue: true
     });
-    handleCancel(shouldInstallPrompt);
+    if (!yes) handleCancel(shouldInstallPrompt);
     if (shouldInstallPrompt) {
-      const packageManager = await fs2.access(join2(packageJsonDir, "pnpm-lock.yaml")).then(() => "pnpm").catch(() => "npm");
-      s.start(`Preparing native workspace via ${packageManager}...`);
+      const packageManager = await fs.access(join(packageJsonDir, "pnpm-lock.yaml")).then(() => "pnpm").catch(() => "npm");
+      if (!json) s.start(`Preparing native workspace via ${packageManager}...`);
       try {
         const installTasks = [];
         if (missingProdDeps.length > 0) {
@@ -394,23 +252,33 @@ async function addCommand(blockName) {
           );
         }
         for (const installCmd of installTasks) {
-          s.stop(pc2.cyan(`Executing: ${installCmd}
+          if (!json) s.stop(pc.cyan(`Executing: ${installCmd}
 `));
           await new Promise((resolve, reject) => {
             const child = exec(installCmd, { cwd: packageJsonDir });
-            child.stdout?.on("data", (data) => process.stdout.write(pc2.dim(data)));
-            child.stderr?.on("data", (data) => process.stdout.write(pc2.dim(pc2.red(data))));
+            child.stdout?.on("data", (data) => {
+              if (!json) process.stdout.write(pc.dim(data));
+            });
+            child.stderr?.on("data", (data) => {
+              if (!json) process.stdout.write(pc.dim(pc.red(data)));
+            });
             child.on(
               "close",
               (code) => code === 0 ? resolve() : reject(new Error(`Exit code ${code}`))
             );
           });
         }
-        s.start(pc2.green("\u2714 All dependencies synchronized successfully."));
-        s.stop();
+        if (!json) {
+          s.start(pc.green("\u2714 All dependencies synchronized successfully."));
+          s.stop();
+        }
       } catch (error) {
-        s.stop(pc2.red("\u2716 Automated dependency installation failed. Please run setup manually."));
-        console.error(pc2.dim(String(error)));
+        if (!json) {
+          s.stop(pc.red("\u2716 Automated dependency installation failed. Please run setup manually."));
+          console.error(pc.dim(String(error)));
+        } else {
+          outputError(json, "Automated dependency installation failed.");
+        }
         return;
       }
     }
@@ -422,7 +290,7 @@ async function addCommand(blockName) {
   if (adapterContext.core) {
     filesToDownload.push({
       source: adapterContext.core,
-      target: path2.basename(adapterContext.core, ".txt")
+      target: path.basename(adapterContext.core, ".txt")
     });
   }
   if (variantMeta && Array.isArray(variantMeta.files)) {
@@ -430,7 +298,7 @@ async function addCommand(blockName) {
       if (typeof fileEntry === "string") {
         filesToDownload.push({
           source: fileEntry,
-          target: path2.basename(fileEntry, ".txt")
+          target: path.basename(fileEntry, ".txt")
         });
       } else {
         filesToDownload.push(fileEntry);
@@ -439,53 +307,892 @@ async function addCommand(blockName) {
   }
   let fileExistsConflict = false;
   for (const fileMap of filesToDownload) {
-    const destinationPath = join2(targetFolder, fileMap.target);
+    const destinationPath = join(targetFolder, fileMap.target);
     try {
-      await fs2.access(destinationPath);
+      await fs.access(destinationPath);
       fileExistsConflict = true;
       break;
     } catch {
     }
   }
   if (fileExistsConflict) {
-    const overwritePrompt = await confirm2({
+    const overwritePrompt = yes ? true : await confirm({
       message: `\u26A0 Components in [${targetBlock}] already exist. Overwrite custom revisions?`,
       initialValue: false
     });
-    handleCancel(overwritePrompt);
+    if (!yes) handleCancel(overwritePrompt);
     if (!overwritePrompt) {
-      outro2(pc2.yellow("\u2139 Operation aborted safely. Local code modifications preserved."));
+      outputResult(json, {
+        success: false,
+        reason: "aborted",
+        message: "Local modifications preserved."
+      });
       return;
     }
   }
-  s.start(`Downloading and building template adapter blocks [${targetBlock}]...`);
+  if (!json) {
+    s.start(`Downloading and building template adapter blocks [${targetBlock}]...`);
+  }
   try {
     for (const fileMap of filesToDownload) {
       const fileUrl = `${RAW_CDN_BASE}/${fileMap.source}`;
       const response = await fetch(fileUrl);
       if (!response.ok) throw new Error(`Download failed for: ${fileMap.source}`);
       const fileContent = await response.text();
-      const localWriteLocation = join2(targetFolder, fileMap.target);
-      await fs2.mkdir(dirname(localWriteLocation), { recursive: true });
-      await fs2.writeFile(localWriteLocation, fileContent, "utf-8");
-    }
-    s.stop(pc2.green("\u2714 Component isolation structures written smoothly."));
-    outro2(
-      pc2.cyan(
-        `\u2728 Source blocks written to ${physicalPath}/${targetBlock}/. Code ownership transferred!`
-      )
+      const localWriteLocation = join(targetFolder, fileMap.target);
+      await fs.mkdir(dirname(localWriteLocation), { recursive: true });
+      await fs.writeFile(localWriteLocation, fileContent, "utf-8");
+    }
+    if (!json) s.stop(pc.green("\u2714 Component isolation structures written smoothly."));
+    outputResult(json, {
+      success: true,
+      block: targetBlock,
+      filesWritten: filesToDownload.map((f) => join(targetFolder, f.target)),
+      dependenciesInstalled: [...missingProdDeps, ...missingDevDeps],
+      message: `Source blocks written to ${physicalPath}/${targetBlock}/. Code ownership transferred!`
+    });
+  } catch (error) {
+    if (!json) {
+      s.stop(pc.red("\u2716 Fatal error occurred while assembling file mappings."));
+      console.error(pc.dim(String(error)));
+    } else {
+      outputError(json, "Fatal error occurred while assembling file mappings.");
+    }
+  }
+}
+
+// src/commands/init.ts
+import path2, { join as join7 } from "path";
+import fs2 from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import { intro as intro2, outro as outro2, select as select2, text, confirm as confirm2, spinner as spinner2, isCancel as isCancel2 } from "@clack/prompts";
+
+// src/detectors/index.ts
+import { join as join6 } from "path";
+
+// src/detectors/readers/package.ts
+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 readFile(pkgPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    throw new Error(`No package.json found at ${pkgPath}. Run blockend from your project root.`);
+  }
+}
+
+// src/detectors/readers/tsconfig.ts
+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 readFile2(tsconfigPath, "utf-8");
+    const cleanLines = content.split(/\r?\n/).filter((line) => {
+      const trimmed = line.trim();
+      return !trimmed.startsWith("//") && !trimmed.startsWith("/*");
+    }).join("\n").replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(cleanLines);
+  } catch {
+    return null;
+  }
+}
+
+// src/detectors/readers/filesystem.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join4 } from "path";
+async function inferSrcDir(cwd) {
+  const candidates = ["src", "app", "lib"];
+  for (const dir of candidates) {
+    if (existsSync2(join4(cwd, dir))) {
+      return join4(cwd, dir);
+    }
+  }
+  return cwd;
+}
+
+// src/detectors/framework.ts
+function detectFramework(deps) {
+  if ("fastify" in deps) return "fastify";
+  if ("hono" in deps) return "hono";
+  if ("express" in deps) return "express";
+  if ("next" in deps) return "next";
+  return "none";
+}
+
+// src/detectors/runtime.ts
+function detectRuntime(deps) {
+  if ("@types/bun" in deps || "bun-types" in deps) return "bun";
+  return "node";
+}
+
+// src/detectors/package-manager.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join5 } from "path";
+function detectPackageManager(cwd) {
+  if (existsSync3(join5(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync3(join5(cwd, "bun.lockb"))) return "bun";
+  if (existsSync3(join5(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+
+// src/detectors/index.ts
+async function detectProject(cwd) {
+  const [pkg, tsConfig] = await Promise.all([readPackageJson(cwd), readTsConfig(cwd)]);
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies
+  };
+  const srcDir = await inferSrcDir(cwd);
+  return {
+    root: cwd,
+    language: tsConfig !== null ? "typescript" : "javascript",
+    runtime: detectRuntime(allDeps),
+    framework: detectFramework(allDeps),
+    packageManager: detectPackageManager(cwd),
+    hasRedis: "ioredis" in allDeps || "redis" in allDeps,
+    hasPrisma: "@prisma/client" in allDeps,
+    hasDrizzle: "drizzle-orm" in allDeps,
+    aliasMap: tsConfig?.compilerOptions?.paths ? flattenTsPaths(tsConfig.compilerOptions.paths) : {},
+    srcDir,
+    // Default blocks directory: srcDir/lib/blocks
+    blocksDir: join6(srcDir, "lib", "blocks")
+  };
+}
+function flattenTsPaths(paths) {
+  const result = {};
+  for (const [alias, targets] of Object.entries(paths)) {
+    if (targets[0]) {
+      result[alias.replace("/*", "/")] = targets[0].replace("/*", "/");
+    }
+  }
+  return result;
+}
+
+// src/ui/theme.ts
+import pc2 from "picocolors";
+var theme = {
+  brand: {
+    primary: pc2.blue,
+    title: pc2.bold,
+    logo: pc2.white
+  },
+  text: {
+    normal: pc2.white,
+    muted: pc2.dim,
+    subtle: pc2.gray
+  },
+  state: {
+    success: pc2.green,
+    warning: pc2.yellow,
+    error: pc2.red,
+    info: pc2.blue
+  },
+  emphasis: {
+    strong: pc2.bold,
+    dim: pc2.dim
+  }
+};
+
+// src/ui/format.ts
+var format = {
+  title: (text2) => theme.brand.primary(theme.brand.title(text2)),
+  success: (text2) => theme.state.success(`\u2714 ${text2}`),
+  error: (text2) => theme.state.error(`\u2716 ${text2}`),
+  warning: (text2) => theme.state.warning(text2),
+  muted: (text2) => theme.text.muted(text2),
+  info: (text2) => theme.state.info(text2)
+};
+
+// src/commands/init.ts
+async function resolveTsConfigPaths(cwd) {
+  const possiblePaths = [join7(cwd, "tsconfig.json"), join7(cwd, "jsconfig.json")];
+  for (const configPath of possiblePaths) {
+    if (existsSync4(configPath)) {
+      try {
+        const rawContent = await fs2.readFile(configPath, "utf-8");
+        const cleanJsonContent = rawContent.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
+        const parsed = JSON.parse(cleanJsonContent);
+        const baseUrl = parsed.compilerOptions?.baseUrl || ".";
+        const paths = parsed.compilerOptions?.paths || {};
+        return { baseUrl, paths };
+      } catch {
+      }
+    }
+  }
+  return { baseUrl: ".", paths: {} };
+}
+function outputInitError(json, message) {
+  if (json) {
+    process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
+  } else {
+    outro2(format.error(message));
+  }
+}
+function outputInitResult(json, result) {
+  if (json) {
+    process.stdout.write(JSON.stringify(result) + "\n");
+  } else {
+    outro2(theme.state.success(result.message));
+  }
+}
+async function initCommand(options = {}) {
+  const { yes = false, json = false } = options;
+  const cwd = process.cwd();
+  const configPath = join7(cwd, "blockend.json");
+  if (!json) {
+    console.log(`
+\u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557         \u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2557
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551         \u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551 \u2588\u2588\u2554\u255D\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551         \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2588\u2588\u2588\u2554\u255D \u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551         \u2588\u2588\u2551   \u2588\u2588\u2551\u2588\u2588\u2551     \u2588\u2588\u2554\u2550\u2588\u2588\u2557 \u2588\u2588\u2554\u2550\u2550\u255D  \u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551  \u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D  \u255A\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+    intro2(theme.brand.primary(" Blockend \xB7 Intelligent Backend Blocks Setup "));
+  }
+  if (existsSync4(configPath)) {
+    let action;
+    if (yes) {
+      action = "overwrite";
+    } else {
+      const actionPrompt = await select2({
+        message: "blockend.json already exists. What do you want to do?",
+        options: [
+          { value: "keep", label: "Keep existing config (cancel init)" },
+          { value: "overwrite", label: "Overwrite config" },
+          { value: "regenerate", label: "Delete and regenerate" }
+        ]
+      });
+      if (isCancel2(actionPrompt) || actionPrompt === "keep") {
+        if (json) {
+          outputInitResult(json, {
+            success: false,
+            message: "Initialization cancelled. Existing config preserved."
+          });
+        } else {
+          outro2(format.muted("Initialization cancelled. Existing config preserved."));
+        }
+        return;
+      }
+      action = actionPrompt;
+    }
+    if (action === "regenerate") {
+      await fs2.unlink(configPath);
+      if (!json) console.log(format.error("Existing config deleted"));
+    }
+  }
+  const s = spinner2();
+  if (!json) s.start("Scanning project layout...");
+  const context = await detectProject(cwd);
+  const hasSrcDir = existsSync4(join7(cwd, "src"));
+  const tsConfig = await resolveTsConfigPaths(cwd);
+  if (!json) s.stop(format.success("Project architecture scanned"));
+  let framework = context.framework;
+  if (!framework) {
+    if (yes) {
+      framework = "express";
+    } else {
+      const frameworkSelect = await select2({
+        message: "Framework could not be auto-detected. Select framework environment manually:",
+        options: [
+          { value: "express", label: "Express.js" },
+          { value: "fastify", label: "Fastify" },
+          { value: "next", label: "Next.js (App Router)" },
+          { value: "hono", label: "Hono" }
+        ]
+      });
+      if (isCancel2(frameworkSelect)) {
+        if (json) {
+          outputInitResult(json, { success: false, message: "Initialization cancelled." });
+        } else {
+          outro2(format.muted("Initialization cancelled."));
+        }
+        return;
+      }
+      framework = frameworkSelect;
+    }
+  } else if (!json) {
+    console.log(
+      `${format.success("\u2714")} Framework environment detected: ${theme.state.info(framework)}`
+    );
+  }
+  const defaultDir = hasSrcDir ? "src/blocks" : "blocks";
+  let rawPhysicalInput = defaultDir;
+  if (!yes) {
+    const directoryPrompt = await text({
+      message: "Configure the targeted physical directory destination for blocks:",
+      placeholder: defaultDir,
+      initialValue: defaultDir,
+      validate(value) {
+        if (value?.trim().length === 0) return "Physical path location directory cannot be empty.";
+      }
+    });
+    if (isCancel2(directoryPrompt)) {
+      outro2(format.muted("Initialization cancelled."));
+      return;
+    }
+    rawPhysicalInput = String(directoryPrompt).trim();
+  }
+  const relativeBlocksPath = path2.relative(cwd, path2.resolve(cwd, rawPhysicalInput));
+  let finalPath = relativeBlocksPath.replace(/\\/g, "/");
+  if (!finalPath.startsWith(".") && !finalPath.startsWith("/")) {
+    finalPath = `./${finalPath}`;
+  }
+  let finalBlockAlias = "@/blocks";
+  const configuredAliases = Object.keys(tsConfig.paths);
+  if (configuredAliases.length > 0) {
+    const matchedAliasKey = configuredAliases.find((alias) => {
+      const targets = tsConfig.paths[alias];
+      if (Array.isArray(targets) && targets.length > 0) {
+        const targetSubPath = targets[0].replace(/\*$/, "").replace(/\\/g, "/");
+        return finalPath.replace(/^\.\//, "").startsWith(targetSubPath);
+      }
+      return false;
+    });
+    if (matchedAliasKey) {
+      const cleanKey = matchedAliasKey.replace(/\*$/, "");
+      const targets = tsConfig.paths[matchedAliasKey];
+      const targetSubPath = targets[0].replace(/\*$/, "").replace(/\\/g, "/");
+      const relativeSuffix = finalPath.replace(/^\.\//, "").replace(targetSubPath, "");
+      finalBlockAlias = `${cleanKey}${relativeSuffix}`.replace(/\/$/, "");
+    } else {
+      const primaryAlias = configuredAliases.find((k) => k.startsWith("@")) || configuredAliases[0];
+      const inferredBaseAlias = primaryAlias.replace(/\*$/, "");
+      const folderSegmentName = path2.basename(finalPath);
+      finalBlockAlias = `${inferredBaseAlias}${folderSegmentName}`;
+    }
+  } else {
+    const folderSegmentName = path2.basename(finalPath);
+    finalBlockAlias = `@/${folderSegmentName}`;
+  }
+  let includeRedis = false;
+  if (context.hasRedis) {
+    if (yes) {
+      includeRedis = true;
+    } else {
+      const redisConfirm = await confirm2({
+        message: "Redis detected. Enable Redis-backed block variants automatically?",
+        initialValue: true
+      });
+      if (!isCancel2(redisConfirm)) {
+        includeRedis = Boolean(redisConfirm);
+      }
+    }
+  }
+  const configPayload = {
+    $schema: "https://blockend.dev/schema.json",
+    environment: framework || "express",
+    language: context.language || "typescript",
+    includeRedis,
+    aliases: {
+      blocks: finalBlockAlias
+    },
+    paths: {
+      blocks: finalPath
+    }
+  };
+  if (!json) s.start("Finalizing configuration...");
+  try {
+    await fs2.writeFile(configPath, JSON.stringify(configPayload, null, 2), "utf-8");
+    if (!json) s.stop(format.success("blockend.json ready"));
+    outputInitResult(json, {
+      success: true,
+      message: "\u2728 Blockend initialized successfully. Run: npx blockend add <block>",
+      config: configPayload
+    });
+  } catch {
+    if (!json) {
+      s.stop(format.error("Failed to write configuration"));
+    } else {
+      outputInitError(json, "Failed to write architectural layout configuration map.");
+    }
+  }
+}
+
+// src/commands/detect.ts
+import { outro as outro3 } from "@clack/prompts";
+import pc3 from "picocolors";
+async function detectCommand(options = {}) {
+  const { json = false } = options;
+  try {
+    const context = await detectProject(process.cwd());
+    if (json) {
+      process.stdout.write(JSON.stringify(context, null, 2) + "\n");
+      return;
+    }
+    console.log();
+    console.log(pc3.bold("  Detected project configuration:"));
+    console.log();
+    console.log(`  Framework:        ${pc3.cyan(context.framework)}`);
+    console.log(`  Language:         ${pc3.cyan(context.language)}`);
+    console.log(`  Package manager:  ${pc3.cyan(context.packageManager)}`);
+    console.log(`  Source dir:       ${pc3.dim(context.srcDir)}`);
+    console.log(
+      `  Redis:            ${context.hasRedis ? pc3.green("detected") : pc3.dim("not found")}`
+    );
+    console.log(
+      `  Prisma:           ${context.hasPrisma ? pc3.green("detected") : pc3.dim("not found")}`
+    );
+    console.log(
+      `  Drizzle:          ${context.hasDrizzle ? pc3.green("detected") : pc3.dim("not found")}`
+    );
+    console.log();
+  } catch (error) {
+    if (json) {
+      process.stdout.write(JSON.stringify({ success: false, error: String(error) }) + "\n");
+    } else {
+      outro3(pc3.red(`\u2716 Detection failed: ${String(error)}`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/list.ts
+import { dirname as dirname2, join as join8 } from "path";
+import fs3 from "fs/promises";
+import pc4 from "picocolors";
+import { outro as outro4, spinner as spinner3 } from "@clack/prompts";
+var REPO_OWNER2 = "codewithnuh";
+var REPO_NAME2 = "blockend";
+var BRANCH2 = "master";
+var MANIFEST_URL2 = `https://raw.githubusercontent.com/${REPO_OWNER2}/${REPO_NAME2}/${BRANCH2}/registry/index.json`;
+async function findUp2(filename, startDir) {
+  let dir = startDir;
+  while (true) {
+    const checkPath = join8(dir, filename);
+    try {
+      await fs3.access(checkPath);
+      return checkPath;
+    } catch {
+      const parent = dirname2(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+async function listCommand(options = {}) {
+  const { json = false } = options;
+  const cwd = process.cwd();
+  const configPath = await findUp2("blockend.json", cwd);
+  if (!configPath) {
+    if (json) {
+      process.stdout.write(
+        JSON.stringify({ success: false, error: "blockend.json not found." }) + "\n"
+      );
+    } else {
+      outro4(pc4.red("\u2716 blockend.json not found. Run 'npx blockend init' first."));
+    }
+    return;
+  }
+  let config;
+  try {
+    const configFile = await fs3.readFile(configPath, "utf-8");
+    config = JSON.parse(configFile);
+  } catch {
+    if (json) {
+      process.stdout.write(
+        JSON.stringify({ success: false, error: "Failed to parse configuration matrix." }) + "\n"
+      );
+    } else {
+      outro4(pc4.red("\u2716 Failed to parse blockend.json layout configuration."));
+    }
+    return;
+  }
+  const envKey = String(config.environment);
+  const s = spinner3();
+  if (!json) {
+    s.start("Syncing registry metadata blocks...");
+  }
+  let registry;
+  try {
+    const response = await fetch(MANIFEST_URL2);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    registry = await response.json();
+    if (!json) s.stop(pc4.green("\u2714 Synced available block registries."));
+  } catch {
+    if (json) {
+      process.stdout.write(
+        JSON.stringify({ success: false, error: "Network sync failure." }) + "\n"
+      );
+    } else {
+      s.stop(pc4.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
+    }
+    return;
+  }
+  let blockMap = {};
+  if (registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks)) {
+    blockMap = registry.blocks;
+  } else {
+    blockMap = registry;
+  }
+  const blocksForEnv = Object.entries(blockMap).filter(([_, block]) => {
+    if (!block) return false;
+    const hasAdapter = block.adapters?.[envKey] !== void 0;
+    const hasEnvironment = block.environments?.[envKey] !== void 0;
+    return hasAdapter || hasEnvironment;
+  }).map(([key, block]) => {
+    const context = block.adapters?.[envKey] ?? block.environments?.[envKey];
+    return {
+      name: key,
+      description: block.description,
+      variants: Object.keys(context?.variants || {})
+    };
+  });
+  if (json) {
+    process.stdout.write(
+      JSON.stringify({ success: true, environment: envKey, blocks: blocksForEnv }) + "\n"
+    );
+  } else {
+    console.log(`
+Available backend blocks for ${pc4.magenta(envKey)}:`);
+    if (blocksForEnv.length === 0) {
+      console.log(pc4.dim("  No blocks found for this framework."));
+    } else {
+      blocksForEnv.forEach((b) => {
+        console.log(`
+  ${pc4.cyan(b.name)}`);
+        console.log(`    ${pc4.dim(b.description)}`);
+        console.log(`    Storage Variants: ${b.variants.map((v) => pc4.yellow(v)).join(", ")}`);
+      });
+      console.log();
+    }
+  }
+}
+
+// src/commands/mcp.ts
+import path3, { join as join9 } from "path";
+import fs4 from "fs/promises";
+import pc5 from "picocolors";
+import { outro as outro5, spinner as spinner4, select as select3, confirm as confirm3 } from "@clack/prompts";
+var CLIENT_MATRIX = {
+  claude: {
+    label: "Claude Code",
+    relativePath: ".mcp.json",
+    format: "json"
+  },
+  codex: {
+    label: "Codex CLI",
+    relativePath: ".codex/config.toml",
+    format: "toml"
+  },
+  cursor: {
+    label: "Cursor",
+    relativePath: ".cursor/mcp.json",
+    format: "json"
+  },
+  vscode: {
+    label: "VS Code",
+    relativePath: ".vscode/settings.json",
+    format: "json",
+    isCustomSchema: true
+  },
+  windsurf: {
+    label: "Windsurf",
+    relativePath: ".windsurf/mcp.json",
+    format: "json"
+  }
+};
+var BLOCKEND_SERVER = {
+  command: "npx",
+  args: ["-y", "blockend-cli", "mcp"]
+};
+function generateToml(server) {
+  const args = server.args.map((arg) => `"${arg}"`).join(", ");
+  return `
+[mcp_servers.blockend]
+command = "${server.command}"
+args = [${args}]
+`.trimStart();
+}
+async function mcpStartCommand() {
+  const { McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+  const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
+  const { z } = await import("zod");
+  const { execa } = await import("execa");
+  const server = new McpServer({
+    name: "blockend",
+    version: "0.1.0",
+    description: "Blockend MCP server \u2014 install production-ready backend blocks into any project"
+  });
+  async function safeExec(command, args, options) {
+    try {
+      const { stdout } = await execa(command, args, options);
+      return { text: String(stdout), isError: false };
+    } catch (error) {
+      const err = error;
+      const rawError = err.stderr || err.stdout || err.message || "Unknown execution error";
+      return { text: `Error executing command: ${String(rawError)}`, isError: true };
+    }
+  }
+  server.tool(
+    "list_blocks",
+    "Lists all available Blockend blocks with names, descriptions, and tags",
+    {},
+    async () => {
+      const result = await safeExec("npx", ["--no-install", "blockend", "list", "--json"]);
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  server.tool(
+    "add_block",
+    "Installs a Blockend block into a project.",
+    {
+      blockName: z.string().describe("Block name e.g. rate-limit, error-handler, logger"),
+      projectPath: z.string().describe("Absolute path to the project root where blockend should install")
+    },
+    async ({ blockName, projectPath }) => {
+      const result = await safeExec(
+        "npx",
+        ["--no-install", "blockend", "add", blockName, "--yes", "--json"],
+        { cwd: projectPath }
+      );
+      return { content: [{ type: "text", text: result.text }], isError: result.isError };
+    }
+  );
+  server.tool(
+    "detect_project",
+    "Analyzes a project context.",
+    {
+      projectPath: z.string().describe("Absolute path to the project root")
+    },
+    async ({ projectPath }) => {
+      const result = await safeExec("npx", ["--no-install", "blockend", "detect", "--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];
+  if (!meta) {
+    outro5(pc5.red(`\u2716 Unsupported client identifier profile: ${options.client}`));
+    return;
+  }
+  const absoluteConfigTarget = join9(cwd, meta.relativePath);
+  if (options.dryRun) {
+    console.log(
+      pc5.cyan(`
+\u2139 Dry-run mode active. Intended path location: ${pc5.dim(meta.relativePath)}`)
+    );
+    if (meta.format === "json") {
+      const jsonConfig = meta.isCustomSchema ? { "mcp.mcpServers": { blockend: BLOCKEND_SERVER } } : { mcpServers: { blockend: BLOCKEND_SERVER } };
+      console.log(pc5.gray(JSON.stringify(jsonConfig, null, 2)));
+    } else {
+      console.log(pc5.gray(generateToml(BLOCKEND_SERVER)));
+    }
+    outro5(pc5.green("\u2714 Dry run evaluation complete."));
+    return;
+  }
+  let fileConflict = false;
+  try {
+    await fs4.access(absoluteConfigTarget);
+    fileConflict = true;
+  } catch {
+  }
+  if (fileConflict && !options.force && !options.yes) {
+    const shouldOverwrite = await confirm3({
+      message: `\u26A0 Local configuration at [${meta.relativePath}] already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (!shouldOverwrite || typeof shouldOverwrite === "symbol") {
+      outro5(pc5.yellow("\u2139 Operations halted. Project layout revisions preserved."));
+      return;
+    }
+  }
+  const s = spinner4();
+  s.start(`Writing localized project configurations inside ${pc5.dim(meta.relativePath)}...`);
+  try {
+    await fs4.mkdir(path3.dirname(absoluteConfigTarget), { recursive: true });
+    if (meta.format === "json") {
+      let workingConfig = {};
+      if (fileConflict) {
+        try {
+          const rawContent = await fs4.readFile(absoluteConfigTarget, "utf-8");
+          workingConfig = JSON.parse(rawContent);
+        } catch {
+          workingConfig = {};
+        }
+      }
+      if (meta.isCustomSchema) {
+        const existingServers = workingConfig["mcp.mcpServers"] || {};
+        workingConfig["mcp.mcpServers"] = { ...existingServers, blockend: BLOCKEND_SERVER };
+      } else {
+        const existingServers = workingConfig.mcpServers || {};
+        workingConfig.mcpServers = { ...existingServers, blockend: BLOCKEND_SERVER };
+      }
+      await fs4.writeFile(absoluteConfigTarget, JSON.stringify(workingConfig, null, 2), "utf-8");
+    } else {
+      await fs4.writeFile(absoluteConfigTarget, generateToml(BLOCKEND_SERVER), "utf-8");
+    }
+    s.stop(
+      pc5.green(`\u2714 Local workspace integration fully complete! File target: ${meta.relativePath}`)
     );
   } catch (error) {
-    s.stop(pc2.red("\u2716 Fatal error occurred while assembling file mappings."));
-    console.error(pc2.dim(String(error)));
+    s.stop(pc5.red("\u2716 Fatal crash reading or creating local configuration maps."));
+    console.error(pc5.dim(String(error)));
   }
 }
 
 // src/index.ts
-var program = new Command();
-program.name("blockend").description("Zero-dependency production backend blocks CLI").version("0.1.0");
-program.command("init").description("Initialize blockend configuration in your project").action(async () => await initCommand());
-program.command("add [block]").description("Inject unstyled, clean backend blocks directly into code paths").action(async (block) => {
-  await addCommand(block);
+var mcpInit = defineCommand({
+  meta: {
+    name: "init",
+    description: "Generate appropriate project-local MCP infrastructure configurations"
+  },
+  args: {
+    client: {
+      type: "string",
+      description: "Target specific integration client profiles: claude | codex | cursor | vscode | windsurf"
+    },
+    force: {
+      type: "boolean",
+      default: false,
+      description: "Force override existing asset layouts"
+    },
+    "dry-run": {
+      type: "boolean",
+      default: false,
+      description: "Output planned workspace updates without disk mutation logs"
+    },
+    yes: { type: "boolean", default: false, description: "Bypass verification prompt iterations" }
+  },
+  async run({ args }) {
+    await mcpInitCommand({
+      client: args.client,
+      force: args.force,
+      dryRun: args["dry-run"],
+      yes: args.yes
+    });
+  }
+});
+var mcp = defineCommand({
+  meta: {
+    name: "mcp",
+    description: "Connect to context protocol channels or configure localized project setups"
+  },
+  subCommands: {
+    init: mcpInit
+  },
+  async run({ rawArgs }) {
+    if (rawArgs.length === 0) {
+      await mcpStartCommand();
+    }
+  }
+});
+var init = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize Blockend configuration profile (blockend.json)"
+  },
+  args: {
+    yes: {
+      type: "boolean",
+      alias: "y",
+      default: false,
+      description: "Skip initialization questions and auto-enforce layout defaults"
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output machine-readable configuration write states"
+    }
+  },
+  async run({ args }) {
+    await initCommand({ yes: args.yes, json: args.json });
+  }
+});
+var list = defineCommand({
+  meta: {
+    name: "list",
+    description: "List available component blocks matching local project runtime environment context"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output machine-readable blocks configuration array stream"
+    }
+  },
+  async run({ args }) {
+    await listCommand({ json: args.json });
+  }
+});
+var add = defineCommand({
+  meta: {
+    name: "add",
+    description: "Inject a production-grade component block straight into your codebase"
+  },
+  args: {
+    block: {
+      type: "positional",
+      required: false,
+      description: "Target block key name from the remote repository registry"
+    },
+    yes: {
+      type: "boolean",
+      alias: "y",
+      default: false,
+      description: "Skip structural modification confirmations and force dependency downloads"
+    },
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output streaming machine-readable JSON payloads for automation systems"
+    }
+  },
+  async run({ args }) {
+    await addCommand(args.block, { yes: args.yes, json: args.json });
+  }
+});
+var detect = defineCommand({
+  meta: {
+    name: "detect",
+    description: "Scan runtime directory frameworks, engines, and workspaces architectures"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      default: false,
+      description: "Output full detected project workspace context delta maps directly as JSON"
+    }
+  },
+  async run({ args }) {
+    await detectCommand({ json: args.json });
+  }
+});
+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 }
 });
-program.parse(process.argv);
+runMain(main);