blockend-cli 1.0.2 → 1.2.0

package/dist/index.js

@@ -264,14 +264,21 @@ async function initCommand() {
 // src/commands/add.ts
 import path2, { join as join7 } from "path";
 import fs2 from "fs/promises";
-import { execSync } from "child_process";
-import { intro as intro2, outro as outro2, select as select2, spinner as spinner2, confirm as confirm2 } from "@clack/prompts";
+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 = "codewitnuh";
+var REPO_OWNER = "codewithnuh";
 var REPO_NAME = "blockend";
 var BRANCH = "master";
+var LOCAL_DEV_URL = "http://localhost:5000";
 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);
+  }
+}
 async function addCommand(blockName) {
   intro2(pc2.bgBlack(pc2.magenta(" Blockend Component Ingestion ")));
   const cwd = process.cwd();
@@ -300,16 +307,18 @@ async function addCommand(blockName) {
   if (!targetBlock) {
     const availableOptions = Object.keys(registry).map((key) => ({
       value: key,
-      label: `${key} - pc.dim(${registry[key].description})`
+      label: `${key} - ${pc2.dim(registry[key].description)}`
     }));
     if (availableOptions.length === 0) {
       outro2(pc2.yellow("\u26A0 The remote block registry is currently empty."));
       return;
     }
-    targetBlock = await select2({
+    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) {
@@ -320,15 +329,34 @@ async function addCommand(blockName) {
   const envConfig = blockMeta.environments[envKey];
   if (!envConfig) {
     outro2(
-      pc2.red(
-        `\u2716 The block "${targetBlock}" does not support your environment layout: ${String(config.environment)}`
-      )
+      pc2.red(`\u2716 The block "${targetBlock}" does not support your environment layout: ${envKey}`)
     );
     return;
   }
+  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";
+    } 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()
+        }))
+      });
+      handleCancel(selectVariantPrompt);
+      selectedVariant = selectVariantPrompt;
+    }
+    variantMeta = envConfig.variants[selectedVariant];
+  }
   let packageJson;
   try {
-    packageJson = JSON.parse(await fs2.readFile(join7(cwd, "package.json"), "utf-8"));
+    packageJson = JSON.parse(
+      await fs2.readFile(join7(cwd, "package.json"), "utf-8")
+    );
   } catch {
     outro2(pc2.red("\u2716 Could not locate package.json in your current workspace directory."));
     return;
@@ -337,23 +365,41 @@ async function addCommand(blockName) {
     ...packageJson.dependencies ?? {},
     ...packageJson.devDependencies ?? {}
   };
-  const missingDeps = envConfig.dependencies.filter((dep) => !(dep in installedDeps));
+  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 shouldInstall = await confirm2({
+    const shouldInstallPrompt = await confirm2({
       message: "Would you like the CLI to automatically install these dependencies?",
       initialValue: true
     });
-    if (shouldInstall) {
-      s.start(`Installing dependencies via your native package manager...`);
+    handleCancel(shouldInstallPrompt);
+    if (shouldInstallPrompt) {
+      const packageManager = await fs2.access(join7(cwd, "pnpm-lock.yaml")).then(() => "pnpm").catch(() => "npm");
+      s.start(`Preparing native workspace via ${packageManager}...`);
       try {
-        const lockfileCheck = await fs2.access(join7(cwd, "pnpm-lock.yaml")).then(() => "pnpm").catch(() => "npm");
-        const installCmd = lockfileCheck === "pnpm" ? `pnpm add ${missingDeps.join(" ")}` : `npm install ${missingDeps.join(" ")}`;
-        execSync(installCmd, { stdio: "ignore", cwd });
-        s.stop(pc2.green("\u2714 Dependencies installed cleanly."));
+        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 });
+          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."));
       }
@@ -361,26 +407,42 @@ async function addCommand(blockName) {
   }
   s.start(`Downloading clean production template block [${targetBlock}]...`);
   try {
-    const targetFileUrl = `${RAW_CDN_BASE}/${envConfig.path}`;
-    const codeFetchResponse = await fetch(targetFileUrl);
-    if (!codeFetchResponse.ok) {
-      throw new Error(`Failed downloading component source file: ${codeFetchResponse.statusText}`);
+    const BASE_URL = MANIFEST_URL.includes("localhost") ? LOCAL_DEV_URL : RAW_CDN_BASE;
+    const coreFileUrl = `${BASE_URL}/${envConfig.core}`;
+    const coreFetchResponse = await fetch(coreFileUrl);
+    if (!coreFetchResponse.ok) {
+      throw new Error(`Failed downloading core component file: ${coreFetchResponse.statusText}`);
     }
-    const targetCodeTemplate = await codeFetchResponse.text();
+    const coreCodeTemplate = await coreFetchResponse.text();
     let physicalPath = config.paths.blocks;
     if (physicalPath.startsWith("@")) {
       physicalPath = "./src/blocks";
     }
-    const targetFolder = path2.resolve(cwd, physicalPath);
+    let targetFolder = path2.resolve(cwd, physicalPath);
+    if (variantMeta && selectedVariant) {
+      targetFolder = join7(targetFolder, targetBlock);
+    }
     await fs2.mkdir(targetFolder, { recursive: true });
     const fileExtension = config.language === "typescript" ? "ts" : "js";
-    const outputFilename = `${targetBlock}.${fileExtension}`;
-    await fs2.writeFile(join7(targetFolder, outputFilename), targetCodeTemplate, "utf-8");
-    const cleanDisplayPath = physicalPath.replace(/\\/g, "/");
-    s.stop(pc2.green(`\u2714 ${outputFilename} successfully injected into codebase.`));
+    const coreOutputFilename = `${targetBlock}.${fileExtension}`;
+    await fs2.writeFile(join7(targetFolder, coreOutputFilename), coreCodeTemplate, "utf-8");
+    if (variantMeta && selectedVariant) {
+      const variantFileUrl = `${BASE_URL}/${variantMeta.path}`;
+      const variantFetchResponse = await fetch(variantFileUrl);
+      if (!variantFetchResponse.ok) {
+        throw new Error(
+          `Failed downloading storage variant file: ${variantFetchResponse.statusText}`
+        );
+      }
+      const variantCodeTemplate = await variantFetchResponse.text();
+      const variantOutputFilename = `store-${selectedVariant}.${fileExtension}`;
+      await fs2.writeFile(join7(targetFolder, variantOutputFilename), variantCodeTemplate, "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}/${outputFilename}. Code ownership transferred!`
+        `\u2728 Source blocks written to ${cleanDisplayPath}/ layout. Code ownership transferred!`
       )
     );
   } catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockend-cli",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Intelligent, modular backend blocks right inside your terminal",
   "main": "./dist/index.js",
   "type": "module",