kirohub 1.0.0

package/README.md

@@ -0,0 +1,36 @@
+# KiroHub CLI
+
+Install and discover Kiro resources from the command line.
+
+## Usage
+
+```bash
+npx kirohub search <query>
+npx kirohub add <owner/resource>
+npx kirohub list
+```
+
+## Examples
+
+```bash
+npx kirohub search steering
+npx kirohub add owner/my-steering
+npx kirohub add kirodotdev/power-builder
+```
+
+## 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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { addResource } from './commands/add.js';
+import { listResources } from './commands/list.js';
+import { searchResources } from './commands/search.js';
+const program = new Command();
+program
+    .name('kirohub')
+    .description('CLI for installing Kiro resources from KiroHub')
+    .version('1.0.0');
+program
+    .command('add <resource>')
+    .description('Install a Kiro resource (e.g., owner/resource-name)')
+    .option('--no-telemetry', 'Disable telemetry')
+    .action(addResource);
+program
+    .command('list')
+    .description('List installed resources')
+    .action(listResources);
+program
+    .command('search <query>')
+    .description('Search available resources')
+    .option('-t, --type <type>', 'Filter by type')
+    .action(searchResources);
+program.parse();

package/dist/commands/add.js

@@ -0,0 +1,79 @@
+import { writeFileSync, mkdirSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { trackResourceInstall, trackCommand } from '../utils/telemetry.js';
+const KIROHUB_API = 'https://kirohub.dev/resource-map.json';
+export async function addResource(resourceSlug, options) {
+    const spinner = ora('Fetching resource...').start();
+    try {
+        // Fetch resource map
+        const response = await fetch(KIROHUB_API);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch resource map: ${response.status} ${response.statusText}`);
+        }
+        const resources = await response.json();
+        // 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})`));
+            });
+            return;
+        }
+        spinner.text = `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
+        writeFileSync(installPath, content);
+        // Track telemetry
+        if (!options.noTelemetry) {
+            trackResourceInstall(resource.slug, resource.type);
+            trackCommand('add');
+        }
+        spinner.succeed(`Installed ${chalk.green(resource.name)} to ${chalk.gray(installPath)}`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to install resource: ${error.message}`);
+    }
+}
+function getInstallPath(resource) {
+    const cwd = process.cwd();
+    const safeName = sanitizeName(resource.name || resource.slug);
+    const safeSlug = sanitizeName(resource.slug);
+    const fileNameFromRepo = basename(resource.githubFile || '');
+    switch (resource.type.toLowerCase()) {
+        case 'steering':
+            return join(cwd, '.kiro', 'steering', fileNameFromRepo || `${safeName}.md`);
+        case 'hook':
+            return join(cwd, '.kiro', 'hooks', fileNameFromRepo || `${safeName}.kiro.hook`);
+        case 'power':
+            return join(cwd, '.kiro', 'powers', safeSlug || safeName, fileNameFromRepo || 'POWER.md');
+        case 'prompt':
+            return join(cwd, '.kiro', 'prompts', fileNameFromRepo || `${safeName}.md`);
+        case 'agent':
+            return join(cwd, '.kiro', 'agents', fileNameFromRepo || `${safeName}.json`);
+        case 'skill':
+            return join(cwd, '.kiro', 'skills', safeSlug || safeName, fileNameFromRepo || 'SKILL.md');
+        default:
+            return join(cwd, '.kiro', 'resources', safeName);
+    }
+}
+function sanitizeName(value) {
+    return value
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9-_./]+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^\/+|\/+$/g, "");
+}

package/dist/commands/list.js

@@ -0,0 +1,37 @@
+import { readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { trackCommand } from '../utils/telemetry.js';
+export async function listResources() {
+    trackCommand('list');
+    const cwd = process.cwd();
+    const kiroDir = join(cwd, '.kiro');
+    if (!existsSync(kiroDir)) {
+        console.log(chalk.yellow('No .kiro directory found. Install resources first.'));
+        return;
+    }
+    console.log(chalk.bold('Installed Kiro resources:'));
+    console.log();
+    const categories = [
+        { name: 'Steering', dir: 'steering', ext: '.md' },
+        { name: 'Hooks', dir: 'hooks', ext: '.kiro.hook' },
+        { name: 'Powers', dir: 'powers', ext: null },
+        { name: 'Prompts', dir: 'prompts', ext: '.md' },
+        { name: 'Agents', dir: 'agents', ext: '.json' },
+        { name: 'Skills', dir: 'skills', ext: null }
+    ];
+    categories.forEach(category => {
+        const categoryDir = join(kiroDir, category.dir);
+        if (!existsSync(categoryDir))
+            return;
+        const items = readdirSync(categoryDir);
+        if (items.length === 0)
+            return;
+        console.log(chalk.green(`${category.name}:`));
+        items.forEach(item => {
+            const name = category.ext ? item.replace(category.ext, '') : item;
+            console.log(chalk.gray(`  ${name}`));
+        });
+        console.log();
+    });
+}

package/dist/commands/search.js

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import { trackCommand } from '../utils/telemetry.js';
+const KIROHUB_API = 'https://kirohub.dev/resource-map.json';
+export async function searchResources(query, options) {
+    try {
+        trackCommand('search');
+        const response = await fetch(KIROHUB_API);
+        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());
+        }
+        // Search by name/slug
+        const results = filtered.filter(r => r.name.toLowerCase().includes(query.toLowerCase()) ||
+            r.slug.toLowerCase().includes(query.toLowerCase()));
+        if (results.length === 0) {
+            console.log(chalk.yellow(`No resources found for "${query}"`));
+            return;
+        }
+        console.log(chalk.bold(`Found ${results.length} resources:`));
+        console.log();
+        results.slice(0, 10).forEach(resource => {
+            console.log(chalk.green(`${resource.slug}`));
+            console.log(chalk.gray(`  Type: ${resource.type}`));
+            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`));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Search failed: ${error.message}`));
+    }
+}

package/dist/utils/telemetry.js

@@ -0,0 +1,52 @@
+// 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_TIMEOUT = 1500;
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const { version: CLI_VERSION } = require('../../package.json');
+function isTelemetryDisabled() {
+    return (process.env.DISABLE_TELEMETRY === '1' ||
+        process.env.KIROHUB_DISABLE_TELEMETRY === '1' ||
+        process.env.NO_TELEMETRY === '1');
+}
+export async function sendTelemetry(payload) {
+    if (isTelemetryDisabled())
+        return;
+    if (typeof fetch !== 'function')
+        return;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), TELEMETRY_TIMEOUT);
+    try {
+        await fetch(TELEMETRY_ENDPOINT, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+            signal: controller.signal,
+            keepalive: true,
+        });
+    }
+    catch {
+        // Ignore telemetry failures
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+export async function trackResourceInstall(resourceSlug, resourceType) {
+    await sendTelemetry({
+        eventType: 'resource_install',
+        resourceSlug,
+        resourceType,
+        cliVersion: CLI_VERSION,
+        source: 'cli',
+    });
+}
+export async function trackCommand(command) {
+    await sendTelemetry({
+        eventType: 'command_usage',
+        command,
+        cliVersion: CLI_VERSION,
+        source: 'cli',
+    });
+}

package/package.json

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

package/postinstall.cjs

@@ -0,0 +1,50 @@
+// 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";
+
+function isTelemetryDisabled() {
+  return (
+    process.env.DISABLE_TELEMETRY === "1" ||
+    process.env.KIROHUB_DISABLE_TELEMETRY === "1" ||
+    process.env.NO_TELEMETRY === "1"
+  );
+}
+
+function detectInstallSource(userAgent) {
+  const value = (userAgent || "").toLowerCase();
+  if (value.includes("npx")) return "npx";
+  if (value.includes("npm")) return "npm";
+  if (value.includes("yarn")) return "yarn";
+  if (value.includes("pnpm")) return "pnpm";
+  return "unknown";
+}
+
+async function sendInstallTelemetry() {
+  if (isTelemetryDisabled()) return;
+  if (typeof fetch !== "function") return;
+
+  const payload = {
+    eventType: "cli_install",
+    cliVersion: process.env.npm_package_version || "unknown",
+    source: detectInstallSource(process.env.npm_config_user_agent),
+  };
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1500);
+
+  try {
+    await fetch(TELEMETRY_ENDPOINT, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+      signal: controller.signal,
+      keepalive: true,
+    });
+  } catch {
+    // Ignore telemetry failures
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+sendInstallTelemetry();