imhcode 1.0.0

package/skills/ui-ux-pro-max/cli/src/commands/init.ts

@@ -0,0 +1,216 @@
+import { join, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import type { AIType } from '../types/index.js';
+import { AI_TYPES } from '../types/index.js';
+import { copyFolders, installFromZip, createTempDir, cleanup } from '../utils/extract.js';
+import { generatePlatformFiles, generateAllPlatformFiles } from '../utils/template.js';
+import { detectAIType, getAITypeDescription } from '../utils/detect.js';
+import { logger } from '../utils/logger.js';
+import {
+  getLatestRelease,
+  getAssetUrl,
+  downloadRelease,
+  GitHubRateLimitError,
+  GitHubDownloadError,
+} from '../utils/github.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// From dist/index.js -> ../assets (one level up to cli/, then assets/)
+const ASSETS_DIR = join(__dirname, '..', 'assets');
+
+interface InitOptions {
+  ai?: AIType;
+  force?: boolean;
+  offline?: boolean;
+  legacy?: boolean; // Use old ZIP-based install
+  global?: boolean; // Install to home directory (global mode)
+}
+
+/**
+ * Try to install from GitHub release (legacy method)
+ * Returns the copied folders if successful, null if failed
+ */
+async function tryGitHubInstall(
+  targetDir: string,
+  aiType: AIType,
+  spinner: ReturnType<typeof ora>
+): Promise<string[] | null> {
+  let tempDir: string | null = null;
+
+  try {
+    spinner.text = 'Fetching latest release from GitHub...';
+    const release = await getLatestRelease();
+    const assetUrl = getAssetUrl(release);
+
+    if (!assetUrl) {
+      throw new GitHubDownloadError('No ZIP asset found in latest release');
+    }
+
+    spinner.text = `Downloading ${release.tag_name}...`;
+    tempDir = await createTempDir();
+    const zipPath = join(tempDir, 'release.zip');
+
+    await downloadRelease(assetUrl, zipPath);
+
+    spinner.text = 'Extracting and installing files...';
+    const { copiedFolders, tempDir: extractedTempDir } = await installFromZip(
+      zipPath,
+      targetDir,
+      aiType
+    );
+
+    // Cleanup temp directory
+    await cleanup(extractedTempDir);
+
+    return copiedFolders;
+  } catch (error) {
+    // Cleanup temp directory on error
+    if (tempDir) {
+      await cleanup(tempDir);
+    }
+
+    if (error instanceof GitHubRateLimitError) {
+      spinner.warn('GitHub rate limit reached, using template generation...');
+      return null;
+    }
+
+    if (error instanceof GitHubDownloadError) {
+      spinner.warn('GitHub download failed, using template generation...');
+      return null;
+    }
+
+    // Network errors or other fetch failures
+    if (error instanceof TypeError && error.message.includes('fetch')) {
+      spinner.warn('Network error, using template generation...');
+      return null;
+    }
+
+    // Unknown errors - still fall back
+    spinner.warn('Download failed, using template generation...');
+    return null;
+  }
+}
+
+/**
+ * Install using template generation (new method)
+ */
+async function templateInstall(
+  targetDir: string,
+  aiType: AIType,
+  spinner: ReturnType<typeof ora>,
+  isGlobal = false
+): Promise<string[]> {
+  spinner.text = isGlobal
+    ? 'Generating skill files globally...'
+    : 'Generating skill files from templates...';
+
+  if (aiType === 'all') {
+    return generateAllPlatformFiles(targetDir, isGlobal);
+  }
+
+  return generatePlatformFiles(targetDir, aiType, isGlobal);
+}
+
+export async function initCommand(options: InitOptions): Promise<void> {
+  logger.title('UI/UX Pro Max Installer');
+
+  let aiType = options.ai;
+
+  // Auto-detect or prompt for AI type
+  if (!aiType) {
+    const { detected, suggested } = detectAIType();
+
+    if (detected.length > 0) {
+      logger.info(`Detected: ${detected.map(t => chalk.cyan(t)).join(', ')}`);
+    }
+
+    const response = await prompts({
+      type: 'select',
+      name: 'aiType',
+      message: 'Select AI assistant to install for:',
+      choices: AI_TYPES.map(type => ({
+        title: getAITypeDescription(type),
+        value: type,
+      })),
+      initial: suggested ? AI_TYPES.indexOf(suggested) : 0,
+    });
+
+    if (!response.aiType) {
+      logger.warn('Installation cancelled');
+      return;
+    }
+
+    aiType = response.aiType as AIType;
+  }
+
+  const isGlobal = !!options.global;
+  const modeLabel = isGlobal ? ' (global)' : '';
+  logger.info(`Installing for: ${chalk.cyan(getAITypeDescription(aiType))}${modeLabel}`);
+
+  const spinner = ora('Installing files...').start();
+  const cwd = process.cwd();
+  let copiedFolders: string[] = [];
+  let installMethod = 'template';
+
+  try {
+    // Use legacy ZIP-based install if --legacy flag is set
+    if (options.legacy) {
+      if (isGlobal) {
+        spinner.warn('--global is not supported with --legacy mode, installing locally instead');
+      }
+      // Try GitHub download first (unless offline mode)
+      if (!options.offline) {
+        const githubResult = await tryGitHubInstall(cwd, aiType, spinner);
+        if (githubResult) {
+          copiedFolders = githubResult;
+          installMethod = 'github';
+        }
+      }
+
+      // Fall back to bundled assets if GitHub failed or offline mode
+      if (installMethod !== 'github') {
+        spinner.text = 'Installing from bundled assets...';
+        copiedFolders = await copyFolders(ASSETS_DIR, cwd, aiType);
+        installMethod = 'bundled';
+      }
+    } else {
+      // Use new template-based generation (default)
+      copiedFolders = await templateInstall(cwd, aiType, spinner, isGlobal);
+      installMethod = 'template';
+    }
+
+    const methodMessage = {
+      github: 'Installed from GitHub release!',
+      bundled: 'Installed from bundled assets!',
+      template: 'Generated from templates!',
+    }[installMethod];
+
+    spinner.succeed(methodMessage);
+
+    // Summary
+    console.log();
+    logger.info('Installed folders:');
+    copiedFolders.forEach(folder => {
+      console.log(`  ${chalk.green('+')} ${folder}`);
+    });
+
+    console.log();
+    logger.success('UI/UX Pro Max installed successfully!');
+
+    // Next steps
+    console.log();
+    console.log(chalk.bold('Next steps:'));
+    console.log(chalk.dim('  1. Restart your AI coding assistant'));
+    console.log(chalk.dim('  2. Try: "Build a landing page for a SaaS product"'));
+    console.log();
+  } catch (error) {
+    spinner.fail('Installation failed');
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+    process.exit(1);
+  }
+}

package/skills/ui-ux-pro-max/cli/src/commands/uninstall.ts

@@ -0,0 +1,135 @@
+import { rm, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import chalk from 'chalk';
+import ora from 'ora';
+import prompts from 'prompts';
+import type { AIType } from '../types/index.js';
+import { AI_TYPES, AI_FOLDERS } from '../types/index.js';
+import { detectAIType, getAITypeDescription } from '../utils/detect.js';
+import { logger } from '../utils/logger.js';
+
+interface UninstallOptions {
+  ai?: AIType;
+  global?: boolean;
+}
+
+/**
+ * Remove skill directory for a given AI type
+ */
+async function removeSkillDir(baseDir: string, aiType: Exclude<AIType, 'all'>): Promise<string[]> {
+  const folders = AI_FOLDERS[aiType];
+  const removed: string[] = [];
+
+  for (const folder of folders) {
+    const skillDir = join(baseDir, folder, 'skills', 'ui-ux-pro-max');
+    try {
+      await stat(skillDir);
+      await rm(skillDir, { recursive: true, force: true });
+      removed.push(`${folder}/skills/ui-ux-pro-max`);
+    } catch (err: unknown) {
+      // Skip non-existent dirs; re-throw permission or other errors
+      if ((err as NodeJS.ErrnoException).code !== 'ENOENT') throw err;
+    }
+  }
+
+  return removed;
+}
+
+export async function uninstallCommand(options: UninstallOptions): Promise<void> {
+  logger.title('UI/UX Pro Max Uninstaller');
+
+  const isGlobal = !!options.global;
+  const baseDir = isGlobal ? homedir() : process.cwd();
+  const locationLabel = isGlobal ? '~/ (global)' : process.cwd();
+
+  let aiType = options.ai;
+  const { detected: initialDetected } = detectAIType(baseDir);
+
+  // Auto-detect or prompt for AI type
+  if (!aiType) {
+    const detected = initialDetected;
+
+    if (detected.length === 0) {
+      logger.warn('No installed AI skill directories detected.');
+      return;
+    }
+
+    logger.info(`Detected installations: ${detected.map(t => chalk.cyan(t)).join(', ')}`);
+
+    const choices = [
+      ...detected.map(type => ({
+        title: getAITypeDescription(type),
+        value: type,
+      })),
+      { title: 'All detected', value: 'all' as AIType },
+    ];
+
+    const response = await prompts({
+      type: 'select',
+      name: 'aiType',
+      message: 'Select which AI skill to uninstall:',
+      choices,
+    });
+
+    if (!response.aiType) {
+      logger.warn('Uninstall cancelled');
+      return;
+    }
+
+    aiType = response.aiType as AIType;
+  }
+
+  // Confirm before removing
+  const { confirmed } = await prompts({
+    type: 'confirm',
+    name: 'confirmed',
+    message: `Remove UI/UX Pro Max skill for ${chalk.cyan(getAITypeDescription(aiType))} from ${locationLabel}?`,
+    initial: false,
+  });
+
+  if (!confirmed) {
+    logger.warn('Uninstall cancelled');
+    return;
+  }
+
+  const spinner = ora('Removing skill files...').start();
+
+  try {
+    const allRemoved: string[] = [];
+
+    if (aiType === 'all') {
+      // Remove for all detected platforms
+      for (const type of initialDetected) {
+        const removed = await removeSkillDir(baseDir, type);
+        allRemoved.push(...removed);
+      }
+    } else {
+      const removed = await removeSkillDir(baseDir, aiType);
+      allRemoved.push(...removed);
+    }
+
+    if (allRemoved.length === 0) {
+      spinner.warn('No skill files found to remove');
+      return;
+    }
+
+    spinner.succeed('Skill files removed!');
+
+    console.log();
+    logger.info('Removed:');
+    allRemoved.forEach(folder => {
+      console.log(`  ${chalk.red('-')} ${folder}`);
+    });
+
+    console.log();
+    logger.success('UI/UX Pro Max uninstalled successfully!');
+    console.log();
+  } catch (error) {
+    spinner.fail('Uninstall failed');
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+    process.exit(1);
+  }
+}

package/skills/ui-ux-pro-max/cli/src/commands/update.ts

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { getLatestRelease } from '../utils/github.js';
+import { logger } from '../utils/logger.js';
+import { initCommand } from './init.js';
+import type { AIType } from '../types/index.js';
+
+interface UpdateOptions {
+  ai?: AIType;
+}
+
+export async function updateCommand(options: UpdateOptions): Promise<void> {
+  logger.title('UI/UX Pro Max Updater');
+
+  const spinner = ora('Checking for updates...').start();
+
+  try {
+    const release = await getLatestRelease();
+    spinner.succeed(`Latest version: ${chalk.cyan(release.tag_name)}`);
+
+    console.log();
+    logger.info('Running update (same as init with latest version)...');
+    console.log();
+
+    await initCommand({
+      ai: options.ai,
+      force: true,
+    });
+  } catch (error) {
+    spinner.fail('Update check failed');
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+    process.exit(1);
+  }
+}

package/skills/ui-ux-pro-max/cli/src/commands/versions.ts

@@ -0,0 +1,42 @@
+import chalk from 'chalk';
+import ora from 'ora';
+import { fetchReleases } from '../utils/github.js';
+import { logger } from '../utils/logger.js';
+
+export async function versionsCommand(): Promise<void> {
+  const spinner = ora('Fetching available versions...').start();
+
+  try {
+    const releases = await fetchReleases();
+
+    if (releases.length === 0) {
+      spinner.warn('No releases found');
+      return;
+    }
+
+    spinner.succeed(`Found ${releases.length} version(s)\n`);
+
+    console.log(chalk.bold('Available versions:\n'));
+
+    releases.forEach((release, index) => {
+      const isLatest = index === 0;
+      const tag = release.tag_name;
+      const date = new Date(release.published_at).toLocaleDateString();
+
+      if (isLatest) {
+        console.log(`  ${chalk.green('*')} ${chalk.bold(tag)} ${chalk.dim(`(${date})`)} ${chalk.green('[latest]')}`);
+      } else {
+        console.log(`    ${tag} ${chalk.dim(`(${date})`)}`);
+      }
+    });
+
+    console.log();
+    logger.dim('Use: uipro init --version <tag> to install a specific version');
+  } catch (error) {
+    spinner.fail('Failed to fetch versions');
+    if (error instanceof Error) {
+      logger.error(error.message);
+    }
+    process.exit(1);
+  }
+}

package/skills/ui-ux-pro-max/cli/src/index.ts

@@ -0,0 +1,83 @@
+#!/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 type { AIType } from './types/index.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/UX Pro Max skill for AI coding assistants')
+  .version(pkg.version);
+
+program
+  .command('init')
+  .description('Install UI/UX Pro Max skill to current project')
+  .option('-a, --ai <type>', `AI assistant type (${AI_TYPES.join(', ')})`)
+  .option('-f, --force', 'Overwrite existing files')
+  .option('-o, --offline', 'Skip GitHub download, use bundled assets only')
+  .option('-g, --global', 'Install globally to 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 initCommand({
+      ai: options.ai as AIType | undefined,
+      force: options.force,
+      offline: options.offline,
+      global: options.global,
+    });
+  });
+
+program
+  .command('versions')
+  .description('List available versions')
+  .action(versionsCommand);
+
+program
+  .command('update')
+  .description('Update UI/UX Pro Max to latest version')
+  .option('-a, --ai <type>', `AI assistant type (${AI_TYPES.join(', ')})`)
+  .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 as AIType | undefined,
+    });
+  });
+
+program
+  .command('uninstall')
+  .description('Remove UI/UX Pro Max 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 as AIType | undefined,
+      global: options.global,
+    });
+  });
+
+program.parse();

package/skills/ui-ux-pro-max/cli/src/types/index.ts

@@ -0,0 +1,68 @@
+export type AIType = 'claude' | 'cursor' | 'windsurf' | 'antigravity' | 'copilot' | 'kiro' | 'roocode' | 'codex' | 'qoder' | 'gemini' | 'trae' | 'opencode' | 'continue' | 'codebuddy' | 'droid' | 'kilocode' | 'warp' | 'augment' | '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 const AI_TYPES: AIType[] = ['claude', 'cursor', 'windsurf', 'antigravity', 'copilot', 'roocode', 'kiro', 'codex', 'qoder', 'gemini', 'trae', 'opencode', 'continue', 'codebuddy', 'droid', 'kilocode', 'warp', 'augment', '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: Record<Exclude<AIType, 'all'>, string[]> = {
+  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'],
+};

package/skills/ui-ux-pro-max/cli/src/utils/detect.ts

@@ -0,0 +1,120 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { AIType } from '../types/index.js';
+
+interface DetectionResult {
+  detected: AIType[];
+  suggested: AIType | null;
+}
+
+export function detectAIType(cwd: string = process.cwd()): DetectionResult {
+  const detected: AIType[] = [];
+
+  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');
+  }
+
+  // Suggest based on what's detected
+  let suggested: AIType | null = null;
+  if (detected.length === 1) {
+    suggested = detected[0];
+  } else if (detected.length > 1) {
+    suggested = 'all';
+  }
+
+  return { detected, suggested };
+}
+
+export function getAITypeDescription(aiType: AIType): string {
+  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 'all':
+      return 'All AI assistants';
+  }
+}