@poetora/cli 0.0.1 → 0.1.2

package/src/services/version.service.ts

@@ -0,0 +1,161 @@
+import { execSync } from 'node:child_process';
+import { getClientVersion, LOCAL_LINKED_CLI_VERSION } from '@poetora/previewing';
+import yargs from 'yargs';
+
+import { InvalidEnvironmentError } from '../errors/index.js';
+import { CLI_CONSTANTS, type NodeVersion, type ValidationResult } from '../types/index.js';
+
+/**
+ * Service for handling version checks and management
+ */
+export class VersionService {
+  constructor(private readonly packageName: string = 'poet') {}
+  /**
+   * Parse Node.js version string
+   */
+  parseNodeVersion(): NodeVersion {
+    let versionString = process.version;
+
+    // Remove 'v' prefix if present
+    if (versionString.charAt(0) === 'v') {
+      versionString = versionString.slice(1);
+    }
+
+    const parts = versionString.split('.');
+    const major = parseInt(parts[0] ?? '0', 10);
+    const minor = parseInt(parts[1] ?? '0', 10);
+    const patch = parseInt(parts[2] ?? '0', 10);
+
+    return {
+      major,
+      minor,
+      patch,
+      raw: versionString,
+    };
+  }
+
+  /**
+   * Check if current Node.js version is supported
+   */
+  checkNodeVersion(): ValidationResult {
+    const current = this.parseNodeVersion();
+    const { MIN_MAJOR, MIN_MINOR, MAX_MAJOR, RECOMMENDED_MAJOR, RECOMMENDED_MINOR } =
+      CLI_CONSTANTS.NODE_VERSION;
+
+    // Check if version is below minimum
+    if (current.major < MIN_MAJOR || (current.major === MIN_MAJOR && current.minor < MIN_MINOR)) {
+      return {
+        isValid: false,
+        hasWarning: false,
+        message: `${this.packageName} requires Node.js ${MIN_MAJOR}.${MIN_MINOR}.0 or higher (current version ${current.raw}). Please upgrade Node.js and try again.`,
+      };
+    }
+
+    // Check if version is above maximum
+    if (current.major > MAX_MAJOR) {
+      return {
+        isValid: false,
+        hasWarning: false,
+        message: `${this.packageName} is not supported on Node.js ${current.major}.x. Please use an LTS version (${MIN_MAJOR}-${MAX_MAJOR}).`,
+      };
+    }
+
+    // Check if version is below recommended
+    if (
+      current.major < RECOMMENDED_MAJOR ||
+      (current.major === RECOMMENDED_MAJOR && current.minor < RECOMMENDED_MINOR)
+    ) {
+      return {
+        isValid: true,
+        hasWarning: true,
+        message: `Node.js ${RECOMMENDED_MAJOR}.${RECOMMENDED_MINOR}.0 or higher is recommended for best compatibility (current: ${current.raw}).`,
+      };
+    }
+
+    // Version is good
+    return {
+      isValid: true,
+      hasWarning: false,
+    };
+  }
+
+  /**
+   * Get CLI version from package.json
+   */
+  getCliVersion(): string | undefined {
+    if (process.env.CLI_TEST_MODE === 'true') {
+      return 'test-cli';
+    }
+
+    const y = yargs();
+    let version: string | undefined;
+
+    y.showVersion((v) => {
+      version = v;
+      return false;
+    });
+
+    // Handle npm link case where version is 'unknown'
+    if (version === 'unknown') {
+      version = LOCAL_LINKED_CLI_VERSION;
+    }
+
+    return version;
+  }
+
+  /**
+   * Get client version
+   */
+  getClientVersion(): string {
+    return getClientVersion().trim();
+  }
+
+  /**
+   * Get versions of CLI and client
+   */
+  getVersions(): { cli: string | undefined; client: string } {
+    return {
+      cli: this.getCliVersion(),
+      client: this.getClientVersion(),
+    };
+  }
+
+  /**
+   * Get latest CLI version from npm registry
+   */
+  getLatestCliVersion(packageName: string): string {
+    try {
+      const version = execSync(`npm view ${packageName} version --silent`, {
+        encoding: 'utf-8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+
+      return version;
+    } catch (error) {
+      throw new Error(
+        `Failed to fetch latest version for ${packageName}: ${
+          error instanceof Error ? error.message : 'unknown error'
+        }`
+      );
+    }
+  }
+
+  /**
+   * Check if current version is up to date
+   */
+  isVersionUpToDate(currentVersion: string, latestVersion: string): boolean {
+    return currentVersion.trim() === latestVersion.trim();
+  }
+
+  /**
+   * Validate and throw if Node version is not supported
+   * @throws {InvalidEnvironmentError} if Node version is not supported
+   */
+  validateNodeVersion(): void {
+    const result = this.checkNodeVersion();
+
+    if (!result.isValid) {
+      throw new InvalidEnvironmentError(result.message ?? 'Unsupported Node.js version');
+    }
+  }
+}

package/src/types/common.ts

@@ -0,0 +1,53 @@
+/**
+ * CLI constants
+ */
+export const CLI_CONSTANTS = {
+  PORT: {
+    DEFAULT: 3000,
+    MAX_ATTEMPTS: 10,
+  },
+  NODE_VERSION: {
+    MIN_MAJOR: 18,
+    MIN_MINOR: 0,
+    MAX_MAJOR: 24,
+    MAX_MINOR: Number.MAX_SAFE_INTEGER,
+    RECOMMENDED_MAJOR: 20,
+    RECOMMENDED_MINOR: 17,
+  },
+  TIMEOUT: {
+    PROCESS_KILL: 5000,
+    LOG_RENDER: 50,
+  },
+  UPDATE: {
+    CHECK_INTERVAL: 86400000, // 24 hours
+  },
+} as const;
+
+/**
+ * Node version structure
+ */
+export interface NodeVersion {
+  major: number;
+  minor: number;
+  patch: number;
+  raw: string;
+}
+
+/**
+ * Validation result
+ */
+export interface ValidationResult {
+  isValid: boolean;
+  hasWarning: boolean;
+  message?: string;
+}
+
+/**
+ * Logger spinner interface
+ */
+export interface LoggerSpinner {
+  start(): void;
+  stop(): void;
+  succeed(message?: string): void;
+  fail(message?: string): void;
+}

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './common.js';
+export * from './options.js';

package/src/types/options.ts

@@ -0,0 +1,42 @@
+/**
+ * Options for dev command
+ */
+export interface DevOptions {
+  port?: number;
+  open?: boolean;
+  localSchema?: boolean;
+  clientVersion?: string;
+  groups?: string[];
+  disableOpenapi?: boolean;
+}
+
+/**
+ * Options for init command
+ */
+export interface InitOptions {
+  directory: string;
+}
+
+/**
+ * Options for openapi-check command
+ */
+export interface OpenApiCheckOptions {
+  filename: string;
+  localSchema?: boolean;
+}
+
+/**
+ * Options for rename command
+ */
+export interface RenameOptions {
+  from: string;
+  to: string;
+  force?: boolean;
+}
+
+/**
+ * Options for update command
+ */
+export interface UpdateOptions {
+  packageName: string;
+}

package/src/utils/console-logger.ts

@@ -0,0 +1,114 @@
+import chalk from 'chalk';
+import ora, { type Ora } from 'ora';
+
+import type { LoggerSpinner } from '../types/index.js';
+
+import type { ILogger } from './logger.interface.js';
+
+/**
+ * Console-based logger implementation using chalk for colors
+ * Provides rich colored output similar to ink but with simpler console-based approach
+ */
+export class ConsoleLogger implements ILogger {
+  info(message: string): void {
+    console.log(chalk.blue(`ℹ ${message}`));
+  }
+
+  success(message: string): void {
+    console.log(chalk.green(`✓ ${message}`));
+  }
+
+  error(message: string): void {
+    console.error(chalk.red(`✗ ${message}`));
+  }
+
+  warn(message: string): void {
+    console.warn(chalk.yellow(`⚠ ${message}`));
+  }
+
+  spinner(message: string): LoggerSpinner {
+    return new ConsoleSpinner(message);
+  }
+
+  log(message: string): void {
+    console.log(message);
+  }
+
+  /**
+   * Log with custom color
+   */
+  logColor(
+    message: string,
+    color: 'green' | 'red' | 'yellow' | 'blue' | 'cyan' | 'magenta' | 'gray'
+  ): void {
+    console.log(chalk[color](message));
+  }
+
+  /**
+   * Log bold text
+   */
+  logBold(message: string, color?: 'green' | 'red' | 'yellow' | 'blue' | 'cyan' | 'magenta'): void {
+    if (color) {
+      console.log(chalk[color].bold(message));
+    } else {
+      console.log(chalk.bold(message));
+    }
+  }
+
+  /**
+   * Log a separator line
+   */
+  logSeparator(): void {
+    console.log(chalk.gray('─'.repeat(50)));
+  }
+
+  /**
+   * Log an empty line
+   */
+  logNewLine(): void {
+    console.log();
+  }
+
+  /**
+   * Log a section header
+   */
+  logHeader(message: string): void {
+    console.log();
+    console.log(chalk.bold.cyan(message));
+    console.log();
+  }
+
+  /**
+   * Highlight text (typically numbers) with yellow color
+   */
+  highlight(text: string): string {
+    return chalk.yellow(text);
+  }
+}
+
+/**
+ * Console spinner implementation using ora
+ */
+class ConsoleSpinner implements LoggerSpinner {
+  private spinner: Ora;
+
+  constructor(message: string) {
+    this.spinner = ora(message);
+  }
+
+  start(): void {
+    this.spinner.start();
+  }
+
+  stop(): void {
+    this.spinner.stop();
+  }
+
+  succeed(message?: string): void {
+    this.spinner.succeed(message);
+  }
+
+  fail(message?: string): void {
+    this.spinner.fail(message);
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,2 @@
+export * from './console-logger.js';
+export * from './logger.interface.js';

package/src/utils/logger.interface.ts

@@ -0,0 +1,70 @@
+import type { LoggerSpinner } from '../types/index.js';
+
+/**
+ * Logger interface for CLI output
+ * Provides rich colored output capabilities
+ */
+export interface ILogger {
+  /**
+   * Log info message (blue with ℹ icon)
+   */
+  info(message: string): void;
+
+  /**
+   * Log success message (green with ✓ icon)
+   */
+  success(message: string): void;
+
+  /**
+   * Log error message (red with ✗ icon)
+   */
+  error(message: string): void;
+
+  /**
+   * Log warning message (yellow with ⚠ icon)
+   */
+  warn(message: string): void;
+
+  /**
+   * Create a spinner for long-running operations
+   */
+  spinner(message: string): LoggerSpinner;
+
+  /**
+   * Log plain message without formatting
+   */
+  log(message: string): void;
+
+  /**
+   * Log with custom color
+   */
+  logColor(
+    message: string,
+    color: 'green' | 'red' | 'yellow' | 'blue' | 'cyan' | 'magenta' | 'gray'
+  ): void;
+
+  /**
+   * Log bold text
+   */
+  logBold(message: string, color?: 'green' | 'red' | 'yellow' | 'blue' | 'cyan' | 'magenta'): void;
+
+  /**
+   * Log a separator line
+   */
+  logSeparator(): void;
+
+  /**
+   * Log an empty line
+   */
+  logNewLine(): void;
+
+  /**
+   * Log a section header
+   */
+  logHeader(message: string): void;
+
+  /**
+   * Highlight text (typically numbers) in a different color
+   */
+  highlight?(text: string): string;
+}

package/tsconfig.build.json

@@ -12,5 +12,6 @@
     "declaration": true,
     "declarationMap": false,
     "inlineSources": false
-  }
+  },
+  "exclude": ["__tests__", "**/__tests__", "**/*.test.ts", "**/*.spec.ts"]
 }

package/tsconfig.json

@@ -17,5 +17,5 @@
     "verbatimModuleSyntax": false,
     "noImplicitReturns": false
   },
-  "include": ["src/**/*.ts", "src/**/*.tsx", "__test__/**/*.ts"]
+  "include": ["src/**/*.ts", "src/**/*.tsx", "__tests__/**/*.ts"]
 }

package/.prettierignore

@@ -1,2 +0,0 @@
-/bin
-/node_modules

package/__test__/brokenLinks.test.ts

@@ -1,93 +0,0 @@
-import { getBrokenInternalLinks, MdxPath } from '@poetora/link-rot';
-import * as previewing from '@poetora/previewing';
-import { mockProcessExit } from 'vitest-mock-process';
-
-import { runCommand } from './utils';
-
-vi.mock('@poetora/link-rot', async () => {
-  const actual = await import('@poetora/link-rot');
-  return {
-    ...actual,
-    getBrokenInternalLinks: vi.fn(),
-  };
-});
-
-const addLogSpy = vi.spyOn(previewing, 'addLog');
-const clearLogsSpy = vi.spyOn(previewing, 'clearLogs');
-const processExitMock = mockProcessExit();
-
-describe('brokenLinks', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('success with no broken links', async () => {
-    vi.mocked(getBrokenInternalLinks).mockResolvedValueOnce([]);
-
-    await runCommand('broken-links');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'checking for broken links...' },
-      })
-    );
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'no broken links found' },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(0);
-  });
-
-  it('fails with broken links', async () => {
-    vi.mocked(getBrokenInternalLinks).mockResolvedValueOnce([
-      {
-        relativeDir: '.',
-        filename: 'introduction.mdx',
-        originalPath: '/api/invalid-path',
-        pathType: 'internal',
-      } as MdxPath,
-    ]);
-
-    await runCommand('broken-links');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'checking for broken links...' },
-      })
-    );
-    expect(clearLogsSpy).toHaveBeenCalled();
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: {
-          brokenLinksByFile: {
-            'introduction.mdx': ['/api/invalid-path'],
-          },
-        },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-
-  it('fails when checking throws error', async () => {
-    vi.mocked(getBrokenInternalLinks).mockRejectedValueOnce(new Error('some error'));
-
-    await runCommand('broken-links');
-
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'checking for broken links...' },
-      })
-    );
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'some error' },
-      })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-});

package/__test__/checkPort.test.ts

@@ -1,92 +0,0 @@
-import * as previewing from '@poetora/previewing';
-import inquirer from 'inquirer';
-import { mockProcessExit } from 'vitest-mock-process';
-
-import { runCommand } from './utils';
-
-vi.mock('@poetora/previewing', async () => {
-  const originalModule =
-    await vi.importActual<typeof import('@poetora/previewing')>('@poetora/previewing');
-  return {
-    ...originalModule,
-    dev: vi.fn(),
-  };
-});
-
-vi.mock('readline/promises', () => {
-  return {
-    createInterface: () => {
-      return {
-        close: () => undefined,
-        question: (question: string) => {
-          console.log(question);
-          return 'y';
-        },
-      };
-    },
-  };
-});
-
-const allowedPorts = [3000, 5002];
-
-vi.mock('detect-port', () => ({
-  default: (port: number) => (allowedPorts.includes(port) ? port : port + 1),
-}));
-
-const devSpy = vi.spyOn(previewing, 'dev');
-const addLogSpy = vi.spyOn(previewing, 'addLog');
-const processExitMock = mockProcessExit();
-
-describe('checkPort', () => {
-  let originalArgv: string[];
-
-  beforeEach(() => {
-    // Remove all cached modules, otherwise the same results are shown in subsequent tests.
-    vi.resetModules();
-
-    // mock inquirer prompt
-    vi.spyOn(inquirer, 'prompt').mockResolvedValue({ action: 'continue' });
-
-    // Keep track of original process arguments.
-    originalArgv = process.argv;
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-
-    // Set process arguments back to the original value.
-    process.argv = originalArgv;
-  });
-
-  it('should run dev command', async () => {
-    await runCommand('dev');
-
-    expect(devSpy).toHaveBeenCalledWith(expect.objectContaining({ port: 3000 }));
-  });
-
-  it('port 5000 and 5001 should be taken and 5002 should be accepted by the user and available.', async () => {
-    await runCommand('dev', '--port=5000');
-
-    expect(addLogSpy).toHaveBeenCalledTimes(2);
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'port 5000 is already in use. trying 5001 instead' },
-      })
-    );
-    expect(addLogSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        props: { message: 'port 5001 is already in use. trying 5002 instead' },
-      })
-    );
-  });
-
-  it('fails after the 10th used port', async () => {
-    await runCommand('dev', '--port=8000');
-
-    expect(addLogSpy).toHaveBeenCalledTimes(10);
-    expect(addLogSpy).toHaveBeenLastCalledWith(
-      expect.objectContaining({ props: { message: 'no available port found' } })
-    );
-    expect(processExitMock).toHaveBeenCalledWith(1);
-  });
-});