@poetora/cli 0.1.9 → 0.1.10

package/src/mdxAccessibility.ts

@@ -1,132 +0,0 @@
-import { categorizeFilePaths, getPoetIgnore } from '@poetora/prebuild';
-import { coreRemark } from '@poetora/shared';
-import fs from 'fs';
-import type { Node, Root, Text } from 'mdast';
-import type { MdxJsxFlowElement } from 'mdast-util-mdx-jsx';
-import path from 'path';
-import { visit } from 'unist-util-visit';
-
-export interface AccessibilityFixAttribute {
-  filePath: string;
-  line?: number;
-  column?: number;
-  element: 'img' | 'video' | 'a';
-  tagName: string;
-}
-
-export interface MdxAccessibilityResult {
-  missingAltAttributes: AccessibilityFixAttribute[];
-  totalFiles: number;
-  filesWithIssues: number;
-}
-
-const checkAltAttributes = (filePath: string, content: string): AccessibilityFixAttribute[] => {
-  const issues: AccessibilityFixAttribute[] = [];
-
-  const visitElements = () => {
-    return (tree: Root) => {
-      visit(tree, (node) => {
-        if (node.type === 'image') {
-          if (!node.alt || node.alt.trim() === '') {
-            issues.push({
-              filePath,
-              line: node.position?.start.line,
-              column: node.position?.start.column,
-              element: 'img',
-              tagName: 'image (markdown)',
-            });
-          }
-          return;
-        }
-
-        const mdxJsxElement = node as MdxJsxFlowElement;
-        if (mdxJsxElement.name === 'img' || mdxJsxElement.name === 'video') {
-          const altAttrIndex = mdxJsxElement.attributes.findIndex(
-            (attr) => attr.type === 'mdxJsxAttribute' && attr.name === 'alt'
-          );
-
-          const altAttribute = mdxJsxElement.attributes[altAttrIndex];
-          const hasValidAlt =
-            altAttribute &&
-            typeof altAttribute.value === 'string' &&
-            altAttribute.value.trim() !== '';
-
-          if (!hasValidAlt) {
-            issues.push({
-              filePath,
-              line: node.position?.start.line,
-              column: node.position?.start.column,
-              element: mdxJsxElement.name,
-              tagName: mdxJsxElement.name,
-            });
-          }
-        } else if (mdxJsxElement.name === 'a') {
-          const hasTextContent = (children: Node[]): boolean => {
-            return children.some((child) => {
-              if (child.type === 'text') {
-                const textNode = child as Text;
-                return textNode.value.trim() !== '';
-              }
-              if ('children' in child && Array.isArray(child.children)) {
-                return hasTextContent(child.children as Node[]);
-              }
-              return false;
-            });
-          };
-
-          if (!hasTextContent(mdxJsxElement.children as Node[])) {
-            issues.push({
-              filePath,
-              line: node.position?.start.line,
-              column: node.position?.start.column,
-              element: 'a',
-              tagName: '<a>',
-            });
-          }
-        }
-      });
-      return tree;
-    };
-  };
-
-  try {
-    coreRemark().use(visitElements).processSync(content);
-  } catch (error) {
-    console.warn(`Warning: Could not parse ${filePath}: ${error}`);
-  }
-
-  return issues;
-};
-
-export const checkMdxAccessibility = async (
-  baseDir: string = process.cwd()
-): Promise<MdxAccessibilityResult> => {
-  const poetIgnore = await getPoetIgnore(baseDir);
-  const { contentFilenames } = await categorizeFilePaths(baseDir, poetIgnore);
-  const mdxFiles: string[] = [];
-  for (const file of contentFilenames) {
-    mdxFiles.push(path.join(baseDir, file));
-  }
-  const allIssues: AccessibilityFixAttribute[] = [];
-  const filesWithIssues = new Set<string>();
-
-  for (const filePath of mdxFiles) {
-    try {
-      const content = fs.readFileSync(filePath, 'utf-8');
-      const issues = checkAltAttributes(filePath, content);
-
-      if (issues.length > 0) {
-        allIssues.push(...issues);
-        filesWithIssues.add(filePath);
-      }
-    } catch (error) {
-      console.warn(`Warning: Could not read file ${filePath}: ${error}`);
-    }
-  }
-
-  return {
-    missingAltAttributes: allIssues,
-    totalFiles: mdxFiles.length,
-    filesWithIssues: filesWithIssues.size,
-  };
-};

package/src/middlewares.ts

@@ -1,73 +0,0 @@
-import { addLog, ErrorLog } from '@poetora/previewing';
-import React from 'react';
-
-/**
- * Yargs middleware functions
- * These run before command execution
- */
-
-/**
- * Check if Node.js version is supported
- * Middleware that validates Node version before any command runs
- *
- * Minimum requirement: Node.js >= 18.0.0
- * Note: Individual commands may have stricter requirements (e.g., dev command)
- */
-export const checkNodeVersion = async (): Promise<void> => {
-  let nodeVersionString = process.version;
-  if (nodeVersionString.charAt(0) === 'v') {
-    nodeVersionString = nodeVersionString.slice(1);
-  }
-  const versionArr = nodeVersionString.split('.');
-  const versionStr = versionArr[0];
-  if (!versionStr) {
-    addLog(
-      React.createElement(ErrorLog, {
-        message: `Unable to determine Node.js version (got "${process.version}"). Please ensure you are running Node.js >= 18.0.0.`,
-      })
-    );
-    process.exit(1);
-  }
-  const majorVersion = parseInt(versionStr, 10);
-
-  if (majorVersion < 18) {
-    addLog(
-      React.createElement(ErrorLog, {
-        message: `poetora requires Node.js >= 18.0.0 (current version ${nodeVersionString}). Please upgrade Node.js and try again.`,
-      })
-    );
-    process.exit(1);
-  }
-};
-
-/**
- * Suppress common console warnings that don't affect functionality
- * Filters out known noise from dependencies
- */
-export const suppressConsoleWarnings = (): void => {
-  // Ignore tailwind warnings and punycode deprecation warning
-  const ignoredMessages = [
-    'No utility classes were detected',
-    'https://tailwindcss.com/docs/content-configuration',
-    'DeprecationWarning',
-    'punycode',
-  ];
-
-  const originalConsoleError = console.error;
-  console.error = (...args) => {
-    const message = args.join(' ');
-    if (ignoredMessages.some((ignoredMessage) => message.includes(ignoredMessage))) {
-      return;
-    }
-    originalConsoleError.apply(console, args);
-  };
-
-  const originalConsoleWarn = console.warn;
-  console.warn = (...args) => {
-    const message = args.join(' ');
-    if (ignoredMessages.some((ignoredMessage) => message.includes(ignoredMessage))) {
-      return;
-    }
-    originalConsoleWarn.apply(console, args);
-  };
-};

package/src/services/__tests__/port.service.test.ts

@@ -1,83 +0,0 @@
-import detect from 'detect-port';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { NoAvailablePortError } from '../../errors/index.js';
-import { CLI_CONSTANTS } from '../../types/index.js';
-import { PortService } from '../port.service.js';
-
-vi.mock('detect-port');
-
-describe('PortService', () => {
-  let service: PortService;
-  const mockDetect = vi.mocked(detect);
-
-  beforeEach(() => {
-    service = new PortService();
-    vi.clearAllMocks();
-  });
-
-  describe('findAvailablePort', () => {
-    it('should return preferred port when available', async () => {
-      mockDetect.mockResolvedValue(3000);
-
-      const port = await service.findAvailablePort(3000);
-
-      expect(port).toBe(3000);
-      expect(mockDetect).toHaveBeenCalledWith(3000);
-    });
-
-    it('should return default port when no preferred port specified', async () => {
-      mockDetect.mockResolvedValue(CLI_CONSTANTS.PORT.DEFAULT);
-
-      const port = await service.findAvailablePort();
-
-      expect(port).toBe(CLI_CONSTANTS.PORT.DEFAULT);
-    });
-
-    it('should try next port when first is occupied', async () => {
-      mockDetect.mockResolvedValueOnce(3001); // 3000 occupied
-      mockDetect.mockResolvedValueOnce(3001); // 3001 available
-
-      const port = await service.findAvailablePort(3000);
-
-      expect(port).toBe(3001);
-      expect(mockDetect).toHaveBeenCalledTimes(2);
-      expect(mockDetect).toHaveBeenNthCalledWith(1, 3000);
-      expect(mockDetect).toHaveBeenNthCalledWith(2, 3001);
-    });
-
-    it('should try multiple ports until finding available one', async () => {
-      // Ports 3000, 3001, 3002 are occupied
-      mockDetect.mockResolvedValueOnce(3001);
-      mockDetect.mockResolvedValueOnce(3002);
-      mockDetect.mockResolvedValueOnce(3003);
-      // Port 3003 is available
-      mockDetect.mockResolvedValueOnce(3003);
-
-      const port = await service.findAvailablePort(3000);
-
-      expect(port).toBe(3003);
-      expect(mockDetect).toHaveBeenCalledTimes(4);
-    });
-
-    it('should throw NoAvailablePortError after MAX_ATTEMPTS', async () => {
-      // All ports are occupied
-      mockDetect.mockImplementation((port) => Promise.resolve((port as number) + 1));
-
-      await expect(service.findAvailablePort(3000)).rejects.toThrow(NoAvailablePortError);
-      expect(mockDetect).toHaveBeenCalledTimes(CLI_CONSTANTS.PORT.MAX_ATTEMPTS);
-    });
-
-    it('should include start port in error message', async () => {
-      mockDetect.mockImplementation((port) => Promise.resolve((port as number) + 1));
-
-      try {
-        await service.findAvailablePort(5000);
-        expect.fail('Should have thrown error');
-      } catch (error) {
-        expect(error).toBeInstanceOf(NoAvailablePortError);
-        expect((error as NoAvailablePortError).message).toContain('5000');
-      }
-    });
-  });
-});

package/src/services/__tests__/template.service.test.ts

@@ -1,234 +0,0 @@
-import AdmZip from 'adm-zip';
-import * as fs from 'fs';
-import * as fse from 'fs-extra';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { ExternalServiceError, FileSystemError } from '../../errors/index.js';
-import { TemplateService } from '../template.service.js';
-
-vi.mock('node:fs', () => ({
-  default: {
-    promises: {
-      readdir: vi.fn(),
-      writeFile: vi.fn(),
-      readFile: vi.fn(),
-    },
-  },
-  promises: {
-    readdir: vi.fn(),
-    writeFile: vi.fn(),
-    readFile: vi.fn(),
-  },
-}));
-
-vi.mock('fs-extra');
-vi.mock('adm-zip', () => ({
-  default: vi.fn(),
-}));
-
-describe('TemplateService', () => {
-  let service: TemplateService;
-
-  beforeEach(() => {
-    service = new TemplateService();
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('checkDirectory', () => {
-    it('should return exists=true and hasContents=true for non-empty directory', async () => {
-      vi.mocked(fse.ensureDir).mockResolvedValue(undefined);
-      vi.mocked(fs.promises.readdir).mockResolvedValue([
-        'file1.txt',
-        'file2.txt',
-      ] as unknown as fs.Dirent[]);
-
-      const result = await service.checkDirectory('/test/dir');
-
-      expect(result).toEqual({
-        exists: true,
-        hasContents: true,
-      });
-      expect(fse.ensureDir).toHaveBeenCalledWith('/test/dir');
-    });
-
-    it('should return exists=true and hasContents=false for empty directory', async () => {
-      vi.mocked(fse.ensureDir).mockResolvedValue(undefined);
-      vi.mocked(fs.promises.readdir).mockResolvedValue([] as unknown as fs.Dirent[]);
-
-      const result = await service.checkDirectory('/test/empty');
-
-      expect(result).toEqual({
-        exists: true,
-        hasContents: false,
-      });
-    });
-
-    it('should return exists=false for non-existent directory on ENOENT', async () => {
-      const error = new Error('ENOENT') as NodeJS.ErrnoException;
-      error.code = 'ENOENT';
-      vi.mocked(fse.ensureDir).mockRejectedValue(error);
-
-      const result = await service.checkDirectory('/nonexistent');
-
-      expect(result).toEqual({
-        exists: false,
-        hasContents: false,
-      });
-    });
-
-    it('should throw FileSystemError for other errors', async () => {
-      vi.mocked(fse.ensureDir).mockRejectedValue(new Error('Permission denied'));
-
-      await expect(service.checkDirectory('/test/dir')).rejects.toThrow(FileSystemError);
-    });
-  });
-
-  describe('getAvailableThemes', () => {
-    it('should return available themes from docsConfigSchema', () => {
-      const themes = service.getAvailableThemes();
-
-      expect(themes).toBeInstanceOf(Array);
-      expect(themes.length).toBeGreaterThan(0);
-      expect(themes).toContain('ora');
-    });
-  });
-
-  describe('installTemplate', () => {
-    const mockFetch = vi.fn();
-    const originalFetch = global.fetch;
-
-    beforeEach(() => {
-      global.fetch = mockFetch;
-
-      // Mock successful download
-      mockFetch.mockResolvedValue({
-        ok: true,
-        arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(8)),
-      });
-
-      // Mock file operations
-      vi.mocked(fs.promises.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.promises.readFile).mockResolvedValue('{}');
-      vi.mocked(fse.ensureDir).mockResolvedValue(undefined);
-      vi.mocked(fse.copy).mockResolvedValue(undefined);
-      vi.mocked(fse.remove).mockResolvedValue(undefined);
-
-      // Mock AdmZip constructor - must use function for constructor
-      vi.mocked(AdmZip).mockImplementation(function (this: AdmZip) {
-        return {
-          extractAllTo: vi.fn(),
-        } as unknown as AdmZip;
-      } as unknown as typeof AdmZip);
-    });
-
-    afterEach(() => {
-      global.fetch = originalFetch;
-    });
-
-    it('should successfully install template', async () => {
-      await service.installTemplate({
-        directory: '/test/project',
-        projectName: 'My Project',
-        theme: 'quartz',
-      });
-
-      expect(mockFetch).toHaveBeenCalledWith(
-        'https://github.com/poetora/starter/archive/refs/heads/main.zip'
-      );
-      expect(fse.copy).toHaveBeenCalled();
-      expect(fs.promises.writeFile).toHaveBeenCalledWith(
-        '/test/project/docs.json',
-        expect.stringContaining('My Project'),
-        'utf-8'
-      );
-    });
-
-    it('should throw ExternalServiceError on download failure', async () => {
-      mockFetch.mockResolvedValue({
-        ok: false,
-        status: 404,
-        statusText: 'Not Found',
-      });
-
-      await expect(
-        service.installTemplate({
-          directory: '/test/project',
-          projectName: 'My Project',
-          theme: 'quartz',
-        })
-      ).rejects.toThrow(ExternalServiceError);
-    });
-
-    it('should cleanup temporary files after successful installation', async () => {
-      await service.installTemplate({
-        directory: '/test/project',
-        projectName: 'My Project',
-        theme: 'quartz',
-      });
-
-      expect(fse.remove).toHaveBeenCalledWith('poetora-starter.zip');
-      expect(fse.remove).toHaveBeenCalledWith('poetora-starter-temp');
-    });
-
-    it('should cleanup temporary files even on error', async () => {
-      vi.mocked(fse.copy).mockRejectedValue(new Error('Copy failed'));
-
-      await expect(
-        service.installTemplate({
-          directory: '/test/project',
-          projectName: 'My Project',
-          theme: 'quartz',
-        })
-      ).rejects.toThrow();
-
-      expect(fse.remove).toHaveBeenCalled();
-    });
-
-    it('should handle missing docs.json by creating new config', async () => {
-      vi.mocked(fs.promises.readFile).mockRejectedValue(new Error('ENOENT'));
-
-      await service.installTemplate({
-        directory: '/test/project',
-        projectName: 'My Project',
-        theme: 'quartz',
-      });
-
-      expect(fs.promises.writeFile).toHaveBeenCalledWith(
-        '/test/project/docs.json',
-        expect.stringContaining('"name": "My Project"'),
-        'utf-8'
-      );
-    });
-
-    it('should preserve existing config fields when updating', async () => {
-      vi.mocked(fs.promises.readFile).mockResolvedValue(
-        JSON.stringify({
-          name: 'Old Name',
-          theme: 'old-theme',
-          customField: 'preserved',
-        })
-      );
-
-      await service.installTemplate({
-        directory: '/test/project',
-        projectName: 'New Project',
-        theme: 'quartz',
-      });
-
-      const writeCall = vi
-        .mocked(fs.promises.writeFile)
-        .mock.calls.find((call) => call[0] === '/test/project/docs.json');
-
-      expect(writeCall).toBeDefined();
-      const writtenConfig = JSON.parse(writeCall?.[1] as string);
-      expect(writtenConfig).toMatchObject({
-        name: 'New Project',
-        theme: 'quartz',
-        customField: 'preserved',
-      });
-    });
-  });
-});

package/src/services/__tests__/version.service.test.ts

@@ -1,165 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { VersionService } from '../version.service.js';
-
-describe('VersionService', () => {
-  let service: VersionService;
-  let _originalVersion: string;
-
-  beforeEach(() => {
-    service = new VersionService();
-    _originalVersion = process.version;
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('parseNodeVersion', () => {
-    it('should parse version with v prefix', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v20.17.0');
-
-      const version = service.parseNodeVersion();
-
-      expect(version.major).toBe(20);
-      expect(version.minor).toBe(17);
-      expect(version.patch).toBe(0);
-      expect(version.raw).toBe('20.17.0');
-    });
-
-    it('should parse version without v prefix', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('18.0.0');
-
-      const version = service.parseNodeVersion();
-
-      expect(version.major).toBe(18);
-      expect(version.minor).toBe(0);
-      expect(version.patch).toBe(0);
-    });
-
-    it('should parse version with only major.minor', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v20.17');
-
-      const version = service.parseNodeVersion();
-
-      expect(version.major).toBe(20);
-      expect(version.minor).toBe(17);
-      expect(version.patch).toBe(0);
-    });
-  });
-
-  describe('checkNodeVersion', () => {
-    it('should pass for Node 20.17.0', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v20.17.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(true);
-      expect(result.hasWarning).toBe(false);
-    });
-
-    it('should pass for Node 18.0.0 (minimum)', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v18.0.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(true);
-      expect(result.hasWarning).toBe(true);
-      expect(result.message).toContain('20.17');
-    });
-
-    it('should pass for Node 24.x', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v24.0.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(true);
-    });
-
-    it('should fail for Node 17.x', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v17.9.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(false);
-      expect(result.message).toContain('18.0');
-    });
-
-    it('should fail for Node 25.x', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v25.0.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(false);
-      expect(result.message).toContain('not supported');
-    });
-
-    it('should warn for Node 19.x (below recommended)', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v19.5.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(true);
-      expect(result.hasWarning).toBe(true);
-      expect(result.message).toContain('recommended');
-    });
-
-    it('should warn for Node 20.16 (below recommended minor)', () => {
-      vi.spyOn(process, 'version', 'get').mockReturnValue('v20.16.0');
-
-      const result = service.checkNodeVersion();
-
-      expect(result.isValid).toBe(true);
-      expect(result.hasWarning).toBe(true);
-    });
-  });
-
-  describe('getCliVersion', () => {
-    it('should return test-cli in test mode', () => {
-      const originalEnv = process.env.CLI_TEST_MODE;
-      process.env.CLI_TEST_MODE = 'true';
-
-      const version = service.getCliVersion();
-
-      expect(version).toBe('test-cli');
-
-      process.env.CLI_TEST_MODE = originalEnv;
-    });
-
-    it('should return version from package.json', () => {
-      const version = service.getCliVersion();
-
-      expect(version).toBeDefined();
-      expect(typeof version).toBe('string');
-    });
-  });
-
-  describe('getLatestCliVersion', () => {
-    it('should return latest version from npm', () => {
-      const version = service.getLatestCliVersion('@poetora/cli');
-
-      expect(version).toBeDefined();
-      expect(typeof version).toBe('string');
-      expect(version).toMatch(/^\d+\.\d+\.\d+/);
-    });
-  });
-
-  describe('isVersionUpToDate', () => {
-    it('should return true when versions match', () => {
-      const result = service.isVersionUpToDate('1.0.0', '1.0.0');
-
-      expect(result).toBe(true);
-    });
-
-    it('should return false when versions differ', () => {
-      const result = service.isVersionUpToDate('1.0.0', '1.0.1');
-
-      expect(result).toBe(false);
-    });
-
-    it('should handle whitespace', () => {
-      const result = service.isVersionUpToDate('1.0.0  ', '  1.0.0');
-
-      expect(result).toBe(true);
-    });
-  });
-});