@jlcpcb/cli 0.2.0 → 0.3.1

package/src/app/screens/LibraryScreen.tsx

@@ -6,15 +6,15 @@ import type { LibraryParams } from '../navigation/types.js';
 import { useAppState } from '../state/AppStateContext.js';
 import { useTerminalSize } from '../hooks/useTerminalSize.js';
 import { Divider } from '../components/Divider.js';
+import {
+  formatLibraryHeader,
+  formatLibraryRow,
+  getLibraryTableWidths,
+} from '../components/library-table-format.js';
 
 const libraryService = createLibraryService();
 const componentService = createComponentService();
 
-function truncate(str: string, len: number): string {
-  if (!str) return '';
-  return str.length > len ? str.slice(0, len - 1) + '…' : str;
-}
-
 function StatusBadge({ installed, linked }: { installed: boolean; linked: boolean }) {
   if (installed && linked) {
     return <Text color="green">Installed & Linked</Text>;
@@ -193,10 +193,7 @@ export function LibraryScreen() {
   // Components table - full width responsive layout
   // Fixed columns: selector(2) + name + category + status columns(15)
   // Description takes remaining space
-  const nameWidth = 20;
-  const categoryWidth = 12;
-  const statusWidth = 15; // Sym(5) + FP(5) + 3D(5)
-  const descWidth = Math.max(terminalWidth - 2 - nameWidth - categoryWidth - statusWidth, 15);
+  const widths = getLibraryTableWidths(terminalWidth);
 
   return (
     <Box flexDirection="column" width="100%">
@@ -216,36 +213,36 @@ export function LibraryScreen() {
       </Box>
       <Divider width={terminalWidth} />
       <Box marginBottom={1} marginTop={1}>
-        <Text bold dimColor>
-          {'  '}
-          {'Name'.padEnd(nameWidth)}
-          {'Category'.padEnd(categoryWidth)}
-          {'Description'.padEnd(descWidth)}
-          {'Sym'.padEnd(5)}
-          {'FP'.padEnd(5)}
-          {'3D'}
-        </Text>
+        <Text bold dimColor>{formatLibraryHeader(widths)}</Text>
       </Box>
       {installed.map((item, i) => {
         const isSelected = i === selectedIndex;
         const desc = descriptions[item.lcscId] || '';
-        // Check if footprint is standard KiCad (not JLC-MCP custom)
-        const isStandardFp = item.footprintRef && !item.footprintRef.startsWith('JLC-MCP:');
-        const fpLabel = !item.footprintRef ? 'N' : isStandardFp ? 'S' : 'Y';
-        const fpColor = !item.footprintRef ? 'red' : isStandardFp ? 'cyan' : 'green';
+        const row = formatLibraryRow(item, desc, widths);
         return (
           <Box key={`${item.lcscId}-${i}`}>
             <Text color={isSelected ? 'cyan' : undefined}>
               {isSelected ? '> ' : '  '}
             </Text>
-            <Text inverse={isSelected}>
-              <Text color="cyan">{truncate(item.name, nameWidth - 1).padEnd(nameWidth)}</Text>
-              {truncate(item.category, categoryWidth - 1).padEnd(categoryWidth)}
-              <Text dimColor>{truncate(desc, descWidth - 1).padEnd(descWidth)}</Text>
-              <Text color="green">{'Y'.padEnd(5)}</Text>
-              <Text color={fpColor}>{fpLabel.padEnd(5)}</Text>
-              <Text color={item.has3dModel ? 'green' : 'red'}>{item.has3dModel ? 'Y' : 'N'}</Text>
-            </Text>
+            {isSelected ? (
+              <Text inverse>
+                {row.name}
+                {row.category}
+                {row.description}
+                {row.sym}
+                {row.fp}
+                {row.model}
+              </Text>
+            ) : (
+              <Text>
+                <Text color="cyan">{row.name}</Text>
+                {row.category}
+                <Text dimColor>{row.description}</Text>
+                <Text color="green">{row.sym}</Text>
+                <Text color={row.fpColor}>{row.fp}</Text>
+                <Text color={row.modelColor}>{row.model}</Text>
+              </Text>
+            )}
           </Box>
         );
       })}

package/src/commands/easyeda.ts

@@ -111,7 +111,7 @@ export async function easyedaInstallCommand(
   // If UUID provided (without --force), launch TUI to fetch and display
   if (uuid) {
     // Launch TUI at EasyEDA info screen - let it fetch the component
-    renderApp('easyeda-info', { uuid })
+    await renderApp('easyeda-info', { uuid })
     return
   }
 
@@ -130,8 +130,7 @@ export async function easyedaInstallCommand(
     process.exit(0)
   }
 
-  const spinner = p.spinner()
-  spinner.start(`Searching EasyEDA community for "${query}"...`)
+  console.log(`Searching EasyEDA community for "${query}"...`)
 
   const searchOptions: SearchOptions = {
     limit: 20,
@@ -139,13 +138,12 @@ export async function easyedaInstallCommand(
   }
   const results = await componentService.search(query as string, searchOptions)
 
-  spinner.stop(`Found ${results.length} results`)
-
   if (results.length === 0) {
-    p.log.warn('No components found. Try a different search term.')
+    console.log('No components found. Try a different search term.')
     return
   }
 
-  // Launch TUI for selection and install
-  renderApp('search', { query: query as string, results })
+  // Clear the "Searching..." line and launch interactive UI
+  process.stdout.write('\x1b[1A\x1b[2K')
+  await renderApp('search', { query: query as string, results })
 }

package/src/commands/info.ts

@@ -33,5 +33,5 @@ export async function infoCommand(id: string, options: InfoOptions): Promise<voi
   }
 
   // Interactive mode - launch TUI
-  renderApp('info', { componentId: id });
+  await renderApp('info', { componentId: id });
 }

package/src/commands/install.ts

@@ -68,18 +68,15 @@ export async function installCommand(id: string | undefined, options: InstallOpt
 
   // If ID provided (without --force), fetch component and launch TUI for install
   if (id) {
-    const spinner = p.spinner();
-    spinner.start(`Fetching component ${id}...`);
+    console.log(`Fetching component ${id}...`);
 
     try {
       const details = await componentService.getDetails(id);
-      spinner.stop('Component found');
-
-      // Launch TUI at info screen (user can navigate to install from there)
-      renderApp('info', { componentId: id, component: details as any });
+      // Clear the "Fetching..." line and launch interactive UI
+      process.stdout.write('\x1b[1A\x1b[2K');
+      await renderApp('info', { componentId: id, component: details as any });
     } catch (error) {
-      spinner.stop('Failed to fetch component');
-      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      console.error(`Failed to fetch component: ${error instanceof Error ? error.message : 'Unknown error'}`);
       process.exit(1);
     }
     return;
@@ -100,8 +97,7 @@ export async function installCommand(id: string | undefined, options: InstallOpt
     process.exit(0);
   }
 
-  const spinner = p.spinner();
-  spinner.start(`Searching for "${query}"...`);
+  console.log(`Searching for "${query}"...`);
 
   const searchOptions: SearchOptions = { limit: 20 };
   let results = await componentService.search(query as string, searchOptions);
@@ -113,13 +109,12 @@ export async function installCommand(id: string | undefined, options: InstallOpt
     return 0;
   });
 
-  spinner.stop(`Found ${results.length} results`);
-
   if (results.length === 0) {
-    p.log.warn('No components found. Try a different search term.');
+    console.log('No components found. Try a different search term.');
     return;
   }
 
-  // Launch TUI for selection and install
-  renderApp('search', { query: query as string, results });
+  // Clear the "Searching..." line and launch interactive UI
+  process.stdout.write('\x1b[1A\x1b[2K');
+  await renderApp('search', { query: query as string, results });
 }

package/src/commands/library.ts

@@ -4,7 +4,8 @@
  */
 
 import * as p from '@clack/prompts';
-import { createLibraryService } from '@jlcpcb/core';
+import chalk from 'chalk';
+import { createLibraryService, type InstalledComponent } from '@jlcpcb/core';
 import { renderApp } from '../app/App.js';
 
 const libraryService = createLibraryService();
@@ -52,5 +53,53 @@ export async function libraryCommand(options: LibraryOptions): Promise<void> {
   }
 
   // Interactive mode - launch TUI
-  renderApp('library', {});
+  await renderApp('library', {});
+}
+
+interface RegenerateOptions {
+  projectPath?: string;
+  include3d?: boolean;
+}
+
+export async function regenerateCommand(options: RegenerateOptions): Promise<void> {
+  const include3d = options.include3d ?? true;
+
+  // First get the count
+  const components = await libraryService.listInstalled({ projectPath: options.projectPath });
+
+  if (components.length === 0) {
+    p.log.warn('No installed components found to regenerate.');
+    return;
+  }
+
+  p.log.info(`Found ${chalk.cyan(components.length)} installed components to regenerate.`);
+  console.log();
+
+  let currentSpinner: ReturnType<typeof p.spinner> | null = null;
+
+  const result = await libraryService.regenerate({
+    projectPath: options.projectPath,
+    include3d,
+    onProgress: (current: number, total: number, component: InstalledComponent, status: 'start' | 'success' | 'error', error?: string) => {
+      if (status === 'start') {
+        currentSpinner = p.spinner();
+        currentSpinner.start(`[${current}/${total}] Regenerating ${chalk.cyan(component.name)} (${component.lcscId})...`);
+      } else if (status === 'success') {
+        currentSpinner?.stop(chalk.green(`✓ [${current}/${total}] ${component.name} (${component.lcscId})`));
+      } else if (status === 'error') {
+        currentSpinner?.stop(chalk.red(`✗ [${current}/${total}] ${component.name} (${component.lcscId}): ${error}`));
+      }
+    },
+  });
+
+  console.log();
+  p.log.success(`Regeneration complete: ${chalk.green(result.success)} succeeded, ${chalk.red(result.failed)} failed`);
+
+  if (result.failed > 0) {
+    console.log();
+    p.log.warn('Failed components:');
+    for (const comp of result.components.filter(c => c.status === 'failed')) {
+      console.log(chalk.red(`  • ${comp.name} (${comp.id}): ${comp.error}`));
+    }
+  }
 }

package/src/commands/search.ts

@@ -30,7 +30,7 @@ export async function searchCommand(query: string, options: SearchOptions): Prom
 
     // Clear the "Searching..." line and launch interactive UI
     process.stdout.write('\x1b[1A\x1b[2K');
-    renderApp('search', { query, results });
+    await renderApp('search', { query, results });
   } catch (error) {
     console.error(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
     process.exit(1);

package/src/commands/validate.ts

@@ -0,0 +1,287 @@
+/**
+ * Validate command
+ * Compare generated footprints/symbols against JLCPCB reference
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { writeFileSync } from 'fs';
+import {
+  fetchReferenceSVG,
+  extractFromReferenceSVG,
+  extractFromKiCadFootprint,
+  compareFootprints,
+  formatComparisonResult,
+  extractSymbolFromReferenceSVG,
+  extractFromKiCadSymbol,
+  compareSymbols,
+  formatSymbolComparisonResult,
+  generateValidationReport,
+  generateBatchReport,
+  TEST_CATEGORIES,
+  getAllTestComponents,
+  getTestComponentsByCategory,
+  getCategoryNames,
+  renderFootprintSvg,
+  renderSymbolSvg,
+  type ValidationResult,
+  type ReportSvgs,
+  easyedaClient,
+  footprintConverter,
+  symbolConverter,
+} from '@jlcpcb/core';
+
+interface ValidateOptions {
+  footprintOnly?: boolean;
+  symbolOnly?: boolean;
+  category?: string;
+  all?: boolean;
+  html?: string;
+  json?: boolean;
+}
+
+/**
+ * Validate a single component
+ */
+async function validateComponent(
+  lcscCode: string,
+  options: { footprint: boolean; symbol: boolean }
+): Promise<ValidationResult> {
+  const startTime = Date.now();
+  const normalizedCode = lcscCode.replace(/^C/i, '');
+  const fullCode = `C${normalizedCode}`;
+
+  try {
+    // Fetch reference SVG
+    const reference = await fetchReferenceSVG(fullCode);
+
+    // Fetch component data
+    const componentData = await easyedaClient.getComponentData(fullCode);
+    if (!componentData) {
+      return {
+        lcscCode: fullCode,
+        componentName: fullCode,
+        passed: false,
+        footprint: null,
+        symbol: null,
+        timestamp: new Date(),
+        durationMs: Date.now() - startTime,
+        error: 'Failed to fetch component data from EasyEDA',
+      };
+    }
+
+    let footprintResult = null;
+    let symbolResult = null;
+
+    // Validate footprint
+    if (options.footprint && reference.footprintSvg) {
+      const kicadContent = footprintConverter.convert(componentData, {});
+
+      const refData = extractFromReferenceSVG(reference.footprintSvg);
+      const genData = extractFromKiCadFootprint(kicadContent);
+
+      footprintResult = compareFootprints(refData, genData, {
+        sizeWarningsOnly: true,
+        positionTolerance: 50,
+      });
+    }
+
+    // Validate symbol
+    if (options.symbol && reference.symbolSvg) {
+      const kicadContent = symbolConverter.convert(componentData, {
+        symbolName: componentData.info.name,
+      });
+
+      const refData = extractSymbolFromReferenceSVG(reference.symbolSvg);
+      const genData = extractFromKiCadSymbol(kicadContent);
+
+      symbolResult = compareSymbols(refData, genData, {
+        positionTolerance: 50,
+      });
+    }
+
+    const passed =
+      (!footprintResult || footprintResult.passed) && (!symbolResult || symbolResult.passed);
+
+    return {
+      lcscCode: fullCode,
+      componentName: componentData.info.name || fullCode,
+      passed,
+      footprint: footprintResult,
+      symbol: symbolResult,
+      timestamp: new Date(),
+      durationMs: Date.now() - startTime,
+    };
+  } catch (error) {
+    return {
+      lcscCode: fullCode,
+      componentName: fullCode,
+      passed: false,
+      footprint: null,
+      symbol: null,
+      timestamp: new Date(),
+      durationMs: Date.now() - startTime,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export async function validateCommand(
+  id: string | undefined,
+  options: ValidateOptions
+): Promise<void> {
+  const validateFootprint = !options.symbolOnly;
+  const validateSymbol = !options.footprintOnly;
+
+  // Single component validation
+  if (id && !options.category && !options.all) {
+    const spinner = p.spinner();
+    spinner.start(`Validating ${id}...`);
+
+    const result = await validateComponent(id, {
+      footprint: validateFootprint,
+      symbol: validateSymbol,
+    });
+
+    spinner.stop(result.passed ? chalk.green('✓ Validation passed') : chalk.red('✗ Validation failed'));
+
+    // Display results
+    console.log();
+    console.log(chalk.bold(`${result.componentName} (${result.lcscCode})`));
+    console.log(chalk.dim(`Duration: ${result.durationMs}ms`));
+    console.log();
+
+    if (result.error) {
+      console.log(chalk.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
+
+    if (result.footprint) {
+      console.log(formatComparisonResult(result.footprint));
+    }
+
+    if (result.symbol) {
+      console.log(formatSymbolComparisonResult(result.symbol));
+    }
+
+    // JSON output
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+    }
+
+    // HTML output
+    if (options.html) {
+      const reference = await fetchReferenceSVG(id);
+      const componentData = await easyedaClient.getComponentData(id);
+
+      const svgs: ReportSvgs = {
+        footprintRef: reference.footprintSvg || undefined,
+        symbolRef: reference.symbolSvg || undefined,
+      };
+
+      // Generate our KiCad output and render to SVG
+      if (componentData) {
+        if (validateFootprint) {
+          const kicadFootprint = footprintConverter.convert(componentData, {});
+          svgs.footprintGen = renderFootprintSvg(kicadFootprint);
+        }
+        if (validateSymbol) {
+          const kicadSymbol = symbolConverter.convert(componentData, {
+            symbolName: componentData.info.name,
+          });
+          svgs.symbolGen = renderSymbolSvg(kicadSymbol);
+        }
+      }
+
+      const html = generateValidationReport(result, svgs);
+      writeFileSync(options.html, html);
+      console.log(chalk.dim(`HTML report: ${options.html}`));
+    }
+
+    process.exit(result.passed ? 0 : 1);
+  }
+
+  // Batch validation
+  let components = options.all
+    ? getAllTestComponents()
+    : options.category
+      ? getTestComponentsByCategory(options.category)
+      : [];
+
+  if (components.length === 0 && !id) {
+    // Interactive category selection
+    const categories = getCategoryNames();
+    const selected = await p.select({
+      message: 'Select a category to validate:',
+      options: [
+        { value: 'all', label: 'All categories' },
+        ...categories.map((c) => ({ value: c, label: c })),
+      ],
+    });
+
+    if (p.isCancel(selected)) {
+      p.cancel('Validation cancelled');
+      process.exit(0);
+    }
+
+    components =
+      selected === 'all' ? getAllTestComponents() : getTestComponentsByCategory(selected as string);
+  }
+
+  // Filter out skipped components
+  components = components.filter((c) => !c.skip);
+
+  if (components.length === 0) {
+    p.log.warn('No components to validate');
+    process.exit(0);
+  }
+
+  console.log(chalk.bold(`\nValidating ${components.length} components...\n`));
+
+  const results: ValidationResult[] = [];
+  let passed = 0;
+  let failed = 0;
+  let errors = 0;
+
+  for (const component of components) {
+    process.stdout.write(`  ${component.lcsc.padEnd(12)} ${component.name.slice(0, 40).padEnd(42)} `);
+
+    const result = await validateComponent(component.lcsc, {
+      footprint: validateFootprint,
+      symbol: validateSymbol,
+    });
+
+    results.push(result);
+
+    if (result.error) {
+      errors++;
+      console.log(chalk.yellow('⚠ ERROR'));
+    } else if (result.passed) {
+      passed++;
+      console.log(chalk.green('✓ PASS'));
+    } else {
+      failed++;
+      console.log(chalk.red('✗ FAIL'));
+    }
+  }
+
+  // Summary
+  console.log();
+  console.log(chalk.bold('Summary:'));
+  console.log(`  ${chalk.green(`${passed} passed`)}  ${chalk.red(`${failed} failed`)}  ${chalk.yellow(`${errors} errors`)}`);
+  console.log();
+
+  // JSON output
+  if (options.json) {
+    console.log(JSON.stringify(results, null, 2));
+  }
+
+  // HTML output
+  if (options.html) {
+    const html = generateBatchReport(results, 'JLC-CLI Validation Report');
+    writeFileSync(options.html, html);
+    console.log(chalk.dim(`HTML report: ${options.html}`));
+  }
+
+  process.exit(failed > 0 || errors > 0 ? 1 : 0);
+}

package/src/index.ts

@@ -9,8 +9,9 @@ import { Command } from 'commander';
 import { searchCommand } from './commands/search.js';
 import { infoCommand } from './commands/info.js';
 import { installCommand } from './commands/install.js';
-import { libraryCommand } from './commands/library.js';
+import { libraryCommand, regenerateCommand } from './commands/library.js';
 import { easyedaSearchCommand, easyedaInstallCommand } from './commands/easyeda.js';
+import { validateCommand } from './commands/validate.js';
 
 const program = new Command();
 
@@ -58,9 +59,14 @@ program
     });
   });
 
-program
+// Library subcommand group
+const library = program
   .command('library')
-  .description('View JLC-MCP library status and installed components')
+  .description('JLC-MCP library management');
+
+library
+  .command('status', { isDefault: true })
+  .description('View library status and installed components')
   .option('--json', 'Output as JSON')
   .action(async (options) => {
     await libraryCommand({
@@ -68,6 +74,38 @@ program
     });
   });
 
+library
+  .command('regenerate')
+  .description('Regenerate all installed components (refetch and reconvert symbols, footprints, 3D models)')
+  .option('-p, --project <path>', 'Regenerate project-local library')
+  .option('--no-3d', 'Skip 3D model download')
+  .action(async (options) => {
+    await regenerateCommand({
+      projectPath: options.project,
+      include3d: options['3d'],
+    });
+  });
+
+program
+  .command('validate [id]')
+  .description('Validate footprint/symbol generation against JLCPCB reference')
+  .option('--footprint-only', 'Only validate footprint')
+  .option('--symbol-only', 'Only validate symbol')
+  .option('-c, --category <name>', 'Validate all components in category')
+  .option('-a, --all', 'Validate all test fixtures')
+  .option('--html <path>', 'Output HTML report to file')
+  .option('--json', 'Output as JSON')
+  .action(async (id, options) => {
+    await validateCommand(id, {
+      footprintOnly: options.footprintOnly,
+      symbolOnly: options.symbolOnly,
+      category: options.category,
+      all: options.all,
+      html: options.html,
+      json: options.json,
+    });
+  });
+
 // EasyEDA subcommand group
 const easyeda = program
   .command('easyeda')