opencode-setup 0.1.0

package/dist/chunk-PKHQD5QT.js

@@ -0,0 +1,1106 @@
+// src/preset/registry.ts
+import { readFileSync, writeFileSync, mkdirSync, existsSync, cpSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var TEMPLATES_DIR = join(__dirname, "templates");
+var MODEL_PRESETS = [
+  {
+    name: "budget",
+    description: "Big Pickle \uBB34\uB8CC \uC870\uD569",
+    monthlyCost: "\uBB34\uB8CC ~ $10",
+    config: JSON.parse(readFileSync(join(TEMPLATES_DIR, "configs/budget.json"), "utf-8"))
+  },
+  {
+    name: "balanced",
+    description: "Sonnet + Flash",
+    monthlyCost: "$20 ~ $40",
+    config: JSON.parse(readFileSync(join(TEMPLATES_DIR, "configs/balanced.json"), "utf-8"))
+  },
+  {
+    name: "power",
+    description: "Sonnet + Opus",
+    monthlyCost: "$50+",
+    config: JSON.parse(readFileSync(join(TEMPLATES_DIR, "configs/power.json"), "utf-8"))
+  },
+  {
+    name: "minimax",
+    description: "M2.5 + Big Pickle",
+    monthlyCost: "$5 ~ $15",
+    config: JSON.parse(readFileSync(join(TEMPLATES_DIR, "configs/minimax.json"), "utf-8"))
+  },
+  {
+    name: "google-only",
+    description: "Gemini Pro + Flash",
+    monthlyCost: "$15 ~ $30",
+    config: JSON.parse(readFileSync(join(TEMPLATES_DIR, "configs/google-only.json"), "utf-8"))
+  }
+];
+var STACK_PRESETS = [
+  {
+    name: "frontend-ts",
+    description: "TypeScript \uD504\uB860\uD2B8\uC5D4\uB4DC \uCD5C\uC801\uD654 (Next.js/React)",
+    modelPreset: "balanced",
+    includes: {
+      agentsMD: "frontend-ts.md",
+      commands: ["test.md", "lint.md", "review.md", "plan.md"],
+      agents: ["reviewer.md", "tester.md", "planner.md"],
+      skills: ["code-review", "testing", "frontend-design"]
+    }
+  },
+  {
+    name: "backend-go",
+    description: "Go \uBC31\uC5D4\uB4DC \uCD5C\uC801\uD654",
+    modelPreset: "balanced",
+    includes: {
+      agentsMD: "backend-go.md",
+      commands: ["test.md", "lint.md", "review.md", "plan.md"],
+      agents: ["reviewer.md", "tester.md", "planner.md"],
+      skills: ["code-review", "testing"]
+    }
+  },
+  {
+    name: "backend-python",
+    description: "Python \uBC31\uC5D4\uB4DC \uCD5C\uC801\uD654 (FastAPI)",
+    modelPreset: "balanced",
+    includes: {
+      agentsMD: "backend-python.md",
+      commands: ["test.md", "lint.md", "review.md", "plan.md"],
+      agents: ["reviewer.md", "tester.md", "planner.md"],
+      skills: ["code-review", "testing"]
+    }
+  },
+  {
+    name: "fullstack",
+    description: "\uD480\uC2A4\uD0DD \uD504\uB85C\uC81D\uD2B8 \uCD5C\uC801\uD654",
+    modelPreset: "balanced",
+    includes: {
+      agentsMD: "fullstack.md",
+      commands: ["test.md", "lint.md", "review.md", "plan.md"],
+      agents: ["reviewer.md", "tester.md", "planner.md"],
+      skills: ["code-review", "testing"]
+    }
+  }
+];
+function listPresets() {
+  const lines = ["# Available Presets\n"];
+  lines.push("## Model Presets");
+  lines.push("");
+  lines.push("| Name | Description | Monthly Cost |");
+  lines.push("|------|-------------|--------------|");
+  for (const preset of MODEL_PRESETS) {
+    lines.push(`| \`${preset.name}\` | ${preset.description} | ${preset.monthlyCost} |`);
+  }
+  lines.push("");
+  lines.push("## Stack Presets");
+  lines.push("");
+  lines.push("| Name | Description |");
+  lines.push("|------|-------------|");
+  for (const preset of STACK_PRESETS) {
+    lines.push(`| \`${preset.name}\` | ${preset.description} |`);
+  }
+  return lines.join("\n");
+}
+function getModelPreset(name) {
+  return MODEL_PRESETS.find((p) => p.name === name);
+}
+function getStackPreset(name) {
+  return STACK_PRESETS.find((p) => p.name === name);
+}
+async function applyPreset(name, projectDir, options = {}) {
+  const files = [];
+  const warnings = [];
+  const modelPreset = getModelPreset(name);
+  if (modelPreset) {
+    const configPath = join(projectDir, "opencode.json");
+    const configDir = dirname(configPath);
+    if (!existsSync(configDir)) {
+      mkdirSync(configDir, { recursive: true });
+    }
+    let existingConfig = {};
+    if (existsSync(configPath)) {
+      try {
+        existingConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+      } catch {
+        warnings.push(`Could not parse existing opencode.json at ${configPath}`);
+      }
+    }
+    const newConfig = {
+      ...existingConfig,
+      ...modelPreset.config
+    };
+    writeFileSync(configPath, JSON.stringify(newConfig, null, 2) + "\n");
+    files.push(configPath);
+    return { success: true, files, warnings };
+  }
+  const stackPreset = getStackPreset(name);
+  if (stackPreset) {
+    const { includes } = stackPreset;
+    const opencodeDir = join(projectDir, ".opencode");
+    const agentsDir = join(opencodeDir, "agents");
+    const commandsDir = join(opencodeDir, "commands");
+    const skillsDir = join(opencodeDir, "skills");
+    mkdirSync(agentsDir, { recursive: true });
+    mkdirSync(commandsDir, { recursive: true });
+    mkdirSync(skillsDir, { recursive: true });
+    const agentsMDSource = join(TEMPLATES_DIR, "agents-md", includes.agentsMD);
+    const agentsMDDest = join(projectDir, "AGENTS.md");
+    if (existsSync(agentsMDSource)) {
+      let content = readFileSync(agentsMDSource, "utf-8");
+      content = content.replace(/\{\{projectName\}\}/g, options.projectName || "My Project");
+      content = content.replace(/\{\{testRunner\}\}/g, options.testRunner || "vitest");
+      content = content.replace(/\{\{linter\}\}/g, options.linter || "biome");
+      writeFileSync(agentsMDDest, content);
+      files.push(agentsMDDest);
+    }
+    for (const cmd of includes.commands) {
+      const src = join(TEMPLATES_DIR, "commands", cmd);
+      const dest = join(commandsDir, cmd.replace(".md", ".md"));
+      if (existsSync(src)) {
+        cpSync(src, dest);
+        files.push(dest);
+      }
+    }
+    for (const agent of includes.agents) {
+      const src = join(TEMPLATES_DIR, "agents", agent);
+      const dest = join(agentsDir, agent);
+      if (existsSync(src)) {
+        cpSync(src, dest);
+        files.push(dest);
+      }
+    }
+    for (const skill of includes.skills) {
+      const src = join(TEMPLATES_DIR, "skills", skill);
+      const dest = join(skillsDir, skill);
+      if (existsSync(src)) {
+        cpSync(src, dest, { recursive: true });
+        files.push(dest);
+      }
+    }
+    const modelResult = await applyPreset(stackPreset.modelPreset, projectDir, options);
+    files.push(...modelResult.files);
+    warnings.push(...modelResult.warnings);
+    return { success: true, files, warnings };
+  }
+  return {
+    success: false,
+    files: [],
+    warnings: [`Unknown preset: ${name}. Use 'preset list' to see available presets.`]
+  };
+}
+
+// src/validator/config-validator.ts
+import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+async function runValidation(directory) {
+  const errors = [];
+  const globalConfigPath = join2(process.env.HOME || "~", ".config/opencode/opencode.json");
+  const expandedGlobalPath = globalConfigPath.replace("~", process.env.HOME || "");
+  if (existsSync2(expandedGlobalPath)) {
+    try {
+      const content = readFileSync2(expandedGlobalPath, "utf-8");
+      const config = JSON.parse(content);
+      if (!config.$schema) {
+        errors.push({ type: "warning", file: "~/.config/opencode/opencode.json", message: "Missing $schema field" });
+      }
+      if (config.model) {
+        const modelPattern = /^[a-z0-9-]+\/[a-z0-9-]+$/i;
+        if (!modelPattern.test(config.model)) {
+          errors.push({ type: "error", file: "~/.config/opencode/opencode.json", message: `Invalid model format: '${config.model}'. Expected 'provider/model'` });
+        }
+      }
+      if (config.permission) {
+        const validValues = ["allow", "ask", "deny"];
+        if (config.permission.edit && !validValues.includes(config.permission.edit)) {
+          errors.push({ type: "error", file: "~/.config/opencode/opencode.json", message: `Invalid permission.edit value: '${config.permission.edit}'` });
+        }
+        if (config.permission.webfetch && !validValues.includes(config.permission.webfetch)) {
+          errors.push({ type: "error", file: "~/.config/opencode/opencode.json", message: `Invalid permission.webfetch value: '${config.permission.webfetch}'` });
+        }
+      }
+      if (config.plugin) {
+        if (!Array.isArray(config.plugin)) {
+          errors.push({ type: "error", file: "~/.config/opencode/opencode.json", message: "plugin must be an array" });
+        } else if (!config.plugin.every((p) => typeof p === "string" || Array.isArray(p) && typeof p[0] === "string")) {
+          errors.push({ type: "error", file: "~/.config/opencode/opencode.json", message: "plugin array must contain strings or [string, options] tuples" });
+        }
+      }
+    } catch (e) {
+      errors.push({ type: "error", file: "~/.config/opencode/opencode.json", message: `Invalid JSON: ${e instanceof Error ? e.message : "Unknown error"}` });
+    }
+  }
+  const projectConfigPath = join2(directory, "opencode.json");
+  if (existsSync2(projectConfigPath)) {
+    try {
+      const content = readFileSync2(projectConfigPath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.permission) {
+        const validValues = ["allow", "ask", "deny"];
+        if (config.permission.edit && !validValues.includes(config.permission.edit)) {
+          errors.push({ type: "error", file: "opencode.json", message: `Invalid permission.edit value: '${config.permission.edit}'` });
+        }
+      }
+      if (config.plugin && !Array.isArray(config.plugin)) {
+        errors.push({ type: "error", file: "opencode.json", message: "plugin must be an array" });
+      }
+    } catch (e) {
+      errors.push({ type: "error", file: "opencode.json", message: `Invalid JSON: ${e instanceof Error ? e.message : "Unknown error"}` });
+    }
+  }
+  const agentsPath = join2(directory, "AGENTS.md");
+  if (!existsSync2(agentsPath)) {
+    errors.push({ type: "warning", file: "AGENTS.md", message: "AGENTS.md not found in project root" });
+  } else {
+    const content = readFileSync2(agentsPath, "utf-8");
+    if (content.trim().length === 0) {
+      errors.push({ type: "error", file: "AGENTS.md", message: "AGENTS.md is empty" });
+    }
+    if (!content.includes("## ")) {
+      errors.push({ type: "warning", file: "AGENTS.md", message: "AGENTS.md has no section headers (##)" });
+    }
+  }
+  const errorCount = errors.filter((e) => e.type === "error").length;
+  const warningCount = errors.filter((e) => e.type === "warning").length;
+  const lines = ["\u{1F4CB} Configuration Validation\n"];
+  if (errors.length === 0) {
+    lines.push("\x1B[32m\u2713 All checks passed!\x1B[0m");
+  } else {
+    for (const error of errors) {
+      const icon = error.type === "error" ? "\u2717" : "\u26A0";
+      const color = error.type === "error" ? "31" : "33";
+      lines.push(`\x1B[${color}m${icon} ${error.file}\x1B[0m ${error.message}`);
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push(`Summary: ${errorCount} errors, ${warningCount} warnings`);
+  return lines.join("\n");
+}
+
+// src/doctor/checks.ts
+import { join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { execSync } from "child_process";
+function execCommand(cmd) {
+  try {
+    const stdout = execSync(cmd.join(" "), { encoding: "utf-8", stdio: ["pipe", "pipe", "ignore"] });
+    return { exitCode: 0, stdout: stdout.trim() };
+  } catch (e) {
+    const err = e;
+    return { exitCode: err.status || 1, stdout: "" };
+  }
+}
+function checkOpenCode() {
+  const whichResult = execCommand(["which", "opencode"]);
+  if (whichResult.exitCode === 0) {
+    const versionResult = execCommand(["opencode", "--version"]);
+    const version = versionResult.stdout || "unknown";
+    return { name: "OpenCode", status: "pass", message: `v${version}` };
+  }
+  const npmResult = execCommand(["npm", "list", "-g", "opencode-ai"]);
+  if (npmResult.exitCode === 0) {
+    return { name: "OpenCode", status: "warn", message: "OpenCode is installed via npm", fix: "Install OpenCode from https://opencode.ai or use npm install -g opencode-ai" };
+  }
+  return { name: "OpenCode", status: "fail", message: "OpenCode not found", fix: "Install OpenCode from https://opencode.ai" };
+}
+function checkBun() {
+  const result = execCommand(["bun", "--version"]);
+  if (result.exitCode === 0) {
+    const version = result.stdout || "unknown";
+    return { name: "Bun", status: "pass", message: `v${version}` };
+  }
+  const nodeResult = execCommand(["node", "--version"]);
+  if (nodeResult.exitCode === 0) {
+    return { name: "Bun", status: "warn", message: "Bun not found, Node.js detected", fix: "Install Bun: https://bun.sh" };
+  }
+  return { name: "Bun", status: "fail", message: "Bun not found", fix: "Install Bun: https://bun.sh" };
+}
+function checkApiKeys() {
+  const keys = ["ANTHROPIC_API_KEY", "GEMINI_API_KEY", "OPENAI_API_KEY", "DEEPSEEK_API_KEY", "OPENROUTER_API_KEY"];
+  const found = [];
+  const missing = [];
+  for (const key of keys) {
+    if (process.env[key]) {
+      found.push(key);
+    } else {
+      missing.push(key);
+    }
+  }
+  if (found.length === 0) {
+    return { name: "API Keys", status: "fail", message: "No API keys configured", fix: "Set at least one API key: ANTHROPIC_API_KEY, GEMINI_API_KEY, or OPENAI_API_KEY" };
+  }
+  return { name: "API Keys", status: "pass", message: `Configured: ${found.join(", ")}` };
+}
+function checkAuthFile() {
+  const authPath = join3(process.env.HOME || "~", ".local/share/opencode/auth.json");
+  const expandedPath = authPath.replace("~", process.env.HOME || "");
+  if (existsSync3(expandedPath)) {
+    return { name: "Auth File", status: "pass", message: "auth.json exists" };
+  }
+  return { name: "Auth File", status: "warn", message: "auth.json not found", fix: "Run /connect in OpenCode to authenticate with providers" };
+}
+function checkConfig() {
+  const configPath = join3(process.env.HOME || "~", ".config/opencode/opencode.json");
+  const expandedPath = configPath.replace("~", process.env.HOME || "");
+  if (!existsSync3(expandedPath)) {
+    return { name: "Global Config", status: "warn", message: "Global opencode.json not found", fix: "Run 'opencode-setup init' or configure OpenCode manually" };
+  }
+  try {
+    const content = readFileSync3(expandedPath, "utf-8");
+    JSON.parse(content);
+    return { name: "Global Config", status: "pass", message: "Valid JSON configuration" };
+  } catch {
+    return { name: "Global Config", status: "fail", message: "Invalid JSON in opencode.json", fix: "Check ~/.config/opencode/opencode.json for syntax errors" };
+  }
+}
+function checkProjectConfig(directory) {
+  const configPath = join3(directory, "opencode.json");
+  if (!existsSync3(configPath)) {
+    return { name: "Project Config", status: "warn", message: "No project opencode.json", fix: "Run 'opencode-setup init' or create opencode.json in project root" };
+  }
+  try {
+    const content = readFileSync3(configPath, "utf-8");
+    JSON.parse(content);
+    return { name: "Project Config", status: "pass", message: "Valid project configuration" };
+  } catch {
+    return { name: "Project Config", status: "fail", message: "Invalid JSON in project opencode.json", fix: "Check opencode.json for syntax errors" };
+  }
+}
+function checkAgentsMD(directory) {
+  const agentsPath = join3(directory, "AGENTS.md");
+  if (!existsSync3(agentsPath)) {
+    return { name: "AGENTS.md", status: "warn", message: "AGENTS.md not found", fix: "Run 'opencode-setup init' or create AGENTS.md with project guidelines" };
+  }
+  const content = readFileSync3(agentsPath, "utf-8");
+  if (content.trim().length === 0) {
+    return { name: "AGENTS.md", status: "warn", message: "AGENTS.md is empty", fix: "Add project-specific guidelines to AGENTS.md" };
+  }
+  return { name: "AGENTS.md", status: "pass", message: "AGENTS.md exists" };
+}
+function checkLSP() {
+  const lspServers = ["typescript-language-server", "gopls", "rust-analyzer", "pyright"];
+  for (const lsp of lspServers) {
+    const result = execCommand(["which", lsp]);
+    if (result.exitCode === 0) {
+      return { name: "LSP", status: "pass", message: `${lsp} found` };
+    }
+  }
+  return { name: "LSP", status: "warn", message: "No LSP servers found", fix: "Install LSP servers: typescript-language-server, gopls, rust-analyzer, or pyright" };
+}
+function checkPlugins() {
+  const configPath = join3(process.env.HOME || "~", ".config/opencode/opencode.json");
+  const expandedPath = configPath.replace("~", process.env.HOME || "");
+  if (!existsSync3(expandedPath)) {
+    return { name: "Plugins", status: "warn", message: "Cannot check plugins - no global config" };
+  }
+  try {
+    const content = readFileSync3(expandedPath, "utf-8");
+    const config = JSON.parse(content);
+    const plugins = config.plugin || [];
+    if (plugins.length === 0) {
+      return { name: "Plugins", status: "warn", message: "No plugins configured", fix: "Consider installing oh-my-opencode for enhanced multi-agent orchestration" };
+    }
+    return { name: "Plugins", status: "pass", message: `Configured: ${plugins.join(", ")}` };
+  } catch {
+    return { name: "Plugins", status: "warn", message: "Could not read plugin config" };
+  }
+}
+async function runAllChecks(directory) {
+  return [
+    checkOpenCode(),
+    checkBun(),
+    checkApiKeys(),
+    checkAuthFile(),
+    checkConfig(),
+    checkProjectConfig(directory),
+    checkAgentsMD(directory),
+    checkLSP(),
+    checkPlugins()
+  ];
+}
+
+// src/doctor/reporter.ts
+function formatReport(results) {
+  const lines = ["\u{1FA7A} Environment Diagnosis\n"];
+  let passCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+  for (const result of results) {
+    if (result.status === "pass") passCount++;
+    else if (result.status === "warn") warnCount++;
+    else failCount++;
+    const icon = result.status === "pass" ? "\u2713" : result.status === "warn" ? "\u26A0" : "\u2717";
+    const color = result.status === "pass" ? "32" : result.status === "warn" ? "33" : "31";
+    lines.push(`\x1B[${color}m${icon} ${result.name}\x1B[0m ${result.message}`);
+    if (result.status === "fail" && result.fix) {
+      lines.push(`  \x1B[36m\u2192\x1B[0m ${result.fix}`);
+    }
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push(`Summary: ${passCount} passed, ${warnCount} warnings, ${failCount} failures`);
+  return lines.join("\n");
+}
+
+// src/migrate/common.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, cpSync as cpSync2, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+function readFileSafe(filePath) {
+  try {
+    if (existsSync4(filePath)) return readFileSync4(filePath, "utf-8");
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeFileSafe(filePath, content) {
+  const dir = dirname2(filePath);
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
+  writeFileSync2(filePath, content, "utf-8");
+}
+function backupFile(filePath) {
+  if (existsSync4(filePath)) cpSync2(filePath, `${filePath}.bak`);
+}
+function copyDirectory(src, dest) {
+  const copied = [];
+  if (!existsSync4(src)) return copied;
+  mkdirSync2(dest, { recursive: true });
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const srcPath = join4(src, entry.name);
+    const destPath = join4(dest, entry.name);
+    if (entry.isDirectory()) {
+      copied.push(...copyDirectory(srcPath, destPath));
+    } else {
+      try {
+        cpSync2(srcPath, destPath);
+        copied.push(destPath);
+      } catch {
+      }
+    }
+  }
+  return copied;
+}
+function detectTool(rootPath) {
+  const checks = [
+    { file: join4(rootPath, ".claude"), name: "claude-code" },
+    { file: join4(rootPath, ".cursorrules"), name: "cursor" },
+    { file: join4(rootPath, ".aider.conf.yml"), name: "aider" },
+    { file: join4(rootPath, "CLAUDE.md"), name: "claude-code" },
+    { file: join4(rootPath, "claude_desktop_config.json"), name: "claude-code" }
+  ];
+  for (const check of checks) {
+    if (existsSync4(check.file)) return check.name;
+  }
+  return null;
+}
+function parseYAML(content) {
+  const result = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex > 0) {
+      const key = trimmed.slice(0, colonIndex).trim();
+      const value = trimmed.slice(colonIndex + 1).trim().replace(/^["']|["']$/g, "");
+      if (value) result[key] = value;
+    }
+  }
+  return result;
+}
+function formatMigrationResult(toolName, files, warnings, suggestions) {
+  const lines = [
+    `\u2705 ${toolName} \u2192 OpenCode \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uC644\uB8CC!`,
+    "",
+    "\uC0DD\uC131\uB41C \uD30C\uC77C:",
+    ...files.map((f) => `  \u2022 ${f}`)
+  ];
+  if (warnings.length > 0) {
+    lines.push("", "\uACBD\uACE0:", ...warnings.map((w) => `  \u26A0\uFE0F ${w}`));
+  }
+  if (suggestions.length > 0) {
+    lines.push("", "\uAD8C\uC7A5 \uC0AC\uD56D:", ...suggestions.map((s) => `  \u2192 ${s}`));
+  }
+  lines.push("", "\uB2E4\uC74C \uB2E8\uACC4:", "1. \uC0DD\uC131\uB41C \uD30C\uC77C\uB4E4\uC744 \uD655\uC778\uD558\uC138\uC694", "2. opencode.json\uC758 API \uD0A4\uB97C \uC124\uC815\uD558\uC138\uC694", "3. 'opencode doctor'\uB85C \uD658\uACBD\uC744 \uD655\uC778\uD558\uC138\uC694");
+  return lines.join("\n");
+}
+
+// src/migrate/claude-code.ts
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+function migrateClaudeCode(rootPath) {
+  const files = [];
+  const warnings = [];
+  const suggestions = [];
+  const claudeMD = readFileSafe(join5(rootPath, "CLAUDE.md"));
+  if (claudeMD) {
+    const destPath = join5(rootPath, "AGENTS.md");
+    backupFile(destPath);
+    writeFileSafe(destPath, claudeMD);
+    files.push("AGENTS.md (\uAE30\uC874 CLAUDE.md)");
+  }
+  const skillsSrc = join5(rootPath, ".claude", "skills");
+  const skillsDest = join5(rootPath, ".opencode", "skills");
+  if (existsSync5(skillsSrc)) {
+    const copied = copyDirectory(skillsSrc, skillsDest);
+    files.push(...copied.map((f) => f.replace(rootPath + "/", "")));
+  }
+  const rulesSrc = join5(rootPath, ".claude", "rules");
+  const rulesDest = join5(rootPath, ".opencode", "rules");
+  if (existsSync5(rulesSrc)) {
+    const copied = copyDirectory(rulesSrc, rulesDest);
+    files.push(...copied.map((f) => f.replace(rootPath + "/", "")));
+    suggestions.push(".claude/rules/ \u2192 .opencode/rules/ \uB9C8\uC774\uADF8\uB808\uC774\uC158\uB428");
+  }
+  const mcpConfig = readFileSafe(join5(rootPath, ".mcp.json")) || readFileSafe(join5(rootPath, "claude_desktop_config.json"));
+  if (mcpConfig) {
+    suggestions.push("MCP \uC124\uC815 \uAC10\uC9C0\uB428 - opencode.json\uC758 mcp \uC139\uC158\uC5D0 \uC218\uB3D9\uC73C\uB85C \uCD94\uAC00 \uD544\uC694");
+  }
+  const settings = readFileSafe(join5(rootPath, ".claude", "settings.json"));
+  if (settings) {
+    const parsed = JSON.parse(settings);
+    if (parsed.model) {
+      suggestions.push(`\uBAA8\uB378 \uC124\uC815 \uAC10\uC9C0\uB428: ${parsed.model} - opencode.json\uC5D0 \uC218\uB3D9\uC73C\uB85C \uCD94\uAC00 \uD544\uC694`);
+    }
+    if (parsed["dangerously-skip-permissions"]) {
+      warnings.push("dangerously-skip-permissions\uB294 OpenCode\uC5D0\uC11C \uC9C0\uC6D0\uB418\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4");
+    }
+  }
+  const omccPath = join5(rootPath, ".claude", "hooks", "oh-my-claude-code");
+  if (existsSync5(omccPath)) {
+    suggestions.push("oh-my-claude-code \uAC10\uC9C0\uB428 - oh-my-opencode \uC124\uCE58 \uAD8C\uC7A5: npm install -g oh-my-opencode");
+  }
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json",
+    theme: "opencode",
+    autoupdate: true
+  };
+  const settingsData = readFileSafe(join5(rootPath, ".claude", "settings.json"));
+  if (settingsData) {
+    try {
+      const settingsObj = JSON.parse(settingsData);
+      if (settingsObj.model) opencodeConfig.model = settingsObj.model;
+    } catch {
+    }
+  }
+  const configPath = join5(rootPath, "opencode.json");
+  backupFile(configPath);
+  writeFileSafe(configPath, JSON.stringify(opencodeConfig, null, 2) + "\n");
+  files.push("opencode.json");
+  return formatMigrationResult("Claude Code", files, warnings, suggestions);
+}
+
+// src/migrate/cursor.ts
+import { join as join6 } from "path";
+function migrateCursor(rootPath) {
+  const files = [];
+  const warnings = [];
+  const suggestions = [];
+  const cursorRules = readFileSafe(join6(rootPath, ".cursorrules"));
+  if (cursorRules) {
+    const destPath = join6(rootPath, "AGENTS.md");
+    backupFile(destPath);
+    writeFileSafe(destPath, cursorRules);
+    files.push("AGENTS.md (\uAE30\uC874 .cursorrules)");
+  }
+  const mcpConfig = readFileSafe(join6(rootPath, ".cursor", "mcp.json"));
+  if (mcpConfig) {
+    try {
+      const mcpData = JSON.parse(mcpConfig);
+      if (mcpData.mcpServers) {
+        suggestions.push("MCP \uC11C\uBC84 \uC124\uC815 \uAC10\uC9C0\uB428 - opencode.json\uC758 mcp \uC139\uC158\uC5D0 \uCD94\uAC00 \uD544\uC694");
+      }
+    } catch {
+    }
+  }
+  const cursorSettings = readFileSafe(join6(rootPath, ".cursor", "settings.json"));
+  if (cursorSettings) {
+    suggestions.push("Cursor \uC124\uC815 \uAC10\uC9C0\uB428 - \uC218\uB3D9\uC73C\uB85C OpenCode \uC124\uC815\uC5D0 \uBC18\uC601 \uD544\uC694");
+  }
+  const cursorRulesContents = readFileSafe(join6(rootPath, ".cursor", "rules"));
+  if (cursorRulesContents) {
+    warnings.push("Cursor Rules \uAC10\uC9C0\uB428 - AGENTS.md\uC5D0 \uBCD1\uD569 \uD544\uC694");
+  }
+  const opencodeConfig = {
+    $schema: "https://opencode.ai/config.json",
+    theme: "opencode",
+    autoupdate: true
+  };
+  const configPath = join6(rootPath, "opencode.json");
+  backupFile(configPath);
+  writeFileSafe(configPath, JSON.stringify(opencodeConfig, null, 2) + "\n");
+  files.push("opencode.json");
+  return formatMigrationResult("Cursor", files, warnings, suggestions);
+}
+
+// src/migrate/aider.ts
+import { join as join7 } from "path";
+function migrateAider(rootPath) {
+  const files = [];
+  const warnings = [];
+  const suggestions = [];
+  const aiderConfig = readFileSafe(join7(rootPath, ".aider.conf.yml")) || readFileSafe(join7(rootPath, ".aider.conf.yaml"));
+  if (aiderConfig) {
+    const parsed = parseYAML(aiderConfig);
+    const opencodeConfig = {
+      $schema: "https://opencode.ai/config.json",
+      theme: "opencode",
+      autoupdate: true
+    };
+    if (parsed.model) {
+      opencodeConfig.model = parsed.model;
+      suggestions.push(`\uBAA8\uB378: ${parsed.model}`);
+    }
+    if (parsed["completion-model"]) {
+      suggestions.push(`\uC644\uB8CC \uBAA8\uB378: ${parsed["completion-model"]}`);
+    }
+    if (parsed["no-fast-subattempts"]) {
+      warnings.push("no-fast-subattempts \uC124\uC815\uC740 OpenCode\uC5D0\uC11C \uC9C0\uC6D0\uB418\uC9C0 \uC54A\uC74C");
+    }
+    const configPath = join7(rootPath, "opencode.json");
+    backupFile(configPath);
+    writeFileSafe(configPath, JSON.stringify(opencodeConfig, null, 2) + "\n");
+    files.push("opencode.json");
+  }
+  const conventions = readFileSafe(join7(rootPath, ".aider.conventions"));
+  if (conventions) {
+    const agentsMDPath = join7(rootPath, "AGENTS.md");
+    backupFile(agentsMDPath);
+    writeFileSafe(agentsMDPath, `# Project Conventions
+
+${conventions}
+`);
+    files.push("AGENTS.md (.aider.conventions)");
+  }
+  const chatHistory = readFileSafe(join7(rootPath, ".aider.chat.history.md"));
+  if (chatHistory) {
+    warnings.push(".aider.chat.history.md\uB294 \uB9C8\uC774\uADF8\uB808\uC774\uC158 \uBD88\uAC00 - \uC218\uB3D9 \uBC31\uC5C5 \uAD8C\uC7A5");
+  }
+  return formatMigrationResult("Aider", files, warnings, suggestions);
+}
+
+// src/migrate/index.ts
+async function runMigration(tool, rootPath) {
+  switch (tool) {
+    case "claude-code":
+      return migrateClaudeCode(rootPath);
+    case "cursor":
+      return migrateCursor(rootPath);
+    case "aider":
+      return migrateAider(rootPath);
+    default:
+      return `\u274C \uC9C0\uC6D0\uD558\uC9C0 \uC54A\uB294 \uB3C4\uAD6C\uC785\uB2C8\uB2E4: ${tool}
+
+\uC9C0\uC6D0: claude-code, cursor, aider`;
+  }
+}
+function autoMigrate(rootPath) {
+  const detected = detectTool(rootPath);
+  if (!detected) {
+    return `\u274C \uB9C8\uC774\uADF8\uB808\uC774\uC158\uD560 \uB3C4\uAD6C\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.
+
+\uAC10\uC9C0 \uAC00\uB2A5\uD55C \uB3C4\uAD6C:
+- Claude Code: .claude/, CLAUDE.md
+- Cursor: .cursorrules
+- Aider: .aider.conf.yml
+
+\uC218\uB3D9\uC73C\uB85C \uC9C0\uC815: opencode-setup migrate <tool-name>`;
+  }
+  switch (detected) {
+    case "claude-code":
+      return migrateClaudeCode(rootPath);
+    case "cursor":
+      return migrateCursor(rootPath);
+    case "aider":
+      return migrateAider(rootPath);
+    default:
+      return `\u274C \uC54C \uC218 \uC5C6\uB294 \uB3C4\uAD6C: ${detected}`;
+  }
+}
+
+// src/core/config-generator.ts
+import { mkdirSync as mkdirSync3, existsSync as existsSync6, writeFileSync as writeFileSync3, cpSync as cpSync3 } from "fs";
+import { join as join8, dirname as dirname3 } from "path";
+var PROVIDER_API_KEYS = {
+  anthropic: "ANTHROPIC_API_KEY",
+  google: "GEMINI_API_KEY",
+  openai: "OPENAI_API_KEY",
+  deepseek: "DEEPSEEK_API_KEY",
+  openrouter: "OPENROUTER_API_KEY",
+  minimax: "MINIMAX_API_KEY"
+};
+var BUDGET_MODELS = {
+  free: { build: "opencode/big-pickle", plan: "opencode/big-pickle" },
+  low: { build: "minimax/minimax-m2.5", plan: "opencode/big-pickle" },
+  mid: { build: "anthropic/claude-sonnet-4-5", plan: "google/gemini-2.5-flash" },
+  high: { build: "anthropic/claude-sonnet-4-5", plan: "anthropic/claude-opus-4-6" }
+};
+var LSP_BY_LANGUAGE = {
+  typescript: "typescript-language-server",
+  javascript: "typescript-language-server",
+  go: "gopls",
+  python: "pyright",
+  rust: "rust-analyzer"
+};
+function getPermissionConfig(level) {
+  switch (level) {
+    case "safe":
+      return { edit: "ask", bash: { "*": "ask" } };
+    case "balanced":
+      return {
+        edit: "allow",
+        bash: { "npm *": "allow", "git *": "allow", "rm *": "ask", "*": "ask" }
+      };
+    case "auto":
+      return { edit: "allow", bash: { "*": "allow" } };
+  }
+}
+function getAgentConfig(budget) {
+  const models = BUDGET_MODELS[budget] || BUDGET_MODELS.mid;
+  return {
+    build: { model: models.build },
+    plan: { model: models.plan }
+  };
+}
+function getMCPConfig(mcpServers) {
+  const result = {};
+  for (const mcp of mcpServers) {
+    result[mcp.name] = {
+      type: "sse",
+      ...mcp.config
+    };
+  }
+  return result;
+}
+function getLSPConfig(language) {
+  const lspCommand = LSP_BY_LANGUAGE[language];
+  if (!lspCommand) return {};
+  return {
+    [language]: {
+      command: lspCommand
+    }
+  };
+}
+function generateGlobalConfig(profile) {
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    theme: "opencode",
+    autoupdate: true,
+    plugin: profile.plugins
+  };
+  if (profile.providers.length > 0) {
+    config.provider = {};
+    for (const provider of profile.providers) {
+      const apiKey = PROVIDER_API_KEYS[provider];
+      if (apiKey) {
+        config.provider[provider] = {
+          options: { apiKey: `{env:${apiKey}}` }
+        };
+      }
+    }
+  }
+  const models = BUDGET_MODELS[profile.budget] || BUDGET_MODELS.mid;
+  config.model = models.build;
+  return config;
+}
+function generateProjectConfig(profile) {
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    permission: getPermissionConfig(profile.permissionLevel),
+    agent: getAgentConfig(profile.budget)
+  };
+  if (profile.mcpServers.length > 0) {
+    config.mcp = getMCPConfig(profile.mcpServers);
+  }
+  const lspConfig = getLSPConfig(profile.projectLanguage);
+  if (Object.keys(lspConfig).length > 0) {
+    config.lsp = lspConfig;
+  }
+  if (profile.projectScale === "monorepo") {
+    config.instructions = ["packages/*/AGENTS.md"];
+  }
+  return config;
+}
+function backupFile2(path) {
+  if (existsSync6(path)) {
+    const backupPath = `${path}.bak`;
+    cpSync3(path, backupPath);
+  }
+}
+function writeConfig(config, filePath) {
+  const dir = dirname3(filePath);
+  if (!existsSync6(dir)) {
+    mkdirSync3(dir, { recursive: true });
+  }
+  backupFile2(filePath);
+  const content = JSON.stringify(config, null, 2) + "\n";
+  writeFileSync3(filePath, content, "utf-8");
+}
+function writeGlobalConfig(profile, homeDir) {
+  const config = generateGlobalConfig(profile);
+  const path = join8(homeDir, ".config/opencode/opencode.json");
+  writeConfig(config, path);
+}
+function writeProjectConfig(profile, projectDir) {
+  const config = generateProjectConfig(profile);
+  const path = join8(projectDir, "opencode.json");
+  writeConfig(config, path);
+}
+
+// src/core/agents-md-generator.ts
+import { existsSync as existsSync7, readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, cpSync as cpSync4 } from "fs";
+import { join as join9, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
+var TEMPLATES_DIR2 = join9(__dirname2, "templates/agents-md");
+var FRAMEWORK_TEMPLATE_MAP = {
+  nextjs: "frontend-ts.md",
+  react: "frontend-ts.md",
+  svelte: "frontend-ts.md",
+  vue: "frontend-ts.md",
+  go: "backend-go.md",
+  gin: "backend-go.md",
+  fastapi: "backend-python.md",
+  python: "backend-python.md",
+  django: "backend-python.md",
+  flask: "backend-python.md"
+};
+var DEFAULT_TEMPLATE = "base.md";
+function getTemplateForFramework(framework) {
+  const lowerFramework = framework.toLowerCase();
+  for (const [key, template] of Object.entries(FRAMEWORK_TEMPLATE_MAP)) {
+    if (lowerFramework.includes(key)) {
+      return template;
+    }
+  }
+  return DEFAULT_TEMPLATE;
+}
+function replaceVariables(content, profile) {
+  const projectName = "My Project";
+  const testRunner = profile.testRunner || "vitest";
+  const linter = profile.linter || "biome";
+  let result = content.replace(/\{\{projectName\}\}/g, projectName);
+  result = result.replace(/\{\{testRunner\}\}/g, testRunner);
+  result = result.replace(/\{\{linter\}\}/g, linter);
+  result = result.replace(/\{\{projectDescription\}\}/g, "This project...");
+  result = result.replace(/\{\{structure\}\}/g, "See project structure");
+  result = result.replace(/\{\{codeStandards\}\}/g, "Follow TypeScript best practices");
+  result = result.replace(/\{\{testingGuidelines\}\}/g, "Run tests with " + testRunner);
+  if (profile.migrationSource?.rules && profile.migrationSource.rules.length > 0) {
+    const rulesContent = profile.migrationSource.rules.join("\n");
+    if (!result.includes("## Rules")) {
+      result += "\n\n## Rules\n\n" + rulesContent;
+    }
+  }
+  return result;
+}
+function generateAgentsMD(profile) {
+  const templateName = getTemplateForFramework(profile.projectFramework);
+  const templatePath = join9(TEMPLATES_DIR2, templateName);
+  if (!existsSync7(templatePath)) {
+    const fallbackPath = join9(TEMPLATES_DIR2, DEFAULT_TEMPLATE);
+    if (!existsSync7(fallbackPath)) {
+      return "# " + (profile.projectFramework || "My Project") + "\n\nProject configuration.";
+    }
+    const fallbackContent = readFileSync5(fallbackPath, "utf-8");
+    return replaceVariables(fallbackContent, profile);
+  }
+  const content = readFileSync5(templatePath, "utf-8");
+  return replaceVariables(content, profile);
+}
+function backupFile3(path) {
+  if (existsSync7(path)) {
+    const backupPath = `${path}.bak`;
+    cpSync4(path, backupPath);
+  }
+}
+function writeAgentsMD(content, dir) {
+  const filePath = join9(dir, "AGENTS.md");
+  const dirPath = dirname4(filePath);
+  if (!existsSync7(dirPath)) {
+    mkdirSync4(dirPath, { recursive: true });
+  }
+  backupFile3(filePath);
+  writeFileSync4(filePath, content, "utf-8");
+}
+
+// src/core/command-generator.ts
+import { existsSync as existsSync8, readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, cpSync as cpSync5 } from "fs";
+import { join as join10, dirname as dirname5 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var __dirname3 = dirname5(fileURLToPath3(import.meta.url));
+var TEMPLATES_DIR3 = join10(__dirname3, "templates/commands");
+var DEFAULT_COMMANDS = ["test.md", "lint.md", "review.md", "plan.md"];
+function generateCommands() {
+  const commands = {};
+  for (const cmd of DEFAULT_COMMANDS) {
+    const cmdPath = join10(TEMPLATES_DIR3, cmd);
+    if (existsSync8(cmdPath)) {
+      commands[cmd] = readFileSync6(cmdPath, "utf-8");
+    }
+  }
+  return commands;
+}
+function backupFile4(path) {
+  if (existsSync8(path)) {
+    const backupPath = `${path}.bak`;
+    cpSync5(path, backupPath);
+  }
+}
+function writeCommands(commands, dir) {
+  const commandsDir = join10(dir, ".opencode", "commands");
+  if (!existsSync8(commandsDir)) {
+    mkdirSync5(commandsDir, { recursive: true });
+  }
+  for (const [filename, content] of Object.entries(commands)) {
+    const filePath = join10(commandsDir, filename);
+    backupFile4(filePath);
+    writeFileSync5(filePath, content, "utf-8");
+  }
+}
+
+// src/core/agent-generator.ts
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, cpSync as cpSync6 } from "fs";
+import { join as join11, dirname as dirname6 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+var __dirname4 = dirname6(fileURLToPath4(import.meta.url));
+var TEMPLATES_DIR4 = join11(__dirname4, "templates/agents");
+var DEFAULT_AGENTS = ["reviewer.md", "tester.md", "planner.md"];
+function generateAgents() {
+  const agents = {};
+  for (const agent of DEFAULT_AGENTS) {
+    const agentPath = join11(TEMPLATES_DIR4, agent);
+    if (existsSync9(agentPath)) {
+      agents[agent] = readFileSync7(agentPath, "utf-8");
+    }
+  }
+  return agents;
+}
+function backupFile5(path) {
+  if (existsSync9(path)) {
+    const backupPath = `${path}.bak`;
+    cpSync6(path, backupPath);
+  }
+}
+function writeAgents(agents, dir) {
+  const agentsDir = join11(dir, ".opencode", "agents");
+  if (!existsSync9(agentsDir)) {
+    mkdirSync6(agentsDir, { recursive: true });
+  }
+  for (const [filename, content] of Object.entries(agents)) {
+    const filePath = join11(agentsDir, filename);
+    backupFile5(filePath);
+    writeFileSync6(filePath, content, "utf-8");
+  }
+}
+
+// src/core/skill-generator.ts
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, cpSync as cpSync7 } from "fs";
+import { join as join12, dirname as dirname7 } from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __dirname5 = dirname7(fileURLToPath5(import.meta.url));
+var TEMPLATES_DIR5 = join12(__dirname5, "templates/skills");
+var BASE_SKILLS = ["code-review", "testing"];
+var FRONTEND_SKILL = "frontend-design";
+function generateSkills(profile) {
+  const skills = {};
+  const language = profile.projectLanguage?.toLowerCase() || "";
+  const isFrontend = ["typescript", "javascript"].includes(language) || profile.projectFramework?.toLowerCase().includes("react") || profile.projectFramework?.toLowerCase().includes("next");
+  const skillDirs = [...BASE_SKILLS];
+  if (isFrontend) {
+    skillDirs.push(FRONTEND_SKILL);
+  }
+  for (const skill of skillDirs) {
+    const skillDir = join12(TEMPLATES_DIR5, skill);
+    if (existsSync10(skillDir)) {
+      const files = [
+        { src: join12(skillDir, "SKILL.md"), dest: skill + "/SKILL.md" }
+      ];
+      for (const file of files) {
+        if (existsSync10(file.src)) {
+          skills[file.dest] = readFileSync8(file.src, "utf-8");
+        }
+      }
+    }
+  }
+  return skills;
+}
+function backupFile6(path) {
+  if (existsSync10(path)) {
+    const backupPath = `${path}.bak`;
+    cpSync7(path, backupPath);
+  }
+}
+function writeSkills(skills, dir) {
+  const skillsDir = join12(dir, ".opencode", "skills");
+  if (!existsSync10(skillsDir)) {
+    mkdirSync7(skillsDir, { recursive: true });
+  }
+  for (const [relativePath, content] of Object.entries(skills)) {
+    const skillSubDir = relativePath.split("/")[0];
+    const fileName = relativePath.split("/")[1] || "SKILL.md";
+    const skillDir = join12(skillsDir, skillSubDir);
+    const filePath = join12(skillDir, fileName);
+    if (!existsSync10(skillDir)) {
+      mkdirSync7(skillDir, { recursive: true });
+    }
+    backupFile6(filePath);
+    writeFileSync7(filePath, content, "utf-8");
+  }
+}
+
+// src/core/env-generator.ts
+import { writeFileSync as writeFileSync8 } from "fs";
+import { join as join13 } from "path";
+var PROVIDER_ENV_VARS = {
+  anthropic: { key: "ANTHROPIC_API_KEY", name: "Anthropic" },
+  google: { key: "GEMINI_API_KEY", name: "Google Gemini" },
+  openai: { key: "OPENAI_API_KEY", name: "OpenAI" },
+  deepseek: { key: "DEEPSEEK_API_KEY", name: "DeepSeek" },
+  openrouter: { key: "OPENROUTER_API_KEY", name: "OpenRouter" },
+  minimax: { key: "MINIMAX_API_KEY", name: "MiniMax" },
+  ollama: { key: "OLLAMA_BASE_URL", name: "Ollama" }
+};
+function generateEnvExample(profile) {
+  const lines = [
+    "# OpenCode Environment Variables",
+    "# Copy this file to .env and fill in your values",
+    ""
+  ];
+  for (const provider of profile.providers) {
+    const envConfig = PROVIDER_ENV_VARS[provider];
+    if (envConfig) {
+      lines.push(`# ${envConfig.name}`);
+      lines.push(`${envConfig.key}=your_key_here`);
+      lines.push("");
+    }
+  }
+  lines.push("# Optional: Custom OpenCode settings");
+  lines.push("# OPENCODE_CONFIG=/path/to/custom/config.json");
+  return lines.join("\n");
+}
+function writeEnvExample(content, dir) {
+  const filePath = join13(dir, ".env.example");
+  writeFileSync8(filePath, content, "utf-8");
+}
+
+export {
+  writeGlobalConfig,
+  writeProjectConfig,
+  generateAgentsMD,
+  writeAgentsMD,
+  generateCommands,
+  writeCommands,
+  generateAgents,
+  writeAgents,
+  generateSkills,
+  writeSkills,
+  generateEnvExample,
+  writeEnvExample,
+  listPresets,
+  applyPreset,
+  runValidation,
+  runAllChecks,
+  formatReport,
+  runMigration,
+  autoMigrate
+};