kirohub 1.0.0 → 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [1.1.0] - 2026-02-23
+
+### Added
+- Interactive CLI mode
+- Search by resource type (`--type`)
+- Search by category (`--category`)
+
+## [1.0.1] - Initial release

package/README.md

@@ -2,35 +2,78 @@
 
 Install and discover Kiro resources from the command line.
 
-## Usage
+## Installation
+
+```bash
+npx kirohub
+```
+
+## Interactive Mode
+
+Run without arguments to launch the interactive menu:
+
+```bash
+npx kirohub
+```
+
+This provides a guided experience to search, install, list, and remove resources with type and category filters.
+
+## Commands
+
+### Search
 
 ```bash
 npx kirohub search <query>
+```
+
+Options:
+- `-t, --type <type>` — Filter by type: `Steering`, `Hook`, `Power`, `Prompt`, `Agent`, `Skill`
+- `-c, --category <cat>` — Filter by category: `aws`, `frontend`, `backend`, `api-design`, `documentation`, `devops`, `security`, `testing`, `database`, `ai-ml`, `architecture`, `developer-tools`, `typescript`, `python`, `java`, `rust`, `golang`, `csharp`
+- `-l, --limit <n>` — Limit results (default: 10)
+- `--json` — Output as JSON for scripting
+
+Examples:
+
+```bash
+npx kirohub search terraform
+npx kirohub search aws --type Steering
+npx kirohub search react --category frontend --limit 20
+npx kirohub search api --type Hook --category backend --json
+```
+
+### Add
+
+```bash
 npx kirohub add <owner/resource>
+```
+
+Options:
+- `-y, --yes` — Skip confirmation prompt
+
+### List
+
+```bash
 npx kirohub list
 ```
 
-## Examples
+Shows installed resources in your `.kiro/` directory.
+
+### Remove
 
 ```bash
-npx kirohub search steering
-npx kirohub add owner/my-steering
-npx kirohub add kirodotdev/power-builder
+npx kirohub remove [resource]
 ```
 
+Options:
+- `-y, --yes` — Skip confirmation prompt
+
+If no resource is specified, shows an interactive picker.
+
 ## Publish (Maintainers)
 
 ```bash
 cd packages/cli
 npm install
 npm run build
-node dist/cli.js --help
-npm login
 npm publish --access public
 ```
-
-Test the published CLI:
-
-```bash
-npx kirohub --help
-```

package/dist/cli.js

@@ -1,8 +1,11 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
+import * as p from '@clack/prompts';
 import { addResource } from './commands/add.js';
 import { listResources } from './commands/list.js';
-import { searchResources } from './commands/search.js';
+import { searchResources, fetchResources } from './commands/search.js';
+import { removeResource } from './commands/remove.js';
+import { showBanner, showLogo } from './utils/banner.js';
 const program = new Command();
 program
     .name('kirohub')
@@ -11,8 +14,12 @@ program
 program
     .command('add <resource>')
     .description('Install a Kiro resource (e.g., owner/resource-name)')
+    .option('-y, --yes', 'Skip confirmation prompt')
     .option('--no-telemetry', 'Disable telemetry')
-    .action(addResource);
+    .action((resource, options) => {
+    showLogo();
+    addResource(resource, options);
+});
 program
     .command('list')
     .description('List installed resources')
@@ -20,6 +27,140 @@ program
 program
     .command('search <query>')
     .description('Search available resources')
-    .option('-t, --type <type>', 'Filter by type')
+    .option('-t, --type <type>', 'Filter by type (Steering, Hook, Power, Prompt, Agent, Skill)')
+    .option('-c, --category <category>', 'Filter by category (aws, frontend, backend, etc.)')
+    .option('-l, --limit <n>', 'Limit results (default: 10)')
+    .option('--json', 'Output as JSON (for scripting)')
     .action(searchResources);
-program.parse();
+program
+    .command('remove [resource]')
+    .description('Remove an installed resource')
+    .option('-y, --yes', 'Skip confirmation prompt')
+    .action((resource, options) => {
+    showLogo();
+    removeResource(resource, options);
+});
+async function interactiveMenu() {
+    showBanner();
+    while (true) {
+        const action = await p.select({
+            message: 'What would you like to do?',
+            options: [
+                { value: 'search', label: 'Search resources', hint: 'find and install from hub' },
+                { value: 'add', label: 'Add a resource', hint: 'install by slug' },
+                { value: 'list', label: 'List installed', hint: 'show local resources' },
+                { value: 'remove', label: 'Remove a resource', hint: 'uninstall' },
+                { value: 'exit', label: 'Exit' },
+            ],
+        });
+        if (p.isCancel(action) || action === 'exit') {
+            p.outro('Goodbye!');
+            break;
+        }
+        console.log();
+        if (action === 'search') {
+            const query = await p.text({
+                message: 'Search query:',
+                placeholder: 'e.g., aws, terraform, react',
+            });
+            if (p.isCancel(query))
+                continue;
+            const filterType = await p.select({
+                message: 'Filter by type?',
+                options: [
+                    { value: '', label: 'All types' },
+                    { value: 'Steering', label: 'Steering', hint: 'context files' },
+                    { value: 'Hook', label: 'Hook', hint: 'event triggers' },
+                    { value: 'Power', label: 'Power', hint: 'bundled packages' },
+                    { value: 'Prompt', label: 'Prompt', hint: 'CLI prompts' },
+                    { value: 'Agent', label: 'Agent', hint: 'agent configs' },
+                    { value: 'Skill', label: 'Skill', hint: 'agent skills' },
+                ],
+            });
+            if (p.isCancel(filterType))
+                continue;
+            const filterCategory = await p.select({
+                message: 'Filter by category?',
+                options: [
+                    { value: '', label: 'All categories' },
+                    { value: 'aws', label: 'AWS' },
+                    { value: 'frontend', label: 'Frontend' },
+                    { value: 'backend', label: 'Backend' },
+                    { value: 'api-design', label: 'API Design' },
+                    { value: 'documentation', label: 'Documentation' },
+                    { value: 'devops', label: 'DevOps' },
+                    { value: 'security', label: 'Security' },
+                    { value: 'testing', label: 'Testing' },
+                    { value: 'database', label: 'Database' },
+                    { value: 'ai-ml', label: 'AI/ML' },
+                    { value: 'architecture', label: 'Architecture' },
+                    { value: 'developer-tools', label: 'Developer Tools' },
+                    { value: 'typescript', label: 'TypeScript' },
+                    { value: 'python', label: 'Python' },
+                    { value: 'java', label: 'Java' },
+                    { value: 'rust', label: 'Rust' },
+                    { value: 'golang', label: 'Go' },
+                    { value: 'csharp', label: 'C#' },
+                ],
+            });
+            if (p.isCancel(filterCategory))
+                continue;
+            const s = p.spinner();
+            s.start('Searching...');
+            try {
+                const results = await fetchResources(query, {
+                    type: filterType || undefined,
+                    category: filterCategory || undefined,
+                    limit: 20,
+                });
+                s.stop(`Found ${results.length} resources`);
+                if (results.length === 0) {
+                    p.log.warn('No resources found.');
+                    continue;
+                }
+                const selected = await p.select({
+                    message: 'Select to install (or esc to cancel)',
+                    options: results.map(r => ({
+                        value: r.slug,
+                        label: `${r.slug}${r.overallScore ? ` [${r.overallScore}]` : ''}`,
+                        hint: r.type,
+                    })),
+                });
+                if (p.isCancel(selected))
+                    continue;
+                await addResource(selected, { yes: true });
+            }
+            catch (err) {
+                s.stop(`Search failed: ${err.message}`);
+            }
+        }
+        else if (action === 'add') {
+            const slug = await p.text({
+                message: 'Resource slug:',
+                placeholder: 'e.g., owner/resource-name',
+            });
+            if (p.isCancel(slug))
+                continue;
+            await addResource(slug, {});
+        }
+        else if (action === 'list') {
+            await listResources();
+        }
+        else if (action === 'remove') {
+            await removeResource(undefined, {});
+        }
+        console.log();
+    }
+}
+// Show interactive menu when no command provided
+if (process.argv.length <= 2) {
+    if (process.stdout.isTTY) {
+        interactiveMenu();
+    }
+    else {
+        showBanner();
+    }
+}
+else {
+    program.parse();
+}

package/dist/commands/add.js

@@ -1,11 +1,16 @@
-import { writeFileSync, mkdirSync } from 'fs';
+import { writeFileSync, mkdirSync, existsSync } from 'fs';
 import { join, dirname, basename } from 'path';
 import chalk from 'chalk';
-import ora from 'ora';
+import * as p from '@clack/prompts';
 import { trackResourceInstall, trackCommand } from '../utils/telemetry.js';
 const KIROHUB_API = 'https://kirohub.dev/resource-map.json';
+function isInteractive() {
+    return process.stdout.isTTY === true;
+}
 export async function addResource(resourceSlug, options) {
-    const spinner = ora('Fetching resource...').start();
+    const skipPrompts = options.yes || !isInteractive();
+    const s = p.spinner();
+    s.start('Fetching resource...');
     try {
         // Fetch resource map
         const response = await fetch(KIROHUB_API);
@@ -16,22 +21,46 @@ export async function addResource(resourceSlug, options) {
         // Find resource by slug
         const resource = resources.find(r => r.slug === resourceSlug);
         if (!resource) {
-            spinner.fail(`Resource "${resourceSlug}" not found`);
-            console.log(chalk.gray('Available resources:'));
-            resources.slice(0, 5).forEach(r => {
-                console.log(chalk.gray(`  ${r.slug} (${r.type})`));
-            });
+            s.stop(`Resource "${resourceSlug}" not found`);
+            if (isInteractive()) {
+                console.log(chalk.gray('Available resources:'));
+                resources.slice(0, 5).forEach(r => {
+                    console.log(chalk.gray(`  ${r.slug} (${r.type})`));
+                });
+            }
             return;
         }
-        spinner.text = `Installing ${resource.name}...`;
+        // Determine installation path
+        const installPath = getInstallPath(resource);
+        s.stop('Found resource');
+        // Check if file exists and prompt for confirmation
+        if (existsSync(installPath) && !skipPrompts) {
+            const overwrite = await p.confirm({
+                message: `File already exists at ${installPath}. Overwrite?`,
+            });
+            if (p.isCancel(overwrite) || !overwrite) {
+                p.cancel('Cancelled.');
+                return;
+            }
+        }
+        // Prompt for confirmation if not using -y flag
+        if (!skipPrompts && !existsSync(installPath)) {
+            p.note(`${resource.name} (${resource.type})\n→ ${installPath}`, 'Resource');
+            const proceed = await p.confirm({
+                message: 'Install this resource?',
+            });
+            if (p.isCancel(proceed) || !proceed) {
+                p.cancel('Cancelled.');
+                return;
+            }
+        }
+        s.start(`Installing ${resource.name}...`);
         // Fetch file content
         const fileResponse = await fetch(resource.githubRawUrl);
         if (!fileResponse.ok) {
             throw new Error(`Failed to fetch resource file: ${fileResponse.status} ${fileResponse.statusText}`);
         }
         const content = await fileResponse.text();
-        // Determine installation path
-        const installPath = getInstallPath(resource);
         // Create directory if needed
         mkdirSync(dirname(installPath), { recursive: true });
         // Write file
@@ -41,13 +70,13 @@ export async function addResource(resourceSlug, options) {
             trackResourceInstall(resource.slug, resource.type);
             trackCommand('add');
         }
-        spinner.succeed(`Installed ${chalk.green(resource.name)} to ${chalk.gray(installPath)}`);
+        s.stop(`Installed ${resource.name} to ${installPath}`);
     }
     catch (error) {
-        spinner.fail(`Failed to install resource: ${error.message}`);
+        s.stop(`Failed: ${error.message}`);
     }
 }
-function getInstallPath(resource) {
+export function getInstallPath(resource) {
     const cwd = process.cwd();
     const safeName = sanitizeName(resource.name || resource.slug);
     const safeSlug = sanitizeName(resource.slug);
@@ -69,7 +98,7 @@ function getInstallPath(resource) {
             return join(cwd, '.kiro', 'resources', safeName);
     }
 }
-function sanitizeName(value) {
+export function sanitizeName(value) {
     return value
         .toLowerCase()
         .trim()

package/dist/commands/add.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import { join } from 'path';
+import { getInstallPath, sanitizeName } from './add.js';
+describe('sanitizeName', () => {
+    it('lowercases and trims', () => {
+        expect(sanitizeName('  Hello World  ')).toBe('hello-world');
+    });
+    it('replaces special chars with hyphens', () => {
+        expect(sanitizeName('my@resource!name')).toBe('my-resource-name');
+    });
+    it('collapses multiple hyphens', () => {
+        expect(sanitizeName('a---b')).toBe('a-b');
+    });
+    it('strips leading/trailing slashes', () => {
+        expect(sanitizeName('/owner/repo/')).toBe('owner/repo');
+    });
+    it('preserves dots, underscores, slashes', () => {
+        expect(sanitizeName('my_file.md')).toBe('my_file.md');
+        expect(sanitizeName('owner/repo')).toBe('owner/repo');
+    });
+});
+describe('getInstallPath', () => {
+    const cwd = process.cwd();
+    const makeResource = (overrides) => ({
+        id: '1',
+        name: 'Test Resource',
+        slug: 'owner/test-resource',
+        type: 'Steering',
+        url: '',
+        githubRepo: 'owner/repo',
+        githubFile: 'architecture.md',
+        githubRawUrl: '',
+        ...overrides,
+    });
+    it('puts steering files in .kiro/steering/', () => {
+        const result = getInstallPath(makeResource({ type: 'Steering', githubFile: 'architecture.md' }));
+        expect(result).toBe(join(cwd, '.kiro', 'steering', 'architecture.md'));
+    });
+    it('puts hooks in .kiro/hooks/', () => {
+        const result = getInstallPath(makeResource({ type: 'Hook', githubFile: 'on-save.kiro.hook' }));
+        expect(result).toBe(join(cwd, '.kiro', 'hooks', 'on-save.kiro.hook'));
+    });
+    it('puts powers in .kiro/powers/<slug>/', () => {
+        const result = getInstallPath(makeResource({ type: 'Power', githubFile: 'power.json', slug: 'owner/my-power' }));
+        expect(result).toBe(join(cwd, '.kiro', 'powers', 'owner/my-power', 'power.json'));
+    });
+    it('puts prompts in .kiro/prompts/', () => {
+        const result = getInstallPath(makeResource({ type: 'Prompt', githubFile: 'deploy.md' }));
+        expect(result).toBe(join(cwd, '.kiro', 'prompts', 'deploy.md'));
+    });
+    it('puts agents in .kiro/agents/', () => {
+        const result = getInstallPath(makeResource({ type: 'Agent', githubFile: 'reviewer.json' }));
+        expect(result).toBe(join(cwd, '.kiro', 'agents', 'reviewer.json'));
+    });
+    it('puts skills in .kiro/skills/<slug>/', () => {
+        const result = getInstallPath(makeResource({ type: 'Skill', githubFile: 'SKILL.md', slug: 'owner/my-skill' }));
+        expect(result).toBe(join(cwd, '.kiro', 'skills', 'owner/my-skill', 'SKILL.md'));
+    });
+    it('falls back to sanitized name when no githubFile', () => {
+        const result = getInstallPath(makeResource({ type: 'Steering', githubFile: '', name: 'My Resource' }));
+        expect(result).toBe(join(cwd, '.kiro', 'steering', 'my-resource.md'));
+    });
+    it('uses default path for unknown type', () => {
+        const result = getInstallPath(makeResource({ type: 'Unknown', githubFile: '' }));
+        expect(result).toContain(join('.kiro', 'resources'));
+    });
+});

package/dist/commands/remove.js

@@ -0,0 +1,101 @@
+import { readdirSync, rmSync, statSync, existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import * as p from '@clack/prompts';
+import { trackCommand } from '../utils/telemetry.js';
+const KIRO_DIRS = [
+    { path: '.kiro/steering', type: 'Steering' },
+    { path: '.kiro/hooks', type: 'Hook' },
+    { path: '.kiro/powers', type: 'Power' },
+    { path: '.kiro/prompts', type: 'Prompt' },
+    { path: '.kiro/agents', type: 'Agent' },
+    { path: '.kiro/skills', type: 'Skill' },
+];
+function isInteractive() {
+    return process.stdout.isTTY === true;
+}
+function getInstalledResources() {
+    const cwd = process.cwd();
+    const resources = [];
+    for (const dir of KIRO_DIRS) {
+        const fullPath = join(cwd, dir.path);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            const entries = readdirSync(fullPath);
+            for (const entry of entries) {
+                if (entry.startsWith('.'))
+                    continue;
+                const entryPath = join(fullPath, entry);
+                const stat = statSync(entryPath);
+                resources.push({
+                    name: entry.replace(/\.(md|kiro\.hook|json)$/, ''),
+                    path: entryPath,
+                    type: dir.type,
+                    isDir: stat.isDirectory(),
+                });
+            }
+        }
+        catch {
+            // Directory doesn't exist or can't be read
+        }
+    }
+    return resources;
+}
+export async function removeResource(resourceName, options) {
+    const skipPrompts = options.yes || !isInteractive();
+    const resources = getInstalledResources();
+    if (resources.length === 0) {
+        p.log.warn('No installed resources found.');
+        return;
+    }
+    // If no resource specified and interactive, show selection
+    if (!resourceName) {
+        if (!isInteractive()) {
+            p.log.error('Resource name required in non-interactive mode.');
+            console.log(chalk.gray('Usage: kirohub remove <resource-name> -y'));
+            return;
+        }
+        const selected = await p.select({
+            message: 'Select resource to remove',
+            options: resources.map(r => ({
+                value: r.name,
+                label: r.name,
+                hint: r.type,
+            })),
+        });
+        if (p.isCancel(selected)) {
+            p.cancel('Cancelled.');
+            return;
+        }
+        resourceName = selected;
+    }
+    // Find the resource
+    const resource = resources.find(r => r.name.toLowerCase() === resourceName.toLowerCase());
+    if (!resource) {
+        p.log.error(`Resource "${resourceName}" not found.`);
+        console.log(chalk.gray('Use `kirohub list` to see installed resources.'));
+        return;
+    }
+    // Confirm removal
+    if (!skipPrompts) {
+        p.note(`${resource.name} (${resource.type})\n${resource.path}`, 'Resource');
+        const proceed = await p.confirm({
+            message: 'Remove this resource?',
+        });
+        if (p.isCancel(proceed) || !proceed) {
+            p.cancel('Cancelled.');
+            return;
+        }
+    }
+    const s = p.spinner();
+    s.start(`Removing ${resource.name}...`);
+    try {
+        rmSync(resource.path, { recursive: true });
+        trackCommand('remove');
+        s.stop(`Removed ${resource.name}`);
+    }
+    catch (error) {
+        s.stop(`Failed: ${error.message}`);
+    }
+}

package/dist/commands/search.js

@@ -1,39 +1,138 @@
 import chalk from 'chalk';
 import { trackCommand } from '../utils/telemetry.js';
-const KIROHUB_API = 'https://kirohub.dev/resource-map.json';
+const KIROHUB_BASE = 'https://kirohub.dev';
+export const TYPES = ['Steering', 'Hook', 'Power', 'Prompt', 'Agent', 'Skill'];
+export const CATEGORIES = [
+    'aws', 'frontend', 'backend', 'api-design', 'documentation', 'devops',
+    'security', 'testing', 'database', 'ai-ml', 'architecture',
+    'developer-tools', 'typescript', 'python', 'java', 'rust', 'golang', 'csharp',
+];
+export function getApiUrl(options) {
+    // Use specific map if filtering by type or category
+    if (options.type) {
+        const typeMatch = TYPES.find(t => t.toLowerCase() === options.type.toLowerCase());
+        if (typeMatch)
+            return `${KIROHUB_BASE}/resource-map-${typeMatch.toLowerCase()}.json`;
+    }
+    if (options.category) {
+        const catMatch = CATEGORIES.find(c => c === options.category.toLowerCase());
+        if (catMatch)
+            return `${KIROHUB_BASE}/resource-map-category-${catMatch}.json`;
+    }
+    return `${KIROHUB_BASE}/resource-map.json`;
+}
+export async function fetchResources(query, options) {
+    const apiUrl = getApiUrl(options);
+    const response = await fetch(apiUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch resource map: ${response.status} ${response.statusText}`);
+    }
+    let resources = await response.json();
+    if (options.type && options.category) {
+        const cat = options.category.toLowerCase();
+        resources = resources.filter(r => r.categories?.includes(cat));
+    }
+    const results = resources.filter(r => r.name.toLowerCase().includes(query.toLowerCase()) ||
+        r.slug.toLowerCase().includes(query.toLowerCase()));
+    results.sort((a, b) => (b.overallScore ?? 0) - (a.overallScore ?? 0));
+    const limit = options.limit ? Math.max(1, parseInt(options.limit, 10) || 10) : 10;
+    return results.slice(0, limit);
+}
 export async function searchResources(query, options) {
     try {
         trackCommand('search');
-        const response = await fetch(KIROHUB_API);
+        // Validate type filter
+        if (options.type) {
+            const typeMatch = TYPES.find(t => t.toLowerCase() === options.type.toLowerCase());
+            if (!typeMatch) {
+                if (options.json) {
+                    console.log(JSON.stringify({ error: `Unknown type: ${options.type}`, availableTypes: TYPES }));
+                }
+                else {
+                    console.log(chalk.yellow(`Unknown type "${options.type}". Available: ${TYPES.join(', ')}`));
+                }
+                return;
+            }
+        }
+        // Validate category filter
+        if (options.category) {
+            const catMatch = CATEGORIES.find(c => c === options.category.toLowerCase());
+            if (!catMatch) {
+                if (options.json) {
+                    console.log(JSON.stringify({ error: `Unknown category: ${options.category}`, availableCategories: CATEGORIES }));
+                }
+                else {
+                    console.log(chalk.yellow(`Unknown category "${options.category}".`));
+                    console.log(chalk.gray(`Available: ${CATEGORIES.join(', ')}`));
+                }
+                return;
+            }
+        }
+        const apiUrl = getApiUrl(options);
+        const response = await fetch(apiUrl);
         if (!response.ok) {
             throw new Error(`Failed to fetch resource map: ${response.status} ${response.statusText}`);
         }
-        const resources = await response.json();
-        // Filter by type if specified
-        let filtered = resources;
-        if (options.type) {
-            filtered = resources.filter(r => r.type.toLowerCase() === options.type.toLowerCase());
+        let resources = await response.json();
+        // Client-side category filter when type map was fetched (type takes URL priority)
+        if (options.type && options.category) {
+            const cat = options.category.toLowerCase();
+            resources = resources.filter(r => r.categories?.includes(cat));
         }
         // Search by name/slug
-        const results = filtered.filter(r => r.name.toLowerCase().includes(query.toLowerCase()) ||
+        const results = resources.filter(r => r.name.toLowerCase().includes(query.toLowerCase()) ||
             r.slug.toLowerCase().includes(query.toLowerCase()));
+        // Sort by score if available
+        results.sort((a, b) => (b.overallScore ?? 0) - (a.overallScore ?? 0));
+        // Apply limit
+        const limit = Math.max(1, parseInt(options.limit, 10) || 10);
+        const limited = results.slice(0, limit);
+        // JSON output mode
+        if (options.json) {
+            console.log(JSON.stringify({
+                query,
+                total: results.length,
+                results: limited.map(r => ({
+                    slug: r.slug,
+                    name: r.name,
+                    type: r.type,
+                    categories: r.categories,
+                    score: r.overallScore,
+                    install: `npx kirohub add ${r.slug}`,
+                })),
+            }));
+            return;
+        }
         if (results.length === 0) {
             console.log(chalk.yellow(`No resources found for "${query}"`));
+            if (options.type)
+                console.log(chalk.gray(`  type: ${options.type}`));
+            if (options.category)
+                console.log(chalk.gray(`  category: ${options.category}`));
             return;
         }
         console.log(chalk.bold(`Found ${results.length} resources:`));
         console.log();
-        results.slice(0, 10).forEach(resource => {
-            console.log(chalk.green(`${resource.slug}`));
+        limited.forEach(resource => {
+            const score = resource.overallScore ? chalk.gray(` [${resource.overallScore}]`) : '';
+            console.log(chalk.green(`${resource.slug}`) + score);
             console.log(chalk.gray(`  Type: ${resource.type}`));
+            if (resource.categories?.length) {
+                console.log(chalk.gray(`  Categories: ${resource.categories.join(', ')}`));
+            }
             console.log(chalk.gray(`  Install: npx kirohub add ${resource.slug}`));
             console.log();
         });
-        if (results.length > 10) {
-            console.log(chalk.gray(`... and ${results.length - 10} more`));
+        if (results.length > limit) {
+            console.log(chalk.gray(`... and ${results.length - limit} more (use --limit to show more)`));
         }
     }
     catch (error) {
-        console.error(chalk.red(`Search failed: ${error.message}`));
+        if (options.json) {
+            console.log(JSON.stringify({ error: error.message }));
+        }
+        else {
+            console.error(chalk.red(`Search failed: ${error.message}`));
+        }
     }
 }

package/dist/commands/search.test.js

@@ -0,0 +1,115 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getApiUrl, TYPES, CATEGORIES } from './search.js';
+describe('getApiUrl', () => {
+    const base = 'https://kirohub.dev';
+    it('returns resource-map.json with no filters', () => {
+        expect(getApiUrl({})).toBe(`${base}/resource-map.json`);
+    });
+    it('returns type-specific map for type filter', () => {
+        expect(getApiUrl({ type: 'Steering' })).toBe(`${base}/steering.json`);
+        expect(getApiUrl({ type: 'Hook' })).toBe(`${base}/hook.json`);
+        expect(getApiUrl({ type: 'Power' })).toBe(`${base}/power.json`);
+    });
+    it('is case-insensitive for type', () => {
+        expect(getApiUrl({ type: 'steering' })).toBe(`${base}/steering.json`);
+        expect(getApiUrl({ type: 'HOOK' })).toBe(`${base}/hook.json`);
+    });
+    it('returns category-specific map for category filter', () => {
+        expect(getApiUrl({ category: 'aws' })).toBe(`${base}/aws.json`);
+        expect(getApiUrl({ category: 'frontend' })).toBe(`${base}/frontend.json`);
+    });
+    it('type takes priority over category for URL', () => {
+        expect(getApiUrl({ type: 'Steering', category: 'aws' })).toBe(`${base}/steering.json`);
+    });
+    it('falls back to resource-map.json for unknown type', () => {
+        expect(getApiUrl({ type: 'Unknown' })).toBe(`${base}/resource-map.json`);
+    });
+    it('falls back to resource-map.json for unknown category', () => {
+        expect(getApiUrl({ category: 'nonexistent' })).toBe(`${base}/resource-map.json`);
+    });
+});
+describe('searchResources JSON output', () => {
+    const mockResources = [
+        { id: '1', name: 'AWS Lambda Steering', slug: 'user/aws-lambda', type: 'Steering', url: '', categories: ['aws', 'backend'], overallScore: 90 },
+        { id: '2', name: 'React Hooks Guide', slug: 'user/react-hooks', type: 'Steering', url: '', categories: ['frontend'], overallScore: 85 },
+        { id: '3', name: 'AWS DynamoDB Hook', slug: 'user/aws-dynamo', type: 'Hook', url: '', categories: ['aws', 'database'], overallScore: 80 },
+    ];
+    beforeEach(() => {
+        vi.restoreAllMocks();
+        vi.resetModules();
+    });
+    it('filters by query and outputs JSON', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockResources),
+        }));
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { searchResources } = await import('./search.js');
+        await searchResources('aws', { json: true });
+        const output = JSON.parse(spy.mock.calls[0][0]);
+        expect(output.total).toBe(2);
+        expect(output.results[0].slug).toBe('user/aws-lambda');
+        expect(output.results[1].slug).toBe('user/aws-dynamo');
+    });
+    it('applies limit', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockResources),
+        }));
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { searchResources } = await import('./search.js');
+        await searchResources('', { json: true, limit: '1' });
+        const output = JSON.parse(spy.mock.calls[0][0]);
+        expect(output.total).toBe(3);
+        expect(output.results).toHaveLength(1);
+    });
+    it('defaults limit to 10 for invalid value', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockResources),
+        }));
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { searchResources } = await import('./search.js');
+        await searchResources('', { json: true, limit: 'foo' });
+        const output = JSON.parse(spy.mock.calls[0][0]);
+        expect(output.results).toHaveLength(3); // all 3, since default limit 10 > 3
+    });
+    it('sorts by score descending', async () => {
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(mockResources),
+        }));
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { searchResources } = await import('./search.js');
+        await searchResources('', { json: true });
+        const output = JSON.parse(spy.mock.calls[0][0]);
+        const scores = output.results.map((r) => r.score);
+        expect(scores).toEqual([90, 85, 80]);
+    });
+    it('applies client-side category filter when both type and category set', async () => {
+        // When fetching steering.json, only Steering resources come back
+        const steeringOnly = mockResources.filter(r => r.type === 'Steering');
+        vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(steeringOnly),
+        }));
+        const spy = vi.spyOn(console, 'log').mockImplementation(() => { });
+        const { searchResources } = await import('./search.js');
+        await searchResources('', { json: true, type: 'Steering', category: 'aws' });
+        const output = JSON.parse(spy.mock.calls[0][0]);
+        expect(output.total).toBe(1);
+        expect(output.results[0].slug).toBe('user/aws-lambda');
+    });
+});
+describe('constants', () => {
+    it('has 6 types', () => {
+        expect(TYPES).toHaveLength(6);
+        expect(TYPES).toContain('Steering');
+        expect(TYPES).toContain('Skill');
+    });
+    it('has 18 categories', () => {
+        expect(CATEGORIES).toHaveLength(18);
+        expect(CATEGORIES).toContain('aws');
+        expect(CATEGORIES).toContain('csharp');
+    });
+});

package/dist/utils/banner.js

@@ -0,0 +1,37 @@
+import * as p from '@clack/prompts';
+const RESET = '\x1b[0m';
+const DIM = '\x1b[38;5;102m';
+const TEXT = '\x1b[38;5;145m';
+const LOGO_LINES = [
+    '██╗  ██╗██╗██████╗  ██████╗     ██╗  ██╗██╗   ██╗██████╗ ',
+    '██║ ██╔╝██║██╔══██╗██╔═══██╗    ██║  ██║██║   ██║██╔══██╗',
+    '█████╔╝ ██║██████╔╝██║   ██║    ███████║██║   ██║██████╔╝',
+    '██╔═██╗ ██║██╔══██╗██║   ██║    ██╔══██║██║   ██║██╔══██╗',
+    '██║  ██╗██║██║  ██║╚██████╔╝    ██║  ██║╚██████╔╝██████╔╝',
+    '╚═╝  ╚═╝╚═╝╚═╝  ╚═╝ ╚═════╝     ╚═╝  ╚═╝ ╚═════╝ ╚═════╝ ',
+];
+const GRAYS = [
+    '\x1b[38;5;250m',
+    '\x1b[38;5;248m',
+    '\x1b[38;5;245m',
+    '\x1b[38;5;243m',
+    '\x1b[38;5;240m',
+    '\x1b[38;5;238m',
+];
+export function showLogo() {
+    console.log();
+    LOGO_LINES.forEach((line, i) => {
+        console.log(`${GRAYS[i]}${line}${RESET}`);
+    });
+    console.log();
+}
+export function showBanner() {
+    showLogo();
+    p.intro('The Kiro resource hub');
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx kirohub add ${DIM}<slug>${RESET}     ${DIM}Install a resource${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx kirohub list${RESET}           ${DIM}List installed resources${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx kirohub search ${DIM}<query>${RESET} ${DIM}Search resources${RESET}`);
+    console.log(`  ${DIM}$${RESET} ${TEXT}npx kirohub remove${RESET}         ${DIM}Remove resources${RESET}`);
+    console.log();
+    p.outro(`Discover more at ${TEXT}https://kirohub.dev/${RESET}`);
+}

package/dist/utils/telemetry.js

@@ -1,6 +1,6 @@
 // Telemetry endpoint — update this after deploying the Lambda Function URL
 // IMPORTANT: Replace this URL with the actual Lambda Function URL before publishing to npm
-const TELEMETRY_ENDPOINT = 'https://kirohub.dev/api/telemetry';
+const TELEMETRY_ENDPOINT = 'https://2ht62y6ttd7fwjoavzef7xtoge0mlzob.lambda-url.eu-west-1.on.aws/';
 const TELEMETRY_TIMEOUT = 1500;
 import { createRequire } from 'module';
 const require = createRequire(import.meta.url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kirohub",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "CLI for installing Kiro resources from KiroHub",
   "type": "module",
   "main": "dist/cli.js",
@@ -10,27 +10,39 @@
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "smoke": "node dist/cli.js --help",
     "postinstall": "node postinstall.cjs",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["kiro", "ai", "cli", "resources", "steering", "hooks", "powers"],
+  "keywords": [
+    "kiro",
+    "ai",
+    "cli",
+    "resources",
+    "steering",
+    "hooks",
+    "powers"
+  ],
   "author": "Kiro Community",
   "license": "MIT",
   "dependencies": {
-    "commander": "^12.0.0",
+    "@clack/prompts": "^1.0.1",
     "chalk": "^5.3.0",
-    "ora": "^8.0.1"
+    "commander": "^12.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "tsx": "^4.0.0",
-    "typescript": "^5.8.2"
+    "typescript": "^5.8.2",
+    "vitest": "^4.0.18"
   },
   "files": [
     "dist/**/*",
     "postinstall.cjs",
-    "README.md"
+    "README.md",
+    "CHANGELOG.md"
   ],
   "engines": {
     "node": ">=18"

package/postinstall.cjs

@@ -1,6 +1,6 @@
 // TODO: Update with actual Lambda Function URL after deployment
 // IMPORTANT: Replace this URL with the actual Lambda Function URL before publishing to npm
-const TELEMETRY_ENDPOINT = "https://kirohub.dev/api/telemetry";
+const TELEMETRY_ENDPOINT = "https://2ht62y6ttd7fwjoavzef7xtoge0mlzob.lambda-url.eu-west-1.on.aws/";
 
 function isTelemetryDisabled() {
   return (