figma-local 1.8.0 → 2.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "figma-local",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "description": "Control Figma Desktop with Claude Code. Smart read, write, and AI-prompt export. No API key required.",
   "author": "elvke",
   "license": "MIT",

package/skills/figma-library/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: figma-library
 description: |
-  Use this skill when the user wants to access, browse, import, or use components and variables from a Figma team library or external Figma file. Triggers on: "library components", "import component", "library variables", "team library", "use components from another file", "get the button from the library", "what components are available", "design system components", "import from library", "library collections". Also use when building UI and the user references a design system or component library in another Figma file.
+  Use this skill when the user wants to access, browse, import, or use components and variables from a Figma team library or external Figma file. Triggers on: "library components", "import component", "library variables", "team library", "use components from another file", "get the button from the library", "what components are available", "design system components", "import from library", "library collections", "index the library", "scan components", "search for a component". Also use when building UI and the user references a design system or component library in another Figma file.
 allowed-tools:
   - Bash(fig library *)
   - Bash(fig library)
@@ -11,143 +11,145 @@ allowed-tools:
 
 # Figma Library
 
-Access team library components and variables from other Figma files. Import components by key and browse available design tokens.
+Access team library components and variables from other Figma files. Index libraries via REST API or plugin, search components by name, import by key, and browse design tokens.
 
 ## Prerequisites
 
 - The `fig` CLI must be connected: `fig daemon status`. If not: `fig connect --safe`.
 - The Figma plugin must have `teamlibrary` permission in its manifest. If library commands fail with a permission error, re-import the plugin in Figma (Plugins → Development → Import from manifest).
-- Libraries must be enabled in the current Figma file (check Assets panel → team library icon).
 
-## Usage
+## IMPORTANT: How to access library components
 
-### List library variable collections
+Figma's plugin API does **not** allow browsing library components directly. To work with library components, you must **index** them first. There are three ways to index:
 
-See what variable collections are available from linked libraries:
+### Option A: REST API (recommended for large files)
 
+No plugin needed. Works on any file size without hanging Figma.
+
+**First time — provide token and file URL:**
 ```bash
-fig library collections
+fig library index --api --token "figd_xxxxx" --file "https://www.figma.com/design/ABC123/MyFile"
 ```
 
-Returns: collection name, library name, and collection key for each.
-
-### List library variables
-
-Browse all variables across all linked library collections:
+The token is saved for future use. Get one from: Figma → Settings → Personal Access Tokens.
 
+**After first time — just provide the file URL:**
 ```bash
-fig library variables
+fig library index --api --file "https://www.figma.com/design/ABC123/MyFile"
 ```
 
-Filter by name:
+### Option B: Page-by-page (for large files via plugin)
+
+Open the library file in Figma, then scan one page at a time:
 
 ```bash
-fig library variables --name "color"
-fig library variables --name "spacing"
-fig library variables --name "radius"
+fig library index --page "Buttons"
+fig library index --page "Inputs"
+fig library index --page "Cards"
 ```
 
-Returns: variable name, type (COLOR, FLOAT, STRING), key, collection, and library name.
+Each page's components are merged into the same index file. This avoids hanging on large files.
 
-### List library components
+### Option C: Full scan (small files only)
 
-Find library components that are already used on the current page:
+Open the library file in Figma, then:
 
 ```bash
-fig library components
+fig library index
 ```
 
-Filter by name:
+**Warning:** This scans ALL pages at once. Only use on small files — large design systems will cause Figma to hang.
+
+## After indexing: Search and Import
+
+### Search indexed libraries
 
 ```bash
-fig library components --name "button"
-fig library components --name "input"
-fig library components --name "card"
+fig library search --name "button"
+fig library search --name "input"
+fig library search --name "card"
+fig library search --name "checkbox"
 ```
 
-Returns: component name, component set, key, description, and whether it's remote (library) or local.
+Returns: component name, key (for importing), component set, page, and library name.
 
-### Import a component by key
-
-Import a library component onto the canvas by its key:
+### List indexed libraries
 
 ```bash
-fig library import --key "abc123def456..."
+fig library list
 ```
 
-Import and rename:
+### Import by key
 
 ```bash
-fig library import --key "abc123def456..." --name "PrimaryButton"
+fig library import --key "<key-from-search>"
+fig library import --key "<key>" --name "PrimaryButton"
 ```
 
-The imported component instance is placed at the viewport center and selected.
+The component is placed at viewport center and selected.
+
+### Inspect the imported component
+
+```bash
+fig inspect --deep
+```
 
-### JSON output
+## Variables (no indexing needed)
 
-All commands support `--json` for structured output:
+Library variables are available directly via the plugin API:
 
 ```bash
-fig library collections --json
-fig library variables --json
-fig library variables --name "color" --json
-fig library components --json
+fig library collections                    # List variable collections
+fig library variables                      # List all variables
+fig library variables --name "color"       # Search by name
 ```
 
-## Workflow: Building with library components
+## Components on current page
 
-1. **Discover** what's available:
-   ```bash
-   fig library collections
-   fig library variables --name "color"
-   fig library components --name "button"
-   ```
+Find library components already dragged onto the current page:
 
-2. **Import** the components you need:
-   ```bash
-   fig library import --key "<key-from-step-1>"
-   ```
+```bash
+fig library components
+fig library components --name "button"
+```
 
-3. **Inspect** the imported component to get its specs:
-   ```bash
-   fig inspect --deep
-   ```
+## Full workflow
 
-4. **Read** variables to get token values:
+1. **Index** the library (pick one method):
    ```bash
-   fig library variables --name "primary" --json
+   # Best for large files:
+   fig library index --api --token "figd_..." --file "https://..."
+   # Or page by page:
+   fig library index --page "Buttons"
    ```
 
-5. **Replicate** in code using the exact specs and token values.
-
-## Workflow: Extracting a design system
-
-1. List all variable collections:
+2. **Search** for components:
    ```bash
-   fig library collections --json
+   fig library search --name "button" --json
    ```
 
-2. Export all variables grouped by type:
+3. **Import** into your working file:
    ```bash
-   fig library variables --name "color" --json > colors.json
-   fig library variables --name "spacing" --json > spacing.json
-   fig library variables --name "radius" --json > radii.json
+   fig library import --key "<key>"
    ```
 
-3. Find key components:
+4. **Inspect** for full specs:
    ```bash
-   fig library components --json
+   fig inspect --deep
    ```
 
-4. Import and document each:
+5. **Get variables** for tokens:
    ```bash
-   fig library import --key "<key>"
-   fig document --json
+   fig library variables --name "primary" --json
    ```
 
+6. **Replicate** in code.
+
 ## Tips
 
-- If `fig library components` returns empty, drag some components from the Assets panel onto the page first — the command scans instances on the current page.
-- Use `fig library variables --json` and pipe to `jq` for filtering: `fig library variables --json | jq '.[] | select(.resolvedType == "COLOR")'`
-- After importing a component, use `fig inspect --deep` to get full specs including variable bindings.
+- **REST API is fastest** for large design systems — no file opening needed.
+- Token is saved after first use in `~/.figma-local/figma-token`.
+- Page-by-page indexing merges results — run multiple times to build up the index.
+- Re-index when the library is updated to get new components.
+- `fig library search --name "" --json` returns ALL indexed components.
 - Component keys are stable across file versions — save them for repeated imports.

package/src/index.js

@@ -5,7 +5,7 @@ import chalk from 'chalk';
 import ora from 'ora';
 import { execSync, spawn } from 'child_process';
 import { randomBytes } from 'crypto';
-import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, readdirSync } from 'fs';
 import { fileURLToPath, pathToFileURL } from 'url';
 import { dirname, join } from 'path';
 import { createInterface } from 'readline';
@@ -10581,21 +10581,34 @@ program
   .option('--key <key>', 'Component key for importing')
   .option('--name <name>', 'Filter by name (partial match)')
   .option('--json', 'Output raw JSON')
+  .option('--api', 'Use Figma REST API instead of plugin (for index)')
+  .option('--token <token>', 'Figma personal access token (for --api)')
+  .option('--file <url>', 'Figma file URL (for --api)')
+  .option('--page <pageName>', 'Index only a specific page (for index)')
   .addHelpText('after', `
 Actions:
   collections    List all available library variable collections
   variables      List variables from a library collection (use --name to filter)
-  components     List available library components (use --name to filter)
+  components     List available library components on current page (use --name to filter)
+  index          Scan and save all components to a local index
+  search         Search indexed libraries for components (use --name to filter)
   import         Import a component by key (use --key)
+  list           List all indexed libraries
+
+Index modes:
+  fig library index                                           Scan current file via plugin (small files)
+  fig library index --page "Buttons"                          Scan only one page (large files)
+  fig library index --api --token "figd_..." --file "URL"     Use REST API (best for large files)
+  fig library index --api --file "URL"                        Use saved token
 
 Examples:
   fig library collections                    List all library variable collections
-  fig library variables                      List all library variables
   fig library variables --name "color"       List variables matching "color"
-  fig library components                     List available library components
   fig library components --name "button"     Find button components
+  fig library index --api --token "figd_..." --file "https://www.figma.com/design/ABC/..."
+  fig library search --name "button"         Search indexed libraries for "button"
+  fig library list                           List all indexed libraries
   fig library import --key "abc123..."       Import a component by its key
-  fig library import --key "abc123..." --name "MyButton"  Import and rename
 `)
   .action(async (action, options) => {
     checkConnection();
@@ -10787,8 +10800,397 @@ Examples:
         spinner.succeed(`Imported "${result.componentName}" as ${result.name} (${result.w}x${result.h})`);
         console.log(`  ${chalk.gray('id:')} ${result.id}`);
         console.log(chalk.gray('  Component is now selected on the canvas.'));
+      } else if (action === 'index') {
+        // Helper to save index data and print summary
+        function saveIndexAndPrint(result, opts) {
+          const libDir = join(homedir(), '.figma-local', 'libraries');
+          mkdirSync(libDir, { recursive: true });
+          const safeName = result.fileName.replace(/[^a-zA-Z0-9_-]/g, '_').toLowerCase();
+          const libFile = join(libDir, `${safeName}.json`);
+
+          // If file exists and we're doing page-by-page, merge
+          let existingComponents = [];
+          let existingPages = new Set();
+          if (opts.page && existsSync(libFile)) {
+            try {
+              const existing = JSON.parse(readFileSync(libFile, 'utf8'));
+              // Keep components from OTHER pages
+              existingComponents = (existing.components || []).filter(c => c.page !== opts.page);
+              existing.components.forEach(c => existingPages.add(c.page));
+            } catch (e) { /* fresh start */ }
+          }
+          const mergedComponents = [...existingComponents, ...result.components];
+          result.components.forEach(c => existingPages.add(c.page));
+
+          const indexData = {
+            fileName: result.fileName,
+            fileKey: result.fileKey || '',
+            indexedAt: new Date().toISOString(),
+            pageCount: opts.page ? existingPages.size : result.pageCount,
+            componentCount: mergedComponents.length,
+            components: mergedComponents
+          };
+          writeFileSync(libFile, JSON.stringify(indexData, null, 2));
+          return { indexData, libFile };
+        }
+
+        function printIndexSummary(indexData, libFile, opts) {
+          console.log(`  ${chalk.gray('Saved to:')} ${libFile}`);
+          if (opts.json) {
+            console.log(JSON.stringify(indexData, null, 2));
+          } else {
+            const sets = {};
+            const standalone = [];
+            for (const c of indexData.components) {
+              if (c.componentSet) {
+                if (!sets[c.componentSet]) sets[c.componentSet] = [];
+                sets[c.componentSet].push(c);
+              } else {
+                standalone.push(c);
+              }
+            }
+            if (Object.keys(sets).length > 0) {
+              console.log(chalk.cyan('\n  Component Sets:'));
+              for (const [setName, variants] of Object.entries(sets)) {
+                console.log(`    ${chalk.white(setName)} ${chalk.gray(`(${variants.length} variant${variants.length !== 1 ? 's' : ''})`)}`);
+              }
+            }
+            if (standalone.length > 0) {
+              console.log(chalk.cyan('\n  Standalone Components:'));
+              for (const c of standalone.slice(0, 50)) {
+                console.log(`    ${chalk.white(c.name)} ${chalk.gray(`[${c.page}]`)}`);
+              }
+              if (standalone.length > 50) {
+                console.log(chalk.gray(`    ... and ${standalone.length - 50} more`));
+              }
+            }
+          }
+        }
+
+        // ---- REST API mode ----
+        if (options.api) {
+          // Get or save token
+          const configDir = join(homedir(), '.figma-local');
+          mkdirSync(configDir, { recursive: true });
+          const tokenFile = join(configDir, 'figma-token');
+          let token = options.token || '';
+          if (!token && existsSync(tokenFile)) {
+            token = readFileSync(tokenFile, 'utf8').trim();
+          }
+          if (!token) {
+            spinner.fail('Figma token required. Get one from: Figma → Settings → Personal Access Tokens\nThen run: fig library index --api --token "figd_..." --file "URL"');
+            process.exit(1);
+          }
+          // Save token for future use
+          if (options.token) {
+            writeFileSync(tokenFile, token);
+          }
+
+          if (!options.file) {
+            spinner.fail('--file is required with --api. Provide a Figma file URL.\nExample: fig library index --api --file "https://www.figma.com/design/ABC123/MyFile"');
+            process.exit(1);
+          }
+
+          // Extract file key from URL
+          const fileKeyMatch = options.file.match(/(?:file|design)\/([a-zA-Z0-9]+)/);
+          if (!fileKeyMatch) {
+            spinner.fail('Could not extract file key from URL. Use a URL like: https://www.figma.com/design/ABC123/MyFile');
+            process.exit(1);
+          }
+          const fileKey = fileKeyMatch[1];
+
+          spinner.text = `Fetching file metadata from Figma API...`;
+
+          // Fetch the file from the REST API
+          const https = await import('https');
+          function figmaApiGet(endpoint) {
+            return new Promise((resolve, reject) => {
+              const url = `https://api.figma.com/v1${endpoint}`;
+              const req = https.get(url, { headers: { 'X-Figma-Token': token } }, (res) => {
+                let data = '';
+                res.on('data', chunk => data += chunk);
+                res.on('end', () => {
+                  if (res.statusCode === 403) {
+                    reject(new Error('Access denied. Check your token has read access to this file.'));
+                  } else if (res.statusCode === 404) {
+                    reject(new Error('File not found. Check the URL is correct.'));
+                  } else if (res.statusCode !== 200) {
+                    reject(new Error(`Figma API returned ${res.statusCode}: ${data.slice(0, 200)}`));
+                  } else {
+                    try { resolve(JSON.parse(data)); }
+                    catch (e) { reject(new Error('Invalid JSON response from Figma API')); }
+                  }
+                });
+              });
+              req.on('error', reject);
+            });
+          }
+
+          try {
+            // Get file components via the components endpoint (lightweight)
+            spinner.text = 'Fetching components from Figma API...';
+            const compData = await figmaApiGet(`/files/${fileKey}/components`);
+
+            const components = [];
+            if (compData.meta && compData.meta.components) {
+              for (const comp of compData.meta.components) {
+                const c = {
+                  name: comp.name,
+                  key: comp.key,
+                  id: comp.node_id,
+                  page: comp.containing_frame ? comp.containing_frame.pageName || '' : '',
+                  description: comp.description || '',
+                };
+                if (comp.containing_frame && comp.containing_frame.name) {
+                  // The containing_frame for component set variants shows the set name
+                  c.componentSet = comp.containing_frame.name !== comp.name ? comp.containing_frame.name : undefined;
+                }
+                components.push(c);
+              }
+            }
+
+            // Also get component sets
+            spinner.text = 'Fetching component sets from Figma API...';
+            try {
+              const setsData = await figmaApiGet(`/files/${fileKey}/component_sets`);
+              if (setsData.meta && setsData.meta.component_sets) {
+                for (const set of setsData.meta.component_sets) {
+                  // Mark components that belong to this set
+                  for (const comp of components) {
+                    if (comp.id && set.node_id && comp.componentSet === undefined) {
+                      // Check if node is child of this set by matching containing_frame
+                    }
+                  }
+                }
+              }
+            } catch (e) { /* component_sets endpoint may not exist for all plans */ }
+
+            // Get file name
+            spinner.text = 'Fetching file info...';
+            let fileName = fileKey;
+            try {
+              const fileInfo = await figmaApiGet(`/files/${fileKey}?depth=1`);
+              if (fileInfo.name) fileName = fileInfo.name;
+            } catch (e) { /* use fileKey as fallback */ }
+
+            const result = {
+              fileName,
+              fileKey,
+              pageCount: 0,
+              componentCount: components.length,
+              components
+            };
+
+            const { indexData, libFile } = saveIndexAndPrint(result, options);
+            spinner.succeed(`Indexed ${components.length} components from "${fileName}" via API`);
+            printIndexSummary(indexData, libFile, options);
+
+          } catch (e) {
+            spinner.fail(`Figma API error: ${e.message}`);
+            process.exit(1);
+          }
+
+        // ---- Plugin mode with --page filter ----
+        } else if (options.page) {
+          const pageName = options.page;
+          spinner.text = `Scanning page "${pageName}" for components...`;
+          const safePageName = pageName.replace(/'/g, "\\'");
+          const code = `(function() {
+            try {
+              var components = [];
+              var targetPage = null;
+              var pages = figma.root.children;
+              for (var p = 0; p < pages.length; p++) {
+                if (pages[p].name === '${safePageName}' || pages[p].name.toLowerCase().indexOf('${safePageName.toLowerCase()}') !== -1) {
+                  targetPage = pages[p];
+                  break;
+                }
+              }
+              if (!targetPage) {
+                return { error: 'Page "${safePageName}" not found. Available pages: ' + pages.map(function(p) { return p.name; }).join(', ') };
+              }
+              function scanNode(node, pageName) {
+                if (node.type === 'COMPONENT') {
+                  var comp = {
+                    name: node.name,
+                    key: node.key,
+                    id: node.id,
+                    page: pageName,
+                    description: node.description || '',
+                    w: Math.round(node.width),
+                    h: Math.round(node.height)
+                  };
+                  if (node.parent && node.parent.type === 'COMPONENT_SET') {
+                    comp.componentSet = node.parent.name;
+                  }
+                  components.push(comp);
+                }
+                if ('children' in node) {
+                  for (var i = 0; i < node.children.length; i++) {
+                    scanNode(node.children[i], pageName);
+                  }
+                }
+              }
+              scanNode(targetPage, targetPage.name);
+              return {
+                fileName: figma.root.name,
+                fileKey: figma.fileKey || '',
+                pageCount: 1,
+                componentCount: components.length,
+                components: components
+              };
+            } catch(e) {
+              return { error: e.message || 'Failed to scan page for components.' };
+            }
+          })()`;
+          const result = await daemonExec('eval', { code });
+          if (result.error) {
+            spinner.fail(result.error);
+            process.exit(1);
+          }
+          const { indexData, libFile } = saveIndexAndPrint(result, { page: pageName });
+          spinner.succeed(`Indexed ${result.componentCount} components from page "${pageName}" (${indexData.componentCount} total in library)`);
+          printIndexSummary(indexData, libFile, options);
+
+        // ---- Plugin mode full scan ----
+        } else {
+          spinner.text = 'Scanning all pages for components...';
+          const code = `(function() {
+            try {
+              var components = [];
+              var pages = figma.root.children;
+              for (var p = 0; p < pages.length; p++) {
+                var page = pages[p];
+                function scanNode(node, pageName) {
+                  if (node.type === 'COMPONENT') {
+                    var comp = {
+                      name: node.name,
+                      key: node.key,
+                      id: node.id,
+                      page: pageName,
+                      description: node.description || '',
+                      w: Math.round(node.width),
+                      h: Math.round(node.height)
+                    };
+                    if (node.parent && node.parent.type === 'COMPONENT_SET') {
+                      comp.componentSet = node.parent.name;
+                    }
+                    components.push(comp);
+                  }
+                  if ('children' in node) {
+                    for (var i = 0; i < node.children.length; i++) {
+                      scanNode(node.children[i], pageName);
+                    }
+                  }
+                }
+                scanNode(page, page.name);
+              }
+              return {
+                fileName: figma.root.name,
+                fileKey: figma.fileKey || '',
+                pageCount: pages.length,
+                componentCount: components.length,
+                components: components
+              };
+            } catch(e) {
+              return { error: e.message || 'Failed to scan file for components.' };
+            }
+          })()`;
+          const result = await daemonExec('eval', { code });
+          if (result.error) {
+            spinner.fail(result.error);
+            process.exit(1);
+          }
+          const { indexData, libFile } = saveIndexAndPrint(result, {});
+          spinner.succeed(`Indexed ${result.componentCount} components from "${result.fileName}" (${result.pageCount} pages)`);
+          printIndexSummary(indexData, libFile, options);
+        }
+      } else if (action === 'search') {
+        const nameFilter = options.name ? options.name.toLowerCase() : '';
+        if (!nameFilter) {
+          spinner.fail('--name is required for search. Example: fig library search --name "button"');
+          process.exit(1);
+        }
+        spinner.text = `Searching indexed libraries for "${options.name}"...`;
+        const libDir = join(homedir(), '.figma-local', 'libraries');
+        if (!existsSync(libDir)) {
+          spinner.fail('No indexed libraries found. Open a library file in Figma and run: fig library index');
+          process.exit(1);
+        }
+        const files = readdirSync(libDir).filter(f => f.endsWith('.json'));
+        if (files.length === 0) {
+          spinner.fail('No indexed libraries found. Open a library file in Figma and run: fig library index');
+          process.exit(1);
+        }
+        const results = [];
+        for (const file of files) {
+          try {
+            const lib = JSON.parse(readFileSync(join(libDir, file), 'utf8'));
+            for (const comp of lib.components) {
+              const matchName = comp.name.toLowerCase().includes(nameFilter);
+              const matchSet = comp.componentSet && comp.componentSet.toLowerCase().includes(nameFilter);
+              const matchDesc = comp.description && comp.description.toLowerCase().includes(nameFilter);
+              if (matchName || matchSet || matchDesc) {
+                results.push({ ...comp, library: lib.fileName });
+              }
+            }
+          } catch (e) { /* skip corrupt files */ }
+        }
+        spinner.succeed(`Found ${results.length} component${results.length !== 1 ? 's' : ''} matching "${options.name}"`);
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+        } else {
+          if (results.length === 0) {
+            console.log(chalk.yellow('  No matches. Try a different search term, or index more libraries with: fig library index'));
+          }
+          let currentLib = '';
+          for (const c of results) {
+            if (c.library !== currentLib) {
+              currentLib = c.library;
+              console.log(chalk.cyan(`\n  ${currentLib}`));
+            }
+            const setLabel = c.componentSet ? chalk.gray(` (set: ${c.componentSet})`) : '';
+            console.log(`    ${chalk.white(c.name)}${setLabel}`);
+            console.log(`      ${chalk.gray('key:')} ${c.key}  ${chalk.gray('page:')} ${c.page}  ${chalk.gray(`${c.w}x${c.h}`)}`);
+            if (c.description) console.log(`      ${chalk.gray('desc:')} ${c.description}`);
+          }
+        }
+      } else if (action === 'list') {
+        spinner.text = 'Loading indexed libraries...';
+        const libDir = join(homedir(), '.figma-local', 'libraries');
+        if (!existsSync(libDir)) {
+          spinner.fail('No indexed libraries found. Open a library file in Figma and run: fig library index');
+          process.exit(1);
+        }
+        const files = readdirSync(libDir).filter(f => f.endsWith('.json'));
+        if (files.length === 0) {
+          spinner.fail('No indexed libraries found. Open a library file in Figma and run: fig library index');
+          process.exit(1);
+        }
+        const libs = [];
+        for (const file of files) {
+          try {
+            const lib = JSON.parse(readFileSync(join(libDir, file), 'utf8'));
+            libs.push({
+              fileName: lib.fileName,
+              componentCount: lib.componentCount,
+              pageCount: lib.pageCount,
+              indexedAt: lib.indexedAt,
+              path: join(libDir, file)
+            });
+          } catch (e) { /* skip corrupt files */ }
+        }
+        spinner.succeed(`${libs.length} indexed librar${libs.length !== 1 ? 'ies' : 'y'}`);
+        if (options.json) {
+          console.log(JSON.stringify(libs, null, 2));
+        } else {
+          for (const lib of libs) {
+            console.log(`  ${chalk.white(lib.fileName)}`);
+            console.log(`    ${chalk.gray('components:')} ${lib.componentCount}  ${chalk.gray('pages:')} ${lib.pageCount}  ${chalk.gray('indexed:')} ${lib.indexedAt}`);
+          }
+        }
       } else {
-        spinner.fail(`Unknown action: ${action}. Use: collections, variables, components, import`);
+        spinner.fail(`Unknown action: ${action}. Use: collections, variables, components, index, search, list, import`);
         process.exit(1);
       }
     } catch (e) {