@jlcpcb/cli 0.1.0

package/src/app/screens/SearchScreen.tsx

@@ -0,0 +1,74 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { createComponentService, type ComponentSearchResult } from '@jlcpcb/core';
+import { useNavigation, useCurrentScreen } from '../navigation/NavigationContext.js';
+import type { SearchParams } from '../navigation/types.js';
+import { useAppState } from '../state/AppStateContext.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { ListView } from '../components/ListView.js';
+
+const componentService = createComponentService();
+
+export function SearchScreen() {
+  const { push } = useNavigation();
+  const { params } = useCurrentScreen() as { screen: 'search'; params: SearchParams };
+  const { selectedIndex, setSelectedIndex, isFiltered, setIsFiltered, resetSelection } = useAppState();
+  const { columns: terminalWidth } = useTerminalSize();
+
+  const [results, setResults] = useState<ComponentSearchResult[]>(params.results);
+  const [isSearching, setIsSearching] = useState(false);
+
+  useInput(async (input, key) => {
+    if (isSearching) return;
+
+    if (key.upArrow) {
+      setSelectedIndex(Math.max(0, selectedIndex - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex(Math.min(results.length - 1, selectedIndex + 1));
+    } else if (key.return && results[selectedIndex]) {
+      push('info', {
+        componentId: results[selectedIndex].lcscId,
+        component: results[selectedIndex],
+      });
+    } else if (key.tab) {
+      setIsSearching(true);
+      const newFiltered = !isFiltered;
+      try {
+        let newResults = await componentService.search(params.query, {
+          limit: 20,
+          basicOnly: newFiltered,
+        });
+        newResults = newResults.sort((a, b) => {
+          if (a.libraryType === 'basic' && b.libraryType !== 'basic') return -1;
+          if (a.libraryType !== 'basic' && b.libraryType === 'basic') return 1;
+          return 0;
+        });
+        setResults(newResults);
+        resetSelection();
+        setIsFiltered(newFiltered);
+      } catch {
+        // Keep existing results on error
+      }
+      setIsSearching(false);
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <Box marginBottom={1}>
+        <Text bold>
+          Search: <Text color="cyan">{params.query}</Text>
+          {' '}
+          <Text dimColor>({results.length} results{isFiltered ? ' - Basic/Preferred only' : ''})</Text>
+          {isSearching && <Text color="yellow"> ⏳</Text>}
+        </Text>
+      </Box>
+      <ListView
+        results={results}
+        selectedIndex={selectedIndex}
+        isFiltered={isFiltered}
+        terminalWidth={terminalWidth}
+      />
+    </Box>
+  );
+}

package/src/app/state/AppStateContext.tsx

@@ -0,0 +1,64 @@
+import React, { createContext, useContext, useState, useCallback, type ReactNode } from 'react';
+
+export interface AppState {
+  selectedIndex: number;
+  isFiltered: boolean;
+  isLoading: boolean;
+}
+
+export interface AppStateActions {
+  setSelectedIndex: (index: number) => void;
+  setIsFiltered: (filtered: boolean) => void;
+  setIsLoading: (loading: boolean) => void;
+  resetSelection: () => void;
+}
+
+export type AppStateContextValue = AppState & AppStateActions;
+
+const AppStateContext = createContext<AppStateContextValue | null>(null);
+
+interface AppStateProviderProps {
+  children: ReactNode;
+}
+
+export function AppStateProvider({ children }: AppStateProviderProps) {
+  const [selectedIndex, setSelectedIndexState] = useState(0);
+  const [isFiltered, setIsFilteredState] = useState(false);
+  const [isLoading, setIsLoadingState] = useState(false);
+
+  const setSelectedIndex = useCallback((index: number) => {
+    setSelectedIndexState(index);
+  }, []);
+
+  const setIsFiltered = useCallback((filtered: boolean) => {
+    setIsFilteredState(filtered);
+  }, []);
+
+  const setIsLoading = useCallback((loading: boolean) => {
+    setIsLoadingState(loading);
+  }, []);
+
+  const resetSelection = useCallback(() => {
+    setSelectedIndexState(0);
+  }, []);
+
+  const value: AppStateContextValue = {
+    selectedIndex,
+    isFiltered,
+    isLoading,
+    setSelectedIndex,
+    setIsFiltered,
+    setIsLoading,
+    resetSelection,
+  };
+
+  return <AppStateContext.Provider value={value}>{children}</AppStateContext.Provider>;
+}
+
+export function useAppState(): AppStateContextValue {
+  const context = useContext(AppStateContext);
+  if (!context) {
+    throw new Error('useAppState must be used within AppStateProvider');
+  }
+  return context;
+}

package/src/commands/info.ts

@@ -0,0 +1,37 @@
+/**
+ * Info command
+ * Display component details
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { createComponentService } from '@jlcpcb/core';
+import { renderApp } from '../app/App.js';
+
+const componentService = createComponentService();
+
+interface InfoOptions {
+  json?: boolean;
+}
+
+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));
+    } catch (error) {
+      spinner.stop('Failed to fetch component');
+      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Interactive mode - launch TUI
+  renderApp('info', { componentId: id });
+}

package/src/commands/install.ts

@@ -0,0 +1,113 @@
+/**
+ * Install command
+ * Fetch component and add to KiCad libraries
+ */
+
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { createComponentService, createLibraryService, type SearchOptions } from '@jlcpcb/core';
+import { renderApp } from '../app/App.js';
+
+const componentService = createComponentService();
+const libraryService = createLibraryService();
+
+interface InstallOptions {
+  projectPath?: string;
+  include3d?: boolean;
+  force?: boolean;
+}
+
+export async function installCommand(id: string | undefined, options: InstallOptions): Promise<void> {
+  // If ID provided with --force, do direct install (non-interactive)
+  if (id && options.force) {
+    const spinner = p.spinner();
+    spinner.start(`Installing component ${id}...`);
+
+    try {
+      // Ensure libraries are set up
+      await libraryService.ensureGlobalTables();
+
+      // Install the component
+      const result = await libraryService.install(id, {
+        projectPath: options.projectPath,
+        include3d: options.include3d,
+        force: true,
+      });
+
+      spinner.stop(chalk.green('✓ Component installed'));
+
+      // Display result
+      console.log();
+      console.log(chalk.cyan('Symbol:    '), result.symbolRef);
+      console.log(chalk.cyan('Footprint: '), result.footprintRef);
+      console.log(chalk.cyan('Action:    '), result.symbolAction);
+      if (result.files.model3d) {
+        console.log(chalk.cyan('3D Model:  '), result.files.model3d);
+      }
+      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'}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // If ID provided (without --force), fetch component and launch TUI for install
+  if (id) {
+    const spinner = p.spinner();
+    spinner.start(`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 });
+    } catch (error) {
+      spinner.stop('Failed to fetch component');
+      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // No ID provided - interactive search mode using @clack/prompts
+  const query = await p.text({
+    message: 'Search for component:',
+    placeholder: 'e.g., STM32F103, ESP32, 10k resistor',
+    validate: (value) => {
+      if (!value) return 'Please enter a search term';
+      return undefined;
+    },
+  });
+
+  if (p.isCancel(query)) {
+    p.cancel('Installation cancelled');
+    process.exit(0);
+  }
+
+  const spinner = p.spinner();
+  spinner.start(`Searching for "${query}"...`);
+
+  const searchOptions: SearchOptions = { limit: 20 };
+  let results = await componentService.search(query as string, searchOptions);
+
+  // Sort results: basic parts first
+  results = results.sort((a, b) => {
+    if (a.libraryType === 'basic' && b.libraryType !== 'basic') return -1;
+    if (a.libraryType !== 'basic' && b.libraryType === 'basic') return 1;
+    return 0;
+  });
+
+  spinner.stop(`Found ${results.length} results`);
+
+  if (results.length === 0) {
+    p.log.warn('No components found. Try a different search term.');
+    return;
+  }
+
+  // Launch TUI for selection and install
+  renderApp('search', { query: query as string, results });
+}

package/src/commands/library.ts

@@ -0,0 +1,56 @@
+/**
+ * Library command
+ * View JLC-MCP library status and installed components
+ */
+
+import * as p from '@clack/prompts';
+import { createLibraryService } from '@jlcpcb/core';
+import { renderApp } from '../app/App.js';
+
+const libraryService = createLibraryService();
+
+interface LibraryOptions {
+  json?: boolean;
+}
+
+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
+        )
+      );
+    } catch (error) {
+      spinner.stop('Failed to get library status');
+      p.log.error(`Error: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Interactive mode - launch TUI
+  renderApp('library', {});
+}

package/src/commands/search.ts

@@ -0,0 +1,38 @@
+/**
+ * Search command
+ * Interactive search for components from LCSC or EasyEDA community
+ */
+
+import { createComponentService, type SearchOptions } from '@jlcpcb/core';
+import { renderApp } from '../app/App.js';
+
+const componentService = createComponentService();
+
+export async function searchCommand(query: string, options: SearchOptions): Promise<void> {
+  console.log(`Searching for "${query}"...`);
+
+  try {
+    let results = await componentService.search(query, options);
+
+    // Sort results: basic parts first, then extended
+    if (!options.basicOnly) {
+      results = results.sort((a, b) => {
+        if (a.libraryType === 'basic' && b.libraryType !== 'basic') return -1;
+        if (a.libraryType !== 'basic' && b.libraryType === 'basic') return 1;
+        return 0;
+      });
+    }
+
+    if (results.length === 0) {
+      console.log('No components found. Try a different search term.');
+      return;
+    }
+
+    // Clear the "Searching..." line and launch interactive UI
+    process.stdout.write('\x1b[1A\x1b[2K');
+    renderApp('search', { query, results });
+  } catch (error) {
+    console.error(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    process.exit(1);
+  }
+}

package/src/index.ts

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * jlc-cli
+ * CLI for JLC/EasyEDA component sourcing and KiCad library management
+ */
+
+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';
+
+const program = new Command();
+
+program
+  .name('jlc')
+  .description('JLC/EasyEDA component sourcing and KiCad library management')
+  .version('0.1.0');
+
+program
+  .command('search <query...>')
+  .description('Search for components (basic parts sorted first)')
+  .option('-l, --limit <number>', 'Maximum results', '20')
+  .option('--in-stock', 'Only show in-stock components')
+  .option('--basic-only', 'Only show basic parts (no extended)')
+  .option('--community', 'Search EasyEDA community library')
+  .action(async (queryParts: string[], options) => {
+    const query = queryParts.join(' ');
+    await searchCommand(query, {
+      limit: parseInt(options.limit, 10),
+      inStock: options.inStock,
+      basicOnly: options.basicOnly || false,
+      source: options.community ? 'easyeda-community' : 'lcsc',
+    });
+  });
+
+program
+  .command('info <id>')
+  .description('Get component details')
+  .option('--json', 'Output as JSON')
+  .action(async (id, options) => {
+    await infoCommand(id, { json: options.json });
+  });
+
+program
+  .command('install [id]')
+  .description('Install 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 (id, options) => {
+    await installCommand(id, {
+      projectPath: options.project,
+      include3d: options.with3d,
+      force: options.force,
+    });
+  });
+
+program
+  .command('library')
+  .description('View JLC-MCP library status and installed components')
+  .option('--json', 'Output as JSON')
+  .action(async (options) => {
+    await libraryCommand({
+      json: options.json,
+    });
+  });
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "jsx": "react-jsx",
+    "jsxImportSource": "react"
+  },
+  "include": ["src/**/*"]
+}