@emmraan/ai-skills 1.0.2 → 1.2.0

package/src/commands/remove.ts

@@ -5,9 +5,11 @@ import {
   updateSkillInstallPathsInLockfile,
 } from '../core/lockfile.js';
 import { AGENT_PLATFORMS, type InstallLocation, type InstallOptions } from '../core/config.js';
-import { error, success, info } from '../utils/logger.js';
+import { error, info, section, highlight } from '../utils/logger.js';
 import { ui } from '../utils/ui.js';
 import inquirer from 'inquirer';
+import chalk from 'chalk';
+import pc from 'picocolors';
 
 export interface CliRemoveFlags {
   local?: boolean;
@@ -145,9 +147,15 @@ async function promptRemoveOptions(): Promise<InstallOptions> {
 
 export async function remove(skillName: string, options: InstallOptions = {}): Promise<boolean> {
   try {
+    section(`Removing ${chalk.bold.cyan(skillName)}`);
+
     const entry = await getSkillEntry(skillName);
     if (!entry) {
+      // eslint-disable-next-line no-console
+      console.log('');
       info(`${skillName} is not installed`);
+      // eslint-disable-next-line no-console
+      console.log('');
       return true;
     }
 
@@ -162,7 +170,33 @@ export async function remove(skillName: string, options: InstallOptions = {}): P
     }
 
     ui.stopSpinnerSuccess(`Removed files for ${skillName}`);
-    success(`Removed ${skillName} from ${removedPaths.length} location(s)`);
+
+    // Print summary
+    // eslint-disable-next-line no-console
+    console.log('');
+    highlight(`✨ Successfully removed ${skillName}`);
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log(pc.gray('Removed from locations:'));
+    removedPaths.forEach((path) => {
+      // eslint-disable-next-line no-console
+      console.log(`  ${pc.red('✗')} ${pc.cyan(path)}`);
+    });
+
+    if (remaining.length > 0) {
+      // eslint-disable-next-line no-console
+      console.log('');
+      // eslint-disable-next-line no-console
+      console.log(pc.gray('Still installed at:'));
+      remaining.forEach((path) => {
+        // eslint-disable-next-line no-console
+        console.log(`  ${pc.green('✓')} ${pc.cyan(path)}`);
+      });
+    }
+    // eslint-disable-next-line no-console
+    console.log('');
+
     return true;
   } catch (err) {
     ui.stopSpinner();

package/src/commands/search.ts

@@ -0,0 +1,94 @@
+import { fetchRegistryIndex } from '../core/downloader.js';
+import { log, warn } from '../utils/logger.js';
+import { ui } from '../utils/ui.js';
+import chalk from 'chalk';
+
+export interface SearchOptions {
+  json?: boolean;
+  domain?: string;
+}
+
+interface SearchResult {
+  name: string;
+  version: string;
+  domains: string[];
+  lastGenerated: string;
+}
+
+function parseSearchFlags(args: string[]): SearchOptions {
+  const options: SearchOptions = { json: false };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--json') {
+      options.json = true;
+    } else if (args[i] === '--domain' && args[i + 1]) {
+      options.domain = args[i + 1];
+      i++;
+    }
+  }
+
+  return options;
+}
+
+function matchesQuery(skillName: string, domains: string[], query: string): boolean {
+  const lowerQuery = query.toLowerCase();
+
+  // Match on skill name
+  if (skillName.toLowerCase().includes(lowerQuery)) {
+    return true;
+  }
+
+  // Match on domains
+  if (domains.some((domain) => domain.toLowerCase().includes(lowerQuery))) {
+    return true;
+  }
+
+  return false;
+}
+
+export async function search(query: string, options: SearchOptions = {}): Promise<void> {
+  const flags = parseSearchFlags([]);
+  const mergedOptions = { ...flags, ...options };
+
+  const index = await fetchRegistryIndex();
+  const skillNames = Object.keys(index.skills);
+
+  // Filter by query
+  let results: SearchResult[] = skillNames
+    .filter((name) => matchesQuery(name, index.skills[name].domains, query))
+    .map((name) => ({
+      name,
+      version: index.skills[name].version,
+      domains: index.skills[name].domains,
+      lastGenerated: index.skills[name].lastGenerated,
+    }));
+
+  // Filter by domain if provided
+  if (mergedOptions.domain) {
+    results = results.filter((skill) => skill.domains.includes(mergedOptions.domain!));
+  }
+
+  // Output
+  if (mergedOptions.json) {
+    log(JSON.stringify(results, null, 2));
+  } else {
+    if (results.length === 0) {
+      warn(
+        `No skills found matching "${query}"${mergedOptions.domain ? ` in domain "${mergedOptions.domain}"` : ''}`
+      );
+    } else {
+      const formattedResults = results.map((r) => {
+        const domainStr = r.domains.length > 0 ? chalk.gray(` [${r.domains.join(', ')}]`) : '';
+        return `${chalk.cyan(r.name)}${chalk.gray(` v${r.version}`)}${domainStr}`;
+      });
+
+      ui.printBox(formattedResults, '🔍 Search Results');
+
+      log('');
+      log(chalk.gray(`💡 Tip: Use ${chalk.cyan('ai-skills install <skill>')} to install a skill`));
+      log('');
+    }
+  }
+}
+
+export { parseSearchFlags };

package/src/commands/update.ts

@@ -2,7 +2,9 @@ import { fetchSkill, fetchRegistryIndex } from '../core/downloader.js';
 import { installSkill } from '../core/installer.js';
 import { addSkillToLockfile, getInstalledSkills, getSkillEntry } from '../core/lockfile.js';
 import { sha256 } from '../utils/hash.js';
-import { error, success, info, warn } from '../utils/logger.js';
+import { error, success, info, warn, section, highlight, divider } from '../utils/logger.js';
+import chalk from 'chalk';
+import pc from 'picocolors';
 
 export async function update(options: { force?: boolean; skill?: string } = {}): Promise<boolean> {
   try {
@@ -12,10 +14,16 @@ export async function update(options: { force?: boolean; skill?: string } = {}):
     if (options.skill) {
       // Update specific skill
       const skillName = options.skill;
+      section(`Updating ${chalk.bold.cyan(skillName)}`);
+
       const entry = await getSkillEntry(skillName);
 
       if (!entry) {
+        // eslint-disable-next-line no-console
+        console.log('');
         warn(`${skillName} is not installed`);
+        // eslint-disable-next-line no-console
+        console.log('');
         return false;
       }
 
@@ -23,7 +31,11 @@ export async function update(options: { force?: boolean; skill?: string } = {}):
       const newHash = sha256(skillContent);
 
       if (newHash === entry.hash && !options.force) {
-        info(`${skillName} is already up-to-date`);
+        // eslint-disable-next-line no-console
+        console.log('');
+        info(`${skillName} is already up-to-date (v${entry.version})`);
+        // eslint-disable-next-line no-console
+        console.log('');
         return true;
       }
 
@@ -31,36 +43,68 @@ export async function update(options: { force?: boolean; skill?: string } = {}):
       const installPaths = await installSkill(skillName, skillContent);
       const version = index.skills[skillName]?.version || 'unknown';
       await addSkillToLockfile(skillName, version, newHash, installPaths);
-      success(`Updated ${skillName}`);
+
+      // eslint-disable-next-line no-console
+      console.log('');
+      highlight(`✨ Successfully updated ${skillName} to v${version}`);
+      // eslint-disable-next-line no-console
+      console.log('');
+      success(`Updated at ${installPaths.length} location(s)`);
+      // eslint-disable-next-line no-console
+      console.log('');
       return true;
     }
 
     // Update all installed skills
+    section('Updating all installed skills');
+    // eslint-disable-next-line no-console
+    console.log('');
+
     let updateCount = 0;
+    let alreadyUpToDate = 0;
+
     for (const entry of installed) {
       try {
+        // eslint-disable-next-line no-console
+        console.log(pc.cyan(`► ${entry.name} (v${entry.version})`));
         const skillContent = await fetchSkill(entry.name);
         const newHash = sha256(skillContent);
 
         if (newHash === entry.hash && !options.force) {
-          info(`${entry.name} is already up-to-date`);
+          // eslint-disable-next-line no-console
+          console.log(`  ${pc.gray('→')} Already up-to-date`);
+          alreadyUpToDate++;
           continue;
         }
 
-        info(`Updating ${entry.name}...`);
         const installPaths = await installSkill(entry.name, skillContent);
         const version = index.skills[entry.name]?.version || 'unknown';
         await addSkillToLockfile(entry.name, version, newHash, installPaths);
-        success(`Updated ${entry.name}`);
+        // eslint-disable-next-line no-console
+        console.log(`  ${pc.green('✓')} Updated to v${version}`);
         updateCount++;
       } catch (err) {
-        error(
-          `Failed to update ${entry.name}: ${err instanceof Error ? err.message : String(err)}`
-        );
+        // eslint-disable-next-line no-console
+        console.log(`  ${pc.red('✗')} Error: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
 
-    success(`Updated ${updateCount} skill(s)`);
+    // eslint-disable-next-line no-console
+    console.log('');
+    divider();
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log(chalk.bold('Update Summary:'));
+    // eslint-disable-next-line no-console
+    console.log(`  ${pc.green('✓')} Updated: ${chalk.bold(updateCount.toString())} skill(s)`);
+    // eslint-disable-next-line no-console
+    console.log(`  ${pc.gray('→')} Up-to-date: ${chalk.bold(alreadyUpToDate.toString())} skill(s)`);
+    // eslint-disable-next-line no-console
+    console.log('');
+    // eslint-disable-next-line no-console
+    console.log('');
+
     return true;
   } catch (err) {
     error(`Update failed: ${err instanceof Error ? err.message : String(err)}`);

package/src/index.ts

@@ -3,6 +3,7 @@ import { remove, parseRemoveFlags, resolveRemoveOptionsFromFlags } from './comma
 import { list } from './commands/list.js';
 import { update } from './commands/update.js';
 import { generateLocal } from './commands/generate-local.js';
+import { search, parseSearchFlags } from './commands/search.js';
 import { error, info } from './utils/logger.js';
 import { ui } from './utils/ui.js';
 
@@ -35,6 +36,11 @@ export async function main(): Promise<void> {
       const jsonFlag = args.includes('--json');
       await list(jsonFlag);
       process.exit(0);
+    } else if (command === 'search' && args.length >= 2) {
+      const query = args[1];
+      const flags = parseSearchFlags(args.slice(2));
+      await search(query, flags);
+      process.exit(0);
     } else if (command === 'update') {
       const forceFlag = args.includes('--force');
       let skillArg: string | undefined;
@@ -70,11 +76,12 @@ AI Skills CLI - Install framework-agnostic SKILLS.md files
 Usage:
   ai-skills <skill> [options]              Install a skill
   ai-skills install <skill> [options]      Install a skill
-  ai-skills list [--json]        List installed and available skills
-  ai-skills remove <skill> [options]   Remove an installed skill
-  ai-skills update [--force]     Update all installed skills
-                  [--skill <name>]   Update a specific skill
-  ai-skills generate-local [skill]    Run local backend generator
+  ai-skills list [--json]                  List installed and available skills
+  ai-skills search <query> [options]       Search for skills
+  ai-skills remove <skill> [options]       Remove an installed skill
+  ai-skills update [--force]               Update all installed skills
+                  [--skill <name>]         Update a specific skill
+  ai-skills generate-local [skill]         Run local backend generator
 
 Install options:
   --local                         Install in current project (.ai-skills/skills)
@@ -88,12 +95,19 @@ Remove options:
   --all                           Remove from all platforms for selected scope
   --platform <a,b,c>              Remove from selected platforms for selected scope
 
+Search options:
+  --domain <name>                 Filter results by domain
+  --json                          Output results as JSON
+
 Examples:
   ai-skills react
   ai-skills react --local
   ai-skills react --platform claude,gemini,opencode,vscode,codex,agents
   ai-skills install typescript
   ai-skills list
+  ai-skills search react
+  ai-skills search "testing" --domain frontend
+  ai-skills search python --json
   ai-skills remove python
   ai-skills update --force
   ai-skills update --skill react

package/src/utils/logger.ts

@@ -1,6 +1,7 @@
 /* eslint-disable no-console */
 
 import chalk from 'chalk';
+import pc from 'picocolors';
 
 export function log(message: string) {
   console.log(message);
@@ -11,13 +12,55 @@ export function info(message: string) {
 }
 
 export function success(message: string) {
-  console.log(`${chalk.green('✓')} ${chalk.green(message)}`);
+  console.log(`${pc.green('✓')} ${chalk.green(message)}`);
 }
 
 export function error(message: string) {
-  console.error(`${chalk.red('✗')} ${chalk.red(message)}`);
+  console.error(`${pc.red('✗')} ${chalk.red(message)}`);
 }
 
 export function warn(message: string) {
-  console.warn(`${chalk.yellow('⚠')} ${chalk.yellow(message)}`);
+  console.warn(`${pc.yellow('⚠')} ${chalk.yellow(message)}`);
+}
+
+export function debug(message: string) {
+  if (process.env.DEBUG) {
+    console.log(`${chalk.gray('→')} ${chalk.gray(message)}`);
+  }
+}
+
+export function divider() {
+  console.log(pc.gray('─'.repeat(60)));
+}
+
+export function section(title: string) {
+  console.log('');
+  console.log(chalk.bold.cyan(`► ${title}`));
+  console.log(pc.gray('─'.repeat(title.length + 2)));
+}
+
+export function highlight(message: string) {
+  console.log(chalk.bold.cyan(message));
+}
+
+export function badge(label: string, content: string) {
+  console.log(`${chalk.bgCyan.black(` ${label} `)} ${pc.cyan(content)}`);
+}
+
+export function card(title: string, content: string[]) {
+  console.log('');
+  console.log(chalk.bold.cyan(`┌─ ${title}`));
+  content.forEach((line) => {
+    console.log(chalk.cyan('│') + ` ${line}`);
+  });
+  console.log(chalk.cyan('└' + '─'.repeat(title.length + 3)));
+  console.log('');
+}
+
+export function progressBar(label: string, current: number, total: number) {
+  const percentage = Math.round((current / total) * 100);
+  const filled = Math.floor((percentage / 100) * 20);
+  const empty = 20 - filled;
+  const bar = `${pc.green('█'.repeat(filled))}${pc.gray('░'.repeat(empty))}`;
+  console.log(`${label}: [${bar}] ${pc.cyan(`${percentage}%`)}`);
 }

package/src/utils/ui.ts

@@ -1,57 +1,192 @@
-import chalk from 'chalk';
-import ora, { type Ora } from 'ora';
-import { info } from '../utils/logger.js';
-
-let activeSpinner: Ora | null = null;
-
-export const ui = {
-  bannerShown: false,
-
-  printBanner(): void {
-    if (this.bannerShown || !process.stdout.isTTY) {
-      return;
-    }
-
-    const title = chalk.bold.cyan('AI Skills CLI');
-    const subtitle = chalk.gray('Install framework-agnostic SKILLS.md files');
-    // Subtle, single-line banner to keep npx output concise
-    info(`${title} ${chalk.gray('•')} ${subtitle}`);
-    this.bannerShown = true;
-  },
-
-  startSpinner(text: string): void {
-    if (!process.stdout.isTTY) {
-      return;
-    }
-
-    if (activeSpinner) {
-      activeSpinner.stop();
-    }
-    activeSpinner = ora({ text, spinner: 'dots' }).start();
-  },
-
-  stopSpinnerSuccess(text?: string): void {
-    if (!activeSpinner) {
-      return;
-    }
-    activeSpinner.succeed(text);
-    activeSpinner = null;
-  },
-
-  stopSpinnerFail(text?: string): void {
-    if (!activeSpinner) {
-      return;
-    }
-    activeSpinner.fail(text);
-    activeSpinner = null;
-  },
-
-  stopSpinner(): void {
-    if (!activeSpinner) {
-      return;
-    }
-    activeSpinner.stop();
-    activeSpinner = null;
-  },
-};
-
+import chalk from 'chalk';
+import pc from 'picocolors';
+import ora, { type Ora } from 'ora';
+import { log } from '../utils/logger.js';
+
+let activeSpinner: Ora | null = null;
+
+const BOX_CHARS = {
+  TOP_LEFT: '╭',
+  TOP_RIGHT: '╮',
+  BOTTOM_LEFT: '╰',
+  BOTTOM_RIGHT: '╯',
+  HORIZONTAL: '─',
+  VERTICAL: '│',
+  T_DOWN: '┬',
+  T_UP: '┴',
+};
+
+export const ui = {
+  bannerShown: false,
+
+  printBanner(): void {
+    if (this.bannerShown || !process.stdout.isTTY) {
+      return;
+    }
+
+    const title = 'AI Skills CLI';
+    const subtitle = 'Install framework-agnostic SKILLS.md files';
+    const width = Math.max(title.length, subtitle.length) + 6;
+
+    log('');
+    log(
+      pc.cyan(
+        `${BOX_CHARS.TOP_LEFT}${BOX_CHARS.HORIZONTAL.repeat(width - 2)}${BOX_CHARS.TOP_RIGHT}`
+      )
+    );
+    log(
+      pc.cyan(`${BOX_CHARS.VERTICAL}`) +
+        ` ${chalk.bold.cyan(title)}${' '.repeat(width - 3 - title.length)}` +
+        pc.cyan(`${BOX_CHARS.VERTICAL}`)
+    );
+    log(
+      pc.cyan(`${BOX_CHARS.VERTICAL}`) +
+        ` ${pc.gray(subtitle)}${' '.repeat(width - 3 - subtitle.length)}` +
+        pc.cyan(`${BOX_CHARS.VERTICAL}`)
+    );
+    log(
+      pc.cyan(
+        `${BOX_CHARS.BOTTOM_LEFT}${BOX_CHARS.HORIZONTAL.repeat(width - 2)}${BOX_CHARS.BOTTOM_RIGHT}`
+      )
+    );
+    log('');
+
+    this.bannerShown = true;
+  },
+
+  printSection(title: string): void {
+    log('');
+    log(chalk.bold.cyan(`${BOX_CHARS.VERTICAL} ${title}`));
+    log(chalk.cyan(`${BOX_CHARS.VERTICAL}${BOX_CHARS.HORIZONTAL.repeat(title.length + 2)}`));
+  },
+
+  printDivider(char: string = '─'): void {
+    log(chalk.gray(char.repeat(60)));
+  },
+
+  printBox(content: string[], title?: string): void {
+    // eslint-disable-next-line no-control-regex
+    const maxLength = Math.max(
+      // eslint-disable-next-line no-control-regex
+      ...content.map((line) => line.replace(/\u001b\[[0-9;]*m/g, '').length)
+    );
+    const width = Math.min(maxLength + 4, 70);
+
+    if (title) {
+      log(
+        chalk.cyan(
+          `${BOX_CHARS.TOP_LEFT}${BOX_CHARS.HORIZONTAL.repeat(width - 2)}${BOX_CHARS.TOP_RIGHT}`
+        )
+      );
+    }
+
+    content.forEach((line) => {
+      // eslint-disable-next-line no-control-regex
+      const padding = width - 4 - line.replace(/\u001b\[[0-9;]*m/g, '').length;
+      log(
+        chalk.cyan(`${BOX_CHARS.VERTICAL} `) +
+          line +
+          ' '.repeat(Math.max(0, padding)) +
+          chalk.cyan(` ${BOX_CHARS.VERTICAL}`)
+      );
+    });
+
+    log(
+      chalk.cyan(
+        `${BOX_CHARS.BOTTOM_LEFT}${BOX_CHARS.HORIZONTAL.repeat(width - 2)}${BOX_CHARS.BOTTOM_RIGHT}`
+      )
+    );
+  },
+
+  startSpinner(text: string): void {
+    if (!process.stdout.isTTY) {
+      return;
+    }
+
+    if (activeSpinner) {
+      activeSpinner.stop();
+    }
+    activeSpinner = ora({
+      text: chalk.cyan(text),
+      spinner: 'dots2',
+    }).start();
+  },
+
+  stopSpinnerSuccess(text?: string): void {
+    if (!activeSpinner) {
+      return;
+    }
+    activeSpinner.succeed(chalk.green(text || 'Done'));
+    activeSpinner = null;
+  },
+
+  stopSpinnerFail(text?: string): void {
+    if (!activeSpinner) {
+      return;
+    }
+    activeSpinner.fail(chalk.red(text || 'Failed'));
+    activeSpinner = null;
+  },
+
+  stopSpinner(): void {
+    if (!activeSpinner) {
+      return;
+    }
+    activeSpinner.stop();
+    activeSpinner = null;
+  },
+
+  updateSpinner(text: string): void {
+    if (activeSpinner) {
+      activeSpinner.text = chalk.cyan(text);
+    }
+  },
+
+  printTable(rows: Array<string[]>, headers?: string[]): void {
+    if (headers) {
+      const headerRow = headers.map((h) => chalk.bold.cyan(h));
+      const separators = headers.map((h) => chalk.gray('─'.repeat(Math.max(h.length, 15))));
+
+      const maxWidths = headers.map((h, i) =>
+        Math.max(h.length, ...rows.map((r) => r[i]?.length || 0))
+      );
+
+      log(headerRow.map((h, i) => h.padEnd(maxWidths[i])).join(' ' + chalk.gray('│') + ' '));
+      log(separators.join('─' + chalk.gray('┼') + '─'));
+
+      rows.forEach((row) => {
+        log(row.map((cell, i) => cell.padEnd(maxWidths[i])).join(' ' + chalk.gray('│') + ' '));
+      });
+    } else {
+      rows.forEach((row) => {
+        log('  ' + row.join('  '));
+      });
+    }
+  },
+
+  printSummary(items: Array<{ label: string; value: string | number }>): void {
+    log('');
+    const maxLabelLength = Math.max(...items.map((i) => i.label.length));
+    items.forEach((item) => {
+      const paddedLabel = item.label.padEnd(maxLabelLength);
+      log(chalk.gray(`  ${paddedLabel}  `) + chalk.bold(String(item.value)));
+    });
+    log('');
+  },
+
+  printSuccess(message: string): void {
+    log(chalk.green(`✓ ${message}`));
+  },
+
+  printError(message: string): void {
+    log(chalk.red(`✗ ${message}`));
+  },
+
+  printWarning(message: string): void {
+    log(chalk.yellow(`⚠ ${message}`));
+  },
+
+  printInfo(message: string): void {
+    log(chalk.cyan(`ℹ ${message}`));
+  },
+};