@poetora/cli 0.1.9 → 0.1.11

package/src/services/openapi-check.service.ts

@@ -1,68 +0,0 @@
-import { getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl, validate } from '@poetora/shared';
-import * as fs from 'fs';
-import * as yaml from 'js-yaml';
-
-import { FileSystemError, ValidationError } from '../errors/index.js';
-import type { ILogger } from '../utils/index.js';
-
-/**
- * Service for OpenAPI validation
- */
-export class OpenApiCheckService {
-  constructor(private readonly logger: ILogger) {}
-
-  /**
-   * Validate OpenAPI spec from URL or local file
-   */
-  async validateSpec(filename: string, localSchema: boolean = false): Promise<void> {
-    // Check if it's a URL
-    if (isAllowedLocalSchemaUrl(filename, localSchema)) {
-      await getOpenApiDocumentFromUrl(filename);
-      this.logger.success('OpenAPI definition is valid.');
-      return;
-    }
-
-    // Warn for http:// URLs without --local-schema
-    if (filename.startsWith('http://') && !localSchema) {
-      this.logger.warn('include the --local-schema flag to check locally hosted OpenAPI files');
-      this.logger.warn('only https protocol is supported in production');
-      return;
-    }
-
-    // Read and validate local file
-    const document = await this.readLocalOpenApiFile(filename);
-
-    if (!document) {
-      throw new ValidationError(
-        'failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.'
-      );
-    }
-
-    await validate(document);
-    this.logger.success('OpenAPI definition is valid.');
-  }
-
-  /**
-   * Read OpenAPI file from local filesystem
-   */
-  private async readLocalOpenApiFile(filename: string): Promise<unknown> {
-    try {
-      const fileContents = await fs.promises.readFile(filename, 'utf-8');
-
-      // Try to parse as JSON first
-      if (filename.endsWith('.json')) {
-        return JSON.parse(fileContents);
-      }
-
-      // Try YAML parsing
-      return yaml.load(fileContents);
-    } catch (error) {
-      if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
-        throw new FileSystemError(`file not found, please check the path provided: ${filename}`);
-      }
-      throw new ValidationError(
-        `Failed to parse OpenAPI spec: ${error instanceof Error ? error.message : 'unknown error'}`
-      );
-    }
-  }
-}

package/src/services/port.service.ts

@@ -1,47 +0,0 @@
-import detect from 'detect-port';
-
-import { NoAvailablePortError } from '../errors/index.js';
-import { CLI_CONSTANTS } from '../types/index.js';
-import type { ILogger } from '../utils/index.js';
-
-/**
- * Service for handling port detection and availability checks
- */
-export class PortService {
-  constructor(private readonly logger?: ILogger) {}
-
-  /**
-   * Find an available port starting from the preferred port
-   * @param preferredPort - The preferred port to start from (defaults to 3000)
-   * @returns The first available port found
-   * @throws {NoAvailablePortError} if no port is available after MAX_ATTEMPTS tries
-   */
-  async findAvailablePort(preferredPort?: number): Promise<number> {
-    const startPort = preferredPort ?? CLI_CONSTANTS.PORT.DEFAULT;
-
-    for (let attempt = 0; attempt < CLI_CONSTANTS.PORT.MAX_ATTEMPTS; attempt++) {
-      const port = startPort + attempt;
-
-      if (await this.isPortAvailable(port)) {
-        if (attempt > 0 && this.logger) {
-          this.logger.info(`port ${startPort} is already in use. using ${port} instead`);
-        }
-        return port;
-      }
-    }
-
-    throw new NoAvailablePortError(
-      `No available port found after ${CLI_CONSTANTS.PORT.MAX_ATTEMPTS} attempts starting from ${startPort}`
-    );
-  }
-
-  /**
-   * Check if a specific port is available
-   * @param port - The port number to check
-   * @returns true if the port is available, false otherwise
-   */
-  private async isPortAvailable(port: number): Promise<boolean> {
-    const detectedPort = await detect(port);
-    return detectedPort === port;
-  }
-}

package/src/services/template.service.ts

@@ -1,203 +0,0 @@
-import { docsConfigSchema } from '@poetora/validation';
-import AdmZip from 'adm-zip';
-import * as fs from 'fs';
-import * as fse from 'fs-extra';
-import * as path from 'path';
-
-import { ExternalServiceError, FileSystemError } from '../errors/index.js';
-
-export interface DirectoryStatus {
-  exists: boolean;
-  hasContents: boolean;
-}
-
-export interface InstallTemplateParams {
-  directory: string;
-  projectName: string;
-  theme: string;
-}
-
-interface DocsConfig {
-  name: string;
-  theme: string;
-  [key: string]: unknown;
-}
-
-/**
- * Service for managing documentation templates
- */
-export class TemplateService {
-  private readonly TEMPLATE_URL = 'https://github.com/poetora/starter/archive/refs/heads/main.zip';
-  private readonly TEMP_ZIP_PATH = 'poetora-starter.zip';
-  private readonly TEMP_EXTRACT_DIR = 'poetora-starter-temp';
-
-  /**
-   * Check if directory exists and has contents
-   */
-  async checkDirectory(directory: string): Promise<DirectoryStatus> {
-    try {
-      await fse.ensureDir(directory);
-
-      const files = await fs.promises.readdir(directory);
-      const hasContents = files.length > 0;
-
-      return {
-        exists: true,
-        hasContents,
-      };
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        return {
-          exists: false,
-          hasContents: false,
-        };
-      }
-      throw new FileSystemError(`Failed to check directory: ${(error as Error).message}`);
-    }
-  }
-
-  /**
-   * Get available themes from validation package
-   */
-  getAvailableThemes(): string[] {
-    // docsConfigSchema is a discriminated union with 'theme' as the discriminator
-    // Extract theme values from each option's shape.theme field
-    const themes = docsConfigSchema.options
-      .map((option) => {
-        // Each option has a shape with theme field (ZodLiteral)
-        const themeField = (
-          option as unknown as { shape?: { theme?: { _def?: { value?: string } } } }
-        ).shape?.theme;
-        if (themeField?._def && 'value' in themeField._def) {
-          return themeField._def.value as string;
-        }
-        return null;
-      })
-      .filter((theme): theme is string => theme !== null);
-
-    return themes.length > 0 ? themes : ['ora'];
-  }
-
-  /**
-   * Download and install template to target directory
-   */
-  async installTemplate(params: InstallTemplateParams): Promise<void> {
-    const { directory, projectName, theme } = params;
-
-    try {
-      // Download template
-      await this.downloadTemplate();
-
-      // Extract template
-      await this.extractTemplate();
-
-      // Copy files to target directory
-      await this.copyTemplateFiles(directory);
-
-      // Update configuration
-      await this.updateDocsConfig(directory, projectName, theme);
-
-      // Cleanup temporary files
-      await this.cleanup();
-    } catch (error) {
-      // Ensure cleanup on error
-      await this.cleanup();
-      throw error;
-    }
-  }
-
-  private async downloadTemplate(): Promise<void> {
-    try {
-      const response = await fetch(this.TEMPLATE_URL);
-
-      if (!response.ok) {
-        throw new ExternalServiceError(
-          `Failed to download template: HTTP ${response.status} ${response.statusText}`
-        );
-      }
-
-      const arrayBuffer = await response.arrayBuffer();
-      const buffer = Buffer.from(arrayBuffer);
-
-      await fs.promises.writeFile(this.TEMP_ZIP_PATH, buffer);
-    } catch (error) {
-      if (error instanceof ExternalServiceError) {
-        throw error;
-      }
-      throw new ExternalServiceError(`Failed to download template: ${(error as Error).message}`);
-    }
-  }
-
-  private async extractTemplate(): Promise<void> {
-    try {
-      const zip = new AdmZip(this.TEMP_ZIP_PATH);
-      zip.extractAllTo(this.TEMP_EXTRACT_DIR, true);
-    } catch (error) {
-      throw new FileSystemError(`Failed to extract template: ${(error as Error).message}`);
-    }
-  }
-
-  private async copyTemplateFiles(targetDir: string): Promise<void> {
-    try {
-      // The extracted folder is typically named "starter-main"
-      const extractedFolder = path.join(this.TEMP_EXTRACT_DIR, 'starter-main');
-
-      // Ensure target directory exists
-      await fse.ensureDir(targetDir);
-
-      // Copy all files from extracted folder to target directory
-      await fse.copy(extractedFolder, targetDir, {
-        overwrite: true,
-        errorOnExist: false,
-      });
-    } catch (error) {
-      throw new FileSystemError(`Failed to copy template files: ${(error as Error).message}`);
-    }
-  }
-
-  private async updateDocsConfig(
-    directory: string,
-    projectName: string,
-    theme: string
-  ): Promise<void> {
-    try {
-      const configPath = path.join(directory, 'docs.json');
-
-      let config: DocsConfig;
-
-      // Try to read existing config
-      try {
-        const configContent = await fs.promises.readFile(configPath, 'utf-8');
-        config = JSON.parse(configContent) as DocsConfig;
-      } catch {
-        // If file doesn't exist or is invalid, create new config
-        config = {} as DocsConfig;
-      }
-
-      // Update config with user choices
-      config.name = projectName;
-      config.theme = theme;
-
-      // Write updated config
-      await fs.promises.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
-    } catch (error) {
-      throw new FileSystemError(`Failed to update docs.json: ${(error as Error).message}`);
-    }
-  }
-
-  private async cleanup(): Promise<void> {
-    try {
-      // Remove temporary files
-      await Promise.all([
-        fse.remove(this.TEMP_ZIP_PATH).catch(() => {
-          /* ignore */
-        }),
-        fse.remove(this.TEMP_EXTRACT_DIR).catch(() => {
-          /* ignore */
-        }),
-      ]);
-    } catch {
-      // Ignore cleanup errors
-    }
-  }
-}

package/src/services/update.service.ts

@@ -1,76 +0,0 @@
-import { exec } from 'child_process';
-import { promisify } from 'util';
-import { ExternalServiceError } from '../errors/index.js';
-import type { ILogger } from '../utils/index.js';
-import type { VersionService } from './version.service.js';
-
-const execAsync = promisify(exec);
-
-/**
- * Service for CLI updates
- */
-export class UpdateService {
-  constructor(
-    private readonly logger: ILogger,
-    private readonly versionService: VersionService,
-    private readonly packageName: string
-  ) {}
-
-  /**
-   * Update CLI to latest version
-   */
-  async update(): Promise<void> {
-    const spinner = this.logger.spinner('checking for updates...');
-    spinner.start();
-
-    const existingCliVersion = this.versionService.getCliVersion();
-    const latestCliVersion = this.versionService.getLatestCliVersion(this.packageName);
-
-    const isUpToDate =
-      existingCliVersion &&
-      latestCliVersion &&
-      latestCliVersion.trim() === existingCliVersion.trim();
-
-    if (isUpToDate) {
-      spinner.succeed('already up to date');
-      return;
-    }
-
-    if (existingCliVersion && latestCliVersion.trim() !== existingCliVersion.trim()) {
-      try {
-        spinner.stop();
-        const updateSpinner = this.logger.spinner(`updating ${this.packageName} package...`);
-        updateSpinner.start();
-
-        const packageManager = await this.detectPackageManager();
-
-        if (packageManager === 'pnpm') {
-          await execAsync(`pnpm install -g ${this.packageName}@latest --silent`);
-        } else {
-          await execAsync(`npm install -g ${this.packageName}@latest --silent`);
-        }
-
-        updateSpinner.succeed(
-          `updated ${this.packageName} to version ${this.logger.highlight?.(latestCliVersion) ?? latestCliVersion}`
-        );
-      } catch (_err) {
-        throw new ExternalServiceError(`failed to update ${this.packageName}@latest`);
-      }
-    }
-  }
-
-  /**
-   * Detect which package manager was used to install the CLI
-   */
-  private async detectPackageManager(): Promise<'npm' | 'pnpm'> {
-    try {
-      const { stdout: packagePath } = await execAsync(`which ${this.packageName}`);
-      if (packagePath.includes('pnpm')) {
-        return 'pnpm';
-      }
-      return 'npm';
-    } catch (_error) {
-      return 'npm';
-    }
-  }
-}

package/src/services/version.service.ts

@@ -1,161 +0,0 @@
-import { getClientVersion, LOCAL_LINKED_CLI_VERSION } from '@poetora/previewing';
-import { execSync } from 'child_process';
-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 {
-    const y = yargs();
-    let version: string | undefined;
-
-    y.showVersion((v) => {
-      version = v;
-      return false;
-    });
-
-    if (process.env.CLI_TEST_MODE === 'true') {
-      return 'test-cli';
-    }
-
-    // When running npm link or pnpm link, the 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/start.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-import { cli } from './cli.js';
-
-const packageName = process.env.POETORA_PACKAGE_NAME ?? 'poet';
-
-cli({ packageName });

package/src/types/common.ts

@@ -1,53 +0,0 @@
-/**
- * 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

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

package/src/types/options.ts

@@ -1,42 +0,0 @@
-/**
- * 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;
-}