@jlcpcb/cli 0.3.2 → 0.4.1

package/src/commands/failures.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+
+function run(scenario: string) {
+  // Isolate module mocks and process.exit from other CLI/core tests.
+  return spawnSync(process.execPath, [join(import.meta.dir, '__fixtures__/failure-scenarios.ts'), scenario], {
+    encoding: 'utf8',
+    timeout: 15_000,
+  });
+}
+
+describe('command failure exit status', () => {
+  it('reports failed regenerations and exits unsuccessfully', () => {
+    const result = run('regenerate');
+    expect(result.status).toBe(1);
+    expect(result.stdout).toContain('C123');
+    expect(result.stdout).toContain('conversion failed');
+  });
+
+  it('does not pass absent requested reference SVGs in JSON', () => {
+    const result = run('missing');
+    expect(result.status).toBe(1);
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      success: false,
+      result: { passed: false, error: expect.stringContaining('footprint, symbol') },
+    });
+  });
+
+  it('reports absent requested references in text', () => {
+    const result = run('text-missing');
+    expect(result.status).toBe(1);
+    expect(result.stdout).toContain('Missing reference SVG: footprint, symbol');
+  });
+
+  it('counts missing references as batch errors instead of passes', () => {
+    const result = run('batch-missing');
+    expect(result.status).toBe(1);
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      success: false,
+      summary: { total: 1, passed: 0, failed: 0, errors: 1 },
+    });
+  });
+
+  it('allows an absent footprint reference when its check was disabled', () => {
+    const result = run('disabled-footprint');
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      success: true,
+      result: { passed: true, footprint: null, symbol: { passed: true } },
+    });
+  });
+
+  it('rejects symbol pin displacement through the real comparator', () => {
+    const result = run('symbol-moved');
+    expect(result.status).toBe(1);
+    const output = JSON.parse(result.stdout);
+    expect(output.success).toBe(false);
+    expect(output.result.symbol.errors.some((e: { field: string }) => e.field === 'position')).toBe(true);
+  });
+
+  it('does not pass symbol pins with unknown reference direction', () => {
+    const result = run('symbol-unverified');
+    expect(result.status).toBe(1);
+    const output = JSON.parse(result.stdout);
+    expect(output.success).toBe(false);
+    expect(output.result.symbol.errors.some((e: { field: string }) => e.field === 'coverage')).toBe(true);
+  });
+
+  it('rejects a manufacturing position mismatch through the real comparator', () => {
+    const result = run('footprint-moved');
+    expect(result.status).toBe(1);
+    const output = JSON.parse(result.stdout);
+    expect(output.success).toBe(false);
+    expect(output.result.footprint.errors.some((e: { field: string }) => e.field === 'position')).toBe(true);
+  });
+
+  it('does not claim success for an unverified reference copper layer', () => {
+    const result = run('footprint-unverified');
+    expect(result.status).toBe(1);
+    const output = JSON.parse(result.stdout);
+    expect(output.success).toBe(false);
+    expect(output.result.footprint.errors.some((e: { field: string }) => e.field === 'coverage')).toBe(true);
+  });
+
+  it('validates matching, fully described manufacturing geometry', () => {
+    const result = run('footprint-matching');
+    expect(result.status).toBe(0);
+    expect(JSON.parse(result.stdout)).toMatchObject({
+      success: true,
+      result: { passed: true, footprint: { passed: true, errors: [] } },
+    });
+  });
+
+  it.each(['mpn', 'package'])('rejects a changed fixture %s during batch validation', (field) => {
+    const result = run(`footprint-identity-${field}`);
+    expect(result.status).toBe(1);
+    const output = JSON.parse(result.stdout);
+    expect(output).toMatchObject({
+      success: false,
+      summary: { total: 1, passed: 0, failed: 0, errors: 1 },
+    });
+    expect(output.results[0].error).toMatch(field === 'mpn' ? /Fixture MPN differs/ : /Fixture package differs/);
+  });
+});

package/src/commands/info.ts

@@ -3,10 +3,9 @@
  * Display component details
  */
 
-import * as p from '@clack/prompts';
-import chalk from 'chalk';
 import { createComponentService } from '@jlcpcb/core';
 import { renderApp } from '../app/App.js';
+import { printJson, printJsonError, getErrorMessage } from '../utils/agent-output.js';
 
 const componentService = createComponentService();
 
@@ -17,16 +16,14 @@ interface InfoOptions {
 export async function infoCommand(id: string, options: InfoOptions): Promise<void> {
   // JSON mode - non-interactive output for scripting
   if (options.json) {
-    const spinner = p.spinner();
-    spinner.start(`Fetching component ${id}...`);
-
     try {
       const details = await componentService.getDetails(id);
-      spinner.stop('Component found');
-      console.log(JSON.stringify(details, null, 2));
+      printJson({
+        success: true,
+        component: details,
+      });
     } catch (error) {
-      spinner.stop('Failed to fetch component');
-      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      printJsonError('component_fetch_failed', getErrorMessage(error), { retryable: true });
       process.exit(1);
     }
     return;

package/src/commands/install.ts

@@ -7,6 +7,7 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { createComponentService, createLibraryService, type SearchOptions } from '@jlcpcb/core';
 import { renderApp } from '../app/App.js';
+import { printJson, printJsonError, getErrorMessage } from '../utils/agent-output.js';
 
 const componentService = createComponentService();
 const libraryService = createLibraryService();
@@ -19,34 +20,60 @@ function isLcscId(id: string): boolean {
 interface InstallOptions {
   projectPath?: string;
   include3d?: boolean;
+  yes?: boolean;
+  json?: boolean;
   force?: boolean;
 }
 
 export async function installCommand(id: string | undefined, options: InstallOptions): Promise<void> {
+  if (!id && (options.yes || options.json)) {
+    if (options.json) {
+      printJsonError('missing_id', 'Direct install requires an LCSC part number');
+    } else {
+      p.log.error('Direct install requires an LCSC part number.');
+    }
+    process.exit(1);
+  }
+
   // Check if ID looks like an EasyEDA UUID (not an LCSC ID)
   if (id && !isLcscId(id)) {
+    if (options.json) {
+      printJsonError('invalid_lcsc_id', `"${id}" is not an LCSC part number`, {
+        details: { hint: `Use jlc easyeda install ${id}` },
+      });
+      process.exit(1);
+    }
+
     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();
-    spinner.start(`Installing component ${id}...`);
+  // If ID provided with --yes or --json, do direct install (non-interactive).
+  if (id && (options.yes || options.json)) {
+    const spinner = options.json ? null : p.spinner();
+    spinner?.start(`Installing component ${id}...`);
 
     try {
       // Ensure libraries are set up
-      await libraryService.ensureGlobalTables();
+      if (!options.projectPath) await libraryService.ensureGlobalTables();
 
       // Install the component
       const result = await libraryService.install(id, {
         projectPath: options.projectPath,
         include3d: options.include3d,
-        force: true,
+        force: options.force,
       });
 
-      spinner.stop(chalk.green('✓ Component installed'));
+      spinner?.stop(chalk.green('✓ Component installed'));
+
+      if (options.json) {
+        printJson({
+          success: true,
+          result,
+        });
+        return;
+      }
 
       // Display result
       console.log();
@@ -59,14 +86,18 @@ export async function installCommand(id: string | undefined, options: InstallOpt
       console.log();
       console.log(chalk.dim(`Library: ${result.files.symbolLibrary}`));
     } catch (error) {
-      spinner.stop(chalk.red('✗ Installation failed'));
-      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      spinner?.stop(chalk.red('✗ Installation failed'));
+      if (options.json) {
+        printJsonError('install_failed', getErrorMessage(error), { retryable: true });
+      } else {
+        p.log.error(`Error: ${getErrorMessage(error)}`);
+      }
       process.exit(1);
     }
     return;
   }
 
-  // If ID provided (without --force), fetch component and launch TUI for install
+  // If ID provided, fetch component and launch TUI for install.
   if (id) {
     console.log(`Fetching component ${id}...`);
 
@@ -74,7 +105,7 @@ export async function installCommand(id: string | undefined, options: InstallOpt
       const details = await componentService.getDetails(id);
       // Clear the "Fetching..." line and launch interactive UI
       process.stdout.write('\x1b[1A\x1b[2K');
-      await renderApp('info', { componentId: id, component: details as any });
+      await renderApp('info', { componentId: id, component: details, installOptions: options });
     } catch (error) {
       console.error(`Failed to fetch component: ${error instanceof Error ? error.message : 'Unknown error'}`);
       process.exit(1);
@@ -116,5 +147,5 @@ export async function installCommand(id: string | undefined, options: InstallOpt
 
   // Clear the "Searching..." line and launch interactive UI
   process.stdout.write('\x1b[1A\x1b[2K');
-  await renderApp('search', { query: query as string, results });
+  await renderApp('search', { query: query as string, results, searchOptions, installOptions: options });
 }

package/src/commands/interactive-install.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'bun:test';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+describe('interactive install artifacts', () => {
+  for (const [scenario, behavior] of [
+    ['lcsc', 'reinstalls the selected LCSC project artifact with downloaded 3D bytes through no-ID search'],
+    ['community', 'ignores global community installation status and installs/reinstalls locally without 3D through no-ID search'],
+  ]) {
+    it(behavior, () => {
+      // Core services and Ink are real; only upstream clients and terminal/prompt IO are substituted.
+      const root = mkdtempSync(join(tmpdir(), 'jlc-interactive-install-'));
+      try {
+        const result = spawnSync(process.execPath, [
+          join(import.meta.dir, '../app/__fixtures__/interactive-install-scenarios.tsx'), scenario, root,
+        ], {
+          encoding: 'utf8',
+          timeout: 15_000,
+          env: { ...process.env, HOME: join(root, 'home'), USERPROFILE: join(root, 'home'), XDG_CONFIG_HOME: join(root, 'config') },
+        });
+        expect({ status: result.status, stderr: result.stderr }).toEqual({ status: 0, stderr: '' });
+      } finally {
+        rmSync(root, { recursive: true, force: true });
+      }
+    }, 20_000);
+  }
+});

package/src/commands/library.ts

@@ -7,6 +7,7 @@ import * as p from '@clack/prompts';
 import chalk from 'chalk';
 import { createLibraryService, type InstalledComponent } from '@jlcpcb/core';
 import { renderApp } from '../app/App.js';
+import { printJson, printJsonError, getErrorMessage } from '../utils/agent-output.js';
 
 const libraryService = createLibraryService();
 
@@ -17,36 +18,25 @@ interface LibraryOptions {
 export async function libraryCommand(options: LibraryOptions): Promise<void> {
   // JSON mode - non-interactive output for scripting
   if (options.json) {
-    const spinner = p.spinner();
-    spinner.start('Loading library status...');
-
     try {
       const [status, components] = await Promise.all([
         libraryService.getStatus(),
         libraryService.listInstalled({}),
       ]);
 
-      spinner.stop(`Found ${components.length} installed components`);
-
-      console.log(
-        JSON.stringify(
-          {
-            status: {
-              installed: status.installed,
-              linked: status.linked,
-              version: status.version,
-              componentCount: status.componentCount,
-              paths: status.paths,
-            },
-            components,
-          },
-          null,
-          2
-        )
-      );
+      printJson({
+        success: true,
+        status: {
+          installed: status.installed,
+          linked: status.linked,
+          version: status.version,
+          componentCount: status.componentCount,
+          paths: status.paths,
+        },
+        components,
+      });
     } catch (error) {
-      spinner.stop('Failed to get library status');
-      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      printJsonError('library_status_failed', getErrorMessage(error), { retryable: false });
       process.exit(1);
     }
     return;
@@ -101,5 +91,6 @@ export async function regenerateCommand(options: RegenerateOptions): Promise<voi
     for (const comp of result.components.filter(c => c.status === 'failed')) {
       console.log(chalk.red(`  • ${comp.name} (${comp.id}): ${comp.error}`));
     }
+    process.exitCode = 1;
   }
 }

package/src/commands/search.ts

@@ -5,11 +5,19 @@
 
 import { createComponentService, type SearchOptions } from '@jlcpcb/core';
 import { renderApp } from '../app/App.js';
+import { printJson, printJsonError, getErrorMessage } from '../utils/agent-output.js';
+import { formatSearchResultForJson } from '../utils/search-result-output.js';
 
 const componentService = createComponentService();
 
-export async function searchCommand(query: string, options: SearchOptions): Promise<void> {
-  console.log(`Searching for "${query}"...`);
+interface SearchCommandOptions extends SearchOptions {
+  json?: boolean;
+}
+
+export async function searchCommand(query: string, options: SearchCommandOptions): Promise<void> {
+  if (!options.json) {
+    console.log(`Searching for "${query}"...`);
+  }
 
   try {
     let results = await componentService.search(query, options);
@@ -24,15 +32,39 @@ export async function searchCommand(query: string, options: SearchOptions): Prom
     }
 
     if (results.length === 0) {
+      if (options.json) {
+        printJson({
+          success: true,
+          query,
+          count: 0,
+          results: [],
+        });
+        return;
+      }
+
       console.log('No components found. Try a different search term.');
       return;
     }
 
+    if (options.json) {
+      printJson({
+        success: true,
+        query,
+        count: results.length,
+        results: results.map(formatSearchResultForJson),
+      });
+      return;
+    }
+
     // Clear the "Searching..." line and launch interactive UI
     process.stdout.write('\x1b[1A\x1b[2K');
-    await renderApp('search', { query, results });
+    await renderApp('search', { query, results, searchOptions: options });
   } catch (error) {
-    console.error(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    if (options.json) {
+      printJsonError('search_failed', getErrorMessage(error), { retryable: true });
+    } else {
+      console.error(`Search failed: ${getErrorMessage(error)}`);
+    }
     process.exit(1);
   }
 }