apero-kit-cli 1.0.0

package/src/utils/prompts.js

@@ -0,0 +1,235 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { KITS, getKitList } from '../kits/index.js';
+import { listAvailable } from './copy.js';
+
+/**
+ * Prompt for project name
+ */
+export async function promptProjectName() {
+  const { projectName } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'projectName',
+      message: 'Project name:',
+      default: 'my-project',
+      validate: (input) => {
+        if (!input.trim()) return 'Project name is required';
+        if (!/^[a-zA-Z0-9-_]+$/.test(input)) {
+          return 'Project name can only contain letters, numbers, dashes, and underscores';
+        }
+        return true;
+      }
+    }
+  ]);
+  return projectName;
+}
+
+/**
+ * Prompt for kit selection
+ */
+export async function promptKit() {
+  const kits = getKitList();
+  const choices = kits.map(kit => ({
+    name: `${kit.emoji}  ${chalk.bold(kit.name.padEnd(12))} - ${kit.description}`,
+    value: kit.name
+  }));
+
+  // Add custom option
+  choices.push({
+    name: `🔧  ${chalk.bold('custom'.padEnd(12))} - Pick your own agents, skills, and commands`,
+    value: 'custom'
+  });
+
+  const { kit } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'kit',
+      message: 'Select a kit:',
+      choices
+    }
+  ]);
+
+  return kit;
+}
+
+/**
+ * Prompt for target folder
+ */
+export async function promptTarget() {
+  const { target } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'target',
+      message: 'Target folder:',
+      choices: [
+        { name: '.claude/  (Claude Code)', value: 'claude' },
+        { name: '.opencode/ (OpenCode)', value: 'opencode' },
+        { name: '.agent/   (Generic)', value: 'generic' }
+      ],
+      default: 'claude'
+    }
+  ]);
+  return target;
+}
+
+/**
+ * Prompt for custom agent selection
+ */
+export async function promptAgents(sourceDir) {
+  const available = listAvailable('agents', sourceDir);
+
+  if (available.length === 0) {
+    return [];
+  }
+
+  const choices = available.map(item => ({
+    name: item.name,
+    value: item.name,
+    checked: ['planner', 'debugger'].includes(item.name) // Default selections
+  }));
+
+  const { agents } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'agents',
+      message: 'Select agents:',
+      choices,
+      pageSize: 15
+    }
+  ]);
+
+  return agents;
+}
+
+/**
+ * Prompt for custom skill selection
+ */
+export async function promptSkills(sourceDir) {
+  const available = listAvailable('skills', sourceDir);
+
+  if (available.length === 0) {
+    return [];
+  }
+
+  const choices = available
+    .filter(item => item.isDir) // Skills are directories
+    .map(item => ({
+      name: item.name,
+      value: item.name,
+      checked: ['planning', 'debugging'].includes(item.name)
+    }));
+
+  const { skills } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'skills',
+      message: 'Select skills:',
+      choices,
+      pageSize: 15
+    }
+  ]);
+
+  return skills;
+}
+
+/**
+ * Prompt for custom command selection
+ */
+export async function promptCommands(sourceDir) {
+  const available = listAvailable('commands', sourceDir);
+
+  if (available.length === 0) {
+    return [];
+  }
+
+  const choices = available.map(item => ({
+    name: item.name,
+    value: item.name,
+    checked: ['plan', 'fix', 'code'].includes(item.name)
+  }));
+
+  const { commands } = await inquirer.prompt([
+    {
+      type: 'checkbox',
+      name: 'commands',
+      message: 'Select commands:',
+      choices,
+      pageSize: 15
+    }
+  ]);
+
+  return commands;
+}
+
+/**
+ * Prompt for router inclusion
+ */
+export async function promptIncludeRouter() {
+  const { includeRouter } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'includeRouter',
+      message: 'Include router?',
+      default: true
+    }
+  ]);
+  return includeRouter;
+}
+
+/**
+ * Prompt for hooks inclusion
+ */
+export async function promptIncludeHooks() {
+  const { includeHooks } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'includeHooks',
+      message: 'Include hooks?',
+      default: false
+    }
+  ]);
+  return includeHooks;
+}
+
+/**
+ * Prompt for confirmation
+ */
+export async function promptConfirm(message, defaultValue = true) {
+  const { confirmed } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message,
+      default: defaultValue
+    }
+  ]);
+  return confirmed;
+}
+
+/**
+ * Prompt for update confirmation with file list
+ */
+export async function promptUpdateConfirm(updates) {
+  console.log(chalk.cyan('\nChanges to apply:'));
+
+  if (updates.toUpdate.length > 0) {
+    console.log(chalk.green('  Will update:'));
+    updates.toUpdate.slice(0, 10).forEach(f => console.log(chalk.green(`    ✓ ${f}`)));
+    if (updates.toUpdate.length > 10) {
+      console.log(chalk.gray(`    ... and ${updates.toUpdate.length - 10} more`));
+    }
+  }
+
+  if (updates.skipped.length > 0) {
+    console.log(chalk.yellow('  Will skip (modified locally):'));
+    updates.skipped.slice(0, 5).forEach(f => console.log(chalk.yellow(`    ~ ${f}`)));
+    if (updates.skipped.length > 5) {
+      console.log(chalk.gray(`    ... and ${updates.skipped.length - 5} more`));
+    }
+  }
+
+  console.log('');
+
+  return promptConfirm('Apply these updates?', true);
+}

package/src/utils/state.js

@@ -0,0 +1,136 @@
+import fs from 'fs-extra';
+import { join } from 'path';
+import { hashDirectory } from './hash.js';
+
+const STATE_DIR = '.ak';
+const STATE_FILE = 'state.json';
+
+/**
+ * Get state file path
+ */
+export function getStatePath(projectDir) {
+  return join(projectDir, STATE_DIR, STATE_FILE);
+}
+
+/**
+ * Load state from .ak/state.json
+ */
+export async function loadState(projectDir) {
+  const statePath = getStatePath(projectDir);
+
+  if (!fs.existsSync(statePath)) {
+    return null;
+  }
+
+  try {
+    return await fs.readJson(statePath);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save state to .ak/state.json
+ */
+export async function saveState(projectDir, state) {
+  const stateDir = join(projectDir, STATE_DIR);
+  const statePath = join(stateDir, STATE_FILE);
+
+  await fs.ensureDir(stateDir);
+  await fs.writeJson(statePath, state, { spaces: 2 });
+}
+
+/**
+ * Create initial state after init
+ */
+export async function createInitialState(projectDir, options) {
+  const { kit, source, target, installed } = options;
+
+  // Calculate hashes of all installed files
+  const targetDir = join(projectDir, target);
+  const hashes = await hashDirectory(targetDir);
+
+  const state = {
+    version: '1.0.0',
+    createdAt: new Date().toISOString(),
+    lastUpdate: new Date().toISOString(),
+    kit,
+    source,
+    target,
+    installed,
+    originalHashes: hashes
+  };
+
+  await saveState(projectDir, state);
+  return state;
+}
+
+/**
+ * Update state after update command
+ */
+export async function updateState(projectDir, updates) {
+  const state = await loadState(projectDir);
+
+  if (!state) {
+    throw new Error('No state found. Is this an ak project?');
+  }
+
+  const targetDir = join(projectDir, state.target || '.claude');
+  const newHashes = await hashDirectory(targetDir);
+
+  const updatedState = {
+    ...state,
+    ...updates,
+    lastUpdate: new Date().toISOString(),
+    originalHashes: newHashes
+  };
+
+  await saveState(projectDir, updatedState);
+  return updatedState;
+}
+
+/**
+ * Get file status (unchanged, modified, added, deleted)
+ */
+export async function getFileStatuses(projectDir) {
+  const state = await loadState(projectDir);
+
+  if (!state) {
+    return { error: 'No state found' };
+  }
+
+  const targetDir = join(projectDir, state.target || '.claude');
+  const currentHashes = await hashDirectory(targetDir);
+  const originalHashes = state.originalHashes || {};
+
+  const statuses = {
+    unchanged: [],
+    modified: [],
+    added: [],
+    deleted: []
+  };
+
+  // Check original files
+  for (const [path, hash] of Object.entries(originalHashes)) {
+    if (currentHashes[path] === undefined) {
+      statuses.deleted.push(path);
+    } else if (currentHashes[path] !== hash) {
+      statuses.modified.push(path);
+    } else {
+      statuses.unchanged.push(path);
+    }
+  }
+
+  // Check for new files
+  for (const path of Object.keys(currentHashes)) {
+    if (originalHashes[path] === undefined) {
+      statuses.added.push(path);
+    }
+  }
+
+  return {
+    state,
+    statuses,
+    targetDir
+  };
+}