@bike4mind/cli 0.2.31-b4m-cli-undo-command.19493 → 0.2.31-b4m-cli-undo-command.19535

package/dist/{chunk-OCYRD7D6.js → chunk-PFBYGCOW.js}

@@ -5,6 +5,7 @@ var Logger = class _Logger {
   static globalInstance = new _Logger();
   metadata = {};
   logInJson;
+  prettyPrint;
   minLevel;
   // Log level hierarchy (higher number = more severe)
   static LOG_LEVELS = {
@@ -13,15 +14,112 @@ var Logger = class _Logger {
     warn: 2,
     error: 3
   };
+  // ANSI color codes for pretty printing
+  static COLORS = {
+    debug: "\x1B[36m",
+    // Cyan
+    info: "\x1B[32m",
+    // Green
+    warn: "\x1B[33m",
+    // Yellow
+    error: "\x1B[31m",
+    // Red
+    reset: "\x1B[0m",
+    dim: "\x1B[2m"
+  };
+  // Level labels for pretty printing (padded for alignment)
+  static LEVEL_LABELS = {
+    debug: "DEBUG",
+    info: " INFO",
+    warn: " WARN",
+    error: "ERROR"
+  };
+  // Indentation constants for pretty printing
+  static INDENT = "    ";
+  static NESTED_INDENT = "      ";
   constructor(options = {}) {
-    const { metadata = {}, logInJson = process.env.LOG_JSON === "true" || !(process.env.IS_LOCAL === "true" || process.env.NODE_ENV === "development"), minLevel = process.env.LOG_LEVEL || "info" } = options;
+    const isLocalDev = process.env.IS_LOCAL === "true" || process.env.NODE_ENV === "development" || process.env.SST_LIVE === "true";
+    const { metadata = {}, logInJson = process.env.LOG_JSON === "true" || !isLocalDev, prettyPrint = isLocalDev && process.env.LOG_PRETTY !== "false", minLevel = process.env.LOG_LEVEL || "info" } = options;
     this.metadata = metadata;
     this.logInJson = logInJson;
+    this.prettyPrint = prettyPrint;
     this.minLevel = minLevel;
   }
   shouldLog(level) {
     return _Logger.LOG_LEVELS[level] >= _Logger.LOG_LEVELS[this.minLevel];
   }
+  /**
+   * Safely stringify a value, handling circular references
+   */
+  safeStringify(value, indent) {
+    try {
+      return JSON.stringify(value, null, indent);
+    } catch {
+      return "[Circular]";
+    }
+  }
+  /**
+   * Parse log arguments to extract message and optional metadata
+   */
+  parseArgs(args, errorAware = false) {
+    if (args.length === 0) {
+      return { message: "" };
+    }
+    const lastArg = args[args.length - 1];
+    const hasMetadata = args.length > 1 && typeof lastArg === "object" && lastArg !== null && !Array.isArray(lastArg) && !(lastArg instanceof Error);
+    const metadata = hasMetadata ? lastArg : void 0;
+    const messageArgs = hasMetadata ? args.slice(0, -1) : args;
+    const message = messageArgs.map((a) => {
+      if (errorAware && a instanceof Error) {
+        return a.stack || a.message;
+      }
+      return typeof a === "string" ? a : this.safeStringify(a);
+    }).join(" ");
+    return { message, metadata };
+  }
+  /**
+   * Output a log message using the appropriate format
+   */
+  output(level, consoleFn, message, metadata) {
+    const allMetadata = { ...this.metadata, ...metadata };
+    if (this.logInJson) {
+      consoleFn(this.safeStringify({ ...allMetadata, severity: level, message }));
+    } else if (this.prettyPrint) {
+      consoleFn(this.formatPretty(level, message, metadata));
+    } else {
+      const metadataKeys = Object.keys(allMetadata);
+      if (metadataKeys.length > 0) {
+        consoleFn(message, allMetadata);
+      } else {
+        consoleFn(message);
+      }
+    }
+  }
+  /**
+   * Format a log message with pino-pretty-like output for local development
+   */
+  formatPretty(level, message, metadata) {
+    const { reset, dim } = _Logger.COLORS;
+    const color = _Logger.COLORS[level];
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const parts = [];
+    parts.push(`${dim}[${timestamp}]${reset} ${color}${_Logger.LEVEL_LABELS[level]}${reset} ${message}`);
+    const allMetadata = { ...this.metadata, ...metadata };
+    const metadataKeys = Object.keys(allMetadata);
+    if (metadataKeys.length > 0) {
+      for (const key of metadataKeys) {
+        const value = allMetadata[key];
+        if (typeof value === "object" && value !== null) {
+          const jsonStr = this.safeStringify(value, 2);
+          const indentedJson = jsonStr.split("\n").map((line, idx) => idx === 0 ? line : _Logger.NESTED_INDENT + line).join("\n");
+          parts.push(`${_Logger.INDENT}${dim}${key}:${reset} ${indentedJson}`);
+        } else {
+          parts.push(`${_Logger.INDENT}${dim}${key}:${reset} ${value}`);
+        }
+      }
+    }
+    return parts.join("\n");
+  }
   resetMetadata() {
     this.metadata = {};
     return this;
@@ -33,6 +131,7 @@ var Logger = class _Logger {
         ...metadata
       },
       logInJson: this.logInJson,
+      prettyPrint: this.prettyPrint,
       minLevel: this.minLevel
     });
   }
@@ -49,47 +148,26 @@ var Logger = class _Logger {
   debug(...args) {
     if (!this.shouldLog("debug"))
       return;
-    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-    if (this.logInJson) {
-      console.debug(JSON.stringify({ ...this.metadata, severity: "debug", message }));
-    } else {
-      console.debug(message);
-    }
+    const { message, metadata } = this.parseArgs(args);
+    this.output("debug", console.debug, message, metadata);
   }
   info(...args) {
     if (!this.shouldLog("info"))
       return;
-    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-    if (this.logInJson) {
-      console.info(JSON.stringify({ ...this.metadata, severity: "info", message }));
-    } else {
-      console.info(message);
-    }
+    const { message, metadata } = this.parseArgs(args);
+    this.output("info", console.info, message, metadata);
   }
   warn(...args) {
     if (!this.shouldLog("warn"))
       return;
-    const message = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-    if (this.logInJson) {
-      console.warn(JSON.stringify({ ...this.metadata, severity: "warn", message }));
-    } else {
-      console.warn(message);
-    }
+    const { message, metadata } = this.parseArgs(args);
+    this.output("warn", console.warn, message, metadata);
   }
   error(...args) {
     if (!this.shouldLog("error"))
       return;
-    const message = args.map((a) => {
-      if (a instanceof Error) {
-        return a.stack || a.message;
-      }
-      return typeof a === "string" ? a : JSON.stringify(a);
-    }).join(" ");
-    if (this.logInJson) {
-      console.error(JSON.stringify({ ...this.metadata, severity: "error", message }));
-    } else {
-      console.error(message);
-    }
+    const { message, metadata } = this.parseArgs(args, true);
+    this.output("error", console.error, message, metadata);
   }
   /*
    * Global logger instance handling:
@@ -160,7 +238,7 @@ var notifyEventLogsToSlack = async ({ event, stage, slackUrl, throttlingSlackUrl
   if (!allowedStages.includes(stage))
     return;
   const logEvents = logData.logEvents;
-  const { notificationDeduplicator: notificationDeduplicator2 } = await import("./notificationDeduplicator-UTHJHMSZ.js");
+  const { notificationDeduplicator: notificationDeduplicator2 } = await import("./notificationDeduplicator-HUC53NEW.js");
   for (const logEvent of logEvents) {
     try {
       let message;

package/dist/commands/doctorCommand.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import {
+  fetchLatestVersion,
+  forceCheckForUpdate,
+  package_default
+} from "../chunk-M2QCFHVX.js";
+
+// src/commands/doctorCommand.ts
+import { execSync } from "child_process";
+import { existsSync, constants } from "fs";
+import { promises as fsPromises } from "fs";
+import path from "path";
+import { homedir } from "os";
+async function handleDoctorCommand() {
+  console.log("B4M CLI Doctor\n");
+  console.log("Running diagnostics...\n");
+  const results = [];
+  const nodeVersion = process.version;
+  const nodeMajor = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+  if (nodeMajor >= 18) {
+    results.push({ name: "Node.js version", status: "pass", message: `${nodeVersion} (>= 18 required)` });
+  } else {
+    results.push({
+      name: "Node.js version",
+      status: "fail",
+      message: `${nodeVersion} (>= 18 required, please upgrade)`
+    });
+  }
+  const latestVersion = await fetchLatestVersion();
+  if (latestVersion) {
+    results.push({ name: "NPM registry", status: "pass", message: `Accessible (latest: v${latestVersion})` });
+  } else {
+    results.push({ name: "NPM registry", status: "fail", message: "Not accessible \u2014 check your internet connection" });
+  }
+  const currentVersion = package_default.version;
+  const updateResult = await forceCheckForUpdate(currentVersion);
+  if (updateResult) {
+    if (updateResult.updateAvailable) {
+      results.push({
+        name: "Version",
+        status: "warn",
+        message: `v${currentVersion} installed, v${updateResult.latestVersion} available. Run: b4m update`
+      });
+    } else {
+      results.push({ name: "Version", status: "pass", message: `v${currentVersion} (latest)` });
+    }
+  }
+  try {
+    const npmPrefix = execSync("npm config get prefix", { encoding: "utf-8", timeout: 1e4 }).trim();
+    try {
+      await fsPromises.access(npmPrefix, constants.W_OK);
+      results.push({ name: "Global npm path", status: "pass", message: `${npmPrefix} (writable)` });
+    } catch {
+      results.push({
+        name: "Global npm path",
+        status: "warn",
+        message: `${npmPrefix} (not writable \u2014 may need sudo for updates)`
+      });
+    }
+  } catch {
+    results.push({ name: "Global npm path", status: "warn", message: "Could not determine npm prefix" });
+  }
+  const configFile = path.join(homedir(), ".bike4mind", "config.json");
+  if (existsSync(configFile)) {
+    results.push({ name: "Config file", status: "pass", message: configFile });
+  } else {
+    results.push({ name: "Config file", status: "warn", message: `Not found at ${configFile}` });
+  }
+  console.log("Results:\n");
+  for (const result of results) {
+    const icon = result.status === "pass" ? "\x1B[32m\u2713\x1B[0m" : result.status === "warn" ? "\x1B[33m!\x1B[0m" : "\x1B[31m\u2717\x1B[0m";
+    console.log(`  ${icon} ${result.name}: ${result.message}`);
+  }
+  const failures = results.filter((r) => r.status === "fail");
+  const warnings = results.filter((r) => r.status === "warn");
+  console.log("");
+  if (failures.length > 0) {
+    console.log(`${failures.length} issue(s) found.`);
+  } else if (warnings.length > 0) {
+    console.log(`All checks passed with ${warnings.length} warning(s).`);
+  } else {
+    console.log("All checks passed.");
+  }
+}
+export {
+  handleDoctorCommand
+};

package/dist/commands/mcpCommand.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ConfigStore
-} from "../chunk-LBTTUQJM.js";
+} from "../chunk-32PKF3N7.js";
 
 // src/commands/mcpCommand.ts
 async function handleMcpCommand(subcommand, argv) {

package/dist/commands/updateCommand.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import {
+  forceCheckForUpdate,
+  package_default
+} from "../chunk-M2QCFHVX.js";
+
+// src/commands/updateCommand.ts
+import { execSync } from "child_process";
+async function handleUpdateCommand() {
+  const currentVersion = package_default.version;
+  console.log(`Current version: v${currentVersion}`);
+  console.log("Checking for updates...\n");
+  const result = await forceCheckForUpdate(currentVersion);
+  if (!result) {
+    console.error("Failed to check for updates. Check your internet connection.");
+    process.exit(1);
+  }
+  if (!result.updateAvailable) {
+    console.log(`Already on the latest version (v${currentVersion}).`);
+    return;
+  }
+  console.log(`Update available: v${currentVersion} \u2192 v${result.latestVersion}
+`);
+  console.log("Installing update...\n");
+  try {
+    execSync("npm install -g @bike4mind/cli@latest", {
+      stdio: "inherit",
+      timeout: 12e4
+    });
+    console.log(`
+Successfully updated to v${result.latestVersion}.`);
+  } catch {
+    console.error("\nUpdate failed. Try running manually:");
+    console.error("  npm install -g @bike4mind/cli@latest");
+    console.error("\nIf you get permission errors, try:");
+    console.error("  sudo npm install -g @bike4mind/cli@latest");
+    process.exit(1);
+  }
+}
+export {
+  handleUpdateCommand
+};

package/dist/create-XOEMSBER.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import {
+  createFabFile,
+  createFabFileSchema
+} from "./chunk-ERV5G6MX.js";
+import "./chunk-3SPW5FYJ.js";
+import "./chunk-NI22LIK3.js";
+import "./chunk-PFBYGCOW.js";
+export {
+  createFabFile,
+  createFabFileSchema
+};