apero-kit-cli 1.0.0

package/src/commands/init.js

@@ -0,0 +1,223 @@
+import fs from 'fs-extra';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { KITS, getKit } from '../kits/index.js';
+import { resolveSource, getTargetDir, TARGETS } from '../utils/paths.js';
+import { copyItems, copyAllOfType, copyRouter, copyHooks, copyBaseFiles, copyAgentsMd } from '../utils/copy.js';
+import { createInitialState } from '../utils/state.js';
+import {
+  promptProjectName,
+  promptKit,
+  promptTarget,
+  promptAgents,
+  promptSkills,
+  promptCommands,
+  promptIncludeRouter,
+  promptIncludeHooks,
+  promptConfirm
+} from '../utils/prompts.js';
+
+export async function initCommand(projectName, options) {
+  console.log('');
+
+  // 1. Get project name
+  if (!projectName) {
+    projectName = await promptProjectName();
+  }
+
+  const projectDir = resolve(process.cwd(), projectName);
+
+  // Check if directory exists
+  if (fs.existsSync(projectDir) && !options.force) {
+    const files = fs.readdirSync(projectDir);
+    if (files.length > 0) {
+      console.log(chalk.red(`Directory "${projectName}" already exists and is not empty.`));
+      console.log(chalk.gray('Use --force to overwrite.'));
+      return;
+    }
+  }
+
+  // 2. Resolve source
+  const source = resolveSource(options.source);
+  if (source.error) {
+    console.log(chalk.red(`Error: ${source.error}`));
+    return;
+  }
+
+  console.log(chalk.gray(`Source: ${source.path}`));
+
+  // 3. Get kit
+  let kitName = options.kit;
+  if (!kitName) {
+    kitName = await promptKit();
+  }
+
+  // 4. Get target
+  let target = options.target || 'claude';
+  if (!TARGETS[target]) {
+    console.log(chalk.yellow(`Unknown target "${target}", using "claude"`));
+    target = 'claude';
+  }
+
+  // 5. Prepare what to install
+  let toInstall = {
+    agents: [],
+    commands: [],
+    skills: [],
+    workflows: [],
+    includeRouter: false,
+    includeHooks: false
+  };
+
+  if (kitName === 'custom') {
+    // Custom mode - prompt for everything
+    console.log(chalk.cyan('\nCustom kit configuration:'));
+    toInstall.agents = await promptAgents(source.claudeDir);
+    toInstall.skills = await promptSkills(source.claudeDir);
+    toInstall.commands = await promptCommands(source.claudeDir);
+    toInstall.includeRouter = await promptIncludeRouter();
+    toInstall.includeHooks = await promptIncludeHooks();
+  } else {
+    const kit = getKit(kitName);
+    if (!kit) {
+      console.log(chalk.red(`Unknown kit: ${kitName}`));
+      console.log(chalk.gray(`Available kits: ${Object.keys(KITS).join(', ')}`));
+      return;
+    }
+
+    toInstall = {
+      agents: kit.agents,
+      commands: kit.commands,
+      skills: kit.skills,
+      workflows: kit.workflows || [],
+      includeRouter: kit.includeRouter,
+      includeHooks: kit.includeHooks
+    };
+  }
+
+  // 6. Confirm
+  console.log(chalk.cyan('\nWill create:'));
+  console.log(chalk.white(`  Project: ${projectName}/`));
+  console.log(chalk.white(`  Target:  ${TARGETS[target]}/`));
+  console.log(chalk.white(`  Kit:     ${kitName}`));
+
+  if (Array.isArray(toInstall.agents)) {
+    console.log(chalk.gray(`  Agents:  ${toInstall.agents.length}`));
+  }
+  if (Array.isArray(toInstall.skills)) {
+    console.log(chalk.gray(`  Skills:  ${toInstall.skills.length}`));
+  }
+  if (Array.isArray(toInstall.commands)) {
+    console.log(chalk.gray(`  Commands: ${toInstall.commands.length}`));
+  }
+
+  console.log('');
+
+  if (!await promptConfirm('Proceed?')) {
+    console.log(chalk.yellow('Cancelled.'));
+    return;
+  }
+
+  // 7. Create project
+  const spinner = ora('Creating project...').start();
+
+  try {
+    // Create project directory
+    await fs.ensureDir(projectDir);
+
+    // Create target directory
+    const targetDir = getTargetDir(projectDir, target);
+    await fs.ensureDir(targetDir);
+
+    // Copy agents
+    spinner.text = 'Copying agents...';
+    if (toInstall.agents === 'all') {
+      await copyAllOfType('agents', source.claudeDir, targetDir);
+    } else if (toInstall.agents.length > 0) {
+      await copyItems(toInstall.agents, 'agents', source.claudeDir, targetDir);
+    }
+
+    // Copy skills
+    spinner.text = 'Copying skills...';
+    if (toInstall.skills === 'all') {
+      await copyAllOfType('skills', source.claudeDir, targetDir);
+    } else if (toInstall.skills.length > 0) {
+      await copyItems(toInstall.skills, 'skills', source.claudeDir, targetDir);
+    }
+
+    // Copy commands
+    spinner.text = 'Copying commands...';
+    if (toInstall.commands === 'all') {
+      await copyAllOfType('commands', source.claudeDir, targetDir);
+    } else if (toInstall.commands.length > 0) {
+      await copyItems(toInstall.commands, 'commands', source.claudeDir, targetDir);
+    }
+
+    // Copy workflows
+    spinner.text = 'Copying workflows...';
+    if (toInstall.workflows === 'all') {
+      await copyAllOfType('workflows', source.claudeDir, targetDir);
+    } else if (toInstall.workflows && toInstall.workflows.length > 0) {
+      await copyItems(toInstall.workflows, 'workflows', source.claudeDir, targetDir);
+    }
+
+    // Copy router
+    if (toInstall.includeRouter) {
+      spinner.text = 'Copying router...';
+      await copyRouter(source.claudeDir, targetDir);
+    }
+
+    // Copy hooks
+    if (toInstall.includeHooks) {
+      spinner.text = 'Copying hooks...';
+      await copyHooks(source.claudeDir, targetDir);
+    }
+
+    // Copy base files
+    spinner.text = 'Copying base files...';
+    await copyBaseFiles(source.claudeDir, targetDir);
+
+    // Copy AGENTS.md
+    if (source.agentsMd) {
+      await copyAgentsMd(source.agentsMd, projectDir);
+    }
+
+    // Create state file
+    spinner.text = 'Saving state...';
+    await createInitialState(projectDir, {
+      kit: kitName,
+      source: source.path,
+      target: TARGETS[target],
+      installed: {
+        agents: toInstall.agents === 'all' ? ['all'] : toInstall.agents,
+        skills: toInstall.skills === 'all' ? ['all'] : toInstall.skills,
+        commands: toInstall.commands === 'all' ? ['all'] : toInstall.commands,
+        workflows: toInstall.workflows === 'all' ? ['all'] : (toInstall.workflows || []),
+        router: toInstall.includeRouter,
+        hooks: toInstall.includeHooks
+      }
+    });
+
+    spinner.succeed(chalk.green('Project created successfully!'));
+
+    // Print next steps
+    console.log('');
+    console.log(chalk.cyan('Next steps:'));
+    console.log(chalk.white(`  cd ${projectName}`));
+    console.log(chalk.white('  # Start coding with Claude Code'));
+    console.log('');
+    console.log(chalk.gray('Useful commands:'));
+    console.log(chalk.gray('  ak status     - Check file status'));
+    console.log(chalk.gray('  ak add <item> - Add more agents/skills'));
+    console.log(chalk.gray('  ak update     - Sync from source'));
+    console.log('');
+
+  } catch (error) {
+    spinner.fail(chalk.red('Failed to create project'));
+    console.error(chalk.red(error.message));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  }
+}

package/src/commands/list.js

@@ -0,0 +1,190 @@
+import chalk from 'chalk';
+import { KITS, getKitList } from '../kits/index.js';
+import { resolveSource } from '../utils/paths.js';
+import { listAvailable } from '../utils/copy.js';
+
+export async function listCommand(type, options = {}) {
+  const validTypes = ['kits', 'agents', 'skills', 'commands', 'workflows'];
+
+  // If no type specified, show help
+  if (!type) {
+    console.log(chalk.cyan('\nAvailable list commands:'));
+    console.log(chalk.white('  ak list kits      - List available kits'));
+    console.log(chalk.white('  ak list agents    - List available agents'));
+    console.log(chalk.white('  ak list skills    - List available skills'));
+    console.log(chalk.white('  ak list commands  - List available commands'));
+    console.log(chalk.white('  ak list workflows - List available workflows'));
+    console.log('');
+    return;
+  }
+
+  // Normalize type
+  type = type.toLowerCase();
+  if (!validTypes.includes(type)) {
+    console.log(chalk.red(`Unknown type: ${type}`));
+    console.log(chalk.gray(`Valid types: ${validTypes.join(', ')}`));
+    return;
+  }
+
+  // List kits (doesn't need source)
+  if (type === 'kits') {
+    listKits();
+    return;
+  }
+
+  // For other types, need source
+  const source = resolveSource(options.source);
+  if (source.error) {
+    console.log(chalk.red(`Error: ${source.error}`));
+    return;
+  }
+
+  console.log(chalk.gray(`Source: ${source.path}\n`));
+
+  switch (type) {
+    case 'agents':
+      listAgents(source.claudeDir);
+      break;
+    case 'skills':
+      listSkills(source.claudeDir);
+      break;
+    case 'commands':
+      listCommands(source.claudeDir);
+      break;
+    case 'workflows':
+      listWorkflows(source.claudeDir);
+      break;
+  }
+}
+
+function listKits() {
+  const kits = getKitList();
+
+  console.log(chalk.cyan.bold('\nAvailable Kits:\n'));
+
+  for (const kit of kits) {
+    const colorFn = chalk[kit.color] || chalk.white;
+    console.log(`  ${kit.emoji}  ${colorFn.bold(kit.name.padEnd(12))} - ${kit.description}`);
+
+    // Show details
+    if (Array.isArray(kit.agents)) {
+      console.log(chalk.gray(`      Agents: ${kit.agents.length} | Skills: ${kit.skills.length} | Commands: ${kit.commands.length}`));
+    } else {
+      console.log(chalk.gray('      Includes: ALL agents, skills, commands'));
+    }
+  }
+
+  console.log(`\n  🔧  ${chalk.bold('custom'.padEnd(12))} - Pick your own agents, skills, and commands`);
+  console.log('');
+}
+
+function listAgents(sourceDir) {
+  const agents = listAvailable('agents', sourceDir);
+
+  console.log(chalk.cyan.bold(`Available Agents (${agents.length}):\n`));
+
+  if (agents.length === 0) {
+    console.log(chalk.gray('  No agents found'));
+    return;
+  }
+
+  // Group into columns
+  const cols = 3;
+  const rows = Math.ceil(agents.length / cols);
+
+  for (let i = 0; i < rows; i++) {
+    let line = '  ';
+    for (let j = 0; j < cols; j++) {
+      const idx = i + j * rows;
+      if (idx < agents.length) {
+        line += chalk.white(agents[idx].name.padEnd(25));
+      }
+    }
+    console.log(line);
+  }
+  console.log('');
+}
+
+function listSkills(sourceDir) {
+  const skills = listAvailable('skills', sourceDir).filter(s => s.isDir);
+
+  console.log(chalk.cyan.bold(`Available Skills (${skills.length}):\n`));
+
+  if (skills.length === 0) {
+    console.log(chalk.gray('  No skills found'));
+    return;
+  }
+
+  // Group into columns
+  const cols = 2;
+  const rows = Math.ceil(skills.length / cols);
+
+  for (let i = 0; i < rows; i++) {
+    let line = '  ';
+    for (let j = 0; j < cols; j++) {
+      const idx = i + j * rows;
+      if (idx < skills.length) {
+        line += chalk.white(skills[idx].name.padEnd(35));
+      }
+    }
+    console.log(line);
+  }
+  console.log('');
+}
+
+function listCommands(sourceDir) {
+  const commands = listAvailable('commands', sourceDir);
+
+  console.log(chalk.cyan.bold(`Available Commands (${commands.length}):\n`));
+
+  if (commands.length === 0) {
+    console.log(chalk.gray('  No commands found'));
+    return;
+  }
+
+  // Separate files and directories
+  const files = commands.filter(c => !c.isDir);
+  const dirs = commands.filter(c => c.isDir);
+
+  // Print main commands (files)
+  console.log(chalk.gray('  Main commands:'));
+  const cols = 4;
+  let rows = Math.ceil(files.length / cols);
+
+  for (let i = 0; i < rows; i++) {
+    let line = '    ';
+    for (let j = 0; j < cols; j++) {
+      const idx = i + j * rows;
+      if (idx < files.length) {
+        line += chalk.white(('/' + files[idx].name).padEnd(18));
+      }
+    }
+    console.log(line);
+  }
+
+  // Print command groups (directories)
+  if (dirs.length > 0) {
+    console.log(chalk.gray('\n  Command groups:'));
+    for (const dir of dirs) {
+      console.log(chalk.yellow(`    /${dir.name}/`));
+    }
+  }
+
+  console.log('');
+}
+
+function listWorkflows(sourceDir) {
+  const workflows = listAvailable('workflows', sourceDir);
+
+  console.log(chalk.cyan.bold(`Available Workflows (${workflows.length}):\n`));
+
+  if (workflows.length === 0) {
+    console.log(chalk.gray('  No workflows found'));
+    return;
+  }
+
+  for (const wf of workflows) {
+    console.log(chalk.white(`  • ${wf.name}`));
+  }
+  console.log('');
+}

package/src/commands/status.js

@@ -0,0 +1,113 @@
+import chalk from 'chalk';
+import { isAkProject } from '../utils/paths.js';
+import { loadState, getFileStatuses } from '../utils/state.js';
+import fs from 'fs-extra';
+import { join } from 'path';
+
+export async function statusCommand(options = {}) {
+  const projectDir = process.cwd();
+
+  // Check if in ak project
+  if (!isAkProject(projectDir)) {
+    console.log(chalk.red('Not in an ak project.'));
+    console.log(chalk.gray('Run "ak init" first.'));
+    return;
+  }
+
+  // Load state
+  const state = await loadState(projectDir);
+  if (!state) {
+    console.log(chalk.yellow('No state file found.'));
+    console.log(chalk.gray('This project may have been created without ak.'));
+    return;
+  }
+
+  // Print project info
+  console.log(chalk.cyan.bold('\nProject Status\n'));
+  console.log(chalk.white(`  Kit:     ${state.kit}`));
+  console.log(chalk.white(`  Target:  ${state.target}`));
+  console.log(chalk.white(`  Source:  ${state.source}`));
+  console.log(chalk.gray(`  Created: ${new Date(state.createdAt).toLocaleDateString()}`));
+  console.log(chalk.gray(`  Updated: ${new Date(state.lastUpdate).toLocaleDateString()}`));
+  console.log('');
+
+  // Get file statuses
+  const result = await getFileStatuses(projectDir);
+
+  if (result.error) {
+    console.log(chalk.red(`Error: ${result.error}`));
+    return;
+  }
+
+  const { statuses } = result;
+
+  // Summary
+  const total = statuses.unchanged.length + statuses.modified.length + statuses.added.length;
+  console.log(chalk.cyan('File Status:'));
+  console.log(chalk.green(`  ✓ ${statuses.unchanged.length} unchanged`));
+  if (statuses.modified.length > 0) {
+    console.log(chalk.yellow(`  ~ ${statuses.modified.length} modified`));
+  }
+  if (statuses.added.length > 0) {
+    console.log(chalk.blue(`  + ${statuses.added.length} added locally`));
+  }
+  if (statuses.deleted.length > 0) {
+    console.log(chalk.red(`  - ${statuses.deleted.length} deleted`));
+  }
+  console.log(chalk.gray(`  Total: ${total} files tracked`));
+  console.log('');
+
+  // Show modified files
+  if (statuses.modified.length > 0 && (options.verbose || statuses.modified.length <= 10)) {
+    console.log(chalk.yellow('Modified files:'));
+    for (const file of statuses.modified) {
+      console.log(chalk.yellow(`  ~ ${file}`));
+    }
+    console.log('');
+  } else if (statuses.modified.length > 10) {
+    console.log(chalk.yellow(`Modified files: (showing first 10, use --verbose for all)`));
+    for (const file of statuses.modified.slice(0, 10)) {
+      console.log(chalk.yellow(`  ~ ${file}`));
+    }
+    console.log(chalk.gray(`  ... and ${statuses.modified.length - 10} more`));
+    console.log('');
+  }
+
+  // Show added files
+  if (statuses.added.length > 0 && (options.verbose || statuses.added.length <= 5)) {
+    console.log(chalk.blue('Added locally:'));
+    for (const file of statuses.added) {
+      console.log(chalk.blue(`  + ${file}`));
+    }
+    console.log('');
+  }
+
+  // Installed components
+  if (state.installed) {
+    console.log(chalk.cyan('Installed Components:'));
+    const { agents, skills, commands, workflows, router, hooks } = state.installed;
+
+    if (agents && agents.length > 0) {
+      console.log(chalk.gray(`  Agents:    ${agents.includes('all') ? 'ALL' : agents.length}`));
+    }
+    if (skills && skills.length > 0) {
+      console.log(chalk.gray(`  Skills:    ${skills.includes('all') ? 'ALL' : skills.length}`));
+    }
+    if (commands && commands.length > 0) {
+      console.log(chalk.gray(`  Commands:  ${commands.includes('all') ? 'ALL' : commands.length}`));
+    }
+    if (workflows && workflows.length > 0) {
+      console.log(chalk.gray(`  Workflows: ${workflows.includes('all') ? 'ALL' : workflows.length}`));
+    }
+    if (router) console.log(chalk.gray('  Router:    ✓'));
+    if (hooks) console.log(chalk.gray('  Hooks:     ✓'));
+    console.log('');
+  }
+
+  // Check source availability
+  if (state.source && !fs.existsSync(state.source)) {
+    console.log(chalk.yellow('⚠ Source directory not found. Update may not work.'));
+    console.log(chalk.gray(`  Expected: ${state.source}`));
+    console.log('');
+  }
+}

package/src/commands/update.js

@@ -0,0 +1,183 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { resolveSource, isAkProject } from '../utils/paths.js';
+import { loadState, updateState, getFileStatuses } from '../utils/state.js';
+import { hashFile, hashDirectory } from '../utils/hash.js';
+import { promptUpdateConfirm } from '../utils/prompts.js';
+
+export async function updateCommand(options = {}) {
+  const projectDir = process.cwd();
+
+  // Check if in ak project
+  if (!isAkProject(projectDir)) {
+    console.log(chalk.red('Not in an ak project.'));
+    console.log(chalk.gray('Run "ak init" first.'));
+    return;
+  }
+
+  // Load state
+  const state = await loadState(projectDir);
+  if (!state) {
+    console.log(chalk.red('No state file found.'));
+    console.log(chalk.gray('This project may have been created without ak. Run "ak doctor" for more info.'));
+    return;
+  }
+
+  // Resolve source
+  const sourceFlag = options.source || state.source;
+  const source = resolveSource(sourceFlag);
+  if (source.error) {
+    console.log(chalk.red(`Error: ${source.error}`));
+    return;
+  }
+
+  console.log(chalk.gray(`Source: ${source.path}`));
+  console.log(chalk.gray(`Target: ${state.target}`));
+  console.log('');
+
+  const spinner = ora('Checking for updates...').start();
+
+  try {
+    // Get current file statuses
+    const { statuses, targetDir } = await getFileStatuses(projectDir);
+
+    // Determine what types to update
+    let typesToUpdate = ['agents', 'skills', 'commands', 'workflows'];
+    if (options.agents) typesToUpdate = ['agents'];
+    if (options.skills) typesToUpdate = ['skills'];
+    if (options.commands) typesToUpdate = ['commands'];
+
+    // Get source hashes
+    const sourceHashes = {};
+    for (const type of typesToUpdate) {
+      const typeDir = join(source.claudeDir, type);
+      if (fs.existsSync(typeDir)) {
+        const hashes = await hashDirectory(typeDir);
+        for (const [path, hash] of Object.entries(hashes)) {
+          sourceHashes[`${type}/${path}`] = hash;
+        }
+      }
+    }
+
+    // Compare with current
+    const toUpdate = [];
+    const skipped = [];
+    const newFiles = [];
+
+    for (const [path, sourceHash] of Object.entries(sourceHashes)) {
+      const currentPath = join(targetDir, path);
+      const originalHash = state.originalHashes?.[path];
+      const currentHash = fs.existsSync(currentPath) ? hashFile(currentPath) : null;
+
+      if (!currentHash) {
+        // New file from source
+        newFiles.push(path);
+      } else if (currentHash === originalHash) {
+        // File unchanged locally, can update
+        if (sourceHash !== currentHash) {
+          toUpdate.push(path);
+        }
+      } else {
+        // File modified locally, skip
+        if (sourceHash !== originalHash) {
+          skipped.push(path);
+        }
+      }
+    }
+
+    spinner.stop();
+
+    // Show summary
+    if (toUpdate.length === 0 && newFiles.length === 0) {
+      console.log(chalk.green('✓ Already up to date!'));
+      if (skipped.length > 0) {
+        console.log(chalk.yellow(`  ${skipped.length} file(s) skipped (modified locally)`));
+      }
+      return;
+    }
+
+    console.log(chalk.cyan('Updates available:'));
+    console.log(chalk.green(`  ${toUpdate.length} file(s) to update`));
+    console.log(chalk.blue(`  ${newFiles.length} new file(s)`));
+    if (skipped.length > 0) {
+      console.log(chalk.yellow(`  ${skipped.length} file(s) skipped (modified locally)`));
+    }
+    console.log('');
+
+    // Dry run mode
+    if (options.dryRun) {
+      console.log(chalk.cyan('Dry run - no changes made'));
+      console.log(chalk.gray('\nFiles that would be updated:'));
+      [...toUpdate, ...newFiles].forEach(f => console.log(chalk.gray(`  ${f}`)));
+      if (skipped.length > 0) {
+        console.log(chalk.gray('\nFiles that would be skipped:'));
+        skipped.forEach(f => console.log(chalk.yellow(`  ~ ${f}`)));
+      }
+      return;
+    }
+
+    // Confirm
+    if (!options.force) {
+      const confirmed = await promptUpdateConfirm({
+        toUpdate: [...toUpdate, ...newFiles],
+        skipped
+      });
+      if (!confirmed) {
+        console.log(chalk.yellow('Cancelled.'));
+        return;
+      }
+    }
+
+    // Apply updates
+    const updateSpinner = ora('Applying updates...').start();
+
+    let updated = 0;
+    let failed = 0;
+
+    for (const path of [...toUpdate, ...newFiles]) {
+      try {
+        const srcPath = join(source.claudeDir, path);
+        const destPath = join(targetDir, path);
+
+        await fs.ensureDir(join(targetDir, path.split('/').slice(0, -1).join('/')));
+        await fs.copy(srcPath, destPath, { overwrite: true });
+        updated++;
+      } catch (err) {
+        failed++;
+        if (process.env.DEBUG) {
+          console.error(`Failed to update ${path}: ${err.message}`);
+        }
+      }
+    }
+
+    // Update state with new hashes
+    const newHashes = await hashDirectory(targetDir);
+    await updateState(projectDir, {
+      source: source.path,
+      originalHashes: newHashes
+    });
+
+    updateSpinner.succeed(chalk.green(`Updated ${updated} file(s)`));
+
+    if (failed > 0) {
+      console.log(chalk.yellow(`  ${failed} file(s) failed to update`));
+    }
+
+    if (skipped.length > 0) {
+      console.log(chalk.gray(`\nSkipped files (modified locally):`));
+      skipped.slice(0, 5).forEach(f => console.log(chalk.yellow(`  ~ ${f}`)));
+      if (skipped.length > 5) {
+        console.log(chalk.gray(`  ... and ${skipped.length - 5} more`));
+      }
+    }
+
+  } catch (error) {
+    spinner.fail(chalk.red('Update failed'));
+    console.error(chalk.red(error.message));
+    if (process.env.DEBUG) {
+      console.error(error.stack);
+    }
+  }
+}