blockend-cli 1.4.5 → 1.5.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { defineCommand, runMain } from "citty";
 
 // src/commands/add.ts
 import path, { join, dirname } from "path";
-import fs from "fs/promises";
+import fs, { readFile } from "fs/promises";
 import { exec } from "child_process";
 import { intro, outro, select, spinner, confirm, isCancel, log } from "@clack/prompts";
 import pc from "picocolors";
@@ -20,21 +20,30 @@ function blockSupportsEnv(block, envKey) {
   }
   return block.adapters?.[envKey] !== void 0 || block.environments?.[envKey] !== void 0;
 }
+var getMissingDependencies = (deps, installed) => [...new Set(deps)].filter((dep) => !(dep in installed));
 function 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;
-  }
+function rewriteFileImports(fileContent, writtenFilePath, blocksRoot, aliasBase, strategy) {
   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}`;
+    let targetPath = relativePath;
+    if (aliasBase && !aliasBase.startsWith(".")) {
+      const absoluteTarget = path.resolve(fileDir, relativePath);
+      const fromBlocksRoot = path.relative(blocksRoot, absoluteTarget).replace(/\\/g, "/");
+      if (!fromBlocksRoot.startsWith("..")) {
+        targetPath = `${aliasBase}/${fromBlocksRoot}`.replace(/\/+/g, "/");
+      }
+    }
+    const hasJsExt = targetPath.endsWith(".js");
+    if (strategy === "rewrite" && !hasJsExt) {
+      targetPath = targetPath.replace(/\.(ts|tsx|mts|cts)$/, "");
+      targetPath = `${targetPath}.js`;
+    } else if (strategy === "remove" && hasJsExt) {
+      targetPath = targetPath.slice(0, -3);
+    }
+    return `${keyword}${openQuote}${targetPath}${closeQuote}`;
   });
 }
 function outputError(json, message) {
@@ -101,6 +110,7 @@ async function addCommand(blockName, options = {}) {
   const blocksRootAbsolute = path.resolve(rootDir, physicalBlocksPath);
   const aliasBase = config.aliases.blocks;
   const envKey = config.environment;
+  const rewriteStrategy = config.importRewriteStrategy ?? "remove";
   const s = spinner();
   if (!json) s.start("Fetching registry...");
   let registry;
@@ -201,20 +211,28 @@ async function addCommand(blockName, options = {}) {
     ...packageJson.dependencies ?? {},
     ...packageJson.devDependencies ?? {}
   };
-  const missingProd = [
-    ...adapterContext.dependencies ?? [],
-    ...variantMeta?.dependencies ?? []
-  ].filter((d) => !(d in installedDeps));
-  const missingDev = [
-    ...adapterContext.devDependencies ?? [],
-    ...variantMeta?.devDependencies ?? []
-  ].filter((d) => !(d in installedDeps));
+  const missingProd = getMissingDependencies(
+    [
+      ...blockMeta.dependencies ?? [],
+      ...adapterContext.dependencies ?? [],
+      ...variantMeta?.dependencies ?? []
+    ],
+    installedDeps
+  );
+  const missingDev = getMissingDependencies(
+    [
+      ...blockMeta.devDependencies ?? [],
+      ...adapterContext.devDependencies ?? [],
+      ...variantMeta?.devDependencies ?? []
+    ],
+    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");
+      const pm = await readFile(join(packageJsonDir, "blockend.json"), "utf8").then((data) => JSON.parse(data).packageManager).catch(() => "npm");
       if (!json) s.start(`Installing via ${pm}...`);
       const tasks = [];
       if (missingProd.length > 0) {
@@ -295,11 +313,17 @@ async function addCommand(blockName, options = {}) {
   const filesWritten = [];
   try {
     for (const fm of filesToDownload) {
-      const res = await fetch(`${RAW_CDN_BASE}/${fm.source}`);
+      const res = await fetch(`${MANIFEST_URL}/${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);
+      content = rewriteFileImports(
+        content,
+        writtenFilePath,
+        blocksRootAbsolute,
+        aliasBase,
+        rewriteStrategy
+      );
       await fs.mkdir(dirname(writtenFilePath), { recursive: true });
       await fs.writeFile(writtenFilePath, content, "utf-8");
       filesWritten.push(writtenFilePath);
@@ -331,12 +355,12 @@ import pc3 from "picocolors";
 import { join as join6 } from "path";
 
 // src/detectors/readers/package.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { join as join2 } from "path";
 async function readPackageJson(cwd) {
   const pkgPath = join2(cwd, "package.json");
   try {
-    const content = await readFile(pkgPath, "utf-8");
+    const content = await readFile2(pkgPath, "utf-8");
     return JSON.parse(content);
   } catch {
     throw new Error(`No package.json found at ${pkgPath}. Run blockend from your project root.`);
@@ -344,14 +368,14 @@ async function readPackageJson(cwd) {
 }
 
 // src/detectors/readers/tsconfig.ts
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { existsSync } from "fs";
 import { join as join3 } from "path";
 async function readTsConfig(cwd) {
   const tsconfigPath = join3(cwd, "tsconfig.json");
   if (!existsSync(tsconfigPath)) return null;
   try {
-    const content = await readFile2(tsconfigPath, "utf-8");
+    const content = await readFile3(tsconfigPath, "utf-8");
     const cleanLines = content.split(/\r?\n/).filter((line) => {
       const trimmed = line.trim();
       return !trimmed.startsWith("//") && !trimmed.startsWith("/*");
@@ -391,9 +415,22 @@ function detectRuntime(deps) {
 }
 
 // src/detectors/package-manager.ts
-import { existsSync as existsSync3 } from "fs";
+import { existsSync as existsSync3, readFileSync } from "fs";
 import { join as join5 } from "path";
 function detectPackageManager(cwd) {
+  const pkgJsonPath = join5(cwd, "package.json");
+  if (existsSync3(pkgJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(pkgJsonPath, "utf8"));
+      if (typeof packageJson.packageManager === "string") {
+        const manager = packageJson.packageManager.split("@")[0];
+        if (manager === "npm" || manager === "pnpm" || manager === "yarn" || manager === "bun") {
+          return manager;
+        }
+      }
+    } catch {
+    }
+  }
   if (existsSync3(join5(cwd, "pnpm-lock.yaml"))) return "pnpm";
   if (existsSync3(join5(cwd, "bun.lockb"))) return "bun";
   if (existsSync3(join5(cwd, "yarn.lock"))) return "yarn";
@@ -409,6 +446,12 @@ async function detectProject(cwd) {
     ...pkg.peerDependencies
   };
   const srcDir = await inferSrcDir(cwd);
+  const moduleOpt = tsConfig?.compilerOptions?.module?.toLocaleLowerCase();
+  const resolutionOpt = tsConfig?.compilerOptions?.moduleResolution?.toLocaleLowerCase();
+  let importRewriteStrategy = "remove";
+  if (moduleOpt === "nodenext" || moduleOpt === "node16" || resolutionOpt === "nodenext" || resolutionOpt === "node16" || pkg.type === "module" && !resolutionOpt) {
+    importRewriteStrategy = "rewrite";
+  }
   return {
     root: cwd,
     language: tsConfig !== null ? "typescript" : "javascript",
@@ -421,7 +464,8 @@ async function detectProject(cwd) {
     aliasMap: tsConfig?.compilerOptions?.paths ? flattenTsPaths(tsConfig.compilerOptions.paths) : {},
     srcDir,
     // Default blocks directory: srcDir/lib/blocks
-    blocksDir: join6(srcDir, "lib", "blocks")
+    blocksDir: join6(srcDir, "lib", "blocks"),
+    importRewriteStrategy
   };
 }
 function flattenTsPaths(paths) {
@@ -618,6 +662,8 @@ async function initCommand(options = {}) {
     log2.info(
       `Import alias: ${theme.state.info(finalBlockAlias === void 0 ? " relative imports" : finalBlockAlias)}`
     );
+    const strategyDisplay = context.importRewriteStrategy === "rewrite" ? "NodeNext (append .js)" : "Bundler / Extensionless";
+    log2.info(`Import strategy: ${theme.state.info(strategyDisplay)}`);
   }
   let includeRedis = false;
   if (context.hasRedis) {
@@ -637,13 +683,15 @@ async function initCommand(options = {}) {
     $schema: "https://blockend.noorulhassan.com/schema.json",
     environment: framework || "express",
     language: context.language || "typescript",
+    packageManager: context.packageManager,
+    importRewriteStrategy: context.importRewriteStrategy,
+    // PERSIST STRATEGY TO DISK
     includeRedis,
     aliases: {
       ...finalBlockAlias ? { blocks: finalBlockAlias } : {}
     },
     paths: {
       blocks: finalPath
-      // e.g. "./src/blocks" — always a real physical path
     }
   };
   if (!json) s.start("Writing configuration...");
@@ -683,6 +731,8 @@ async function detectCommand(options = {}) {
     console.log(`  Language:         ${pc4.cyan(context.language)}`);
     console.log(`  Package manager:  ${pc4.cyan(context.packageManager)}`);
     console.log(`  Source dir:       ${pc4.dim(context.srcDir)}`);
+    const strategyDisplay = context.importRewriteStrategy === "rewrite" ? pc4.yellow("NodeNext (append .js)") : pc4.magenta("Bundler / Extensionless");
+    console.log(`  Import strategy:  ${strategyDisplay}`);
     console.log(
       `  Redis:            ${context.hasRedis ? pc4.green("detected") : pc4.dim("not found")}`
     );

package/package.json

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