blockend-cli 1.4.2 → 1.4.4

package/dist/index.js

@@ -7,18 +7,34 @@ import { defineCommand, runMain } from "citty";
 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 { intro, outro, select, spinner, confirm, isCancel, log } 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 rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase) {
+  if (!aliasBase || aliasBase.startsWith(".")) {
+    return fileContent;
+  }
+  const importRegex = /((?:from|import)\s*)(['"`])(\.\.?\/[^'"` \n\r]+)(['"`])/g;
+  const fileDir = dirname(writtenFilePath);
+  return fileContent.replace(importRegex, (match, keyword, openQuote, relativePath, closeQuote) => {
+    const absoluteTarget = path.resolve(fileDir, relativePath);
+    const fromBlocksRoot = path.relative(blocksRoot, absoluteTarget).replace(/\\/g, "/");
+    if (fromBlocksRoot.startsWith("..")) {
+      return match;
+    }
+    const aliased = `${aliasBase}/${fromBlocksRoot}`.replace(/\/+/g, "/");
+    return `${keyword}${openQuote}${aliased}${closeQuote}`;
+  });
+}
 function outputError(json, message) {
   if (json) {
     process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
   } else {
-    outro(pc.red(`\u2716 ${message}`));
+    log.error(message);
   }
 }
 function outputResult(json, result) {
@@ -26,7 +42,7 @@ function outputResult(json, result) {
     process.stdout.write(JSON.stringify(result) + "\n");
   } else {
     if (result.success) {
-      outro(pc.cyan(`\u2728 ${result.message}`));
+      outro(pc.green(`\u2728 ${result.message}`));
     } else {
       outro(pc.yellow(`\u2139 ${result.message}`));
     }
@@ -34,17 +50,17 @@ function outputResult(json, result) {
 }
 function handleCancel(value) {
   if (isCancel(value)) {
-    outro(pc.yellow("\u26A0 Operation cancelled. Exiting Blockend CLI cleanly."));
+    outro(pc.dim("Operation cancelled."));
     process.exit(0);
   }
 }
 async function findUp(filename, startDir) {
   let dir = startDir;
   while (true) {
-    const checkPath = join(dir, filename);
+    const candidate = join(dir, filename);
     try {
-      await fs.access(checkPath);
-      return checkPath;
+      await fs.access(candidate);
+      return candidate;
     } catch {
       const parent = dirname(dir);
       if (parent === dir) break;
@@ -56,7 +72,8 @@ async function findUp(filename, startDir) {
 async function addCommand(blockName, options = {}) {
   const { yes = false, json = false } = options;
   if (!json) {
-    intro(pc.bgBlack(pc.magenta(" Blockend Component Ingestion ")));
+    console.log("");
+    intro(`${pc.bgCyan(pc.black(" blockend "))} ${pc.dim("add")}`);
   }
   const cwd = process.cwd();
   const configPath = await findUp("blockend.json", cwd);
@@ -67,296 +84,242 @@ async function addCommand(blockName, options = {}) {
   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)));
+    config = JSON.parse(await fs.readFile(configPath, "utf-8"));
+  } catch (err) {
+    outputError(json, "Failed to parse blockend.json.");
+    if (!json) log.error(pc.dim(String(err)));
     return;
   }
   if (config.language !== "typescript") {
-    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.`
-        )
-      );
-    }
+    outputError(json, "Blockend currently only supports TypeScript projects.");
+    if (!json) outro(pc.dim("Exiting."));
     return;
   }
+  const physicalBlocksPath = config.paths.blocks;
+  const blocksRootAbsolute = path.resolve(rootDir, physicalBlocksPath);
+  const aliasBase = config.aliases.blocks;
+  const envKey = config.environment;
   const s = spinner();
-  if (!json) {
-    s.start("Connecting to remote Blockend Registry manifest...");
-  }
+  if (!json) s.start("Fetching registry...");
   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) {
+    const res = await fetch(MANIFEST_URL);
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    registry = await res.json();
+    if (!json) s.stop("Registry synced.");
+  } catch (err) {
     if (!json) {
-      s.stop(pc.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
-      console.error(pc.dim(String(error)));
+      s.stop("Failed to fetch registry.");
+      log.error(pc.dim(String(err)));
     } else {
-      outputError(json, "Failed to fetch the component registry from GitHub network paths.");
+      outputError(json, "Failed to fetch the component registry from GitHub.");
     }
     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"
-    );
+  const blockMap = registry.blocks && typeof registry.blocks === "object" && !Array.isArray(registry.blocks) ? registry.blocks : registry;
+  if (yes && !blockName) {
+    outputError(json, "Block name required with --yes. Usage: blockend add <block> --yes");
     return;
   }
+  let targetBlock = blockName;
   if (!targetBlock) {
-    const availableOptions = Object.entries(blockMap).filter(([_, block]) => {
+    const available = 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 block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
+    });
+    if (available.length === 0) {
+      const msg = `No blocks available for environment: ${envKey}`;
+      outputError(json, msg);
+      if (!json) outro(pc.dim("Exiting."));
       return;
     }
-    const selectBlockPrompt = await select({
-      message: "Which backend block would you like to inject?",
-      options: availableOptions
+    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
+    const selectPrompt = await select({
+      message: "Which block would you like to add?",
+      options: available.map(([key, block], i) => ({
+        value: key,
+        label: `${pc.dim(`${i + 1}.`)} ${pc.bold(pc.cyan(key.padEnd(maxKeyLen + 4)))}${pc.dim(
+          block.description.length > 60 ? `${block.description.slice(0, 60)}...` : block.description
+        )}`
+      }))
     });
-    handleCancel(selectBlockPrompt);
-    targetBlock = selectBlockPrompt;
+    handleCancel(selectPrompt);
+    targetBlock = selectPrompt;
   }
   const blockMeta = blockMap[targetBlock];
   if (!blockMeta) {
-    outputError(json, `Block "${targetBlock}" does not exist in the remote registry.`);
+    outputError(json, `Block "${targetBlock}" does not exist in the registry.`);
     return;
   }
   const adapterContext = blockMeta.adapters?.[envKey] ?? blockMeta.environments?.[envKey];
   if (!adapterContext) {
-    outputError(
-      json,
-      `The block "${targetBlock}" does not support your environment layout: ${envKey}`
-    );
+    outputError(json, `Block "${targetBlock}" does not support environment: ${envKey}`);
     return;
   }
-  let selectedVariant;
-  const variantKeys = Object.keys(adapterContext.variants || {});
+  const variantKeys = Object.keys(adapterContext.variants ?? {});
   if (variantKeys.length === 0) {
-    outputError(
-      json,
-      `No architecture storage layout variants found for block framework: ${envKey}`
-    );
+    outputError(json, `No variants found for block "${targetBlock}" in environment "${envKey}"`);
     return;
   }
+  let selectedVariant;
   if (yes) {
     selectedVariant = variantKeys.includes("memory") ? "memory" : variantKeys[0];
-  } else if (variantKeys.includes("redis") && config.redisEnabled) {
+  } else if (variantKeys.includes("redis") && (config.redisEnabled || config.includeRedis)) {
     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()
-      }))
+    const variantPrompt = await select({
+      message: "Select a storage variant:",
+      options: variantKeys.map((v) => ({ value: v, label: v.toUpperCase() }))
     });
-    handleCancel(selectVariantPrompt);
-    selectedVariant = selectVariantPrompt;
+    handleCancel(variantPrompt);
+    selectedVariant = variantPrompt;
   }
   const variantMeta = adapterContext.variants[selectedVariant];
-  let physicalPath = config.paths.blocks;
-  if (physicalPath.startsWith("@")) {
-    physicalPath = "./src/blocks";
-  }
-  const targetFolder = path.resolve(rootDir, physicalPath, targetBlock);
+  const targetFolder = path.resolve(blocksRootAbsolute, targetBlock);
   const packageJsonPath = await findUp("package.json", rootDir);
   if (!packageJsonPath) {
-    outputError(json, "Could not locate package.json in your current directory layout hierarchy.");
+    outputError(json, "Could not locate package.json.");
     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)));
+    packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+  } catch (err) {
+    outputError(json, "Failed to parse package.json.");
+    if (!json) log.error(pc.dim(String(err)));
     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];
+  const missingProd = [
+    ...adapterContext.dependencies ?? [],
+    ...variantMeta?.dependencies ?? []
+  ].filter((d) => !(d in installedDeps));
+  const missingDev = [
+    ...adapterContext.devDependencies ?? [],
+    ...variantMeta?.devDependencies ?? []
+  ].filter((d) => !(d in installedDeps));
+  if (missingProd.length > 0 || missingDev.length > 0) {
     if (!json) {
-      console.log(
-        pc.yellow(`
-\u26A0\uFE0F Missing required infrastructure packages: ${allMissingNames.join(", ")}`)
-      );
+      log.warn(`Missing dependencies: ${pc.cyan([...missingProd, ...missingDev].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}...`);
+    const shouldInstall = yes ? true : await confirm({ message: "Install missing dependencies?", initialValue: true });
+    if (!yes) handleCancel(shouldInstall);
+    if (shouldInstall) {
+      const pm = await fs.access(join(packageJsonDir, "pnpm-lock.yaml")).then(() => "pnpm").catch(() => "npm");
+      if (!json) s.start(`Installing via ${pm}...`);
+      const tasks = [];
+      if (missingProd.length > 0) {
+        tasks.push(
+          pm === "pnpm" ? `pnpm add ${missingProd.join(" ")}` : `npm install ${missingProd.join(" ")}`
+        );
+      }
+      if (missingDev.length > 0) {
+        tasks.push(
+          pm === "pnpm" ? `pnpm add -D ${missingDev.join(" ")}` : `npm install --save-dev ${missingDev.join(" ")}`
+        );
+      }
       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}
-`));
+        for (const cmd of tasks) {
+          if (!json) s.message(`Running: ${cmd}`);
           await new Promise((resolve, reject) => {
-            const child = exec(installCmd, { cwd: packageJsonDir });
-            child.stdout?.on("data", (data) => {
-              if (!json) process.stdout.write(pc.dim(data));
+            const child = exec(cmd, { cwd: packageJsonDir });
+            child.stdout?.on("data", (d) => {
+              if (!json) process.stdout.write(pc.dim(d));
             });
-            child.stderr?.on("data", (data) => {
-              if (!json) process.stdout.write(pc.dim(pc.red(data)));
+            child.stderr?.on("data", (d) => {
+              if (!json) process.stdout.write(pc.dim(pc.red(d)));
             });
             child.on(
               "close",
-              (code) => code === 0 ? resolve() : reject(new Error(`Exit code ${code}`))
+              (code) => code === 0 ? resolve() : reject(new Error(`Exit ${code}`))
             );
           });
         }
+        if (!json) s.stop("Dependencies installed.");
+      } catch (err) {
         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)));
+          s.stop("Installation failed.");
+          log.error(pc.dim(String(err)));
         } else {
-          outputError(json, "Automated dependency installation failed.");
+          outputError(json, "Dependency installation failed.");
         }
         return;
       }
     }
   }
   const filesToDownload = [];
-  if (blockMeta.baseFiles) {
+  if (blockMeta.baseFiles && Array.isArray(blockMeta.baseFiles)) {
     filesToDownload.push(...blockMeta.baseFiles);
   }
   if (adapterContext.core) {
     filesToDownload.push({
       source: adapterContext.core,
-      target: path.basename(adapterContext.core, ".txt")
+      target: path.basename(adapterContext.core)
     });
   }
   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")
-        });
+    for (const entry of variantMeta.files) {
+      if (typeof entry === "string") {
+        filesToDownload.push({ source: entry, target: path.basename(entry) });
       } else {
-        filesToDownload.push(fileEntry);
+        filesToDownload.push(entry);
       }
     }
   }
-  let fileExistsConflict = false;
-  for (const fileMap of filesToDownload) {
-    const destinationPath = join(targetFolder, fileMap.target);
+  let hasConflict = false;
+  for (const fm of filesToDownload) {
     try {
-      await fs.access(destinationPath);
-      fileExistsConflict = true;
+      await fs.access(join(targetFolder, fm.target));
+      hasConflict = true;
       break;
     } catch {
     }
   }
-  if (fileExistsConflict) {
-    const overwritePrompt = yes ? true : await confirm({
-      message: `\u26A0 Components in [${targetBlock}] already exist. Overwrite custom revisions?`,
+  if (hasConflict) {
+    const overwrite = yes ? true : await confirm({
+      message: `Files for "${targetBlock}" already exist. Overwrite?`,
       initialValue: false
     });
-    if (!yes) handleCancel(overwritePrompt);
-    if (!overwritePrompt) {
-      outputResult(json, {
-        success: false,
-        reason: "aborted",
-        message: "Local modifications preserved."
-      });
+    if (!yes) handleCancel(overwrite);
+    if (!overwrite) {
+      outputResult(json, { success: false, reason: "aborted", message: "Local files preserved." });
       return;
     }
   }
-  if (!json) {
-    s.start(`Downloading and building template adapter blocks [${targetBlock}]...`);
-  }
+  if (!json) s.start(`Downloading ${targetBlock}...`);
+  const filesWritten = [];
   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");
+    for (const fm of filesToDownload) {
+      const fileUrl = `${RAW_CDN_BASE}/${fm.source}`;
+      const res = await fetch(fileUrl);
+      if (!res.ok) throw new Error(`Failed to download: ${fm.source} (HTTP ${res.status})`);
+      let content = await res.text();
+      const writtenFilePath = path.join(targetFolder, fm.target);
+      content = rewriteFileImports(content, writtenFilePath, blocksRootAbsolute, aliasBase);
+      await fs.mkdir(dirname(writtenFilePath), { recursive: true });
+      await fs.writeFile(writtenFilePath, content, "utf-8");
+      filesWritten.push(writtenFilePath);
     }
-    if (!json) s.stop(pc.green("\u2714 Component isolation structures written smoothly."));
+    if (!json) s.stop("Files written.");
     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!`
+      filesWritten,
+      dependenciesInstalled: [...missingProd, ...missingDev],
+      message: `${targetBlock} added to ${physicalBlocksPath}/${targetBlock}`
     });
-  } catch (error) {
+  } catch (err) {
     if (!json) {
-      s.stop(pc.red("\u2716 Fatal error occurred while assembling file mappings."));
-      console.error(pc.dim(String(error)));
+      s.stop("Failed.");
+      log.error(pc.dim(String(err)));
     } else {
-      outputError(json, "Fatal error occurred while assembling file mappings.");
+      outputError(json, "Fatal error while writing block files.");
     }
   }
 }
@@ -365,7 +328,8 @@ async function addCommand(blockName, options = {}) {
 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";
+import { intro as intro2, outro as outro2, select as select2, text, confirm as confirm2, spinner as spinner2, isCancel as isCancel2, log as log2 } from "@clack/prompts";
+import pc3 from "picocolors";
 
 // src/detectors/index.ts
 import { join as join6 } from "path";
@@ -478,7 +442,7 @@ function flattenTsPaths(paths) {
 import pc2 from "picocolors";
 var theme = {
   brand: {
-    primary: pc2.blue,
+    primary: pc2.cyan,
     title: pc2.bold,
     logo: pc2.white
   },
@@ -491,7 +455,7 @@ var theme = {
     success: pc2.green,
     warning: pc2.yellow,
     error: pc2.red,
-    info: pc2.blue
+    info: pc2.cyan
   },
   emphasis: {
     strong: pc2.bold,
@@ -502,36 +466,56 @@ var theme = {
 // 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}`),
+  success: (text2) => theme.state.success(text2),
+  error: (text2) => theme.state.error(text2),
   warning: (text2) => theme.state.warning(text2),
   muted: (text2) => theme.text.muted(text2),
-  info: (text2) => theme.state.info(text2)
+  info: (text2) => theme.state.info(text2),
+  highlight: (text2) => theme.brand.primary(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 {
-      }
+  const candidates = [join7(cwd, "tsconfig.json"), join7(cwd, "jsconfig.json")];
+  for (const configPath of candidates) {
+    if (!existsSync4(configPath)) continue;
+    try {
+      const raw = await fs2.readFile(configPath, "utf-8");
+      const clean = raw.replace(/\/\*[\s\S]*?\*\/|([^\\:]|^)\/\/.*$/gm, "$1");
+      const parsed = JSON.parse(clean);
+      return {
+        baseUrl: parsed.compilerOptions?.baseUrl ?? ".",
+        paths: parsed.compilerOptions?.paths ?? {}
+      };
+    } catch {
     }
   }
   return { baseUrl: ".", paths: {} };
 }
+function deriveBlockAlias(tsPaths, blocksPhysicalPath) {
+  const normalizedBlocksPath = blocksPhysicalPath.replace(/^\.\//, "").replace(/\\/g, "/");
+  for (const [aliasKey, targets] of Object.entries(tsPaths)) {
+    if (!Array.isArray(targets) || targets.length === 0) continue;
+    const rawTarget = targets[0].replace(/\\/g, "/");
+    const targetRoot = rawTarget.replace(/\*$/, "").replace(/\/$/, "").replace(/^\.\//, "");
+    const aliasRoot = aliasKey.replace(/\/\*$/, "").replace(/\*$/, "");
+    if (targetRoot === "") {
+      return `${aliasRoot}/${normalizedBlocksPath}`.replace(/\/+/g, "/");
+    }
+    if (normalizedBlocksPath === targetRoot || normalizedBlocksPath.startsWith(`${targetRoot}/`)) {
+      const suffix = normalizedBlocksPath.slice(targetRoot.length).replace(/^\//, "");
+      const alias = suffix ? `${aliasRoot}/${suffix}` : aliasRoot;
+      return alias.replace(/\/+/g, "/");
+    }
+  }
+  return void 0;
+}
 function outputInitError(json, message) {
   if (json) {
     process.stdout.write(JSON.stringify({ success: false, error: message }) + "\n");
   } else {
-    outro2(format.error(message));
+    log2.error(format.error(message));
+    process.exit(1);
   }
 }
 function outputInitResult(json, result) {
@@ -546,15 +530,8 @@ async function initCommand(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 "));
+    console.log("");
+    intro2(`${pc3.bgCyan(pc3.black(" blockend "))} ${theme.text.muted("setup")}`);
   }
   if (existsSync4(configPath)) {
     let action;
@@ -562,21 +539,21 @@ async function initCommand(options = {}) {
       action = "overwrite";
     } else {
       const actionPrompt = await select2({
-        message: "blockend.json already exists. What do you want to do?",
+        message: "A blockend.json already exists. What would you like to do?",
         options: [
-          { value: "keep", label: "Keep existing config (cancel init)" },
-          { value: "overwrite", label: "Overwrite config" },
-          { value: "regenerate", label: "Delete and regenerate" }
+          { value: "keep", label: "Keep existing (cancel setup)" },
+          { value: "overwrite", label: "Overwrite current configuration" },
+          { value: "regenerate", label: "Delete and regenerate from scratch" }
         ]
       });
       if (isCancel2(actionPrompt) || actionPrompt === "keep") {
         if (json) {
           outputInitResult(json, {
             success: false,
-            message: "Initialization cancelled. Existing config preserved."
+            message: "Setup cancelled. Existing config preserved."
           });
         } else {
-          outro2(format.muted("Initialization cancelled. Existing config preserved."));
+          outro2(format.muted("Setup cancelled. Existing config preserved."));
         }
         return;
       }
@@ -584,22 +561,22 @@ async function initCommand(options = {}) {
     }
     if (action === "regenerate") {
       await fs2.unlink(configPath);
-      if (!json) console.log(format.error("Existing config deleted"));
+      if (!json) log2.warn("Existing configuration deleted.");
     }
   }
   const s = spinner2();
-  if (!json) s.start("Scanning project layout...");
+  if (!json) s.start("Scanning project architecture...");
   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"));
+  if (!json) s.stop("Project 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:",
+        message: "Which framework does this project use?",
         options: [
           { value: "express", label: "Express.js" },
           { value: "fastify", label: "Fastify" },
@@ -609,67 +586,42 @@ async function initCommand(options = {}) {
       });
       if (isCancel2(frameworkSelect)) {
         if (json) {
-          outputInitResult(json, { success: false, message: "Initialization cancelled." });
+          outputInitResult(json, { success: false, message: "Setup cancelled." });
         } else {
-          outro2(format.muted("Initialization cancelled."));
+          outro2(format.muted("Setup cancelled."));
         }
         return;
       }
       framework = frameworkSelect;
     }
   } else if (!json) {
-    console.log(
-      `${format.success("\u2714")} Framework environment detected: ${theme.state.info(framework)}`
-    );
+    log2.info(`Framework 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:",
+      message: "Where would you like to install blocks?",
       placeholder: defaultDir,
       initialValue: defaultDir,
       validate(value) {
-        if (value?.trim().length === 0) return "Physical path location directory cannot be empty.";
+        if (!value || value.trim().length === 0) return "Directory path cannot be empty.";
       }
     });
     if (isCancel2(directoryPrompt)) {
-      outro2(format.muted("Initialization cancelled."));
+      outro2(format.muted("Setup 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 relativeBlocksPath = path2.relative(cwd, path2.resolve(cwd, rawPhysicalInput)).replace(/\\/g, "/");
+  const finalPath = relativeBlocksPath.startsWith(".") ? relativeBlocksPath : `./${relativeBlocksPath}`;
+  const hasTsPaths = Object.keys(tsConfig.paths).length > 0;
+  const finalBlockAlias = hasTsPaths ? deriveBlockAlias(tsConfig.paths, relativeBlocksPath) : void 0;
+  if (!json) {
+    log2.info(
+      `Import alias: ${theme.state.info(finalBlockAlias === void 0 ? " relative imports" : finalBlockAlias)}`
+    );
   }
   let includeRedis = false;
   if (context.hasRedis) {
@@ -677,7 +629,7 @@ async function initCommand(options = {}) {
       includeRedis = true;
     } else {
       const redisConfirm = await confirm2({
-        message: "Redis detected. Enable Redis-backed block variants automatically?",
+        message: "Redis detected in project. Enable Redis-backed variants?",
         initialValue: true
       });
       if (!isCancel2(redisConfirm)) {
@@ -686,38 +638,40 @@ async function initCommand(options = {}) {
     }
   }
   const configPayload = {
-    $schema: "https://blockend.dev/schema.json",
+    $schema: "https://blockend.noorulhassan.com/schema.json",
     environment: framework || "express",
     language: context.language || "typescript",
     includeRedis,
     aliases: {
-      blocks: finalBlockAlias
+      ...finalBlockAlias ? { blocks: finalBlockAlias } : {}
     },
     paths: {
       blocks: finalPath
+      // e.g. "./src/blocks" — always a real physical path
     }
   };
-  if (!json) s.start("Finalizing configuration...");
+  if (!json) s.start("Writing configuration...");
   try {
     await fs2.writeFile(configPath, JSON.stringify(configPayload, null, 2), "utf-8");
-    if (!json) s.stop(format.success("blockend.json ready"));
+    if (!json) s.stop("Configuration saved.");
     outputInitResult(json, {
       success: true,
-      message: "\u2728 Blockend initialized successfully. Run: npx blockend add <block>",
+      message: "Blockend initialized! Run: npx blockend add <block>",
       config: configPayload
     });
   } catch {
     if (!json) {
-      s.stop(format.error("Failed to write configuration"));
+      s.stop("Failed");
+      outputInitError(false, "Failed to write configuration file.");
     } else {
-      outputInitError(json, "Failed to write architectural layout configuration map.");
+      outputInitError(true, "Failed to write configuration file.");
     }
   }
 }
 
 // src/commands/detect.ts
 import { outro as outro3 } from "@clack/prompts";
-import pc3 from "picocolors";
+import pc4 from "picocolors";
 async function detectCommand(options = {}) {
   const { json = false } = options;
   try {
@@ -727,27 +681,27 @@ async function detectCommand(options = {}) {
       return;
     }
     console.log();
-    console.log(pc3.bold("  Detected project configuration:"));
+    console.log(pc4.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(`  Framework:        ${pc4.cyan(context.framework)}`);
+    console.log(`  Language:         ${pc4.cyan(context.language)}`);
+    console.log(`  Package manager:  ${pc4.cyan(context.packageManager)}`);
+    console.log(`  Source dir:       ${pc4.dim(context.srcDir)}`);
     console.log(
-      `  Redis:            ${context.hasRedis ? pc3.green("detected") : pc3.dim("not found")}`
+      `  Redis:            ${context.hasRedis ? pc4.green("detected") : pc4.dim("not found")}`
     );
     console.log(
-      `  Prisma:           ${context.hasPrisma ? pc3.green("detected") : pc3.dim("not found")}`
+      `  Prisma:           ${context.hasPrisma ? pc4.green("detected") : pc4.dim("not found")}`
     );
     console.log(
-      `  Drizzle:          ${context.hasDrizzle ? pc3.green("detected") : pc3.dim("not found")}`
+      `  Drizzle:          ${context.hasDrizzle ? pc4.green("detected") : pc4.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)}`));
+      outro3(pc4.red(`\u2716 Detection failed: ${String(error)}`));
     }
     process.exit(1);
   }
@@ -756,7 +710,7 @@ async function detectCommand(options = {}) {
 // src/commands/list.ts
 import { dirname as dirname2, join as join8 } from "path";
 import fs3 from "fs/promises";
-import pc4 from "picocolors";
+import pc5 from "picocolors";
 import { outro as outro4, spinner as spinner3 } from "@clack/prompts";
 var REPO_OWNER2 = "codewithnuh";
 var REPO_NAME2 = "blockend";
@@ -787,7 +741,7 @@ async function listCommand(options = {}) {
         JSON.stringify({ success: false, error: "blockend.json not found." }) + "\n"
       );
     } else {
-      outro4(pc4.red("\u2716 blockend.json not found. Run 'npx blockend init' first."));
+      outro4(pc5.red("\u2716 blockend.json not found. Run 'npx blockend init' first."));
     }
     return;
   }
@@ -801,7 +755,7 @@ async function listCommand(options = {}) {
         JSON.stringify({ success: false, error: "Failed to parse configuration matrix." }) + "\n"
       );
     } else {
-      outro4(pc4.red("\u2716 Failed to parse blockend.json layout configuration."));
+      outro4(pc5.red("\u2716 Failed to parse blockend.json layout configuration."));
     }
     return;
   }
@@ -815,14 +769,14 @@ async function listCommand(options = {}) {
     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."));
+    if (!json) s.stop(pc5.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."));
+      s.stop(pc5.red("\u2716 Failed to fetch the component registry from GitHub network paths."));
     }
     return;
   }
@@ -851,15 +805,15 @@ async function listCommand(options = {}) {
     );
   } else {
     console.log(`
-Available backend blocks for ${pc4.magenta(envKey)}:`);
+Available backend blocks for ${pc5.magenta(envKey)}:`);
     if (blocksForEnv.length === 0) {
-      console.log(pc4.dim("  No blocks found for this framework."));
+      console.log(pc5.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(", ")}`);
+  ${pc5.cyan(b.name)}`);
+        console.log(`    ${pc5.dim(b.description)}`);
+        console.log(`    Storage Variants: ${b.variants.map((v) => pc5.yellow(v)).join(", ")}`);
       });
       console.log();
     }
@@ -869,7 +823,7 @@ Available backend blocks for ${pc4.magenta(envKey)}:`);
 // src/commands/mcp.ts
 import path3, { join as join9 } from "path";
 import fs4 from "fs/promises";
-import pc5 from "picocolors";
+import pc6 from "picocolors";
 import { outro as outro5, spinner as spinner4, select as select3, confirm as confirm3 } from "@clack/prompts";
 var CLIENT_MATRIX = {
   claude: {
@@ -992,22 +946,22 @@ async function mcpInitCommand(options) {
   }
   const meta = CLIENT_MATRIX[chosenClient];
   if (!meta) {
-    outro5(pc5.red(`\u2716 Unsupported client identifier profile: ${options.client}`));
+    outro5(pc6.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)}`)
+      pc6.cyan(`
+\u2139 Dry-run mode active. Intended path location: ${pc6.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)));
+      console.log(pc6.gray(JSON.stringify(jsonConfig, null, 2)));
     } else {
-      console.log(pc5.gray(generateToml(BLOCKEND_SERVER)));
+      console.log(pc6.gray(generateToml(BLOCKEND_SERVER)));
     }
-    outro5(pc5.green("\u2714 Dry run evaluation complete."));
+    outro5(pc6.green("\u2714 Dry run evaluation complete."));
     return;
   }
   let fileConflict = false;
@@ -1022,12 +976,12 @@ async function mcpInitCommand(options) {
       initialValue: false
     });
     if (!shouldOverwrite || typeof shouldOverwrite === "symbol") {
-      outro5(pc5.yellow("\u2139 Operations halted. Project layout revisions preserved."));
+      outro5(pc6.yellow("\u2139 Operations halted. Project layout revisions preserved."));
       return;
     }
   }
   const s = spinner4();
-  s.start(`Writing localized project configurations inside ${pc5.dim(meta.relativePath)}...`);
+  s.start(`Writing localized project configurations inside ${pc6.dim(meta.relativePath)}...`);
   try {
     await fs4.mkdir(path3.dirname(absoluteConfigTarget), { recursive: true });
     if (meta.format === "json") {
@@ -1052,11 +1006,11 @@ async function mcpInitCommand(options) {
       await fs4.writeFile(absoluteConfigTarget, generateToml(BLOCKEND_SERVER), "utf-8");
     }
     s.stop(
-      pc5.green(`\u2714 Local workspace integration fully complete! File target: ${meta.relativePath}`)
+      pc6.green(`\u2714 Local workspace integration fully complete! File target: ${meta.relativePath}`)
     );
   } catch (error) {
-    s.stop(pc5.red("\u2716 Fatal crash reading or creating local configuration maps."));
-    console.error(pc5.dim(String(error)));
+    s.stop(pc6.red("\u2716 Fatal crash reading or creating local configuration maps."));
+    console.error(pc6.dim(String(error)));
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockend-cli",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "CLI for installing production-ready backend blocks into Next.js, Express, Hono, NestJS, and other Node.js applications.",
   "type": "module",
   "main": "./dist/index.js",