@ollie-shop/cli 0.3.4 → 1.0.1

package/src/utils/__tests__/console.test.ts

@@ -1,192 +0,0 @@
-import chalk from "chalk";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { Console } from "../console";
-
-// Mock chalk
-vi.mock("chalk", () => ({
-  default: {
-    green: vi.fn((str: string) => `[GREEN]${str}[/GREEN]`),
-    red: Object.assign(
-      vi.fn((str: string) => `[RED]${str}[/RED]`),
-      {
-        bold: vi.fn((str: string) => `[RED-BOLD]${str}[/RED-BOLD]`),
-      },
-    ),
-    yellow: vi.fn((str: string) => `[YELLOW]${str}[/YELLOW]`),
-    blue: Object.assign(
-      vi.fn((str: string) => `[BLUE]${str}[/BLUE]`),
-      {
-        bold: vi.fn((str: string) => `[BLUE-BOLD]${str}[/BLUE-BOLD]`),
-      },
-    ),
-    gray: vi.fn((str: string) => `[GRAY]${str}[/GRAY]`),
-    cyan: vi.fn((str: string) => `[CYAN]${str}[/CYAN]`),
-    level: 0,
-  },
-}));
-
-// Mock ora
-vi.mock("ora", () => ({
-  default: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn().mockReturnThis(),
-    fail: vi.fn().mockReturnThis(),
-    warn: vi.fn().mockReturnThis(),
-    stop: vi.fn().mockReturnThis(),
-  })),
-}));
-
-describe("Console Class", () => {
-  let consoleInstance: Console;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.spyOn(global.console, "log").mockImplementation(() => {
-      // Intentionally empty for test isolation
-    });
-    vi.spyOn(global.console, "error").mockImplementation(() => {
-      // Intentionally empty for test isolation
-    });
-    consoleInstance = new Console();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe("setOptions", () => {
-    it("should set noColor option", () => {
-      // Act
-      consoleInstance.setOptions({ noColor: true });
-
-      // Assert
-      expect(chalk.level).toBe(0);
-    });
-  });
-
-  describe("success", () => {
-    it("should log success message in green", () => {
-      // Act
-      consoleInstance.success("Operation completed");
-
-      // Assert
-      expect(global.console.log).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "[BLUE-BOLD][ollie][/BLUE-BOLD] [GREEN]✓[/GREEN] [GREEN]Operation completed[/GREEN]",
-        ),
-      );
-    });
-  });
-
-  describe("error", () => {
-    it("should log error message in red", () => {
-      // Act
-      consoleInstance.error("Operation failed");
-
-      // Assert
-      expect(global.console.error).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "[BLUE-BOLD][ollie][/BLUE-BOLD] [RED]✗[/RED] [RED-BOLD]Operation failed[/RED-BOLD]",
-        ),
-      );
-    });
-  });
-
-  describe("info", () => {
-    it("should log info message", () => {
-      // Act
-      consoleInstance.info("Information message");
-
-      // Assert
-      expect(global.console.log).toHaveBeenCalledWith(
-        expect.stringContaining("Information message"),
-      );
-    });
-  });
-
-  describe("warn", () => {
-    it("should log warning message in yellow", () => {
-      // Act
-      consoleInstance.warn("Warning message");
-
-      // Assert
-      expect(global.console.warn).toHaveBeenCalledWith(
-        expect.stringContaining(
-          "[BLUE-BOLD][ollie][/BLUE-BOLD] [YELLOW]⚠[/YELLOW] [YELLOW]Warning message[/YELLOW]",
-        ),
-      );
-    });
-  });
-
-  describe("hint", () => {
-    it("should log hint message in gray", () => {
-      // Act
-      consoleInstance.hint("Hint message");
-
-      // Assert
-      expect(global.console.log).toHaveBeenCalledWith(
-        expect.stringContaining("[GRAY]Hint message[/GRAY]"),
-      );
-    });
-  });
-
-  describe("spinner", () => {
-    it("should create and return a spinner", () => {
-      // Act
-      const spinner = consoleInstance.spinner("Loading...");
-
-      // Assert
-      expect(spinner).toBeDefined();
-      expect(spinner.start).toBeDefined();
-    });
-  });
-
-  describe("quiet mode", () => {
-    it("should not log messages when quiet mode is enabled", () => {
-      // Arrange
-      consoleInstance.setOptions({ quiet: true });
-
-      // Act
-      consoleInstance.info("Should not appear");
-      consoleInstance.success("Should not appear");
-      consoleInstance.warn("Should not appear");
-
-      // Assert
-      expect(global.console.log).not.toHaveBeenCalled();
-    });
-
-    it("should still log errors in quiet mode", () => {
-      // Arrange
-      consoleInstance.setOptions({ quiet: true });
-
-      // Act
-      consoleInstance.error("Error should appear");
-
-      // Assert
-      expect(global.console.error).toHaveBeenCalled();
-    });
-  });
-
-  describe("verbose mode", () => {
-    it("should log debug messages when verbose mode is enabled", () => {
-      // Arrange
-      consoleInstance.setOptions({ verbose: true });
-
-      // Act
-      consoleInstance.debug("Debug message");
-
-      // Assert
-      expect(global.console.log).toHaveBeenCalledWith(
-        expect.stringContaining("[GRAY]Debug message[/GRAY]"),
-      );
-    });
-
-    it("should not log debug messages when verbose mode is disabled", () => {
-      // Act
-      consoleInstance.debug("Debug message");
-
-      // Assert
-      expect(global.console.log).not.toHaveBeenCalled();
-    });
-  });
-});

package/src/utils/__tests__/context-detector.test.ts

@@ -1,258 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { detectProjectContext, getContextualPath } from "../context-detector";
-
-// Mock fs module
-vi.mock("fs", () => ({
-  existsSync: vi.fn(),
-  readFileSync: vi.fn(),
-  statSync: vi.fn(),
-}));
-
-describe("Context Detector", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe("detectProjectContext", () => {
-    it("should detect component directory by meta.json", () => {
-      const mockPath = "/project/components/header";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue(
-        JSON.stringify({
-          type: "component",
-          name: "header",
-        }),
-      );
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("component");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBe("header");
-    });
-
-    it("should detect component directory by index.tsx", () => {
-      const mockPath = "/project/components/footer";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        if (p === path.join(mockPath, "index.tsx")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue("{}");
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("component");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBe("footer");
-    });
-
-    it("should detect function directory by meta.json", () => {
-      const mockPath = "/project/functions/validate-order";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue(
-        JSON.stringify({
-          type: "function",
-          name: "validate-order",
-        }),
-      );
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("function");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBe("validate-order");
-    });
-
-    it("should detect function directory by index.ts", () => {
-      const mockPath = "/project/functions/process-payment";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        if (p === path.join(mockPath, "index.ts")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue("{}");
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("function");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBe("process-payment");
-    });
-
-    it("should detect project root with components directory", () => {
-      const mockPath = "/project";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "components")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.statSync).mockReturnValue({
-        isDirectory: () => true,
-      } as fs.Stats);
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("unknown");
-      expect(result.path).toBe(mockPath);
-      expect(result.parentPath).toBe(mockPath);
-    });
-
-    it("should detect when inside components/name directory structure", () => {
-      const mockPath = "/project/components/my-component";
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("component");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBe("my-component");
-    });
-
-    it("should detect when inside functions/name directory structure", () => {
-      const mockPath = "/project/functions/my-function";
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("function");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBe("my-function");
-    });
-
-    it("should return unknown for unrecognized directory", () => {
-      const mockPath = "/some/random/path";
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      const result = detectProjectContext(mockPath);
-
-      expect(result.type).toBe("unknown");
-      expect(result.path).toBe(mockPath);
-      expect(result.name).toBeUndefined();
-    });
-
-    it("should handle invalid meta.json gracefully", () => {
-      const mockPath = "/project/components/broken";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        if (p === path.join(mockPath, "index.tsx")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
-
-      const result = detectProjectContext(mockPath);
-
-      // Should fall back to file detection
-      expect(result.type).toBe("component");
-      expect(result.path).toBe(mockPath);
-    });
-  });
-
-  describe("getContextualPath", () => {
-    it("should return explicit path when provided", () => {
-      const explicitPath = "/explicit/path";
-      const result = getContextualPath(explicitPath, "component");
-
-      expect(result).toBe(explicitPath);
-    });
-
-    it("should return current directory when in matching context", () => {
-      const mockPath = "/project/components/header";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        if (p === path.join(mockPath, "index.tsx")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue("{}");
-
-      // Mock process.cwd to return our test path
-      const originalCwd = process.cwd;
-      process.cwd = vi.fn().mockReturnValue(mockPath);
-
-      const result = getContextualPath(undefined, "component");
-
-      expect(result).toBe(mockPath);
-
-      process.cwd = originalCwd;
-    });
-
-    it("should throw error when in parent directory", () => {
-      const mockPath = "/project";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "components")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.statSync).mockReturnValue({
-        isDirectory: () => true,
-      } as fs.Stats);
-
-      // Mock process.cwd to return our test path
-      const originalCwd = process.cwd;
-      process.cwd = vi.fn().mockReturnValue(mockPath);
-
-      expect(() => getContextualPath(undefined, "component")).toThrowError(
-        /No component found in current directory/,
-      );
-
-      process.cwd = originalCwd;
-    });
-
-    it("should throw error when in wrong context type", () => {
-      const mockPath = "/project/functions/my-function";
-      vi.mocked(fs.existsSync).mockImplementation((p) => {
-        if (p === path.join(mockPath, "package.json")) return true;
-        if (p === path.join(mockPath, "meta.json")) return true;
-        if (p === path.join(mockPath, "index.ts")) return true;
-        return false;
-      });
-
-      vi.mocked(fs.readFileSync).mockReturnValue("{}");
-
-      // Mock process.cwd to return our test path
-      const originalCwd = process.cwd;
-      process.cwd = vi.fn().mockReturnValue(mockPath);
-
-      expect(() => getContextualPath(undefined, "component")).toThrowError(
-        /Current directory appears to be a function, not a component/,
-      );
-
-      process.cwd = originalCwd;
-    });
-
-    it("should return current directory for unknown context", () => {
-      const mockPath = "/some/random/path";
-      vi.mocked(fs.existsSync).mockReturnValue(false);
-
-      // Mock process.cwd to return our test path
-      const originalCwd = process.cwd;
-      process.cwd = vi.fn().mockReturnValue(mockPath);
-
-      const result = getContextualPath(undefined, "component");
-
-      expect(result).toBe(mockPath);
-
-      process.cwd = originalCwd;
-    });
-  });
-});

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

@@ -1,137 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import type { CliConsole } from "../console";
-import {
-  EnhancedErrorHandler,
-  createContextualError,
-} from "../enhanced-error-handler";
-
-describe("EnhancedErrorHandler", () => {
-  let mockConsole: CliConsole;
-  let handler: EnhancedErrorHandler;
-
-  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(),
-    };
-    handler = new EnhancedErrorHandler(mockConsole);
-    vi.clearAllMocks();
-  });
-
-  describe("handle", () => {
-    it("should display basic error message", () => {
-      const error = new Error("Something went wrong");
-      handler.handle(error);
-
-      expect(mockConsole.error).toHaveBeenCalledWith(
-        "\n❌ Something went wrong\n",
-      );
-    });
-
-    it("should show recovery suggestions for ENOENT errors", () => {
-      const error = createContextualError("File not found", "ENOENT");
-      handler.handle(error);
-
-      expect(mockConsole.warn).toHaveBeenCalledWith("💡 Possible solutions:\n");
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Check if the path exists"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("--path"),
-      );
-    });
-
-    it("should show recovery suggestions for ECONNREFUSED errors", () => {
-      const error = createContextualError("Connection failed", "ECONNREFUSED");
-      handler.handle(error);
-
-      expect(mockConsole.warn).toHaveBeenCalledWith("💡 Possible solutions:\n");
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Check your internet connection"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("ollieshop login"),
-      );
-    });
-
-    it("should show recovery suggestions for component exists errors", () => {
-      const error = new Error("Component header-nav already exists");
-      handler.handle(error, { name: "header-nav" });
-
-      expect(mockConsole.warn).toHaveBeenCalledWith("💡 Possible solutions:\n");
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Use a different name"),
-      );
-    });
-
-    it("should display contextual information", () => {
-      const error = new Error("Test error");
-      handler.handle(error, { path: "/test/path" });
-
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("📍 Context:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Current directory:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("Target path: /test/path"),
-      );
-    });
-
-    it("should suggest similar commands for command errors", () => {
-      const error = createContextualError(
-        "Unknown command",
-        "COMMAND_NOT_FOUND",
-        {
-          attemptedCommand: "component crate",
-        },
-      );
-      handler.handle(error, { attemptedCommand: "component crate" });
-
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("💡 Did you mean:"),
-      );
-      expect(mockConsole.log).toHaveBeenCalledWith(
-        expect.stringContaining("component create"),
-      );
-    });
-  });
-
-  describe("createContextualError", () => {
-    it("should create error with code", () => {
-      const error = createContextualError("Test error", "TEST_CODE");
-
-      expect(error.message).toBe("Test error");
-      expect((error as Error & { code?: string }).code).toBe("TEST_CODE");
-    });
-
-    it("should create error with context", () => {
-      const context = { foo: "bar" };
-      const error = createContextualError("Test error", undefined, context);
-
-      expect(
-        (error as Error & { context?: Record<string, unknown> }).context,
-      ).toEqual(context);
-    });
-  });
-});

package/src/utils/__tests__/error-handler.test.ts

@@ -1,107 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { console as cliConsole } from "../console";
-import { handleError } from "../error-handler";
-import { CommandError, ValidationError } from "../errors";
-
-// Mock console with all required methods
-vi.mock("../console", () => ({
-  console: {
-    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(),
-  },
-}));
-
-// Mock process.exit to follow CLI testing best practices
-const _mockExit = vi.spyOn(process, "exit").mockImplementation((code) => {
-  throw new Error(`process.exit(${code})`);
-});
-
-describe("Error Handler", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env.DEBUG = undefined;
-  });
-
-  it("should handle CommandError with specific message", () => {
-    // Arrange
-    const error = new CommandError("Command failed", "COMMAND_FAILED");
-
-    // Act & Assert
-    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
-    expect(cliConsole.error).toHaveBeenCalledWith("\nCommand failed");
-  });
-
-  it("should handle ValidationError with details", () => {
-    // Arrange
-    const error = new ValidationError("Validation failed", [
-      { field: "name", message: "Name is required" },
-      { field: "version", message: "Invalid version format" },
-    ]);
-
-    // Act & Assert
-    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
-    expect(cliConsole.error).toHaveBeenCalledWith("\nValidation failed");
-    expect(cliConsole.dim).toHaveBeenCalledWith("\nContext:");
-    expect(cliConsole.dim).toHaveBeenCalledWith("  fields:");
-    expect(cliConsole.dim).toHaveBeenCalledWith("    name: Name is required");
-    expect(cliConsole.dim).toHaveBeenCalledWith(
-      "    version: Invalid version format",
-    );
-  });
-
-  it("should handle generic Error", () => {
-    // Arrange
-    const error = new Error("Something went wrong");
-
-    // Act & Assert
-    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
-    // Enhanced error handler formats with emoji
-    expect(cliConsole.error).toHaveBeenCalledWith(
-      "\n❌ Something went wrong\n",
-    );
-  });
-
-  it("should handle non-Error objects", () => {
-    // Arrange
-    const error = "String error";
-
-    // Act & Assert
-    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
-    expect(cliConsole.error).toHaveBeenCalledWith(
-      "\nAn unexpected error occurred",
-    );
-    expect(cliConsole.dim).toHaveBeenCalledWith("String error");
-  });
-
-  it("should show debug information when NODE_ENV is development", () => {
-    // Arrange
-    process.env.DEBUG = "1";
-    const error = new Error("Debug error");
-    error.stack = "Error: Debug error\n    at test.js:1:1";
-
-    // Act & Assert
-    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
-    // Enhanced error handler shows context instead of stack trace in dim
-    expect(cliConsole.log).toHaveBeenCalledWith(
-      expect.stringContaining("📍 Context:"),
-    );
-  });
-});