apero-kit-cli 1.0.0

package/src/index.js

@@ -0,0 +1,8 @@
+// Apero Kit CLI - Main exports
+export { initCommand } from './commands/init.js';
+export { addCommand } from './commands/add.js';
+export { listCommand } from './commands/list.js';
+export { updateCommand } from './commands/update.js';
+export { statusCommand } from './commands/status.js';
+export { doctorCommand } from './commands/doctor.js';
+export { KITS, getKit, getKitNames, getKitList } from './kits/index.js';

package/src/kits/index.js

@@ -0,0 +1,122 @@
+// Kit definitions - what each kit includes
+
+export const KITS = {
+  engineer: {
+    name: 'engineer',
+    description: 'Full-stack development kit for building applications',
+    emoji: '🛠️',
+    color: 'blue',
+    agents: [
+      'planner',
+      'debugger',
+      'fullstack-developer',
+      'tester',
+      'code-reviewer',
+      'git-manager',
+      'database-admin'
+    ],
+    commands: [
+      'plan', 'plan/parallel', 'plan/fast', 'plan/hard',
+      'code', 'code/auto', 'code/parallel',
+      'fix', 'fix/test', 'fix/types', 'fix/fast', 'fix/ci',
+      'test', 'test/ui',
+      'review', 'review/codebase',
+      'scout', 'build', 'lint'
+    ],
+    skills: [
+      'frontend-development',
+      'backend-development',
+      'databases',
+      'debugging',
+      'code-review',
+      'planning',
+      'problem-solving'
+    ],
+    workflows: ['feature-development', 'bug-fixing'],
+    includeRouter: true,
+    includeHooks: true
+  },
+
+  researcher: {
+    name: 'researcher',
+    description: 'Research and analysis kit for exploring codebases',
+    emoji: '🔬',
+    color: 'green',
+    agents: [
+      'researcher',
+      'scout',
+      'scout-external',
+      'brainstormer',
+      'docs-manager',
+      'planner'
+    ],
+    commands: [
+      'scout', 'scout/ext',
+      'investigate', 'brainstorm',
+      'docs', 'docs/init', 'docs/update', 'docs/summarize',
+      'plan', 'ask', 'context'
+    ],
+    skills: [
+      'research',
+      'planning-with-files',
+      'documentation',
+      'project-index'
+    ],
+    workflows: [],
+    includeRouter: true,
+    includeHooks: false
+  },
+
+  designer: {
+    name: 'designer',
+    description: 'UI/UX design and frontend development kit',
+    emoji: '🎨',
+    color: 'magenta',
+    agents: [
+      'ui-ux-designer',
+      'fullstack-developer',
+      'code-reviewer'
+    ],
+    commands: [
+      'code', 'fix', 'fix/ui', 'test/ui', 'review'
+    ],
+    skills: [
+      'ui-ux-pro-max',
+      'frontend-development',
+      'frontend-design'
+    ],
+    workflows: [],
+    includeRouter: false,
+    includeHooks: true
+  },
+
+  minimal: {
+    name: 'minimal',
+    description: 'Lightweight kit with essential agents only',
+    emoji: '📦',
+    color: 'yellow',
+    agents: ['planner', 'debugger'],
+    commands: ['plan', 'fix', 'code'],
+    skills: ['planning', 'debugging'],
+    workflows: [],
+    includeRouter: false,
+    includeHooks: false
+  },
+
+  full: {
+    name: 'full',
+    description: 'Complete kit with ALL agents, commands, and skills',
+    emoji: '🚀',
+    color: 'cyan',
+    agents: 'all',
+    commands: 'all',
+    skills: 'all',
+    workflows: 'all',
+    includeRouter: true,
+    includeHooks: true
+  }
+};
+
+export const getKit = (name) => KITS[name] || null;
+export const getKitNames = () => Object.keys(KITS);
+export const getKitList = () => Object.values(KITS);

package/src/utils/copy.js

@@ -0,0 +1,194 @@
+import fs from 'fs-extra';
+import { join, basename } from 'path';
+
+/**
+ * Copy specific items from source to destination
+ */
+export async function copyItems(items, type, sourceDir, destDir) {
+  const typeDir = join(sourceDir, type);
+  const destTypeDir = join(destDir, type);
+
+  if (!fs.existsSync(typeDir)) {
+    return { copied: [], skipped: items, errors: [] };
+  }
+
+  await fs.ensureDir(destTypeDir);
+
+  const copied = [];
+  const skipped = [];
+  const errors = [];
+
+  for (const item of items) {
+    try {
+      // Handle nested paths like "plan/parallel"
+      const itemPath = join(typeDir, item);
+      const itemPathMd = itemPath + '.md';
+
+      let srcPath;
+      if (fs.existsSync(itemPath)) {
+        srcPath = itemPath;
+      } else if (fs.existsSync(itemPathMd)) {
+        srcPath = itemPathMd;
+      } else {
+        skipped.push(item);
+        continue;
+      }
+
+      // Determine destination path
+      const stat = fs.statSync(srcPath);
+      if (stat.isDirectory()) {
+        await fs.copy(srcPath, join(destTypeDir, item), { overwrite: true });
+      } else {
+        // Preserve directory structure for nested items
+        const destPath = srcPath.endsWith('.md')
+          ? join(destTypeDir, item + '.md')
+          : join(destTypeDir, item);
+        await fs.ensureDir(join(destTypeDir, item.split('/').slice(0, -1).join('/')));
+        await fs.copy(srcPath, destPath, { overwrite: true });
+      }
+
+      copied.push(item);
+    } catch (err) {
+      errors.push({ item, error: err.message });
+    }
+  }
+
+  return { copied, skipped, errors };
+}
+
+/**
+ * Copy all items of a type
+ */
+export async function copyAllOfType(type, sourceDir, destDir) {
+  const typeDir = join(sourceDir, type);
+  const destTypeDir = join(destDir, type);
+
+  if (!fs.existsSync(typeDir)) {
+    return { success: false, error: `${type} directory not found` };
+  }
+
+  try {
+    await fs.copy(typeDir, destTypeDir, { overwrite: true });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Copy router directory
+ */
+export async function copyRouter(sourceDir, destDir) {
+  const routerDir = join(sourceDir, 'router');
+
+  if (!fs.existsSync(routerDir)) {
+    return { success: false, error: 'Router directory not found' };
+  }
+
+  try {
+    await fs.copy(routerDir, join(destDir, 'router'), { overwrite: true });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Copy hooks directory
+ */
+export async function copyHooks(sourceDir, destDir) {
+  const hooksDir = join(sourceDir, 'hooks');
+
+  if (!fs.existsSync(hooksDir)) {
+    return { success: false, error: 'Hooks directory not found' };
+  }
+
+  try {
+    await fs.copy(hooksDir, join(destDir, 'hooks'), { overwrite: true });
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Copy workflows directory
+ */
+export async function copyWorkflows(items, sourceDir, destDir) {
+  if (items === 'all') {
+    return copyAllOfType('workflows', sourceDir, destDir);
+  }
+  return copyItems(items, 'workflows', sourceDir, destDir);
+}
+
+/**
+ * Copy base files (README, settings, etc.)
+ */
+export async function copyBaseFiles(sourceDir, destDir) {
+  const baseFiles = ['README.md', 'settings.json', '.env.example'];
+  const copied = [];
+
+  for (const file of baseFiles) {
+    const srcPath = join(sourceDir, file);
+    if (fs.existsSync(srcPath)) {
+      await fs.copy(srcPath, join(destDir, file), { overwrite: true });
+      copied.push(file);
+    }
+  }
+
+  return copied;
+}
+
+/**
+ * Copy AGENTS.md to project root
+ */
+export async function copyAgentsMd(agentsMdPath, projectDir) {
+  if (!agentsMdPath || !fs.existsSync(agentsMdPath)) {
+    return false;
+  }
+
+  await fs.copy(agentsMdPath, join(projectDir, 'AGENTS.md'), { overwrite: true });
+  return true;
+}
+
+/**
+ * List available items of a type
+ */
+export function listAvailable(type, sourceDir) {
+  const typeDir = join(sourceDir, type);
+
+  if (!fs.existsSync(typeDir)) {
+    return [];
+  }
+
+  const items = fs.readdirSync(typeDir);
+  return items.map(item => {
+    const itemPath = join(typeDir, item);
+    const isDir = fs.statSync(itemPath).isDirectory();
+    const name = item.replace(/\.md$/, '');
+    return { name, isDir, path: itemPath };
+  });
+}
+
+/**
+ * Copy only unchanged files (for update)
+ */
+export async function copyUnchangedOnly(sourceDir, destDir, unchangedFiles) {
+  const copied = [];
+  const skipped = [];
+
+  for (const file of unchangedFiles) {
+    const srcPath = join(sourceDir, file);
+    const destPath = join(destDir, file);
+
+    if (fs.existsSync(srcPath)) {
+      await fs.ensureDir(join(destDir, file.split('/').slice(0, -1).join('/')));
+      await fs.copy(srcPath, destPath, { overwrite: true });
+      copied.push(file);
+    } else {
+      skipped.push(file);
+    }
+  }
+
+  return { copied, skipped };
+}

package/src/utils/hash.js

@@ -0,0 +1,74 @@
+import { createHash } from 'crypto';
+import fs from 'fs-extra';
+import { join, relative } from 'path';
+
+/**
+ * Calculate MD5 hash of a file
+ */
+export function hashFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(filePath);
+  return createHash('md5').update(content).digest('hex');
+}
+
+/**
+ * Calculate hashes for all files in a directory
+ */
+export async function hashDirectory(dirPath, baseDir = dirPath) {
+  const hashes = {};
+
+  if (!fs.existsSync(dirPath)) {
+    return hashes;
+  }
+
+  const items = await fs.readdir(dirPath, { withFileTypes: true });
+
+  for (const item of items) {
+    const itemPath = join(dirPath, item.name);
+    const relativePath = relative(baseDir, itemPath);
+
+    if (item.isDirectory()) {
+      const subHashes = await hashDirectory(itemPath, baseDir);
+      Object.assign(hashes, subHashes);
+    } else if (item.isFile()) {
+      hashes[relativePath] = hashFile(itemPath);
+    }
+  }
+
+  return hashes;
+}
+
+/**
+ * Compare two hash maps and return differences
+ */
+export function compareHashes(original, current) {
+  const result = {
+    unchanged: [],
+    modified: [],
+    added: [],
+    deleted: []
+  };
+
+  // Check original files
+  for (const [path, hash] of Object.entries(original)) {
+    if (current[path] === undefined) {
+      result.deleted.push(path);
+    } else if (current[path] !== hash) {
+      result.modified.push(path);
+    } else {
+      result.unchanged.push(path);
+    }
+  }
+
+  // Check for new files
+  for (const path of Object.keys(current)) {
+    if (original[path] === undefined) {
+      result.added.push(path);
+    }
+  }
+
+  return result;
+}

package/src/utils/paths.js

@@ -0,0 +1,166 @@
+import { fileURLToPath } from 'url';
+import { dirname, join, resolve } from 'path';
+import { existsSync, statSync } from 'fs';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// CLI root directory
+export const CLI_ROOT = resolve(__dirname, '../..');
+
+// Target folder mappings
+export const TARGETS = {
+  claude: '.claude',
+  opencode: '.opencode',
+  generic: '.agent'
+};
+
+/**
+ * Find source directory by traversing up from cwd
+ * Algorithm: cwd → parent → git root
+ * Looks for: AGENTS.md file or .claude/ directory
+ */
+export function findSource(startDir = process.cwd()) {
+  let current = resolve(startDir);
+  const root = getGitRoot(current) || '/';
+
+  while (current !== root && current !== '/') {
+    // Check for AGENTS.md file
+    const agentsMd = join(current, 'AGENTS.md');
+    if (existsSync(agentsMd) && statSync(agentsMd).isFile()) {
+      // Found AGENTS.md, check for .claude/ in same directory
+      const claudeDir = join(current, '.claude');
+      if (existsSync(claudeDir) && statSync(claudeDir).isDirectory()) {
+        return {
+          path: current,
+          type: 'agents-repo',
+          claudeDir,
+          agentsMd
+        };
+      }
+    }
+
+    // Check for standalone .claude/ directory
+    const claudeDir = join(current, '.claude');
+    if (existsSync(claudeDir) && statSync(claudeDir).isDirectory()) {
+      return {
+        path: current,
+        type: 'claude-only',
+        claudeDir,
+        agentsMd: null
+      };
+    }
+
+    // Check for .opencode/ as fallback
+    const opencodeDir = join(current, '.opencode');
+    if (existsSync(opencodeDir) && statSync(opencodeDir).isDirectory()) {
+      return {
+        path: current,
+        type: 'opencode',
+        claudeDir: opencodeDir,
+        agentsMd: existsSync(join(current, 'AGENTS.md')) ? join(current, 'AGENTS.md') : null
+      };
+    }
+
+    current = dirname(current);
+  }
+
+  // Check git root as final attempt
+  if (root && root !== '/') {
+    const claudeDir = join(root, '.claude');
+    if (existsSync(claudeDir)) {
+      return {
+        path: root,
+        type: 'git-root',
+        claudeDir,
+        agentsMd: existsSync(join(root, 'AGENTS.md')) ? join(root, 'AGENTS.md') : null
+      };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Get git root directory
+ */
+export function getGitRoot(startDir = process.cwd()) {
+  try {
+    const result = execSync('git rev-parse --show-toplevel', {
+      cwd: startDir,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if current directory is an ak project
+ */
+export function isAkProject(dir = process.cwd()) {
+  const akConfig = join(dir, '.ak', 'state.json');
+  const claudeDir = join(dir, '.claude');
+  const opencodeDir = join(dir, '.opencode');
+  const agentDir = join(dir, '.agent');
+
+  return existsSync(akConfig) ||
+         existsSync(claudeDir) ||
+         existsSync(opencodeDir) ||
+         existsSync(agentDir);
+}
+
+/**
+ * Get target directory path
+ */
+export function getTargetDir(projectDir, target = 'claude') {
+  const folder = TARGETS[target] || TARGETS.claude;
+  return join(projectDir, folder);
+}
+
+/**
+ * Resolve source path (from --source flag or auto-detect)
+ */
+export function resolveSource(sourceFlag) {
+  if (sourceFlag) {
+    const resolved = resolve(sourceFlag);
+    if (!existsSync(resolved)) {
+      return { error: `Source path not found: ${sourceFlag}` };
+    }
+
+    // Check if it's a valid source
+    const claudeDir = join(resolved, '.claude');
+    const opencodeDir = join(resolved, '.opencode');
+
+    if (existsSync(claudeDir)) {
+      return {
+        path: resolved,
+        claudeDir,
+        agentsMd: existsSync(join(resolved, 'AGENTS.md')) ? join(resolved, 'AGENTS.md') : null
+      };
+    }
+
+    if (existsSync(opencodeDir)) {
+      return {
+        path: resolved,
+        claudeDir: opencodeDir,
+        agentsMd: existsSync(join(resolved, 'AGENTS.md')) ? join(resolved, 'AGENTS.md') : null
+      };
+    }
+
+    return { error: `No .claude/ or .opencode/ found in: ${sourceFlag}` };
+  }
+
+  // Auto-detect
+  const found = findSource();
+  if (!found) {
+    return {
+      error: 'Could not find source. Use --source flag or ensure AGENTS.md/.claude/ exists in parent directories.'
+    };
+  }
+
+  return found;
+}