@ollie-shop/cli 0.3.4 → 1.0.1

package/src/types/index.ts

@@ -1,183 +0,0 @@
-/**
- * Shared type definitions for the CLI package
- */
-
-import type { Ora } from "ora";
-
-/**
- * CLI Error types
- */
-export interface CLIError extends Error {
-  code?: string;
-  context?: ErrorContext;
-}
-
-export interface NodeError extends Error {
-  code: string;
-  errno?: number;
-  syscall?: string;
-  path?: string;
-}
-
-export interface ErrorContext {
-  command?: string;
-  file?: string;
-  input?: string;
-  attemptedCommand?: string;
-  path?: string;
-}
-
-/**
- * Progress and spinner types
- */
-export type Spinner = Ora;
-
-/**
- * Command handler types
- */
-export type CommandHandler<T = unknown> = (
-  options: T,
-  console: typeof import("../utils/console").console,
-) => Promise<void>;
-
-/**
- * Build progress types
- */
-export interface BuildProgressPayload {
-  emoji?: string;
-  step?: string;
-  message?: string;
-  startTime?: number;
-}
-
-/**
- * CLI Progress bar options
- */
-export interface ProgressBarOptions {
-  barCompleteString: string;
-  barIncompleteString: string;
-  barsize: number;
-}
-
-/**
- * Progress bar params from cli-progress
- */
-export interface ProgressParams {
-  progress: number;
-  value: number;
-  total: number;
-  eta: number;
-  startTime: number;
-  stopTime: number | null;
-  duration: number;
-}
-
-/**
- * Progress bar payload that can contain custom data
- */
-export interface ProgressPayload {
-  emoji?: string;
-  step?: string;
-  message?: string;
-  startTime?: number;
-  [key: string]: unknown;
-}
-
-/**
- * Generic formatter for progress bars
- * Matches cli-progress GenericFormatter interface
- */
-export type ProgressFormatter = (
-  options: {
-    barCompleteString?: string;
-    barIncompleteString?: string;
-    barsize?: number;
-    [key: string]: unknown;
-  },
-  params: ProgressParams,
-  payload: ProgressPayload,
-) => string;
-
-/**
- * Interactive command types
- */
-export interface InteractiveChoice {
-  name: string;
-  value: string;
-  short?: string;
-}
-
-/**
- * Mock data types for development
- */
-export interface MockComponent {
-  id: string;
-  name: string;
-  slot: string;
-  version: string;
-  enabled: boolean;
-  createdAt: string;
-  type?: string;
-  description?: string;
-}
-
-export interface MockFunction {
-  id: string;
-  name: string;
-  runtime?: string;
-  version?: string;
-  enabled: boolean;
-  createdAt: string;
-  event?: string;
-  timing?: string;
-  description?: string;
-}
-
-/**
- * CLI Error with exit code for process control
- */
-export interface CLIError extends Error {
-  exitCode?: number;
-  isValidationError?: boolean;
-}
-
-/**
- * Type guards
- */
-export function isNodeError(error: unknown): error is NodeError {
-  return (
-    error instanceof Error &&
-    "code" in error &&
-    typeof (error as NodeError).code === "string"
-  );
-}
-
-export function isCLIError(error: unknown): error is CLIError {
-  return error instanceof Error && "context" in error;
-}
-
-/**
- * Command option types without index signatures
- */
-export interface BaseCommandOptions {
-  verbose?: boolean;
-  quiet?: boolean;
-  debug?: boolean;
-}
-
-export interface PathCommandOptions extends BaseCommandOptions {
-  path?: string;
-}
-
-export interface WatchCommandOptions extends PathCommandOptions {
-  watch?: boolean;
-}
-
-export interface BuildCommandOptions extends WatchCommandOptions {
-  minify?: boolean;
-  sourcemap?: boolean;
-}
-
-export interface DeployCommandOptions extends PathCommandOptions {
-  wait?: boolean;
-}

package/src/utils/__tests__/command-parser.test.ts

@@ -1,159 +0,0 @@
-import { InvalidArgumentError } from "@commander-js/extra-typings";
-import { describe, expect, it } from "vitest";
-import {
-  parseBooleanOption,
-  parseComponentName,
-  parseComponentSlot,
-  parseFunctionInvocation,
-  parseFunctionName,
-  parsePath,
-} from "../command-parser";
-
-describe("Command Parsers", () => {
-  describe("parseComponentName", () => {
-    it("should accept valid component names", () => {
-      expect(parseComponentName("header-nav")).toBe("header-nav");
-      expect(parseComponentName("shopping-cart")).toBe("shopping-cart");
-      expect(parseComponentName("product-list-2")).toBe("product-list-2");
-    });
-
-    it("should reject invalid component names", () => {
-      expect(() => parseComponentName("")).toThrow(InvalidArgumentError);
-      expect(() => parseComponentName("Test")).toThrow(
-        /lowercase with hyphens/,
-      );
-      expect(() => parseComponentName("test component")).toThrow(
-        /lowercase with hyphens/,
-      );
-      expect(() => parseComponentName("test_component")).toThrow(
-        /lowercase with hyphens/,
-      );
-      expect(() => parseComponentName("Test-Component")).toThrow(
-        /lowercase with hyphens/,
-      );
-    });
-
-    it("should provide helpful error messages", () => {
-      try {
-        parseComponentName("TestComponent");
-      } catch (error) {
-        expect(error).toBeInstanceOf(InvalidArgumentError);
-        expect(error.message).toContain("Invalid component name");
-        expect(error.message).toContain(
-          "Component names must be lowercase with hyphens only",
-        );
-        expect(error.message).toContain("Examples:");
-      }
-    });
-  });
-
-  describe("parseFunctionName", () => {
-    it("should accept valid function names", () => {
-      expect(parseFunctionName("validate-order")).toBe("validate-order");
-      expect(parseFunctionName("apply-discount")).toBe("apply-discount");
-      expect(parseFunctionName("check-inventory-v2")).toBe(
-        "check-inventory-v2",
-      );
-    });
-
-    it("should reject invalid function names", () => {
-      expect(() => parseFunctionName("")).toThrow(InvalidArgumentError);
-      expect(() => parseFunctionName("ValidateOrder")).toThrow(
-        /lowercase with hyphens/,
-      );
-      expect(() => parseFunctionName("validate order")).toThrow(
-        /lowercase with hyphens/,
-      );
-    });
-  });
-
-  describe("parseComponentSlot", () => {
-    it("should accept valid slots", () => {
-      expect(parseComponentSlot("header")).toBe("header");
-      expect(parseComponentSlot("main")).toBe("main");
-      expect(parseComponentSlot("sidebar")).toBe("sidebar");
-      expect(parseComponentSlot("footer")).toBe("footer");
-    });
-
-    it("should reject invalid slots", () => {
-      expect(() => parseComponentSlot("invalid")).toThrow(InvalidArgumentError);
-      expect(() => parseComponentSlot("")).toThrow(InvalidArgumentError);
-    });
-
-    it("should provide list of valid slots in error", () => {
-      try {
-        parseComponentSlot("invalid");
-      } catch (error) {
-        expect(error.message).toContain(
-          "Valid slots: header, footer, sidebar, main, checkout-summary, payment-method, shipping-method, customer-info, order-confirmation",
-        );
-      }
-    });
-  });
-
-  describe("parseFunctionInvocation", () => {
-    it("should accept valid invocations", () => {
-      expect(parseFunctionInvocation("request")).toBe("request");
-      expect(parseFunctionInvocation("response")).toBe("response");
-    });
-
-    it("should reject invalid invocations", () => {
-      expect(() => parseFunctionInvocation("invalid")).toThrow(
-        InvalidArgumentError,
-      );
-    });
-
-    it("should provide list of valid invocations in error", () => {
-      try {
-        parseFunctionInvocation("invalid");
-      } catch (error) {
-        expect(error.message).toContain("request");
-        expect(error.message).toContain("response");
-      }
-    });
-  });
-
-  describe("parseBooleanOption", () => {
-    it("should parse truthy values", () => {
-      expect(parseBooleanOption("true")).toBe(true);
-      expect(parseBooleanOption("TRUE")).toBe(true);
-      expect(parseBooleanOption("yes")).toBe(true);
-      expect(parseBooleanOption("y")).toBe(true);
-      expect(parseBooleanOption("1")).toBe(true);
-    });
-
-    it("should parse falsy values", () => {
-      expect(parseBooleanOption("false")).toBe(false);
-      expect(parseBooleanOption("FALSE")).toBe(false);
-      expect(parseBooleanOption("no")).toBe(false);
-      expect(parseBooleanOption("n")).toBe(false);
-      expect(parseBooleanOption("0")).toBe(false);
-    });
-
-    it("should reject invalid values", () => {
-      expect(() => parseBooleanOption("maybe")).toThrow(InvalidArgumentError);
-      expect(() => parseBooleanOption("")).toThrow(InvalidArgumentError);
-    });
-
-    it("should provide helpful error message", () => {
-      try {
-        parseBooleanOption("invalid");
-      } catch (error) {
-        expect(error.message).toContain("Use true/false, yes/no, or 1/0");
-      }
-    });
-  });
-
-  describe("parsePath", () => {
-    it("should accept valid paths", () => {
-      expect(parsePath("./components/header")).toBe("./components/header");
-      expect(parsePath("/absolute/path")).toBe("/absolute/path");
-      expect(parsePath("relative/path")).toBe("relative/path");
-    });
-
-    it("should reject empty paths", () => {
-      expect(() => parsePath("")).toThrow(InvalidArgumentError);
-      expect(() => parsePath("")).toThrow(/cannot be empty/);
-    });
-  });
-});

package/src/utils/__tests__/command-suggestions.test.ts

@@ -1,185 +0,0 @@
-import * as fs from "node:fs";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { CommandSuggestions } from "../command-suggestions";
-import type { CliConsole } from "../console";
-
-// Mock the fs module
-vi.mock("fs");
-
-describe("CommandSuggestions", () => {
-  let mockConsole: CliConsole;
-  let suggestions: CommandSuggestions;
-
-  beforeEach(() => {
-    // Create a mock console
-    mockConsole = {
-      log: vi.fn(),
-      error: vi.fn(),
-      warn: vi.fn(),
-      info: vi.fn(),
-      success: vi.fn(),
-      dim: vi.fn(),
-      bold: vi.fn(),
-      list: vi.fn(),
-      table: vi.fn(),
-      json: vi.fn(),
-      spinner: vi.fn(),
-      confirm: vi.fn(),
-      prompt: vi.fn(),
-      setOptions: vi.fn(),
-      group: vi.fn(),
-      groupEnd: vi.fn(),
-      separator: vi.fn(),
-      suggestions: vi.fn(),
-      debug: vi.fn(),
-      nextSteps: vi.fn(),
-    };
-    suggestions = new CommandSuggestions(mockConsole);
-    vi.clearAllMocks();
-
-    // Mock process.cwd
-    vi.spyOn(process, "cwd").mockReturnValue("/test/project");
-  });
-
-  describe("show", () => {
-    it("should show suggestions for component directory", () => {
-      // Mock component detection
-      vi.mocked(fs.existsSync).mockImplementation((path) => {
-        if (path.toString().includes("package.json")) return true;
-        if (path.toString().includes("meta.json")) return true;
-        if (path.toString().includes("index.tsx")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue(
-        JSON.stringify({ type: "component", name: "header-nav" }),
-      );
-
-      suggestions.show();
-
-      // Check context display
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("You're in a component directory: header-nav"),
-      );
-
-      // Check component commands
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Common commands for this component:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("validate"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("build"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("deploy"),
-      );
-
-      // Check tip
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Run 'ollieshop dev' to start developing"),
-      );
-    });
-
-    it("should show suggestions for function directory", () => {
-      // Mock function detection - ensure we ONLY return true for function files
-      vi.mocked(fs.existsSync).mockImplementation((path) => {
-        const pathStr = path.toString();
-        // Check for function-specific files
-        const isFunctionFile =
-          pathStr.includes("package.json") ||
-          pathStr.includes("meta.json") ||
-          (pathStr.includes("index.ts") && !pathStr.includes("index.tsx"));
-        return isFunctionFile;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue(
-        JSON.stringify({ type: "function", name: "validate-order" }),
-      );
-
-      suggestions.show();
-
-      // Check context display
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "You're in a function directory: validate-order",
-        ),
-      );
-
-      // Check function commands
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Common commands for this function:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("test"),
-      );
-
-      // Check tip
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Run 'ollieshop test' to test this function"),
-      );
-    });
-
-    it("should show suggestions for project root", () => {
-      // Mock project root detection
-      vi.mocked(fs.existsSync).mockImplementation((path) => {
-        if (path.toString().includes("components")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.statSync).mockReturnValue({
-        isDirectory: () => true,
-      } as fs.Stats);
-
-      suggestions.show();
-
-      // Check context display
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("You're in the project root"),
-      );
-
-      // Check general commands
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Common commands:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("component create"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("function create"),
-      );
-
-      // Check tip
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "Navigate to a component with 'cd components/<name>'",
-        ),
-      );
-    });
-
-    it("should show recent commands for component", () => {
-      // Mock component detection
-      vi.mocked(fs.existsSync).mockImplementation((path) => {
-        if (path.toString().includes("package.json")) return true;
-        if (path.toString().includes("meta.json")) return true;
-        if (path.toString().includes("index.tsx")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue(
-        JSON.stringify({ type: "component" }),
-      );
-
-      suggestions.show();
-
-      // Check recent commands section
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Recent commands:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("validate --fix"),
-      );
-    });
-  });
-});