@jlcpcb/cli 0.1.1 → 0.3.0

package/src/commands/install.ts

@@ -11,6 +11,11 @@ import { renderApp } from '../app/App.js';
 const componentService = createComponentService();
 const libraryService = createLibraryService();
 
+// LCSC IDs match pattern: C followed by digits (e.g., C2040, C5446)
+function isLcscId(id: string): boolean {
+  return /^C\d+$/i.test(id);
+}
+
 interface InstallOptions {
   projectPath?: string;
   include3d?: boolean;
@@ -18,6 +23,13 @@ interface InstallOptions {
 }
 
 export async function installCommand(id: string | undefined, options: InstallOptions): Promise<void> {
+  // Check if ID looks like an EasyEDA UUID (not an LCSC ID)
+  if (id && !isLcscId(id)) {
+    p.log.error(`"${id}" is not an LCSC part number (e.g., C2040).`);
+    p.log.info(`For EasyEDA community components, use: ${chalk.cyan(`jlc easyeda install ${id}`)}`);
+    process.exit(1);
+  }
+
   // If ID provided with --force, do direct install (non-interactive)
   if (id && options.force) {
     const spinner = p.spinner();
@@ -56,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;
@@ -88,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);
@@ -101,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,7 +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();
 
@@ -57,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({
@@ -67,4 +74,66 @@ 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')
+  .description('EasyEDA community component browser');
+
+easyeda
+  .command('search <query...>')
+  .description('Open browser-based component search')
+  .option('-p, --port <number>', 'HTTP server port', '3847')
+  .action(async (queryParts: string[], options) => {
+    const query = queryParts.join(' ');
+    await easyedaSearchCommand(query, {
+      port: options.port ? parseInt(options.port, 10) : undefined,
+    });
+  });
+
+easyeda
+  .command('install [uuid]')
+  .description('Install EasyEDA community component to KiCad libraries')
+  .option('-p, --project <path>', 'Install to project-local library')
+  .option('--with-3d', 'Include 3D model')
+  .option('-f, --force', 'Force reinstall (regenerate symbol and footprint)')
+  .action(async (uuid, options) => {
+    await easyedaInstallCommand(uuid, {
+      projectPath: options.project,
+      include3d: options.with3d,
+      force: options.force,
+    });
+  });
+
 program.parse();