blockend-cli 1.3.1 → 1.4.1

package/dist/index.js

@@ -1,37 +1,395 @@
 #!/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 { exec } from "child_process";
+import { intro, outro, select, spinner, confirm, isCancel } from "@clack/prompts";
+import pc 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 outputError(json, message) {
+  if (json) {
+    process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
+  } else {
+    outro(pc.red(`\u2716 ${message}`));
+  }
+}
+function outputResult(json, result) {
+  if (json) {
+    process.stdout.write(JSON.stringify(result) + "\n");
+  } else {
+    if (result.success) {
+      outro(pc.cyan(`\u2728 ${result.message}`));
+    } else {
+      outro(pc.yellow(`\u2139 ${result.message}`));
+    }
+  }
+}
+function handleCancel(value) {
+  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 = join(dir, filename);
+    try {
+      await fs.access(checkPath);
+      return checkPath;
+    } catch {
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  }
+  return null;
+}
+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) {
+    outputError(json, "blockend.json not found. Run 'npx blockend init' first.");
+    return;
+  }
+  const rootDir = dirname(configPath);
+  let config;
+  try {
+    const configFile = await fs.readFile(configPath, "utf-8");
+    config = JSON.parse(configFile);
+  } catch (error) {
+    outputError(json, "Failed to parse blockend.json layout configuration.");
+    if (!json) console.error(pc.dim(String(error)));
+    return;
+  }
+  if (config.language !== "typescript") {
+    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 = 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();
+    if (!json) s.stop(pc.green("\u2714 Remote manifest synchronization complete."));
+  } catch (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 = {};
+  if (registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks)) {
+    blockMap = registry.blocks;
+  } else {
+    blockMap = registry;
+  }
+  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;
+      const hasAdapter = block.adapters?.[envKey] !== void 0;
+      const hasEnvironment = block.environments?.[envKey] !== void 0;
+      return hasAdapter || hasEnvironment;
+    }).map(([key, block]) => ({
+      value: key,
+      label: `${key} - ${pc.dim(block.description)}`
+    }));
+    if (availableOptions.length === 0) {
+      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 select({
+      message: "Which backend block would you like to inject?",
+      options: availableOptions
+    });
+    handleCancel(selectBlockPrompt);
+    targetBlock = selectBlockPrompt;
+  }
+  const blockMeta = blockMap[targetBlock];
+  if (!blockMeta) {
+    outputError(json, `Block "${targetBlock}" does not exist in the remote registry.`);
+    return;
+  }
+  const adapterContext = blockMeta.adapters?.[envKey] ?? blockMeta.environments?.[envKey];
+  if (!adapterContext) {
+    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) {
+    outputError(
+      json,
+      `No architecture storage layout variants found for block framework: ${envKey}`
+    );
+    return;
+  }
+  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 select({
+      message: "Which architectural storage variant do you want to back this block?",
+      options: variantKeys.map((vKey) => ({
+        value: vKey,
+        label: vKey.toUpperCase()
+      }))
+    });
+    handleCancel(selectVariantPrompt);
+    selectedVariant = selectVariantPrompt;
+  }
+  const variantMeta = adapterContext.variants[selectedVariant];
+  let physicalPath = config.paths.blocks;
+  if (physicalPath.startsWith("@")) {
+    physicalPath = "./src/blocks";
+  }
+  const targetFolder = path.resolve(rootDir, physicalPath, targetBlock);
+  const packageJsonPath = await findUp("package.json", rootDir);
+  if (!packageJsonPath) {
+    outputError(json, "Could not locate package.json in your current directory layout hierarchy.");
+    return;
+  }
+  const packageJsonDir = dirname(packageJsonPath);
+  let packageJson;
+  try {
+    const packageJsonContent = await fs.readFile(packageJsonPath, "utf-8");
+    packageJson = JSON.parse(packageJsonContent);
+  } catch (error) {
+    outputError(json, "Failed parsing file data configurations from target package.json location.");
+    if (!json) console.error(pc.dim(String(error)));
+    return;
+  }
+  const installedDeps = {
+    ...packageJson.dependencies ?? {},
+    ...packageJson.devDependencies ?? {}
+  };
+  const missingProdDeps = (adapterContext.dependencies ?? []).concat(variantMeta?.dependencies ?? []).filter((dep) => !(dep in installedDeps));
+  const missingDevDeps = (adapterContext.devDependencies ?? []).concat(variantMeta?.devDependencies ?? []).filter((dep) => !(dep in installedDeps));
+  const hasMissingDeps = missingProdDeps.length > 0 || missingDevDeps.length > 0;
+  if (hasMissingDeps) {
+    const allMissingNames = [...missingProdDeps, ...missingDevDeps];
+    if (!json) {
+      console.log(
+        pc.yellow(`
+\u26A0\uFE0F Missing required infrastructure packages: ${allMissingNames.join(", ")}`)
+      );
+    }
+    const shouldInstallPrompt = yes ? true : await confirm({
+      message: "Would you like the CLI to automatically install these dependencies?",
+      initialValue: true
+    });
+    if (!yes) handleCancel(shouldInstallPrompt);
+    if (shouldInstallPrompt) {
+      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) {
+          installTasks.push(
+            packageManager === "pnpm" ? `pnpm add ${missingProdDeps.join(" ")}` : `npm install ${missingProdDeps.join(" ")}`
+          );
+        }
+        if (missingDevDeps.length > 0) {
+          installTasks.push(
+            packageManager === "pnpm" ? `pnpm add -D ${missingDevDeps.join(" ")}` : `npm install --save-dev ${missingDevDeps.join(" ")}`
+          );
+        }
+        for (const installCmd of installTasks) {
+          if (!json) s.stop(pc.cyan(`Executing: ${installCmd}
+`));
+          await new Promise((resolve, reject) => {
+            const child = exec(installCmd, { cwd: packageJsonDir });
+            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}`))
+            );
+          });
+        }
+        if (!json) {
+          s.start(pc.green("\u2714 All dependencies synchronized successfully."));
+          s.stop();
+        }
+      } catch (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;
+      }
+    }
+  }
+  const filesToDownload = [];
+  if (blockMeta.baseFiles) {
+    filesToDownload.push(...blockMeta.baseFiles);
+  }
+  if (adapterContext.core) {
+    filesToDownload.push({
+      source: adapterContext.core,
+      target: path.basename(adapterContext.core, ".txt")
+    });
+  }
+  if (variantMeta && Array.isArray(variantMeta.files)) {
+    for (const fileEntry of variantMeta.files) {
+      if (typeof fileEntry === "string") {
+        filesToDownload.push({
+          source: fileEntry,
+          target: path.basename(fileEntry, ".txt")
+        });
+      } else {
+        filesToDownload.push(fileEntry);
+      }
+    }
+  }
+  let fileExistsConflict = false;
+  for (const fileMap of filesToDownload) {
+    const destinationPath = join(targetFolder, fileMap.target);
+    try {
+      await fs.access(destinationPath);
+      fileExistsConflict = true;
+      break;
+    } catch {
+    }
+  }
+  if (fileExistsConflict) {
+    const overwritePrompt = yes ? true : await confirm({
+      message: `\u26A0 Components in [${targetBlock}] already exist. Overwrite custom revisions?`,
+      initialValue: false
+    });
+    if (!yes) handleCancel(overwritePrompt);
+    if (!overwritePrompt) {
+      outputResult(json, {
+        success: false,
+        reason: "aborted",
+        message: "Local modifications preserved."
+      });
+      return;
+    }
+  }
+  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 = 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 join2 } from "path";
+import fs2 from "fs/promises";
 import { existsSync } from "fs";
-import { intro, outro, select, text, confirm, spinner, isCancel } from "@clack/prompts";
+import { intro as intro2, outro as outro2, select as select2, text, confirm as confirm2, spinner as spinner2, isCancel as isCancel2 } from "@clack/prompts";
 import { detectProject } from "@blockend/detector";
 
 // src/ui/theme.ts
-import pc from "picocolors";
+import pc2 from "picocolors";
 var theme = {
   brand: {
-    primary: pc.blue,
-    title: pc.bold,
-    logo: pc.white
+    primary: pc2.blue,
+    title: pc2.bold,
+    logo: pc2.white
   },
   text: {
-    normal: pc.white,
-    muted: pc.dim,
-    subtle: pc.gray
+    normal: pc2.white,
+    muted: pc2.dim,
+    subtle: pc2.gray
   },
   state: {
-    success: pc.green,
-    warning: pc.yellow,
-    error: pc.red,
-    info: pc.blue
+    success: pc2.green,
+    warning: pc2.yellow,
+    error: pc2.red,
+    info: pc2.blue
   },
   emphasis: {
-    strong: pc.bold,
-    dim: pc.dim
+    strong: pc2.bold,
+    dim: pc2.dim
   }
 };
 
@@ -46,372 +404,690 @@ var format = {
 };
 
 // src/commands/init.ts
-async function initCommand() {
+async function resolveTsConfigPaths(cwd) {
+  const possiblePaths = [join2(cwd, "tsconfig.json"), join2(cwd, "jsconfig.json")];
+  for (const configPath of possiblePaths) {
+    if (existsSync(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 = 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
+  const configPath = join2(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
 `);
-  intro(format.title("Blockend \xB7 Intelligent Backend Blocks Setup"));
+    intro2(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;
+    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 fs.unlink(configPath);
-      console.log(format.error("Existing config deleted"));
+      await fs2.unlink(configPath);
+      if (!json) console.log(format.error("Existing config deleted"));
     }
   }
-  const s = spinner();
-  s.start("Scanning project structure...");
+  const s = spinner2();
+  if (!json) s.start("Scanning project layout...");
   const context = await detectProject(cwd);
-  s.stop(format.success("Project structure detected"));
-  s.start("Analyzing framework signals...");
-  await new Promise((r) => setTimeout(r, 400));
-  s.stop(format.success(`Detected ${context.framework || "unknown"} environment`));
-  s.start("Resolving alias mappings...");
-  await new Promise((r) => setTimeout(r, 300));
-  s.stop(format.success("Import strategy mapped"));
-  console.log(
-    format.muted(
-      `System: ${context.framework || "unknown"} \xB7 ${context.language || "ts"} \xB7 aliases=${Object.keys(context.aliasMap || {}).length}`
-    )
-  );
-  const framework = await select({
-    message: "Confirm framework environment",
-    initialValue: context.framework || "express",
-    options: [
-      { value: "express", label: "Express.js" },
-      { value: "fastify", label: "Fastify" },
-      { value: "next", label: "Next.js (App Router)" },
-      { value: "hono", label: "Hono" }
-    ]
-  });
-  if (isCancel(framework)) {
-    outro(format.muted("Initialization cancelled."));
-    return;
+  const hasSrcDir = existsSync(join2(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 availableAliases = Object.keys(context.aliasMap || {});
-  const baseAliasToken = availableAliases.length > 0 ? availableAliases[0] : "@/";
-  const blockAliasInput = await text({
-    message: "Configure blocks import alias",
-    initialValue: `${baseAliasToken}blocks`,
-    placeholder: `${baseAliasToken}blocks`
-  });
-  if (isCancel(blockAliasInput)) {
-    outro(format.muted("Initialization cancelled."));
-    return;
+  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}`;
   }
-  const blockAlias = String(blockAliasInput);
-  const aliasPrefix = availableAliases.find((a) => blockAlias.startsWith(a)) || "";
-  const physicalPrefix = aliasPrefix ? context.aliasMap[aliasPrefix] : "./";
-  const resolvedSubDir = blockAlias.replace(aliasPrefix, "");
-  const assumedPhysicalDir = join(physicalPrefix, resolvedSubDir);
-  const relativeBlocksPath = path.relative(cwd, path.resolve(cwd, assumedPhysicalDir));
-  const normalizedPath = relativeBlocksPath.replace(/\\/g, "/");
-  const finalPath = normalizedPath.startsWith(".") ? normalizedPath : `./${normalizedPath}`;
   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);
+    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,
-    language: "typescript",
+    environment: framework || "express",
+    language: context.language || "typescript",
     includeRedis,
     aliases: {
-      blocks: blockAlias
+      blocks: finalBlockAlias
     },
     paths: {
       blocks: finalPath
     }
   };
-  const writeSpinner = spinner();
-  writeSpinner.start("Finalizing configuration...");
+  if (!json) s.start("Finalizing configuration...");
   try {
-    await fs.writeFile(configPath, JSON.stringify(configPayload, null, 2), "utf-8");
-    writeSpinner.stop(format.success("blockend.json ready"));
-    outro(format.title("Blockend initialized successfully. Run: npx blockend add <block>"));
+    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 {
-    writeSpinner.stop(format.error("Failed to write configuration"));
+    if (!json) {
+      s.stop(format.error("Failed to write configuration"));
+    } else {
+      outputInitError(json, "Failed to write architectural layout configuration map.");
+    }
   }
 }
 
-// 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."));
-    process.exit(0);
+// src/commands/detect.ts
+import { detectProject as detectProject2 } from "@blockend/detector";
+import { outro as outro3 } from "@clack/prompts";
+import pc3 from "picocolors";
+async function detectCommand(options = {}) {
+  const { json = false } = options;
+  try {
+    const context = await detectProject2(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);
   }
 }
-async function findUp(filename, startDir) {
+
+// src/commands/list.ts
+import { dirname as dirname2, join as join3 } 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 = join2(dir, filename);
+    const checkPath = join3(dir, filename);
     try {
-      await fs2.access(checkPath);
+      await fs3.access(checkPath);
       return checkPath;
     } catch {
-      const parent = dirname(dir);
+      const parent = dirname2(dir);
       if (parent === dir) break;
       dir = parent;
     }
   }
   return null;
 }
-async function addCommand(blockName) {
-  intro2(pc2.bgBlack(pc2.magenta(" Blockend Component Ingestion ")));
+async function listCommand(options = {}) {
+  const { json = false } = options;
   const cwd = process.cwd();
-  const configPath = await findUp("blockend.json", cwd);
+  const configPath = await findUp2("blockend.json", cwd);
   if (!configPath) {
-    outro2(pc2.red("\u2716 blockend.json not found. Run 'npx blockend init' first."));
+    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;
   }
-  const rootDir = dirname(configPath);
   let config;
   try {
-    const configFile = await fs2.readFile(configPath, "utf-8");
+    const configFile = await fs3.readFile(configPath, "utf-8");
     config = JSON.parse(configFile);
   } catch {
-    outro2(pc2.red("\u2716 Failed to parse blockend.json layout configuration."));
+    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;
   }
-  if (config.language !== "typescript") {
-    outro2(
-      pc2.yellow(
-        `
-\u2139 Blockend forces modern architectural standards.
-  To ensure strict type safety and absolute code ownership, the registry exclusively supports TypeScript.
-  Please migrate your project configuration to TypeScript to ingest blocks.`
-      )
-    );
-    return;
+  const envKey = String(config.environment);
+  const s = spinner3();
+  if (!json) {
+    s.start("Syncing registry metadata blocks...");
   }
-  const s = spinner2();
-  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}`);
+    const response = await fetch(MANIFEST_URL2);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
     registry = await response.json();
-    s.stop(pc2.green("\u2714 Remote manifest synchronization complete."));
+    if (!json) s.stop(pc4.green("\u2714 Synced available block registries."));
   } catch {
-    s.stop(pc2.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
-    return;
-  }
-  const envKey = String(config.environment);
-  let targetBlock = blockName;
-  if (!targetBlock) {
-    const availableOptions = Object.keys(registry).filter((key) => registry[key].environments[envKey] !== void 0).map((key) => ({
-      value: key,
-      label: `${key} - ${pc2.dim(registry[key].description)}`
-    }));
-    if (availableOptions.length === 0) {
-      outro2(
-        pc2.yellow(
-          `\u26A0 No backend blocks are currently available for your framework layer: [${envKey}].`
-        )
+    if (json) {
+      process.stdout.write(
+        JSON.stringify({ success: false, error: "Network sync failure." }) + "\n"
       );
-      return;
+    } else {
+      s.stop(pc4.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
     }
-    const selectBlockPrompt = await select2({
-      message: "Which backend block would you like to inject?",
-      options: availableOptions
-    });
-    handleCancel(selectBlockPrompt);
-    targetBlock = selectBlockPrompt;
-  }
-  const blockMeta = registry[targetBlock];
-  if (!blockMeta) {
-    outro2(pc2.red(`\u2716 Block "${targetBlock}" does not exist in the remote registry.`));
     return;
   }
-  const envConfig = blockMeta.environments[envKey];
-  if (!envConfig) {
-    outro2(
-      pc2.red(`\u2716 The block "${targetBlock}" does not support your environment layout: ${envKey}`)
+  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"
     );
-    return;
+  } 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();
+    }
   }
-  let selectedVariant;
-  let variantMeta = void 0;
-  if (envConfig.variants && Object.keys(envConfig.variants).length > 0) {
-    const variantKeys = Object.keys(envConfig.variants);
-    if (variantKeys.includes("redis") && config.redisEnabled) {
-      selectedVariant = "redis";
+}
+
+// src/commands/mcp.ts
+import path3, { join as join4 } 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 selectVariantPrompt = await select2({
-        message: "Which architectural storage variant do you want to back this block?",
-        options: variantKeys.map((vKey) => ({
-          value: vKey,
-          label: vKey.toUpperCase()
+      const selection = await select3({
+        message: "Select target AI client layout profile:",
+        options: Object.entries(CLIENT_MATRIX).map(([key, value]) => ({
+          value: key,
+          label: value.label
         }))
       });
-      handleCancel(selectVariantPrompt);
-      selectedVariant = selectVariantPrompt;
+      if (typeof selection === "symbol") return;
+      chosenClient = selection;
     }
-    variantMeta = envConfig.variants[selectedVariant];
   }
-  const packageJsonPath = await findUp("package.json", rootDir);
-  if (!packageJsonPath) {
-    outro2(pc2.red("\u2716 Could not locate package.json in your current directory layout hierarchy."));
+  const meta = CLIENT_MATRIX[chosenClient];
+  if (!meta) {
+    outro5(pc5.red(`\u2716 Unsupported client identifier profile: ${options.client}`));
     return;
   }
-  const packageJsonDir = dirname(packageJsonPath);
-  let packageJson;
+  const absoluteConfigTarget = join4(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 {
-    packageJson = JSON.parse(await fs2.readFile(packageJsonPath, "utf-8"));
+    await fs4.access(absoluteConfigTarget);
+    fileConflict = true;
   } catch {
-    outro2(pc2.red("\u2716 Failed parsing file data configurations from target package.json location."));
-    return;
   }
-  const installedDeps = {
-    ...packageJson.dependencies ?? {},
-    ...packageJson.devDependencies ?? {}
-  };
-  const allRequiredDeps = [...envConfig.dependencies ?? [], ...variantMeta?.dependencies ?? []];
-  const missingDeps = allRequiredDeps.filter((dep) => !(dep in installedDeps));
-  if (missingDeps.length > 0) {
-    console.log(
-      pc2.yellow(`
-\u26A0\uFE0F Missing required infrastructure packages: ${missingDeps.join(", ")}`)
-    );
-    const shouldInstallPrompt = await confirm2({
-      message: "Would you like the CLI to automatically install these dependencies?",
-      initialValue: true
+  if (fileConflict && !options.force && !options.yes) {
+    const shouldOverwrite = await confirm3({
+      message: `\u26A0 Local configuration at [${meta.relativePath}] already exists. Overwrite?`,
+      initialValue: false
     });
-    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}...`);
-      try {
-        const installCmd = packageManager === "pnpm" ? `pnpm add ${missingDeps.join(" ")}` : `npm install ${missingDeps.join(" ")}`;
-        s.stop(pc2.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.on("close", (code) => {
-            if (code === 0) resolve();
-            else reject(new Error(`Exit code ${code}`));
-          });
-        });
-        console.log("");
-        s.start(pc2.green("\u2714 Dependencies installed cleanly. Continuing components build..."));
-        s.stop();
-      } catch {
-        s.stop(pc2.red("\u2716 Automated dependency installation failed. Please run setup manually."));
-      }
+    if (!shouldOverwrite || typeof shouldOverwrite === "symbol") {
+      outro5(pc5.yellow("\u2139 Operations halted. Project layout revisions preserved."));
+      return;
     }
   }
-  s.start(`Downloading clean production template block [${targetBlock}]...`);
+  const s = spinner4();
+  s.start(`Writing localized project configurations inside ${pc5.dim(meta.relativePath)}...`);
   try {
-    const remoteFilesToDownload = [];
-    if (envConfig.core) {
-      remoteFilesToDownload.push(envConfig.core);
-    }
-    if (variantMeta && Array.isArray(variantMeta.files)) {
-      remoteFilesToDownload.push(...variantMeta.files);
-    }
-    let physicalPath = config.paths.blocks;
-    if (physicalPath.startsWith("@")) {
-      physicalPath = "./src/blocks";
-    }
-    let targetFolder = path2.resolve(rootDir, physicalPath);
-    if (variantMeta && selectedVariant) {
-      targetFolder = join2(targetFolder, targetBlock);
-    }
-    let fileExistsConflict = false;
-    for (const remoteFile of remoteFilesToDownload) {
-      const parsedFilename = path2.basename(remoteFile, ".txt");
-      const checkFileLocation = join2(targetFolder, parsedFilename);
-      try {
-        await fs2.access(checkFileLocation);
-        fileExistsConflict = true;
-        break;
-      } catch {
+    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 (fileExistsConflict) {
-      s.stop();
-      const overwritePrompt = await confirm2({
-        message: `\u26A0 Components in [${targetBlock}] already exist. Overwrite custom revisions?`,
-        initialValue: false
-      });
-      handleCancel(overwritePrompt);
-      if (!overwritePrompt) {
-        outro2(pc2.yellow("\u2139 Operation aborted safely. Local code modifications preserved."));
-        return;
+      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 };
       }
-      s.start(`Re-downloading template block files [${targetBlock}]...`);
+      await fs4.writeFile(absoluteConfigTarget, JSON.stringify(workingConfig, null, 2), "utf-8");
+    } else {
+      await fs4.writeFile(absoluteConfigTarget, generateToml(BLOCKEND_SERVER), "utf-8");
     }
-    await fs2.mkdir(targetFolder, { recursive: true });
-    for (const remoteFilePath of remoteFilesToDownload) {
-      const fileUrl = `${RAW_CDN_BASE}/${remoteFilePath}`;
-      const response = await fetch(fileUrl);
-      if (!response.ok) {
-        throw new Error(`Failed downloading file: ${remoteFilePath} (${response.statusText})`);
-      }
-      const rawCodeTemplate = await response.text();
-      const targetFilename = path2.basename(remoteFilePath, ".txt");
-      const localWriteLocation = join2(targetFolder, targetFilename);
-      await fs2.writeFile(localWriteLocation, rawCodeTemplate, "utf-8");
-    }
-    const cleanDisplayPath = variantMeta && selectedVariant ? `${physicalPath.replace(/\\/g, "/")}/${targetBlock}` : physicalPath.replace(/\\/g, "/");
-    s.stop(pc2.green("\u2714 Component isolation structures written smoothly."));
-    outro2(
-      pc2.cyan(
-        `\u2728 Source blocks written to ${cleanDisplayPath}/ layout. Code ownership transferred!`
-      )
+    s.stop(
+      pc5.green(`\u2714 Local workspace integration fully complete! File target: ${meta.relativePath}`)
     );
-    process.exit(0);
   } catch (error) {
-    s.stop(pc2.red("\u2716 Fatal crash occurred while downloading or transferring file layouts."));
-    console.error(error);
-    process.exit(1);
+    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);