@onion-architect-ai/cli 4.1.0-beta.1

package/dist/cli.js

@@ -0,0 +1,1952 @@
+#!/usr/bin/env node
+import fs2 from 'fs-extra';
+import path8 from 'path';
+import yaml5 from 'yaml';
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import ora from 'ora';
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/constants.ts
+var ONION_VERSION, SUPPORTED_IDES;
+var init_constants = __esm({
+  "src/constants.ts"() {
+    ONION_VERSION = "4.1.0-beta.1";
+    SUPPORTED_IDES = [
+      {
+        id: "cursor",
+        name: "Cursor",
+        detector: ".cursor",
+        loader: "cursor.js",
+        configFile: "settings.json"
+      },
+      {
+        id: "windsurf",
+        name: "Windsurf",
+        detector: ".windsurf",
+        loader: "windsurf.ts",
+        configFile: "settings.yml"
+      },
+      {
+        id: "claude-code",
+        name: "Claude Code",
+        detector: ".claude",
+        loader: "claude.py",
+        configFile: "config.json"
+      },
+      {
+        id: "vscode",
+        name: "VS Code (GitHub Copilot)",
+        detector: ".vscode",
+        loader: "vscode.js",
+        configFile: "settings.json"
+      },
+      {
+        id: "cline",
+        name: "Cline (VS Code)",
+        detector: ".vscode/extensions",
+        loader: "cline.js",
+        configFile: "cline-config.json"
+      }
+    ];
+  }
+});
+
+// src/core/validator.ts
+function validateContextName(name) {
+  if (!name || typeof name !== "string") {
+    throw new Error("Nome do contexto \xE9 obrigat\xF3rio");
+  }
+  const trimmed = name.trim();
+  if (trimmed.length < 3 || trimmed.length > 20) {
+    throw new Error("Nome do contexto deve ter entre 3 e 20 caracteres");
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(trimmed)) {
+    throw new Error(
+      "Nome do contexto deve come\xE7ar com letra min\xFAscula e conter apenas letras, n\xFAmeros e h\xEDfens"
+    );
+  }
+  if (trimmed.endsWith("-")) {
+    throw new Error("Nome do contexto n\xE3o pode terminar com h\xEDfen");
+  }
+  const reserved = ["core", "ide", "contexts", "config", "help"];
+  if (reserved.includes(trimmed)) {
+    throw new Error(`"${trimmed}" \xE9 uma palavra reservada do sistema`);
+  }
+  return true;
+}
+function validateIDEName(ide) {
+  if (!ide || typeof ide !== "string") {
+    throw new Error("Nome do IDE \xE9 obrigat\xF3rio");
+  }
+  const supportedIds = SUPPORTED_IDES.map((i) => i.id);
+  if (!supportedIds.includes(ide.toLowerCase())) {
+    throw new Error(
+      `IDE "${ide}" n\xE3o \xE9 suportado. IDEs dispon\xEDveis: ${supportedIds.join(", ")}`
+    );
+  }
+  return true;
+}
+function validateConfig(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("Configura\xE7\xE3o inv\xE1lida");
+  }
+  const cfg = config;
+  const required = ["version", "contexts", "ides"];
+  for (const field of required) {
+    if (!cfg[field]) {
+      throw new Error(`Campo obrigat\xF3rio ausente no config: ${field}`);
+    }
+  }
+  if (!Array.isArray(cfg.contexts)) {
+    throw new Error('Campo "contexts" deve ser um array');
+  }
+  if (!Array.isArray(cfg.ides)) {
+    throw new Error('Campo "ides" deve ser um array');
+  }
+  for (const ctx of cfg.contexts) {
+    try {
+      validateContextName(ctx);
+    } catch (err) {
+      throw new Error(`Contexto inv\xE1lido "${ctx}": ${err.message}`);
+    }
+  }
+  for (const ide of cfg.ides) {
+    try {
+      validateIDEName(ide);
+    } catch (err) {
+      throw new Error(`IDE inv\xE1lido "${ide}": ${err.message}`);
+    }
+  }
+  return true;
+}
+var init_validator = __esm({
+  "src/core/validator.ts"() {
+    init_constants();
+  }
+});
+async function readConfig(projectRoot) {
+  const configPath = path8.join(projectRoot, CONFIG_FILENAME);
+  if (!await fs2.pathExists(configPath)) {
+    throw new Error(`Arquivo ${CONFIG_FILENAME} n\xE3o encontrado em ${projectRoot}`);
+  }
+  try {
+    const content = await fs2.readFile(configPath, "utf8");
+    const config = yaml5.parse(content);
+    validateConfig(config);
+    return config;
+  } catch (error) {
+    if (error.message.includes("n\xE3o encontrado")) {
+      throw error;
+    }
+    throw new Error(`Erro ao ler ${CONFIG_FILENAME}: ${error.message}`);
+  }
+}
+async function createConfig(projectRoot, data) {
+  const configPath = path8.join(projectRoot, CONFIG_FILENAME);
+  if (await fs2.pathExists(configPath)) {
+    throw new Error(`Arquivo ${CONFIG_FILENAME} j\xE1 existe. Use updateConfig() para modificar.`);
+  }
+  validateConfig(data);
+  try {
+    const yamlContent = yaml5.stringify(data, {
+      indent: 2,
+      lineWidth: 0
+      // Sem quebra de linha
+    });
+    await fs2.writeFile(configPath, yamlContent, "utf8");
+  } catch (error) {
+    throw new Error(`Erro ao criar ${CONFIG_FILENAME}: ${error.message}`);
+  }
+}
+async function updateConfig(projectRoot, updates) {
+  const current = await readConfig(projectRoot);
+  const merged = deepMerge(
+    current,
+    updates
+  );
+  validateConfig(merged);
+  const configPath = path8.join(projectRoot, CONFIG_FILENAME);
+  const yamlContent = yaml5.stringify(merged, {
+    indent: 2,
+    lineWidth: 0
+  });
+  await fs2.writeFile(configPath, yamlContent, "utf8");
+  return merged;
+}
+async function addContext(projectRoot, contextName) {
+  const config = await readConfig(projectRoot);
+  if (config.contexts.includes(contextName)) {
+    throw new Error(`Contexto "${contextName}" j\xE1 existe na configura\xE7\xE3o`);
+  }
+  return await updateConfig(projectRoot, {
+    contexts: [...config.contexts, contextName]
+  });
+}
+async function addIDE(projectRoot, ideName) {
+  const config = await readConfig(projectRoot);
+  if (config.ides.includes(ideName)) {
+    throw new Error(`IDE "${ideName}" j\xE1 existe na configura\xE7\xE3o`);
+  }
+  return await updateConfig(projectRoot, {
+    ides: [...config.ides, ideName]
+  });
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      const targetValue = result[key];
+      const sourceValue = source[key];
+      if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+        result[key] = [.../* @__PURE__ */ new Set([...targetValue, ...sourceValue])];
+      } else if (typeof targetValue === "object" && targetValue !== null && typeof sourceValue === "object" && sourceValue !== null && !Array.isArray(targetValue) && !Array.isArray(sourceValue)) {
+        result[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+  }
+  return result;
+}
+function createDefaultConfig(options = {}) {
+  return {
+    version: options.version || "4.0.0",
+    contexts: options.contexts || [],
+    ides: options.ides || ["cursor"],
+    integrations: options.integrations || {},
+    created: options.created || (/* @__PURE__ */ new Date()).toISOString(),
+    ...options
+  };
+}
+var CONFIG_FILENAME;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    init_validator();
+    CONFIG_FILENAME = ".onion-config.yml";
+  }
+});
+async function init(options = {}) {
+  try {
+    const projectRoot = process.cwd();
+    console.log("");
+    console.log(chalk.magenta.bold("\u{1F9C5} Initializing Onion System v4..."));
+    console.log("");
+    if (fs2.existsSync(path8.join(projectRoot, ".onion"))) {
+      console.log(chalk.yellow("\u26A0\uFE0F  .onion/ already exists!"));
+      console.log(chalk.gray('Use "onion migrate" to upgrade from v3'));
+      process.exit(1);
+    }
+    const onionRoot = path8.resolve(import.meta.dirname, "../../../..");
+    const sourceOnion = path8.join(onionRoot, ".onion");
+    if (!fs2.existsSync(sourceOnion)) {
+      console.log(chalk.red("\u274C Could not find Onion source structure"));
+      console.log(chalk.gray(`Expected: ${sourceOnion}`));
+      process.exit(1);
+    }
+    console.log(chalk.cyan("\u{1F4C1} Creating .onion/ structure..."));
+    fs2.copySync(sourceOnion, path8.join(projectRoot, ".onion"), {
+      dereference: true
+      // Resolve symlinks
+    });
+    console.log(chalk.green("\u2713 Created .onion/"));
+    console.log(chalk.cyan("\u{1F3AF} Setting up Cursor IDE integration..."));
+    const cursorDir = path8.join(projectRoot, ".cursor");
+    fs2.ensureDirSync(cursorDir);
+    const sourceCursorCommands = path8.join(onionRoot, ".cursor/commands");
+    if (fs2.existsSync(sourceCursorCommands)) {
+      fs2.copySync(sourceCursorCommands, path8.join(cursorDir, "commands"), {
+        dereference: true
+      });
+    }
+    const sourceCursorAgents = path8.join(onionRoot, ".cursor/agents");
+    if (fs2.existsSync(sourceCursorAgents)) {
+      fs2.copySync(sourceCursorAgents, path8.join(cursorDir, "agents"), {
+        dereference: true
+      });
+    }
+    const sourceCursorRules = path8.join(onionRoot, ".cursor/rules");
+    if (fs2.existsSync(sourceCursorRules)) {
+      fs2.copySync(sourceCursorRules, path8.join(cursorDir, "rules"), {
+        dereference: true
+      });
+    }
+    console.log(chalk.green("\u2713 Created .cursor/"));
+    console.log(chalk.cyan("\u2699\uFE0F  Creating configuration..."));
+    const config = `# Onion System v4 Configuration
+version: 4.0.0
+created: ${(/* @__PURE__ */ new Date()).toISOString()}
+project_type: monorepo
+
+contexts:
+  - name: business
+    enabled: true
+    description: Product specs, features, tasks
+  - name: technical
+    enabled: true
+    description: Development, architecture, PRs
+
+ides:
+  - name: cursor
+    enabled: true
+    path: .cursor/
+
+integrations:
+  task_manager:
+    provider: none
+  transcription:
+    provider: none
+`;
+    fs2.writeFileSync(path8.join(projectRoot, ".onion-config.yml"), config, "utf8");
+    console.log(chalk.green("\u2713 Created .onion-config.yml"));
+    const readme = `# \u{1F9C5} Onion System v4
+
+This project uses Onion System v4 for development.
+
+## Quick Start
+
+### Available Commands
+
+**Business Context:**
+\`\`\`
+/business/help      # Show all business commands
+/business/spec      # Create product spec
+/business/task      # Create task
+/business/estimate  # Estimate story points
+\`\`\`
+
+**Technical Context:**
+\`\`\`
+/technical/help     # Show all technical commands
+/technical/plan     # Plan development
+/technical/work     # Start working on task
+/technical/pr       # Create pull request
+\`\`\`
+
+**Global:**
+\`\`\`
+/help               # Show global help
+\`\`\`
+
+## Documentation
+
+- Full docs: https://github.com/your-org/onion-v4
+- Configuration: .onion-config.yml
+- Structure: .onion/
+
+## Learn More
+
+- [Installation Guide](https://github.com/your-org/onion-v4/docs/onion/INSTALLATION.md)
+- [Release Notes](https://github.com/your-org/onion-v4/docs/onion/RELEASE-NOTES-v4.0-beta.md)
+`;
+    fs2.writeFileSync(path8.join(projectRoot, ".onion", "README.md"), readme, "utf8");
+    console.log("");
+    console.log(chalk.green.bold("\u2705 Onion System initialized successfully!"));
+    console.log("");
+    console.log(chalk.cyan("\u{1F4DA} Next steps:"));
+    console.log("");
+    console.log("  1. Restart Cursor IDE");
+    console.log("  2. Try a command:");
+    console.log(chalk.yellow("     /business/help"));
+    console.log(chalk.yellow("     /technical/help"));
+    console.log("  3. Start developing:");
+    console.log(chalk.yellow('     /business/spec "my-feature"'));
+    console.log(chalk.yellow("     /technical/work"));
+    console.log("");
+    console.log(chalk.gray("Need help? Run: /help"));
+    console.log("");
+  } catch (error) {
+    console.log("");
+    console.log(chalk.red.bold("\u274C Initialization failed:"));
+    console.log(chalk.red(error instanceof Error ? error.message : String(error)));
+    console.log("");
+    if (options.debug) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+var Logger = class {
+  spinner = null;
+  // Títulos
+  title(text) {
+    console.log("\n" + chalk.cyan.bold("\u2501".repeat(60)));
+    console.log(chalk.cyan.bold(`  ${text}`));
+    console.log(chalk.cyan.bold("\u2501".repeat(60)));
+  }
+  // Seções
+  section(text) {
+    console.log("\n" + chalk.white.bold(text));
+  }
+  // Sucesso
+  success(text) {
+    console.log(chalk.green("\u2705 ") + text);
+  }
+  // Info
+  info(text) {
+    console.log(chalk.blue("\u2139\uFE0F  ") + text);
+  }
+  // Warning
+  warn(text) {
+    console.log(chalk.yellow("\u26A0\uFE0F  ") + text);
+  }
+  // Erro
+  error(text) {
+    console.log(chalk.red("\u274C ") + text);
+  }
+  // Spinner
+  startSpinner(text) {
+    this.spinner = ora(text).start();
+  }
+  stopSpinner(success = true, text = null) {
+    if (!this.spinner) return;
+    if (success) {
+      this.spinner.succeed(text ?? void 0);
+    } else {
+      this.spinner.fail(text ?? void 0);
+    }
+    this.spinner = null;
+  }
+  // Lista
+  list(items, prefix = "  \u221F") {
+    items.forEach((item) => {
+      console.log(chalk.gray(prefix) + " " + item);
+    });
+  }
+  // Quebra
+  break() {
+    console.log();
+  }
+};
+var logger = new Logger();
+async function detectOnionV4Structure(projectRoot) {
+  try {
+    const onionDir = path8.join(projectRoot, ".onion");
+    const configFile = path8.join(projectRoot, ".onion-config.yml");
+    if (!await fs2.pathExists(onionDir)) {
+      return null;
+    }
+    if (!await fs2.pathExists(configFile)) {
+      return null;
+    }
+    const contextsDir = path8.join(onionDir, "contexts");
+    if (!await fs2.pathExists(contextsDir)) {
+      return null;
+    }
+    const structure = {
+      version: "v4",
+      root: projectRoot,
+      onionDir,
+      configFile,
+      contextsDir,
+      coreDir: path8.join(onionDir, "core"),
+      ideDir: path8.join(onionDir, "ide"),
+      contexts: [],
+      ides: []
+    };
+    try {
+      const contextDirs = await fs2.readdir(contextsDir);
+      const validContexts = [];
+      for (const name of contextDirs) {
+        const stat = await fs2.stat(path8.join(contextsDir, name));
+        if (stat.isDirectory()) {
+          validContexts.push(name);
+        }
+      }
+      structure.contexts = validContexts;
+    } catch {
+      structure.contexts = [];
+    }
+    const ideDir = path8.join(onionDir, "ide");
+    if (await fs2.pathExists(ideDir)) {
+      try {
+        const ideDirs = await fs2.readdir(ideDir);
+        const validIdes = [];
+        for (const name of ideDirs) {
+          const stat = await fs2.stat(path8.join(ideDir, name));
+          if (stat.isDirectory()) {
+            validIdes.push(name);
+          }
+        }
+        structure.ides = validIdes;
+      } catch {
+        structure.ides = [];
+      }
+    }
+    return structure;
+  } catch {
+    return null;
+  }
+}
+async function detectOnionV3Structure(projectRoot) {
+  try {
+    const cursorDir = path8.join(projectRoot, ".cursor");
+    const commandsDir = path8.join(cursorDir, "commands");
+    const agentsDir = path8.join(cursorDir, "agents");
+    if (!await fs2.pathExists(cursorDir)) {
+      return null;
+    }
+    const hasCommands = await fs2.pathExists(commandsDir);
+    const hasAgents = await fs2.pathExists(agentsDir);
+    if (!hasCommands && !hasAgents) {
+      return null;
+    }
+    const onionDir = path8.join(projectRoot, ".onion");
+    if (await fs2.pathExists(onionDir)) {
+      return null;
+    }
+    const structure = {
+      version: "v3",
+      root: projectRoot,
+      cursorDir,
+      commandsDir,
+      agentsDir,
+      commands: {},
+      agents: {},
+      hasRules: false,
+      hasSessions: false
+    };
+    if (hasCommands) {
+      try {
+        const categories = await fs2.readdir(commandsDir);
+        for (const category of categories) {
+          const categoryPath = path8.join(commandsDir, category);
+          const stat = await fs2.stat(categoryPath);
+          if (stat.isDirectory()) {
+            const files = await fs2.readdir(categoryPath);
+            structure.commands[category] = files.filter((f) => f.endsWith(".md"));
+          }
+        }
+      } catch {
+        structure.commands = {};
+      }
+    }
+    if (hasAgents) {
+      try {
+        const categories = await fs2.readdir(agentsDir);
+        for (const category of categories) {
+          const categoryPath = path8.join(agentsDir, category);
+          const stat = await fs2.stat(categoryPath);
+          if (stat.isDirectory()) {
+            const files = await fs2.readdir(categoryPath);
+            structure.agents[category] = files.filter((f) => f.endsWith(".md"));
+          }
+        }
+      } catch {
+        structure.agents = {};
+      }
+    }
+    const rulesDir = path8.join(cursorDir, "rules");
+    structure.hasRules = await fs2.pathExists(rulesDir);
+    const sessionsDir = path8.join(cursorDir, "sessions");
+    structure.hasSessions = await fs2.pathExists(sessionsDir);
+    return structure;
+  } catch {
+    return null;
+  }
+}
+function validateMigrationEligibility(v3Structure) {
+  const issues = [];
+  if (!v3Structure || v3Structure.version !== "v3") {
+    return { canMigrate: false, issues: ["N\xE3o \xE9 um projeto Onion v3"] };
+  }
+  if (v3Structure.root) {
+    const onionPath = path8.join(v3Structure.root, ".onion");
+    if (fs2.existsSync(onionPath)) {
+      issues.push("Projeto j\xE1 tem estrutura .onion/ (poss\xEDvel v4)");
+    }
+  }
+  const hasCommands = Object.keys(v3Structure.commands || {}).length > 0;
+  const hasAgents = Object.keys(v3Structure.agents || {}).length > 0;
+  if (!hasCommands && !hasAgents) {
+    issues.push("Projeto n\xE3o tem comandos nem agentes para migrar");
+  }
+  const canMigrate = issues.length === 0;
+  return { canMigrate, issues };
+}
+
+// src/commands/add.ts
+init_config();
+init_validator();
+async function generateCoreStructure(projectRoot) {
+  const onionRoot = path8.join(projectRoot, ".onion");
+  const corePaths = [
+    "core/knowbase/concepts",
+    "core/knowbase/frameworks",
+    "core/knowbase/tools",
+    "core/knowbase/learnings",
+    "core/agents",
+    "core/commands",
+    "core/rules",
+    "core/utils"
+  ];
+  for (const p of corePaths) {
+    await fs2.ensureDir(path8.join(onionRoot, p));
+  }
+}
+async function generateContextStructure(projectRoot, contextName, options = {}) {
+  const onionRoot = path8.join(projectRoot, ".onion");
+  const contextRoot = path8.join(onionRoot, "contexts", contextName);
+  const basePaths = [
+    "knowbase",
+    "agents",
+    "commands/starter",
+    "commands/intermediate",
+    "commands/advanced",
+    "sessions"
+  ];
+  for (const p of basePaths) {
+    await fs2.ensureDir(path8.join(contextRoot, p));
+  }
+  if (options.includeREADME !== false) {
+    await generateContextREADME(projectRoot, contextName);
+  }
+  if (options.includeConfig !== false) {
+    await generateContextConfig(projectRoot, contextName, { type: options.type });
+  }
+}
+async function generateContextREADME(projectRoot, contextName) {
+  const readmePath = path8.join(projectRoot, ".onion/contexts", contextName, "README.md");
+  const content = `# ${capitalizeFirst(contextName)} Context
+
+> **Onion v4.0** | Multi-Context Development Orchestrator
+
+---
+
+## \u{1F3AF} Sobre Este Contexto
+
+O contexto **${contextName}** \xE9 dedicado a [descrever prop\xF3sito].
+
+## \u{1F680} Quick Start
+
+### Comandos Starter (80% dos casos)
+
+\`\`\`bash
+/${contextName}/[comando-starter]
+\`\`\`
+
+### Ver todos os comandos
+
+\`\`\`bash
+/${contextName}/help
+\`\`\`
+
+---
+
+**Vers\xE3o**: 4.0.0  
+**Criado**: ${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}
+`;
+  await fs2.writeFile(readmePath, content, "utf-8");
+}
+async function generateContextConfig(projectRoot, contextName, config = {}) {
+  const configPath = path8.join(
+    projectRoot,
+    ".onion/contexts",
+    contextName,
+    ".context-config.yml"
+  );
+  const defaultConfig = {
+    context: {
+      name: contextName,
+      version: "4.0.0",
+      type: config.type || "custom"
+    },
+    integrations: config.integrations || {}
+  };
+  await fs2.writeFile(configPath, yaml5.stringify(defaultConfig), "utf-8");
+}
+async function generateStarterCommands(projectRoot, contextName, contextType) {
+  const starterPath = path8.join(
+    projectRoot,
+    ".onion/contexts",
+    contextName,
+    "commands/starter"
+  );
+  const starterCommands = [
+    {
+      name: "help",
+      description: `Show ${contextName} context help`,
+      content: generateHelpCommandContent(contextName, contextType)
+    },
+    {
+      name: "warm-up",
+      description: `Warm up ${contextName} context`,
+      content: generateWarmUpCommandContent(contextName)
+    }
+  ];
+  if (contextType === "business") {
+    starterCommands.push(
+      {
+        name: "spec",
+        description: "Create product specification",
+        content: generateBusinessSpecContent()
+      },
+      {
+        name: "task",
+        description: "Create task with story points",
+        content: generateBusinessTaskContent()
+      }
+    );
+  } else if (contextType === "technical") {
+    starterCommands.push(
+      {
+        name: "plan",
+        description: "Create development plan",
+        content: generateTechnicalPlanContent()
+      },
+      {
+        name: "work",
+        description: "Continue work on feature",
+        content: generateTechnicalWorkContent()
+      }
+    );
+  }
+  for (const cmd of starterCommands) {
+    const filePath = path8.join(starterPath, `${cmd.name}.md`);
+    await fs2.writeFile(filePath, cmd.content, "utf-8");
+  }
+}
+async function generateIDELoader(projectRoot, ideName, config = {}) {
+  const loaderPath = path8.join(projectRoot, ".onion/ide", ideName);
+  await fs2.ensureDir(loaderPath);
+  {
+    await generateCursorLoader(projectRoot, config);
+  }
+}
+async function generateDocsStructure(projectRoot, contexts = []) {
+  await fs2.ensureDir(path8.join(projectRoot, "docs/onion"));
+  for (const ctx of contexts) {
+    await fs2.ensureDir(path8.join(projectRoot, `docs/${ctx}-context`));
+  }
+}
+function capitalizeFirst(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function generateHelpCommandContent(contextName, contextType) {
+  return `---
+name: help
+description: Show ${contextName} context commands by level
+model: sonnet
+category: ${contextType}
+tags: [help, onboarding]
+version: "4.0.0"
+updated: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"
+level: starter
+context: ${contextName}
+---
+
+# ${capitalizeFirst(contextName)} Context Help
+
+List all commands in ${contextName} context organized by level.
+
+Run: \`/${contextName}/help\` or \`/${contextName}/help --level=starter\`
+`;
+}
+function generateWarmUpCommandContent(contextName) {
+  return `---
+name: warm-up
+description: Warm up ${contextName} context with project information
+model: sonnet
+category: ${contextName}
+tags: [context, warm-up]
+version: "4.0.0"
+updated: "${(/* @__PURE__ */ new Date()).toISOString().split("T")[0]}"
+level: starter
+context: ${contextName}
+---
+
+# Warm Up ${capitalizeFirst(contextName)} Context
+
+Load project context and recent activity.
+`;
+}
+function generateBusinessSpecContent() {
+  return `---
+name: spec
+description: Create product specification
+model: sonnet
+category: business
+tags: [specification, product]
+version: "4.0.0"
+level: starter
+context: business
+---
+
+# Create Product Specification
+
+Create detailed product specification for a feature.
+`;
+}
+function generateBusinessTaskContent() {
+  return `---
+name: task
+description: Create task with story points
+model: sonnet
+category: business
+tags: [task, story-points]
+version: "4.0.0"
+level: starter
+context: business
+---
+
+# Create Task
+
+Create task in task manager with story points and acceptance criteria.
+`;
+}
+function generateTechnicalPlanContent() {
+  return `---
+name: plan
+description: Create development plan
+model: sonnet
+category: technical
+tags: [planning, development]
+version: "4.0.0"
+level: starter
+context: technical
+---
+
+# Create Development Plan
+
+Create structured development plan with phases and tasks.
+`;
+}
+function generateTechnicalWorkContent() {
+  return `---
+name: work
+description: Continue work on active feature
+model: sonnet
+category: technical
+tags: [development, workflow]
+version: "4.0.0"
+level: starter
+context: technical
+---
+
+# Continue Work
+
+Continue development on active feature, reading session and identifying next phase.
+`;
+}
+async function generateCursorLoader(projectRoot, config) {
+  const cursorRoot = path8.join(projectRoot, ".cursor");
+  await fs2.ensureDir(cursorRoot);
+  for (const ctx of config.contexts || []) {
+    await fs2.ensureDir(path8.join(cursorRoot, "commands", ctx));
+    await fs2.ensureDir(path8.join(cursorRoot, "agents", ctx));
+  }
+}
+var LoadersGenerator = class {
+  projectRoot;
+  config;
+  constructor(projectRoot, config) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+  }
+  async generate() {
+    for (const ide of this.config.ides) {
+      if (ide === "universal") {
+        await this.generateUniversalAgentsMd();
+      } else {
+        await this.generateIDELoader(ide);
+        await this.createIDERootStructure(ide);
+      }
+    }
+  }
+  async generateIDELoader(ide) {
+    logger.startSpinner(`Generating ${ide} loader...`);
+    const loaderPath = path8.join(this.projectRoot, ".onion", "ide", ide);
+    await fs2.ensureDir(loaderPath);
+    if (ide === "cursor") {
+      await this.generateCursorLoader(loaderPath);
+    } else if (ide === "windsurf") {
+      await this.generateWindsurfLoader(loaderPath);
+    } else if (ide === "claude-code" || ide === "claude") {
+      await this.generateClaudeLoader(loaderPath);
+    }
+    logger.stopSpinner(true, `Created ${ide} loader`);
+  }
+  async generateCursorLoader(loaderPath) {
+    const settings = {
+      onion: {
+        enabled: true,
+        root: ".onion",
+        loader: ".onion/ide/cursor/onion-loader.js",
+        version: "4.0.0-beta.1"
+      }
+    };
+    await fs2.writeJson(path8.join(loaderPath, "settings.json"), settings, { spaces: 2 });
+    const readme = `# Cursor IDE Loader
+
+This loader syncs Onion resources to Cursor IDE.
+
+## Usage
+
+The loader automatically syncs commands and agents from \`.onion/\` to \`.cursor/\`.
+
+## Manual Sync
+
+Run: \`node .onion/ide/cursor/onion-loader.js\`
+`;
+    await fs2.writeFile(path8.join(loaderPath, "README.md"), readme, "utf-8");
+  }
+  async generateWindsurfLoader(loaderPath) {
+    const windsurfConfig = {
+      onion: {
+        version: "4.0.0-beta.1",
+        generated: (/* @__PURE__ */ new Date()).toISOString(),
+        contexts: this.config.contexts
+      }
+    };
+    const configPath = path8.join(this.projectRoot, "windsurf.config.yml");
+    await fs2.writeFile(configPath, yaml5.stringify(windsurfConfig), "utf-8");
+    const readme = `# Windsurf IDE Integration
+
+This loader generates windsurf.config.yml for Windsurf IDE.
+
+## Files
+
+- \`windsurf.config.yml\` - Configuration file (in project root)
+
+## Usage
+
+The config is auto-generated during \`onion init\` or \`onion add windsurf\`.
+`;
+    await fs2.writeFile(path8.join(loaderPath, "README.md"), readme, "utf-8");
+  }
+  async generateClaudeLoader(loaderPath) {
+    const claudeConfig = {
+      onion: {
+        version: "4.0.0-beta.1",
+        generated: (/* @__PURE__ */ new Date()).toISOString(),
+        contexts: this.config.contexts
+      }
+    };
+    const configPath = path8.join(this.projectRoot, "claude.config.json");
+    await fs2.writeJson(configPath, claudeConfig, { spaces: 2 });
+    const readme = `# Claude Code IDE Integration
+
+This loader generates claude.config.json for Claude Code IDE.
+
+## Files
+
+- \`claude.config.json\` - Configuration file (in project root)
+
+## Usage
+
+The config is auto-generated during \`onion init\` or \`onion add claude-code\`.
+`;
+    await fs2.writeFile(path8.join(loaderPath, "README.md"), readme, "utf-8");
+  }
+  async generateUniversalAgentsMd() {
+    logger.startSpinner("Generating universal AGENTS.md...");
+    const agentsMdContent = `# Sistema Onion - Universal Agents
+
+Este arquivo serve como fallback para IDEs que n\xE3o possuem suporte nativo ao Sistema Onion.
+
+## Comandos Dispon\xEDveis
+
+### Core Commands
+- \`/onion\` - Orquestrador principal
+- \`/warm-up\` - Preparar contexto
+
+${this.config.contexts.map(
+      (ctx) => `
+### ${ctx.charAt(0).toUpperCase() + ctx.slice(1)} Context
+- \`/${ctx}/spec\` - Criar especifica\xE7\xE3o
+- \`/${ctx}/help\` - Ajuda do contexto
+`
+    ).join("")}
+
+## Como Usar
+
+Mencione os comandos acima no chat do seu IDE.
+
+## Configura\xE7\xE3o
+
+Este projeto usa Sistema Onion v4.0. Para melhor experi\xEAncia, use:
+- Cursor IDE
+- Windsurf
+- Claude Code
+
+Ou acesse a documenta\xE7\xE3o em \`.onion/README.md\`
+`;
+    const universalPath = path8.join(this.projectRoot, ".onion", "ide", "universal");
+    await fs2.ensureDir(universalPath);
+    await fs2.writeFile(path8.join(universalPath, "AGENTS.md"), agentsMdContent, "utf-8");
+    logger.stopSpinner(true, "Created universal AGENTS.md");
+  }
+  // Criar estrutura na raiz do projeto para o IDE reconhecer
+  async createIDERootStructure(ide) {
+    if (ide === "cursor") {
+      await this.createCursorRootStructure();
+    }
+  }
+  async createCursorRootStructure() {
+    logger.startSpinner("Creating .cursor/ structure...");
+    const cursorRoot = path8.join(this.projectRoot, ".cursor");
+    await fs2.ensureDir(cursorRoot);
+    const commandsPath = path8.join(cursorRoot, "commands");
+    const agentsPath = path8.join(cursorRoot, "agents");
+    await fs2.ensureDir(commandsPath);
+    await fs2.ensureDir(agentsPath);
+    for (const context of this.config.contexts) {
+      await fs2.ensureDir(path8.join(commandsPath, context));
+      await fs2.ensureDir(path8.join(agentsPath, context));
+      await this.createStarterCommands(context, path8.join(commandsPath, context));
+    }
+    const cursorRulesContent = `# Sistema Onion v4.0
+
+Este projeto usa o Sistema Onion - Multi-Context Development Orchestrator.
+
+## Estrutura
+
+- **Comandos**: .cursor/commands/
+- **Agentes**: .cursor/agents/
+- **Fonte**: .onion/
+
+## Contextos Dispon\xEDveis
+
+${this.config.contexts.map((ctx) => `- **${ctx}**: /${ctx}/*`).join("\n")}
+
+## Documenta\xE7\xE3o
+
+Consulte \`.onion/README.md\` para mais informa\xE7\xF5es.
+
+---
+
+**Gerado por**: @onion/cli v4.0.0
+`;
+    await fs2.writeFile(path8.join(cursorRoot, ".cursorrules"), cursorRulesContent, "utf-8");
+    logger.stopSpinner(true, "Created .cursor/ structure");
+  }
+  async createStarterCommands(context, commandsPath) {
+    const helpContent = `---
+name: help
+description: Ajuda do contexto ${context}
+category: ${context}
+version: "4.0.0"
+---
+
+# \u{1F4DA} ${context.charAt(0).toUpperCase() + context.slice(1)} Context - Help
+
+Comandos dispon\xEDveis neste contexto.
+
+## \u{1F7E2} Starter Commands (essenciais)
+
+- \`/${context}/help\` - Esta ajuda
+
+## \u{1F4D6} Documenta\xE7\xE3o
+
+Veja documenta\xE7\xE3o completa em \`docs/${context}-context/\`
+
+---
+
+**Fonte**: .onion/contexts/${context}/commands/starter/help.md  
+**Auto-gerado por**: @onion/cli
+`;
+    await fs2.writeFile(path8.join(commandsPath, "help.md"), helpContent, "utf-8");
+  }
+};
+
+// src/commands/add.ts
+async function add(options = {}) {
+  try {
+    const projectRoot = process.cwd();
+    const project = await detectOnionV4Structure(projectRoot);
+    if (!project) {
+      logger.error("\u274C This is not an Onion v4 project");
+      logger.info('Run "onion init" first to initialize the system');
+      process.exit(1);
+    }
+    logger.title("\u{1F9C5} Add to Onion System");
+    logger.break();
+    const { type } = await inquirer.prompt([
+      {
+        type: "list",
+        name: "type",
+        message: "What would you like to add?",
+        choices: [
+          { name: "\u{1F4E6} New Context", value: "context" },
+          { name: "\u{1F4BB} New IDE Integration", value: "ide" },
+          { name: "\u274C Cancel", value: "cancel" }
+        ]
+      }
+    ]);
+    if (type === "cancel") {
+      logger.info("Cancelled");
+      return;
+    }
+    if (type === "context") {
+      await addContext2(project);
+    } else if (type === "ide") {
+      await addIDE2(project);
+    }
+  } catch (error) {
+    logger.break();
+    logger.error("\u274C Add command failed:");
+    logger.error(error.message);
+    if (options.debug) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+async function addContext2(project) {
+  const { contextName } = await inquirer.prompt([
+    {
+      type: "input",
+      name: "contextName",
+      message: 'Context name (lowercase, e.g., "customer-success"):',
+      validate: (input) => {
+        try {
+          validateContextName(input);
+          return true;
+        } catch (err) {
+          return err.message;
+        }
+      }
+    }
+  ]);
+  const config = await readConfig(project.root);
+  if (config.contexts.includes(contextName)) {
+    logger.error(`\u274C Context "${contextName}" already exists`);
+    process.exit(1);
+  }
+  const { contextType } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "contextType",
+      message: "Context type:",
+      choices: [
+        { name: "\u{1F4CA} Business/Product", value: "business" },
+        { name: "\u2699\uFE0F  Technical/Engineering", value: "technical" },
+        { name: "\u{1F3A8} Custom", value: "custom" }
+      ]
+    }
+  ]);
+  logger.break();
+  logger.startSpinner(`Creating context "${contextName}"...`);
+  try {
+    await generateContextStructure(project.root, contextName, {
+      includeREADME: true,
+      includeConfig: true
+    });
+    await generateStarterCommands(project.root, contextName, contextType);
+    await addContext(project.root, contextName);
+    for (const ide of config.ides) {
+      const loaderConfig = {
+        contexts: config.contexts,
+        ides: [ide]
+      };
+      const loadersGen = new LoadersGenerator(project.root, loaderConfig);
+      await loadersGen.generateIDELoader(ide);
+      if (ide === "cursor") {
+        try {
+          const loaderPath = path8.join(project.root, ".onion/ide/cursor/onion-loader.js");
+          if (fs2.existsSync(loaderPath)) {
+            const loaderModule = await import(loaderPath);
+            const loader = loaderModule.getLoader(project.root);
+            loader.syncToCursor();
+          }
+        } catch {
+        }
+      }
+    }
+    logger.stopSpinner(true, `Context "${contextName}" created successfully`);
+    logger.break();
+    logger.success("Next steps:");
+    logger.info(`  1. Explore: /${contextName}/help`);
+    logger.info(`  2. Add commands: .onion/contexts/${contextName}/commands/`);
+    logger.info(`  3. Add agents: .onion/contexts/${contextName}/agents/`);
+    logger.break();
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to create context");
+    throw error;
+  }
+}
+async function addIDE2(project) {
+  const config = await readConfig(project.root);
+  const availableIDEs = ["cursor", "windsurf", "claude"];
+  const notConfigured = availableIDEs.filter((ide) => !config.ides.includes(ide));
+  if (notConfigured.length === 0) {
+    logger.warn("\u26A0\uFE0F  All supported IDEs are already configured");
+    logger.info("Configured IDEs: " + config.ides.join(", "));
+    return;
+  }
+  const { ideName } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "ideName",
+      message: "Which IDE would you like to add?",
+      choices: notConfigured.map((ide) => ({
+        name: capitalizeFirst2(ide),
+        value: ide
+      }))
+    }
+  ]);
+  logger.break();
+  logger.startSpinner(`Configuring ${ideName}...`);
+  try {
+    const loaderConfig = {
+      contexts: config.contexts,
+      ides: [ideName]
+    };
+    const loadersGen = new LoadersGenerator(project.root, loaderConfig);
+    await loadersGen.generateIDELoader(ideName);
+    await addIDE(project.root, ideName);
+    if (ideName === "cursor") {
+      try {
+        const loaderPath = path8.join(project.root, ".onion/ide/cursor/onion-loader.js");
+        if (fs2.existsSync(loaderPath)) {
+          const loaderModule = await import(loaderPath);
+          const loader = loaderModule.getLoader(project.root);
+          const result = loader.syncToCursor();
+          logger.info(`   Synced ${result.commandsSynced} commands and ${result.agentsSynced} agents`);
+        }
+      } catch (err) {
+        logger.warn(`   Could not sync: ${err.message}`);
+      }
+    }
+    logger.stopSpinner(true, `IDE "${ideName}" configured successfully`);
+    logger.break();
+    logger.success("Next steps:");
+    if (ideName === "cursor") {
+      logger.info("  1. Restart Cursor to load commands");
+      logger.info("  2. Test: Run any command like /business/help");
+    } else if (ideName === "windsurf") {
+      logger.info("  1. Restart Windsurf");
+      logger.info("  2. Commands will be available via Windsurf interface");
+    } else if (ideName === "claude") {
+      logger.info("  1. Restart Claude Code");
+      logger.info("  2. Commands available via @onion agent");
+    }
+    logger.break();
+  } catch (error) {
+    logger.stopSpinner(false, "Failed to configure IDE");
+    throw error;
+  }
+}
+function capitalizeFirst2(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+init_config();
+async function detectV3Commands(projectRoot) {
+  const v3 = await detectOnionV3Structure(projectRoot);
+  if (!v3) {
+    return [];
+  }
+  const commands = [];
+  for (const [category, files] of Object.entries(v3.commands)) {
+    const categoryPath = path8.join(v3.commandsDir, category);
+    for (const file of files) {
+      const filePath = path8.join(categoryPath, file);
+      const metadata = await extractCommandMetadata(filePath);
+      commands.push({
+        name: path8.basename(file, ".md"),
+        category,
+        path: filePath,
+        relativePath: path8.relative(projectRoot, filePath),
+        metadata
+      });
+    }
+  }
+  return commands;
+}
+async function detectV3Agents(projectRoot) {
+  const v3 = await detectOnionV3Structure(projectRoot);
+  if (!v3) {
+    return [];
+  }
+  const agents = [];
+  for (const [category, files] of Object.entries(v3.agents)) {
+    const categoryPath = path8.join(v3.agentsDir, category);
+    for (const file of files) {
+      const filePath = path8.join(categoryPath, file);
+      const metadata = await extractAgentMetadata(filePath);
+      agents.push({
+        name: path8.basename(file, ".md"),
+        category,
+        path: filePath,
+        relativePath: path8.relative(projectRoot, filePath),
+        metadata
+      });
+    }
+  }
+  return agents;
+}
+async function detectV3CustomFiles(projectRoot) {
+  const custom = [];
+  const cursorDir = path8.join(projectRoot, ".cursor");
+  if (!await fs2.pathExists(cursorDir)) {
+    return custom;
+  }
+  const subdirs = ["commands", "agents", "rules", "utils"];
+  for (const subdir of subdirs) {
+    const dirPath = path8.join(cursorDir, subdir);
+    if (await fs2.pathExists(dirPath)) {
+      const files = await findCustomFiles(dirPath, projectRoot);
+      custom.push(...files);
+    }
+  }
+  return custom;
+}
+async function analyzeV3Structure(projectRoot) {
+  const commands = await detectV3Commands(projectRoot);
+  const agents = await detectV3Agents(projectRoot);
+  const customFiles = await detectV3CustomFiles(projectRoot);
+  const v3 = await detectOnionV3Structure(projectRoot);
+  const stats = {
+    totalCommands: commands.length,
+    totalAgents: agents.length,
+    totalCustomFiles: customFiles.length,
+    commandsByCategory: {},
+    agentsByCategory: {},
+    hasRules: v3?.hasRules || false,
+    hasSessions: v3?.hasSessions || false
+  };
+  for (const cmd of commands) {
+    stats.commandsByCategory[cmd.category] = (stats.commandsByCategory[cmd.category] || 0) + 1;
+  }
+  for (const agent of agents) {
+    stats.agentsByCategory[agent.category] = (stats.agentsByCategory[agent.category] || 0) + 1;
+  }
+  return {
+    commands,
+    agents,
+    customFiles,
+    stats,
+    v3Structure: v3
+  };
+}
+async function extractCommandMetadata(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!yamlMatch || !yamlMatch[1]) {
+      return { raw: true };
+    }
+    const metadata = yaml5.parse(yamlMatch[1]);
+    return {
+      ...metadata,
+      hasYAML: true,
+      contentLength: content.length,
+      linesCount: content.split("\n").length
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      raw: true
+    };
+  }
+}
+async function extractAgentMetadata(filePath) {
+  try {
+    const content = await fs2.readFile(filePath, "utf-8");
+    const yamlMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!yamlMatch || !yamlMatch[1]) {
+      return { raw: true };
+    }
+    const metadata = yaml5.parse(yamlMatch[1]);
+    return {
+      ...metadata,
+      hasYAML: true,
+      contentLength: content.length,
+      linesCount: content.split("\n").length
+    };
+  } catch (error) {
+    return {
+      error: error.message,
+      raw: true
+    };
+  }
+}
+async function findCustomFiles(dirPath, projectRoot) {
+  const custom = [];
+  try {
+    const entries = await fs2.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path8.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        const subFiles = await findCustomFiles(fullPath, projectRoot);
+        custom.push(...subFiles);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        const stats = await fs2.stat(fullPath);
+        const content = await fs2.readFile(fullPath, "utf-8");
+        if (content.length > 100) {
+          custom.push({
+            name: entry.name,
+            path: fullPath,
+            relativePath: path8.relative(projectRoot, fullPath),
+            size: stats.size,
+            modified: stats.mtime
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return custom;
+}
+
+// src/migrator/mapper.ts
+var CATEGORY_TO_CONTEXT = {
+  // Commands
+  product: "business",
+  business: "business",
+  engineer: "technical",
+  git: "technical",
+  docs: "technical",
+  test: "technical",
+  meta: "core",
+  validate: "core",
+  quick: "core",
+  global: "core",
+  // Agents
+  development: "technical",
+  compliance: "business",
+  review: "technical",
+  testing: "technical",
+  research: "business"
+};
+var KNOWN_STARTER_COMMANDS = [
+  "spec",
+  "task",
+  "estimate",
+  "refine",
+  "warm-up",
+  "work",
+  "plan",
+  "pr",
+  "docs",
+  "sync",
+  "init",
+  "help"
+];
+var KNOWN_ADVANCED_COMMANDS = [
+  "bump",
+  "hotfix",
+  "e2e",
+  "presentation",
+  "branding",
+  "analyze-pain-price",
+  "transform-consolidated",
+  "release-start",
+  "release-finish",
+  "feature-start",
+  "feature-finish"
+];
+function mapCommandToContext(command) {
+  const context = CATEGORY_TO_CONTEXT[command.category] || "custom";
+  const level = inferCommandLevel(command);
+  const newPath = `.onion/contexts/${context}/commands/${level}/${command.name}.md`;
+  return {
+    context,
+    level,
+    newPath,
+    oldPath: command.path,
+    name: command.name,
+    category: command.category
+  };
+}
+function mapAgentToContext(agent) {
+  const context = CATEGORY_TO_CONTEXT[agent.category] || "custom";
+  if (agent.name.includes("onion") || agent.name.includes("metaspec")) {
+    return {
+      context: "core",
+      newPath: `.onion/core/agents/${agent.name}.md`,
+      oldPath: agent.path,
+      name: agent.name,
+      category: agent.category
+    };
+  }
+  const newPath = `.onion/contexts/${context}/agents/${agent.name}.md`;
+  return {
+    context,
+    newPath,
+    oldPath: agent.path,
+    name: agent.name,
+    category: agent.category
+  };
+}
+function inferCommandLevel(command) {
+  const name = command.name.toLowerCase();
+  if (KNOWN_STARTER_COMMANDS.includes(name)) {
+    return "starter";
+  }
+  if (KNOWN_ADVANCED_COMMANDS.includes(name)) {
+    return "advanced";
+  }
+  if (command.metadata) {
+    if (command.metadata.level) {
+      return command.metadata.level;
+    }
+    const tags = command.metadata.tags || [];
+    const description = (command.metadata.description || "").toLowerCase();
+    if (tags.includes("starter") || tags.includes("basic") || name.includes("help") || name.includes("warm-up")) {
+      return "starter";
+    }
+    if (tags.includes("advanced") || tags.includes("release") || name.includes("release") || name.includes("hotfix") || description.includes("advanced") || description.includes("complex")) {
+      return "advanced";
+    }
+  }
+  return "intermediate";
+}
+function buildMigrationPlan(analysis) {
+  const contextsSet = /* @__PURE__ */ new Set();
+  const commands = [];
+  const agents = [];
+  const summary = {
+    totalCommands: analysis.commands.length,
+    totalAgents: analysis.agents.length,
+    commandsByContext: {},
+    agentsByContext: {},
+    commandsByLevel: {
+      starter: 0,
+      intermediate: 0,
+      advanced: 0
+    }
+  };
+  for (const command of analysis.commands) {
+    const mapping = mapCommandToContext(command);
+    commands.push(mapping);
+    contextsSet.add(mapping.context);
+    summary.commandsByContext[mapping.context] = (summary.commandsByContext[mapping.context] || 0) + 1;
+    const level = mapping.level;
+    if (level in summary.commandsByLevel) {
+      summary.commandsByLevel[level]++;
+    }
+  }
+  for (const agent of analysis.agents) {
+    const mapping = mapAgentToContext(agent);
+    agents.push(mapping);
+    contextsSet.add(mapping.context);
+    summary.agentsByContext[mapping.context] = (summary.agentsByContext[mapping.context] || 0) + 1;
+  }
+  return {
+    commands,
+    agents,
+    contexts: Array.from(contextsSet),
+    summary
+  };
+}
+function validateMigrationPlan(plan) {
+  const issues = [];
+  if (plan.contexts.length === 0) {
+    issues.push("Nenhum contexto identificado");
+  }
+  if (plan.commands.length === 0 && plan.agents.length === 0) {
+    issues.push("Nenhum comando ou agente para migrar");
+  }
+  const newPaths = /* @__PURE__ */ new Set();
+  for (const cmd of plan.commands) {
+    if (newPaths.has(cmd.newPath)) {
+      issues.push(`Path duplicado: ${cmd.newPath}`);
+    }
+    newPaths.add(cmd.newPath);
+  }
+  for (const agent of plan.agents) {
+    if (newPaths.has(agent.newPath)) {
+      issues.push(`Path duplicado: ${agent.newPath}`);
+    }
+    newPaths.add(agent.newPath);
+  }
+  return {
+    valid: issues.length === 0,
+    issues
+  };
+}
+function generateMigrationReport(plan) {
+  const lines = [];
+  lines.push("# Plano de Migra\xE7\xE3o Onion v3 \u2192 v4\n");
+  lines.push("## \u{1F4CA} Resumo\n");
+  lines.push(`- **Comandos**: ${plan.summary.totalCommands}`);
+  lines.push(`- **Agentes**: ${plan.summary.totalAgents}`);
+  lines.push(`- **Contextos**: ${plan.contexts.join(", ")}
+`);
+  lines.push("## \u{1F4E6} Comandos por Contexto\n");
+  for (const [context, count] of Object.entries(plan.summary.commandsByContext)) {
+    lines.push(`- **${context}**: ${count} comandos`);
+  }
+  lines.push("");
+  lines.push("## \u{1F4CA} Comandos por N\xEDvel\n");
+  lines.push(`- **Starter**: ${plan.summary.commandsByLevel.starter}`);
+  lines.push(`- **Intermediate**: ${plan.summary.commandsByLevel.intermediate}`);
+  lines.push(`- **Advanced**: ${plan.summary.commandsByLevel.advanced}
+`);
+  if (plan.summary.totalAgents > 0) {
+    lines.push("## \u{1F916} Agentes por Contexto\n");
+    for (const [context, count] of Object.entries(plan.summary.agentsByContext)) {
+      lines.push(`- **${context}**: ${count} agentes`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+async function transformCommandFile(sourceFilePath, targetFilePath, targetContext, targetLevel) {
+  const content = await fs2.readFile(sourceFilePath, "utf-8");
+  const yamlMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!yamlMatch || !yamlMatch[1] || yamlMatch[2] === void 0) {
+    const newContent2 = createCommandYAMLHeader(path8.basename(sourceFilePath, ".md"), targetContext, targetLevel) + "\n\n" + content;
+    await fs2.ensureDir(path8.dirname(targetFilePath));
+    await fs2.writeFile(targetFilePath, newContent2, "utf-8");
+    return;
+  }
+  const existingYAML = yaml5.parse(yamlMatch[1]);
+  const body = yamlMatch[2];
+  const updatedYAML = {
+    ...existingYAML,
+    context: targetContext,
+    level: targetLevel,
+    version: existingYAML.version || "4.0.0",
+    updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  };
+  const newContent = "---\n" + yaml5.stringify(updatedYAML) + "---\n" + body;
+  await fs2.ensureDir(path8.dirname(targetFilePath));
+  await fs2.writeFile(targetFilePath, newContent, "utf-8");
+}
+async function transformAgentFile(sourceFilePath, targetFilePath, targetContext) {
+  const content = await fs2.readFile(sourceFilePath, "utf-8");
+  const yamlMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!yamlMatch || !yamlMatch[1] || yamlMatch[2] === void 0) {
+    const newContent2 = createAgentYAMLHeader(path8.basename(sourceFilePath, ".md"), targetContext) + "\n\n" + content;
+    await fs2.ensureDir(path8.dirname(targetFilePath));
+    await fs2.writeFile(targetFilePath, newContent2, "utf-8");
+    return;
+  }
+  const existingYAML = yaml5.parse(yamlMatch[1]);
+  const body = yamlMatch[2];
+  const updatedYAML = {
+    ...existingYAML,
+    context: targetContext,
+    version: existingYAML.version || "4.0.0",
+    updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+  };
+  const newContent = "---\n" + yaml5.stringify(updatedYAML) + "---\n" + body;
+  await fs2.ensureDir(path8.dirname(targetFilePath));
+  await fs2.writeFile(targetFilePath, newContent, "utf-8");
+}
+async function createBackwardCompatSymlink(projectRoot, v3Path, v4Path) {
+  const v3FullPath = path8.join(projectRoot, v3Path);
+  const v4FullPath = path8.join(projectRoot, v4Path);
+  await fs2.ensureDir(path8.dirname(v3FullPath));
+  const relativePath = path8.relative(path8.dirname(v3FullPath), v4FullPath);
+  try {
+    if (await fs2.pathExists(v3FullPath)) {
+      await fs2.remove(v3FullPath);
+    }
+    await fs2.symlink(relativePath, v3FullPath);
+  } catch {
+    console.warn(`Warning: Could not create symlink ${v3Path} \u2192 ${v4Path}`);
+  }
+}
+async function createSymlinks(projectRoot, mappings) {
+  let created = 0;
+  for (const mapping of mappings) {
+    try {
+      await createBackwardCompatSymlink(projectRoot, mapping.oldPath, mapping.newPath);
+      created++;
+    } catch {
+    }
+  }
+  return created;
+}
+async function copyRules(projectRoot) {
+  const v3RulesPath = path8.join(projectRoot, ".cursor/rules");
+  const v4RulesPath = path8.join(projectRoot, ".onion/core/rules");
+  if (!await fs2.pathExists(v3RulesPath)) {
+    return 0;
+  }
+  const files = await fs2.readdir(v3RulesPath);
+  let copied = 0;
+  for (const file of files) {
+    if (file.endsWith(".mdc") || file.endsWith(".md")) {
+      await fs2.copy(path8.join(v3RulesPath, file), path8.join(v4RulesPath, file));
+      copied++;
+    }
+  }
+  return copied;
+}
+async function copySessions(projectRoot, targetContext = "technical") {
+  const v3SessionsPath = path8.join(projectRoot, ".cursor/sessions");
+  const v4SessionsPath = path8.join(projectRoot, `.onion/contexts/${targetContext}/sessions`);
+  if (!await fs2.pathExists(v3SessionsPath)) {
+    return 0;
+  }
+  await fs2.copy(v3SessionsPath, v4SessionsPath);
+  const dirs = await fs2.readdir(v3SessionsPath);
+  let count = 0;
+  for (const name of dirs) {
+    const stat = await fs2.stat(path8.join(v3SessionsPath, name));
+    if (stat.isDirectory()) {
+      count++;
+    }
+  }
+  return count;
+}
+function createCommandYAMLHeader(name, context, level) {
+  const header = {
+    name,
+    description: `${name} command`,
+    model: "sonnet",
+    category: context,
+    tags: [level],
+    version: "4.0.0",
+    updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    level,
+    context
+  };
+  return "---\n" + yaml5.stringify(header) + "---";
+}
+function createAgentYAMLHeader(name, context) {
+  const header = {
+    name,
+    description: `${name} agent`,
+    model: "sonnet",
+    category: context,
+    tags: ["agent"],
+    expertise: [],
+    version: "4.0.0",
+    updated: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    context
+  };
+  return "---\n" + yaml5.stringify(header) + "---";
+}
+
+// src/commands/migrate.ts
+async function migrate(options = {}) {
+  try {
+    const projectRoot = process.cwd();
+    logger.title("\u{1F9C5} Onion Migration: v3 \u2192 v4");
+    logger.break();
+    const v3 = await detectOnionV3Structure(projectRoot);
+    if (!v3) {
+      logger.error("\u274C This is not an Onion v3 project");
+      logger.info("Looking for .cursor/ structure with commands/ and agents/");
+      logger.break();
+      logger.info("To initialize a new Onion v4 project, run: onion init");
+      process.exit(1);
+    }
+    logger.success("\u2705 Onion v3 project detected");
+    logger.break();
+    const eligibility = validateMigrationEligibility(v3);
+    if (!eligibility.canMigrate) {
+      logger.error("\u274C Cannot migrate this project:");
+      for (const issue of eligibility.issues) {
+        logger.error(`  \u2022 ${issue}`);
+      }
+      process.exit(1);
+    }
+    logger.startSpinner("Analyzing v3 structure...");
+    const analysis = await analyzeV3Structure(projectRoot);
+    logger.stopSpinner(true, "Analysis complete");
+    logger.break();
+    logger.info("\u{1F4CA} Found:");
+    logger.info(`  \u2022 ${analysis.stats.totalCommands} commands`);
+    logger.info(`  \u2022 ${analysis.stats.totalAgents} agents`);
+    if (analysis.stats.hasRules) logger.info("  \u2022 Rules directory");
+    if (analysis.stats.hasSessions) logger.info("  \u2022 Sessions directory");
+    logger.break();
+    const plan = buildMigrationPlan(analysis);
+    const planValidation = validateMigrationPlan(plan);
+    if (!planValidation.valid) {
+      logger.error("\u274C Migration plan has issues:");
+      for (const issue of planValidation.issues) {
+        logger.error(`  \u2022 ${issue}`);
+      }
+      process.exit(1);
+    }
+    logger.title("\u{1F5FA}\uFE0F  Migration Plan:");
+    logger.break();
+    logger.info(`\u{1F4E6} Contexts to create: ${plan.contexts.join(", ")}`);
+    logger.break();
+    logger.info("\u{1F4DD} Commands:");
+    for (const [context, count] of Object.entries(plan.summary.commandsByContext)) {
+      logger.info(`  \u2022 ${context}: ${count} commands`);
+    }
+    logger.break();
+    logger.info("\u{1F916} Agents:");
+    for (const [context, count] of Object.entries(plan.summary.agentsByContext)) {
+      logger.info(`  \u2022 ${context}: ${count} agents`);
+    }
+    logger.break();
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: "Proceed with migration?",
+        default: false
+      }
+    ]);
+    if (!confirm) {
+      logger.warn("\u274C Migration cancelled");
+      return;
+    }
+    logger.break();
+    logger.title("\u{1F680} Starting migration...");
+    logger.break();
+    if (!options.noBackup) {
+      logger.startSpinner("Creating backup...");
+      const backupPath = path8.join(projectRoot, ".cursor-backup");
+      await fs2.copy(path8.join(projectRoot, ".cursor"), backupPath);
+      logger.stopSpinner(true, `Backup created: .cursor-backup/`);
+    }
+    logger.startSpinner("Creating v4 structure...");
+    await generateCoreStructure(projectRoot);
+    for (const contextName of plan.contexts) {
+      await generateContextStructure(projectRoot, contextName, {
+        includeREADME: true,
+        includeConfig: true
+      });
+    }
+    await generateIDELoader(projectRoot, "cursor", {
+      contexts: plan.contexts
+    });
+    await generateDocsStructure(projectRoot, plan.contexts);
+    logger.stopSpinner(true, "Structure created");
+    logger.startSpinner(`Migrating ${plan.commands.length} commands...`);
+    for (const mapping of plan.commands) {
+      const targetPath = path8.join(projectRoot, mapping.newPath);
+      await transformCommandFile(
+        mapping.oldPath,
+        targetPath,
+        mapping.context,
+        mapping.level
+      );
+    }
+    logger.stopSpinner(true, `${plan.commands.length} commands migrated`);
+    logger.startSpinner(`Migrating ${plan.agents.length} agents...`);
+    for (const mapping of plan.agents) {
+      const targetPath = path8.join(projectRoot, mapping.newPath);
+      await transformAgentFile(mapping.oldPath, targetPath, mapping.context);
+    }
+    logger.stopSpinner(true, `${plan.agents.length} agents migrated`);
+    if (analysis.stats.hasRules) {
+      logger.startSpinner("Copying rules...");
+      const copied = await copyRules(projectRoot);
+      logger.stopSpinner(true, `${copied} rules copied`);
+    }
+    if (analysis.stats.hasSessions) {
+      logger.startSpinner("Copying sessions...");
+      await copySessions(projectRoot, "technical");
+      logger.stopSpinner(true, `Sessions copied`);
+    }
+    logger.startSpinner("Creating symlinks for backward compatibility...");
+    const symlinkMappings = [
+      ...plan.commands.map((m) => ({
+        oldPath: path8.relative(projectRoot, m.oldPath),
+        newPath: m.newPath
+      })),
+      ...plan.agents.map((m) => ({
+        oldPath: path8.relative(projectRoot, m.oldPath),
+        newPath: m.newPath
+      }))
+    ];
+    const symlinkCount = await createSymlinks(projectRoot, symlinkMappings);
+    logger.stopSpinner(true, `${symlinkCount} symlinks created`);
+    logger.startSpinner("Creating .onion-config.yml...");
+    const configData = createDefaultConfig({
+      version: "4.0.0",
+      contexts: plan.contexts,
+      ides: ["cursor"],
+      migrated: true,
+      migratedFrom: "v3",
+      migratedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      migration: {
+        commandsMigrated: plan.commands.length,
+        agentsMigrated: plan.agents.length,
+        backupPath: options.noBackup ? null : ".cursor-backup/"
+      }
+    });
+    await createConfig(projectRoot, configData);
+    logger.stopSpinner(true, "Config created");
+    const reportPath = path8.join(projectRoot, "docs/onion/MIGRATION-REPORT.md");
+    await fs2.ensureDir(path8.dirname(reportPath));
+    await fs2.writeFile(reportPath, generateMigrationReport(plan), "utf-8");
+    logger.break();
+    logger.title("\u2705 Migration completed successfully!");
+    logger.break();
+    logger.success("Summary:");
+    logger.info(`  \u2022 ${plan.commands.length} commands migrated`);
+    logger.info(`  \u2022 ${plan.agents.length} agents migrated`);
+    logger.info(`  \u2022 ${plan.contexts.length} contexts created`);
+    logger.info(`  \u2022 ${symlinkCount} symlinks for backward compatibility`);
+    if (!options.noBackup) {
+      logger.info("  \u2022 Backup saved: .cursor-backup/");
+    }
+    logger.break();
+    logger.success("Next steps:");
+    logger.info("  1. Review migration report: docs/onion/MIGRATION-REPORT.md");
+    logger.info("  2. Test your commands (they still work via symlinks)");
+    logger.info("  3. Explore new structure: .onion/contexts/");
+    logger.info("  4. Read system guide: docs/onion/levels-system.md");
+    logger.info("  5. Use new help commands: /business/help, /technical/help");
+    logger.break();
+    logger.warn("\u26A0\uFE0F  Important:");
+    logger.info("  \u2022 .cursor/ is now deprecated (kept for backward compatibility)");
+    logger.info("  \u2022 New commands/agents should be added to .onion/contexts/");
+    logger.info("  \u2022 Backup can be removed after validation: rm -rf .cursor-backup");
+    logger.break();
+  } catch (error) {
+    logger.break();
+    logger.error("\u274C Migration failed:");
+    logger.error(error.message);
+    if (options.debug) {
+      console.error(error);
+    }
+    logger.break();
+    logger.info("\u{1F4A1} Troubleshooting:");
+    logger.info("  \u2022 Backup preserved: .cursor-backup/");
+    logger.info("  \u2022 Review error above");
+    logger.info("  \u2022 Run with --debug for more details");
+    logger.info("  \u2022 Report issue: https://github.com/onion-system/onion/issues");
+    logger.break();
+    process.exit(1);
+  }
+}
+
+// src/commands/validate.ts
+async function validate(options = {}) {
+  try {
+    logger.info("Validating Onion structure...");
+    logger.warn("Command not implemented yet - Coming soon!");
+  } catch (error) {
+    logger.error(`Validation failed: ${error.message}`);
+    if (options.debug) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli.ts
+init_constants();
+var program = new Command();
+console.log("");
+console.log(chalk.magenta("\u{1F9C5} Onion System CLI"));
+console.log(chalk.gray(`v${ONION_VERSION} - Multi-Context Development Orchestrator`));
+console.log("");
+program.name("onion").description("CLI for Onion System - Multi-Context Development Orchestrator").version(ONION_VERSION);
+program.command("init").description("Initialize new Onion project").option("-d, --debug", "Enable debug mode").action(async (options) => {
+  await init(options);
+});
+program.command("add").description("Add context or IDE to existing project").option("-d, --debug", "Enable debug mode").action(async (options) => {
+  await add(options);
+});
+program.command("migrate").description("Migrate from Onion v3 to v4").option("--no-backup", "Skip backup creation").option("-d, --debug", "Enable debug mode").action(async (options) => {
+  await migrate(options);
+});
+program.command("validate").description("Validate Onion structure").option("-d, --debug", "Enable debug mode").action(async (options) => {
+  await validate(options);
+});
+program.parse(process.argv);
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map