@ollie-shop/cli 0.2.0 → 0.3.0

package/src/utils/enhanced-error-handler.ts

@@ -0,0 +1,264 @@
+import chalk from "chalk";
+import type { ErrorContext } from "../types";
+import { isNodeError } from "../types";
+import type { CliConsole } from "./console.js";
+import { detectProjectContext } from "./context-detector.js";
+
+interface ErrorRecovery {
+  message: string;
+  suggestions: string[];
+  commands?: string[];
+}
+
+export class EnhancedErrorHandler {
+  constructor(private console: CliConsole) {}
+
+  /**
+   * Common error patterns with recovery suggestions
+   */
+  private readonly errorPatterns = new Map<string | RegExp, ErrorRecovery>([
+    [
+      "ENOENT",
+      {
+        message: "File or directory not found",
+        suggestions: [
+          "Check if the path exists",
+          "Use --path to specify the correct location",
+        ],
+        commands: ["ls", "pwd"],
+      },
+    ],
+    [
+      "EACCES",
+      {
+        message: "Permission denied",
+        suggestions: [
+          "Check file permissions",
+          "Try running with appropriate permissions",
+        ],
+        commands: ["ls -la"],
+      },
+    ],
+    [
+      "ECONNREFUSED",
+      {
+        message: "Connection refused",
+        suggestions: [
+          "Check your internet connection",
+          "Verify your authentication",
+          "Check if backend services are running",
+        ],
+        commands: ["ollieshop login", "ollieshop status"],
+      },
+    ],
+    [
+      /Component .* already exists/,
+      {
+        message: "Component already exists",
+        suggestions: [
+          "Use a different name",
+          "Delete the existing component first",
+          "Update the existing component instead",
+        ],
+        commands: ["ollieshop component list", "rm -rf ./components/{name}"],
+      },
+    ],
+    [
+      /Invalid component name/,
+      {
+        message: "Component name validation failed",
+        suggestions: [
+          "Use lowercase letters and hyphens only",
+          "Examples: header-nav, shopping-cart, product-list",
+        ],
+      },
+    ],
+  ]);
+
+  /**
+   * Handle errors with enhanced recovery suggestions
+   */
+  handle(error: Error, context?: ErrorContext): void {
+    // Display the main error
+    this.console.error(`\n❌ ${error.message}\n`);
+
+    // Get recovery suggestions
+    const recovery = this.getRecoverySuggestions(error);
+
+    if (recovery) {
+      this.displayRecoverySuggestions(recovery, context);
+    }
+
+    // Show contextual information
+    this.displayContextualInfo(error, context);
+
+    // Suggest similar commands if applicable
+    if (this.isCommandError(error)) {
+      this.suggestSimilarCommands(context);
+    }
+  }
+
+  /**
+   * Get recovery suggestions based on error
+   */
+  private getRecoverySuggestions(error: Error): ErrorRecovery | undefined {
+    // Check error code
+    if (isNodeError(error) && this.errorPatterns.has(error.code)) {
+      return this.errorPatterns.get(error.code);
+    }
+
+    // Check error message patterns
+    for (const [pattern, recovery] of this.errorPatterns) {
+      if (pattern instanceof RegExp && pattern.test(error.message)) {
+        return recovery;
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Display recovery suggestions
+   */
+  private displayRecoverySuggestions(
+    recovery: ErrorRecovery,
+    context?: ErrorContext,
+  ): void {
+    this.console.warn("💡 Possible solutions:\n");
+
+    for (const [index, suggestion] of recovery.suggestions.entries()) {
+      // Replace placeholders in suggestions
+      const formatted = this.formatSuggestion(suggestion, context);
+      this.console.log(chalk.yellow(`  ${index + 1}. ${formatted}`));
+    }
+
+    if (recovery.commands && recovery.commands.length > 0) {
+      this.console.log(chalk.dim("\n📍 Helpful commands:"));
+      for (const cmd of recovery.commands) {
+        const formatted = this.formatSuggestion(cmd, context);
+        this.console.log(chalk.dim(`  $ ${formatted}`));
+      }
+    }
+  }
+
+  /**
+   * Display contextual information
+   */
+  private displayContextualInfo(_error: Error, context?: ErrorContext): void {
+    const projectContext = detectProjectContext();
+
+    this.console.log(chalk.dim("\n📍 Context:"));
+    this.console.log(chalk.dim(`  Current directory: ${process.cwd()}`));
+
+    if (projectContext.type !== "unknown") {
+      this.console.log(chalk.dim(`  Project type: ${projectContext.type}`));
+      if (projectContext.name) {
+        this.console.log(
+          chalk.dim(`  ${projectContext.type} name: ${projectContext.name}`),
+        );
+      }
+    }
+
+    if (context?.path) {
+      this.console.log(chalk.dim(`  Target path: ${context.path}`));
+    }
+  }
+
+  /**
+   * Format suggestion with context values
+   */
+  private formatSuggestion(suggestion: string, context?: ErrorContext): string {
+    if (!context) return suggestion;
+
+    return suggestion.replace(/{(\w+)}/g, (match, key) => {
+      const value = context[key as keyof ErrorContext];
+      return typeof value === "string" ? value : match;
+    });
+  }
+
+  /**
+   * Check if this is a command-related error
+   */
+  private isCommandError(error: Error): boolean {
+    return (
+      error.message.includes("Unknown command") ||
+      error.message.includes("not found") ||
+      (isNodeError(error) && error.code === "COMMAND_NOT_FOUND")
+    );
+  }
+
+  /**
+   * Suggest similar commands
+   */
+  private suggestSimilarCommands(context?: ErrorContext): void {
+    if (!context?.attemptedCommand) return;
+
+    const suggestions = this.findSimilarCommands(
+      String(context.attemptedCommand),
+    );
+
+    if (suggestions.length > 0) {
+      this.console.log(chalk.dim("\n💡 Did you mean:"));
+      for (const cmd of suggestions) {
+        this.console.log(chalk.dim(`  $ ollieshop ${cmd}`));
+      }
+    }
+  }
+
+  /**
+   * Find similar commands using basic string matching
+   */
+  private findSimilarCommands(attempted: string): string[] {
+    const commands = [
+      "component create",
+      "component validate",
+      "component build",
+      "component deploy",
+      "component list",
+      "function create",
+      "function validate",
+      "function build",
+      "function test",
+      "function deploy",
+      "store-version create",
+      "store-version list",
+      "template list",
+      "login",
+      "whoami",
+    ];
+
+    return commands
+      .filter((cmd) => {
+        // Simple similarity check
+        const cmdParts = cmd.toLowerCase().split(" ");
+        const attemptedParts = attempted.toLowerCase().split(" ");
+
+        // Check if any part matches
+        return cmdParts.some((part) =>
+          attemptedParts.some(
+            (aPart) => part.startsWith(aPart) || aPart.startsWith(part),
+          ),
+        );
+      })
+      .slice(0, 3); // Show top 3 suggestions
+  }
+}
+
+/**
+ * Create an error with additional context
+ */
+export function createContextualError(
+  message: string,
+  code?: string,
+  context?: Record<string, unknown>,
+): Error {
+  const error = new Error(message) as Error & {
+    code?: string;
+    context?: Record<string, unknown>;
+  };
+
+  if (code) error.code = code;
+  if (context) error.context = context;
+
+  return error;
+}

package/src/utils/error-handler.ts

@@ -0,0 +1,60 @@
+import type { ErrorContext } from "../types";
+import { console as cliConsole } from "./console";
+import { EnhancedErrorHandler } from "./enhanced-error-handler.js";
+import { OllieShopCLIError, type RecoveryAction } from "./errors";
+
+function handleOllieShopError(error: OllieShopCLIError): void {
+  cliConsole.error(`\n${error.message}`);
+
+  if (error.details) {
+    displayErrorDetails(error.details);
+  }
+
+  if (error.suggestions && error.suggestions.length > 0) {
+    displayRecoveryActions(error.suggestions);
+  }
+}
+
+function displayErrorDetails(details: ErrorContext): void {
+  cliConsole.dim("\nContext:");
+  for (const [key, value] of Object.entries(details)) {
+    if (key === "fields" && Array.isArray(value)) {
+      displayFieldErrors(value);
+    } else {
+      cliConsole.dim(`  ${key}: ${value}`);
+    }
+  }
+}
+
+function displayFieldErrors(
+  fields: Array<{ field: string; message: string }>,
+): void {
+  cliConsole.dim("  fields:");
+  for (const field of fields) {
+    cliConsole.dim(`    ${field.field}: ${field.message}`);
+  }
+}
+
+function displayRecoveryActions(actions: RecoveryAction[]): void {
+  cliConsole.info("\nSuggestions:");
+  for (const action of actions) {
+    cliConsole.dim(`  • ${action.description}`);
+    if (action.command) {
+      cliConsole.dim(`    $ ${action.command}`);
+    }
+  }
+}
+
+export function handleError(error: unknown, context?: ErrorContext): never {
+  if (error instanceof OllieShopCLIError) {
+    handleOllieShopError(error);
+  } else if (error instanceof Error) {
+    const enhancedHandler = new EnhancedErrorHandler(cliConsole);
+    enhancedHandler.handle(error, context);
+  } else {
+    cliConsole.error("\nAn unexpected error occurred");
+    cliConsole.dim(String(error));
+  }
+
+  process.exit(1);
+}

package/src/utils/errors.ts

@@ -0,0 +1,125 @@
+import type { ZodError } from "zod";
+import type { ErrorContext } from "../types";
+
+export interface RecoveryAction {
+  description: string;
+  command?: string;
+}
+
+export class OllieShopCLIError extends Error {
+  public readonly context: ErrorContext;
+  public readonly recoveryActions: RecoveryAction[];
+
+  constructor(
+    message: string,
+    context: ErrorContext = {},
+    recoveryActions: RecoveryAction[] = [],
+  ) {
+    super(message);
+    this.name = "OllieShopCLIError";
+    this.context = context;
+    this.recoveryActions = recoveryActions;
+  }
+
+  get details(): ErrorContext {
+    return this.context;
+  }
+
+  get suggestions(): RecoveryAction[] {
+    return this.recoveryActions;
+  }
+
+  static fromZodError(
+    error: ZodError,
+    context: ErrorContext = {},
+  ): OllieShopCLIError {
+    const firstIssue = error.issues[0];
+    if (!firstIssue) {
+      return new OllieShopCLIError("Validation failed", context);
+    }
+
+    const message =
+      error.issues.length > 1
+        ? `${firstIssue.message} (and ${error.issues.length - 1} more error${error.issues.length === 2 ? "" : "s"})`
+        : firstIssue.message;
+
+    return new OllieShopCLIError(message, context, [
+      { description: "Check the command documentation for valid formats" },
+    ]);
+  }
+
+  static fromUnknown(
+    error: unknown,
+    context: ErrorContext = {},
+  ): OllieShopCLIError {
+    if (error instanceof OllieShopCLIError) {
+      return error;
+    }
+
+    if (error instanceof Error) {
+      return new OllieShopCLIError(error.message, context, [
+        { description: "Check the command syntax and try again" },
+      ]);
+    }
+
+    return new OllieShopCLIError(
+      String(error) || "Unknown error occurred",
+      context,
+    );
+  }
+
+  static fileNotFound(
+    path: string,
+    context: ErrorContext = {},
+  ): OllieShopCLIError {
+    return new OllieShopCLIError(
+      `File not found: ${path}`,
+      { ...context, file: path },
+      [
+        { description: "Check if the file path is correct" },
+        { description: "Ensure the file exists in the specified location" },
+      ],
+    );
+  }
+}
+
+export const CLIError = OllieShopCLIError;
+
+/**
+ * Command execution error
+ */
+export class CommandError extends OllieShopCLIError {
+  public readonly code: string;
+
+  constructor(message: string, code: string, context: ErrorContext = {}) {
+    super(message, context);
+    this.name = "CommandError";
+    this.code = code;
+  }
+}
+
+/**
+ * Validation error with detailed field information
+ */
+export class ValidationError extends OllieShopCLIError {
+  public readonly fields: Array<{ field: string; message: string }>;
+
+  constructor(
+    message: string,
+    fields: Array<{ field: string; message: string }> = [],
+    context: ErrorContext = {},
+  ) {
+    super(message, context);
+    this.name = "ValidationError";
+    this.fields = fields;
+  }
+
+  get details(): ErrorContext & {
+    fields: Array<{ field: string; message: string }>;
+  } {
+    return {
+      ...this.context,
+      fields: this.fields,
+    };
+  }
+}

package/src/utils/interactive-builder.ts

@@ -0,0 +1,271 @@
+import { ComponentSlot } from "@ollie-shop/core";
+import chalk from "chalk";
+import inquirer from "inquirer";
+import type { ComponentDeployOptions } from "../schemas/command.schema";
+import type { InteractiveChoice, MockComponent } from "../types";
+import type { CliConsole } from "./console.js";
+
+export class InteractiveCommandBuilder {
+  constructor(private console: CliConsole) {}
+
+  /**
+   * Build component deploy command interactively
+   */
+  async buildDeployComponentCommand(): Promise<void> {
+    this.console.log(chalk.blue.bold("\n🚀 Component Deployment Wizard\n"));
+
+    try {
+      // Get available components (mock data for now)
+      const components = await this.getAvailableComponents();
+
+      const answers = await inquirer.prompt([
+        {
+          type: "list",
+          name: "component",
+          message: "Select component to deploy:",
+          choices: components.map(
+            (c): InteractiveChoice => ({
+              name: `${c.name} (${c.slot}) - v${c.version || "1.0.0"} - ${chalk.dim(
+                `Created ${new Date(c.createdAt).toLocaleDateString()}`,
+              )}`,
+              value: c.id,
+            }),
+          ),
+        },
+        {
+          type: "checkbox",
+          name: "options",
+          message: "Deployment options:",
+          choices: [
+            { name: "Wait for completion", value: "wait", checked: true },
+            { name: "Run tests before deploy", value: "test", checked: true },
+            {
+              name: "Enable verbose logging",
+              value: "verbose",
+              checked: false,
+            },
+          ],
+        },
+      ]);
+
+      // Build the command
+      let command = `ollieshop component deploy --id ${answers.component}`;
+
+      if (answers.options.includes("wait")) {
+        command += " --wait";
+      }
+
+      if (answers.options.includes("verbose")) {
+        command += " --verbose";
+      }
+
+      // Show preview
+      this.console.log(`\n${chalk.dim("[Preview] This will run:")}`);
+      this.console.log(chalk.cyan(`  ${command}\n`));
+
+      // Confirm execution
+      const { proceed } = await inquirer.prompt({
+        type: "confirm",
+        name: "proceed",
+        message: "Execute this command?",
+        default: true,
+      });
+
+      if (proceed) {
+        // Execute the command
+        this.console.log(chalk.dim("\nExecuting command...\n"));
+
+        // Import and execute the action directly
+        const { deployComponent } = await import(
+          "../actions/component.actions.js"
+        );
+        const deployOptions: ComponentDeployOptions = {
+          componentId: answers.component,
+          path: process.cwd(),
+          wait: answers.options.includes("wait"),
+        };
+        await deployComponent(deployOptions, this.console);
+      } else {
+        this.console.log(chalk.yellow("\n⚠️  Deployment cancelled"));
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "ExitPromptError") {
+        this.console.log(chalk.yellow("\n⚠️  Wizard cancelled"));
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Build component create command interactively
+   */
+  async buildCreateComponentCommand(): Promise<void> {
+    this.console.log(chalk.blue.bold("\n🎨 Component Creation Wizard\n"));
+
+    try {
+      const answers = await inquirer.prompt([
+        {
+          type: "input",
+          name: "name",
+          message: "Component name:",
+          validate: (input: string) => {
+            if (!input) return "Component name is required";
+            if (!/^[a-z0-9-]+$/.test(input)) {
+              return "Must be lowercase with hyphens only (e.g., header-nav)";
+            }
+            return true;
+          },
+          transformer: (input: string) => {
+            // Show live validation
+            if (!/^[a-z0-9-]+$/.test(input) && input) {
+              return chalk.red(input);
+            }
+            return input;
+          },
+        },
+        {
+          type: "list",
+          name: "slot",
+          message: "Component slot:",
+          choices: ComponentSlot.options.map((slot) => ({
+            name:
+              slot.charAt(0).toUpperCase() + slot.slice(1).replace(/-/g, " "),
+            value: slot,
+          })),
+          default: "main",
+        },
+        {
+          type: "list",
+          name: "language",
+          message: "Language:",
+          choices: [
+            { name: "TypeScript (recommended)", value: "typescript" },
+            { name: "JavaScript", value: "javascript" },
+          ],
+          default: "typescript",
+        },
+        {
+          type: "confirm",
+          name: "tests",
+          message: "Include test files?",
+          default: true,
+        },
+      ]);
+
+      // Build the command
+      let command = `ollieshop component create --name ${answers.name}`;
+
+      if (answers.slot !== "main") {
+        command += ` --slot ${answers.slot}`;
+      }
+
+      if (answers.language === "javascript") {
+        command += " --no-typescript";
+      }
+
+      if (!answers.tests) {
+        command += " --no-tests";
+      }
+
+      // Show preview
+      this.console.log(`\n${chalk.dim("[Preview] This will run:")}`);
+      this.console.log(chalk.cyan(`  ${command}\n`));
+
+      // Confirm execution
+      const { proceed } = await inquirer.prompt({
+        type: "confirm",
+        name: "proceed",
+        message: "Create this component?",
+        default: true,
+      });
+
+      if (proceed) {
+        // Execute the command
+        this.console.log(chalk.dim("\nCreating component...\n"));
+
+        const { createComponent } = await import(
+          "../actions/component.actions.js"
+        );
+        await createComponent(
+          {
+            name: answers.name,
+            slot: answers.slot,
+            tests: answers.tests,
+          },
+          this.console,
+        );
+      } else {
+        this.console.log(chalk.yellow("\n⚠️  Component creation cancelled"));
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name === "ExitPromptError") {
+        this.console.log(chalk.yellow("\n⚠️  Wizard cancelled"));
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * Get available components (mock for now)
+   */
+  private async getAvailableComponents(): Promise<MockComponent[]> {
+    // TODO: Replace with actual API call
+    return [
+      {
+        id: "comp_header_123",
+        name: "header-nav",
+        slot: "header",
+        version: "1.2.0",
+        enabled: true,
+        createdAt: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+        type: "ui",
+        description: "Navigation header component",
+      },
+      {
+        id: "comp_cart_456",
+        name: "shopping-cart",
+        slot: "sidebar",
+        version: "1.0.0",
+        enabled: true,
+        createdAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+        type: "ui",
+        description: "Shopping cart widget",
+      },
+      {
+        id: "comp_product_789",
+        name: "product-list",
+        slot: "main",
+        version: "2.1.0",
+        enabled: true,
+        createdAt: new Date(Date.now() - 3 * 24 * 60 * 60 * 1000).toISOString(),
+        type: "ui",
+        description: "Product listing component",
+      },
+    ];
+  }
+}
+
+/**
+ * Create an interactive command builder
+ */
+export async function runInteractiveCommand(
+  command: string,
+  console: CliConsole,
+): Promise<void> {
+  const builder = new InteractiveCommandBuilder(console);
+
+  switch (command) {
+    case "deploy":
+    case "component-deploy":
+      await builder.buildDeployComponentCommand();
+      break;
+    case "create":
+    case "component-create":
+      await builder.buildCreateComponentCommand();
+      break;
+    default:
+      console.warn(`Interactive mode not available for command: ${command}`);
+  }
+}