@poetora/cli 0.0.1

package/.prettierignore

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

package/README.md

@@ -0,0 +1,3 @@
+# @poetora/cli
+
+A CLI tool for launching the documentation engine to preview your documents locally.

package/__test__/brokenLinks.test.ts

@@ -0,0 +1,93 @@
+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

@@ -0,0 +1,92 @@
+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);
+  });
+});

package/__test__/openApiCheck.test.ts

@@ -0,0 +1,127 @@
+import * as previewing from '@poetora/previewing';
+import { getOpenApiDocumentFromUrl, isAllowedLocalSchemaUrl, validate } from '@poetora/shared';
+import { mockProcessExit } from 'vitest-mock-process';
+
+import { readLocalOpenApiFile } from '../src/helpers';
+import { mockValidOpenApiDocument, runCommand } from './utils';
+
+vi.mock('@poetora/shared', () => ({
+  getOpenApiDocumentFromUrl: vi.fn(),
+  isAllowedLocalSchemaUrl: vi.fn(),
+  validate: vi.fn(),
+}));
+
+vi.mock('../src/helpers', async () => {
+  const originalModule = await import('../src/helpers');
+  return {
+    ...originalModule,
+    readLocalOpenApiFile: vi.fn(),
+  };
+});
+
+const addLogSpy = vi.spyOn(previewing, 'addLog');
+const processExitMock = mockProcessExit();
+
+describe('openApiCheck', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('valid openApi file from url', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(true);
+    vi.mocked(getOpenApiDocumentFromUrl).mockResolvedValueOnce(mockValidOpenApiDocument);
+
+    await runCommand('openapi-check', 'https://petstore3.swagger.io/api/v3/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'OpenAPI definition is valid.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('invalid openApi file from url', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(true);
+    vi.mocked(getOpenApiDocumentFromUrl).mockRejectedValueOnce(
+      new Error('Could not parse OpenAPI document.')
+    );
+
+    await runCommand('openapi-check', 'https://petstore3.swagger.io/api/v3/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'Could not parse OpenAPI document.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('valid openApi file from localhost', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(true);
+    vi.mocked(getOpenApiDocumentFromUrl).mockResolvedValueOnce(mockValidOpenApiDocument);
+
+    await runCommand('openapi-check', 'http://localhost:3000/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'OpenAPI definition is valid.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('invalid openApi file from localhost', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(false);
+    vi.mocked(readLocalOpenApiFile).mockResolvedValueOnce(undefined);
+
+    await runCommand('openapi-check', 'http://localhost:3000/openapi.json');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: {
+          message:
+            'failed to parse OpenAPI spec: could not parse file correctly, please check for any syntax errors.',
+        },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+  it('valid openApi file from local file', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(false);
+    vi.mocked(readLocalOpenApiFile).mockResolvedValueOnce(mockValidOpenApiDocument);
+    vi.mocked(validate).mockResolvedValueOnce({
+      valid: true,
+      errors: [],
+    });
+
+    await runCommand('openapi-check', 'test/openapi.yaml');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'OpenAPI definition is valid.' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('invalid openApi file from local file', async () => {
+    vi.mocked(isAllowedLocalSchemaUrl).mockReturnValueOnce(false);
+    vi.mocked(readLocalOpenApiFile).mockResolvedValueOnce(mockValidOpenApiDocument);
+    vi.mocked(validate).mockRejectedValueOnce(new Error('some schema parsing error'));
+
+    await runCommand('openapi-check', 'test/openapi.yaml');
+
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'some schema parsing error' },
+      })
+    );
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+});

package/__test__/update.test.ts

@@ -0,0 +1,108 @@
+import * as previewing from '@poetora/previewing';
+
+import { getLatestCliVersion, getVersions, execAsync } from '../src/helpers';
+import { update } from '../src/update';
+
+vi.mock('@poetora/previewing', async () => {
+  const originalModule =
+    await vi.importActual<typeof import('@poetora/previewing')>('@poetora/previewing');
+  return {
+    ...originalModule,
+    getClientVersion: vi.fn(),
+    downloadTargetPoet: vi.fn(),
+  };
+});
+
+vi.mock('../src/helpers', async () => {
+  const originalModule = await vi.importActual<typeof import('../src/helpers')>('../src/helpers');
+  return {
+    ...originalModule,
+    execAsync: vi.fn(),
+    getLatestCliVersion: vi.fn(),
+    getVersions: vi.fn().mockReturnValue({
+      cli: '1.0.0',
+      client: '1.0.0',
+    }),
+    detectPackageManager: vi.fn().mockResolvedValue('pnpm'),
+  };
+});
+
+const addLogSpy = vi.spyOn(previewing, 'addLog');
+
+describe('update', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('should update the cli successfully', async () => {
+    vi.mocked(getVersions).mockReturnValue({
+      cli: '1.0.0',
+      client: '1.0.0',
+    });
+    vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+    vi.mocked(previewing.downloadTargetPoet).mockResolvedValue();
+
+    await update({ packageName: 'poetora' });
+
+    expect(addLogSpy).toHaveBeenCalledTimes(3);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating poetora package...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        props: { message: 'updated poetora to the latest version: 2.0.0' },
+      })
+    );
+    expect(execAsync).toHaveBeenCalledWith('pnpm install -g poetora@latest --silent');
+  });
+
+  it('should return when already up to date', async () => {
+    vi.mocked(getVersions).mockReturnValue({
+      cli: '1.0.0',
+      client: '1.0.0',
+    });
+    vi.mocked(getLatestCliVersion).mockReturnValue('1.0.0');
+    vi.mocked(execAsync).mockResolvedValue({ stdout: '', stderr: '' });
+
+    await update({ packageName: 'poetora' });
+
+    expect(addLogSpy).toHaveBeenCalledTimes(2);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'already up to date' } })
+    );
+    expect(execAsync).not.toHaveBeenCalled();
+  });
+
+  it('should handle cli update failure', async () => {
+    vi.mocked(getVersions).mockReturnValue({
+      cli: '1.0.0',
+      client: '1.0.0',
+    });
+    vi.mocked(getLatestCliVersion).mockReturnValue('2.0.0');
+    vi.mocked(execAsync).mockRejectedValue(new Error('Update failed'));
+
+    await update({ packageName: 'poetora' });
+
+    expect(addLogSpy).toHaveBeenCalledTimes(3);
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'updating poetora package...' } })
+    );
+    expect(addLogSpy).toHaveBeenCalledWith(
+      expect.objectContaining({ props: { message: 'failed to update poetora@latest' } })
+    );
+  });
+});

package/__test__/utils.ts

@@ -0,0 +1,20 @@
+import { cli } from '../src/cli';
+
+/**
+ * Programmatically set arguments and execute the CLI script
+ *
+ * @param {...string} args - Additional command arguments.
+ */
+export async function runCommand(...args: string[]) {
+  process.argv = ['node', 'cli', ...args];
+  return cli({ packageName: 'poet' });
+}
+
+export const mockValidOpenApiDocument = {
+  openapi: '3.0.0',
+  info: {
+    title: 'Test API',
+    version: '1.0.0',
+  },
+  components: {},
+};

package/bin/accessibility.d.ts

@@ -0,0 +1,44 @@
+export declare const WCAG_STANDARDS: {
+    readonly AA_NORMAL: 4.5;
+    readonly AA_LARGE: 3;
+    readonly AAA_NORMAL: 7;
+    readonly AAA_LARGE: 4.5;
+};
+export type ContrastResult = {
+    ratio: number;
+    meetsAA: boolean;
+    meetsAAA: boolean;
+    recommendation: 'pass' | 'warning' | 'fail';
+    message: string;
+};
+export declare function checkColorContrast(foreground: string, background: string, minThreshold?: number): ContrastResult | null;
+export interface AccessibilityCheckResult {
+    primaryContrast: ContrastResult | null;
+    lightContrast: ContrastResult | null;
+    darkContrast: ContrastResult | null;
+    darkOnLightContrast: ContrastResult | null;
+    anchorResults: Array<{
+        name: string;
+        lightContrast: ContrastResult | null;
+        darkContrast: ContrastResult | null;
+    }>;
+    overallScore: 'pass' | 'warning' | 'fail';
+}
+export declare function checkDocsColors(colors: {
+    primary?: string;
+    light?: string;
+    dark?: string;
+}, background: {
+    lightHex: string;
+    darkHex: string;
+}, navigation?: {
+    global?: {
+        anchors?: Array<{
+            anchor: string;
+            color?: {
+                light?: string;
+                dark?: string;
+            };
+        }>;
+    };
+}): AccessibilityCheckResult;

package/bin/accessibility.js

@@ -0,0 +1,110 @@
+import Color from 'color';
+export const WCAG_STANDARDS = {
+    AA_NORMAL: 4.5,
+    AA_LARGE: 3,
+    AAA_NORMAL: 7,
+    AAA_LARGE: 4.5,
+};
+export function checkColorContrast(foreground, background, minThreshold = WCAG_STANDARDS.AA_NORMAL) {
+    try {
+        const fg = Color(foreground);
+        const bg = Color(background);
+        const ratio = fg.contrast(bg);
+        const level = fg.level(bg);
+        const meetsAA = level === 'AA' || level === 'AAA';
+        const meetsAAA = level === 'AAA';
+        let recommendation;
+        let message;
+        if (minThreshold !== WCAG_STANDARDS.AA_NORMAL) {
+            if (ratio >= minThreshold) {
+                recommendation = 'pass';
+                message = `Contrast ratio: ${ratio.toFixed(2)}:1 (meets minimum threshold of ${minThreshold}:1)`;
+            }
+            else {
+                recommendation = 'fail';
+                message = `Poor contrast ratio: ${ratio.toFixed(2)}:1 (fails minimum threshold, required: ${minThreshold}:1)`;
+            }
+        }
+        else {
+            if (meetsAAA) {
+                recommendation = 'pass';
+                message = `Excellent contrast ratio: ${ratio.toFixed(2)}:1 (meets WCAG AAA)`;
+            }
+            else if (meetsAA) {
+                recommendation = 'warning';
+                message = `Good contrast ratio: ${ratio.toFixed(2)}:1 (meets WCAG AA, consider AAA for better accessibility)`;
+            }
+            else {
+                recommendation = 'fail';
+                message = `Poor contrast ratio: ${ratio.toFixed(2)}:1 (fails WCAG AA, minimum required: ${WCAG_STANDARDS.AA_NORMAL}:1)`;
+            }
+        }
+        return {
+            ratio,
+            meetsAA,
+            meetsAAA,
+            recommendation,
+            message,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function checkDocsColors(colors, background, navigation) {
+    const lightBackground = background.lightHex;
+    const darkBackground = background.darkHex;
+    const primaryContrast = colors.primary
+        ? checkColorContrast(colors.primary, lightBackground)
+        : null;
+    const lightContrast = colors.light ? checkColorContrast(colors.light, darkBackground) : null;
+    const darkContrast = colors.dark ? checkColorContrast(colors.dark, darkBackground, 3) : null;
+    const darkOnLightContrast = colors.dark
+        ? checkColorContrast(colors.dark, lightBackground, 3)
+        : null;
+    const anchorResults = [];
+    if (navigation?.global?.anchors) {
+        for (const anchor of navigation.global.anchors) {
+            if (anchor.color) {
+                const lightContrast = anchor.color.light
+                    ? checkColorContrast(anchor.color.light, lightBackground)
+                    : null;
+                const darkContrast = anchor.color.dark
+                    ? checkColorContrast(anchor.color.dark, darkBackground)
+                    : null;
+                anchorResults.push({
+                    name: anchor.anchor,
+                    lightContrast,
+                    darkContrast,
+                });
+            }
+        }
+    }
+    const results = [
+        primaryContrast,
+        lightContrast,
+        darkContrast,
+        darkOnLightContrast,
+        ...anchorResults.flatMap((anchor) => [anchor.lightContrast, anchor.darkContrast]),
+    ].filter(Boolean);
+    const hasFailure = results.some((result) => result.recommendation === 'fail');
+    const hasWarning = results.some((result) => result.recommendation === 'warning');
+    let overallScore;
+    if (hasFailure) {
+        overallScore = 'fail';
+    }
+    else if (hasWarning) {
+        overallScore = 'warning';
+    }
+    else {
+        overallScore = 'pass';
+    }
+    return {
+        primaryContrast,
+        lightContrast,
+        darkContrast,
+        darkOnLightContrast,
+        anchorResults,
+        overallScore,
+    };
+}

package/bin/accessibilityCheck.d.ts

@@ -0,0 +1,2 @@
+export type TerminateCode = 0 | 1;
+export declare const accessibilityCheck: () => Promise<TerminateCode>;

package/bin/accessibilityCheck.js

@@ -0,0 +1,70 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { getConfigObj, getConfigPath } from '@poetora/prebuild';
+import { addLog, ErrorLog, WarningLog } from '@poetora/previewing';
+import { getBackgroundColors } from '@poetora/shared';
+import { Text } from 'ink';
+import { checkDocsColors } from './accessibility.js';
+import { CMD_EXEC_PATH } from './constants.js';
+export const accessibilityCheck = async () => {
+    try {
+        const docsConfigPath = await getConfigPath(CMD_EXEC_PATH);
+        if (!docsConfigPath) {
+            addLog(_jsx(ErrorLog, { message: "No configuration file found. Please run this command from a directory with a docs.json file." }));
+            return 1;
+        }
+        const config = await getConfigObj(CMD_EXEC_PATH);
+        if (!config.colors) {
+            addLog(_jsx(WarningLog, { message: "No colors section found in configuration file" }));
+            return 0;
+        }
+        const { colors, navigation } = config;
+        const { lightHex, darkHex } = getBackgroundColors(config);
+        const results = checkDocsColors(colors, { lightHex, darkHex }, navigation);
+        const displayContrastResult = (result, label, prefix = '') => {
+            if (!result)
+                return;
+            const { recommendation, message } = result;
+            const icon = recommendation === 'pass' ? 'PASS' : recommendation === 'warning' ? 'WARN' : 'FAIL';
+            const color = recommendation === 'pass' ? 'green' : recommendation === 'warning' ? 'yellow' : 'red';
+            addLog(_jsxs(Text, { children: [_jsxs(Text, { bold: prefix === '', children: [prefix, label, ":", ' '] }), _jsxs(Text, { color: color, children: [icon, " ", message] })] }));
+        };
+        addLog(_jsx(Text, { bold: true, color: "cyan", children: "Checking color accessibility..." }));
+        addLog(_jsx(Text, {}));
+        displayContrastResult(results.primaryContrast, `Primary Color (${colors.primary}) vs Light Background`);
+        displayContrastResult(results.lightContrast, `Light Color (${colors.light}) vs Dark Background`);
+        displayContrastResult(results.darkContrast, `Dark Color (${colors.dark}) vs Dark Background`);
+        displayContrastResult(results.darkOnLightContrast, `Dark Color (${colors.dark}) vs Light Background`);
+        const anchorsWithResults = results.anchorResults.filter((anchor) => anchor.lightContrast || anchor.darkContrast);
+        if (anchorsWithResults.length > 0) {
+            addLog(_jsx(Text, {}));
+            addLog(_jsx(Text, { bold: true, color: "cyan", children: "Navigation Anchors:" }));
+            for (const anchor of anchorsWithResults) {
+                addLog(_jsxs(Text, { bold: true, children: [" ", anchor.name, ":"] }));
+                displayContrastResult(anchor.lightContrast, 'Light variant vs Light Background', '    ');
+                displayContrastResult(anchor.darkContrast, 'Dark variant vs Dark Background', '    ');
+            }
+        }
+        addLog(_jsx(Text, {}));
+        const overallIcon = results.overallScore === 'pass'
+            ? 'PASS'
+            : results.overallScore === 'warning'
+                ? 'WARN'
+                : 'FAIL';
+        const overallColor = results.overallScore === 'pass'
+            ? 'green'
+            : results.overallScore === 'warning'
+                ? 'yellow'
+                : 'red';
+        const overallMessage = results.overallScore === 'pass'
+            ? 'All colors meet accessibility standards!'
+            : results.overallScore === 'warning'
+                ? 'Some colors could be improved for better accessibility'
+                : 'Some colors fail accessibility standards and should be updated';
+        addLog(_jsx(Text, { children: _jsxs(Text, { bold: true, color: overallColor, children: ["Overall Assessment: ", overallIcon, " ", overallMessage] }) }));
+        return results.overallScore === 'fail' ? 1 : 0;
+    }
+    catch (error) {
+        addLog(_jsx(ErrorLog, { message: `Accessibility check failed: ${error instanceof Error ? error.message : 'Unknown error'}` }));
+        return 1;
+    }
+};

package/bin/cli.d.ts

@@ -0,0 +1,11 @@
+export declare const cli: ({ packageName }: {
+    packageName?: string;
+}) => {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+} | Promise<{
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+}>;