@ollie-shop/cli 0.2.0 → 0.3.0

package/src/commands/project.ts

@@ -0,0 +1,107 @@
+import type { Command } from "@commander-js/extra-typings";
+import {
+  buildProject,
+  initProject,
+  startDevServer,
+  validateProject,
+} from "../actions/project.actions";
+import { console as cliConsole } from "../utils/console";
+
+export function registerProjectCommands(program: Command): void {
+  const projectCommand = program
+    .command("project")
+    .description("Project management commands");
+
+  projectCommand
+    .command("init")
+    .description("Initialize a new project")
+    .option("-n, --name <name>", "Project name")
+    .option("-t, --template <template>", "Project template")
+    .action(async (options) => {
+      try {
+        await initProject(
+          {
+            name: options.name,
+            template:
+              (options.template as
+                | "default"
+                | "grocery"
+                | "sales"
+                | undefined) || "default",
+            git: true,
+            install: true,
+          },
+          cliConsole,
+        );
+      } catch (error) {
+        cliConsole.error(
+          error instanceof Error ? error.message : "An error occurred",
+        );
+        process.exit(1);
+      }
+    });
+
+  projectCommand
+    .command("build")
+    .description("Build project")
+    .option("-p, --path <path>", "Project path")
+    .option("--watch", "Watch for changes")
+    .action(async (options) => {
+      try {
+        await buildProject(
+          {
+            path: options.path,
+            watch: options.watch ?? false,
+          },
+          cliConsole,
+        );
+      } catch (error) {
+        cliConsole.error(
+          error instanceof Error ? error.message : "An error occurred",
+        );
+        process.exit(1);
+      }
+    });
+
+  projectCommand
+    .command("dev")
+    .description("Start development server")
+    .option("-p, --port <port>", "Port number", Number.parseInt)
+    .option("--open", "Open browser")
+    .action(async (options) => {
+      try {
+        await startDevServer(
+          {
+            port: options.port ?? 3000,
+            open: options.open ?? false,
+          },
+          cliConsole,
+        );
+      } catch (error) {
+        cliConsole.error(
+          error instanceof Error ? error.message : "An error occurred",
+        );
+        process.exit(1);
+      }
+    });
+
+  projectCommand
+    .command("validate")
+    .description("Validate project")
+    .option("-p, --path <path>", "Project path")
+    .action(async (options) => {
+      try {
+        await validateProject(
+          {
+            path: options.path,
+          },
+          cliConsole,
+        );
+      } catch (error) {
+        cliConsole.error(
+          error instanceof Error ? error.message : "An error occurred",
+        );
+        process.exit(1);
+      }
+    });
+}

package/src/commands/store-version.ts

@@ -0,0 +1,242 @@
+import type { Command } from "@commander-js/extra-typings";
+import { z } from "zod";
+import * as versionActions from "../actions/version.actions";
+import { buildCommand, buildCommandGroup } from "../utils/command-builder";
+import { COMMON_OPTIONS, parseUUID } from "../utils/command-parser";
+import { console as cliConsole } from "../utils/console";
+
+const StoreVersionCreateOptionsSchema = z.object({
+  store: z.string().uuid("Invalid store ID format"),
+  name: z.string().min(1, "Version name is required"),
+  template: z.string().optional(),
+  active: z.boolean().optional(),
+});
+
+const StoreVersionListOptionsSchema = z.object({
+  store: z.string().uuid("Invalid store ID format"),
+});
+
+export function registerStoreVersionCommands(program: Command): void {
+  const cmd = buildCommandGroup(
+    program,
+    "store-version",
+    "Manage store versions",
+    ["sv"],
+  );
+
+  // Create version command
+  buildCommand(cmd, {
+    name: "create",
+    description: "Create a new version for a store",
+    options: [
+      COMMON_OPTIONS.storeId,
+      COMMON_OPTIONS.versionName,
+      COMMON_OPTIONS.template,
+      COMMON_OPTIONS.active,
+      COMMON_OPTIONS.noActive,
+    ],
+    schema: StoreVersionCreateOptionsSchema,
+    examples: [
+      {
+        description: "Create an active version",
+        command:
+          "ollieshop store-version create --store 123e4567-e89b-12d3-a456-426614174000 --name v2.0.0",
+      },
+      {
+        description: "Create version with grocery template",
+        command:
+          "ollieshop store-version create --store 123e4567-e89b-12d3-a456-426614174000 --name grocery-v1 --template grocery",
+      },
+      {
+        description: "Create inactive version for testing",
+        command:
+          "ollieshop store-version create --store 123e4567-e89b-12d3-a456-426614174000 --name test-version --no-active",
+      },
+    ],
+    handler: async (options) => {
+      await versionActions.create(options);
+    },
+  });
+
+  // List versions command
+  buildCommand(cmd, {
+    name: "list",
+    description: "List all versions for a store",
+    options: [COMMON_OPTIONS.storeId],
+    schema: StoreVersionListOptionsSchema,
+    examples: [
+      {
+        description: "List all versions for a store",
+        command:
+          "ollieshop store-version list --store 123e4567-e89b-12d3-a456-426614174000",
+      },
+    ],
+    handler: async (options) => {
+      await versionActions.list(options);
+    },
+  });
+
+  // Get version command with argument parser
+  const _getCmd = cmd
+    .command("get <versionId>")
+    .description("Get version details")
+    .addHelpText("after", "\nExamples:")
+    .addHelpText("after", "  Get version details:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version get 987fcdeb-51a2-43b7-9abc-123456789012",
+    )
+    .action(async (versionId) => {
+      try {
+        const validated = parseUUID(versionId);
+        await versionActions.get(validated);
+      } catch (error) {
+        if (error instanceof Error) {
+          cliConsole.error(`❌ ${error.message}`);
+          if (error.message.includes("UUID")) {
+            cliConsole.info("💡 Version IDs must be in UUID format");
+            cliConsole.log("   Example: 123e4567-e89b-12d3-a456-426614174000");
+          }
+        } else {
+          cliConsole.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Set default version command
+  const _setDefaultCmd = cmd
+    .command("set-default <versionId>")
+    .description("Set a version as the default for the store")
+    .addHelpText("after", "\nExamples:")
+    .addHelpText("after", "  Set version as default:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version set-default 987fcdeb-51a2-43b7-9abc-123456789012",
+    )
+    .action(async (versionId) => {
+      try {
+        const validated = parseUUID(versionId);
+        await versionActions.setDefault(validated);
+      } catch (error) {
+        if (error instanceof Error) {
+          cliConsole.error(`❌ ${error.message}`);
+        } else {
+          cliConsole.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Activate version command
+  const _activateCmd = cmd
+    .command("activate <versionId>")
+    .description("Activate a version")
+    .addHelpText("after", "\nExamples:")
+    .addHelpText("after", "  Activate a version:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version activate 987fcdeb-51a2-43b7-9abc-123456789012",
+    )
+    .action(async (versionId) => {
+      try {
+        const validated = parseUUID(versionId);
+        await versionActions.activate(validated);
+      } catch (error) {
+        if (error instanceof Error) {
+          cliConsole.error(`❌ ${error.message}`);
+        } else {
+          cliConsole.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Deactivate version command
+  const _deactivateCmd = cmd
+    .command("deactivate <versionId>")
+    .description("Deactivate a version")
+    .addHelpText("after", "\nExamples:")
+    .addHelpText("after", "  Deactivate a version:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version deactivate 987fcdeb-51a2-43b7-9abc-123456789012",
+    )
+    .action(async (versionId) => {
+      try {
+        const validated = parseUUID(versionId);
+        await versionActions.deactivate(validated);
+      } catch (error) {
+        if (error instanceof Error) {
+          cliConsole.error(`❌ ${error.message}`);
+        } else {
+          cliConsole.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Clone version command
+  const _cloneCmd = cmd
+    .command("clone <versionId>")
+    .description("Clone an existing version")
+    .requiredOption(
+      "-n, --name <name>",
+      "Name for the cloned version",
+      COMMON_OPTIONS.versionName.parser,
+    )
+    .addHelpText("after", "\nExamples:")
+    .addHelpText("after", "  Clone a version:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version clone 987fcdeb-51a2-43b7-9abc-123456789012 --name v2.1.0",
+    )
+    .addHelpText("after", "\n  Clone for A/B testing:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version clone 987fcdeb-51a2-43b7-9abc-123456789012 --name experiment-checkout",
+    )
+    .action(async (versionId, options) => {
+      try {
+        const validatedId = parseUUID(versionId);
+        await versionActions.clone(validatedId, options.name);
+      } catch (error) {
+        if (error instanceof Error) {
+          cliConsole.error(`❌ ${error.message}`);
+        } else {
+          cliConsole.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    });
+
+  // Delete version command
+  const _deleteCmd = cmd
+    .command("delete <versionId>")
+    .description("Delete a version")
+    .option("-f, --force", "Skip confirmation")
+    .addHelpText("after", "\nExamples:")
+    .addHelpText("after", "  Delete with confirmation:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version delete 987fcdeb-51a2-43b7-9abc-123456789012",
+    )
+    .addHelpText("after", "\n  Delete without confirmation:")
+    .addHelpText(
+      "after",
+      "  $ ollieshop store-version delete 987fcdeb-51a2-43b7-9abc-123456789012 --force",
+    )
+    .action(async (versionId, options) => {
+      try {
+        const validated = parseUUID(versionId);
+        await versionActions.deleteVersion(validated, options.force);
+      } catch (error) {
+        if (error instanceof Error) {
+          cliConsole.error(`❌ ${error.message}`);
+        } else {
+          cliConsole.error(`Error: ${String(error)}`);
+        }
+        process.exit(1);
+      }
+    });
+}

package/src/commands/version.ts

@@ -1,14 +1,51 @@
-import chalk from "chalk";
-import type { Command } from "commander";
-import { pkg } from "../utils/core";
+import type { Command } from "@commander-js/extra-typings";
+import { console as cliConsole } from "../utils/console";
+
+const pkg = require("../../package.json");
 
 export function configureVersionCommand(program: Command): void {
+  // Simple version command
   program
     .command("version")
-    .description("Display the current CLI version")
-    .action(() => {
-      console.log(
-        `${chalk.bold("Ollie Shop CLI version:")} ${chalk.cyan(pkg.version)}\n`,
-      );
+    .alias("v")
+    .description("Display CLI version and environment information")
+    .option("-d, --detailed", "Show detailed version information", false)
+    .option("-j, --json", "Output version information as JSON", false)
+    .action(async (options) => {
+      if (options.json) {
+        const versionInfo = {
+          cli: pkg.version,
+          node: process.version,
+          platform: process.platform,
+          arch: process.arch,
+        };
+        console.log(JSON.stringify(versionInfo, null, 2));
+        return;
+      }
+
+      cliConsole.info(`Ollie Shop CLI version: ${pkg.version}`);
+
+      if (options.detailed) {
+        cliConsole.log("");
+        cliConsole.log("Environment:");
+        cliConsole.log(`  Node.js: ${process.version}`);
+        cliConsole.log(`  Platform: ${process.platform}`);
+        cliConsole.log(`  Architecture: ${process.arch}`);
+
+        // Check for core package version
+        try {
+          const corePkg = require("@ollie-shop/core/package.json");
+          cliConsole.log(`  Core: v${corePkg.version}`);
+        } catch {
+          // Core package might not be available
+        }
+
+        cliConsole.log("");
+        cliConsole.log("For help, run: ollieshop --help");
+        cliConsole.log("Documentation: https://docs.ollie.shop");
+        cliConsole.log(
+          "Report issues: https://github.com/ollie-shop/cli/issues",
+        );
+      }
     });
 }

package/src/commands/whoami.ts

@@ -1,16 +1,15 @@
-import chalk from "chalk";
-import type { Command } from "commander";
+import type { Command } from "@commander-js/extra-typings";
 import { getCurrentUser } from "../utils/auth";
+import { console as cliConsole } from "../utils/console";
 import { type OllieConfig, getOllieConfig } from "../utils/store";
 
-// Reads credentials from ~/.ollie-shop/credentials.json
 async function getUserInfo(): Promise<{ email?: string; store?: OllieConfig }> {
   try {
     const user = await getCurrentUser();
     const store = await getOllieConfig();
 
     if (!user || !user.email) {
-      console.log("❌ No user authenticated");
+      cliConsole.error("No user authenticated");
       return {};
     }
 
@@ -31,21 +30,17 @@ export function configureWhoamiCommand(program: Command) {
       const { email, store } = await getUserInfo();
 
       if (!email) {
-        console.log(chalk.red("You are not authenticated"));
+        cliConsole.error("You are not authenticated");
         return;
       }
 
-      console.log();
-      console.log(
-        `${chalk.bold("You are logged in as:")} ${chalk.cyan(email)}`,
-      );
+      cliConsole.newLine();
+      cliConsole.info(`You are logged in as: ${email}`);
 
       if (store) {
-        console.log(
-          `${chalk.bold("Current store:")} ${chalk.cyan(store.platformStoreId ?? "unknown")}`,
-        );
+        cliConsole.info(`Current store: ${store.platformStoreId ?? "unknown"}`);
       }
 
-      console.log();
+      cliConsole.newLine();
     });
 }

package/src/index.ts

@@ -1,42 +1,116 @@
-import { Command } from "commander";
+#!/usr/bin/env node
+
+import { Command } from "@commander-js/extra-typings";
+import packageJson from "../package.json";
 import { registerCommands } from "./commands";
 import {
-  checkForUpdates,
-  pkg,
-  showWelcomeMessage,
-  validateProjectLocation,
-} from "./utils/core";
-
-/**
- * Creates and configures the CLI program instance
- */
-export function createProgram() {
-  const program = new Command();
-
-  program
-    .name("ollieshop")
-    .description("Ollie Shop CLI tools")
-    .version(pkg.version);
-
-  // Register CLI commands from external modules
-  registerCommands(program);
-
-  return program;
-}
+  type GlobalOptions,
+  GlobalOptionsSchema,
+} from "./schemas/command.schema";
+import { console as cliConsole } from "./utils/console";
+
+class OllieShopCLI {
+  private program = new Command();
+
+  constructor() {
+    this.setupProgram();
+    this.registerCommands();
+  }
+
+  private setupProgram(): void {
+    this.program
+      .name("ollieshop")
+      .description(
+        "Ollie Shop CLI - Build and manage your e-commerce components and functions",
+      )
+      .version(packageJson.version)
+      .option("-v, --verbose", "Enable verbose logging", false)
+      .option("-q, --quiet", "Suppress non-essential output", false)
+      .option("--no-color", "Disable colored output", false)
+      .option("-c, --config <path>", "Path to configuration file")
+      .option(
+        "--log-level <level>",
+        "Set log level (error|warn|info|debug)",
+        "info",
+      )
+      .hook("preAction", (thisCommand: Command) => {
+        this.setupGlobalOptions(thisCommand);
+      });
+  }
+
+  private setupGlobalOptions(thisCommand: Command): void {
+    try {
+      const options = thisCommand.opts();
+      const parsedOptions = this.validateGlobalOptions(options);
 
-// If this file is executed directly, initialize the CLI
-if (require.main === module) {
-  (async () => {
-    const program = createProgram();
+      cliConsole.setOptions({
+        quiet: parsedOptions.quiet,
+        verbose: parsedOptions.verbose,
+        noColor: !parsedOptions.color, // --no-color sets color to false
+      });
 
-    if (process.argv.length <= 2) {
-      await checkForUpdates();
-      showWelcomeMessage();
-      process.exit(0);
+      if (parsedOptions.verbose) {
+        process.env.DEBUG = "ollieshop:*";
+      }
+    } catch (error) {
+      cliConsole.error("Invalid global options:");
+      if (error instanceof Error) {
+        cliConsole.error(error.message);
+      }
+      process.exit(1);
     }
+  }
 
-    validateProjectLocation();
+  private validateGlobalOptions(options: unknown): GlobalOptions {
+    const result = GlobalOptionsSchema.safeParse(options);
+    if (!result.success) {
+      const errors = result.error.issues.map(
+        (issue) => `${issue.path.join(".")}: ${issue.message}`,
+      );
+      throw new Error(errors.join("\n"));
+    }
+    return result.data;
+  }
+
+  private registerCommands(): void {
+    try {
+      registerCommands(this.program);
+    } catch (error) {
+      cliConsole.error("Failed to register commands:");
+      if (error instanceof Error) {
+        cliConsole.error(error.message);
+      }
+      process.exit(1);
+    }
+  }
 
-    program.parse();
-  })();
+  async run(): Promise<void> {
+    try {
+      // Show command suggestions if no args provided
+      if (process.argv.length <= 2) {
+        const { showCommandSuggestions } = await import(
+          "./utils/command-suggestions.js"
+        );
+        showCommandSuggestions(cliConsole);
+        return;
+      }
+
+      await this.program.parseAsync();
+    } catch (error) {
+      cliConsole.error("CLI execution failed:");
+      if (error instanceof Error) {
+        cliConsole.error(error.message);
+        if (process.env.DEBUG) {
+          cliConsole.info(`Stack trace: ${error.stack || ""}`);
+        }
+      }
+      process.exit(1);
+    }
+  }
 }
+
+const cli = new OllieShopCLI();
+cli.run().catch((error) => {
+  cliConsole.error(`Unexpected error: ${error}`);
+  process.exit(1);
+});