blockend-cli 1.4.3 → 1.4.5

package/dist/index.js

@@ -14,6 +14,29 @@ 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 blockSupportsEnv(block, envKey) {
+  if (block.frameworks && block.frameworks.length > 0) {
+    return block.frameworks.includes("*") || block.frameworks.includes(envKey);
+  }
+  return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
+}
+function resolveAdapterContext(block, envKey) {
+  return block.adapters?.[envKey] ?? block.adapters?.["*"] ?? block.environments?.[envKey] ?? block.environments?.["*"] ?? null;
+}
+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");
@@ -25,11 +48,7 @@ function outputResult(json, result) {
   if (json) {
     process.stdout.write(JSON.stringify(result) + "\n");
   } else {
-    if (result.success) {
-      outro(pc.green(`\u2728 ${result.message}`));
-    } else {
-      outro(pc.yellow(`\u2139 ${result.message}`));
-    }
+    outro(result.success ? pc.green(`\u2728 ${result.message}`) : pc.yellow(`\u2139 ${result.message}`));
   }
 }
 function handleCancel(value) {
@@ -41,10 +60,10 @@ function handleCancel(value) {
 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;
@@ -68,281 +87,236 @@ 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) {
+    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(error)));
+    if (!json) log.error(pc.dim(String(err)));
     return;
   }
   if (config.language !== "typescript") {
-    if (json) {
-      outputError(json, "Registry exclusively supports TypeScript projects.");
-    } else {
-      log.warn("Blockend currently only supports TypeScript projects.");
-      outro(pc.dim("Exiting."));
-    }
+    outputError(json, "Blockend currently only supports TypeScript projects.");
     return;
   }
+  const physicalBlocksPath = config.paths.blocks;
+  const blocksRootAbsolute = path.resolve(rootDir, physicalBlocksPath);
+  const aliasBase = config.aliases.blocks;
+  const envKey = config.environment;
   const s = spinner();
-  if (!json) {
-    s.start("Fetching registry...");
-  }
+  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();
+    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 (error) {
+  } catch (err) {
     if (!json) {
       s.stop("Failed to fetch registry.");
-      log.error(pc.dim(String(error)));
-    } else {
-      outputError(json, "Failed to fetch the component registry from GitHub.");
-    }
+      log.error(pc.dim(String(err)));
+    } else outputError(json, "Failed to fetch 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 filteredBlocks = 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;
-    });
-    if (filteredBlocks.length === 0) {
-      const msg = `No backend blocks are currently available for: ${envKey}.`;
-      if (json) {
-        outputError(json, msg);
-      } else {
-        log.warn(msg);
-        outro(pc.dim("Exiting."));
-      }
+    const available = Object.entries(blockMap).filter(
+      ([, block]) => block != null && blockSupportsEnv(block, envKey)
+    );
+    if (available.length === 0) {
+      outputError(json, `No blocks available for environment: ${envKey}`);
+      if (!json) outro(pc.dim("Exiting."));
       return;
     }
-    const maxKeyLength = Math.max(...filteredBlocks.map(([key]) => key.length), 0);
-    const availableOptions = filteredBlocks.map(([key, block], index) => {
-      const paddedKey = key.padEnd(maxKeyLength + 4, " ");
-      const maxDescWidth = 60;
-      const optimizedDescription = block.description.length > maxDescWidth ? `${block.description.slice(0, maxDescWidth)}...` : block.description;
-      return {
-        value: key,
-        label: `${pc.dim(`${index + 1}.`)} ${pc.bold(pc.cyan(paddedKey))}${pc.dim(optimizedDescription)}`
-      };
-    });
-    const selectBlockPrompt = await select({
+    const maxKeyLen = Math.max(...available.map(([k]) => k.length), 0);
+    const selectPrompt = await select({
       message: "Which block would you like to add?",
-      options: availableOptions
+      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 registry.`);
+    outputError(json, `Block "${targetBlock}" not found in the registry.`);
     return;
   }
-  const adapterContext = blockMeta.adapters?.[envKey] ?? blockMeta.environments?.[envKey];
+  if (!blockSupportsEnv(blockMeta, envKey)) {
+    outputError(json, `Block "${targetBlock}" does not support environment: ${envKey}`);
+    return;
+  }
+  const adapterContext = resolveAdapterContext(blockMeta, envKey);
   if (!adapterContext) {
-    outputError(json, `The block "${targetBlock}" does not support your environment: ${envKey}`);
+    outputError(
+      json,
+      `Block "${targetBlock}" has no adapter or environment entry for: ${envKey}. This is a registry configuration issue \u2014 please open an issue.`
+    );
     return;
   }
-  let selectedVariant;
-  const variantKeys = Object.keys(adapterContext.variants || {});
+  const variantKeys = Object.keys(adapterContext.variants ?? {});
   if (variantKeys.length === 0) {
-    outputError(json, `No storage variants found for block environment: ${envKey}`);
+    outputError(json, `No variants found for "${targetBlock}" / "${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({
+    const variantPrompt = await select({
       message: "Select a storage variant:",
-      options: variantKeys.map((vKey) => ({
-        value: vKey,
-        label: vKey.toUpperCase()
-      }))
+      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.");
+    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 package.json.");
-    if (!json) log.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];
-    if (!json) {
-      log.warn(`Missing dependencies: ${pc.cyan(allMissingNames.join(", "))}`);
-    }
-    const shouldInstallPrompt = yes ? true : await confirm({
-      message: "Install missing 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(`Installing via ${packageManager}...`);
+  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) log.warn(`Missing: ${pc.cyan([...missingProd, ...missingDev].join(", "))}`);
+    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.message(`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 (error) {
+        if (!json) s.stop("Dependencies installed.");
+      } catch (err) {
         if (!json) {
           s.stop("Installation failed.");
-          log.error(pc.dim(String(error)));
-        } else {
-          outputError(json, "Automated dependency installation failed.");
-        }
+          log.error(pc.dim(String(err)));
+        } else outputError(json, "Dependency installation failed.");
         return;
       }
     }
   }
   const filesToDownload = [];
-  if (blockMeta.baseFiles) {
+  if (blockMeta.baseFiles?.length) {
     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")
-        });
-      } else {
-        filesToDownload.push(fileEntry);
-      }
+    for (const entry of variantMeta.files) {
+      filesToDownload.push(
+        typeof entry === "string" ? { source: entry, target: path.basename(entry) } : 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({
+  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 ${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 res = await fetch(`${RAW_CDN_BASE}/${fm.source}`);
+      if (!res.ok) throw new Error(`Download failed: ${fm.source} (HTTP ${res.status})`);
+      let content = await res.text();
+      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("Files copied.");
+    if (!json) s.stop("Files written.");
     outputResult(json, {
       success: true,
       block: targetBlock,
-      filesWritten: filesToDownload.map((f) => join(targetFolder, f.target)),
-      dependenciesInstalled: [...missingProdDeps, ...missingDevDeps],
-      message: `Block added to ${physicalPath}/${targetBlock}`
+      filesWritten,
+      dependenciesInstalled: [...missingProd, ...missingDev],
+      message: `${targetBlock} added to ${physicalBlocksPath}/${targetBlock}`
     });
-  } catch (error) {
+  } catch (err) {
     if (!json) {
-      s.stop("Failed to write files.");
-      log.error(pc.dim(String(error)));
-    } else {
-      outputError(json, "Fatal error occurred while writing block files.");
-    }
+      s.stop("Failed.");
+      log.error(pc.dim(String(err)));
+    } else outputError(json, "Fatal error while writing block files.");
   }
 }
 
@@ -498,22 +472,40 @@ var format = {
 
 // 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");
@@ -543,7 +535,7 @@ async function initCommand(options = {}) {
       action = "overwrite";
     } else {
       const actionPrompt = await select2({
-        message: "A blockend.json configuration already exists. What would you like to do?",
+        message: "A blockend.json already exists. What would you like to do?",
         options: [
           { value: "keep", label: "Keep existing (cancel setup)" },
           { value: "overwrite", label: "Overwrite current configuration" },
@@ -609,7 +601,7 @@ async function initCommand(options = {}) {
       placeholder: defaultDir,
       initialValue: defaultDir,
       validate(value) {
-        if (value?.trim().length === 0) return "Directory path cannot be empty.";
+        if (!value || value.trim().length === 0) return "Directory path cannot be empty.";
       }
     });
     if (isCancel2(directoryPrompt)) {
@@ -618,37 +610,14 @@ async function initCommand(options = {}) {
     }
     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) {
@@ -665,15 +634,16 @@ 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("Writing configuration...");
@@ -682,7 +652,7 @@ async function initCommand(options = {}) {
     if (!json) s.stop("Configuration saved.");
     outputInitResult(json, {
       success: true,
-      message: "Blockend initialized successfully! Run: npx blockend add <block>",
+      message: "Blockend initialized! Run: npx blockend add <block>",
       config: configPayload
     });
   } catch {
@@ -690,7 +660,7 @@ async function initCommand(options = {}) {
       s.stop("Failed");
       outputInitError(false, "Failed to write configuration file.");
     } else {
-      outputInitError(true, "Failed to write architectural layout configuration map.");
+      outputInitError(true, "Failed to write configuration file.");
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockend-cli",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "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",