@orderful/droid 0.16.0 → 0.17.0

package/dist/bin/droid.js

@@ -1,57 +1,3067 @@
 #!/usr/bin/env node
-import { program } from 'commander';
-import { setupCommand } from '../commands/setup';
-import { configCommand } from '../commands/config';
-import { skillsCommand } from '../commands/skills';
-import { installCommand } from '../commands/install';
-import { uninstallCommand } from '../commands/uninstall';
-import { updateCommand } from '../commands/update';
-import { tuiCommand } from '../commands/tui';
-import { getVersion } from '../lib/version';
-const version = getVersion();
-program
-    .name('droid')
-    .description('Droid, teaching your AI new tricks')
-    .version(version);
-program
-    .command('setup')
-    .description('Interactive wizard for global configuration')
-    .action(setupCommand);
-program
-    .command('config')
-    .description('View or edit configuration')
-    .option('-e, --edit', 'Open config in editor')
-    .option('-g, --get <key>', 'Get a specific config value')
-    .option('-s, --set <key=value>', 'Set a config value')
-    .action(configCommand);
-program
-    .command('tools')
-    .description('Browse and manage available tools')
-    .action(skillsCommand);
-program
-    .command('install <tool>')
-    .description('Install a tool and run its setup wizard')
-    .action(installCommand);
-program
-    .command('uninstall <tool>')
-    .description('Uninstall a tool')
-    .action(uninstallCommand);
-program
-    .command('update')
-    .description('Update droid and installed tools')
-    .option('--tools', 'Only update tools')
-    .option('--cli', 'Only update the CLI')
-    .argument('[tool]', 'Update a specific tool')
-    .action(updateCommand);
-program
-    .command('tui')
-    .description('Launch interactive TUI dashboard')
-    .action(tuiCommand);
-// If no command provided, launch TUI
-if (process.argv.length === 2) {
-    tuiCommand();
+
+// src/bin/droid.ts
+import { program } from "commander";
+
+// src/commands/setup.ts
+import inquirer from "inquirer";
+import chalk2 from "chalk";
+import { execSync as execSync2 } from "child_process";
+import { existsSync as existsSync5, readFileSync as readFileSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/lib/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import YAML from "yaml";
+
+// src/lib/types.ts
+function getPlatformTools(config) {
+  return config.platforms[config.platform]?.tools ?? {};
+}
+function setPlatformTools(config, tools) {
+  if (!config.platforms[config.platform]) {
+    config.platforms[config.platform] = { tools: {} };
+  }
+  config.platforms[config.platform].tools = tools;
+}
+
+// src/lib/config.ts
+var CONFIG_DIR = join(homedir(), ".droid");
+var CONFIG_FILE = join(CONFIG_DIR, "config.yaml");
+var DEFAULT_AUTO_UPDATE = {
+  app: false,
+  // Opt-in: user must enable
+  tools: true
+  // Opt-out: enabled by default (tools only update when app updates)
+};
+var DEFAULT_CONFIG = {
+  platform: "claude-code" /* ClaudeCode */,
+  user_mention: "@user",
+  output_preference: "terminal" /* Terminal */,
+  git_username: "",
+  platforms: {}
+};
+function migrateConfig(config) {
+  if ("ai_tool" in config && !("platform" in config)) {
+    const legacyConfig = config;
+    return {
+      platform: legacyConfig.ai_tool,
+      user_mention: legacyConfig.user_mention ?? DEFAULT_CONFIG.user_mention,
+      output_preference: legacyConfig.output_preference ?? DEFAULT_CONFIG.output_preference,
+      git_username: legacyConfig.git_username ?? DEFAULT_CONFIG.git_username,
+      platforms: {
+        [legacyConfig.ai_tool]: {
+          tools: legacyConfig.skills ?? {}
+        }
+      }
+    };
+  }
+  return {
+    ...DEFAULT_CONFIG,
+    ...config,
+    platforms: config.platforms ?? {}
+  };
+}
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+function configExists() {
+  return existsSync(CONFIG_FILE);
+}
+function loadConfig() {
+  ensureConfigDir();
+  if (!existsSync(CONFIG_FILE)) {
+    return { ...DEFAULT_CONFIG };
+  }
+  try {
+    const content = readFileSync(CONFIG_FILE, "utf-8");
+    const rawConfig = YAML.parse(content);
+    const needsMigration = "ai_tool" in rawConfig && !("platform" in rawConfig);
+    const config = migrateConfig(rawConfig);
+    if (needsMigration) {
+      saveConfig(config);
+    }
+    return config;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    console.error(`Error reading config: ${message}`);
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  const content = YAML.stringify(config, { indent: 2 });
+  writeFileSync(CONFIG_FILE, content, "utf-8");
+}
+function getConfigValue(key) {
+  const config = loadConfig();
+  const keys = key.split(".");
+  let value = config;
+  for (const k of keys) {
+    if (value === void 0 || value === null || typeof value !== "object") {
+      return void 0;
+    }
+    value = value[k];
+  }
+  return value;
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  const keys = key.split(".");
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (current[keys[i]] === void 0) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+  saveConfig(config);
+}
+function getConfigPath() {
+  return CONFIG_FILE;
+}
+function getSkillOverridesPath(skillName) {
+  return join(CONFIG_DIR, "skills", skillName, "overrides.yaml");
+}
+function loadSkillOverrides(skillName) {
+  const overridesPath = getSkillOverridesPath(skillName);
+  if (!existsSync(overridesPath)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(overridesPath, "utf-8");
+    return YAML.parse(content) || {};
+  } catch {
+    return {};
+  }
+}
+function saveSkillOverrides(skillName, overrides) {
+  const overridesPath = getSkillOverridesPath(skillName);
+  const skillDir = join(CONFIG_DIR, "skills", skillName);
+  if (!existsSync(skillDir)) {
+    mkdirSync(skillDir, { recursive: true });
+  }
+  const content = YAML.stringify(overrides, { indent: 2 });
+  writeFileSync(overridesPath, content, "utf-8");
+}
+function getAutoUpdateConfig() {
+  const config = loadConfig();
+  return {
+    ...DEFAULT_AUTO_UPDATE,
+    ...config.auto_update
+  };
+}
+function setAutoUpdateConfig(updates) {
+  const config = loadConfig();
+  config.auto_update = {
+    ...DEFAULT_AUTO_UPDATE,
+    ...config.auto_update,
+    ...updates
+  };
+  saveConfig(config);
+}
+
+// src/lib/skills.ts
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync5, mkdirSync as mkdirSync3, writeFileSync as writeFileSync3, rmSync } from "fs";
+import { join as join6, dirname as dirname4 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import YAML4 from "yaml";
+
+// src/lib/agents.ts
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
+import { join as join5, dirname as dirname3 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+import YAML3 from "yaml";
+
+// src/lib/platforms.ts
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var PLATFORM_PATHS = {
+  ["claude-code" /* ClaudeCode */]: {
+    skills: join2(homedir2(), ".claude", "skills"),
+    commands: join2(homedir2(), ".claude", "commands"),
+    agents: join2(homedir2(), ".claude", "agents"),
+    config: join2(homedir2(), ".claude", "CLAUDE.md")
+  },
+  ["opencode" /* OpenCode */]: {
+    skills: join2(homedir2(), ".config", "opencode", "skills"),
+    commands: join2(homedir2(), ".config", "opencode", "command"),
+    agents: join2(homedir2(), ".config", "opencode", "agent"),
+    config: join2(homedir2(), ".config", "opencode", "AGENTS.md")
+  }
+};
+function getSkillsPath(platform) {
+  return PLATFORM_PATHS[platform].skills;
+}
+function getCommandsPath(platform) {
+  return PLATFORM_PATHS[platform].commands;
+}
+function getAgentsPath(platform) {
+  return PLATFORM_PATHS[platform].agents;
+}
+function getConfigPath2(platform) {
+  return PLATFORM_PATHS[platform].config;
+}
+
+// src/lib/tools.ts
+import { existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "fs";
+import { join as join4, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import YAML2 from "yaml";
+
+// src/lib/version.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join as join3 } from "path";
+import { execSync } from "child_process";
+import chalk from "chalk";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var packageJsonPath = join3(__dirname, "../../package.json");
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf-8"));
+    return pkg.version;
+  } catch {
+    return "0.0.0";
+  }
+}
+function compareSemver(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const numA = partsA[i] || 0;
+    const numB = partsB[i] || 0;
+    if (numA > numB) return 1;
+    if (numA < numB) return -1;
+  }
+  return 0;
+}
+function getUpdateInfo() {
+  const currentVersion = getVersion();
+  try {
+    const latestVersion = execSync("npm view @orderful/droid version 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 3e3
+    }).trim();
+    return {
+      hasUpdate: latestVersion ? compareSemver(latestVersion, currentVersion) > 0 : false,
+      currentVersion,
+      latestVersion: latestVersion || null
+    };
+  } catch {
+    return {
+      hasUpdate: false,
+      currentVersion,
+      latestVersion: null
+    };
+  }
+}
+function runUpdate() {
+  try {
+    execSync("npm install -g @orderful/droid@latest", {
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: 6e4
+    });
+    return { success: true, message: "Update complete!" };
+  } catch (error) {
+    return { success: false, message: `Update failed: ${error}` };
+  }
+}
+
+// src/lib/tools.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var BUNDLED_TOOLS_DIR = join4(__dirname2, "../tools");
+function getBundledToolsDir() {
+  return BUNDLED_TOOLS_DIR;
+}
+function loadToolManifest(toolDir) {
+  const manifestPath = join4(toolDir, "TOOL.yaml");
+  if (!existsSync2(manifestPath)) {
+    return null;
+  }
+  try {
+    const content = readFileSync3(manifestPath, "utf-8");
+    const parsed = YAML2.parse(content);
+    const includes = {
+      skills: parsed.includes?.skills || [],
+      commands: parsed.includes?.commands || [],
+      agents: parsed.includes?.agents || []
+    };
+    return {
+      ...parsed,
+      includes
+    };
+  } catch {
+    return null;
+  }
+}
+function getBundledTools() {
+  if (!existsSync2(BUNDLED_TOOLS_DIR)) {
+    return [];
+  }
+  const toolDirs = readdirSync(BUNDLED_TOOLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  const tools = [];
+  for (const toolName of toolDirs) {
+    const manifest = loadToolManifest(join4(BUNDLED_TOOLS_DIR, toolName));
+    if (manifest) {
+      tools.push(manifest);
+    }
+  }
+  return tools;
+}
+function isToolInstalled(toolName) {
+  const config = loadConfig();
+  const installedTools = getPlatformTools(config);
+  const tool = getBundledTools().find((t) => t.name === toolName);
+  if (!tool) return false;
+  const requiredSkills = tool.includes.skills.filter((s) => s.required).map((s) => s.name);
+  return requiredSkills.some((skillName) => skillName in installedTools);
+}
+function getInstalledToolVersion(toolName) {
+  const config = loadConfig();
+  const installedTools = getPlatformTools(config);
+  const tool = getBundledTools().find((t) => t.name === toolName);
+  if (!tool) return null;
+  const requiredSkills = tool.includes.skills.filter((s) => s.required).map((s) => s.name);
+  for (const skillName of requiredSkills) {
+    if (installedTools[skillName]) {
+      return installedTools[skillName].version;
+    }
+  }
+  return null;
+}
+function getToolUpdateStatus(toolName) {
+  const installedVersion = getInstalledToolVersion(toolName);
+  const tool = getBundledTools().find((t) => t.name === toolName);
+  const bundledVersion = tool?.version || null;
+  if (!installedVersion || !bundledVersion) {
+    return {
+      name: toolName,
+      hasUpdate: false,
+      installedVersion,
+      bundledVersion
+    };
+  }
+  const hasUpdate = compareSemver(bundledVersion, installedVersion) > 0;
+  return {
+    name: toolName,
+    hasUpdate,
+    installedVersion,
+    bundledVersion
+  };
+}
+function getToolsWithUpdates() {
+  const config = loadConfig();
+  const installedTools = getPlatformTools(config);
+  const bundledTools = getBundledTools();
+  const toolsWithUpdates = [];
+  for (const tool of bundledTools) {
+    const requiredSkills = tool.includes.skills.filter((s) => s.required).map((s) => s.name);
+    const isInstalled = requiredSkills.some((skillName) => skillName in installedTools);
+    if (isInstalled) {
+      const updateStatus = getToolUpdateStatus(tool.name);
+      if (updateStatus.hasUpdate) {
+        toolsWithUpdates.push(updateStatus);
+      }
+    }
+  }
+  return toolsWithUpdates;
+}
+
+// src/lib/agents.ts
+var __dirname3 = dirname3(fileURLToPath3(import.meta.url));
+var BUNDLED_TOOLS_DIR2 = join5(__dirname3, "../tools");
+function getAgentsInstallPath(platform) {
+  return getAgentsPath(platform);
+}
+function parseAgentFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endMatch = trimmed.slice(3).indexOf("---");
+  if (endMatch === -1) {
+    return null;
+  }
+  const frontmatterContent = trimmed.slice(3, 3 + endMatch);
+  try {
+    return YAML3.parse(frontmatterContent);
+  } catch {
+    return null;
+  }
+}
+function loadAgentManifest(agentPath) {
+  if (!existsSync3(agentPath)) {
+    return null;
+  }
+  const content = readFileSync4(agentPath, "utf-8");
+  const frontmatter = parseAgentFrontmatter(content);
+  if (!frontmatter || !frontmatter.name) {
+    return null;
+  }
+  const toolDir = dirname3(dirname3(agentPath));
+  const toolManifest = loadToolManifest(toolDir);
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description || "",
+    version: toolManifest?.version || "0.0.0",
+    status: toolManifest?.status,
+    mode: frontmatter.mode,
+    model: frontmatter.model,
+    color: frontmatter.color,
+    tools: frontmatter.tools
+  };
+}
+function getInstalledAgentsDir() {
+  const config = loadConfig();
+  return getAgentsInstallPath(config.platform);
+}
+function isAgentInstalled(agentName) {
+  const config = loadConfig();
+  const agentsDir = getAgentsInstallPath(config.platform);
+  const agentPath = join5(agentsDir, `${agentName}.md`);
+  return existsSync3(agentPath);
+}
+function generateClaudeCodeAgent(manifest, agentContent) {
+  const lines = [
+    "---",
+    `name: ${manifest.name}`,
+    `description: ${manifest.description}`
+  ];
+  if (manifest.tools && manifest.tools.length > 0) {
+    lines.push(`tools: ${manifest.tools.join(", ")}`);
+  }
+  if (manifest.color) {
+    lines.push(`color: ${manifest.color}`);
+  }
+  lines.push("---", "", agentContent.trim(), "");
+  return lines.join("\n");
+}
+function generateOpenCodeAgent(manifest, agentContent) {
+  const lines = [
+    "---",
+    `description: ${manifest.description}`,
+    `mode: ${manifest.mode || "subagent"}`
+  ];
+  if (manifest.tools && manifest.tools.length > 0) {
+    lines.push("tools:");
+    for (const tool of manifest.tools) {
+      const toolName = tool.toLowerCase();
+      lines.push(`  ${toolName}: true`);
+    }
+  }
+  lines.push("---", "", agentContent.trim(), "");
+  return lines.join("\n");
+}
+function installAgentFromPath(agentPath, agentName) {
+  const config = loadConfig();
+  const manifest = loadAgentManifest(agentPath);
+  if (!manifest) {
+    return { success: false, message: `Agent manifest not found: ${agentName}` };
+  }
+  try {
+    const rawContent = readFileSync4(agentPath, "utf-8");
+    const frontmatterMatch = rawContent.match(/^---\n[\s\S]*?\n---\n?/);
+    const agentContent = frontmatterMatch ? rawContent.slice(frontmatterMatch[0].length) : rawContent;
+    const installedContent = config.platform === "claude-code" /* ClaudeCode */ ? generateClaudeCodeAgent(manifest, agentContent) : generateOpenCodeAgent(manifest, agentContent);
+    const agentsDir = getAgentsInstallPath(config.platform);
+    if (!existsSync3(agentsDir)) {
+      mkdirSync2(agentsDir, { recursive: true });
+    }
+    const outputPath = join5(agentsDir, `${agentName}.md`);
+    writeFileSync2(outputPath, installedContent);
+    const targetDir = config.platform === "claude-code" /* ClaudeCode */ ? "~/.claude/agents/" : "~/.config/opencode/agent/";
+    return { success: true, message: `Installed ${agentName} to ${targetDir}` };
+  } catch (error) {
+    return { success: false, message: `Failed to install agent: ${error}` };
+  }
+}
+function uninstallAgent(agentName) {
+  const config = loadConfig();
+  const agentsDir = getAgentsInstallPath(config.platform);
+  const agentPath = join5(agentsDir, `${agentName}.md`);
+  if (!existsSync3(agentPath)) {
+    return { success: false, message: `Agent not installed: ${agentName}` };
+  }
+  try {
+    unlinkSync(agentPath);
+    return { success: true, message: `Uninstalled ${agentName}` };
+  } catch (error) {
+    return { success: false, message: `Failed to uninstall agent: ${error}` };
+  }
+}
+
+// src/lib/skills.ts
+var DROID_SKILLS_START = "<!-- droid-skills-start -->";
+var DROID_SKILLS_END = "<!-- droid-skills-end -->";
+var __dirname4 = dirname4(fileURLToPath4(import.meta.url));
+var BUNDLED_SKILLS_DIR = join6(__dirname4, "../tools");
+function getSkillsInstallPath(platform) {
+  return getSkillsPath(platform);
+}
+function getCommandsInstallPath(platform) {
+  return getCommandsPath(platform);
+}
+function getPlatformConfigPath(platform) {
+  return getConfigPath2(platform);
 }
-else {
-    program.parse();
+function updatePlatformConfigSkills(platform, installedSkills) {
+  const configPath = getPlatformConfigPath(platform);
+  let content = "";
+  if (existsSync4(configPath)) {
+    content = readFileSync5(configPath, "utf-8");
+  }
+  const skillLines = installedSkills.map((name) => {
+    const relativePath = `skills/${name}/SKILL.md`;
+    return `- [${name}](${relativePath})`;
+  });
+  const skillsSection = installedSkills.length > 0 ? `${DROID_SKILLS_START}
+## Droid Skills
+
+${skillLines.join("\n")}
+${DROID_SKILLS_END}` : "";
+  const startIdx = content.indexOf(DROID_SKILLS_START);
+  const endIdx = content.indexOf(DROID_SKILLS_END);
+  if (startIdx !== -1 && endIdx !== -1) {
+    content = content.slice(0, startIdx) + skillsSection + content.slice(endIdx + DROID_SKILLS_END.length);
+  } else if (skillsSection) {
+    content = content.trim() + "\n\n" + skillsSection + "\n";
+  }
+  const configDir = dirname4(configPath);
+  if (!existsSync4(configDir)) {
+    mkdirSync3(configDir, { recursive: true });
+  }
+  writeFileSync3(configPath, content, "utf-8");
+}
+function parseSkillFrontmatter(content) {
+  const trimmed = content.trimStart();
+  if (!trimmed.startsWith("---")) {
+    return null;
+  }
+  const endMatch = trimmed.slice(3).indexOf("---");
+  if (endMatch === -1) {
+    return null;
+  }
+  const frontmatterContent = trimmed.slice(3, 3 + endMatch);
+  try {
+    return YAML4.parse(frontmatterContent);
+  } catch {
+    return null;
+  }
+}
+function loadSkillManifest(skillDir) {
+  const skillMdPath = join6(skillDir, "SKILL.md");
+  if (!existsSync4(skillMdPath)) {
+    return null;
+  }
+  const content = readFileSync5(skillMdPath, "utf-8");
+  const frontmatter = parseSkillFrontmatter(content);
+  if (!frontmatter || !frontmatter.name) {
+    return null;
+  }
+  const toolDir = dirname4(dirname4(skillDir));
+  const toolManifest = loadToolManifest(toolDir);
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description || "",
+    version: toolManifest?.version || "0.0.0",
+    status: toolManifest?.status,
+    dependencies: toolManifest?.dependencies,
+    config_schema: toolManifest?.config_schema
+  };
+}
+function findSkillPath(skillName) {
+  if (!existsSync4(BUNDLED_SKILLS_DIR)) {
+    return null;
+  }
+  const toolDirs = readdirSync3(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  for (const toolName of toolDirs) {
+    const skillsDir = join6(BUNDLED_SKILLS_DIR, toolName, "skills");
+    if (!existsSync4(skillsDir)) continue;
+    const skillDir = join6(skillsDir, skillName);
+    if (existsSync4(skillDir) && existsSync4(join6(skillDir, "SKILL.md"))) {
+      return {
+        toolDir: join6(BUNDLED_SKILLS_DIR, toolName),
+        skillDir
+      };
+    }
+  }
+  return null;
+}
+function getBundledSkills() {
+  if (!existsSync4(BUNDLED_SKILLS_DIR)) {
+    return [];
+  }
+  const toolDirs = readdirSync3(BUNDLED_SKILLS_DIR, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+  const skills = [];
+  for (const toolName of toolDirs) {
+    const skillsDir = join6(BUNDLED_SKILLS_DIR, toolName, "skills");
+    if (!existsSync4(skillsDir)) continue;
+    const skillSubdirs = readdirSync3(skillsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    for (const skillName of skillSubdirs) {
+      const manifest = loadSkillManifest(join6(skillsDir, skillName));
+      if (manifest) {
+        skills.push(manifest);
+      }
+    }
+  }
+  return skills;
+}
+function isSkillInstalled(skillName) {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  return skillName in tools;
+}
+function getInstalledSkill(skillName) {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  return tools[skillName] || null;
+}
+function getSkillUpdateStatus(skillName) {
+  const installed = getInstalledSkill(skillName);
+  const skillPath = findSkillPath(skillName);
+  const manifest = skillPath ? loadSkillManifest(skillPath.skillDir) : null;
+  if (!installed || !manifest) {
+    return {
+      hasUpdate: false,
+      installedVersion: installed?.version || null,
+      bundledVersion: manifest?.version || null
+    };
+  }
+  return {
+    hasUpdate: manifest.version !== installed.version,
+    installedVersion: installed.version,
+    bundledVersion: manifest.version
+  };
+}
+function updateSkill(skillName) {
+  const status = getSkillUpdateStatus(skillName);
+  if (!status.installedVersion) {
+    return { success: false, message: `Skill '${skillName}' is not installed` };
+  }
+  if (!status.bundledVersion) {
+    return { success: false, message: `Skill '${skillName}' not found in bundled skills` };
+  }
+  if (!status.hasUpdate) {
+    return { success: false, message: `Skill '${skillName}' is already at latest version (${status.installedVersion})` };
+  }
+  const result = installSkill(skillName);
+  if (result.success) {
+    return {
+      success: true,
+      message: `Updated ${skillName} from ${status.installedVersion} to ${status.bundledVersion}`
+    };
+  }
+  return result;
+}
+function installSkill(skillName) {
+  const config = loadConfig();
+  const skillPath = findSkillPath(skillName);
+  if (!skillPath) {
+    return { success: false, message: `Skill '${skillName}' not found` };
+  }
+  const { toolDir, skillDir } = skillPath;
+  const manifest = loadSkillManifest(skillDir);
+  if (!manifest) {
+    return { success: false, message: `Invalid skill manifest for '${skillName}'` };
+  }
+  if (manifest.dependencies) {
+    for (const dep of manifest.dependencies) {
+      if (!isSkillInstalled(dep)) {
+        return {
+          success: false,
+          message: `Missing dependency: '${dep}'. Install it first with \`droid install ${dep}\``
+        };
+      }
+    }
+  }
+  const skillsPath = getSkillsInstallPath(config.platform);
+  const targetSkillDir = join6(skillsPath, skillName);
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const tools = getPlatformTools(config);
+  const commandsSource = join6(toolDir, "commands");
+  const agentsSource = join6(toolDir, "agents");
+  if (!tools[skillName]) {
+    if (existsSync4(commandsSource)) {
+      const commandFiles = readdirSync3(commandsSource).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+      for (const file of commandFiles) {
+        const targetCommandPath = join6(commandsPath, file);
+        if (existsSync4(targetCommandPath)) {
+          const commandName = file.replace(".md", "");
+          return {
+            success: false,
+            message: `Cannot install: command /${commandName} already exists at ${targetCommandPath}`
+          };
+        }
+      }
+    }
+    if (existsSync4(agentsSource)) {
+      const agentDirs = readdirSync3(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+      for (const agentName of agentDirs) {
+        if (isAgentInstalled(agentName)) {
+          return {
+            success: false,
+            message: `Cannot install: agent '${agentName}' already exists at ${getInstalledAgentsDir()}`
+          };
+        }
+      }
+    }
+  }
+  if (!existsSync4(skillsPath)) {
+    mkdirSync3(skillsPath, { recursive: true });
+  }
+  const skillMdSource = join6(skillDir, "SKILL.md");
+  if (existsSync4(skillMdSource)) {
+    if (!existsSync4(targetSkillDir)) {
+      mkdirSync3(targetSkillDir, { recursive: true });
+    }
+    const skillMdTarget = join6(targetSkillDir, "SKILL.md");
+    const content = readFileSync5(skillMdSource, "utf-8");
+    writeFileSync3(skillMdTarget, content);
+  }
+  const referencesSource = join6(skillDir, "references");
+  if (existsSync4(referencesSource)) {
+    const targetReferencesDir = join6(targetSkillDir, "references");
+    if (!existsSync4(targetReferencesDir)) {
+      mkdirSync3(targetReferencesDir, { recursive: true });
+    }
+    const referenceFiles = readdirSync3(referencesSource).filter((f) => f.endsWith(".md"));
+    for (const file of referenceFiles) {
+      const sourcePath = join6(referencesSource, file);
+      const targetPath = join6(targetReferencesDir, file);
+      const content = readFileSync5(sourcePath, "utf-8");
+      writeFileSync3(targetPath, content);
+    }
+  }
+  if (existsSync4(commandsSource)) {
+    if (!existsSync4(commandsPath)) {
+      mkdirSync3(commandsPath, { recursive: true });
+    }
+    const commandFiles = readdirSync3(commandsSource).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+    for (const file of commandFiles) {
+      const sourcePath = join6(commandsSource, file);
+      const targetPath = join6(commandsPath, file);
+      const content = readFileSync5(sourcePath, "utf-8");
+      writeFileSync3(targetPath, content);
+    }
+  }
+  const installedAgents = [];
+  if (existsSync4(agentsSource)) {
+    const agentDirs = readdirSync3(agentsSource, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    for (const agentName of agentDirs) {
+      const agentDir = join6(agentsSource, agentName);
+      const result = installAgentFromPath(agentDir, agentName);
+      if (result.success) {
+        installedAgents.push(agentName);
+      }
+    }
+  }
+  const updatedTools = {
+    ...tools,
+    [skillName]: {
+      version: manifest.version,
+      installed_at: (/* @__PURE__ */ new Date()).toISOString(),
+      ...installedAgents.length > 0 && { bundled_agents: installedAgents }
+    }
+  };
+  setPlatformTools(config, updatedTools);
+  saveConfig(config);
+  const installedSkillNames = Object.keys(updatedTools);
+  updatePlatformConfigSkills(config.platform, installedSkillNames);
+  return { success: true, message: `Installed ${skillName} v${manifest.version}` };
+}
+function uninstallSkill(skillName) {
+  const config = loadConfig();
+  const tools = getPlatformTools(config);
+  if (!isSkillInstalled(skillName)) {
+    return { success: false, message: `Skill '${skillName}' is not installed` };
+  }
+  const skillsPath = getSkillsInstallPath(config.platform);
+  const skillDir = join6(skillsPath, skillName);
+  if (existsSync4(skillDir)) {
+    rmSync(skillDir, { recursive: true });
+  }
+  const skillPath = findSkillPath(skillName);
+  const commandsPath = getCommandsInstallPath(config.platform);
+  const commandsSource = skillPath ? join6(skillPath.toolDir, "commands") : null;
+  if (commandsSource && existsSync4(commandsSource)) {
+    const commandFiles = readdirSync3(commandsSource).filter((f) => f.endsWith(".md") && f.toLowerCase() !== "readme.md");
+    for (const file of commandFiles) {
+      const commandPath = join6(commandsPath, file);
+      if (existsSync4(commandPath)) {
+        rmSync(commandPath);
+      }
+    }
+  }
+  const installedSkillInfo = tools[skillName];
+  if (installedSkillInfo?.bundled_agents) {
+    for (const agentName of installedSkillInfo.bundled_agents) {
+      uninstallAgent(agentName);
+    }
+  }
+  const { [skillName]: removed, ...remainingTools } = tools;
+  setPlatformTools(config, remainingTools);
+  saveConfig(config);
+  const installedSkillNames = Object.keys(remainingTools);
+  updatePlatformConfigSkills(config.platform, installedSkillNames);
+  return { success: true, message: `Uninstalled ${skillName}` };
+}
+
+// src/commands/setup.ts
+var DROID_PERMISSIONS = [
+  "Read(~/.droid/**)",
+  "Write(~/.droid/**)",
+  "Edit(~/.droid/**)",
+  "Glob(~/.droid/**)",
+  "Grep(~/.droid/**)"
+];
+function detectPlatform() {
+  try {
+    execSync2("claude --version", { stdio: "ignore" });
+    return "claude-code" /* ClaudeCode */;
+  } catch {
+  }
+  try {
+    execSync2("opencode --version", { stdio: "ignore" });
+    return "opencode" /* OpenCode */;
+  } catch {
+  }
+  return null;
+}
+function detectGitUsername() {
+  try {
+    return execSync2("git config user.name", { encoding: "utf-8" }).trim();
+  } catch {
+    return "";
+  }
+}
+var OPENCODE_SKILLS_PLUGIN = "opencode-skills";
+function configurePlatformPermissions(platform) {
+  const added = [];
+  if (platform === "claude-code" /* ClaudeCode */) {
+    const settingsPath = join7(homedir3(), ".claude", "settings.json");
+    const claudeDir = join7(homedir3(), ".claude");
+    if (!existsSync5(claudeDir)) {
+      mkdirSync4(claudeDir, { recursive: true });
+    }
+    let settings = {};
+    if (existsSync5(settingsPath)) {
+      try {
+        settings = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+      } catch {
+        console.warn(chalk2.yellow("\u26A0 Claude Code settings.json appears corrupted, resetting permissions"));
+        settings = {};
+      }
+    }
+    if (!settings.permissions) {
+      settings.permissions = {};
+    }
+    if (!Array.isArray(settings.permissions.allow)) {
+      settings.permissions.allow = [];
+    }
+    for (const perm of DROID_PERMISSIONS) {
+      if (!settings.permissions.allow.includes(perm)) {
+        settings.permissions.allow.push(perm);
+        added.push(perm);
+      }
+    }
+    if (added.length > 0) {
+      try {
+        writeFileSync4(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
+      } catch (e) {
+        const message = e instanceof Error ? e.message : "Unknown error";
+        return { added: [], alreadyPresent: false, error: `Failed to update Claude Code settings: ${message}` };
+      }
+    }
+    return { added, alreadyPresent: added.length === 0 };
+  }
+  if (platform === "opencode" /* OpenCode */) {
+    const globalConfigDir = join7(homedir3(), ".config", "opencode");
+    const globalConfigPath = join7(globalConfigDir, "opencode.json");
+    if (!existsSync5(globalConfigDir)) {
+      mkdirSync4(globalConfigDir, { recursive: true });
+    }
+    let config = {};
+    if (existsSync5(globalConfigPath)) {
+      try {
+        config = JSON.parse(readFileSync6(globalConfigPath, "utf-8"));
+      } catch {
+        console.warn(chalk2.yellow("\u26A0 OpenCode config appears corrupted, resetting"));
+        config = {};
+      }
+    }
+    if (!Array.isArray(config.plugin)) {
+      config.plugin = [];
+    }
+    if (!config.plugin.includes(OPENCODE_SKILLS_PLUGIN)) {
+      config.plugin.push(OPENCODE_SKILLS_PLUGIN);
+      added.push(OPENCODE_SKILLS_PLUGIN);
+    }
+    if (added.length > 0) {
+      try {
+        writeFileSync4(globalConfigPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+      } catch (e) {
+        const message = e instanceof Error ? e.message : "Unknown error";
+        return { added: [], alreadyPresent: false, error: `Failed to update OpenCode config: ${message}` };
+      }
+    }
+    return { added, alreadyPresent: added.length === 0 };
+  }
+  return { added: [], alreadyPresent: true };
+}
+function getOutputOptions() {
+  const options = [
+    { name: "Terminal (display in CLI)", value: "terminal" /* Terminal */ },
+    { name: "Editor ($EDITOR)", value: "editor" /* Editor */ }
+  ];
+  const skills = getBundledSkills();
+  for (const skill of skills) {
+    if (skill.provides_output) {
+      options.push({
+        name: `${skill.name} (${skill.description})`,
+        value: skill.name
+      });
+    }
+  }
+  return options;
+}
+async function setupCommand() {
+  console.log(chalk2.bold("\n\u{1F916} Droid Setup\n"));
+  const hasExistingConfig = configExists();
+  if (hasExistingConfig) {
+    const { overwrite } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "overwrite",
+        message: "Config already exists. Overwrite?",
+        default: false
+      }
+    ]);
+    if (!overwrite) {
+      console.log(chalk2.gray("Setup cancelled."));
+      return;
+    }
+  }
+  const detectedPlatform = detectPlatform();
+  if (detectedPlatform) {
+    console.log(chalk2.green(`\u2713 Detected ${detectedPlatform}
+`));
+  } else {
+    console.log(chalk2.yellow("\u26A0 No platform detected (Claude Code or OpenCode)\n"));
+  }
+  const detectedGitUsername = detectGitUsername();
+  const outputOptions = getOutputOptions();
+  const answers = await inquirer.prompt([
+    {
+      type: "list",
+      name: "platform",
+      message: "Which platform are you using?",
+      choices: [
+        { name: "Claude Code", value: "claude-code" /* ClaudeCode */ },
+        { name: "OpenCode", value: "opencode" /* OpenCode */ }
+      ],
+      default: detectedPlatform || "claude-code" /* ClaudeCode */
+    },
+    {
+      type: "input",
+      name: "user_mention",
+      message: "What @mention should be used for you?",
+      default: "@user",
+      filter: (input) => {
+        return input.startsWith("@") ? input : `@${input}`;
+      }
+    },
+    {
+      type: "list",
+      name: "output_preference",
+      message: "Default output preference for skill results?",
+      choices: outputOptions,
+      default: "terminal" /* Terminal */
+    },
+    {
+      type: "input",
+      name: "git_username",
+      message: "Git username for attribution?",
+      default: detectedGitUsername || ""
+    }
+  ]);
+  const existingConfig = loadConfig();
+  const config = {
+    ...existingConfig,
+    platform: answers.platform,
+    user_mention: answers.user_mention,
+    output_preference: answers.output_preference,
+    git_username: answers.git_username
+  };
+  saveConfig(config);
+  console.log(chalk2.green("\n\u2713 Config saved to ~/.droid/config.yaml"));
+  const { added, alreadyPresent, error } = configurePlatformPermissions(answers.platform);
+  if (error) {
+    console.log(chalk2.red(`\u2717 ${error}`));
+    console.log(chalk2.yellow("  You may need to manually configure your platform"));
+  } else if (answers.platform === "claude-code" /* ClaudeCode */) {
+    if (added.length > 0) {
+      console.log(chalk2.green(`\u2713 Added droid permissions to Claude Code settings`));
+    } else if (alreadyPresent) {
+      console.log(chalk2.gray(`  Droid permissions already configured in Claude Code`));
+    }
+  } else if (answers.platform === "opencode" /* OpenCode */) {
+    if (added.length > 0) {
+      console.log(chalk2.green(`\u2713 Added opencode-skills plugin to OpenCode config`));
+      console.log(chalk2.gray(`  This enables Claude Code-style skills in OpenCode`));
+      console.log(chalk2.gray(`  Restart OpenCode to activate the plugin`));
+    } else if (alreadyPresent) {
+      console.log(chalk2.gray(`  opencode-skills plugin already configured in OpenCode`));
+    }
+  }
+  console.log(chalk2.gray("\nRun `droid skills` to browse and install skills."));
+}
+
+// src/commands/config.ts
+import chalk3 from "chalk";
+import { execSync as execSync3 } from "child_process";
+async function configCommand(options) {
+  if (options.edit) {
+    const configPath = getConfigPath();
+    const editor = process.env.EDITOR || "vim";
+    if (!configExists()) {
+      console.log(chalk3.yellow("No config file exists yet. Run `droid setup` first."));
+      return;
+    }
+    console.log(chalk3.gray(`Opening ${configPath} in ${editor}...`));
+    try {
+      execSync3(`${editor} "${configPath}"`, { stdio: "inherit" });
+    } catch {
+      console.error(chalk3.red("Failed to open editor"));
+    }
+    return;
+  }
+  if (options.get) {
+    const value = getConfigValue(options.get);
+    if (value === void 0) {
+      console.log(chalk3.yellow(`Config key '${options.get}' not found`));
+      process.exit(1);
+    }
+    if (typeof value === "object") {
+      console.log(JSON.stringify(value, null, 2));
+    } else {
+      console.log(value);
+    }
+    return;
+  }
+  if (options.set) {
+    const match = options.set.match(/^([^=]+)=(.*)$/);
+    if (!match) {
+      console.error(chalk3.red("Invalid format. Use: --set key=value"));
+      process.exit(1);
+    }
+    const [, key, rawValue] = match;
+    let value;
+    try {
+      value = JSON.parse(rawValue);
+    } catch {
+      value = rawValue;
+    }
+    setConfigValue(key, value);
+    console.log(chalk3.green(`\u2713 Set ${key} = ${JSON.stringify(value)}`));
+    return;
+  }
+  if (!configExists()) {
+    console.log(chalk3.yellow("No config file exists yet. Run `droid setup` first."));
+    return;
+  }
+  const config = loadConfig();
+  console.log(chalk3.bold("\n\u{1F4CB} Droid Config\n"));
+  console.log(chalk3.gray(`Path: ${getConfigPath()}
+`));
+  console.log(JSON.stringify(config, null, 2));
+}
+
+// src/commands/skills.ts
+import inquirer3 from "inquirer";
+import chalk5 from "chalk";
+
+// src/lib/skill-config.ts
+import chalk4 from "chalk";
+import inquirer2 from "inquirer";
+async function promptForSkillConfig(skillName, configSchema, askFirst = true) {
+  const globalConfig = loadConfig();
+  if (askFirst) {
+    const { wantsConfigure } = await inquirer2.prompt([
+      {
+        type: "confirm",
+        name: "wantsConfigure",
+        message: "Would you like to configure this skill now?",
+        default: false
+      }
+    ]);
+    if (!wantsConfigure) {
+      return;
+    }
+  }
+  console.log(chalk4.bold(`
+\u2699\uFE0F  Configure ${skillName}
+`));
+  const existingOverrides = loadSkillOverrides(skillName);
+  const questions = Object.entries(configSchema).map(([key, option]) => {
+    const baseQuestion = {
+      name: key,
+      message: option.description
+    };
+    const existingValue = existingOverrides[key];
+    switch (option.type) {
+      case "boolean" /* Boolean */:
+        return {
+          ...baseQuestion,
+          type: "confirm",
+          default: existingValue ?? option.default ?? false
+        };
+      case "select" /* Select */:
+        return {
+          ...baseQuestion,
+          type: "list",
+          choices: option.options || [],
+          default: existingValue ?? option.default
+        };
+      case "string" /* String */:
+      default: {
+        let defaultValue = existingValue ?? option.default ?? "";
+        if (key === "user_mention" && !existingValue && globalConfig.user_mention) {
+          defaultValue = globalConfig.user_mention;
+        }
+        return {
+          ...baseQuestion,
+          type: "input",
+          default: defaultValue
+        };
+      }
+    }
+  });
+  const answers = await inquirer2.prompt(questions);
+  const overrides = {};
+  for (const [key, value] of Object.entries(answers)) {
+    const schema = configSchema[key];
+    if (value !== schema.default && value !== "" && value !== false) {
+      overrides[key] = value;
+    }
+  }
+  if (Object.keys(overrides).length > 0) {
+    saveSkillOverrides(skillName, overrides);
+    console.log(chalk4.green(`
+\u2713 Configuration saved to ~/.droid/skills/${skillName}/overrides.yaml`));
+  } else {
+    console.log(chalk4.gray("\nNo custom configuration set (using defaults)."));
+  }
+}
+
+// src/commands/skills.ts
+function formatToolChoice(tool) {
+  const installed = isToolInstalled(tool.name);
+  const installedVersion = getInstalledToolVersion(tool.name);
+  let line = `${tool.name}`;
+  if (installed && installedVersion) {
+    line += chalk5.green(` [installed] v${installedVersion}`);
+  } else {
+    line += chalk5.gray(` v${tool.version}`);
+  }
+  if (tool.status) {
+    const statusColor = tool.status === "alpha" /* Alpha */ ? chalk5.red : tool.status === "beta" /* Beta */ ? chalk5.yellow : chalk5.white;
+    line += statusColor(` [${tool.status}]`);
+  }
+  return line;
+}
+async function skillsCommand() {
+  const tools = getBundledTools();
+  if (tools.length === 0) {
+    console.log(chalk5.yellow("\nNo tools available yet."));
+    return;
+  }
+  console.log(chalk5.bold("\n\u{1F916} Available Tools\n"));
+  const toolChoices = tools.map((tool2) => ({
+    name: formatToolChoice(tool2),
+    value: tool2.name,
+    short: tool2.name
+  }));
+  const choices = [
+    {
+      name: chalk5.gray("\u2190 Exit"),
+      value: "__exit__",
+      short: "Exit"
+    },
+    ...toolChoices
+  ];
+  const { selectedTool } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "selectedTool",
+      message: "Select a tool to view details or install:",
+      choices,
+      pageSize: 15
+    }
+  ]);
+  if (selectedTool === "__exit__") {
+    return;
+  }
+  const tool = tools.find((t) => t.name === selectedTool);
+  if (!tool) {
+    console.error(chalk5.red("Tool not found"));
+    return;
+  }
+  console.log(chalk5.bold(`
+\u{1F4E6} ${tool.name}`));
+  console.log(chalk5.gray(`Version: ${tool.version}`));
+  if (tool.status) {
+    console.log(chalk5.gray(`Status: ${tool.status}`));
+  }
+  console.log(`
+${tool.description}`);
+  const skillNames = tool.includes.skills.map((s) => s.name);
+  const commandNames = tool.includes.commands.map((c) => `/${c}`);
+  const agentNames = tool.includes.agents;
+  if (skillNames.length > 0) {
+    console.log(chalk5.gray(`
+Skills: ${skillNames.join(", ")}`));
+  }
+  if (commandNames.length > 0) {
+    console.log(chalk5.gray(`Commands: ${commandNames.join(", ")}`));
+  }
+  if (agentNames.length > 0) {
+    console.log(chalk5.gray(`Agents: ${agentNames.join(", ")}`));
+  }
+  const installed = isToolInstalled(tool.name);
+  const primarySkill = tool.includes.skills.find((s) => s.required)?.name || tool.name;
+  const actions = installed ? [
+    { name: "\u2190 Back", value: "back" },
+    { name: "Configure", value: "configure" },
+    { name: "Uninstall", value: "uninstall" }
+  ] : [
+    { name: "\u2190 Back", value: "back" },
+    { name: "Install", value: "install" }
+  ];
+  const { action } = await inquirer3.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "What would you like to do?",
+      choices: actions
+    }
+  ]);
+  switch (action) {
+    case "install": {
+      const result = installSkill(primarySkill);
+      if (result.success) {
+        console.log(chalk5.green(`
+\u2713 Installed ${tool.name}`));
+        if (tool.config_schema && Object.keys(tool.config_schema).length > 0) {
+          const hasRequiredConfig = Object.values(tool.config_schema).some(
+            (option) => option.default === void 0
+          );
+          await promptForSkillConfig(primarySkill, tool.config_schema, !hasRequiredConfig);
+        }
+      } else {
+        console.log(chalk5.red(`
+\u2717 ${result.message}`));
+      }
+      break;
+    }
+    case "configure": {
+      if (tool.config_schema && Object.keys(tool.config_schema).length > 0) {
+        await promptForSkillConfig(primarySkill, tool.config_schema, false);
+      } else {
+        console.log(chalk5.gray("\nThis tool has no configuration options."));
+      }
+      break;
+    }
+    case "uninstall": {
+      const result = uninstallSkill(primarySkill);
+      if (result.success) {
+        console.log(chalk5.green(`
+\u2713 Uninstalled ${tool.name}`));
+      } else {
+        console.log(chalk5.red(`
+\u2717 ${result.message}`));
+      }
+      break;
+    }
+    case "back":
+      await skillsCommand();
+      break;
+  }
+}
+
+// src/commands/install.ts
+import chalk6 from "chalk";
+async function installCommand(toolName) {
+  const tools = getBundledTools();
+  const tool = tools.find((t) => t.name === toolName);
+  if (!tool) {
+    console.error(chalk6.red(`
+\u2717 Tool '${toolName}' not found`));
+    console.log(chalk6.gray("\nAvailable tools:"));
+    for (const t of tools) {
+      console.log(chalk6.gray(`  - ${t.name}`));
+    }
+    process.exit(1);
+  }
+  if (isToolInstalled(toolName)) {
+    console.log(chalk6.yellow(`
+\u26A0 Tool '${toolName}' is already installed`));
+    console.log(chalk6.gray("Use `droid update` to update it, or uninstall first."));
+    return;
+  }
+  console.log(chalk6.bold(`
+\u{1F916} Installing ${toolName}...
+`));
+  const primarySkill = tool.includes.skills.find((s) => s.required)?.name || toolName;
+  const result = installSkill(primarySkill);
+  if (result.success) {
+    console.log(chalk6.green(`\u2713 Installed ${toolName}`));
+    if (tool.config_schema && Object.keys(tool.config_schema).length > 0) {
+      const hasRequiredConfig = Object.values(tool.config_schema).some(
+        (option) => option.default === void 0
+      );
+      await promptForSkillConfig(primarySkill, tool.config_schema, !hasRequiredConfig);
+    }
+    console.log(chalk6.gray("\nNext steps:"));
+    console.log(chalk6.gray("  - Run your AI tool to start using it"));
+    console.log(chalk6.gray(`  - Reconfigure anytime with \`droid\` \u2192 Configure`));
+  } else {
+    console.error(chalk6.red(`\u2717 ${result.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/uninstall.ts
+import chalk7 from "chalk";
+async function uninstallCommand(toolName) {
+  const tools = getBundledTools();
+  const tool = tools.find((t) => t.name === toolName);
+  if (!tool) {
+    console.error(chalk7.red(`
+\u2717 Tool '${toolName}' not found`));
+    process.exit(1);
+  }
+  if (!isToolInstalled(toolName)) {
+    console.error(chalk7.red(`
+\u2717 Tool '${toolName}' is not installed`));
+    process.exit(1);
+  }
+  const primarySkill = tool.includes.skills.find((s) => s.required)?.name || toolName;
+  const result = uninstallSkill(primarySkill);
+  if (result.success) {
+    console.log(chalk7.green(`
+\u2713 Uninstalled ${toolName}`));
+  } else {
+    console.error(chalk7.red(`
+\u2717 ${result.message}`));
+    process.exit(1);
+  }
+}
+
+// src/commands/update.ts
+import chalk8 from "chalk";
+import { execSync as execSync4 } from "child_process";
+async function updateCommand(tool, options) {
+  if (tool) {
+    console.log(chalk8.yellow("\n\u26A0 Per-tool updates not implemented yet"));
+    console.log(chalk8.gray("Tools are bundled with the CLI - run `droid update` to update all."));
+    return;
+  }
+  if (options?.tools) {
+    console.log(chalk8.yellow("\n\u26A0 Tool-only updates not implemented yet"));
+    console.log(chalk8.gray("Tools are bundled with the CLI - run `droid update` to update all."));
+    return;
+  }
+  console.log(chalk8.bold("\n\u{1F916} Updating Droid...\n"));
+  const currentVersion = getVersion();
+  console.log(chalk8.gray(`Current version: ${currentVersion}`));
+  try {
+    const latestVersion = execSync4("npm view @orderful/droid version 2>/dev/null", {
+      encoding: "utf-8"
+    }).trim();
+    if (!latestVersion) {
+      console.log(chalk8.yellow("\n\u26A0 Could not check for updates"));
+      return;
+    }
+    if (latestVersion === currentVersion) {
+      console.log(chalk8.green("\n\u2713 Already on latest version"));
+      return;
+    }
+    console.log(chalk8.gray(`Latest version: ${latestVersion}`));
+    console.log(chalk8.gray("\nUpdating..."));
+    execSync4("npm install -g @orderful/droid@latest", { stdio: "inherit" });
+    console.log(chalk8.green(`
+\u2713 Updated to v${latestVersion}`));
+  } catch {
+    console.log(chalk8.yellow("\n\u26A0 Could not check for updates"));
+    console.log(chalk8.gray("Package may not be published yet."));
+  }
+}
+
+// src/commands/tui.tsx
+import { render, Box as Box12, Text as Text13, useInput as useInput7, useApp as useApp2 } from "ink";
+import { useState as useState9 } from "react";
+
+// src/commands/tui/constants.ts
+var colors = {
+  primary: "#6366f1",
+  bgSelected: "#2d2d2d",
+  border: "#3a3a3a",
+  text: "#e8e8e8",
+  textMuted: "#999999",
+  textDim: "#6a6a6a",
+  success: "#4ade80",
+  error: "#f87171",
+  // Component type badges
+  skill: "#ec4899",
+  // pink/magenta
+  command: "#22d3ee",
+  // cyan
+  agent: "#fbbf24"
+  // yellow/amber
+};
+var MAX_VISIBLE_ITEMS = 6;
+var MAX_VISIBLE_CONFIG_ITEMS = 4;
+
+// src/commands/tui/components/TabBar.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function TabBar({ tabs, activeTab }) {
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "row", flexWrap: "wrap", children: tabs.map((tab) => /* @__PURE__ */ jsxs(
+    Text,
+    {
+      backgroundColor: tab.id === activeTab ? colors.primary : void 0,
+      color: tab.id === activeTab ? "#ffffff" : colors.textMuted,
+      bold: tab.id === activeTab,
+      wrap: "truncate",
+      children: [
+        " ",
+        tab.label,
+        " "
+      ]
+    },
+    tab.id
+  )) });
+}
+
+// src/commands/tui/components/ToolItem.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function ToolItem({
+  tool,
+  isSelected,
+  isActive,
+  wasAutoUpdated
+}) {
+  const installed = isToolInstalled(tool.name);
+  const installedVersion = getInstalledToolVersion(tool.name);
+  const updateStatus = getToolUpdateStatus(tool.name);
+  return /* @__PURE__ */ jsx2(Box2, { paddingX: 1, backgroundColor: isActive ? colors.bgSelected : void 0, children: /* @__PURE__ */ jsxs2(Text2, { wrap: "truncate", children: [
+    /* @__PURE__ */ jsxs2(Text2, { color: colors.textDim, children: [
+      isSelected ? ">" : " ",
+      " "
+    ] }),
+    /* @__PURE__ */ jsx2(Text2, { color: isSelected || isActive ? colors.text : colors.textMuted, children: tool.name }),
+    installed && installedVersion && /* @__PURE__ */ jsxs2(Text2, { color: colors.textDim, children: [
+      " v",
+      installedVersion
+    ] }),
+    installed && /* @__PURE__ */ jsx2(Text2, { color: colors.success, children: " \u2713" }),
+    wasAutoUpdated && /* @__PURE__ */ jsx2(Text2, { color: colors.success, children: " \u2191" }),
+    updateStatus.hasUpdate && !wasAutoUpdated && /* @__PURE__ */ jsx2(Text2, { color: colors.primary, children: " \u2191" }),
+    /* @__PURE__ */ jsx2(Text2, { children: " " }),
+    tool.includes.skills.length > 0 && /* @__PURE__ */ jsx2(Text2, { color: colors.skill, children: "\u25CF " }),
+    tool.includes.commands.length > 0 && /* @__PURE__ */ jsx2(Text2, { color: colors.command, children: "\u25CF " }),
+    tool.includes.agents.length > 0 && /* @__PURE__ */ jsx2(Text2, { color: colors.agent, children: "\u25CF" })
+  ] }) });
+}
+
+// src/commands/tui/components/ToolDetails.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+
+// src/commands/tui/components/Badge.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function ComponentBadges({ tool, compact = false }) {
+  const hasSkills = tool.includes.skills.length > 0;
+  const hasCommands = tool.includes.commands.length > 0;
+  const hasAgents = tool.includes.agents.length > 0;
+  if (compact) {
+    const parts = [];
+    if (hasSkills) parts.push("skill");
+    if (hasCommands) parts.push("command");
+    if (hasAgents) parts.push("agent");
+    return /* @__PURE__ */ jsx3(Box3, { flexDirection: "row", children: parts.map((type, i) => /* @__PURE__ */ jsxs3(Text3, { children: [
+      /* @__PURE__ */ jsx3(Text3, { backgroundColor: colors[type], children: " " }),
+      i < parts.length - 1 && " "
+    ] }, type)) });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", children: [
+    hasSkills && /* @__PURE__ */ jsx3(Box3, { marginRight: 1, children: /* @__PURE__ */ jsx3(Text3, { backgroundColor: colors.skill, color: "#000000", bold: true, children: ` ${tool.includes.skills.length} skill${tool.includes.skills.length > 1 ? "s" : ""} ` }) }),
+    hasCommands && /* @__PURE__ */ jsx3(Box3, { marginRight: 1, children: /* @__PURE__ */ jsx3(Text3, { backgroundColor: colors.command, color: "#000000", bold: true, children: ` ${tool.includes.commands.length} cmd${tool.includes.commands.length > 1 ? "s" : ""} ` }) }),
+    hasAgents && /* @__PURE__ */ jsx3(Box3, { marginRight: 1, children: /* @__PURE__ */ jsx3(Text3, { backgroundColor: colors.agent, color: "#000000", bold: true, children: ` ${tool.includes.agents.length} agent${tool.includes.agents.length > 1 ? "s" : ""} ` }) })
+  ] });
+}
+
+// src/commands/tui/components/ToolDetails.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function ToolDetails({
+  tool,
+  isFocused,
+  selectedAction
+}) {
+  if (!tool) {
+    return /* @__PURE__ */ jsx4(Box4, { paddingLeft: 2, flexGrow: 1, children: /* @__PURE__ */ jsx4(Text4, { color: colors.textDim, children: "Select a tool" }) });
+  }
+  const installed = isToolInstalled(tool.name);
+  const installedVersion = getInstalledToolVersion(tool.name);
+  const updateStatus = getToolUpdateStatus(tool.name);
+  const isSystemTool = tool.system === true;
+  const actions = installed ? [
+    { id: "explore", label: "Explore", variant: "default" },
+    ...updateStatus.hasUpdate ? [{ id: "update", label: `Update (${updateStatus.bundledVersion})`, variant: "primary" }] : [],
+    { id: "configure", label: "Configure", variant: "default" },
+    // System tools can't be uninstalled
+    ...!isSystemTool ? [{ id: "uninstall", label: "Uninstall", variant: "danger" }] : []
+  ] : [
+    { id: "explore", label: "Explore", variant: "default" },
+    // System tools auto-install, but show Install for manual trigger if needed
+    { id: "install", label: "Install", variant: "primary" }
+  ];
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 2, flexGrow: 1, children: [
+    /* @__PURE__ */ jsx4(Text4, { color: colors.text, bold: true, children: tool.name }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsxs4(Text4, { color: colors.textDim, children: [
+      tool.version,
+      tool.status && ` \xB7 ${tool.status}`,
+      installed && /* @__PURE__ */ jsx4(Text4, { color: colors.success, children: " \xB7 installed" }),
+      updateStatus.hasUpdate && /* @__PURE__ */ jsxs4(Text4, { color: colors.primary, children: [
+        " \xB7 update (",
+        installedVersion,
+        " \u2192 ",
+        updateStatus.bundledVersion,
+        ")"
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { color: colors.textMuted, children: tool.description }) }),
+    /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsx4(Text4, { color: colors.textDim, children: "Includes:" }),
+      /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(ComponentBadges, { tool }) }),
+      /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", marginTop: 1, marginLeft: 1, children: [
+        tool.includes.skills.length > 0 && /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: colors.skill, children: "Skills: " }),
+          /* @__PURE__ */ jsx4(Text4, { color: colors.textMuted, children: tool.includes.skills.map((s) => s.name).join(", ") })
+        ] }),
+        tool.includes.commands.length > 0 && /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: colors.command, children: "Commands: " }),
+          /* @__PURE__ */ jsx4(Text4, { color: colors.textMuted, children: tool.includes.commands.map((c) => `/${c}`).join(", ") })
+        ] }),
+        tool.includes.agents.length > 0 && /* @__PURE__ */ jsxs4(Text4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { color: colors.agent, children: "Agents: " }),
+          /* @__PURE__ */ jsx4(Text4, { color: colors.textMuted, children: tool.includes.agents.join(", ") })
+        ] })
+      ] })
+    ] }),
+    isFocused && /* @__PURE__ */ jsx4(Box4, { flexDirection: "row", marginTop: 1, children: actions.map((action, index) => /* @__PURE__ */ jsxs4(
+      Text4,
+      {
+        backgroundColor: selectedAction === index ? action.variant === "danger" ? colors.error : colors.primary : colors.bgSelected,
+        color: selectedAction === index ? "#ffffff" : colors.textMuted,
+        bold: selectedAction === index,
+        children: [
+          " ",
+          action.label,
+          " "
+        ]
+      },
+      action.id
+    )) })
+  ] });
+}
+
+// src/commands/tui/components/SettingsDetails.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function SettingsDetails({
+  isFocused
+}) {
+  const config = loadConfig();
+  const autoUpdateConfig = getAutoUpdateConfig();
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingLeft: 2, flexGrow: 1, children: [
+    /* @__PURE__ */ jsx5(Text5, { color: colors.text, bold: true, children: "Settings" }),
+    /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "Platform:           " }),
+        /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: config.platform === "claude-code" /* ClaudeCode */ ? "Claude Code" : "OpenCode" })
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "Your @mention:      " }),
+        /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: config.user_mention })
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "Auto-update tools:  " }),
+        /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: autoUpdateConfig.tools ? "enabled" : "disabled" })
+      ] }),
+      /* @__PURE__ */ jsxs5(Text5, { children: [
+        /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "Auto-update app:    " }),
+        /* @__PURE__ */ jsx5(Text5, { color: colors.text, children: autoUpdateConfig.app ? "enabled" : "disabled" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx5(Box5, { marginTop: 2, children: /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "Config: ~/.droid/config.yaml" }) }),
+    isFocused && /* @__PURE__ */ jsx5(Box5, { marginTop: 2, children: /* @__PURE__ */ jsxs5(
+      Text5,
+      {
+        backgroundColor: colors.primary,
+        color: "#ffffff",
+        bold: true,
+        children: [
+          " ",
+          "Edit",
+          " "
+        ]
+      }
+    ) }),
+    isFocused && /* @__PURE__ */ jsx5(Box5, { marginTop: 1, children: /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "enter edit \xB7 esc back" }) }),
+    !isFocused && /* @__PURE__ */ jsx5(Box5, { marginTop: 2, children: /* @__PURE__ */ jsx5(Text5, { color: colors.textDim, children: "press enter to edit" }) })
+  ] });
+}
+
+// src/commands/tui/views/WelcomeScreen.tsx
+import { Box as Box6, Text as Text6, useInput } from "ink";
+import { useState, useMemo } from "react";
+
+// src/lib/quotes.ts
+var quotes = [
+  "I'm probably the droid you are looking for.",
+  "These are the skills you're looking for.",
+  "I have a bad feeling about this, we might be too efficient.",
+  "May the source be with you.",
+  "The Force is strong with this one.",
+  "This is the way.",
+  "I'm fluent in over six million forms of communication. - `/comments`",
+  "Much to learn, you still have. - `/coach`",
+  "If into the archives you go, only knowledge will you find. - `/project`"
+];
+function getRandomQuote() {
+  const index = Math.floor(Math.random() * quotes.length);
+  return quotes[index];
+}
+
+// src/commands/tui/views/WelcomeScreen.tsx
+import { Fragment, jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function WelcomeScreen({ onContinue, onUpdate, onAlways, onExit, updateInfo, isUpdating }) {
+  const [selectedButton, setSelectedButton] = useState(0);
+  const welcomeQuote = useMemo(() => getRandomQuote(), []);
+  useInput((input, key) => {
+    if (isUpdating) return;
+    if (updateInfo.hasUpdate) {
+      if (key.leftArrow) {
+        setSelectedButton((prev) => Math.max(0, prev - 1));
+      }
+      if (key.rightArrow) {
+        setSelectedButton((prev) => Math.min(2, prev + 1));
+      }
+      if (key.return) {
+        if (selectedButton === 0) {
+          onUpdate();
+        } else if (selectedButton === 1) {
+          onAlways();
+        } else {
+          onContinue();
+        }
+      }
+      if (input === "q") {
+        onExit();
+      }
+    } else {
+      if (key.return) {
+        onContinue();
+      }
+      if (input === "q") {
+        onExit();
+      }
+    }
+  });
+  const hasUpdate = updateInfo.hasUpdate && updateInfo.latestVersion;
+  return /* @__PURE__ */ jsx6(Box6, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: 18, children: /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      flexDirection: "column",
+      alignItems: "center",
+      borderStyle: "single",
+      borderColor: hasUpdate ? "#eab308" : colors.border,
+      paddingX: 4,
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs6(Text6, { children: [
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: "\u2554\u2550\u2550\u2550\u2550\u2550\u2557    " }),
+            /* @__PURE__ */ jsx6(Text6, { color: colors.text, children: "droid" }),
+            /* @__PURE__ */ jsxs6(Text6, { color: colors.textDim, children: [
+              " v",
+              updateInfo.currentVersion
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxs6(Text6, { children: [
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: "\u2551 " }),
+            /* @__PURE__ */ jsx6(Text6, { color: hasUpdate ? "#eab308" : colors.primary, children: "\u25CF" }),
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: " " }),
+            /* @__PURE__ */ jsx6(Text6, { color: hasUpdate ? "#eab308" : colors.primary, children: "\u25CF" }),
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: " \u2551    " }),
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textMuted, children: "Droid, teaching your AI new tricks" })
+          ] }),
+          /* @__PURE__ */ jsxs6(Text6, { children: [
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: "\u255A\u2550\u2566\u2550\u2566\u2550\u255D    " }),
+            /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: "github.com/Orderful/droid" })
+          ] })
+        ] }),
+        hasUpdate ? /* @__PURE__ */ jsxs6(Fragment, { children: [
+          /* @__PURE__ */ jsxs6(Box6, { marginTop: 2, marginBottom: 1, flexDirection: "column", alignItems: "center", children: [
+            /* @__PURE__ */ jsx6(Text6, { color: "#eab308", italic: true, children: '"The odds of functioning optimally without this' }),
+            /* @__PURE__ */ jsx6(Text6, { color: "#eab308", italic: true, children: 'update are approximately 3,720 to 1."' })
+          ] }),
+          /* @__PURE__ */ jsx6(Box6, { marginBottom: 1, children: /* @__PURE__ */ jsxs6(Text6, { color: colors.textMuted, children: [
+            "v",
+            updateInfo.currentVersion,
+            " \u2192 v",
+            updateInfo.latestVersion
+          ] }) }),
+          isUpdating ? /* @__PURE__ */ jsx6(Text6, { color: "#eab308", children: "Updating..." }) : /* @__PURE__ */ jsxs6(Box6, { flexDirection: "row", children: [
+            /* @__PURE__ */ jsxs6(
+              Text6,
+              {
+                backgroundColor: selectedButton === 0 ? "#eab308" : colors.bgSelected,
+                color: selectedButton === 0 ? "#000000" : colors.textMuted,
+                bold: selectedButton === 0,
+                children: [
+                  " ",
+                  "Update",
+                  " "
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx6(Text6, { children: " " }),
+            /* @__PURE__ */ jsxs6(
+              Text6,
+              {
+                backgroundColor: selectedButton === 1 ? "#eab308" : colors.bgSelected,
+                color: selectedButton === 1 ? "#000000" : colors.textMuted,
+                bold: selectedButton === 1,
+                children: [
+                  " ",
+                  "Always",
+                  " "
+                ]
+              }
+            ),
+            /* @__PURE__ */ jsx6(Text6, { children: " " }),
+            /* @__PURE__ */ jsxs6(
+              Text6,
+              {
+                backgroundColor: selectedButton === 2 ? colors.bgSelected : void 0,
+                color: selectedButton === 2 ? colors.text : colors.textMuted,
+                bold: selectedButton === 2,
+                children: [
+                  " ",
+                  "Skip",
+                  " "
+                ]
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx6(Box6, { marginTop: 1, children: /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: '\u2190\u2192 select \xB7 enter \xB7 "Always" enables auto-update' }) })
+        ] }) : /* @__PURE__ */ jsxs6(Fragment, { children: [
+          /* @__PURE__ */ jsx6(Box6, { marginTop: 2, marginBottom: 1, children: /* @__PURE__ */ jsx6(Text6, { backgroundColor: colors.primary, color: "#ffffff", bold: true, children: ` ${welcomeQuote} ` }) }),
+          /* @__PURE__ */ jsx6(Text6, { color: colors.textDim, children: "press enter" })
+        ] })
+      ]
+    }
+  ) });
+}
+
+// src/commands/tui/views/ToolUpdatePrompt.tsx
+import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
+import { useState as useState2 } from "react";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function ToolUpdatePrompt({ toolUpdates, onUpdateAll, onAlways, onSkip, isUpdating }) {
+  const [selectedButton, setSelectedButton] = useState2(0);
+  useInput2((input, key) => {
+    if (isUpdating) return;
+    if (key.leftArrow) {
+      setSelectedButton((prev) => Math.max(0, prev - 1));
+    }
+    if (key.rightArrow) {
+      setSelectedButton((prev) => Math.min(2, prev + 1));
+    }
+    if (key.return) {
+      if (selectedButton === 0) {
+        onUpdateAll();
+      } else if (selectedButton === 1) {
+        onAlways();
+      } else {
+        onSkip();
+      }
+    }
+    if (input === "q") {
+      onSkip();
+    }
+  });
+  const buttons = [
+    { label: "Update All", action: onUpdateAll },
+    { label: "Always", action: onAlways },
+    { label: "Skip", action: onSkip }
+  ];
+  return /* @__PURE__ */ jsx7(Box7, { flexDirection: "column", alignItems: "center", justifyContent: "center", height: 18, children: /* @__PURE__ */ jsxs7(
+    Box7,
+    {
+      flexDirection: "column",
+      alignItems: "center",
+      borderStyle: "single",
+      borderColor: colors.primary,
+      paddingX: 4,
+      paddingY: 1,
+      children: [
+        /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", children: [
+          /* @__PURE__ */ jsxs7(Text7, { children: [
+            /* @__PURE__ */ jsx7(Text7, { color: colors.textDim, children: "\u2554\u2550\u2550\u2550\u2550\u2550\u2557    " }),
+            /* @__PURE__ */ jsx7(Text7, { color: colors.text, children: "Tool Updates" })
+          ] }),
+          /* @__PURE__ */ jsxs7(Text7, { children: [
+            /* @__PURE__ */ jsx7(Text7, { color: colors.textDim, children: "\u2551 " }),
+            /* @__PURE__ */ jsx7(Text7, { color: colors.primary, children: "\u25CF" }),
+            /* @__PURE__ */ jsx7(Text7, { color: colors.textDim, children: " " }),
+            /* @__PURE__ */ jsx7(Text7, { color: colors.primary, children: "\u25CF" }),
+            /* @__PURE__ */ jsx7(Text7, { color: colors.textDim, children: " \u2551    " }),
+            /* @__PURE__ */ jsxs7(Text7, { color: colors.textMuted, children: [
+              toolUpdates.length,
+              " tool",
+              toolUpdates.length > 1 ? "s have" : " has",
+              " updates available"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx7(Text7, { children: /* @__PURE__ */ jsx7(Text7, { color: colors.textDim, children: "\u255A\u2550\u2566\u2550\u2566\u2550\u255D" }) })
+        ] }),
+        /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, marginBottom: 1, flexDirection: "column", children: [
+          toolUpdates.slice(0, 5).map((tool) => /* @__PURE__ */ jsxs7(Text7, { color: colors.textMuted, children: [
+            /* @__PURE__ */ jsx7(Text7, { color: colors.primary, children: "\u2191" }),
+            " ",
+            tool.name,
+            /* @__PURE__ */ jsxs7(Text7, { color: colors.textDim, children: [
+              " ",
+              tool.installedVersion,
+              " \u2192 ",
+              tool.bundledVersion
+            ] })
+          ] }, tool.name)),
+          toolUpdates.length > 5 && /* @__PURE__ */ jsxs7(Text7, { color: colors.textDim, children: [
+            "...and ",
+            toolUpdates.length - 5,
+            " more"
+          ] })
+        ] }),
+        isUpdating ? /* @__PURE__ */ jsx7(Text7, { color: colors.primary, children: "Updating tools..." }) : /* @__PURE__ */ jsx7(Box7, { flexDirection: "row", children: buttons.map((button, index) => /* @__PURE__ */ jsxs7(
+          Text7,
+          {
+            backgroundColor: selectedButton === index ? colors.primary : colors.bgSelected,
+            color: selectedButton === index ? "#000000" : colors.textMuted,
+            bold: selectedButton === index,
+            children: [
+              " ",
+              button.label,
+              " "
+            ]
+          },
+          button.label
+        )) }),
+        /* @__PURE__ */ jsx7(Box7, { marginTop: 1, children: /* @__PURE__ */ jsx7(Text7, { color: colors.textDim, children: '\u2190\u2192 select \xB7 enter \xB7 "Always" enables auto-update' }) })
+      ]
+    }
+  ) });
+}
+
+// src/commands/tui/views/SetupScreen.tsx
+import { Box as Box8, Text as Text8, useInput as useInput3 } from "ink";
+import TextInput from "ink-text-input";
+import { useState as useState3 } from "react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var platformOptions = [
+  { label: "Claude Code", value: "claude-code" /* ClaudeCode */ },
+  { label: "OpenCode", value: "opencode" /* OpenCode */ }
+];
+function SetupScreen({ onComplete, onSkip, initialConfig }) {
+  const [step, setStep] = useState3("platform");
+  const [platform, setPlatform] = useState3(
+    initialConfig?.platform || "claude-code" /* ClaudeCode */
+  );
+  const [userMention, setUserMention] = useState3(initialConfig?.user_mention || "@user");
+  const [selectedIndex, setSelectedIndex] = useState3(0);
+  const [error, setError] = useState3(null);
+  const existingAutoUpdate = getAutoUpdateConfig();
+  const [autoUpdateTools, setAutoUpdateTools] = useState3(existingAutoUpdate.tools);
+  const [autoUpdateApp, setAutoUpdateApp] = useState3(existingAutoUpdate.app);
+  const [autoUpdateSelectedIndex, setAutoUpdateSelectedIndex] = useState3(0);
+  const steps = ["platform", "user_mention", "auto_update", "confirm"];
+  const stepIndex = steps.indexOf(step);
+  const totalSteps = steps.length - 1;
+  const handleUserMentionSubmit = () => {
+    const mention = userMention.startsWith("@") ? userMention : `@${userMention}`;
+    setUserMention(mention);
+    setError(null);
+    setStep("auto_update");
+    setAutoUpdateSelectedIndex(0);
+  };
+  useInput3((input, key) => {
+    if (key.escape) {
+      setStep("platform");
+      setSelectedIndex(0);
+    }
+  }, { isActive: step === "user_mention" });
+  useInput3((input, key) => {
+    if (key.escape) {
+      if (step === "platform") {
+        onSkip();
+      } else if (step === "auto_update") {
+        setStep("user_mention");
+      } else if (step === "confirm") {
+        setStep("auto_update");
+        setAutoUpdateSelectedIndex(0);
+      }
+      return;
+    }
+    if (step === "platform") {
+      if (key.upArrow) setSelectedIndex((prev) => Math.max(0, prev - 1));
+      if (key.downArrow) setSelectedIndex((prev) => Math.min(platformOptions.length - 1, prev + 1));
+      if (key.return) {
+        setPlatform(platformOptions[selectedIndex].value);
+        setStep("user_mention");
+      }
+    } else if (step === "auto_update") {
+      if (key.upArrow) setAutoUpdateSelectedIndex((prev) => Math.max(0, prev - 1));
+      if (key.downArrow) setAutoUpdateSelectedIndex((prev) => Math.min(2, prev + 1));
+      if (key.return) {
+        if (autoUpdateSelectedIndex === 0) {
+          setAutoUpdateTools(!autoUpdateTools);
+        } else if (autoUpdateSelectedIndex === 1) {
+          setAutoUpdateApp(!autoUpdateApp);
+        } else {
+          setStep("confirm");
+        }
+      }
+    } else if (step === "confirm") {
+      if (key.return) {
+        const existingConfig = loadConfig();
+        const config = {
+          ...existingConfig,
+          platform,
+          user_mention: userMention,
+          output_preference: "terminal" /* Terminal */
+          // Default to terminal
+        };
+        saveConfig(config);
+        setAutoUpdateConfig({ tools: autoUpdateTools, app: autoUpdateApp });
+        configurePlatformPermissions(platform);
+        onComplete();
+      }
+    }
+  }, { isActive: step !== "user_mention" });
+  const renderHeader = () => /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", marginBottom: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+    /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "[" }),
+    /* @__PURE__ */ jsx8(Text8, { color: colors.primary, children: "\u25CF" }),
+    /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: " " }),
+    /* @__PURE__ */ jsx8(Text8, { color: colors.primary, children: "\u25CF" }),
+    /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "] " }),
+    /* @__PURE__ */ jsx8(Text8, { color: colors.text, bold: true, children: "droid setup" }),
+    /* @__PURE__ */ jsxs8(Text8, { color: colors.textDim, children: [
+      " \xB7 Step ",
+      Math.min(stepIndex + 1, totalSteps),
+      " of ",
+      totalSteps
+    ] })
+  ] }) });
+  if (step === "platform") {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+      renderHeader(),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: "Which platform are you using?" }),
+      /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", marginTop: 1, children: platformOptions.map((option, index) => /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsxs8(Text8, { color: colors.textDim, children: [
+          index === selectedIndex ? ">" : " ",
+          " "
+        ] }),
+        /* @__PURE__ */ jsx8(Text8, { color: index === selectedIndex ? colors.text : colors.textMuted, children: option.label })
+      ] }, option.value)) }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "\u2191\u2193 select \xB7 enter next \xB7 esc skip" }) })
+    ] });
+  }
+  if (step === "user_mention") {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+      renderHeader(),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: "What @mention should be used for you?" }),
+      /* @__PURE__ */ jsxs8(Box8, { marginTop: 1, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "> " }),
+        /* @__PURE__ */ jsx8(
+          TextInput,
+          {
+            value: userMention,
+            onChange: setUserMention,
+            onSubmit: handleUserMentionSubmit,
+            placeholder: "@user"
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: colors.error, children: error }) }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "enter next \xB7 esc back" }) })
+    ] });
+  }
+  if (step === "auto_update") {
+    return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+      renderHeader(),
+      /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: "Configure auto-update behaviour" }),
+      /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginTop: 1, children: [
+        /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsxs8(Text8, { children: [
+          /* @__PURE__ */ jsxs8(Text8, { color: colors.textDim, children: [
+            autoUpdateSelectedIndex === 0 ? ">" : " ",
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs8(Text8, { color: autoUpdateSelectedIndex === 0 ? colors.text : colors.textMuted, children: [
+            "[",
+            autoUpdateTools ? "x" : " ",
+            "] Auto-update tools"
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "    Update tools automatically when droid starts" }),
+        /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsxs8(Text8, { children: [
+          /* @__PURE__ */ jsxs8(Text8, { color: colors.textDim, children: [
+            autoUpdateSelectedIndex === 1 ? ">" : " ",
+            " "
+          ] }),
+          /* @__PURE__ */ jsxs8(Text8, { color: autoUpdateSelectedIndex === 1 ? colors.text : colors.textMuted, children: [
+            "[",
+            autoUpdateApp ? "x" : " ",
+            "] Auto-update app"
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "    Update droid automatically when a new version is available" })
+      ] }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 2, children: /* @__PURE__ */ jsxs8(
+        Text8,
+        {
+          backgroundColor: autoUpdateSelectedIndex === 2 ? colors.primary : colors.bgSelected,
+          color: autoUpdateSelectedIndex === 2 ? "#ffffff" : colors.textMuted,
+          bold: autoUpdateSelectedIndex === 2,
+          children: [
+            " ",
+            "Next",
+            " "
+          ]
+        }
+      ) }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "\u2191\u2193 select \xB7 enter toggle/next \xB7 esc back" }) })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", padding: 1, children: [
+    renderHeader(),
+    /* @__PURE__ */ jsx8(Text8, { color: colors.text, bold: true, children: "Review your settings" }),
+    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", marginTop: 1, children: [
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "Platform:          " }),
+        /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: platform === "claude-code" /* ClaudeCode */ ? "Claude Code" : "OpenCode" })
+      ] }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "Your @mention:     " }),
+        /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: userMention })
+      ] }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "Auto-update tools: " }),
+        /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: autoUpdateTools ? "enabled" : "disabled" })
+      ] }),
+      /* @__PURE__ */ jsxs8(Text8, { children: [
+        /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "Auto-update app:   " }),
+        /* @__PURE__ */ jsx8(Text8, { color: colors.text, children: autoUpdateApp ? "enabled" : "disabled" })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 2, children: /* @__PURE__ */ jsxs8(Text8, { backgroundColor: colors.primary, color: "#ffffff", bold: true, children: [
+      " ",
+      "Save",
+      " "
+    ] }) }),
+    /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text8, { color: colors.textDim, children: "enter save \xB7 esc back" }) })
+  ] });
+}
+
+// src/commands/tui/views/ReadmeViewer.tsx
+import { Box as Box9, Text as Text10, useInput as useInput4 } from "ink";
+import { useState as useState4, useMemo as useMemo2 } from "react";
+
+// src/commands/tui/components/Markdown.tsx
+import { Text as Text9 } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function MarkdownLine({ line, inCodeBlock }) {
+  if (inCodeBlock) {
+    return /* @__PURE__ */ jsx9(Text9, { color: "#a5d6ff", children: line || " " });
+  }
+  if (line.startsWith("```")) {
+    return /* @__PURE__ */ jsx9(Text9, { color: colors.textDim, children: line });
+  }
+  if (line.startsWith("# ")) {
+    return /* @__PURE__ */ jsx9(Text9, { color: colors.text, bold: true, children: line.slice(2) });
+  }
+  if (line.startsWith("## ")) {
+    return /* @__PURE__ */ jsx9(Text9, { color: colors.text, bold: true, children: line.slice(3) });
+  }
+  if (line.startsWith("### ")) {
+    return /* @__PURE__ */ jsx9(Text9, { color: "#c9d1d9", bold: true, children: line.slice(4) });
+  }
+  if (line === "---") {
+    return /* @__PURE__ */ jsx9(Text9, { color: colors.textDim, children: line });
+  }
+  if (line.match(/^[\s]*[-*]\s/)) {
+    return /* @__PURE__ */ jsx9(Text9, { color: colors.textMuted, children: line });
+  }
+  if (line.startsWith(">")) {
+    return /* @__PURE__ */ jsx9(Text9, { color: "#8b949e", italic: true, children: line });
+  }
+  if (line.includes("|")) {
+    return /* @__PURE__ */ jsx9(Text9, { color: colors.textMuted, children: line });
+  }
+  return /* @__PURE__ */ jsx9(Text9, { color: colors.textMuted, children: line || " " });
+}
+
+// src/commands/tui/views/ReadmeViewer.tsx
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+function ReadmeViewer({ title, content, onClose }) {
+  const [scrollOffset, setScrollOffset] = useState4(0);
+  const lines = useMemo2(() => content.split("\n"), [content]);
+  const maxVisible = 20;
+  const lineStates = useMemo2(() => {
+    const states = [];
+    let inCode = false;
+    for (const line of lines) {
+      if (line.startsWith("```")) {
+        states.push(false);
+        inCode = !inCode;
+      } else {
+        states.push(inCode);
+      }
+    }
+    return states;
+  }, [lines]);
+  const maxOffset = Math.max(0, lines.length - maxVisible + 1);
+  useInput4((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.upArrow) {
+      setScrollOffset((prev) => Math.max(0, prev - 1));
+    }
+    if (key.downArrow) {
+      setScrollOffset((prev) => Math.min(maxOffset, prev + 1));
+    }
+    if (key.pageDown || input === " ") {
+      setScrollOffset((prev) => Math.min(maxOffset, prev + maxVisible));
+    }
+    if (key.pageUp) {
+      setScrollOffset((prev) => Math.max(0, prev - maxVisible));
+    }
+  });
+  const showTopIndicator = scrollOffset > 0;
+  const contentLines = maxVisible - (showTopIndicator ? 1 : 0);
+  const endIndex = Math.min(scrollOffset + contentLines, lines.length);
+  const showBottomIndicator = endIndex < lines.length;
+  const actualContentLines = contentLines - (showBottomIndicator ? 1 : 0);
+  const visibleLines = lines.slice(scrollOffset, scrollOffset + actualContentLines);
+  return /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsxs9(Box9, { marginBottom: 1, children: [
+      /* @__PURE__ */ jsx10(Text10, { color: colors.text, bold: true, children: title }),
+      /* @__PURE__ */ jsxs9(Text10, { color: colors.textDim, children: [
+        " \xB7 ",
+        lines.length,
+        " lines"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs9(
+      Box9,
+      {
+        flexDirection: "column",
+        borderStyle: "single",
+        borderColor: colors.border,
+        paddingX: 1,
+        children: [
+          showTopIndicator && /* @__PURE__ */ jsxs9(Text10, { color: colors.textDim, children: [
+            "\u2191 ",
+            scrollOffset,
+            " more lines"
+          ] }),
+          visibleLines.map((line, i) => /* @__PURE__ */ jsx10(MarkdownLine, { line, inCodeBlock: lineStates[scrollOffset + i] }, scrollOffset + i)),
+          showBottomIndicator && /* @__PURE__ */ jsxs9(Text10, { color: colors.textDim, children: [
+            "\u2193 ",
+            lines.length - scrollOffset - actualContentLines,
+            " more lines"
+          ] })
+        ]
+      }
+    ),
+    /* @__PURE__ */ jsx10(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx10(Text10, { color: colors.textDim, children: "\u2191\u2193 scroll \xB7 space/pgdn page \xB7 esc back" }) })
+  ] });
+}
+
+// src/commands/tui/views/ToolExplorer.tsx
+import { Box as Box10, Text as Text11, useInput as useInput5 } from "ink";
+import { useState as useState5, useMemo as useMemo3 } from "react";
+import { existsSync as existsSync6, readFileSync as readFileSync7 } from "fs";
+import { join as join8 } from "path";
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function ToolExplorer({ tool, onViewSource, onClose }) {
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const items = useMemo3(() => {
+    const result = [];
+    const toolDir = getBundledToolsDir();
+    for (const skill of tool.includes.skills) {
+      result.push({
+        type: "skill",
+        name: skill.name,
+        path: join8(toolDir, tool.name, "skills", skill.name, "SKILL.md")
+      });
+    }
+    for (const cmd of tool.includes.commands) {
+      result.push({
+        type: "command",
+        name: `/${cmd}`,
+        path: join8(toolDir, tool.name, "commands", `${cmd}.md`)
+      });
+    }
+    for (const agent of tool.includes.agents) {
+      result.push({
+        type: "agent",
+        name: agent,
+        path: join8(toolDir, tool.name, "agents", agent, "AGENT.md")
+      });
+    }
+    return result;
+  }, [tool]);
+  useInput5((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.leftArrow || key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    }
+    if (key.rightArrow || key.downArrow) {
+      setSelectedIndex((prev) => Math.min(items.length - 1, prev + 1));
+    }
+    if (key.return && items.length > 0) {
+      const item = items[selectedIndex];
+      if (existsSync6(item.path)) {
+        const content = readFileSync7(item.path, "utf-8");
+        onViewSource(`${tool.name} / ${item.name}`, content);
+      } else {
+        const yamlPath = item.path.replace(".md", ".yaml");
+        if (existsSync6(yamlPath)) {
+          const content = readFileSync7(yamlPath, "utf-8");
+          onViewSource(`${tool.name} / ${item.name}`, content);
+        }
+      }
+    }
+  });
+  const skillItems = items.filter((i) => i.type === "skill");
+  const commandItems = items.filter((i) => i.type === "command");
+  const agentItems = items.filter((i) => i.type === "agent");
+  const getItemIndex = (item) => items.indexOf(item);
+  return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx11(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsxs10(Text11, { children: [
+      /* @__PURE__ */ jsx11(Text11, { color: colors.textDim, children: "[" }),
+      /* @__PURE__ */ jsx11(Text11, { color: colors.primary, children: "\u25CF" }),
+      /* @__PURE__ */ jsx11(Text11, { color: colors.textDim, children: " " }),
+      /* @__PURE__ */ jsx11(Text11, { color: colors.primary, children: "\u25CF" }),
+      /* @__PURE__ */ jsx11(Text11, { color: colors.textDim, children: "] " }),
+      /* @__PURE__ */ jsx11(Text11, { color: colors.text, bold: true, children: tool.name })
+    ] }) }),
+    /* @__PURE__ */ jsx11(Box10, { marginBottom: 1, children: /* @__PURE__ */ jsx11(Text11, { color: colors.textMuted, children: tool.description }) }),
+    skillItems.length > 0 && /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: colors.skill, bold: true, children: "Skills" }),
+      /* @__PURE__ */ jsx11(Box10, { flexDirection: "row", flexWrap: "wrap", marginTop: 1, children: skillItems.map((item) => {
+        const idx = getItemIndex(item);
+        const isSelected = selectedIndex === idx;
+        return /* @__PURE__ */ jsx11(Box10, { marginRight: 1, marginBottom: 1, children: /* @__PURE__ */ jsx11(
+          Text11,
+          {
+            backgroundColor: isSelected ? colors.skill : colors.bgSelected,
+            color: isSelected ? "#000000" : colors.skill,
+            bold: isSelected,
+            children: ` ${item.name} `
+          }
+        ) }, item.name);
+      }) })
+    ] }),
+    commandItems.length > 0 && /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: colors.command, bold: true, children: "Commands" }),
+      /* @__PURE__ */ jsx11(Box10, { flexDirection: "row", flexWrap: "wrap", marginTop: 1, children: commandItems.map((item) => {
+        const idx = getItemIndex(item);
+        const isSelected = selectedIndex === idx;
+        return /* @__PURE__ */ jsx11(Box10, { marginRight: 1, marginBottom: 1, children: /* @__PURE__ */ jsx11(
+          Text11,
+          {
+            backgroundColor: isSelected ? colors.command : colors.bgSelected,
+            color: isSelected ? "#000000" : colors.command,
+            bold: isSelected,
+            children: ` ${item.name} `
+          }
+        ) }, item.name);
+      }) })
+    ] }),
+    agentItems.length > 0 && /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx11(Text11, { color: colors.agent, bold: true, children: "Agents" }),
+      /* @__PURE__ */ jsx11(Box10, { flexDirection: "row", flexWrap: "wrap", marginTop: 1, children: agentItems.map((item) => {
+        const idx = getItemIndex(item);
+        const isSelected = selectedIndex === idx;
+        return /* @__PURE__ */ jsx11(Box10, { marginRight: 1, marginBottom: 1, children: /* @__PURE__ */ jsx11(
+          Text11,
+          {
+            backgroundColor: isSelected ? colors.agent : colors.bgSelected,
+            color: isSelected ? "#000000" : colors.agent,
+            bold: isSelected,
+            children: ` ${item.name} `
+          }
+        ) }, item.name);
+      }) })
+    ] }),
+    /* @__PURE__ */ jsx11(Box10, { marginTop: 1, children: /* @__PURE__ */ jsx11(Text11, { color: colors.textDim, children: "\u2190\u2192 navigate \xB7 enter view source \xB7 esc back" }) })
+  ] });
+}
+
+// src/commands/tui/views/SkillConfigScreen.tsx
+import { Box as Box11, Text as Text12, useInput as useInput6 } from "ink";
+import TextInput2 from "ink-text-input";
+import { useState as useState6, useMemo as useMemo4 } from "react";
+import { jsx as jsx12, jsxs as jsxs11 } from "react/jsx-runtime";
+function SkillConfigScreen({ skill, onComplete, onCancel }) {
+  const configSchema = skill.config_schema || {};
+  const configKeys = Object.keys(configSchema);
+  const initialOverrides = useMemo4(() => loadSkillOverrides(skill.name), [skill.name]);
+  const [values, setValues] = useState6(() => {
+    const initial = {};
+    for (const key of configKeys) {
+      const option = configSchema[key];
+      initial[key] = initialOverrides[key] ?? option.default ?? (option.type === "boolean" /* Boolean */ ? false : "");
+    }
+    return initial;
+  });
+  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const [scrollOffset, setScrollOffset] = useState6(0);
+  const [editingField, setEditingField] = useState6(null);
+  const [editValue, setEditValue] = useState6("");
+  const [editingSelect, setEditingSelect] = useState6(null);
+  const [selectOptionIndex, setSelectOptionIndex] = useState6(0);
+  const totalItems = configKeys.length + 1;
+  const handleSave = () => {
+    saveSkillOverrides(skill.name, values);
+    onComplete();
+  };
+  const handleSubmitEdit = () => {
+    if (editingField) {
+      setValues((prev) => ({ ...prev, [editingField]: editValue }));
+      setEditingField(null);
+      setEditValue("");
+    }
+  };
+  useInput6((input, key) => {
+    if (key.escape) {
+      setEditingField(null);
+      setEditValue("");
+    }
+  }, { isActive: editingField !== null });
+  useInput6((input, key) => {
+    if (!editingSelect) return;
+    const option = configSchema[editingSelect];
+    if (!option?.options) return;
+    if (key.escape) {
+      setEditingSelect(null);
+      return;
+    }
+    if (key.leftArrow || key.upArrow) {
+      setSelectOptionIndex((prev) => Math.max(0, prev - 1));
+    }
+    if (key.rightArrow || key.downArrow) {
+      setSelectOptionIndex((prev) => Math.min(option.options.length - 1, prev + 1));
+    }
+    if (key.return) {
+      setValues((prev) => ({ ...prev, [editingSelect]: option.options[selectOptionIndex] }));
+      setEditingSelect(null);
+    }
+  }, { isActive: editingSelect !== null });
+  useInput6((input, key) => {
+    if (key.escape) {
+      onCancel();
+      return;
+    }
+    if (key.upArrow) {
+      setSelectedIndex((prev) => {
+        const newIndex = Math.max(0, prev - 1);
+        if (newIndex < scrollOffset) {
+          setScrollOffset(newIndex);
+        }
+        return newIndex;
+      });
+    }
+    if (key.downArrow) {
+      setSelectedIndex((prev) => {
+        const newIndex = Math.min(totalItems - 1, prev + 1);
+        if (newIndex >= scrollOffset + MAX_VISIBLE_CONFIG_ITEMS) {
+          setScrollOffset(newIndex - MAX_VISIBLE_CONFIG_ITEMS + 1);
+        }
+        return newIndex;
+      });
+    }
+    if (key.return) {
+      if (selectedIndex === configKeys.length) {
+        handleSave();
+        return;
+      }
+      const key2 = configKeys[selectedIndex];
+      const option = configSchema[key2];
+      if (option.type === "boolean" /* Boolean */) {
+        setValues((prev) => ({ ...prev, [key2]: !prev[key2] }));
+      } else if (option.type === "select" /* Select */ && option.options) {
+        const currentValue = String(values[key2] || option.options[0]);
+        const currentIndex = option.options.indexOf(currentValue);
+        setSelectOptionIndex(currentIndex >= 0 ? currentIndex : 0);
+        setEditingSelect(key2);
+      } else if (option.type === "string" /* String */) {
+        setEditingField(key2);
+        setEditValue(String(values[key2] || ""));
+      }
+    }
+  }, { isActive: editingField === null && editingSelect === null });
+  if (configKeys.length === 0) {
+    return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", padding: 1, children: [
+      /* @__PURE__ */ jsx12(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Text12, { children: [
+        /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "[" }),
+        /* @__PURE__ */ jsx12(Text12, { color: colors.primary, children: "\u25CF" }),
+        /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: " " }),
+        /* @__PURE__ */ jsx12(Text12, { color: colors.primary, children: "\u25CF" }),
+        /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "] " }),
+        /* @__PURE__ */ jsxs11(Text12, { color: colors.text, bold: true, children: [
+          "configure ",
+          skill.name
+        ] })
+      ] }) }),
+      /* @__PURE__ */ jsx12(Text12, { color: colors.textMuted, children: "This skill has no configuration options." }),
+      /* @__PURE__ */ jsx12(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "esc to go back" }) })
+    ] });
+  }
+  const visibleEndIndex = Math.min(scrollOffset + MAX_VISIBLE_CONFIG_ITEMS, totalItems);
+  const visibleConfigKeys = configKeys.slice(scrollOffset, Math.min(scrollOffset + MAX_VISIBLE_CONFIG_ITEMS, configKeys.length));
+  const showSaveButton = visibleEndIndex > configKeys.length || scrollOffset + MAX_VISIBLE_CONFIG_ITEMS > configKeys.length;
+  const showTopIndicator = scrollOffset > 0;
+  const showBottomIndicator = scrollOffset + MAX_VISIBLE_CONFIG_ITEMS < totalItems;
+  return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx12(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Text12, { children: [
+      /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "[" }),
+      /* @__PURE__ */ jsx12(Text12, { color: colors.primary, children: "\u25CF" }),
+      /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: " " }),
+      /* @__PURE__ */ jsx12(Text12, { color: colors.primary, children: "\u25CF" }),
+      /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "] " }),
+      /* @__PURE__ */ jsxs11(Text12, { color: colors.text, bold: true, children: [
+        "configure ",
+        skill.name
+      ] })
+    ] }) }),
+    /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", children: [
+      showTopIndicator && /* @__PURE__ */ jsx12(Box11, { marginBottom: 1, children: /* @__PURE__ */ jsxs11(Text12, { color: colors.textDim, children: [
+        "  \u2191 ",
+        scrollOffset,
+        " more"
+      ] }) }),
+      visibleConfigKeys.map((configKey) => {
+        const actualIndex = configKeys.indexOf(configKey);
+        const option = configSchema[configKey];
+        const isSelected = selectedIndex === actualIndex;
+        const isEditing = editingField === configKey;
+        return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", marginBottom: 1, children: [
+          /* @__PURE__ */ jsxs11(Text12, { children: [
+            /* @__PURE__ */ jsxs11(Text12, { color: colors.textDim, children: [
+              isSelected ? ">" : " ",
+              " "
+            ] }),
+            /* @__PURE__ */ jsx12(Text12, { color: isSelected ? colors.text : colors.textMuted, children: configKey })
+          ] }),
+          /* @__PURE__ */ jsxs11(Text12, { color: colors.textDim, children: [
+            "    ",
+            option.description
+          ] }),
+          /* @__PURE__ */ jsxs11(Box11, { children: [
+            /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "    " }),
+            option.type === "boolean" /* Boolean */ ? /* @__PURE__ */ jsxs11(Text12, { color: colors.text, children: [
+              "[",
+              values[configKey] ? "x" : " ",
+              "] ",
+              values[configKey] ? "enabled" : "disabled"
+            ] }) : option.type === "select" /* Select */ && option.options ? /* @__PURE__ */ jsx12(Text12, { color: colors.text, children: option.options.map((opt, i) => {
+              const isCurrentValue = String(values[configKey]) === opt;
+              const isEditingThis = editingSelect === configKey;
+              const isHighlighted = isEditingThis && selectOptionIndex === i;
+              return /* @__PURE__ */ jsxs11(Text12, { children: [
+                i > 0 && /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: " \xB7 " }),
+                /* @__PURE__ */ jsx12(
+                  Text12,
+                  {
+                    color: isHighlighted ? "#ffffff" : isCurrentValue ? colors.primary : colors.textMuted,
+                    backgroundColor: isHighlighted ? colors.primary : void 0,
+                    children: isCurrentValue && !isEditingThis ? `[${opt}]` : isHighlighted ? ` ${opt} ` : opt
+                  }
+                )
+              ] }, opt);
+            }) }) : isEditing ? /* @__PURE__ */ jsxs11(Box11, { children: [
+              /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: "> " }),
+              /* @__PURE__ */ jsx12(
+                TextInput2,
+                {
+                  value: editValue,
+                  onChange: setEditValue,
+                  onSubmit: handleSubmitEdit
+                }
+              )
+            ] }) : /* @__PURE__ */ jsx12(Text12, { color: colors.text, children: String(values[configKey]) || "(not set)" })
+          ] })
+        ] }, configKey);
+      }),
+      showSaveButton && /* @__PURE__ */ jsx12(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text12, { children: [
+        /* @__PURE__ */ jsxs11(Text12, { color: colors.textDim, children: [
+          selectedIndex === configKeys.length ? ">" : " ",
+          " "
+        ] }),
+        /* @__PURE__ */ jsxs11(
+          Text12,
+          {
+            backgroundColor: selectedIndex === configKeys.length ? colors.primary : void 0,
+            color: selectedIndex === configKeys.length ? "#ffffff" : colors.textMuted,
+            bold: selectedIndex === configKeys.length,
+            children: [
+              " ",
+              "Save",
+              " "
+            ]
+          }
+        )
+      ] }) }),
+      showBottomIndicator && /* @__PURE__ */ jsx12(Box11, { marginTop: 1, children: /* @__PURE__ */ jsxs11(Text12, { color: colors.textDim, children: [
+        "  \u2193 ",
+        totalItems - scrollOffset - MAX_VISIBLE_CONFIG_ITEMS,
+        " more"
+      ] }) })
+    ] }),
+    /* @__PURE__ */ jsx12(Box11, { marginTop: 1, children: /* @__PURE__ */ jsx12(Text12, { color: colors.textDim, children: editingField ? "enter save \xB7 esc cancel" : editingSelect ? "\u2190\u2192 choose \xB7 enter select \xB7 esc cancel" : "\u2191\u2193 select \xB7 enter toggle/edit \xB7 esc back" }) })
+  ] });
+}
+
+// src/commands/tui/hooks/useAppUpdate.ts
+import { useState as useState7, useMemo as useMemo5 } from "react";
+import { useApp } from "ink";
+function useAppUpdate({ onUpdateSuccess, onUpdateFailure }) {
+  const { exit } = useApp();
+  const [isUpdating, setIsUpdating] = useState7(false);
+  const updateInfo = useMemo5(() => getUpdateInfo(), []);
+  const handleUpdate = () => {
+    setIsUpdating(true);
+    setTimeout(() => {
+      const result = runUpdate();
+      if (result.success) {
+        const blue = "\x1B[38;2;99;102;241m";
+        const dim = "\x1B[38;2;106;106;106m";
+        const reset = "\x1B[0m";
+        const message = `
+${dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${reset}
+
+    ${dim}\u2554\u2550\u2550\u2550\u2550\u2550\u2557${reset}
+    ${dim}\u2551${reset} ${blue}\u25CF${reset} ${blue}\u25CF${reset} ${dim}\u2551${reset}   ${blue}"It's quite possible this system${reset}
+    ${dim}\u255A\u2550\u2566\u2550\u2566\u2550\u255D${reset}    ${blue}is now fully operational."${reset}
+
+             Run ${blue}droid${reset} to start the new version.
+
+${dim}\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500${reset}
+`;
+        onUpdateSuccess(message);
+        exit();
+      } else {
+        setIsUpdating(false);
+        onUpdateFailure(result.message);
+      }
+    }, 100);
+  };
+  const handleAlwaysUpdate = () => {
+    setAutoUpdateConfig({ app: true });
+    handleUpdate();
+  };
+  return {
+    updateInfo,
+    isUpdating,
+    handleUpdate,
+    handleAlwaysUpdate
+  };
+}
+
+// src/commands/tui/hooks/useToolUpdates.ts
+import { useState as useState8, useCallback } from "react";
+function useToolUpdates({ onUpdateComplete }) {
+  const [toolUpdates, setToolUpdates] = useState8([]);
+  const [isUpdatingTools, setIsUpdatingTools] = useState8(false);
+  const [autoUpdatedTools, setAutoUpdatedTools] = useState8([]);
+  const tools = getBundledTools();
+  const ensureSystemTools = useCallback(() => {
+    const systemTools = tools.filter((t) => t.system === true);
+    for (const systemTool of systemTools) {
+      const installed = isToolInstalled(systemTool.name);
+      const updateStatus = getToolUpdateStatus(systemTool.name);
+      if (!installed || updateStatus.hasUpdate) {
+        const primarySkill = systemTool.includes.skills.find((s) => s.required)?.name || systemTool.name;
+        installSkill(primarySkill);
+      }
+    }
+  }, [tools]);
+  const checkForUpdates = useCallback(() => {
+    ensureSystemTools();
+    const updates = getToolsWithUpdates();
+    setToolUpdates(updates);
+    const autoUpdateConfig = getAutoUpdateConfig();
+    return {
+      updates,
+      shouldAutoUpdate: autoUpdateConfig.tools && updates.length > 0
+    };
+  }, [ensureSystemTools]);
+  const updateAllTools = useCallback((updates = toolUpdates, silent = false) => {
+    if (!silent) {
+      setIsUpdatingTools(true);
+    }
+    setTimeout(() => {
+      let successCount = 0;
+      let failCount = 0;
+      const updatedNames = [];
+      for (const tool of updates) {
+        const toolManifest = tools.find((t) => t.name === tool.name);
+        if (toolManifest) {
+          const primarySkill = toolManifest.includes.skills.find((s) => s.required)?.name || toolManifest.name;
+          const result = updateSkill(primarySkill);
+          if (result.success) {
+            successCount++;
+            updatedNames.push(tool.name);
+          } else {
+            failCount++;
+          }
+        }
+      }
+      setIsUpdatingTools(false);
+      if (silent && updatedNames.length > 0) {
+        setAutoUpdatedTools(updatedNames);
+      }
+      onUpdateComplete({ successCount, failCount, updatedNames, silent });
+    }, 100);
+  }, [toolUpdates, tools, onUpdateComplete]);
+  const enableAutoUpdateAndUpdate = useCallback(() => {
+    setAutoUpdateConfig({ tools: true });
+    updateAllTools();
+  }, [updateAllTools]);
+  return {
+    toolUpdates,
+    isUpdatingTools,
+    autoUpdatedTools,
+    checkForUpdates,
+    updateAllTools,
+    enableAutoUpdateAndUpdate
+  };
+}
+
+// src/commands/tui.tsx
+import { Fragment as Fragment2, jsx as jsx13, jsxs as jsxs12 } from "react/jsx-runtime";
+var exitMessage = null;
+function App() {
+  const { exit } = useApp2();
+  const tabs = [
+    { id: "tools", label: "Tools" },
+    { id: "settings", label: "Settings" }
+  ];
+  const [activeTab, setActiveTab] = useState9("tools");
+  const [tabIndex, setTabIndex] = useState9(0);
+  const [view, setView] = useState9("welcome");
+  const [selectedIndex, setSelectedIndex] = useState9(0);
+  const [selectedAction, setSelectedAction] = useState9(0);
+  const [scrollOffset, setScrollOffset] = useState9(0);
+  const [message, setMessage] = useState9(null);
+  const [isEditingSettings, setIsEditingSettings] = useState9(false);
+  const [readmeContent, setReadmeContent] = useState9(null);
+  const [previousView, setPreviousView] = useState9("detail");
+  const { updateInfo, isUpdating, handleUpdate, handleAlwaysUpdate } = useAppUpdate({
+    onUpdateSuccess: (msg) => {
+      exitMessage = msg;
+    },
+    onUpdateFailure: (error) => {
+      setMessage({ text: error, type: "error" });
+      if (!configExists()) {
+        setView("setup");
+      } else {
+        setView("menu");
+      }
+    }
+  });
+  const proceedToNextView = () => {
+    if (!configExists()) {
+      setView("setup");
+    } else {
+      setView("menu");
+    }
+  };
+  const {
+    toolUpdates,
+    isUpdatingTools,
+    autoUpdatedTools,
+    checkForUpdates,
+    updateAllTools,
+    enableAutoUpdateAndUpdate
+  } = useToolUpdates({
+    onUpdateComplete: ({ successCount, failCount, silent }) => {
+      if (successCount > 0) {
+        setMessage({
+          text: silent ? `\u2191 Auto-updated ${successCount} tool${successCount > 1 ? "s" : ""}` : `\u2713 Updated ${successCount} tool${successCount > 1 ? "s" : ""}${failCount > 0 ? `, ${failCount} failed` : ""}`,
+          type: failCount > 0 ? "error" : "success"
+        });
+      }
+      proceedToNextView();
+    }
+  });
+  const checkToolUpdatesAndProceed = () => {
+    const { updates, shouldAutoUpdate } = checkForUpdates();
+    if (shouldAutoUpdate) {
+      updateAllTools(updates, true);
+      return;
+    }
+    if (updates.length > 0) {
+      setView("tool-updates");
+      return;
+    }
+    proceedToNextView();
+  };
+  const handleSkipToolUpdates = () => {
+    proceedToNextView();
+  };
+  const tools = getBundledTools();
+  const skills = getBundledSkills();
+  useInput7((input, key) => {
+    if (message) setMessage(null);
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (view === "menu") {
+      if (key.leftArrow) {
+        const newIndex = Math.max(0, tabIndex - 1);
+        setTabIndex(newIndex);
+        setActiveTab(tabs[newIndex].id);
+        setSelectedIndex(0);
+        setScrollOffset(0);
+      }
+      if (key.rightArrow) {
+        const newIndex = Math.min(tabs.length - 1, tabIndex + 1);
+        setTabIndex(newIndex);
+        setActiveTab(tabs[newIndex].id);
+        setSelectedIndex(0);
+        setScrollOffset(0);
+      }
+      if (key.upArrow) {
+        setSelectedIndex((prev) => {
+          const newIndex = Math.max(0, prev - 1);
+          if (newIndex < scrollOffset) {
+            setScrollOffset(newIndex);
+          }
+          return newIndex;
+        });
+        setSelectedAction(0);
+      }
+      if (key.downArrow) {
+        const maxIndex = activeTab === "tools" ? tools.length - 1 : 0;
+        setSelectedIndex((prev) => {
+          const newIndex = Math.min(maxIndex, prev + 1);
+          if (newIndex >= scrollOffset + MAX_VISIBLE_ITEMS) {
+            setScrollOffset(newIndex - MAX_VISIBLE_ITEMS + 1);
+          }
+          return newIndex;
+        });
+        setSelectedAction(0);
+      }
+      if (key.return) {
+        if (activeTab === "tools" && tools.length > 0) {
+          setView("detail");
+        } else if (activeTab === "settings") {
+          setView("detail");
+        }
+      }
+    } else if (view === "detail") {
+      if (key.escape || key.backspace) {
+        setView("menu");
+        setSelectedAction(0);
+      }
+      if (activeTab === "settings") {
+        if (key.return) {
+          setIsEditingSettings(true);
+          setView("setup");
+        }
+      }
+      if (key.leftArrow && activeTab === "tools") {
+        setSelectedAction((prev) => Math.max(0, prev - 1));
+      }
+      if (key.rightArrow && activeTab === "tools") {
+        let maxActions = 0;
+        const tool = tools[selectedIndex];
+        const installed = tool ? isToolInstalled(tool.name) : false;
+        const hasUpdate = tool ? getToolUpdateStatus(tool.name).hasUpdate : false;
+        const isSystem = tool ? tool.system === true : false;
+        maxActions = installed ? hasUpdate ? isSystem ? 2 : 3 : isSystem ? 1 : 2 : 1;
+        setSelectedAction((prev) => Math.min(maxActions, prev + 1));
+      }
+      if (key.return && activeTab === "tools") {
+        const tool = tools[selectedIndex];
+        if (tool) {
+          const installed = isToolInstalled(tool.name);
+          const toolUpdateStatus = getToolUpdateStatus(tool.name);
+          const isSystemTool = tool.system === true;
+          const toolActions = installed ? [
+            { id: "explore" },
+            ...toolUpdateStatus.hasUpdate ? [{ id: "update" }] : [],
+            { id: "configure" },
+            ...!isSystemTool ? [{ id: "uninstall" }] : []
+          ] : [{ id: "explore" }, { id: "install" }];
+          const actionId = toolActions[selectedAction]?.id;
+          if (actionId === "explore") {
+            setView("explorer");
+          } else if (actionId === "update") {
+            const primarySkill = tool.includes.skills.find((s) => s.required)?.name || tool.name;
+            const result = updateSkill(primarySkill);
+            setMessage({
+              text: result.success ? `\u2713 Updated ${tool.name}` : `\u2717 ${result.message}`,
+              type: result.success ? "success" : "error"
+            });
+            if (result.success) {
+              setSelectedAction(0);
+            }
+          } else if (actionId === "configure") {
+            setView("configure");
+          } else if (actionId === "uninstall") {
+            const primarySkill = tool.includes.skills.find((s) => s.required)?.name || tool.name;
+            const result = uninstallSkill(primarySkill);
+            setMessage({
+              text: result.success ? `\u2713 Uninstalled ${tool.name}` : `\u2717 ${result.message}`,
+              type: result.success ? "success" : "error"
+            });
+            if (result.success) {
+              setView("menu");
+              setSelectedAction(0);
+            }
+          } else if (actionId === "install") {
+            const primarySkill = tool.includes.skills.find((s) => s.required)?.name || tool.name;
+            const result = installSkill(primarySkill);
+            setMessage({
+              text: result.success ? `\u2713 Installed ${tool.name}` : `\u2717 ${result.message}`,
+              type: result.success ? "success" : "error"
+            });
+            if (result.success) {
+              const configSchema = tool.config_schema || {};
+              const hasRequiredConfig = Object.values(configSchema).some(
+                (option) => option.default === void 0
+              );
+              if (hasRequiredConfig) {
+                setView("configure");
+              } else {
+                setView("menu");
+                setSelectedAction(0);
+              }
+            }
+          }
+        }
+      }
+    }
+  }, { isActive: view !== "welcome" && view !== "tool-updates" && view !== "setup" && view !== "configure" && view !== "explorer" });
+  const selectedTool = activeTab === "tools" ? tools[selectedIndex] ?? null : null;
+  const selectedSkillForConfig = selectedTool ? skills.find((s) => s.name === (selectedTool.includes.skills.find((sk) => sk.required)?.name || selectedTool.name)) : null;
+  if (view === "welcome") {
+    return /* @__PURE__ */ jsx13(
+      WelcomeScreen,
+      {
+        updateInfo,
+        isUpdating,
+        onUpdate: handleUpdate,
+        onAlways: handleAlwaysUpdate,
+        onExit: exit,
+        onContinue: checkToolUpdatesAndProceed
+      }
+    );
+  }
+  if (view === "tool-updates" && toolUpdates.length > 0) {
+    return /* @__PURE__ */ jsx13(
+      ToolUpdatePrompt,
+      {
+        toolUpdates,
+        onUpdateAll: () => updateAllTools(),
+        onAlways: enableAutoUpdateAndUpdate,
+        onSkip: handleSkipToolUpdates,
+        isUpdating: isUpdatingTools
+      }
+    );
+  }
+  if (view === "setup") {
+    return /* @__PURE__ */ jsx13(
+      SetupScreen,
+      {
+        onComplete: () => {
+          setIsEditingSettings(false);
+          setView("menu");
+        },
+        onSkip: () => {
+          setIsEditingSettings(false);
+          setView("menu");
+        },
+        initialConfig: isEditingSettings ? loadConfig() : void 0
+      }
+    );
+  }
+  if (view === "readme" && readmeContent) {
+    return /* @__PURE__ */ jsx13(
+      ReadmeViewer,
+      {
+        title: readmeContent.title,
+        content: readmeContent.content,
+        onClose: () => {
+          setReadmeContent(null);
+          setView(previousView);
+        }
+      }
+    );
+  }
+  if (view === "explorer" && selectedTool) {
+    return /* @__PURE__ */ jsx13(
+      ToolExplorer,
+      {
+        tool: selectedTool,
+        onViewSource: (title, content) => {
+          setPreviousView("explorer");
+          setReadmeContent({ title, content });
+          setView("readme");
+        },
+        onClose: () => {
+          setView("detail");
+        }
+      }
+    );
+  }
+  if (view === "configure" && selectedSkillForConfig) {
+    return /* @__PURE__ */ jsx13(
+      SkillConfigScreen,
+      {
+        skill: selectedSkillForConfig,
+        onComplete: () => {
+          setMessage({ text: `\u2713 Configuration saved for ${selectedTool?.name || selectedSkillForConfig.name}`, type: "success" });
+          setView("detail");
+        },
+        onCancel: () => {
+          setView("detail");
+        }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs12(Box12, { flexDirection: "row", padding: 1, children: [
+    /* @__PURE__ */ jsxs12(
+      Box12,
+      {
+        flexDirection: "column",
+        width: 44,
+        borderStyle: "single",
+        borderColor: colors.border,
+        children: [
+          /* @__PURE__ */ jsx13(Box12, { paddingX: 1, children: /* @__PURE__ */ jsxs12(Text13, { children: [
+            /* @__PURE__ */ jsx13(Text13, { color: colors.textDim, children: "[" }),
+            /* @__PURE__ */ jsx13(Text13, { color: colors.primary, children: "\u25CF" }),
+            /* @__PURE__ */ jsx13(Text13, { color: colors.textDim, children: " " }),
+            /* @__PURE__ */ jsx13(Text13, { color: colors.primary, children: "\u25CF" }),
+            /* @__PURE__ */ jsx13(Text13, { color: colors.textDim, children: "] " }),
+            /* @__PURE__ */ jsx13(Text13, { color: colors.textMuted, children: "droid" }),
+            /* @__PURE__ */ jsxs12(Text13, { color: colors.textDim, children: [
+              " v",
+              getVersion()
+            ] })
+          ] }) }),
+          /* @__PURE__ */ jsx13(Box12, { paddingX: 1, children: /* @__PURE__ */ jsx13(Text13, { color: colors.textDim, children: loadConfig().platform === "claude-code" /* ClaudeCode */ ? "Claude Code" : "OpenCode" }) }),
+          /* @__PURE__ */ jsx13(Box12, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx13(TabBar, { tabs, activeTab }) }),
+          /* @__PURE__ */ jsxs12(Box12, { flexDirection: "column", marginTop: 1, children: [
+            activeTab === "tools" && /* @__PURE__ */ jsxs12(Fragment2, { children: [
+              scrollOffset > 0 && /* @__PURE__ */ jsx13(Box12, { paddingX: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: colors.textDim, children: [
+                "\u2191 ",
+                scrollOffset,
+                " more"
+              ] }) }),
+              tools.slice(scrollOffset, scrollOffset + MAX_VISIBLE_ITEMS).map((tool, index) => /* @__PURE__ */ jsx13(
+                ToolItem,
+                {
+                  tool,
+                  isSelected: scrollOffset + index === selectedIndex,
+                  isActive: scrollOffset + index === selectedIndex && view === "detail",
+                  wasAutoUpdated: autoUpdatedTools.includes(tool.name)
+                },
+                tool.name
+              )),
+              scrollOffset + MAX_VISIBLE_ITEMS < tools.length && /* @__PURE__ */ jsx13(Box12, { paddingX: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: colors.textDim, children: [
+                "\u2193 ",
+                tools.length - scrollOffset - MAX_VISIBLE_ITEMS,
+                " more"
+              ] }) }),
+              tools.length > MAX_VISIBLE_ITEMS && /* @__PURE__ */ jsx13(Box12, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsxs12(Text13, { color: colors.textDim, children: [
+                tools.length,
+                " tools total"
+              ] }) })
+            ] }),
+            activeTab === "settings" && /* @__PURE__ */ jsx13(Box12, { paddingX: 1, children: /* @__PURE__ */ jsx13(Text13, { color: colors.textDim, children: "View and edit config" }) })
+          ] }),
+          message && /* @__PURE__ */ jsx13(Box12, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { color: message.type === "success" ? colors.success : colors.error, children: message.text }) }),
+          /* @__PURE__ */ jsx13(Box12, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx13(Text13, { color: colors.textDim, children: view === "menu" ? "\u2190\u2192 \u2191\u2193 enter q" : "\u2190\u2192 enter esc q" }) })
+        ]
+      }
+    ),
+    activeTab === "tools" && /* @__PURE__ */ jsx13(ToolDetails, { tool: selectedTool, isFocused: view === "detail", selectedAction }),
+    activeTab === "settings" && /* @__PURE__ */ jsx13(
+      SettingsDetails,
+      {
+        isFocused: view === "detail"
+      }
+    )
+  ] });
+}
+async function tuiCommand() {
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[H");
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx13(App, {}));
+  await waitUntilExit();
+  process.stdout.write("\x1B[?1049l");
+  if (exitMessage) {
+    console.log(exitMessage);
+    exitMessage = null;
+  }
+}
+
+// src/bin/droid.ts
+var version = getVersion();
+program.name("droid").description("Droid, teaching your AI new tricks").version(version);
+program.command("setup").description("Interactive wizard for global configuration").action(setupCommand);
+program.command("config").description("View or edit configuration").option("-e, --edit", "Open config in editor").option("-g, --get <key>", "Get a specific config value").option("-s, --set <key=value>", "Set a config value").action(configCommand);
+program.command("tools").description("Browse and manage available tools").action(skillsCommand);
+program.command("install <tool>").description("Install a tool and run its setup wizard").action(installCommand);
+program.command("uninstall <tool>").description("Uninstall a tool").action(uninstallCommand);
+program.command("update").description("Update droid and installed tools").option("--tools", "Only update tools").option("--cli", "Only update the CLI").argument("[tool]", "Update a specific tool").action(updateCommand);
+program.command("tui").description("Launch interactive TUI dashboard").action(tuiCommand);
+if (process.argv.length === 2) {
+  tuiCommand();
+} else {
+  program.parse();
 }
-//# sourceMappingURL=droid.js.map