apero-kit-cli 2.4.7 → 2.5.0

package/dist/index.js

@@ -163,6 +163,17 @@ var init_kits = __esm({
 });
 
 // src/utils/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  CLI_ROOT: () => CLI_ROOT,
+  TARGETS: () => TARGETS,
+  TEMPLATES_DIR: () => TEMPLATES_DIR,
+  getEmbeddedTemplates: () => getEmbeddedTemplates,
+  getGlobalInstallPath: () => getGlobalInstallPath,
+  getTargetDir: () => getTargetDir,
+  isAkProject: () => isAkProject,
+  resolveSource: () => resolveSource
+});
 import { fileURLToPath } from "url";
 import { dirname, join, resolve } from "path";
 import { existsSync } from "fs";
@@ -257,643 +268,618 @@ var init_paths = __esm({
   }
 });
 
-// src/utils/copy.ts
+// src/targets/base-adapter.ts
 import fs from "fs-extra";
 import { join as join2, dirname as dirname2 } from "path";
-function parseFrontmatter(content) {
-  const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!frontmatterMatch) {
-    return { description: "", argumentHint: "", body: content };
-  }
-  const frontmatter = frontmatterMatch[1];
-  const body = frontmatterMatch[2].trim();
-  const descMatch = frontmatter.match(/description:\s*(.+)/);
-  const argMatch = frontmatter.match(/argument-hint:\s*(.+)/);
-  return {
-    description: descMatch ? descMatch[1].trim() : "",
-    argumentHint: argMatch ? argMatch[1].trim() : "",
-    body
-  };
-}
-function escapeTomlBasicString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
-}
-function convertMdToToml(mdContent) {
-  const { description, body } = parseFrontmatter(mdContent);
-  const prompt = body.replace(/\$ARGUMENTS/g, "{{args}}");
-  const lines = [];
-  if (description) {
-    lines.push(`description = "${escapeTomlBasicString(description)}"`);
-  }
-  lines.push(`prompt = '''
-${prompt}
-'''`);
-  return lines.join("\n");
-}
-async function copyItems(items, type, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, type);
-  const destTypeDir = join2(destDir, type);
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: items, errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  for (const item of items) {
-    try {
-      const itemPath = join2(typeDir, item);
-      const itemPathMd = itemPath + ".md";
-      let srcPath;
-      if (fs.existsSync(itemPath)) {
-        srcPath = itemPath;
-      } else if (fs.existsSync(itemPathMd)) {
-        srcPath = itemPathMd;
-      } else {
-        skipped.push(item);
-        continue;
-      }
-      const stat = fs.statSync(srcPath);
-      if (stat.isDirectory()) {
-        await fs.copy(srcPath, join2(destTypeDir, item), { overwrite: !mergeMode });
-      } else {
-        const destPath = srcPath.endsWith(".md") ? join2(destTypeDir, item + ".md") : join2(destTypeDir, item);
-        await fs.ensureDir(join2(destTypeDir, item.split("/").slice(0, -1).join("/")));
-        await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
+var BaseTargetAdapter;
+var init_base_adapter = __esm({
+  "src/targets/base-adapter.ts"() {
+    "use strict";
+    BaseTargetAdapter = class {
+      supports(feature) {
+        return this.config.features[feature];
+      }
+      getSupportedFeatures() {
+        return Object.entries(this.config.features).filter(([_, supported]) => supported).map(([feature]) => feature);
+      }
+      filterInstallItems(items) {
+        return {
+          agents: this.supports("agents") ? items.agents : [],
+          skills: this.supports("skills") ? items.skills : [],
+          commands: this.supports("commands") ? items.commands : [],
+          workflows: this.supports("workflows") ? items.workflows : [],
+          includeRouter: this.supports("router") && items.includeRouter,
+          includeHooks: this.supports("hooks") && items.includeHooks
+        };
+      }
+      /**
+       * Default: not supported - override in subclass if needed
+       */
+      async copyWorkflows(_items, _sourceDir, _targetDir, _mergeMode) {
+        return { copied: [], skipped: [], errors: [] };
+      }
+      async copyRouter(_sourceDir, _targetDir, _mergeMode) {
+        return { success: false, error: "Router not supported by this target" };
+      }
+      async copyHooks(_sourceDir, _targetDir, _mergeMode) {
+        return { success: false, error: "Hooks not supported by this target" };
+      }
+      async copyExtras(_sourceDir, _targetDir, _mergeMode) {
+        return [];
+      }
+      // Helper methods for common operations
+      async copyDirectory(dirName, sourceDir, destDir, mergeMode) {
+        const srcPath = join2(sourceDir, dirName);
+        if (!fs.existsSync(srcPath)) {
+          return { success: false, error: `${dirName} directory not found` };
+        }
+        try {
+          await fs.copy(srcPath, join2(destDir, dirName), { overwrite: !mergeMode });
+          return { success: true };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
       }
-      copied.push(item);
-    } catch (err) {
-      errors.push({ item, error: err.message });
-    }
-  }
-  return { copied, skipped, errors };
-}
-async function copyAllOfType(type, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, type);
-  const destTypeDir = join2(destDir, type);
-  if (!fs.existsSync(typeDir)) {
-    return { success: false, error: `${type} directory not found` };
-  }
-  try {
-    await fs.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
-    return { success: true };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-async function copyRouter(sourceDir, destDir, mergeMode = false) {
-  const routerDir = join2(sourceDir, "router");
-  if (!fs.existsSync(routerDir)) {
-    return { success: false, error: "Router directory not found" };
-  }
-  try {
-    await fs.copy(routerDir, join2(destDir, "router"), { overwrite: !mergeMode });
-    return { success: true };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-async function copyHooks(sourceDir, destDir, mergeMode = false) {
-  const hooksDir = join2(sourceDir, "hooks");
-  if (!fs.existsSync(hooksDir)) {
-    return { success: false, error: "Hooks directory not found" };
-  }
-  try {
-    await fs.copy(hooksDir, join2(destDir, "hooks"), { overwrite: !mergeMode });
-    return { success: true };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-async function copyBaseFiles(sourceDir, destDir, mergeMode = false) {
-  const baseFiles = ["README.md", "settings.json", ".env.example", "statusline.cjs", "statusline.ps1", "statusline.sh"];
-  const copied = [];
-  for (const file of baseFiles) {
-    const srcPath = join2(sourceDir, file);
-    const destPath = join2(destDir, file);
-    if (mergeMode && fs.existsSync(destPath)) {
-      continue;
-    }
-    if (fs.existsSync(srcPath)) {
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-      copied.push(file);
-    }
-  }
-  return copied;
-}
-async function copyDirectory(dirName, sourceDir, destDir, mergeMode = false) {
-  const srcPath = join2(sourceDir, dirName);
-  if (!fs.existsSync(srcPath)) {
-    return { success: false, error: `${dirName} directory not found` };
-  }
-  try {
-    await fs.copy(srcPath, join2(destDir, dirName), { overwrite: !mergeMode });
-    return { success: true };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-}
-async function copyAgentsMd(agentsMdPath, projectDir, mergeMode = false) {
-  if (!agentsMdPath || !fs.existsSync(agentsMdPath)) {
-    return false;
-  }
-  const destPath = join2(projectDir, "AGENTS.md");
-  if (mergeMode && fs.existsSync(destPath)) {
-    return false;
-  }
-  await fs.copy(agentsMdPath, destPath, { overwrite: !mergeMode });
-  return true;
-}
-function listAvailable(type, sourceDir) {
-  const typeDir = join2(sourceDir, type);
-  if (!fs.existsSync(typeDir)) {
-    return [];
-  }
-  const items = fs.readdirSync(typeDir);
-  return items.map((item) => {
-    const itemPath = join2(typeDir, item);
-    const isDir = fs.statSync(itemPath).isDirectory();
-    const name = item.replace(/\.md$/, "");
-    return { name, isDir, path: itemPath };
-  });
-}
-async function copyCommandsForGemini(items, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, "commands");
-  const destTypeDir = join2(destDir, "commands");
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: [], errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  let itemList;
-  if (items === "all") {
-    const entries = fs.readdirSync(typeDir);
-    itemList = entries.map((e) => e.replace(/\.md$/, ""));
-    itemList = [...new Set(itemList)];
-  } else {
-    itemList = items;
-  }
-  for (const item of itemList) {
-    try {
-      const srcPathMd = join2(typeDir, item + ".md");
-      const srcPathDir = join2(typeDir, item);
-      let copiedSomething = false;
-      if (fs.existsSync(srcPathMd) && fs.statSync(srcPathMd).isFile()) {
-        const destPath = join2(destTypeDir, item + ".toml");
-        if (!(mergeMode && fs.existsSync(destPath))) {
+      async copyFile(srcPath, destPath, mergeMode) {
+        if (mergeMode && fs.existsSync(destPath)) {
+          return false;
+        }
+        if (fs.existsSync(srcPath)) {
           await fs.ensureDir(dirname2(destPath));
-          const mdContent = fs.readFileSync(srcPathMd, "utf-8");
-          const tomlContent = convertMdToToml(mdContent);
-          await fs.writeFile(destPath, tomlContent, "utf-8");
-          copiedSomething = true;
+          await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
+          return true;
         }
+        return false;
       }
-      if (fs.existsSync(srcPathDir) && fs.statSync(srcPathDir).isDirectory()) {
-        await convertDirectoryToToml(srcPathDir, join2(destTypeDir, item), mergeMode);
-        copiedSomething = true;
+      async listItems(typeDir, extension) {
+        if (!fs.existsSync(typeDir)) {
+          return [];
+        }
+        const entries = fs.readdirSync(typeDir);
+        return entries.filter((e) => {
+          if (extension) {
+            return e.endsWith(extension) && e !== "README.md";
+          }
+          return e !== "README.md";
+        }).map((e) => extension ? e.replace(extension, "") : e);
       }
-      if (copiedSomething) {
-        copied.push(item);
-      } else {
-        skipped.push(item);
+      getItemList(items, typeDir, extension) {
+        if (items === "all") {
+          return this.listItemsSync(typeDir, extension);
+        }
+        return items;
       }
-    } catch (err) {
-      errors.push({ item, error: err.message });
-    }
+      listItemsSync(typeDir, extension) {
+        if (!fs.existsSync(typeDir)) {
+          return [];
+        }
+        const entries = fs.readdirSync(typeDir);
+        let result = entries.filter((e) => e !== "README.md");
+        if (extension) {
+          result = result.filter((e) => e.endsWith(extension)).map((e) => e.replace(extension, ""));
+        }
+        return [...new Set(result.map((e) => e.replace(/\.md$/, "")))];
+      }
+    };
   }
-  return { copied, skipped, errors };
-}
-async function convertDirectoryToToml(srcDir, destDir, mergeMode = false) {
-  await fs.ensureDir(destDir);
-  const entries = fs.readdirSync(srcDir);
-  for (const entry of entries) {
-    const srcPath = join2(srcDir, entry);
-    const stat = fs.statSync(srcPath);
-    if (stat.isDirectory()) {
-      await convertDirectoryToToml(srcPath, join2(destDir, entry), mergeMode);
-    } else if (entry.endsWith(".md")) {
-      const destPath = join2(destDir, entry.replace(/\.md$/, ".toml"));
-      if (mergeMode && fs.existsSync(destPath)) {
-        continue;
+});
+
+// src/targets/claude-adapter.ts
+import fs2 from "fs-extra";
+import { join as join3 } from "path";
+var ClaudeAdapter;
+var init_claude_adapter = __esm({
+  "src/targets/claude-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    ClaudeAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "claude",
+        displayName: "Claude Code",
+        directory: ".claude",
+        features: {
+          agents: true,
+          skills: true,
+          commands: true,
+          workflows: true,
+          router: true,
+          hooks: true,
+          memory: true,
+          scripts: true,
+          "output-styles": true
+        }
+      };
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "agents");
+        const destTypeDir = join3(targetDir, "agents");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir).filter((e) => e.endsWith(".md") && e !== "README.md");
+          return { copied: entries.map((e) => e.replace(".md", "")), skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const agent of items) {
+          try {
+            const srcPath = join3(typeDir, agent + ".md");
+            if (!fs2.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const destPath = join3(destTypeDir, agent + ".md");
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(agent);
+          } catch (err) {
+            errors.push({ item: agent, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-      const mdContent = fs.readFileSync(srcPath, "utf-8");
-      const tomlContent = convertMdToToml(mdContent);
-      await fs.writeFile(destPath, tomlContent, "utf-8");
-    } else {
-      const destPath = join2(destDir, entry);
-      if (mergeMode && fs.existsSync(destPath)) {
-        continue;
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "skills");
+        const destTypeDir = join3(targetDir, "skills");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir).filter((e) => {
+            const fullPath = join3(typeDir, e);
+            return fs2.statSync(fullPath).isDirectory() && fs2.existsSync(join3(fullPath, "SKILL.md"));
+          });
+          return { copied: entries, skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of items) {
+          try {
+            const srcPath = join3(typeDir, skill);
+            if (!fs2.existsSync(srcPath) || !fs2.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
+              continue;
+            }
+            if (!fs2.existsSync(join3(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
+              continue;
+            }
+            const destPath = join3(destTypeDir, skill);
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-    }
-  }
-}
-function convertAgentForGemini(mdContent) {
-  const frontmatterMatch = mdContent.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!frontmatterMatch) return mdContent;
-  let frontmatter = frontmatterMatch[1];
-  const body = frontmatterMatch[2];
-  const modelMap = {
-    "opus": "gemini-2.5-pro",
-    "sonnet": "gemini-2.5-flash",
-    "haiku": "gemini-2.0-flash-lite",
-    "inherit": ""
-    // Remove inherit, let Gemini use default
-  };
-  for (const [claudeModel, geminiModel] of Object.entries(modelMap)) {
-    const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
-    if (geminiModel) {
-      frontmatter = frontmatter.replace(regex, `model: ${geminiModel}`);
-    } else {
-      frontmatter = frontmatter.replace(regex, "");
-    }
-  }
-  frontmatter = frontmatter.replace(/^tools:\s*.+$/m, "");
-  if (!frontmatter.includes("kind:")) {
-    frontmatter = frontmatter.trim() + "\nkind: local";
-  }
-  return `---
-${frontmatter.trim()}
----
-${body}`;
-}
-async function copyAgentsForGemini(items, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, "agents");
-  const destTypeDir = join2(destDir, "agents");
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: [], errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  let agentList;
-  if (items === "all") {
-    const entries = fs.readdirSync(typeDir);
-    agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(/\.md$/, ""));
-  } else {
-    agentList = items;
-  }
-  for (const agent of agentList) {
-    try {
-      const srcPath = join2(typeDir, agent + ".md");
-      if (!fs.existsSync(srcPath)) {
-        skipped.push(agent);
-        continue;
+      async copyCommands(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "commands");
+        const destTypeDir = join3(targetDir, "commands");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir);
+          return { copied: [...new Set(entries.map((e) => e.replace(".md", "")))], skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const item of items) {
+          try {
+            const itemPath = join3(typeDir, item);
+            const itemPathMd = itemPath + ".md";
+            let srcPath = null;
+            if (fs2.existsSync(itemPath)) {
+              srcPath = itemPath;
+            } else if (fs2.existsSync(itemPathMd)) {
+              srcPath = itemPathMd;
+            }
+            if (!srcPath) {
+              skipped.push(item);
+              continue;
+            }
+            const stat = fs2.statSync(srcPath);
+            const destPath = stat.isDirectory() ? join3(destTypeDir, item) : join3(destTypeDir, item + ".md");
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(item);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(item);
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-      const destPath = join2(destTypeDir, agent + ".md");
-      if (mergeMode && fs.existsSync(destPath)) {
-        skipped.push(agent);
-        continue;
+      async copyWorkflows(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join3(sourceDir, "workflows");
+        const destTypeDir = join3(targetDir, "workflows");
+        if (!fs2.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs2.ensureDir(destTypeDir);
+        if (items === "all") {
+          await fs2.copy(typeDir, destTypeDir, { overwrite: !mergeMode });
+          const entries = fs2.readdirSync(typeDir);
+          return { copied: entries.map((e) => e.replace(".md", "")), skipped: [], errors: [] };
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const item of items) {
+          try {
+            const srcPath = join3(typeDir, item + ".md");
+            if (!fs2.existsSync(srcPath)) {
+              skipped.push(item);
+              continue;
+            }
+            const destPath = join3(destTypeDir, item + ".md");
+            if (mergeMode && fs2.existsSync(destPath)) {
+              skipped.push(item);
+              continue;
+            }
+            await fs2.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(item);
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-      const mdContent = fs.readFileSync(srcPath, "utf-8");
-      const convertedContent = convertAgentForGemini(mdContent);
-      await fs.writeFile(destPath, convertedContent, "utf-8");
-      copied.push(agent);
-    } catch (err) {
-      errors.push({ item: agent, error: err.message });
-    }
-  }
-  return { copied, skipped, errors };
-}
-async function copySkillsForGemini(items, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, "skills");
-  const destTypeDir = join2(destDir, "skills");
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: [], errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  let skillList;
-  if (items === "all") {
-    const entries = fs.readdirSync(typeDir);
-    skillList = entries.filter((e) => {
-      const fullPath = join2(typeDir, e);
-      return fs.statSync(fullPath).isDirectory() && fs.existsSync(join2(fullPath, "SKILL.md"));
-    });
-  } else {
-    skillList = items;
-  }
-  for (const skill of skillList) {
-    try {
-      const srcPath = join2(typeDir, skill);
-      if (!fs.existsSync(srcPath) || !fs.statSync(srcPath).isDirectory()) {
-        skipped.push(skill);
-        continue;
+      async copyRouter(sourceDir, targetDir, mergeMode) {
+        return this.copyDirectory("router", sourceDir, targetDir, mergeMode);
       }
-      const skillMdPath = join2(srcPath, "SKILL.md");
-      if (!fs.existsSync(skillMdPath)) {
-        skipped.push(skill);
-        continue;
+      async copyHooks(sourceDir, targetDir, mergeMode) {
+        return this.copyDirectory("hooks", sourceDir, targetDir, mergeMode);
       }
-      const destPath = join2(destTypeDir, skill);
-      if (mergeMode && fs.existsSync(destPath)) {
-        skipped.push(skill);
-        continue;
+      async copyExtras(sourceDir, targetDir, mergeMode) {
+        const extras = ["memory", "output-styles", "scripts"];
+        const copied = [];
+        for (const extra of extras) {
+          const result = await this.copyDirectory(extra, sourceDir, targetDir, mergeMode);
+          if (result.success) {
+            copied.push(extra);
+          }
+        }
+        return copied;
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const sourceDir = join3(CLI_ROOT2, "templates");
+        const baseFiles = ["README.md", "settings.json", ".env.example", "statusline.cjs", "statusline.ps1", "statusline.sh"];
+        const copied = [];
+        for (const file of baseFiles) {
+          const srcPath = join3(sourceDir, file);
+          const destPath = join3(targetDir, file);
+          if (await this.copyFile(srcPath, destPath, mergeMode)) {
+            copied.push(file);
+          }
+        }
+        return copied;
       }
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-      copied.push(skill);
-    } catch (err) {
-      errors.push({ skill, error: err.message });
-    }
+    };
   }
-  return { copied, skipped, errors };
-}
-async function copyGeminiBaseFiles(destDir, mergeMode = false) {
-  const geminiTemplates = join2(CLI_ROOT, "templates", "gemini");
-  const copied = [];
-  const settingsPath = join2(geminiTemplates, "settings.json");
-  const destSettingsPath = join2(destDir, "settings.json");
-  if (fs.existsSync(settingsPath)) {
-    if (mergeMode && fs.existsSync(destSettingsPath)) {
-      return copied;
-    }
-    await fs.copy(settingsPath, destSettingsPath, { overwrite: !mergeMode });
-    copied.push("settings.json");
+});
+
+// src/targets/gemini-adapter.ts
+import fs3 from "fs-extra";
+import { join as join4, dirname as dirname3 } from "path";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: "", body: content };
   }
-  return copied;
+  return { frontmatter: match[1], body: match[2] };
 }
-function convertCommandForDiscord(mdContent, commandName) {
-  const { description, body } = parseFrontmatter(mdContent);
-  const prompt = body.replace(/\$ARGUMENTS/g, "{{args}}");
-  return {
-    name: commandName,
-    description: description || `Execute ${commandName} command`,
-    prompt
-  };
+function escapeTomlString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
 }
-function convertAgentForDiscord(mdContent) {
-  const frontmatterMatch = mdContent.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!frontmatterMatch) return mdContent;
-  let frontmatter = frontmatterMatch[1];
-  const body = frontmatterMatch[2];
-  const modelMap = {
-    "opus": "claude-3-opus",
-    "sonnet": "claude-3-sonnet",
-    "haiku": "claude-3-haiku",
-    "inherit": ""
-    // Remove inherit
-  };
-  for (const [claudeModel, discordModel] of Object.entries(modelMap)) {
+function convertAgentToGemini(mdContent) {
+  const { frontmatter, body } = parseFrontmatter(mdContent);
+  if (!frontmatter) return mdContent;
+  let converted = frontmatter;
+  for (const [claudeModel, geminiModel] of Object.entries(MODEL_MAP)) {
     const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
-    if (discordModel) {
-      frontmatter = frontmatter.replace(regex, `model: ${discordModel}`);
+    if (geminiModel) {
+      converted = converted.replace(regex, `model: ${geminiModel}`);
     } else {
-      frontmatter = frontmatter.replace(regex, "");
+      converted = converted.replace(regex, "");
     }
   }
-  frontmatter = frontmatter.replace(/^tools:\s*.+$/m, "");
-  if (!frontmatter.includes("kind:")) {
-    frontmatter = frontmatter.trim() + "\nkind: local";
+  converted = converted.replace(/^tools:\s*.+$/m, "");
+  if (!converted.includes("kind:")) {
+    converted = converted.trim() + "\nkind: local";
   }
   return `---
-${frontmatter.trim()}
+${converted.trim()}
 ---
 ${body}`;
 }
-async function copyAgentsForDiscord(items, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, "agents");
-  const destTypeDir = join2(destDir, "agents");
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: [], errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  let agentList;
-  if (items === "all") {
-    const entries = fs.readdirSync(typeDir);
-    agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(/\.md$/, ""));
-  } else {
-    agentList = items;
-  }
-  for (const agent of agentList) {
-    try {
-      const srcPath = join2(typeDir, agent + ".md");
-      if (!fs.existsSync(srcPath)) {
-        skipped.push(agent);
-        continue;
-      }
-      const destPath = join2(destTypeDir, agent + ".md");
-      if (mergeMode && fs.existsSync(destPath)) {
-        skipped.push(agent);
-        continue;
-      }
-      const mdContent = fs.readFileSync(srcPath, "utf-8");
-      const convertedContent = convertAgentForDiscord(mdContent);
-      await fs.writeFile(destPath, convertedContent, "utf-8");
-      copied.push(agent);
-    } catch (err) {
-      errors.push({ item: agent, error: err.message });
-    }
-  }
-  return { copied, skipped, errors };
-}
-async function copyCommandsForDiscord(items, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, "commands");
-  const destTypeDir = join2(destDir, "commands");
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: [], errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  const commandsConfig = {};
-  let itemList;
-  if (items === "all") {
-    const entries = fs.readdirSync(typeDir);
-    itemList = entries.map((e) => e.replace(/\.md$/, ""));
-    itemList = [...new Set(itemList)];
-  } else {
-    itemList = items;
-  }
-  for (const item of itemList) {
-    try {
-      const srcPathMd = join2(typeDir, item + ".md");
-      const srcPathDir = join2(typeDir, item);
-      let copiedSomething = false;
-      if (fs.existsSync(srcPathMd) && fs.statSync(srcPathMd).isFile()) {
-        const destPath = join2(destTypeDir, item + ".md");
-        if (!(mergeMode && fs.existsSync(destPath))) {
-          await fs.ensureDir(dirname2(destPath));
-          const mdContent = fs.readFileSync(srcPathMd, "utf-8");
-          await fs.copy(srcPathMd, destPath, { overwrite: !mergeMode });
-          const cmd = convertCommandForDiscord(mdContent, item);
-          commandsConfig[item] = {
-            description: cmd.description,
-            prompt: cmd.prompt
-          };
-          copiedSomething = true;
-        }
-      }
-      if (fs.existsSync(srcPathDir) && fs.statSync(srcPathDir).isDirectory()) {
-        await copyDirectoryForDiscord(srcPathDir, join2(destTypeDir, item), mergeMode, commandsConfig, item);
-        copiedSomething = true;
-      }
-      if (copiedSomething) {
-        copied.push(item);
-      } else {
-        skipped.push(item);
-      }
-    } catch (err) {
-      errors.push({ item, error: err.message });
-    }
-  }
-  const configPath = join2(destDir, "commands.json5");
-  if (Object.keys(commandsConfig).length > 0 && !(mergeMode && fs.existsSync(configPath))) {
-    const json5Content = generateCommandsJson5(commandsConfig);
-    await fs.writeFile(configPath, json5Content, "utf-8");
+function convertCommandToToml(mdContent) {
+  const { frontmatter, body } = parseFrontmatter(mdContent);
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  const description = descMatch ? descMatch[1].trim() : "";
+  const prompt = body.trim().replace(/\$ARGUMENTS/g, "{{args}}");
+  const lines = [];
+  if (description) {
+    lines.push(`description = "${escapeTomlString(description)}"`);
   }
-  return { copied, skipped, errors };
+  lines.push(`prompt = '''
+${prompt}
+'''`);
+  return lines.join("\n");
 }
-async function copyDirectoryForDiscord(srcDir, destDir, mergeMode, commandsConfig, parentName) {
-  await fs.ensureDir(destDir);
-  const entries = fs.readdirSync(srcDir);
-  for (const entry of entries) {
-    const srcPath = join2(srcDir, entry);
-    const stat = fs.statSync(srcPath);
-    if (stat.isDirectory()) {
-      await copyDirectoryForDiscord(
-        srcPath,
-        join2(destDir, entry),
-        mergeMode,
-        commandsConfig,
-        `${parentName}/${entry}`
-      );
-    } else if (entry.endsWith(".md")) {
-      const destPath = join2(destDir, entry);
-      if (mergeMode && fs.existsSync(destPath)) {
-        continue;
-      }
-      const mdContent = fs.readFileSync(srcPath, "utf-8");
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-      const cmdName = `${parentName}/${entry.replace(/\.md$/, "")}`;
-      const cmd = convertCommandForDiscord(mdContent, cmdName);
-      commandsConfig[cmdName] = {
-        description: cmd.description,
-        prompt: cmd.prompt
+var MODEL_MAP, GeminiAdapter;
+var init_gemini_adapter = __esm({
+  "src/targets/gemini-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    MODEL_MAP = {
+      "opus": "gemini-2.5-pro",
+      "sonnet": "gemini-2.5-flash",
+      "haiku": "gemini-2.0-flash-lite",
+      "inherit": ""
+      // Remove inherit, let Gemini use default
+    };
+    GeminiAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "gemini",
+        displayName: "Gemini CLI",
+        directory: ".gemini",
+        features: {
+          agents: true,
+          skills: true,
+          commands: true,
+          workflows: false,
+          router: false,
+          hooks: false,
+          memory: false,
+          scripts: false,
+          "output-styles": false
+        }
       };
-    } else {
-      const destPath = join2(destDir, entry);
-      if (mergeMode && fs.existsSync(destPath)) {
-        continue;
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join4(sourceDir, "agents");
+        const destTypeDir = join4(targetDir, "agents");
+        if (!fs3.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs3.ensureDir(destTypeDir);
+        let agentList;
+        if (items === "all") {
+          const entries = fs3.readdirSync(typeDir);
+          agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
+        } else {
+          agentList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const agent of agentList) {
+          try {
+            const srcPath = join4(typeDir, agent + ".md");
+            if (!fs3.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const destPath = join4(destTypeDir, agent + ".md");
+            if (mergeMode && fs3.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const mdContent = fs3.readFileSync(srcPath, "utf-8");
+            const convertedContent = convertAgentToGemini(mdContent);
+            await fs3.writeFile(destPath, convertedContent, "utf-8");
+            copied.push(agent);
+          } catch (err) {
+            errors.push({ item: agent, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-    }
-  }
-}
-function generateCommandsJson5(commands) {
-  const lines = [
-    "// Clawbot Commands Configuration",
-    "// Generated by Apero Kit CLI",
-    "// These commands can be used as slash commands in Discord",
-    "{",
-    '  "commands": {'
-  ];
-  const cmdEntries = Object.entries(commands);
-  cmdEntries.forEach(([name, cmd], index) => {
-    const safeName = name.replace(/\//g, ":");
-    const isLast = index === cmdEntries.length - 1;
-    lines.push(`    "${safeName}": {`);
-    lines.push(`      "description": ${JSON.stringify(cmd.description)},`);
-    lines.push(`      "prompt": ${JSON.stringify(cmd.prompt)}`);
-    lines.push(`    }${isLast ? "" : ","}`);
-  });
-  lines.push("  }");
-  lines.push("}");
-  return lines.join("\n");
-}
-async function copySkillsForDiscord(items, sourceDir, destDir, mergeMode = false) {
-  return copySkillsForGemini(items, sourceDir, destDir, mergeMode);
-}
-async function copyDiscordBaseFiles(destDir, mergeMode = false) {
-  const discordTemplates = join2(CLI_ROOT, "templates", "discord");
-  const copied = [];
-  const filesToCopy = ["config.json5", "README.md"];
-  for (const file of filesToCopy) {
-    const srcPath = join2(discordTemplates, file);
-    const destPath = join2(destDir, file);
-    if (fs.existsSync(srcPath)) {
-      if (mergeMode && fs.existsSync(destPath)) {
-        continue;
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join4(sourceDir, "skills");
+        const destTypeDir = join4(targetDir, "skills");
+        if (!fs3.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs3.ensureDir(destTypeDir);
+        let skillList;
+        if (items === "all") {
+          const entries = fs3.readdirSync(typeDir);
+          skillList = entries.filter((e) => {
+            const fullPath = join4(typeDir, e);
+            return fs3.statSync(fullPath).isDirectory() && fs3.existsSync(join4(fullPath, "SKILL.md"));
+          });
+        } else {
+          skillList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of skillList) {
+          try {
+            const srcPath = join4(typeDir, skill);
+            if (!fs3.existsSync(srcPath) || !fs3.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
+              continue;
+            }
+            if (!fs3.existsSync(join4(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
+              continue;
+            }
+            const destPath = join4(destTypeDir, skill);
+            if (mergeMode && fs3.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs3.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-      copied.push(file);
-    }
-  }
-  return copied;
-}
-async function updateDiscordConfig(destDir, token, guildId) {
-  const configPath = join2(destDir, "config.json5");
-  if (!fs.existsSync(configPath)) {
-    return;
-  }
-  let content = await fs.readFile(configPath, "utf-8");
-  content = content.replace(
-    '"token": "${DISCORD_BOT_TOKEN}"',
-    `"token": "${token}"`
-  );
-  if (guildId) {
-    const guildConfig = `"${guildId}": {
-          "requireMention": true,
-          "users": [],
-          "roles": [],
-          "channels": {}
-        }`;
-    content = content.replace(
-      '"guilds": {\n        // Example guild configuration',
-      `"guilds": {
-        ${guildConfig},
-        // Example guild configuration`
-    );
+      async copyCommands(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join4(sourceDir, "commands");
+        const destTypeDir = join4(targetDir, "commands");
+        if (!fs3.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs3.ensureDir(destTypeDir);
+        let itemList;
+        if (items === "all") {
+          const entries = fs3.readdirSync(typeDir);
+          itemList = [...new Set(entries.map((e) => e.replace(".md", "")))];
+        } else {
+          itemList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const item of itemList) {
+          try {
+            const srcPathMd = join4(typeDir, item + ".md");
+            const srcPathDir = join4(typeDir, item);
+            let copiedSomething = false;
+            if (fs3.existsSync(srcPathMd) && fs3.statSync(srcPathMd).isFile()) {
+              const destPath = join4(destTypeDir, item + ".toml");
+              if (!(mergeMode && fs3.existsSync(destPath))) {
+                await fs3.ensureDir(dirname3(destPath));
+                const mdContent = fs3.readFileSync(srcPathMd, "utf-8");
+                const tomlContent = convertCommandToToml(mdContent);
+                await fs3.writeFile(destPath, tomlContent, "utf-8");
+                copiedSomething = true;
+              }
+            }
+            if (fs3.existsSync(srcPathDir) && fs3.statSync(srcPathDir).isDirectory()) {
+              await this.convertDirectoryToToml(srcPathDir, join4(destTypeDir, item), mergeMode);
+              copiedSomething = true;
+            }
+            if (copiedSomething) {
+              copied.push(item);
+            } else {
+              skipped.push(item);
+            }
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
+      }
+      async convertDirectoryToToml(srcDir, destDir, mergeMode) {
+        await fs3.ensureDir(destDir);
+        const entries = fs3.readdirSync(srcDir);
+        for (const entry of entries) {
+          const srcPath = join4(srcDir, entry);
+          const stat = fs3.statSync(srcPath);
+          if (stat.isDirectory()) {
+            await this.convertDirectoryToToml(srcPath, join4(destDir, entry), mergeMode);
+          } else if (entry.endsWith(".md")) {
+            const destPath = join4(destDir, entry.replace(".md", ".toml"));
+            if (mergeMode && fs3.existsSync(destPath)) {
+              continue;
+            }
+            const mdContent = fs3.readFileSync(srcPath, "utf-8");
+            const tomlContent = convertCommandToToml(mdContent);
+            await fs3.writeFile(destPath, tomlContent, "utf-8");
+          } else {
+            const destPath = join4(destDir, entry);
+            if (mergeMode && fs3.existsSync(destPath)) {
+              continue;
+            }
+            await fs3.copy(srcPath, destPath, { overwrite: !mergeMode });
+          }
+        }
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const geminiTemplates = join4(CLI_ROOT2, "templates", "gemini");
+        const copied = [];
+        const settingsPath = join4(geminiTemplates, "settings.json");
+        const destSettingsPath = join4(targetDir, "settings.json");
+        if (fs3.existsSync(settingsPath)) {
+          if (!(mergeMode && fs3.existsSync(destSettingsPath))) {
+            await fs3.copy(settingsPath, destSettingsPath, { overwrite: !mergeMode });
+            copied.push("settings.json");
+          }
+        }
+        return copied;
+      }
+    };
   }
-  await fs.writeFile(configPath, content, "utf-8");
+});
+
+// src/targets/discord-adapter.ts
+import fs4 from "fs-extra";
+import { join as join5, dirname as dirname4 } from "path";
+function parseFrontmatter2(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: "", body: content, description: "", argumentHint: "" };
+  }
+  const frontmatter = match[1];
+  const body = match[2].trim();
+  const descMatch = frontmatter.match(/description:\s*(.+)/);
+  const argMatch = frontmatter.match(/argument-hint:\s*(.+)/);
+  return {
+    frontmatter,
+    body,
+    description: descMatch ? descMatch[1].trim() : "",
+    argumentHint: argMatch ? argMatch[1].trim() : ""
+  };
 }
-async function setupOpenClawConfig(token) {
-  const { execSync: execSync3 } = await import("child_process");
-  try {
-    execSync3("which openclaw", { stdio: "ignore" });
-  } catch {
-    return { success: false, message: "OpenClaw CLI not installed. Run: npm install -g openclaw" };
+function convertAgentToDiscord(mdContent) {
+  const { frontmatter, body } = parseFrontmatter2(mdContent);
+  if (!frontmatter) return mdContent;
+  let converted = frontmatter;
+  for (const [claudeModel, discordModel] of Object.entries(MODEL_MAP2)) {
+    const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
+    if (discordModel) {
+      converted = converted.replace(regex, `model: ${discordModel}`);
+    } else {
+      converted = converted.replace(regex, "");
+    }
   }
-  try {
-    execSync3(`openclaw config set channels.discord.token '"${token}"' --json`, { stdio: "ignore" });
-    execSync3("openclaw config set channels.discord.enabled true --json", { stdio: "ignore" });
-    execSync3("openclaw config set gateway.mode local", { stdio: "ignore" });
-    return { success: true, message: "OpenClaw configured successfully!" };
-  } catch (error) {
-    return { success: false, message: `Failed to configure OpenClaw: ${error.message}` };
+  converted = converted.replace(/^tools:\s*.+$/m, "");
+  if (!converted.includes("kind:")) {
+    converted = converted.trim() + "\nkind: local";
   }
+  return `---
+${converted.trim()}
+---
+${body}`;
 }
 function extractKeywords(content, commandName) {
   const keywords = /* @__PURE__ */ new Set();
   keywords.add(commandName);
   keywords.add(commandName.replace(/-/g, " "));
-  const keywordPatterns = [
-    /keywords?:\s*([^\n]+)/gi,
-    /when.*(?:says?|mentions?|asks?).*["']([^"']+)["']/gi,
-    /trigger.*["']([^"']+)["']/gi
-  ];
-  for (const pattern of keywordPatterns) {
-    const matches = content.matchAll(pattern);
-    for (const match of matches) {
-      match[1].split(/[,;]/).forEach((k) => keywords.add(k.trim().toLowerCase()));
-    }
-  }
   const intentMap = {
     "plan": ["plan", "design", "architect", "implement", "create plan"],
-    "brainstorm": ["brainstorm", "ideas", "options", "alternatives", "think"],
+    "brainstorm": ["brainstorm", "ideas", "options", "alternatives"],
     "fix": ["fix", "debug", "error", "broken", "issue", "bug"],
     "code": ["code", "implement", "build", "develop", "write code"],
     "review": ["review", "check", "audit", "look at"],
     "test": ["test", "testing", "spec", "unit test"],
-    "cook": ["cook", "implement", "build feature", "develop"],
     "scout": ["scout", "search", "find", "explore codebase"],
     "debug": ["debug", "trace", "diagnose", "investigate"]
   };
@@ -904,10 +890,10 @@ function extractKeywords(content, commandName) {
   return Array.from(keywords).slice(0, 10);
 }
 function convertCommandToSkill(mdContent, commandName) {
-  const { description, argumentHint, body } = parseFrontmatter(mdContent);
+  const { description, argumentHint, body } = parseFrontmatter2(mdContent);
   const prompt = body.replace(/\$ARGUMENTS/g, "{{args}}");
   const keywords = extractKeywords(body, commandName);
-  const skillContent = `---
+  return `---
 name: ${commandName.replace(/\//g, "-")}
 description: ${description || `Execute ${commandName} task`}
 user-invocable: true
@@ -933,131 +919,394 @@ ${prompt}
 
 Provide clear, actionable response based on the workflow above.
 `;
-  return skillContent;
 }
-async function convertCommandsToSkills(items, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join2(sourceDir, "commands");
-  const destTypeDir = join2(destDir, "skills");
-  if (!fs.existsSync(typeDir)) {
-    return { copied: [], skipped: [], errors: [] };
-  }
-  await fs.ensureDir(destTypeDir);
-  const copied = [];
-  const skipped = [];
-  const errors = [];
-  let itemList;
-  if (items === "all") {
-    const entries = fs.readdirSync(typeDir);
-    itemList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(/\.md$/, ""));
-    const dirs = entries.filter((e) => {
-      const fullPath = join2(typeDir, e);
-      return fs.statSync(fullPath).isDirectory();
-    });
-    itemList = [.../* @__PURE__ */ new Set([...itemList, ...dirs])];
-  } else {
-    itemList = items;
-  }
-  for (const item of itemList) {
-    try {
-      const srcPathMd = join2(typeDir, item + ".md");
-      const srcPathDir = join2(typeDir, item);
-      if (fs.existsSync(srcPathMd) && fs.statSync(srcPathMd).isFile()) {
-        const skillDir = join2(destTypeDir, item.replace(/\//g, "-"));
-        const skillPath = join2(skillDir, "SKILL.md");
-        if (mergeMode && fs.existsSync(skillPath)) {
-          skipped.push(item);
-          continue;
-        }
-        await fs.ensureDir(skillDir);
-        const mdContent = fs.readFileSync(srcPathMd, "utf-8");
-        const skillContent = convertCommandToSkill(mdContent, item);
-        await fs.writeFile(skillPath, skillContent, "utf-8");
-        copied.push(item);
-      }
-      if (fs.existsSync(srcPathDir) && fs.statSync(srcPathDir).isDirectory()) {
-        await convertNestedCommandsToSkills(srcPathDir, destTypeDir, item, mergeMode);
-        copied.push(item + "/*");
+var MODEL_MAP2, DiscordAdapter;
+var init_discord_adapter = __esm({
+  "src/targets/discord-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    MODEL_MAP2 = {
+      "opus": "claude-3-opus",
+      "sonnet": "claude-3-sonnet",
+      "haiku": "claude-3-haiku",
+      "inherit": ""
+    };
+    DiscordAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "discord",
+        displayName: "Discord + OpenClaw",
+        directory: ".discord",
+        features: {
+          agents: true,
+          skills: true,
+          commands: true,
+          workflows: false,
+          router: false,
+          hooks: false,
+          memory: false,
+          scripts: false,
+          "output-styles": false
+        }
+      };
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "agents");
+        const destTypeDir = join5(targetDir, "agents");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        let agentList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
+        } else {
+          agentList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const agent of agentList) {
+          try {
+            const srcPath = join5(typeDir, agent + ".md");
+            if (!fs4.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const destPath = join5(destTypeDir, agent + ".md");
+            if (mergeMode && fs4.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
+            }
+            const mdContent = fs4.readFileSync(srcPath, "utf-8");
+            const convertedContent = convertAgentToDiscord(mdContent);
+            await fs4.writeFile(destPath, convertedContent, "utf-8");
+            copied.push(agent);
+          } catch (err) {
+            errors.push({ item: agent, error: err.message });
+          }
+        }
+        return { copied, skipped, errors };
       }
-    } catch (err) {
-      errors.push({ item, error: err.message });
-    }
-  }
-  return { copied, skipped, errors };
-}
-async function convertNestedCommandsToSkills(srcDir, destDir, parentName, mergeMode) {
-  const entries = fs.readdirSync(srcDir);
-  for (const entry of entries) {
-    const srcPath = join2(srcDir, entry);
-    const stat = fs.statSync(srcPath);
-    if (stat.isDirectory()) {
-      await convertNestedCommandsToSkills(
-        srcPath,
-        destDir,
-        `${parentName}-${entry}`,
-        mergeMode
-      );
-    } else if (entry.endsWith(".md") && entry !== "README.md") {
-      const skillName = `${parentName}-${entry.replace(/\.md$/, "")}`;
-      const skillDir = join2(destDir, skillName);
-      const skillPath = join2(skillDir, "SKILL.md");
-      if (mergeMode && fs.existsSync(skillPath)) {
-        continue;
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "skills");
+        const destTypeDir = join5(targetDir, "skills");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        let skillList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          skillList = entries.filter((e) => {
+            const fullPath = join5(typeDir, e);
+            return fs4.statSync(fullPath).isDirectory() && fs4.existsSync(join5(fullPath, "SKILL.md"));
+          });
+        } else {
+          skillList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of skillList) {
+          try {
+            const srcPath = join5(typeDir, skill);
+            if (!fs4.existsSync(srcPath) || !fs4.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
+              continue;
+            }
+            if (!fs4.existsSync(join5(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
+              continue;
+            }
+            const destPath = join5(destTypeDir, skill);
+            if (mergeMode && fs4.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
+          }
+        }
+        const bundledCopied = await this.copyBundledSkills(targetDir, mergeMode);
+        copied.push(...bundledCopied);
+        return { copied, skipped, errors };
+      }
+      async copyCommands(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "commands");
+        const destTypeDir = join5(targetDir, "commands");
+        const destSkillsDir = join5(targetDir, "skills");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        await fs4.ensureDir(destSkillsDir);
+        let itemList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          itemList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
+          const dirs = entries.filter((e) => {
+            const fullPath = join5(typeDir, e);
+            return fs4.statSync(fullPath).isDirectory();
+          });
+          itemList = [.../* @__PURE__ */ new Set([...itemList, ...dirs])];
+        } else {
+          itemList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        const commandsConfig = {};
+        for (const item of itemList) {
+          try {
+            const srcPathMd = join5(typeDir, item + ".md");
+            const srcPathDir = join5(typeDir, item);
+            if (fs4.existsSync(srcPathMd) && fs4.statSync(srcPathMd).isFile()) {
+              const destPath = join5(destTypeDir, item + ".md");
+              const skillDir = join5(destSkillsDir, item.replace(/\//g, "-"));
+              const skillPath = join5(skillDir, "SKILL.md");
+              if (!(mergeMode && fs4.existsSync(destPath))) {
+                await fs4.ensureDir(dirname4(destPath));
+                const mdContent = fs4.readFileSync(srcPathMd, "utf-8");
+                await fs4.copy(srcPathMd, destPath, { overwrite: !mergeMode });
+                if (!(mergeMode && fs4.existsSync(skillPath))) {
+                  await fs4.ensureDir(skillDir);
+                  const skillContent = convertCommandToSkill(mdContent, item);
+                  await fs4.writeFile(skillPath, skillContent, "utf-8");
+                }
+                const { description, body } = parseFrontmatter2(mdContent);
+                commandsConfig[item] = {
+                  description: description || `Execute ${item} command`,
+                  prompt: body.replace(/\$ARGUMENTS/g, "{{args}}")
+                };
+                copied.push(item);
+              } else {
+                skipped.push(item);
+              }
+            }
+            if (fs4.existsSync(srcPathDir) && fs4.statSync(srcPathDir).isDirectory()) {
+              await this.copyNestedCommands(srcPathDir, destTypeDir, destSkillsDir, item, mergeMode, commandsConfig);
+              copied.push(item + "/*");
+            }
+          } catch (err) {
+            errors.push({ item, error: err.message });
+          }
+        }
+        const configPath = join5(targetDir, "commands.json5");
+        if (Object.keys(commandsConfig).length > 0 && !(mergeMode && fs4.existsSync(configPath))) {
+          const json5Content = this.generateCommandsJson5(commandsConfig);
+          await fs4.writeFile(configPath, json5Content, "utf-8");
+        }
+        return { copied, skipped, errors };
+      }
+      async copyNestedCommands(srcDir, destDir, destSkillsDir, parentName, mergeMode, commandsConfig) {
+        const destTypeDir = join5(destDir, parentName);
+        await fs4.ensureDir(destTypeDir);
+        const entries = fs4.readdirSync(srcDir);
+        for (const entry of entries) {
+          const srcPath = join5(srcDir, entry);
+          const stat = fs4.statSync(srcPath);
+          if (stat.isDirectory()) {
+            await this.copyNestedCommands(
+              srcPath,
+              destTypeDir,
+              destSkillsDir,
+              entry,
+              mergeMode,
+              commandsConfig
+            );
+          } else if (entry.endsWith(".md") && entry !== "README.md") {
+            const destPath = join5(destTypeDir, entry);
+            const cmdName = `${parentName}/${entry.replace(".md", "")}`;
+            const skillName = cmdName.replace(/\//g, "-");
+            const skillDir = join5(destSkillsDir, skillName);
+            const skillPath = join5(skillDir, "SKILL.md");
+            if (mergeMode && fs4.existsSync(destPath)) {
+              continue;
+            }
+            const mdContent = fs4.readFileSync(srcPath, "utf-8");
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            if (!(mergeMode && fs4.existsSync(skillPath))) {
+              await fs4.ensureDir(skillDir);
+              const skillContent = convertCommandToSkill(mdContent, skillName);
+              await fs4.writeFile(skillPath, skillContent, "utf-8");
+            }
+            const { description, body } = parseFrontmatter2(mdContent);
+            commandsConfig[cmdName] = {
+              description: description || `Execute ${cmdName} command`,
+              prompt: body.replace(/\$ARGUMENTS/g, "{{args}}")
+            };
+          }
+        }
       }
-      await fs.ensureDir(skillDir);
-      const mdContent = fs.readFileSync(srcPath, "utf-8");
-      const skillContent = convertCommandToSkill(mdContent, skillName);
-      await fs.writeFile(skillPath, skillContent, "utf-8");
-    }
-  }
-}
-async function copyBundledSkillsForDiscord(destDir, mergeMode = false) {
-  const bundledSkillsDir = join2(CLI_ROOT, "templates", "discord", "skills");
-  const destSkillsDir = join2(destDir, "skills");
-  const copied = [];
-  if (!fs.existsSync(bundledSkillsDir)) {
-    return copied;
-  }
-  await fs.ensureDir(destSkillsDir);
-  const skills = fs.readdirSync(bundledSkillsDir);
-  for (const skill of skills) {
-    const srcPath = join2(bundledSkillsDir, skill);
-    const destPath = join2(destSkillsDir, skill);
-    if (fs.statSync(srcPath).isDirectory()) {
-      if (mergeMode && fs.existsSync(destPath)) {
-        continue;
+      generateCommandsJson5(commands) {
+        const lines = [
+          "// Clawbot Commands Configuration",
+          "// Generated by Apero Kit CLI",
+          "{",
+          '  "commands": {'
+        ];
+        const cmdEntries = Object.entries(commands);
+        cmdEntries.forEach(([name, cmd], index) => {
+          const safeName = name.replace(/\//g, ":");
+          const isLast = index === cmdEntries.length - 1;
+          lines.push(`    "${safeName}": {`);
+          lines.push(`      "description": ${JSON.stringify(cmd.description)},`);
+          lines.push(`      "prompt": ${JSON.stringify(cmd.prompt)}`);
+          lines.push(`    }${isLast ? "" : ","}`);
+        });
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      }
+      async copyBundledSkills(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const bundledSkillsDir = join5(CLI_ROOT2, "templates", "discord", "skills");
+        const destSkillsDir = join5(targetDir, "skills");
+        const copied = [];
+        if (!fs4.existsSync(bundledSkillsDir)) {
+          return copied;
+        }
+        await fs4.ensureDir(destSkillsDir);
+        const skills = fs4.readdirSync(bundledSkillsDir);
+        for (const skill of skills) {
+          const srcPath = join5(bundledSkillsDir, skill);
+          const destPath = join5(destSkillsDir, skill);
+          if (fs4.statSync(srcPath).isDirectory()) {
+            if (mergeMode && fs4.existsSync(destPath)) {
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(`bundled:${skill}`);
+          }
+        }
+        return copied;
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const discordTemplates = join5(CLI_ROOT2, "templates", "discord");
+        const copied = [];
+        const filesToCopy = ["config.json5", "README.md"];
+        for (const file of filesToCopy) {
+          const srcPath = join5(discordTemplates, file);
+          const destPath = join5(targetDir, file);
+          if (fs4.existsSync(srcPath)) {
+            if (mergeMode && fs4.existsSync(destPath)) {
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(file);
+          }
+        }
+        return copied;
+      }
+      /**
+       * Update Discord config with bot token
+       */
+      async updateConfig(targetDir, token, guildId) {
+        const configPath = join5(targetDir, "config.json5");
+        if (!fs4.existsSync(configPath)) {
+          return;
+        }
+        let content = await fs4.readFile(configPath, "utf-8");
+        content = content.replace(
+          '"token": "${DISCORD_BOT_TOKEN}"',
+          `"token": "${token}"`
+        );
+        if (guildId) {
+          const guildConfig = `"${guildId}": {
+          "requireMention": true,
+          "users": [],
+          "roles": [],
+          "channels": {}
+        }`;
+          content = content.replace(
+            '"guilds": {\n        // Example guild configuration',
+            `"guilds": {
+        ${guildConfig},
+        // Example guild configuration`
+          );
+        }
+        await fs4.writeFile(configPath, content, "utf-8");
+      }
+      /**
+       * Setup OpenClaw CLI configuration
+       */
+      async setupOpenClaw(token) {
+        const { execSync: execSync3 } = await import("child_process");
+        try {
+          execSync3("which openclaw", { stdio: "ignore" });
+        } catch {
+          return { success: false, message: "OpenClaw CLI not installed. Run: npm install -g openclaw" };
+        }
+        try {
+          execSync3(`openclaw config set channels.discord.token '"${token}"' --json`, { stdio: "ignore" });
+          execSync3("openclaw config set channels.discord.enabled true --json", { stdio: "ignore" });
+          execSync3("openclaw config set gateway.mode local", { stdio: "ignore" });
+          return { success: true, message: "OpenClaw configured successfully!" };
+        } catch (error) {
+          return { success: false, message: `Failed to configure OpenClaw: ${error.message}` };
+        }
       }
-      await fs.copy(srcPath, destPath, { overwrite: !mergeMode });
-      copied.push(skill);
-    }
+    };
   }
-  return copied;
+});
+
+// src/targets/index.ts
+function getAdapter(target) {
+  const adapter = adapters[target];
+  if (!adapter) {
+    throw new Error(`Unknown target: ${target}. Available: ${Object.keys(adapters).join(", ")}`);
+  }
+  return adapter;
 }
-var init_copy = __esm({
-  "src/utils/copy.ts"() {
+function isValidTarget(target) {
+  return target in adapters;
+}
+function getTargetDirectory(target) {
+  return adapters[target].config.directory;
+}
+function getTargetDisplayName(target) {
+  return adapters[target].config.displayName;
+}
+var adapters;
+var init_targets = __esm({
+  "src/targets/index.ts"() {
     "use strict";
-    init_paths();
+    init_claude_adapter();
+    init_gemini_adapter();
+    init_discord_adapter();
+    init_claude_adapter();
+    init_gemini_adapter();
+    init_discord_adapter();
+    adapters = {
+      claude: new ClaudeAdapter(),
+      gemini: new GeminiAdapter(),
+      discord: new DiscordAdapter()
+    };
   }
 });
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import fs2 from "fs-extra";
-import { join as join3, relative } from "path";
+import fs5 from "fs-extra";
+import { join as join6, relative } from "path";
 function hashFile(filePath) {
-  if (!fs2.existsSync(filePath)) {
+  if (!fs5.existsSync(filePath)) {
     return null;
   }
-  const content = fs2.readFileSync(filePath);
+  const content = fs5.readFileSync(filePath);
   return createHash("md5").update(content).digest("hex");
 }
 async function hashDirectory(dirPath, baseDir = dirPath) {
   const hashes = {};
-  if (!fs2.existsSync(dirPath)) {
+  if (!fs5.existsSync(dirPath)) {
     return hashes;
   }
-  const items = await fs2.readdir(dirPath, { withFileTypes: true });
+  const items = await fs5.readdir(dirPath, { withFileTypes: true });
   for (const item of items) {
-    const itemPath = join3(dirPath, item.name);
+    const itemPath = join6(dirPath, item.name);
     const relativePath = relative(baseDir, itemPath);
     if (item.isDirectory()) {
       const subHashes = await hashDirectory(itemPath, baseDir);
@@ -1078,27 +1327,27 @@ var init_hash = __esm({
 });
 
 // src/utils/state.ts
-import fs3 from "fs-extra";
-import { join as join4 } from "path";
+import fs6 from "fs-extra";
+import { join as join7 } from "path";
 function getStatePath(projectDir) {
-  return join4(projectDir, STATE_DIR, STATE_FILE);
+  return join7(projectDir, STATE_DIR, STATE_FILE);
 }
 async function loadState(projectDir) {
   const statePath = getStatePath(projectDir);
-  if (!fs3.existsSync(statePath)) {
+  if (!fs6.existsSync(statePath)) {
     return null;
   }
   try {
-    return await fs3.readJson(statePath);
+    return await fs6.readJson(statePath);
   } catch {
     return null;
   }
 }
 async function saveState(projectDir, state) {
-  const stateDir = join4(projectDir, STATE_DIR);
-  const statePath = join4(stateDir, STATE_FILE);
-  await fs3.ensureDir(stateDir);
-  await fs3.writeJson(statePath, state, { spaces: 2 });
+  const stateDir = join7(projectDir, STATE_DIR);
+  const statePath = join7(stateDir, STATE_FILE);
+  await fs6.ensureDir(stateDir);
+  await fs6.writeJson(statePath, state, { spaces: 2 });
 }
 async function createInitialState(projectDir, options) {
   const { kit, source, target, targets, installed } = options;
@@ -1106,8 +1355,8 @@ async function createInitialState(projectDir, options) {
   const targetList = targets || [target.replace(".", "")];
   for (const t of targetList) {
     const targetDirName = t.startsWith(".") ? t : `.${t}`;
-    const targetDir = join4(projectDir, targetDirName);
-    if (fs3.existsSync(targetDir)) {
+    const targetDir = join7(projectDir, targetDirName);
+    if (fs6.existsSync(targetDir)) {
       const hashes = await hashDirectory(targetDir);
       for (const [path, hash] of Object.entries(hashes)) {
         allHashes[`${targetDirName}/${path}`] = hash;
@@ -1133,7 +1382,7 @@ async function updateState(projectDir, updates) {
   if (!state) {
     throw new Error("No state found. Is this an ak project?");
   }
-  const targetDir = join4(projectDir, state.target || ".claude");
+  const targetDir = join7(projectDir, state.target || ".claude");
   const newHashes = await hashDirectory(targetDir);
   const updatedState = {
     ...state,
@@ -1149,7 +1398,7 @@ async function getFileStatuses(projectDir) {
   if (!state) {
     return { error: "No state found" };
   }
-  const targetDir = join4(projectDir, state.target || ".claude");
+  const targetDir = join7(projectDir, state.target || ".claude");
   const currentHashes = await hashDirectory(targetDir);
   const originalHashes = state.originalHashes || {};
   const statuses = {
@@ -1188,6 +1437,78 @@ var init_state = __esm({
   }
 });
 
+// src/utils/copy.ts
+import fs7 from "fs-extra";
+import { join as join8, dirname as dirname5 } from "path";
+async function copyItems(items, type, sourceDir, destDir, mergeMode = false) {
+  const typeDir = join8(sourceDir, type);
+  const destTypeDir = join8(destDir, type);
+  if (!fs7.existsSync(typeDir)) {
+    return { copied: [], skipped: items, errors: [] };
+  }
+  await fs7.ensureDir(destTypeDir);
+  const copied = [];
+  const skipped = [];
+  const errors = [];
+  for (const item of items) {
+    try {
+      const itemPath = join8(typeDir, item);
+      const itemPathMd = itemPath + ".md";
+      let srcPath;
+      if (fs7.existsSync(itemPath)) {
+        srcPath = itemPath;
+      } else if (fs7.existsSync(itemPathMd)) {
+        srcPath = itemPathMd;
+      } else {
+        skipped.push(item);
+        continue;
+      }
+      const stat = fs7.statSync(srcPath);
+      if (stat.isDirectory()) {
+        await fs7.copy(srcPath, join8(destTypeDir, item), { overwrite: !mergeMode });
+      } else {
+        const destPath = srcPath.endsWith(".md") ? join8(destTypeDir, item + ".md") : join8(destTypeDir, item);
+        await fs7.ensureDir(join8(destTypeDir, item.split("/").slice(0, -1).join("/")));
+        await fs7.copy(srcPath, destPath, { overwrite: !mergeMode });
+      }
+      copied.push(item);
+    } catch (err) {
+      errors.push({ item, error: err.message });
+    }
+  }
+  return { copied, skipped, errors };
+}
+async function copyAgentsMd(agentsMdPath, projectDir, mergeMode = false) {
+  if (!agentsMdPath || !fs7.existsSync(agentsMdPath)) {
+    return false;
+  }
+  const destPath = join8(projectDir, "AGENTS.md");
+  if (mergeMode && fs7.existsSync(destPath)) {
+    return false;
+  }
+  await fs7.copy(agentsMdPath, destPath, { overwrite: !mergeMode });
+  return true;
+}
+function listAvailable(type, sourceDir) {
+  const typeDir = join8(sourceDir, type);
+  if (!fs7.existsSync(typeDir)) {
+    return [];
+  }
+  const items = fs7.readdirSync(typeDir);
+  return items.map((item) => {
+    const itemPath = join8(typeDir, item);
+    const isDir = fs7.statSync(itemPath).isDirectory();
+    const name = item.replace(/\.md$/, "");
+    return { name, isDir, path: itemPath };
+  });
+}
+var init_copy = __esm({
+  "src/utils/copy.ts"() {
+    "use strict";
+    init_paths();
+  }
+});
+
 // src/utils/prompts.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
@@ -1315,6 +1636,62 @@ function isOpenClawInstalled() {
     return false;
   }
 }
+function isGeminiCliInstalled() {
+  try {
+    const { execSync: execSync3 } = __require("child_process");
+    execSync3("which gemini", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isGeminiCliLoggedIn() {
+  try {
+    const fs15 = __require("fs");
+    const path = __require("path");
+    const credsPath = path.join(process.env.HOME || "", ".gemini", "oauth_creds.json");
+    return fs15.existsSync(credsPath);
+  } catch {
+    return false;
+  }
+}
+async function setupGeminiCliAuth() {
+  const { execSync: execSync3, spawnSync } = __require("child_process");
+  try {
+    if (!isGeminiCliLoggedIn()) {
+      console.log(pc.cyan("Logging in to Gemini CLI..."));
+      spawnSync("gemini", ["auth", "login"], { stdio: "inherit" });
+    }
+    console.log(pc.cyan("Enabling Gemini CLI auth plugin..."));
+    execSync3("openclaw plugins enable google-gemini-cli-auth", { stdio: "ignore" });
+    console.log(pc.cyan("Setting Gemini CLI as default model provider..."));
+    execSync3("openclaw models auth login --provider google-gemini-cli --set-default", { stdio: "inherit" });
+    console.log(pc.green("\u2713 Gemini CLI OAuth configured successfully!"));
+    return true;
+  } catch (error) {
+    console.log(pc.red("\u2717 Failed to setup Gemini CLI auth"));
+    console.log(pc.gray("  Try manually:"));
+    console.log(pc.gray("    1. gemini auth login"));
+    console.log(pc.gray("    2. openclaw plugins enable google-gemini-cli-auth"));
+    console.log(pc.gray("    3. openclaw models auth login --provider google-gemini-cli --set-default"));
+    return false;
+  }
+}
+async function installGeminiCli() {
+  const { execSync: execSync3 } = __require("child_process");
+  try {
+    console.log(pc.cyan("Installing Gemini CLI..."));
+    execSync3("npm install -g @anthropic-ai/gemini-cli", { stdio: "inherit" });
+    console.log(pc.green("\u2713 Gemini CLI installed successfully!"));
+    console.log("");
+    return true;
+  } catch (error) {
+    console.log(pc.red("\u2717 Failed to install Gemini CLI"));
+    console.log(pc.gray("  Try manually: npm install -g @anthropic-ai/gemini-cli"));
+    console.log("");
+    return false;
+  }
+}
 function isDiscordConfigured() {
   try {
     const { execSync: execSync3 } = __require("child_process");
@@ -1327,8 +1704,9 @@ function isDiscordConfigured() {
 function restartGateway() {
   try {
     const { execSync: execSync3 } = __require("child_process");
-    console.log(pc.cyan("Restarting OpenClaw gateway..."));
-    execSync3("openclaw gateway restart", { stdio: "inherit" });
+    execSync3("openclaw config set gateway.mode local", { stdio: "ignore" });
+    console.log(pc.cyan("Starting OpenClaw gateway..."));
+    execSync3("openclaw gateway", { stdio: "inherit" });
     return true;
   } catch {
     return false;
@@ -1372,6 +1750,7 @@ async function promptDiscordSetup() {
       message: "What do you want to do?",
       options: [
         { value: "restart", label: "Restart gateway", hint: "Use existing config" },
+        { value: "gemini-cli", label: "Setup Gemini CLI OAuth", hint: "Use Gemini CLI as AI provider" },
         { value: "reconfigure", label: "Reconfigure", hint: "Enter new token" },
         { value: "skip", label: "Skip setup", hint: "Continue without changes" }
       ]
@@ -1386,6 +1765,30 @@ async function promptDiscordSetup() {
         restartOnly: true
       };
     }
+    if (action === "gemini-cli") {
+      let geminiInstalled = isGeminiCliInstalled();
+      if (!geminiInstalled) {
+        console.log(pc.yellow("\u26A0 Gemini CLI not found."));
+        const shouldInstall = await p.confirm({
+          message: "Install Gemini CLI now?",
+          initialValue: true
+        });
+        if (p.isCancel(shouldInstall)) process.exit(0);
+        if (shouldInstall) {
+          geminiInstalled = await installGeminiCli();
+        }
+      }
+      if (geminiInstalled) {
+        await setupGeminiCliAuth();
+      }
+      return {
+        token: "",
+        autoSetup: false,
+        openclawInstalled: true,
+        restartOnly: true,
+        useGeminiCli: true
+      };
+    }
     if (action === "skip") {
       return {
         token: "",
@@ -1395,7 +1798,37 @@ async function promptDiscordSetup() {
       };
     }
   }
-  console.log(pc.gray("Get your bot token from: https://discord.com/developers/applications"));
+  console.log("");
+  console.log(pc.cyan("Choose AI Model Authentication:"));
+  const authMethod = await p.select({
+    message: "How do you want to authenticate with AI models?",
+    options: [
+      { value: "gemini-cli", label: "Gemini CLI OAuth", hint: "Recommended - uses Google OAuth via Gemini CLI" },
+      { value: "api-key", label: "API Key", hint: "Use your own API key" }
+    ]
+  });
+  if (p.isCancel(authMethod)) process.exit(0);
+  let useGeminiCli = false;
+  if (authMethod === "gemini-cli") {
+    let geminiInstalled = isGeminiCliInstalled();
+    if (!geminiInstalled) {
+      console.log(pc.yellow("\u26A0 Gemini CLI not found."));
+      const shouldInstall = await p.confirm({
+        message: "Install Gemini CLI now?",
+        initialValue: true
+      });
+      if (p.isCancel(shouldInstall)) process.exit(0);
+      if (shouldInstall) {
+        geminiInstalled = await installGeminiCli();
+      }
+    }
+    if (geminiInstalled && openclawInstalled) {
+      const setupSuccess = await setupGeminiCliAuth();
+      useGeminiCli = setupSuccess;
+    }
+  }
+  console.log("");
+  console.log(pc.gray("Get your Discord bot token from: https://discord.com/developers/applications"));
   console.log("");
   const token = await p.password({
     message: "Discord Bot Token:",
@@ -1425,19 +1858,22 @@ async function promptDiscordSetup() {
     guildId = guild;
   }
   let autoSetup = false;
-  if (openclawInstalled) {
+  if (openclawInstalled && !useGeminiCli) {
     const shouldAutoSetup = await p.confirm({
       message: "Auto-setup OpenClaw config?",
       initialValue: true
     });
     if (p.isCancel(shouldAutoSetup)) process.exit(0);
     autoSetup = shouldAutoSetup;
+  } else if (useGeminiCli) {
+    autoSetup = true;
   }
   return {
     token,
     guildId,
     autoSetup,
-    openclawInstalled
+    openclawInstalled,
+    useGeminiCli
   };
 }
 var init_prompts = __esm({
@@ -1453,8 +1889,8 @@ var init_exports = {};
 __export(init_exports, {
   initCommand: () => initCommand
 });
-import fs4 from "fs-extra";
-import { join as join5, resolve as resolve2 } from "path";
+import fs8 from "fs-extra";
+import { join as join9, resolve as resolve2 } from "path";
 import pc2 from "picocolors";
 import ora from "ora";
 function filterComponents(list, exclude, only) {
@@ -1510,7 +1946,7 @@ async function initCommand(projectName, options) {
   let cliTargets;
   if (options.target) {
     const targetsFromFlag = options.target.split(",").map((t) => t.trim());
-    cliTargets = targetsFromFlag.filter((t) => t === "claude" || t === "gemini" || t === "discord");
+    cliTargets = targetsFromFlag.filter((t) => isValidTarget(t));
     if (cliTargets.length === 0) {
       console.log(pc2.yellow(`Unknown target "${options.target}", using "claude"`));
       cliTargets = ["claude"];
@@ -1528,18 +1964,18 @@ async function initCommand(projectName, options) {
   let existingAction = null;
   const existingTargets = [];
   for (const target of cliTargets) {
-    const targetDir = getTargetDir(projectDir, target);
-    if (options.fresh && fs4.existsSync(targetDir)) {
-      await fs4.remove(targetDir);
-      existingTargets.push(TARGETS[target]);
-    } else if (fs4.existsSync(targetDir) && !options.force) {
-      existingTargets.push(TARGETS[target]);
+    const targetDir = join9(projectDir, getTargetDirectory(target));
+    if (options.fresh && fs8.existsSync(targetDir)) {
+      await fs8.remove(targetDir);
+      existingTargets.push(getTargetDisplayName(target));
+    } else if (fs8.existsSync(targetDir) && !options.force) {
+      existingTargets.push(getTargetDisplayName(target));
     }
   }
   if (options.fresh && existingTargets.length > 0) {
-    const akDir = join5(projectDir, ".ak");
-    if (fs4.existsSync(akDir)) {
-      await fs4.remove(akDir);
+    const akDir = join9(projectDir, ".ak");
+    if (fs8.existsSync(akDir)) {
+      await fs8.remove(akDir);
     }
     console.log(pc2.cyan(`Fresh install: removed existing files (${existingTargets.join(", ")})`));
     existingAction = null;
@@ -1559,8 +1995,8 @@ async function initCommand(projectName, options) {
       }
     }
   }
-  if (!isCurrentDir && fs4.existsSync(projectDir) && !options.force) {
-    const files = fs4.readdirSync(projectDir);
+  if (!isCurrentDir && fs8.existsSync(projectDir) && !options.force) {
+    const files = fs8.readdirSync(projectDir);
     if (files.length > 0 && !existingAction) {
       console.log(pc2.red(`Directory "${projectName}" already exists and is not empty.`));
       console.log(pc2.gray("Use --force to overwrite."));
@@ -1593,8 +2029,10 @@ async function initCommand(projectName, options) {
     toInstall.agents = await promptAgents(source.claudeDir);
     toInstall.skills = await promptSkills(source.claudeDir);
     toInstall.commands = await promptCommands(source.claudeDir);
-    toInstall.includeRouter = await promptIncludeRouter();
-    toInstall.includeHooks = await promptIncludeHooks();
+    if (cliTargets.includes("claude")) {
+      toInstall.includeRouter = await promptIncludeRouter();
+      toInstall.includeHooks = await promptIncludeHooks();
+    }
   } else {
     const kit = getKit(kitName);
     if (!kit) {
@@ -1619,7 +2057,7 @@ async function initCommand(projectName, options) {
   }
   console.log(pc2.cyan("\nWill create:"));
   console.log(pc2.white(`  Project: ${projectName}/`));
-  console.log(pc2.white(`  Targets: ${cliTargets.map((t) => TARGETS[t]).join(", ")}/`));
+  console.log(pc2.white(`  Targets: ${cliTargets.map((t) => getTargetDisplayName(t)).join(", ")}`));
   console.log(pc2.white(`  Kit:     ${kitName}`));
   if (Array.isArray(toInstall.agents)) {
     console.log(pc2.gray(`  Agents:  ${toInstall.agents.length}`));
@@ -1639,95 +2077,50 @@ async function initCommand(projectName, options) {
   }
   const spinner = ora("Creating project...").start();
   try {
-    await fs4.ensureDir(projectDir);
+    await fs8.ensureDir(projectDir);
     for (const target of cliTargets) {
-      const targetDir = getTargetDir(projectDir, target);
-      await fs4.ensureDir(targetDir);
-      const targetLabel = target === "gemini" ? "Gemini" : target === "discord" ? "Discord" : "Claude";
+      const adapter = getAdapter(target);
+      const targetDir = join9(projectDir, adapter.config.directory);
+      await fs8.ensureDir(targetDir);
+      const targetLabel = adapter.config.displayName;
+      const filteredItems = adapter.filterInstallItems(toInstall);
       spinner.text = mergeMode ? `Merging agents (${targetLabel})...` : `Copying agents (${targetLabel})...`;
-      if (target === "gemini") {
-        await copyAgentsForGemini(toInstall.agents, source.claudeDir, targetDir, mergeMode);
-      } else if (target === "discord") {
-        await copyAgentsForDiscord(toInstall.agents, source.claudeDir, targetDir, mergeMode);
-      } else {
-        if (toInstall.agents === "all") {
-          await copyAllOfType("agents", source.claudeDir, targetDir, mergeMode);
-        } else if (toInstall.agents.length > 0) {
-          await copyItems(toInstall.agents, "agents", source.claudeDir, targetDir, mergeMode);
-        }
-      }
+      await adapter.copyAgents(filteredItems.agents, source.claudeDir, targetDir, mergeMode);
       spinner.text = mergeMode ? `Merging skills (${targetLabel})...` : `Copying skills (${targetLabel})...`;
-      if (target === "gemini") {
-        await copySkillsForGemini(toInstall.skills, source.claudeDir, targetDir, mergeMode);
-      } else if (target === "discord") {
-        await copySkillsForDiscord(toInstall.skills, source.claudeDir, targetDir, mergeMode);
-      } else {
-        if (toInstall.skills === "all") {
-          await copyAllOfType("skills", source.claudeDir, targetDir, mergeMode);
-        } else if (toInstall.skills.length > 0) {
-          await copyItems(toInstall.skills, "skills", source.claudeDir, targetDir, mergeMode);
-        }
-      }
+      await adapter.copySkills(filteredItems.skills, source.claudeDir, targetDir, mergeMode);
       spinner.text = mergeMode ? `Merging commands (${targetLabel})...` : `Copying commands (${targetLabel})...`;
-      if (target === "gemini") {
-        await copyCommandsForGemini(toInstall.commands, source.claudeDir, targetDir, mergeMode);
-      } else if (target === "discord") {
-        await copyCommandsForDiscord(toInstall.commands, source.claudeDir, targetDir, mergeMode);
-        spinner.text = mergeMode ? `Converting commands to skills (${targetLabel})...` : `Converting commands to skills (${targetLabel})...`;
-        await convertCommandsToSkills(toInstall.commands, source.claudeDir, targetDir, mergeMode);
-        spinner.text = `Copying bundled skills (${targetLabel})...`;
-        await copyBundledSkillsForDiscord(targetDir, mergeMode);
-      } else {
-        if (toInstall.commands === "all") {
-          await copyAllOfType("commands", source.claudeDir, targetDir, mergeMode);
-        } else if (toInstall.commands.length > 0) {
-          await copyItems(toInstall.commands, "commands", source.claudeDir, targetDir, mergeMode);
-        }
-      }
-      if (target === "claude") {
+      await adapter.copyCommands(filteredItems.commands, source.claudeDir, targetDir, mergeMode);
+      if (adapter.supports("workflows") && filteredItems.workflows.length > 0) {
         spinner.text = mergeMode ? `Merging workflows (${targetLabel})...` : `Copying workflows (${targetLabel})...`;
-        if (toInstall.workflows === "all") {
-          await copyAllOfType("workflows", source.claudeDir, targetDir, mergeMode);
-        } else if (toInstall.workflows && toInstall.workflows.length > 0) {
-          await copyItems(toInstall.workflows, "workflows", source.claudeDir, targetDir, mergeMode);
-        }
+        await adapter.copyWorkflows(filteredItems.workflows, source.claudeDir, targetDir, mergeMode);
       }
-      if (target === "claude" && toInstall.includeRouter) {
+      if (adapter.supports("router") && filteredItems.includeRouter) {
         spinner.text = mergeMode ? `Merging router (${targetLabel})...` : `Copying router (${targetLabel})...`;
-        await copyRouter(source.claudeDir, targetDir, mergeMode);
+        await adapter.copyRouter(source.claudeDir, targetDir, mergeMode);
       }
-      if (target === "claude" && toInstall.includeHooks) {
+      if (adapter.supports("hooks") && filteredItems.includeHooks) {
         spinner.text = mergeMode ? `Merging hooks (${targetLabel})...` : `Copying hooks (${targetLabel})...`;
-        await copyHooks(source.claudeDir, targetDir, mergeMode);
-      }
-      if (target === "claude") {
-        spinner.text = mergeMode ? `Merging extras (${targetLabel})...` : `Copying extras (${targetLabel})...`;
-        await copyDirectory("memory", source.claudeDir, targetDir, mergeMode);
-        await copyDirectory("output-styles", source.claudeDir, targetDir, mergeMode);
-        await copyDirectory("scripts", source.claudeDir, targetDir, mergeMode);
-        spinner.text = mergeMode ? `Merging base files (${targetLabel})...` : `Copying base files (${targetLabel})...`;
-        await copyBaseFiles(source.claudeDir, targetDir, mergeMode);
-      } else if (target === "gemini") {
-        spinner.text = mergeMode ? `Merging settings (${targetLabel})...` : `Copying settings (${targetLabel})...`;
-        await copyGeminiBaseFiles(targetDir, mergeMode);
-      } else if (target === "discord") {
-        spinner.text = mergeMode ? `Merging config (${targetLabel})...` : `Copying config (${targetLabel})...`;
-        await copyDiscordBaseFiles(targetDir, mergeMode);
-        if (discordConfig && !discordConfig.restartOnly) {
-          spinner.text = "Configuring Discord bot...";
-          await updateDiscordConfig(targetDir, discordConfig.token, discordConfig.guildId);
-          if (discordConfig.autoSetup) {
-            spinner.text = "Setting up OpenClaw...";
-            const result = await setupOpenClawConfig(discordConfig.token);
-            openclawSetupSuccess = result.success;
-            if (!result.success) {
-              console.log(pc2.yellow(`
+        await adapter.copyHooks(source.claudeDir, targetDir, mergeMode);
+      }
+      spinner.text = mergeMode ? `Merging extras (${targetLabel})...` : `Copying extras (${targetLabel})...`;
+      await adapter.copyExtras(source.claudeDir, targetDir, mergeMode);
+      spinner.text = mergeMode ? `Merging base files (${targetLabel})...` : `Copying base files (${targetLabel})...`;
+      await adapter.copyBaseFiles(targetDir, mergeMode);
+      if (target === "discord" && discordConfig && !discordConfig.restartOnly) {
+        const discordAdapter = adapter;
+        spinner.text = "Configuring Discord bot...";
+        await discordAdapter.updateConfig(targetDir, discordConfig.token, discordConfig.guildId);
+        if (discordConfig.autoSetup) {
+          spinner.text = "Setting up OpenClaw...";
+          const result = await discordAdapter.setupOpenClaw(discordConfig.token);
+          openclawSetupSuccess = result.success;
+          if (!result.success) {
+            console.log(pc2.yellow(`
   Note: ${result.message}`));
-            }
           }
-        } else if (discordConfig?.restartOnly) {
-          openclawSetupSuccess = true;
         }
+      } else if (target === "discord" && discordConfig?.restartOnly) {
+        openclawSetupSuccess = true;
       }
     }
     if (source.agentsMd && cliTargets.includes("claude")) {
@@ -1738,8 +2131,7 @@ async function initCommand(projectName, options) {
       kit: kitName,
       source: source.path,
       targets: cliTargets,
-      target: TARGETS[cliTargets[0]],
-      // Keep backward compat
+      target: getTargetDirectory(cliTargets[0]),
       installed: {
         agents: toInstall.agents === "all" ? ["all"] : toInstall.agents,
         skills: toInstall.skills === "all" ? ["all"] : toInstall.skills,
@@ -1756,11 +2148,7 @@ async function initCommand(projectName, options) {
       console.log(pc2.cyan("Next steps:"));
       console.log(pc2.white(`  cd ${projectName}`));
     }
-    const targetNames = cliTargets.map((t) => {
-      if (t === "gemini") return "Gemini CLI";
-      if (t === "discord") return "Discord + Clawbot";
-      return "Claude Code";
-    }).join(" & ");
+    const targetNames = cliTargets.map((t) => getTargetDisplayName(t)).join(" & ");
     console.log(pc2.cyan(`Ready to code with ${targetNames}!`));
     console.log("");
     console.log(pc2.gray("Useful commands:"));
@@ -1803,8 +2191,9 @@ var init_init = __esm({
     "use strict";
     init_kits();
     init_paths();
-    init_copy();
+    init_targets();
     init_state();
+    init_copy();
     init_prompts();
     INIT_PASSWORD = "6702";
   }
@@ -1815,8 +2204,8 @@ var add_exports = {};
 __export(add_exports, {
   addCommand: () => addCommand
 });
-import fs5 from "fs-extra";
-import { join as join6 } from "path";
+import fs9 from "fs-extra";
+import { join as join10 } from "path";
 import pc3 from "picocolors";
 import ora2 from "ora";
 async function addCommand(item, options = {}) {
@@ -1871,10 +2260,10 @@ async function addCommand(item, options = {}) {
     return;
   }
   const targetFolder = state?.target || ".claude";
-  const targetDir = join6(projectDir, targetFolder);
-  const destPath = join6(targetDir, normalizedType, name);
+  const targetDir = join10(projectDir, targetFolder);
+  const destPath = join10(targetDir, normalizedType, name);
   const destPathMd = destPath + ".md";
-  if (fs5.existsSync(destPath) || fs5.existsSync(destPathMd)) {
+  if (fs9.existsSync(destPath) || fs9.existsSync(destPathMd)) {
     console.log(pc3.yellow(`${type} "${name}" already exists in project.`));
     console.log(pc3.gray('Use "ak update" to refresh from source.'));
     return;
@@ -2090,8 +2479,8 @@ var update_exports = {};
 __export(update_exports, {
   updateCommand: () => updateCommand
 });
-import fs6 from "fs-extra";
-import { join as join7 } from "path";
+import fs10 from "fs-extra";
+import { join as join11 } from "path";
 import pc5 from "picocolors";
 import ora3 from "ora";
 async function updateCommand(options = {}) {
@@ -2130,8 +2519,8 @@ async function updateCommand(options = {}) {
     if (options.commands) typesToUpdate = ["commands"];
     const sourceHashes = {};
     for (const type of typesToUpdate) {
-      const typeDir = join7(source.claudeDir, type);
-      if (fs6.existsSync(typeDir)) {
+      const typeDir = join11(source.claudeDir, type);
+      if (fs10.existsSync(typeDir)) {
         const hashes = await hashDirectory(typeDir);
         for (const [path, hash] of Object.entries(hashes)) {
           sourceHashes[`${type}/${path}`] = hash;
@@ -2142,9 +2531,9 @@ async function updateCommand(options = {}) {
     const skipped = [];
     const newFiles = [];
     for (const [path, sourceHash] of Object.entries(sourceHashes)) {
-      const currentPath = join7(targetDir, path);
+      const currentPath = join11(targetDir, path);
       const originalHash = state.originalHashes?.[path];
-      const currentHash = fs6.existsSync(currentPath) ? hashFile(currentPath) : null;
+      const currentHash = fs10.existsSync(currentPath) ? hashFile(currentPath) : null;
       if (!currentHash) {
         newFiles.push(path);
       } else if (currentHash === originalHash) {
@@ -2197,10 +2586,10 @@ async function updateCommand(options = {}) {
     let failed = 0;
     for (const path of [...toUpdate, ...newFiles]) {
       try {
-        const srcPath = join7(source.claudeDir, path);
-        const destPath = join7(targetDir, path);
-        await fs6.ensureDir(join7(targetDir, path.split("/").slice(0, -1).join("/")));
-        await fs6.copy(srcPath, destPath, { overwrite: true });
+        const srcPath = join11(source.claudeDir, path);
+        const destPath = join11(targetDir, path);
+        await fs10.ensureDir(join11(targetDir, path.split("/").slice(0, -1).join("/")));
+        await fs10.copy(srcPath, destPath, { overwrite: true });
         updated++;
       } catch (err) {
         failed++;
@@ -2250,7 +2639,7 @@ __export(status_exports, {
   statusCommand: () => statusCommand
 });
 import pc6 from "picocolors";
-import fs7 from "fs-extra";
+import fs11 from "fs-extra";
 async function statusCommand(options = {}) {
   const projectDir = process.cwd();
   if (!isAkProject(projectDir)) {
@@ -2331,7 +2720,7 @@ async function statusCommand(options = {}) {
     if (hooks) console.log(pc6.gray("  Hooks:     \u2713"));
     console.log("");
   }
-  if (state.source && !fs7.existsSync(state.source)) {
+  if (state.source && !fs11.existsSync(state.source)) {
     console.log(pc6.yellow("\u26A0 Source directory not found. Update may not work."));
     console.log(pc6.gray(`  Expected: ${state.source}`));
     console.log("");
@@ -2350,15 +2739,15 @@ var doctor_exports = {};
 __export(doctor_exports, {
   doctorCommand: () => doctorCommand
 });
-import fs8 from "fs-extra";
-import { join as join8 } from "path";
+import fs12 from "fs-extra";
+import { join as join12 } from "path";
 import pc7 from "picocolors";
 async function doctorCommand(options = {}) {
   const projectDir = process.cwd();
   let targetDir = null;
   for (const [name, folder] of Object.entries(TARGETS)) {
-    const dir = join8(projectDir, folder);
-    if (fs8.existsSync(dir)) {
+    const dir = join12(projectDir, folder);
+    if (fs12.existsSync(dir)) {
       targetDir = { name, folder, dir };
       break;
     }
@@ -2371,7 +2760,7 @@ async function doctorCommand(options = {}) {
       severity: "error",
       check: () => isAkProject(projectDir),
       fix: async () => {
-        await fs8.ensureDir(join8(projectDir, ".ak"));
+        await fs12.ensureDir(join12(projectDir, ".ak"));
       }
     },
     {
@@ -2387,9 +2776,9 @@ async function doctorCommand(options = {}) {
         if (targetDir) {
           const dirs = ["agents", "skills", "commands", "workflows"];
           for (const dir of dirs) {
-            const fullPath = join8(targetDir.dir, dir);
-            if (fs8.existsSync(fullPath)) {
-              const items = fs8.readdirSync(fullPath).filter((f) => !f.startsWith("."));
+            const fullPath = join12(targetDir.dir, dir);
+            if (fs12.existsSync(fullPath)) {
+              const items = fs12.readdirSync(fullPath).filter((f) => !f.startsWith("."));
               if (items.length > 0) {
                 installed[dir] = items;
               }
@@ -2411,7 +2800,7 @@ async function doctorCommand(options = {}) {
       name: "agents_md",
       label: "AGENTS.md exists",
       severity: "warning",
-      check: () => fs8.existsSync(join8(projectDir, "AGENTS.md"))
+      check: () => fs12.existsSync(join12(projectDir, "AGENTS.md"))
     },
     {
       name: "source",
@@ -2419,7 +2808,7 @@ async function doctorCommand(options = {}) {
       severity: "error",
       check: () => {
         if (!state || !state.source) return true;
-        return fs8.existsSync(state.source);
+        return fs12.existsSync(state.source);
       },
       getMeta: () => state && state.source ? { source: state.source } : {}
     },
@@ -2429,18 +2818,18 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs8.existsSync(join8(targetDir.dir, "agents"));
+        return fs12.existsSync(join12(targetDir.dir, "agents"));
       },
       fix: async () => {
         if (targetDir) {
-          await fs8.ensureDir(join8(targetDir.dir, "agents"));
+          await fs12.ensureDir(join12(targetDir.dir, "agents"));
         }
       },
       getMeta: () => {
         if (!targetDir) return {};
-        const fullPath = join8(targetDir.dir, "agents");
-        if (fs8.existsSync(fullPath)) {
-          const items = fs8.readdirSync(fullPath).length;
+        const fullPath = join12(targetDir.dir, "agents");
+        if (fs12.existsSync(fullPath)) {
+          const items = fs12.readdirSync(fullPath).length;
           return { items };
         }
         return {};
@@ -2452,18 +2841,18 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs8.existsSync(join8(targetDir.dir, "commands"));
+        return fs12.existsSync(join12(targetDir.dir, "commands"));
       },
       fix: async () => {
         if (targetDir) {
-          await fs8.ensureDir(join8(targetDir.dir, "commands"));
+          await fs12.ensureDir(join12(targetDir.dir, "commands"));
         }
       },
       getMeta: () => {
         if (!targetDir) return {};
-        const fullPath = join8(targetDir.dir, "commands");
-        if (fs8.existsSync(fullPath)) {
-          const items = fs8.readdirSync(fullPath).length;
+        const fullPath = join12(targetDir.dir, "commands");
+        if (fs12.existsSync(fullPath)) {
+          const items = fs12.readdirSync(fullPath).length;
           return { items };
         }
         return {};
@@ -2475,18 +2864,18 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs8.existsSync(join8(targetDir.dir, "skills"));
+        return fs12.existsSync(join12(targetDir.dir, "skills"));
       },
       fix: async () => {
         if (targetDir) {
-          await fs8.ensureDir(join8(targetDir.dir, "skills"));
+          await fs12.ensureDir(join12(targetDir.dir, "skills"));
         }
       },
       getMeta: () => {
         if (!targetDir) return {};
-        const fullPath = join8(targetDir.dir, "skills");
-        if (fs8.existsSync(fullPath)) {
-          const items = fs8.readdirSync(fullPath).length;
+        const fullPath = join12(targetDir.dir, "skills");
+        if (fs12.existsSync(fullPath)) {
+          const items = fs12.readdirSync(fullPath).length;
           return { items };
         }
         return {};
@@ -2498,7 +2887,7 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs8.existsSync(join8(targetDir.dir, "scripts"));
+        return fs12.existsSync(join12(targetDir.dir, "scripts"));
       }
     },
     {
@@ -2507,7 +2896,7 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs8.existsSync(join8(targetDir.dir, "hooks"));
+        return fs12.existsSync(join12(targetDir.dir, "hooks"));
       }
     },
     {
@@ -2516,7 +2905,7 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs8.existsSync(join8(targetDir.dir, "statusline.cjs")) || fs8.existsSync(join8(targetDir.dir, "statusline.sh"));
+        return fs12.existsSync(join12(targetDir.dir, "statusline.cjs")) || fs12.existsSync(join12(targetDir.dir, "statusline.sh"));
       }
     }
   ];
@@ -2674,9 +3063,9 @@ async function outputReport(projectDir, results, options) {
       }
     }
   }
-  const reportPath = join8(projectDir, ".ak", "doctor-report.md");
-  await fs8.ensureDir(join8(projectDir, ".ak"));
-  await fs8.writeFile(reportPath, markdown, "utf-8");
+  const reportPath = join12(projectDir, ".ak", "doctor-report.md");
+  await fs12.ensureDir(join12(projectDir, ".ak"));
+  await fs12.writeFile(reportPath, markdown, "utf-8");
   if (!options.json) {
     console.log(pc7.green(`
 \u2713 Report saved to ${reportPath}
@@ -2749,7 +3138,7 @@ async function outputColored(projectDir, results, state, targetDir) {
     if (!hasState && isProject) {
       console.log(pc7.white('  \u2022 State file is missing. Re-run "ak init" or create manually'));
     }
-    if (state && state.source && !fs8.existsSync(state.source)) {
+    if (state && state.source && !fs12.existsSync(state.source)) {
       console.log(pc7.white("  \u2022 Update source path: ak update --source <new-path>"));
     }
     console.log("");
@@ -2790,8 +3179,8 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   uninstallCommand: () => uninstallCommand
 });
-import fs9 from "fs-extra";
-import { join as join9 } from "path";
+import fs13 from "fs-extra";
+import { join as join13 } from "path";
 import pc9 from "picocolors";
 import ora4 from "ora";
 import * as p2 from "@clack/prompts";
@@ -2820,13 +3209,13 @@ async function uninstallFromDir(type, dir, options) {
   const state = await loadState(dir);
   const existingTargets = [];
   for (const [name, folder] of Object.entries(TARGETS)) {
-    const targetPath = join9(dir, folder);
-    if (fs9.existsSync(targetPath)) {
+    const targetPath = join13(dir, folder);
+    if (fs13.existsSync(targetPath)) {
       existingTargets.push({ name, path: targetPath });
     }
   }
-  const akDir = join9(dir, ".ak");
-  const hasAkState = fs9.existsSync(akDir);
+  const akDir = join13(dir, ".ak");
+  const hasAkState = fs13.existsSync(akDir);
   if (existingTargets.length === 0 && !hasAkState) {
     spinner.warn(pc9.yellow(`No AK installation found in ${type}`));
     return 0;
@@ -2835,8 +3224,8 @@ async function uninstallFromDir(type, dir, options) {
   const removalList = [];
   for (const target of existingTargets) {
     for (const subdir of AK_SUBDIRS) {
-      const subdirPath = join9(target.path, subdir);
-      if (fs9.existsSync(subdirPath)) {
+      const subdirPath = join13(target.path, subdir);
+      if (fs13.existsSync(subdirPath)) {
         removalList.push(subdirPath);
       }
     }
@@ -2917,7 +3306,7 @@ async function removeItems(paths, baseDir) {
       continue;
     }
     try {
-      await fs9.remove(path);
+      await fs13.remove(path);
       result.removed.push(path);
     } catch (error) {
       result.errors.push({
@@ -3031,10 +3420,10 @@ import { execSync as execSync2 } from "child_process";
 import pc11 from "picocolors";
 import ora6 from "ora";
 import { readFileSync } from "fs";
-import { join as join10 } from "path";
+import { join as join14 } from "path";
 function getCurrentVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(join10(CLI_ROOT, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync(join14(CLI_ROOT, "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0";
@@ -3094,8 +3483,8 @@ __export(skills_exports, {
   skillsCommand: () => skillsCommand
 });
 import pc12 from "picocolors";
-import fs10 from "fs-extra";
-import { join as join11 } from "path";
+import fs14 from "fs-extra";
+import { join as join15 } from "path";
 import * as p3 from "@clack/prompts";
 async function skillsCommand(options) {
   const { name, agent, list, installed, uninstall, yes } = options;
@@ -3173,8 +3562,8 @@ async function installSkill(skillName, agents, skipConfirm) {
     console.log(pc12.red(`Error: ${source.error}`));
     process.exit(1);
   }
-  const skillPath = join11(source.claudeDir, "skills", skillName);
-  if (!fs10.existsSync(skillPath)) {
+  const skillPath = join15(source.claudeDir, "skills", skillName);
+  if (!fs14.existsSync(skillPath)) {
     console.log(pc12.red(`Error: Skill "${skillName}" not found in source`));
     console.log(pc12.gray(`Available skills: ak skills --list`));
     process.exit(1);
@@ -3191,9 +3580,9 @@ async function installSkill(skillName, agents, skipConfirm) {
   const results = [];
   for (const agent of agents) {
     try {
-      const targetPath = join11(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
-      await fs10.ensureDir(join11(process.cwd(), AGENT_SKILL_PATHS[agent]));
-      await fs10.copy(skillPath, targetPath, { overwrite: true });
+      const targetPath = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs14.ensureDir(join15(process.cwd(), AGENT_SKILL_PATHS[agent]));
+      await fs14.copy(skillPath, targetPath, { overwrite: true });
       results.push({ agent, success: true });
     } catch (err) {
       results.push({ agent, success: false, error: err.message });
@@ -3232,8 +3621,8 @@ async function uninstallSkill(skillName, agents, skipConfirm) {
   const results = [];
   for (const agent of installedIn) {
     try {
-      const targetPath = join11(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
-      await fs10.remove(targetPath);
+      const targetPath = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs14.remove(targetPath);
       results.push({ agent, success: true });
     } catch (err) {
       results.push({ agent, success: false, error: err.message });
@@ -3268,19 +3657,19 @@ function parseAgents(agentFlag) {
   return valid;
 }
 function isSkillInstalled(skillName, agent) {
-  const skillPath = join11(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
-  return fs10.existsSync(skillPath);
+  const skillPath = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+  return fs14.existsSync(skillPath);
 }
 function getInstalledSkills(agent) {
-  const skillsDir = join11(process.cwd(), AGENT_SKILL_PATHS[agent]);
-  if (!fs10.existsSync(skillsDir)) {
+  const skillsDir = join15(process.cwd(), AGENT_SKILL_PATHS[agent]);
+  if (!fs14.existsSync(skillsDir)) {
     return [];
   }
   try {
-    const items = fs10.readdirSync(skillsDir);
+    const items = fs14.readdirSync(skillsDir);
     return items.filter((item) => {
-      const itemPath = join11(skillsDir, item);
-      return fs10.statSync(itemPath).isDirectory();
+      const itemPath = join15(skillsDir, item);
+      return fs14.statSync(itemPath).isDirectory();
     });
   } catch {
     return [];
@@ -3304,7 +3693,7 @@ var init_skills = __esm({
 import cac from "cac";
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname3, join as join13 } from "path";
+import { dirname as dirname6, join as join17 } from "path";
 import pc13 from "picocolors";
 
 // src/cli/command-registry.ts
@@ -3360,11 +3749,11 @@ function registerCommands(cli2) {
 }
 
 // src/utils/version-check.ts
-import { join as join12 } from "path";
+import { join as join16 } from "path";
 import { homedir as homedir2 } from "os";
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-var CACHE_DIR = join12(homedir2(), ".apero-kit");
-var CACHE_FILE = join12(CACHE_DIR, "version-check.json");
+var CACHE_DIR = join16(homedir2(), ".apero-kit");
+var CACHE_FILE = join16(CACHE_DIR, "version-check.json");
 var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
 function getCachedVersionNoFetch() {
   try {
@@ -3388,10 +3777,10 @@ function isNewerVersion(current, latest) {
 
 // src/index.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname3(__filename2);
+var __dirname2 = dirname6(__filename2);
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(join13(__dirname2, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync3(join17(__dirname2, "..", "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0";