@poetora/cli 0.0.1

package/src/mdxAccessibility.ts

@@ -0,0 +1,133 @@
+import { categorizeFilePaths, getPoetIgnore } from '@poetora/prebuild';
+import { coreRemark } from '@poetora/shared';
+import fs from 'fs';
+import type { Root, Text } from 'mdast';
+import type { Node } 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/mdxLinter.tsx

@@ -0,0 +1,88 @@
+import { addLog, ErrorLog, SuccessLog } from '@poetora/previewing';
+import { Text } from 'ink';
+import path from 'path';
+
+import { TerminateCode } from './accessibilityCheck.js';
+import { checkMdxAccessibility, type AccessibilityFixAttribute } from './mdxAccessibility.js';
+
+export const mdxLinter = async (): Promise<TerminateCode> => {
+  try {
+    addLog(
+      <Text bold color="cyan">
+        Checking mdx files for accessibility issues...
+      </Text>
+    );
+
+    const results = await checkMdxAccessibility();
+
+    if (results.missingAltAttributes.length === 0) {
+      addLog(<SuccessLog message="no accessibility issues found" />);
+      addLog(
+        <Text>
+          Checked {results.totalFiles} MDX files - all images and videos have alt attributes.
+        </Text>
+      );
+      return 0;
+    }
+
+    const issuesByFile: Record<string, AccessibilityFixAttribute[]> = {};
+    results.missingAltAttributes.forEach((issue) => {
+      if (!issuesByFile[issue.filePath]) {
+        issuesByFile[issue.filePath] = [];
+      }
+      issuesByFile[issue.filePath]?.push(issue);
+    });
+
+    addLog(
+      <Text bold color="red">
+        Found {results.missingAltAttributes.length} accessibility issues in{' '}
+        {results.filesWithIssues} files:
+      </Text>
+    );
+    addLog(<Text></Text>);
+
+    for (const [filePath, issues] of Object.entries(issuesByFile)) {
+      const relativePath = path.relative(process.cwd(), filePath);
+      addLog(<Text bold>{relativePath}:</Text>);
+
+      for (const issue of issues) {
+        const location =
+          issue.line && issue.column ? ` (line ${issue.line}, col ${issue.column})` : '';
+        if (issue.element === 'a') {
+          addLog(
+            <Text>
+              <Text color="red"> ✗</Text> Missing text attribute <Text bold>{issue.tagName}</Text>{' '}
+              element{location}
+            </Text>
+          );
+        } else {
+          addLog(
+            <Text>
+              <Text color="red"> ✗</Text> Missing alt attribute on <Text bold>{issue.tagName}</Text>{' '}
+              element{location}
+            </Text>
+          );
+        }
+      }
+      addLog(<Text></Text>);
+    }
+
+    addLog(
+      <Text color="yellow">
+        <Text bold>Recommendation:</Text> Add alt attributes to all images and videos for better
+        accessibility.
+      </Text>
+    );
+
+    return 1;
+  } catch (error) {
+    addLog(
+      <ErrorLog
+        message={`MDX accessibility check failed: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`}
+      />
+    );
+    return 1;
+  }
+};

package/src/start.ts

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

package/src/update.tsx

@@ -0,0 +1,37 @@
+import { SpinnerLog, SuccessLog, ErrorLog, addLog, clearLogs } from '@poetora/previewing';
+
+import { execAsync, getLatestCliVersion, getVersions, detectPackageManager } from './helpers.js';
+
+export const update = async ({ packageName }: { packageName: string }) => {
+  addLog(<SpinnerLog message="updating..." />);
+  const { cli: existingCliVersion } = getVersions();
+  const latestCliVersion = getLatestCliVersion(packageName);
+  const isUpToDate =
+    existingCliVersion && latestCliVersion && latestCliVersion.trim() === existingCliVersion.trim();
+
+  if (isUpToDate) {
+    addLog(<SuccessLog message="already up to date" />);
+    return;
+  }
+
+  if (existingCliVersion && latestCliVersion.trim() !== existingCliVersion.trim()) {
+    try {
+      clearLogs();
+      addLog(<SpinnerLog message={`updating ${packageName} package...`} />);
+      const packageManager = await detectPackageManager({ packageName });
+      if (packageManager === 'pnpm') {
+        await execAsync(`pnpm install -g ${packageName}@latest --silent`);
+      } else {
+        await execAsync(`npm install -g ${packageName}@latest --silent`);
+      }
+    } catch (err) {
+      addLog(<ErrorLog message={`failed to update ${packageName}@latest`} />);
+      return;
+    }
+  }
+
+  clearLogs();
+  addLog(
+    <SuccessLog message={`updated ${packageName} to the latest version: ${latestCliVersion}`} />
+  );
+};

package/tsconfig.build.json

@@ -0,0 +1,16 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*"],
+  "compilerOptions": {
+    "noEmit": false,
+    "outDir": "./bin",
+    "skipLibCheck": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "sourceMap": false,
+    "inlineSourceMap": false,
+    "declaration": true,
+    "declarationMap": false,
+    "inlineSources": false
+  }
+}

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./bin",
+    "baseUrl": "./src",
+    "paths": {
+      "@/*": ["*"]
+    },
+    "sourceMap": false,
+    "removeComments": true,
+    "preserveConstEnums": true,
+    "types": ["vitest/globals"],
+    "jsx": "react-jsx",
+    "jsxImportSource": "react",
+    "allowJs": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": false,
+    "noImplicitReturns": false
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "__test__/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+  },
+});