@onion-ai/cli 1.0.0-beta.1

package/src/cli.js

@@ -0,0 +1,73 @@
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf-8'));
+
+export function createCli() {
+  const program = new Command();
+
+  program
+    .name('onion')
+    .description('The Onion Framework - AI-powered development workflow system for Claude Code')
+    .version(pkg.version);
+
+  program
+    .command('install')
+    .description('Install the Onion Framework into ~/.claude/')
+    .option('--force', 'Overwrite existing installation')
+    .option('--dry-run', 'Show what would be installed without making changes')
+    .action(async (opts) => {
+      const { install } = await import('./commands/install.js');
+      await install(opts);
+    });
+
+  program
+    .command('uninstall')
+    .description('Remove the Onion Framework from ~/.claude/')
+    .option('--keep-config', 'Keep user customizations in ~/.claude/onion/config/')
+    .action(async (opts) => {
+      const { uninstall } = await import('./commands/uninstall.js');
+      await uninstall(opts);
+    });
+
+  program
+    .command('doctor')
+    .description('Check installation health and prerequisites')
+    .action(async () => {
+      const { doctor } = await import('./commands/doctor.js');
+      await doctor();
+    });
+
+  program
+    .command('update')
+    .description('Update the Onion Framework to the latest version')
+    .action(async () => {
+      const { update } = await import('./commands/update.js');
+      await update();
+    });
+
+  program
+    .command('list')
+    .description('List installed framework components')
+    .option('--commands', 'List only commands')
+    .option('--agents', 'List only agents')
+    .option('--skills', 'List only skills')
+    .action(async (opts) => {
+      const { list } = await import('./commands/list.js');
+      await list(opts);
+    });
+
+  program
+    .command('init')
+    .description('Initialize Onion configuration for the current project (.onion/)')
+    .option('--force', 'Overwrite existing .onion/ configuration')
+    .action(async (opts) => {
+      const { init } = await import('./commands/init.js');
+      await init(opts);
+    });
+
+  return program;
+}

package/src/commands/doctor.js

@@ -0,0 +1,191 @@
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import {
+  CLAUDE_HOME, ONION_HOME, ONION_MANIFEST,
+  ONION_COMMANDS, ONION_AGENTS, CLAUDE_SKILLS, CLAUDE_MD
+} from '../utils/paths.js';
+import { readFile, exists, countFiles } from '../utils/fs.js';
+import * as log from '../utils/log.js';
+import { readdirSync } from 'fs';
+
+export async function doctor() {
+  log.header('Onion Framework Health Check');
+
+  let issues = 0;
+  let warnings = 0;
+
+  // 1. Prerequisites
+  log.step('Checking prerequisites...');
+
+  // Claude Code
+  if (exists(CLAUDE_HOME)) {
+    log.success('Claude Code config directory exists');
+  } else {
+    log.error('Claude Code config directory not found (~/.claude/)');
+    issues++;
+  }
+
+  // Claude CLI
+  if (commandExists('claude')) {
+    log.success('Claude Code CLI available');
+  } else {
+    log.warn('Claude Code CLI not found in PATH (optional — may use IDE integration)');
+    warnings++;
+  }
+
+  // Git
+  if (commandExists('git')) {
+    log.success('Git available');
+  } else {
+    log.error('Git not found — required for GitFlow commands');
+    issues++;
+  }
+
+  // Node.js
+  if (commandExists('node')) {
+    const version = getCommandOutput('node --version');
+    const major = parseInt(version.replace('v', '').split('.')[0]);
+    if (major >= 18) {
+      log.success(`Node.js ${version} (>= 18 required)`);
+    } else {
+      log.warn(`Node.js ${version} — version 18+ recommended`);
+      warnings++;
+    }
+  } else {
+    log.error('Node.js not found');
+    issues++;
+  }
+
+  // Python (optional)
+  if (commandExists('python3') || commandExists('python')) {
+    const cmd = commandExists('python3') ? 'python3' : 'python';
+    const version = getCommandOutput(`${cmd} --version`);
+    log.success(`${version} (optional dependency)`);
+  } else {
+    log.info('Python not found (optional — only needed for specific commands)');
+  }
+
+  log.blank();
+
+  // 2. Installation check
+  log.step('Checking installation...');
+
+  if (!exists(ONION_HOME)) {
+    log.error('Onion Framework not installed');
+    log.info('Run: npx @onion-ai/cli install');
+    process.exit(1);
+  }
+  log.success('Framework home exists (~/.claude/onion/)');
+
+  // Manifest
+  const manifest = readManifest();
+  if (manifest) {
+    log.success(`Version ${manifest.version} installed on ${manifest.installedAt.split('T')[0]}`);
+  } else {
+    log.warn('Installation manifest missing or corrupted');
+    warnings++;
+  }
+
+  // Commands
+  if (exists(ONION_COMMANDS)) {
+    const count = countFiles(ONION_COMMANDS);
+    log.success(`${count} commands installed → /onion:*`);
+  } else {
+    log.error('Commands directory missing (~/.claude/commands/onion/)');
+    issues++;
+  }
+
+  // Agents
+  if (exists(ONION_AGENTS)) {
+    const count = countFiles(ONION_AGENTS);
+    log.success(`${count} agents installed`);
+  } else {
+    log.error('Agents directory missing (~/.claude/agents/onion/)');
+    issues++;
+  }
+
+  // Skills
+  const skillCount = countOnionSkills();
+  if (skillCount > 0) {
+    log.success(`${skillCount} skills installed (onion-* prefix)`);
+  } else {
+    log.warn('No onion skills found in ~/.claude/skills/');
+    warnings++;
+  }
+
+  // CLAUDE.md integration
+  const claudeMd = readFile(CLAUDE_MD);
+  if (claudeMd && claudeMd.includes('Onion Framework')) {
+    log.success('CLAUDE.md integration active');
+  } else {
+    log.error('CLAUDE.md not patched — framework may not load');
+    log.info('Run: onion install --force');
+    issues++;
+  }
+
+  // Docs
+  if (exists(`${ONION_HOME}/docs`)) {
+    const docCount = countFiles(`${ONION_HOME}/docs`);
+    log.success(`${docCount} documentation files available`);
+  } else {
+    log.warn('Documentation directory missing');
+    warnings++;
+  }
+
+  log.blank();
+
+  // 3. Summary
+  if (issues === 0 && warnings === 0) {
+    log.header('All checks passed!');
+    log.success('Onion Framework is healthy and ready to use');
+  } else if (issues === 0) {
+    log.header(`Passed with ${warnings} warning(s)`);
+    log.info('Framework is functional but some optional features may be limited');
+  } else {
+    log.header(`${issues} issue(s) found, ${warnings} warning(s)`);
+    log.error('Run "onion install --force" to repair the installation');
+  }
+
+  log.blank();
+  return { issues, warnings };
+}
+
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    // Windows fallback
+    try {
+      execSync(`where ${cmd}`, { stdio: 'ignore' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function getCommandOutput(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf-8' }).trim();
+  } catch {
+    return 'unknown';
+  }
+}
+
+function countOnionSkills() {
+  if (!existsSync(CLAUDE_SKILLS)) return 0;
+  return readdirSync(CLAUDE_SKILLS, { withFileTypes: true })
+    .filter(e => e.isDirectory() && e.name.startsWith('onion-'))
+    .length;
+}
+
+function readManifest() {
+  const content = readFile(ONION_MANIFEST);
+  if (!content) return null;
+  try {
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}

package/src/commands/init.js

@@ -0,0 +1,287 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { ensureDir, readFile, writeFile, exists } from '../utils/fs.js';
+import * as log from '../utils/log.js';
+import { ask, confirm, select } from '../utils/prompt.js';
+
+const ONION_DIR = '.onion';
+const CONFIG_FILE = 'config.yaml';
+const ENV_FILE = '.env';
+const ENV_EXAMPLE_FILE = '.env.example';
+
+export async function init(opts = {}) {
+  const projectRoot = process.cwd();
+  const onionDir = join(projectRoot, ONION_DIR);
+
+  log.header('Onion Framework — Project Setup');
+
+  // Check if already initialized
+  if (exists(onionDir) && !opts.force) {
+    log.warn(`${ONION_DIR}/ already exists in this project`);
+    const overwrite = await confirm('Overwrite existing configuration?', false);
+    if (!overwrite) {
+      log.info('Setup cancelled. Use --force to overwrite.');
+      return;
+    }
+  }
+
+  // Interactive configuration
+  log.step('Let\'s configure Onion for this project.\n');
+
+  // 1. Task Manager
+  const taskManager = await select('Which task manager does this project use?', [
+    { label: 'ClickUp', value: 'clickup', description: 'via MCP integration', default: true },
+    { label: 'Jira', value: 'jira', description: 'via API' },
+    { label: 'Linear', value: 'linear', description: 'via API' },
+    { label: 'Asana', value: 'asana', description: 'via MCP integration' },
+    { label: 'None', value: 'none', description: 'offline mode — local task tracking only' },
+  ]);
+
+  // Task manager specific config
+  let taskManagerConfig = {};
+  if (taskManager !== 'none') {
+    if (taskManager === 'clickup') {
+      taskManagerConfig.workspace_id = await ask('ClickUp Workspace ID (from URL)', '');
+      taskManagerConfig.default_list = await ask('Default List ID for new tasks', '');
+    } else if (taskManager === 'jira') {
+      taskManagerConfig.base_url = await ask('Jira base URL (e.g., https://company.atlassian.net)', '');
+      taskManagerConfig.project_key = await ask('Jira project key (e.g., PROJ)', '');
+    } else if (taskManager === 'linear') {
+      taskManagerConfig.team_id = await ask('Linear Team ID', '');
+    } else if (taskManager === 'asana') {
+      taskManagerConfig.workspace_id = await ask('Asana Workspace ID', '');
+      taskManagerConfig.project_id = await ask('Asana Project ID', '');
+    }
+  }
+
+  console.log('');
+
+  // 2. Language
+  const docsLanguage = await select('Documentation and comments language?', [
+    { label: 'English', value: 'en', default: true },
+    { label: 'Portuguese (Brazil)', value: 'pt-BR' },
+    { label: 'Spanish', value: 'es' },
+    { label: 'Other', value: 'other' },
+  ]);
+
+  let docsLang = docsLanguage;
+  if (docsLanguage === 'other') {
+    docsLang = await ask('Language code (e.g., fr, de, ja)', 'en');
+  }
+
+  console.log('');
+
+  // 3. Git Workflow
+  const gitFlow = await select('Git workflow for this project?', [
+    { label: 'GitFlow', value: 'gitflow', description: 'feature/release/hotfix branches', default: true },
+    { label: 'GitHub Flow', value: 'github-flow', description: 'feature branches from main' },
+    { label: 'Trunk-based', value: 'trunk', description: 'direct commits to main with short-lived branches' },
+  ]);
+
+  const mainBranch = await ask('Main branch name', 'main');
+  let developBranch = '';
+  if (gitFlow === 'gitflow') {
+    developBranch = await ask('Develop branch name', 'develop');
+  }
+
+  console.log('');
+
+  // 4. Integrations
+  const enableGamma = await confirm('Enable Gamma.app integration (presentations)?', false);
+  const enableCodeReview = await confirm('Enable automated code review?', true);
+
+  console.log('');
+
+  // Generate config
+  log.step('Creating configuration...');
+  ensureDir(onionDir);
+
+  // Write config.yaml
+  const config = generateConfig({
+    taskManager,
+    taskManagerConfig,
+    docsLang,
+    gitFlow,
+    mainBranch,
+    developBranch,
+    enableGamma,
+    enableCodeReview,
+  });
+  writeFile(join(onionDir, CONFIG_FILE), config);
+  log.success(`Created ${ONION_DIR}/${CONFIG_FILE}`);
+
+  // Write .env
+  const envContent = generateEnv(taskManager, enableGamma);
+  writeFile(join(onionDir, ENV_FILE), envContent);
+  log.success(`Created ${ONION_DIR}/${ENV_FILE}`);
+
+  // Write .env.example (committable reference)
+  const envExample = generateEnvExample(taskManager, enableGamma);
+  writeFile(join(onionDir, ENV_EXAMPLE_FILE), envExample);
+  log.success(`Created ${ONION_DIR}/${ENV_EXAMPLE_FILE}`);
+
+  // Patch .gitignore
+  patchGitignore(projectRoot);
+  log.success('Updated .gitignore');
+
+  // Summary
+  log.blank();
+  log.header('Project configured!');
+  log.blank();
+  log.info('Next steps:');
+  log.step(`Add your API keys to ${ONION_DIR}/.env`);
+  log.step(`Commit ${ONION_DIR}/config.yaml and ${ONION_DIR}/.env.example to share with your team`);
+  log.step('Run /onion:warm-up in Claude Code to start');
+  log.blank();
+}
+
+function generateConfig({ taskManager, taskManagerConfig, docsLang, gitFlow, mainBranch, developBranch, enableGamma, enableCodeReview }) {
+  let yaml = `# Onion Framework — Project Configuration
+# Generated by @onion-ai/cli
+# Commit this file to share settings with your team.
+
+version: "1.0"
+
+# Task Manager
+task_manager:
+  provider: ${taskManager}
+`;
+
+  // Add provider-specific fields
+  if (taskManager === 'clickup') {
+    yaml += `  workspace_id: "${taskManagerConfig.workspace_id || ''}"
+  default_list: "${taskManagerConfig.default_list || ''}"
+`;
+  } else if (taskManager === 'jira') {
+    yaml += `  base_url: "${taskManagerConfig.base_url || ''}"
+  project_key: "${taskManagerConfig.project_key || ''}"
+`;
+  } else if (taskManager === 'linear') {
+    yaml += `  team_id: "${taskManagerConfig.team_id || ''}"
+`;
+  } else if (taskManager === 'asana') {
+    yaml += `  workspace_id: "${taskManagerConfig.workspace_id || ''}"
+  project_id: "${taskManagerConfig.project_id || ''}"
+`;
+  }
+
+  yaml += `
+# Language
+language:
+  code: en
+  docs: ${docsLang}
+  commits: ${docsLang}
+
+# Git Workflow
+git:
+  flow: ${gitFlow}
+  main_branch: ${mainBranch}
+`;
+
+  if (gitFlow === 'gitflow' && developBranch) {
+    yaml += `  develop_branch: ${developBranch}
+`;
+  }
+
+  yaml += `
+# Integrations
+integrations:
+  gamma:
+    enabled: ${enableGamma}
+  code_review:
+    enabled: ${enableCodeReview}
+`;
+
+  return yaml;
+}
+
+function generateEnv(taskManager, enableGamma) {
+  let env = `# Onion Framework — Secrets
+# DO NOT COMMIT THIS FILE. It is gitignored.
+# Copy from .env.example and fill in your values.
+
+`;
+
+  if (taskManager === 'clickup') {
+    env += `# ClickUp API Token (get from: ClickUp > Settings > Apps)
+CLICKUP_API_TOKEN=
+`;
+  } else if (taskManager === 'jira') {
+    env += `# Jira API Token (get from: https://id.atlassian.com/manage-profile/security/api-tokens)
+JIRA_API_TOKEN=
+JIRA_USER_EMAIL=
+`;
+  } else if (taskManager === 'linear') {
+    env += `# Linear API Key (get from: Linear > Settings > API)
+LINEAR_API_KEY=
+`;
+  } else if (taskManager === 'asana') {
+    env += `# Asana Personal Access Token (get from: Asana > Settings > Apps > Developer)
+ASANA_API_TOKEN=
+`;
+  }
+
+  if (enableGamma) {
+    env += `
+# Gamma.app API Key (for presentation generation)
+GAMMA_API_KEY=
+`;
+  }
+
+  return env;
+}
+
+function generateEnvExample(taskManager, enableGamma) {
+  let env = `# Onion Framework — Environment Variables
+# Copy this file to .env and fill in your values:
+#   cp .onion/.env.example .onion/.env
+
+`;
+
+  if (taskManager === 'clickup') {
+    env += `CLICKUP_API_TOKEN=pk_your_token_here
+`;
+  } else if (taskManager === 'jira') {
+    env += `JIRA_API_TOKEN=your_token_here
+JIRA_USER_EMAIL=your_email@company.com
+`;
+  } else if (taskManager === 'linear') {
+    env += `LINEAR_API_KEY=lin_api_your_key_here
+`;
+  } else if (taskManager === 'asana') {
+    env += `ASANA_API_TOKEN=your_token_here
+`;
+  }
+
+  if (enableGamma) {
+    env += `GAMMA_API_KEY=your_gamma_key_here
+`;
+  }
+
+  return env;
+}
+
+/**
+ * Patch .gitignore to exclude .onion/.env (but allow .onion/config.yaml).
+ */
+function patchGitignore(projectRoot) {
+  const gitignorePath = join(projectRoot, '.gitignore');
+  let content = '';
+
+  if (existsSync(gitignorePath)) {
+    content = readFileSync(gitignorePath, 'utf-8');
+  }
+
+  const entries = ['.onion/.env'];
+  const toAdd = entries.filter(entry => !content.includes(entry));
+
+  if (toAdd.length === 0) return;
+
+  const block = `
+# Onion Framework secrets
+${toAdd.join('\n')}
+`;
+
+  content = content.trimEnd() + '\n' + block + '\n';
+  writeFileSync(gitignorePath, content, 'utf-8');
+}