ui-pro-forge-cli 2.5.0

package/dist/index.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { initCommand } from './commands/init.js';
+import { versionsCommand } from './commands/versions.js';
+import { updateCommand } from './commands/update.js';
+import { uninstallCommand } from './commands/uninstall.js';
+import { AI_TYPES } from './types/index.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const pkg = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const program = new Command();
+program
+    .name('uipro')
+    .description('CLI to install UI Pro Forge skill for AI coding assistants')
+    .version(pkg.version);
+program
+    .command('init')
+    .description('Install UI Pro Forge skill to current project')
+    .option('-a, --ai <type>', `AI assistant type (${AI_TYPES.join(', ')})`)
+    .option('-f, --force', 'Overwrite existing files')
+    .option('-o, --offline', 'Compatibility flag; template installs use bundled assets')
+    .option('-g, --global', 'Install globally to home directory (~/) instead of current project')
+    .option('-t, --token <token>', 'GitHub Personal Access Token for higher API rate limits')
+    .action(async (options) => {
+    if (options.ai && !AI_TYPES.includes(options.ai)) {
+        console.error(`Invalid AI type: ${options.ai}`);
+        console.error(`Valid types: ${AI_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    await initCommand({
+        ai: options.ai,
+        force: options.force,
+        offline: options.offline,
+        global: options.global,
+        token: options.token,
+    });
+});
+program
+    .command('versions')
+    .description('List available versions')
+    .option('-t, --token <token>', 'GitHub Personal Access Token for higher API rate limits')
+    .action(versionsCommand);
+program
+    .command('update')
+    .description('Update UI Pro Forge to latest version')
+    .option('-a, --ai <type>', `AI assistant type (${AI_TYPES.join(', ')})`)
+    .option('-t, --token <token>', 'GitHub Personal Access Token for higher API rate limits')
+    .action(async (options) => {
+    if (options.ai && !AI_TYPES.includes(options.ai)) {
+        console.error(`Invalid AI type: ${options.ai}`);
+        console.error(`Valid types: ${AI_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    await updateCommand({
+        ai: options.ai,
+        token: options.token,
+    });
+});
+program
+    .command('uninstall')
+    .description('Remove UI Pro Forge skill from current project or globally')
+    .option('-a, --ai <type>', `AI assistant type (${AI_TYPES.join(', ')})`)
+    .option('-g, --global', 'Uninstall from home directory (~/) instead of current project')
+    .action(async (options) => {
+    if (options.ai && !AI_TYPES.includes(options.ai)) {
+        console.error(`Invalid AI type: ${options.ai}`);
+        console.error(`Valid types: ${AI_TYPES.join(', ')}`);
+        process.exit(1);
+    }
+    await uninstallCommand({
+        ai: options.ai,
+        global: options.global,
+    });
+});
+program.parse();

package/dist/types/index.d.ts

@@ -0,0 +1,40 @@
+export type AIType = 'claude' | 'cursor' | 'windsurf' | 'antigravity' | 'copilot' | 'kiro' | 'roocode' | 'codex' | 'qoder' | 'gemini' | 'trae' | 'opencode' | 'continue' | 'codebuddy' | 'droid' | 'kilocode' | 'warp' | 'augment' | 'codewhale' | 'all';
+export type ConcreteAIType = Exclude<AIType, 'all'>;
+export type InstallType = 'full' | 'reference';
+export interface Release {
+    tag_name: string;
+    name: string;
+    published_at: string;
+    html_url: string;
+    assets: Asset[];
+}
+export interface Asset {
+    name: string;
+    browser_download_url: string;
+    size: number;
+}
+export interface InstallConfig {
+    aiType: AIType;
+    version?: string;
+    force?: boolean;
+}
+export interface PlatformConfig {
+    platform: string;
+    displayName: string;
+    installType: InstallType;
+    folderStructure: {
+        root: string;
+        skillPath: string;
+        filename: string;
+    };
+    scriptPath: string;
+    frontmatter: Record<string, string> | null;
+    sections: {
+        quickReference: boolean;
+    };
+    title: string;
+    description: string;
+    skillOrWorkflow: string;
+}
+export declare const AI_TYPES: AIType[];
+export declare const AI_FOLDERS: Record<ConcreteAIType, string[]>;

package/dist/types/index.js

@@ -0,0 +1,25 @@
+export const AI_TYPES = ['claude', 'cursor', 'windsurf', 'antigravity', 'copilot', 'roocode', 'kiro', 'codex', 'qoder', 'gemini', 'trae', 'opencode', 'continue', 'codebuddy', 'droid', 'kilocode', 'warp', 'augment', 'codewhale', 'all'];
+// Legacy folder mapping for backward compatibility with ZIP-based installs.
+// Note: .shared is included for platforms that used ZIP installs. Post-ZIP platforms
+// (kilocode, warp, augment) include .shared as a no-op for consistent uninstall behavior.
+export const AI_FOLDERS = {
+    claude: ['.claude'],
+    cursor: ['.cursor', '.shared'],
+    windsurf: ['.windsurf', '.shared'],
+    antigravity: ['.agents', '.shared'],
+    copilot: ['.github', '.shared'],
+    kiro: ['.kiro', '.shared'],
+    codex: ['.codex'],
+    roocode: ['.roo', '.shared'],
+    qoder: ['.qoder', '.shared'],
+    gemini: ['.gemini', '.shared'],
+    trae: ['.trae', '.shared'],
+    opencode: ['.opencode', '.shared'],
+    continue: ['.continue'],
+    codebuddy: ['.codebuddy'],
+    droid: ['.factory'],
+    kilocode: ['.kilocode', '.shared'],
+    warp: ['.warp', '.shared'],
+    augment: ['.augment', '.shared'],
+    codewhale: ['.codewhale', '.shared'],
+};

package/dist/utils/detect.d.ts

@@ -0,0 +1,8 @@
+import type { AIType, ConcreteAIType } from '../types/index.js';
+interface DetectionResult {
+    detected: ConcreteAIType[];
+    suggested: AIType | null;
+}
+export declare function detectAIType(cwd?: string): DetectionResult;
+export declare function getAITypeDescription(aiType: AIType): string;
+export {};

package/dist/utils/detect.js

@@ -0,0 +1,115 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+export function detectAIType(cwd = process.cwd()) {
+    const detected = [];
+    if (existsSync(join(cwd, '.claude'))) {
+        detected.push('claude');
+    }
+    if (existsSync(join(cwd, '.cursor'))) {
+        detected.push('cursor');
+    }
+    if (existsSync(join(cwd, '.windsurf'))) {
+        detected.push('windsurf');
+    }
+    if (existsSync(join(cwd, '.agents')) || existsSync(join(cwd, '.agent'))) {
+        detected.push('antigravity');
+    }
+    if (existsSync(join(cwd, '.github'))) {
+        detected.push('copilot');
+    }
+    if (existsSync(join(cwd, '.kiro'))) {
+        detected.push('kiro');
+    }
+    if (existsSync(join(cwd, '.codex'))) {
+        detected.push('codex');
+    }
+    if (existsSync(join(cwd, '.roo'))) {
+        detected.push('roocode');
+    }
+    if (existsSync(join(cwd, '.qoder'))) {
+        detected.push('qoder');
+    }
+    if (existsSync(join(cwd, '.gemini'))) {
+        detected.push('gemini');
+    }
+    if (existsSync(join(cwd, '.trae'))) {
+        detected.push('trae');
+    }
+    if (existsSync(join(cwd, '.opencode'))) {
+        detected.push('opencode');
+    }
+    if (existsSync(join(cwd, '.continue'))) {
+        detected.push('continue');
+    }
+    if (existsSync(join(cwd, '.codebuddy'))) {
+        detected.push('codebuddy');
+    }
+    if (existsSync(join(cwd, '.factory'))) {
+        detected.push('droid');
+    }
+    if (existsSync(join(cwd, '.kilocode'))) {
+        detected.push('kilocode');
+    }
+    if (existsSync(join(cwd, '.warp'))) {
+        detected.push('warp');
+    }
+    if (existsSync(join(cwd, '.augment'))) {
+        detected.push('augment');
+    }
+    if (existsSync(join(cwd, '.codewhale'))) {
+        detected.push('codewhale');
+    }
+    // Suggest based on what's detected
+    let suggested = null;
+    if (detected.length === 1) {
+        suggested = detected[0];
+    }
+    else if (detected.length > 1) {
+        suggested = 'all';
+    }
+    return { detected, suggested };
+}
+export function getAITypeDescription(aiType) {
+    switch (aiType) {
+        case 'claude':
+            return 'Claude Code (.claude/skills/)';
+        case 'cursor':
+            return 'Cursor (.cursor/skills/)';
+        case 'windsurf':
+            return 'Windsurf (.windsurf/skills/)';
+        case 'antigravity':
+            return 'Antigravity (.agents/skills/)';
+        case 'copilot':
+            return 'GitHub Copilot (.github/prompts/)';
+        case 'kiro':
+            return 'Kiro (.kiro/steering/)';
+        case 'codex':
+            return 'Codex (.codex/skills/)';
+        case 'roocode':
+            return 'RooCode (.roo/skills/)';
+        case 'qoder':
+            return 'Qoder (.qoder/skills/)';
+        case 'gemini':
+            return 'Gemini CLI (.gemini/skills/)';
+        case 'trae':
+            return 'Trae (.trae/skills/)';
+        case 'opencode':
+            return 'OpenCode (.opencode/skills/)';
+        case 'continue':
+            return 'Continue (.continue/skills/)';
+        case 'codebuddy':
+            return 'CodeBuddy (.codebuddy/skills/)';
+        case 'droid':
+            return 'Droid (Factory) (.factory/skills/)';
+        case 'kilocode':
+            return 'KiloCode (.kilocode/skills/)';
+        case 'warp':
+            return 'Warp (.warp/skills/)';
+        case 'augment':
+            return 'Augment (.augment/skills/)';
+        case 'codewhale':
+            return 'CodeWhale (.codewhale/skills/)';
+        case 'all':
+            return 'All AI assistants';
+    }
+}

package/dist/utils/extract.d.ts

@@ -0,0 +1,15 @@
+import type { AIType } from '../types/index.js';
+export declare function extractZip(zipPath: string, destDir: string): Promise<void>;
+export declare function copyFolders(sourceDir: string, targetDir: string, aiType: AIType): Promise<string[]>;
+export declare function cleanup(tempDir: string): Promise<void>;
+/**
+ * Create a temporary directory for extracting ZIP files
+ */
+export declare function createTempDir(): Promise<string>;
+/**
+ * Install from a downloaded and extracted ZIP file
+ */
+export declare function installFromZip(zipPath: string, targetDir: string, aiType: AIType): Promise<{
+    copiedFolders: string[];
+    tempDir: string;
+}>;

package/dist/utils/extract.js

@@ -0,0 +1,125 @@
+import { mkdir, rm, access, cp, mkdtemp, readdir } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { tmpdir } from 'node:os';
+import { AI_FOLDERS } from '../types/index.js';
+const execAsync = promisify(exec);
+const EXCLUDED_FILES = ['settings.local.json'];
+export async function extractZip(zipPath, destDir) {
+    try {
+        const isWindows = process.platform === 'win32';
+        if (isWindows) {
+            await execAsync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${destDir}' -Force"`);
+        }
+        else {
+            await execAsync(`unzip -o "${zipPath}" -d "${destDir}"`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to extract zip: ${error}`);
+    }
+}
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function copyFolders(sourceDir, targetDir, aiType) {
+    const copiedFolders = [];
+    const foldersToCopy = aiType === 'all'
+        ? Object.values(AI_FOLDERS).flat()
+        : AI_FOLDERS[aiType];
+    // Deduplicate folders (e.g., .shared might be listed multiple times)
+    const uniqueFolders = [...new Set(foldersToCopy)];
+    for (const folder of uniqueFolders) {
+        const sourcePath = join(sourceDir, folder);
+        const targetPath = join(targetDir, folder);
+        // Check if source folder exists
+        const sourceExists = await exists(sourcePath);
+        if (!sourceExists) {
+            continue;
+        }
+        // Create target directory if needed
+        await mkdir(targetPath, { recursive: true });
+        // Filter function to exclude certain files
+        const filterFn = (src) => {
+            const fileName = basename(src);
+            return !EXCLUDED_FILES.includes(fileName);
+        };
+        // Copy recursively
+        try {
+            await cp(sourcePath, targetPath, { recursive: true, filter: filterFn });
+            copiedFolders.push(folder);
+        }
+        catch {
+            // Try shell fallback for older Node versions
+            try {
+                if (process.platform === 'win32') {
+                    await execAsync(`xcopy "${sourcePath}" "${targetPath}" /E /I /Y`);
+                }
+                else {
+                    await execAsync(`cp -r "${sourcePath}/." "${targetPath}"`);
+                }
+                copiedFolders.push(folder);
+            }
+            catch {
+                // Skip if copy fails
+            }
+        }
+    }
+    return copiedFolders;
+}
+export async function cleanup(tempDir) {
+    try {
+        await rm(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Create a temporary directory for extracting ZIP files
+ */
+export async function createTempDir() {
+    return mkdtemp(join(tmpdir(), 'uipro-'));
+}
+/**
+ * Find the extracted folder inside temp directory
+ * GitHub release ZIPs often contain a single root folder
+ */
+async function findExtractedRoot(tempDir) {
+    const entries = await readdir(tempDir, { withFileTypes: true });
+    const dirs = entries.filter(e => e.isDirectory());
+    // If there's exactly one directory, it's likely the extracted root
+    if (dirs.length === 1) {
+        return join(tempDir, dirs[0].name);
+    }
+    // Otherwise, assume tempDir itself is the root
+    return tempDir;
+}
+/**
+ * Install from a downloaded and extracted ZIP file
+ */
+export async function installFromZip(zipPath, targetDir, aiType) {
+    // Create temp directory
+    const tempDir = await createTempDir();
+    try {
+        // Extract ZIP to temp directory
+        await extractZip(zipPath, tempDir);
+        // Find the actual root of the extracted content
+        const extractedRoot = await findExtractedRoot(tempDir);
+        // Copy folders from extracted content to target
+        const copiedFolders = await copyFolders(extractedRoot, targetDir, aiType);
+        return { copiedFolders, tempDir };
+    }
+    catch (error) {
+        // Cleanup on error
+        await cleanup(tempDir);
+        throw error;
+    }
+}

package/dist/utils/github.d.ts

@@ -0,0 +1,12 @@
+import type { Release } from '../types/index.js';
+export declare class GitHubRateLimitError extends Error {
+    constructor(message: string);
+}
+export declare class GitHubDownloadError extends Error {
+    constructor(message: string);
+}
+export declare function getGitHubTokenGuidance(): string;
+export declare function fetchReleases(token?: string): Promise<Release[]>;
+export declare function getLatestRelease(token?: string): Promise<Release>;
+export declare function downloadRelease(url: string, dest: string, token?: string): Promise<void>;
+export declare function getAssetUrl(release: Release): string | null;

package/dist/utils/github.js

@@ -0,0 +1,97 @@
+import { writeFile } from 'node:fs/promises';
+const REPO_OWNER = 'kterfan';
+const REPO_NAME = 'ui-pro-forge';
+const API_BASE = 'https://api.github.com';
+const USER_AGENT = 'ui-pro-forge-cli';
+export class GitHubRateLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitHubRateLimitError';
+    }
+}
+export class GitHubDownloadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'GitHubDownloadError';
+    }
+}
+export function getGitHubTokenGuidance() {
+    return ('To increase your GitHub API rate limit, set the UI_PRO_MAX_GITHUB_TOKEN environment variable\n' +
+        'to a GitHub Personal Access Token (no scopes needed for public repos).\n' +
+        'Create one at: https://github.com/settings/tokens\n' +
+        'Example: UI_PRO_MAX_GITHUB_TOKEN=ghp_xxx uipro init\n' +
+        'Or pass it directly: uipro init --token ghp_xxx');
+}
+function checkRateLimit(response) {
+    const remaining = response.headers.get('x-ratelimit-remaining');
+    if (response.status === 403 && remaining === '0') {
+        const resetTime = response.headers.get('x-ratelimit-reset');
+        const resetDate = resetTime ? new Date(parseInt(resetTime) * 1000).toLocaleTimeString() : 'unknown';
+        throw new GitHubRateLimitError(`GitHub API rate limit exceeded. Resets at ${resetDate}.\n${getGitHubTokenGuidance()}`);
+    }
+    if (response.status === 429) {
+        throw new GitHubRateLimitError(`GitHub API rate limit exceeded (429 Too Many Requests).\n${getGitHubTokenGuidance()}`);
+    }
+}
+function getAuthHeaders(token) {
+    const resolved = (token || process.env['UI_PRO_MAX_GITHUB_TOKEN'] || process.env['GITHUB_TOKEN'])?.trim();
+    return resolved ? { 'Authorization': `Bearer ${resolved}` } : {};
+}
+export async function fetchReleases(token) {
+    const url = `${API_BASE}/repos/${REPO_OWNER}/${REPO_NAME}/releases`;
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': USER_AGENT,
+            ...getAuthHeaders(token),
+        },
+    });
+    checkRateLimit(response);
+    if (!response.ok) {
+        throw new GitHubDownloadError(`Failed to fetch releases: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function getLatestRelease(token) {
+    const url = `${API_BASE}/repos/${REPO_OWNER}/${REPO_NAME}/releases/latest`;
+    const response = await fetch(url, {
+        headers: {
+            'Accept': 'application/vnd.github.v3+json',
+            'User-Agent': USER_AGENT,
+            ...getAuthHeaders(token),
+        },
+    });
+    checkRateLimit(response);
+    if (!response.ok) {
+        throw new GitHubDownloadError(`Failed to fetch latest release: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+}
+export async function downloadRelease(url, dest, token) {
+    const response = await fetch(url, {
+        headers: {
+            'User-Agent': USER_AGENT,
+            'Accept': 'application/octet-stream',
+            ...getAuthHeaders(token),
+        },
+    });
+    checkRateLimit(response);
+    if (!response.ok) {
+        throw new GitHubDownloadError(`Failed to download: ${response.status} ${response.statusText}`);
+    }
+    const buffer = await response.arrayBuffer();
+    await writeFile(dest, Buffer.from(buffer));
+}
+export function getAssetUrl(release) {
+    // First try to find an uploaded ZIP asset
+    const asset = release.assets.find(a => a.name.endsWith('.zip'));
+    if (asset?.browser_download_url) {
+        return asset.browser_download_url;
+    }
+    // Fall back to GitHub's auto-generated archive
+    // Format: https://github.com/{owner}/{repo}/archive/refs/tags/{tag}.zip
+    if (release.tag_name) {
+        return `https://github.com/${REPO_OWNER}/${REPO_NAME}/archive/refs/tags/${release.tag_name}.zip`;
+    }
+    return null;
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,8 @@
+export declare const logger: {
+    info: (msg: string) => void;
+    success: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string) => void;
+    title: (msg: string) => void;
+    dim: (msg: string) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,9 @@
+import chalk from 'chalk';
+export const logger = {
+    info: (msg) => console.log(chalk.blue('info'), msg),
+    success: (msg) => console.log(chalk.green('success'), msg),
+    warn: (msg) => console.log(chalk.yellow('warn'), msg),
+    error: (msg) => console.log(chalk.red('error'), msg),
+    title: (msg) => console.log(chalk.bold.cyan(`\n${msg}\n`)),
+    dim: (msg) => console.log(chalk.dim(msg)),
+};

package/dist/utils/template.d.ts

@@ -0,0 +1,50 @@
+export interface PlatformConfig {
+    platform: string;
+    displayName: string;
+    installType: 'full' | 'reference';
+    folderStructure: {
+        root: string;
+        skillPath: string;
+        filename: string;
+    };
+    scriptPath: string;
+    frontmatter: Record<string, string> | null;
+    sections: {
+        quickReference: boolean;
+    };
+    title: string;
+    description: string;
+    skillOrWorkflow: string;
+}
+/**
+ * Load platform configuration from JSON file
+ */
+export declare function loadPlatformConfig(aiType: string): Promise<PlatformConfig>;
+/**
+ * Load all available platform configs
+ */
+export declare function loadAllPlatformConfigs(): Promise<Map<string, PlatformConfig>>;
+/**
+ * Render skill file content from template
+ * When isGlobal=true, rewrites script paths to use ~/{root}/ prefix
+ */
+export declare function renderSkillFile(config: PlatformConfig, isGlobal?: boolean): Promise<string>;
+/**
+ * List the static sub-skills bundled under assets/skills/ (everything except
+ * the template-rendered orchestrator). Empty if the package predates bundling.
+ */
+export declare function listBundledSubSkills(): Promise<string[]>;
+/**
+ * Generate platform files for a specific AI type
+ * All platforms use self-contained installation with data and scripts
+ * When isGlobal=true, installs to ~/home directory with absolute script paths
+ */
+export declare function generatePlatformFiles(targetDir: string, aiType: string, isGlobal?: boolean, force?: boolean): Promise<string[]>;
+/**
+ * Generate files for all AI types
+ */
+export declare function generateAllPlatformFiles(targetDir: string, isGlobal?: boolean, force?: boolean): Promise<string[]>;
+/**
+ * Get list of supported AI types
+ */
+export declare function getSupportedAITypes(): string[];