ux-toolkit 0.4.0 → 0.5.0

package/dist/cli.js

@@ -1,28 +1,106 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/cli.ts
 import { parseArgs } from "util";
+import { createInterface } from "readline";
 
 // src/installer.ts
-import { existsSync, mkdirSync, cpSync, readdirSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, cpSync, readdirSync, rmSync, statSync } from "fs";
 import { join as join2, dirname as dirname2 } from "path";
 
 // src/paths.ts
-import { homedir } from "os";
-import { join, dirname } from "path";
+import { homedir, platform } from "os";
+import { join, dirname, resolve } from "path";
 import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
+import { existsSync } from "fs";
+function getCurrentDirname() {
+  try {
+    if (import.meta?.url) {
+      return dirname(fileURLToPath(import.meta.url));
+    }
+  } catch {
+  }
+  try {
+    const packageJsonPath = __require.resolve("ux-toolkit/package.json");
+    return join(dirname(packageJsonPath), "dist");
+  } catch {
+  }
+  const cwd = process.cwd();
+  try {
+    const fs = __require("fs");
+    const pkgPath = resolve(cwd, "package.json");
+    if (fs.existsSync(pkgPath)) {
+      const pkg = __require(pkgPath);
+      if (pkg.name === "ux-toolkit") {
+        return resolve(cwd, "dist");
+      }
+    }
+  } catch {
+  }
+  return resolve(cwd, "dist");
+}
+var currentDirname = getCurrentDirname();
 function getPackageRoot() {
-  return join(__dirname, "..");
+  return join(currentDirname, "..");
 }
 function getGlobalConfigDir() {
-  return join(homedir(), ".config", "opencode");
+  if (process.env.UX_TOOLKIT_CONFIG_DIR) {
+    return resolve(process.env.UX_TOOLKIT_CONFIG_DIR);
+  }
+  if (process.env.OPENCODE_CONFIG_DIR) {
+    return resolve(process.env.OPENCODE_CONFIG_DIR);
+  }
+  const home = homedir();
+  const currentPlatform = platform();
+  if (currentPlatform === "linux" && process.env.XDG_CONFIG_HOME) {
+    return join(process.env.XDG_CONFIG_HOME, "opencode");
+  }
+  return join(home, ".config", "opencode");
+}
+function isOpenCodeInstalled() {
+  return existsSync(getGlobalConfigDir());
+}
+function getClaudeConfigDir() {
+  if (process.env.CLAUDE_CONFIG_DIR) {
+    return resolve(process.env.CLAUDE_CONFIG_DIR);
+  }
+  return join(homedir(), ".claude");
+}
+function isClaudeInstalled() {
+  return existsSync(getClaudeConfigDir());
 }
-function getProjectConfigDir(projectRoot = process.cwd()) {
-  return join(projectRoot, ".opencode");
+function getPlatformInfo() {
+  const opencodeDir = getGlobalConfigDir();
+  const claudeDir = getClaudeConfigDir();
+  return {
+    platform: platform(),
+    opencode: {
+      configDir: opencodeDir,
+      exists: existsSync(opencodeDir)
+    },
+    claude: {
+      configDir: claudeDir,
+      exists: existsSync(claudeDir)
+    }
+  };
 }
-function getDestinationPaths(global, projectRoot) {
-  const baseDir = global ? getGlobalConfigDir() : getProjectConfigDir(projectRoot);
+function getProjectConfigDir(projectRoot = process.cwd(), target = "opencode") {
+  const dirName = target === "claude" ? ".claude" : ".opencode";
+  return join(projectRoot, dirName);
+}
+function getDestinationPaths(global, projectRoot, target = "opencode") {
+  let baseDir;
+  if (global) {
+    baseDir = target === "claude" ? getClaudeConfigDir() : getGlobalConfigDir();
+  } else {
+    baseDir = getProjectConfigDir(projectRoot, target);
+  }
   return {
     skills: join(baseDir, "skills"),
     agents: join(baseDir, "agents"),
@@ -30,97 +108,6 @@ function getDestinationPaths(global, projectRoot) {
   };
 }
 
-// src/installer.ts
-async function install(options = {}) {
-  const {
-    global: isGlobal = false,
-    projectRoot = process.cwd(),
-    categories = ["skills", "agents", "commands"],
-    force = false,
-    verbose = false
-  } = options;
-  const result = {
-    installed: [],
-    skipped: [],
-    errors: []
-  };
-  const packageRoot = getPackageRoot();
-  const destinations = getDestinationPaths(isGlobal, projectRoot);
-  const log = (msg) => {
-    if (verbose) console.log(msg);
-  };
-  if (categories.includes("skills")) {
-    const skillsDir = join2(packageRoot, "skills");
-    if (existsSync(skillsDir)) {
-      const skills = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
-      for (const skill of skills) {
-        const src = join2(skillsDir, skill);
-        const dest = join2(destinations.skills, skill);
-        try {
-          if (existsSync(dest) && !force) {
-            result.skipped.push(`skill:${skill}`);
-            log(`Skipped skill/${skill} (already exists)`);
-            continue;
-          }
-          mkdirSync(dirname2(dest), { recursive: true });
-          cpSync(src, dest, { recursive: true });
-          result.installed.push(`skill:${skill}`);
-          log(`Installed skill/${skill}`);
-        } catch (err) {
-          result.errors.push(`skill:${skill}: ${err}`);
-        }
-      }
-    }
-  }
-  if (categories.includes("agents")) {
-    const agentsDir = join2(packageRoot, "agents");
-    if (existsSync(agentsDir)) {
-      const agents = readdirSync(agentsDir).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
-      for (const agent of agents) {
-        const src = join2(agentsDir, `${agent}.md`);
-        const dest = join2(destinations.agents, `${agent}.md`);
-        try {
-          if (existsSync(dest) && !force) {
-            result.skipped.push(`agent:${agent}`);
-            log(`Skipped agents/${agent}.md (already exists)`);
-            continue;
-          }
-          mkdirSync(dirname2(dest), { recursive: true });
-          cpSync(src, dest);
-          result.installed.push(`agent:${agent}`);
-          log(`Installed agents/${agent}.md`);
-        } catch (err) {
-          result.errors.push(`agent:${agent}: ${err}`);
-        }
-      }
-    }
-  }
-  if (categories.includes("commands")) {
-    const commandsDir = join2(packageRoot, "commands");
-    if (existsSync(commandsDir)) {
-      const commands = readdirSync(commandsDir).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
-      for (const command of commands) {
-        const src = join2(commandsDir, `${command}.md`);
-        const dest = join2(destinations.commands, `${command}.md`);
-        try {
-          if (existsSync(dest) && !force) {
-            result.skipped.push(`command:${command}`);
-            log(`Skipped commands/${command}.md (already exists)`);
-            continue;
-          }
-          mkdirSync(dirname2(dest), { recursive: true });
-          cpSync(src, dest);
-          result.installed.push(`command:${command}`);
-          log(`Installed commands/${command}.md`);
-        } catch (err) {
-          result.errors.push(`command:${command}: ${err}`);
-        }
-      }
-    }
-  }
-  return result;
-}
-
 // src/manifest.ts
 var SKILLS = [
   // Core UX Skills
@@ -372,7 +359,269 @@ var COMMANDS = [
   }
 ];
 
+// src/installer.ts
+async function install(options = {}) {
+  const {
+    global: isGlobal = false,
+    projectRoot = process.cwd(),
+    target = "opencode",
+    categories = ["skills", "agents", "commands"],
+    skills: specificSkills,
+    agents: specificAgents,
+    commands: specificCommands,
+    force = false,
+    verbose = false
+  } = options;
+  const hasSpecificComponents = specificSkills?.length || specificAgents?.length || specificCommands?.length;
+  const effectiveCategories = hasSpecificComponents ? categories.filter((cat) => {
+    if (cat === "skills" && specificSkills?.length) return true;
+    if (cat === "agents" && specificAgents?.length) return true;
+    if (cat === "commands" && specificCommands?.length) return true;
+    return false;
+  }) : categories;
+  const result = {
+    installed: [],
+    skipped: [],
+    errors: []
+  };
+  const packageRoot = getPackageRoot();
+  const destinations = getDestinationPaths(isGlobal, projectRoot, target);
+  const log = (msg) => {
+    if (verbose) console.log(msg);
+  };
+  if (effectiveCategories.includes("skills")) {
+    const skillsDir = join2(packageRoot, "skills");
+    if (existsSync2(skillsDir)) {
+      let skills = readdirSync(skillsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+      if (specificSkills?.length) {
+        const requested = new Set(specificSkills.map((s) => s.toLowerCase()));
+        skills = skills.filter((s) => requested.has(s.toLowerCase()));
+      }
+      for (const skill of skills) {
+        const src = join2(skillsDir, skill);
+        const dest = join2(destinations.skills, skill);
+        try {
+          if (existsSync2(dest) && !force) {
+            result.skipped.push(`skill:${skill}`);
+            log(`Skipped skill/${skill} (already exists)`);
+            continue;
+          }
+          mkdirSync(dirname2(dest), { recursive: true });
+          cpSync(src, dest, { recursive: true });
+          result.installed.push(`skill:${skill}`);
+          log(`Installed skill/${skill}`);
+        } catch (err) {
+          result.errors.push(`skill:${skill}: ${err}`);
+        }
+      }
+    }
+  }
+  if (effectiveCategories.includes("agents")) {
+    const agentsDir = join2(packageRoot, "agents");
+    if (existsSync2(agentsDir)) {
+      let agents = readdirSync(agentsDir).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+      if (specificAgents?.length) {
+        const requested = new Set(specificAgents.map((a) => a.toLowerCase()));
+        agents = agents.filter((a) => requested.has(a.toLowerCase()));
+      }
+      for (const agent of agents) {
+        const src = join2(agentsDir, `${agent}.md`);
+        const dest = join2(destinations.agents, `${agent}.md`);
+        try {
+          if (existsSync2(dest) && !force) {
+            result.skipped.push(`agent:${agent}`);
+            log(`Skipped agents/${agent}.md (already exists)`);
+            continue;
+          }
+          mkdirSync(dirname2(dest), { recursive: true });
+          cpSync(src, dest);
+          result.installed.push(`agent:${agent}`);
+          log(`Installed agents/${agent}.md`);
+        } catch (err) {
+          result.errors.push(`agent:${agent}: ${err}`);
+        }
+      }
+    }
+  }
+  if (effectiveCategories.includes("commands")) {
+    const commandsDir = join2(packageRoot, "commands");
+    if (existsSync2(commandsDir)) {
+      let commands = readdirSync(commandsDir).filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+      if (specificCommands?.length) {
+        const requested = new Set(specificCommands.map((c) => c.toLowerCase()));
+        commands = commands.filter((c) => requested.has(c.toLowerCase()));
+      }
+      for (const command of commands) {
+        const src = join2(commandsDir, `${command}.md`);
+        const dest = join2(destinations.commands, `${command}.md`);
+        try {
+          if (existsSync2(dest) && !force) {
+            result.skipped.push(`command:${command}`);
+            log(`Skipped commands/${command}.md (already exists)`);
+            continue;
+          }
+          mkdirSync(dirname2(dest), { recursive: true });
+          cpSync(src, dest);
+          result.installed.push(`command:${command}`);
+          log(`Installed commands/${command}.md`);
+        } catch (err) {
+          result.errors.push(`command:${command}: ${err}`);
+        }
+      }
+    }
+  }
+  return result;
+}
+function checkComponentStatus(componentPath, name) {
+  const installed = existsSync2(componentPath);
+  if (!installed) {
+    return { name, installed: false };
+  }
+  try {
+    const stats = statSync(componentPath);
+    return {
+      name,
+      installed: true,
+      path: componentPath,
+      modifiedAt: stats.mtime
+    };
+  } catch {
+    return { name, installed: true, path: componentPath };
+  }
+}
+function getTargetStatus(target, isGlobal, projectRoot) {
+  const available = target === "opencode" ? isOpenCodeInstalled() : isClaudeInstalled();
+  const destinations = getDestinationPaths(isGlobal, projectRoot, target);
+  const skillStatuses = SKILLS.map(
+    (s) => checkComponentStatus(join2(destinations.skills, s.name), s.name)
+  );
+  const agentStatuses = AGENTS.map(
+    (a) => checkComponentStatus(join2(destinations.agents, `${a.name}.md`), a.name)
+  );
+  const commandStatuses = COMMANDS.map(
+    (c) => checkComponentStatus(join2(destinations.commands, `${c.name}.md`), c.name)
+  );
+  return {
+    target,
+    available,
+    configDir: target === "opencode" ? isGlobal ? destinations.skills.replace(/[/\\]skills$/, "") : destinations.skills.replace(/[/\\]skills$/, "") : isGlobal ? destinations.skills.replace(/[/\\]skills$/, "") : destinations.skills.replace(/[/\\]skills$/, ""),
+    skills: {
+      installed: skillStatuses.filter((s) => s.installed).length,
+      total: SKILLS.length,
+      components: skillStatuses
+    },
+    agents: {
+      installed: agentStatuses.filter((a) => a.installed).length,
+      total: AGENTS.length,
+      components: agentStatuses
+    },
+    commands: {
+      installed: commandStatuses.filter((c) => c.installed).length,
+      total: COMMANDS.length,
+      components: commandStatuses
+    }
+  };
+}
+async function getStatus(options = {}) {
+  const { global: isGlobal = true, projectRoot = process.cwd() } = options;
+  return {
+    opencode: getTargetStatus("opencode", isGlobal, projectRoot),
+    claude: getTargetStatus("claude", isGlobal, projectRoot)
+  };
+}
+async function uninstall(options = {}) {
+  const {
+    global: isGlobal = false,
+    projectRoot = process.cwd(),
+    target = "opencode",
+    categories = ["skills", "agents", "commands"],
+    verbose = false
+  } = options;
+  const result = {
+    removed: [],
+    notFound: [],
+    errors: []
+  };
+  const destinations = getDestinationPaths(isGlobal, projectRoot, target);
+  const log = (msg) => {
+    if (verbose) console.log(msg);
+  };
+  const ourSkills = SKILLS.map((s) => s.name);
+  const ourAgents = AGENTS.map((a) => a.name);
+  const ourCommands = COMMANDS.map((c) => c.name);
+  if (categories.includes("skills")) {
+    for (const skill of ourSkills) {
+      const dest = join2(destinations.skills, skill);
+      try {
+        if (!existsSync2(dest)) {
+          result.notFound.push(`skill:${skill}`);
+          log(`Not found: skill/${skill}`);
+          continue;
+        }
+        rmSync(dest, { recursive: true, force: true });
+        result.removed.push(`skill:${skill}`);
+        log(`Removed skill/${skill}`);
+      } catch (err) {
+        result.errors.push(`skill:${skill}: ${err}`);
+      }
+    }
+  }
+  if (categories.includes("agents")) {
+    for (const agent of ourAgents) {
+      const dest = join2(destinations.agents, `${agent}.md`);
+      try {
+        if (!existsSync2(dest)) {
+          result.notFound.push(`agent:${agent}`);
+          log(`Not found: agents/${agent}.md`);
+          continue;
+        }
+        rmSync(dest, { force: true });
+        result.removed.push(`agent:${agent}`);
+        log(`Removed agents/${agent}.md`);
+      } catch (err) {
+        result.errors.push(`agent:${agent}: ${err}`);
+      }
+    }
+  }
+  if (categories.includes("commands")) {
+    for (const command of ourCommands) {
+      const dest = join2(destinations.commands, `${command}.md`);
+      try {
+        if (!existsSync2(dest)) {
+          result.notFound.push(`command:${command}`);
+          log(`Not found: commands/${command}.md`);
+          continue;
+        }
+        rmSync(dest, { force: true });
+        result.removed.push(`command:${command}`);
+        log(`Removed commands/${command}.md`);
+      } catch (err) {
+        result.errors.push(`command:${command}: ${err}`);
+      }
+    }
+  }
+  return result;
+}
+
 // src/cli.ts
+async function prompt(question) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase());
+    });
+  });
+}
+async function promptYesNo(question, defaultYes = true) {
+  const suffix = defaultYes ? "[Y/n]" : "[y/N]";
+  const answer = await prompt(`${question} ${suffix} `);
+  if (answer === "") return defaultYes;
+  return answer === "y" || answer === "yes";
+}
 var HELP = `
 ux-toolkit - AI-powered UI/UX review toolkit
 
@@ -381,20 +630,67 @@ USAGE:
 
 COMMANDS:
   install     Install skills, agents, and commands
+  uninstall   Remove installed skills, agents, and commands
+  upgrade     Reinstall all components (alias for install --force)
+  status      Show what's installed vs available
+  doctor      Diagnose installation issues
   list        List available components
+  info        Show platform and config information
+
+TARGET (choose one):
+  --opencode        Target OpenCode (default) - ~/.config/opencode
+  --claude          Target Claude Code - ~/.claude
+
+SCOPE:
+  --global, -g      Install to global config (default)
+  --project, -p     Install to project config (.opencode/ or .claude/)
 
 OPTIONS:
-  --global, -g      Install to global config (~/.config/opencode)
-  --project, -p     Install to project config (.opencode/)
+  --all, -a         Install to all detected platforms (no prompt)
   --force, -f       Overwrite existing files
   --verbose, -v     Verbose output
+  --only            Install specific categories (skills,agents,commands)
+  --skill           Install specific skill(s) by name (can repeat)
+  --agent           Install specific agent(s) by name (can repeat)
+  --command         Install specific command(s) by name (can repeat)
   --help, -h        Show this help
 
+ENVIRONMENT:
+  UX_TOOLKIT_CONFIG_DIR   Override config directory
+  OPENCODE_CONFIG_DIR     OpenCode config directory override
+  CLAUDE_CONFIG_DIR       Claude Code config directory override
+  XDG_CONFIG_HOME         Linux XDG config home (respected)
+
 EXAMPLES:
+  # OpenCode (default)
   npx ux-toolkit install --global
-  npx ux-toolkit install --project --force
+  npx ux-toolkit install --opencode --global
+  
+  # Claude Code
+  npx ux-toolkit install --claude --global
+  npx ux-toolkit uninstall --claude --global
+  
+  # Both platforms
+  npx ux-toolkit install --opencode --global && npx ux-toolkit install --claude --global
+  
+  # Project-level
+  npx ux-toolkit install --project
+  npx ux-toolkit install --claude --project
+  
+  # Selective
+  npx ux-toolkit install --global --only=skills,agents
+  
+  # Other commands
+  npx ux-toolkit info
   npx ux-toolkit list
 `;
+function parseCategories(only) {
+  if (!only) return void 0;
+  const valid = ["skills", "agents", "commands"];
+  const parsed = only.split(",").map((s) => s.trim().toLowerCase());
+  const filtered = parsed.filter((c) => valid.includes(c));
+  return filtered.length > 0 ? filtered : void 0;
+}
 async function main() {
   const { values, positionals } = parseArgs({
     allowPositionals: true,
@@ -403,7 +699,14 @@ async function main() {
       project: { type: "boolean", short: "p", default: false },
       force: { type: "boolean", short: "f", default: false },
       verbose: { type: "boolean", short: "v", default: false },
-      help: { type: "boolean", short: "h", default: false }
+      help: { type: "boolean", short: "h", default: false },
+      only: { type: "string" },
+      opencode: { type: "boolean", default: false },
+      claude: { type: "boolean", default: false },
+      all: { type: "boolean", short: "a", default: false },
+      skill: { type: "string", multiple: true },
+      agent: { type: "string", multiple: true },
+      command: { type: "string", multiple: true }
     }
   });
   if (values.help || positionals.length === 0) {
@@ -411,25 +714,103 @@ async function main() {
     process.exit(0);
   }
   const command = positionals[0];
+  const isGlobal = values.global || !values.project;
+  const categories = parseCategories(values.only);
+  async function runInstall(target, showHeader = true) {
+    const targetName = target === "claude" ? "Claude Code" : "OpenCode";
+    if (showHeader) {
+      console.log(`
+Installing UX Toolkit to ${targetName} ${isGlobal ? "globally" : "in project"}...
+`);
+    }
+    const result = await install({
+      global: isGlobal,
+      target,
+      force: values.force,
+      verbose: values.verbose,
+      categories,
+      skills: values.skill,
+      agents: values.agent,
+      commands: values.command
+    });
+    if (result.installed.length > 0) {
+      console.log(`Installed ${result.installed.length} components:`);
+      result.installed.forEach((item) => console.log(`  + ${item}`));
+    }
+    if (result.skipped.length > 0) {
+      console.log(`
+Skipped ${result.skipped.length} (already exist, use --force to overwrite):`);
+      result.skipped.forEach((item) => console.log(`  - ${item}`));
+    }
+    if (result.errors.length > 0) {
+      console.error(`
+Errors:`);
+      result.errors.forEach((err) => console.error(`  ! ${err}`));
+      return false;
+    }
+    return true;
+  }
   switch (command) {
     case "install": {
-      const isGlobal = values.global || !values.project;
+      const opencodeInstalled = isOpenCodeInstalled();
+      const claudeInstalled = isClaudeInstalled();
+      const explicitTarget = values.opencode || values.claude;
+      let targets = [];
+      if (values.all) {
+        if (opencodeInstalled) targets.push("opencode");
+        if (claudeInstalled) targets.push("claude");
+        if (targets.length === 0) {
+          console.warn("\n\u26A0\uFE0F  No platforms detected. Installing to OpenCode by default.\n");
+          targets = ["opencode"];
+        }
+      } else if (explicitTarget) {
+        targets = [values.claude ? "claude" : "opencode"];
+      } else if (isGlobal && opencodeInstalled && claudeInstalled) {
+        console.log("\n\u{1F50D} Detected both OpenCode and Claude Code installations.\n");
+        const installBoth = await promptYesNo("Install to both platforms?", true);
+        if (installBoth) {
+          targets = ["opencode", "claude"];
+        } else {
+          const choice = await prompt("Which platform? (opencode/claude) [opencode]: ");
+          targets = [choice === "claude" ? "claude" : "opencode"];
+        }
+      } else if (isGlobal && claudeInstalled && !opencodeInstalled) {
+        console.log("\n\u{1F50D} Detected Claude Code (OpenCode not found).\n");
+        targets = ["claude"];
+      } else {
+        targets = ["opencode"];
+      }
+      let hasErrors = false;
+      for (let i = 0; i < targets.length; i++) {
+        const target = targets[i];
+        if (i > 0) console.log("");
+        const success = await runInstall(target);
+        if (!success) hasErrors = true;
+      }
+      console.log("\nDone!");
+      if (hasErrors) process.exit(1);
+      break;
+    }
+    case "uninstall": {
+      const target = values.claude ? "claude" : "opencode";
+      const targetName = target === "claude" ? "Claude Code" : "OpenCode";
       console.log(`
-Installing UX Toolkit ${isGlobal ? "globally" : "to project"}...
+Uninstalling UX Toolkit from ${targetName} ${isGlobal ? "globally" : "in project"}...
 `);
-      const result = await install({
+      const result = await uninstall({
         global: isGlobal,
-        force: values.force,
-        verbose: values.verbose
+        target,
+        verbose: values.verbose,
+        categories
       });
-      if (result.installed.length > 0) {
-        console.log(`Installed ${result.installed.length} components:`);
-        result.installed.forEach((item) => console.log(`  + ${item}`));
+      if (result.removed.length > 0) {
+        console.log(`Removed ${result.removed.length} components:`);
+        result.removed.forEach((item) => console.log(`  - ${item}`));
       }
-      if (result.skipped.length > 0) {
+      if (result.notFound.length > 0 && values.verbose) {
         console.log(`
-Skipped ${result.skipped.length} (already exist, use --force to overwrite):`);
-        result.skipped.forEach((item) => console.log(`  - ${item}`));
+Not found (${result.notFound.length}):`);
+        result.notFound.forEach((item) => console.log(`  ? ${item}`));
       }
       if (result.errors.length > 0) {
         console.error(`
@@ -440,6 +821,248 @@ Errors:`);
       console.log("\nDone!");
       break;
     }
+    case "upgrade": {
+      const target = values.claude ? "claude" : "opencode";
+      const targetName = target === "claude" ? "Claude Code" : "OpenCode";
+      console.log(`
+Upgrading UX Toolkit in ${targetName} ${isGlobal ? "globally" : "in project"}...
+`);
+      const result = await install({
+        global: isGlobal,
+        target,
+        force: true,
+        // Always force for upgrade
+        verbose: values.verbose,
+        categories
+      });
+      if (result.installed.length > 0) {
+        console.log(`Upgraded ${result.installed.length} components:`);
+        result.installed.forEach((item) => console.log(`  \u2191 ${item}`));
+      }
+      if (result.errors.length > 0) {
+        console.error(`
+Errors:`);
+        result.errors.forEach((err) => console.error(`  ! ${err}`));
+        process.exit(1);
+      }
+      console.log("\nDone!");
+      break;
+    }
+    case "status": {
+      const status = await getStatus({ global: isGlobal });
+      console.log("\nUX Toolkit - Installation Status\n");
+      const formatStatus = (installed, total) => {
+        if (installed === 0) return `\u2717 0/${total}`;
+        if (installed === total) return `\u2713 ${installed}/${total}`;
+        return `\u25D0 ${installed}/${total}`;
+      };
+      const getMissing = (components) => {
+        return components.filter((c) => !c.installed).map((c) => c.name);
+      };
+      console.log("  OpenCode:");
+      if (!status.opencode.available) {
+        console.log("    Not installed (no config directory found)");
+      } else {
+        console.log(`    Skills:   ${formatStatus(status.opencode.skills.installed, status.opencode.skills.total)}`);
+        console.log(`    Agents:   ${formatStatus(status.opencode.agents.installed, status.opencode.agents.total)}`);
+        console.log(`    Commands: ${formatStatus(status.opencode.commands.installed, status.opencode.commands.total)}`);
+        if (values.verbose) {
+          const missingSkills = getMissing(status.opencode.skills.components);
+          const missingAgents = getMissing(status.opencode.agents.components);
+          const missingCommands = getMissing(status.opencode.commands.components);
+          if (missingSkills.length > 0) {
+            console.log(`    Missing skills: ${missingSkills.join(", ")}`);
+          }
+          if (missingAgents.length > 0) {
+            console.log(`    Missing agents: ${missingAgents.join(", ")}`);
+          }
+          if (missingCommands.length > 0) {
+            console.log(`    Missing commands: ${missingCommands.join(", ")}`);
+          }
+        }
+      }
+      console.log("\n  Claude Code:");
+      if (!status.claude.available) {
+        console.log("    Not installed (no config directory found)");
+      } else {
+        console.log(`    Skills:   ${formatStatus(status.claude.skills.installed, status.claude.skills.total)}`);
+        console.log(`    Agents:   ${formatStatus(status.claude.agents.installed, status.claude.agents.total)}`);
+        console.log(`    Commands: ${formatStatus(status.claude.commands.installed, status.claude.commands.total)}`);
+        if (values.verbose) {
+          const missingSkills = getMissing(status.claude.skills.components);
+          const missingAgents = getMissing(status.claude.agents.components);
+          const missingCommands = getMissing(status.claude.commands.components);
+          if (missingSkills.length > 0) {
+            console.log(`    Missing skills: ${missingSkills.join(", ")}`);
+          }
+          if (missingAgents.length > 0) {
+            console.log(`    Missing agents: ${missingAgents.join(", ")}`);
+          }
+          if (missingCommands.length > 0) {
+            console.log(`    Missing commands: ${missingCommands.join(", ")}`);
+          }
+        }
+      }
+      const totalOpencode = status.opencode.skills.installed + status.opencode.agents.installed + status.opencode.commands.installed;
+      const totalClaude = status.claude.skills.installed + status.claude.agents.installed + status.claude.commands.installed;
+      const totalAvailable = SKILLS.length + AGENTS.length + COMMANDS.length;
+      console.log("\n  Summary:");
+      if (status.opencode.available && totalOpencode === totalAvailable) {
+        console.log("    OpenCode:    \u2713 Fully installed");
+      } else if (status.opencode.available && totalOpencode > 0) {
+        console.log(`    OpenCode:    \u25D0 Partially installed (${totalOpencode}/${totalAvailable})`);
+      } else if (status.opencode.available) {
+        console.log("    OpenCode:    \u2717 Not installed");
+      }
+      if (status.claude.available && totalClaude === totalAvailable) {
+        console.log("    Claude Code: \u2713 Fully installed");
+      } else if (status.claude.available && totalClaude > 0) {
+        console.log(`    Claude Code: \u25D0 Partially installed (${totalClaude}/${totalAvailable})`);
+      } else if (status.claude.available) {
+        console.log("    Claude Code: \u2717 Not installed");
+      }
+      break;
+    }
+    case "doctor": {
+      console.log("\nUX Toolkit - Diagnostics\n");
+      const issues = [];
+      const warnings = [];
+      const ok = [];
+      const nodeVersion = process.version;
+      const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0], 10);
+      if (majorVersion < 18) {
+        issues.push(`Node.js ${nodeVersion} is below minimum (v18+)`);
+      } else {
+        ok.push(`Node.js ${nodeVersion}`);
+      }
+      const platformInfo = getPlatformInfo();
+      if (platformInfo.opencode.exists) {
+        ok.push(`OpenCode detected at ${platformInfo.opencode.configDir}`);
+        const { existsSync: existsSync3 } = await import("fs");
+        const { join: join3 } = await import("path");
+        const skillsDir = join3(platformInfo.opencode.configDir, "skills");
+        const agentsDir = join3(platformInfo.opencode.configDir, "agents");
+        const commandsDir = join3(platformInfo.opencode.configDir, "commands");
+        if (!existsSync3(skillsDir)) {
+          warnings.push("OpenCode skills directory missing");
+        }
+        if (!existsSync3(agentsDir)) {
+          warnings.push("OpenCode agents directory missing");
+        }
+        if (!existsSync3(commandsDir)) {
+          warnings.push("OpenCode commands directory missing");
+        }
+      } else {
+        warnings.push("OpenCode not detected (config directory not found)");
+      }
+      if (platformInfo.claude.exists) {
+        ok.push(`Claude Code detected at ${platformInfo.claude.configDir}`);
+        const { existsSync: existsSync3 } = await import("fs");
+        const { join: join3 } = await import("path");
+        const skillsDir = join3(platformInfo.claude.configDir, "skills");
+        const agentsDir = join3(platformInfo.claude.configDir, "agents");
+        const commandsDir = join3(platformInfo.claude.configDir, "commands");
+        if (!existsSync3(skillsDir)) {
+          warnings.push("Claude Code skills directory missing");
+        }
+        if (!existsSync3(agentsDir)) {
+          warnings.push("Claude Code agents directory missing");
+        }
+        if (!existsSync3(commandsDir)) {
+          warnings.push("Claude Code commands directory missing");
+        }
+      } else {
+        warnings.push("Claude Code not detected (config directory not found)");
+      }
+      const status = await getStatus({ global: true });
+      const opencodeTotal = status.opencode.skills.installed + status.opencode.agents.installed + status.opencode.commands.installed;
+      const claudeTotal = status.claude.skills.installed + status.claude.agents.installed + status.claude.commands.installed;
+      const totalAvailable = SKILLS.length + AGENTS.length + COMMANDS.length;
+      if (status.opencode.available) {
+        if (opencodeTotal === totalAvailable) {
+          ok.push("OpenCode: All components installed");
+        } else if (opencodeTotal > 0) {
+          warnings.push(`OpenCode: Partial installation (${opencodeTotal}/${totalAvailable})`);
+        } else {
+          warnings.push("OpenCode: No components installed");
+        }
+      }
+      if (status.claude.available) {
+        if (claudeTotal === totalAvailable) {
+          ok.push("Claude Code: All components installed");
+        } else if (claudeTotal > 0) {
+          warnings.push(`Claude Code: Partial installation (${claudeTotal}/${totalAvailable})`);
+        } else {
+          warnings.push("Claude Code: No components installed");
+        }
+      }
+      if (ok.length > 0) {
+        console.log("  \u2713 OK:");
+        ok.forEach((item) => console.log(`    \u2022 ${item}`));
+      }
+      if (warnings.length > 0) {
+        console.log("\n  \u26A0 Warnings:");
+        warnings.forEach((item) => console.log(`    \u2022 ${item}`));
+      }
+      if (issues.length > 0) {
+        console.log("\n  \u2717 Issues:");
+        issues.forEach((item) => console.log(`    \u2022 ${item}`));
+      }
+      console.log("\n  Summary:");
+      if (issues.length === 0 && warnings.length === 0) {
+        console.log("    Everything looks good!");
+      } else if (issues.length === 0) {
+        console.log(`    ${warnings.length} warning(s), no critical issues`);
+      } else {
+        console.log(`    ${issues.length} issue(s), ${warnings.length} warning(s)`);
+      }
+      if (warnings.length > 0 || issues.length > 0) {
+        console.log("\n  Suggestions:");
+        if (!platformInfo.opencode.exists && !platformInfo.claude.exists) {
+          console.log("    \u2022 Install OpenCode or Claude Code first");
+        }
+        if (opencodeTotal < totalAvailable && status.opencode.available) {
+          console.log("    \u2022 Run: npx ux-toolkit install --opencode --global");
+        }
+        if (claudeTotal < totalAvailable && status.claude.available) {
+          console.log("    \u2022 Run: npx ux-toolkit install --claude --global");
+        }
+      }
+      break;
+    }
+    case "info": {
+      const platformInfo = getPlatformInfo();
+      console.log("\nUX Toolkit - Platform Information\n");
+      console.log(`  Platform:       ${platformInfo.platform}`);
+      console.log(`  Node Version:   ${process.version}`);
+      console.log("\n  OpenCode:");
+      console.log(`    Config Dir:   ${platformInfo.opencode.configDir}`);
+      console.log(`    Installed:    ${platformInfo.opencode.exists ? "Yes" : "No"}`);
+      console.log("\n  Claude Code:");
+      console.log(`    Config Dir:   ${platformInfo.claude.configDir}`);
+      console.log(`    Installed:    ${platformInfo.claude.exists ? "Yes" : "No"}`);
+      if (process.env.UX_TOOLKIT_CONFIG_DIR || process.env.OPENCODE_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR || process.env.XDG_CONFIG_HOME) {
+        console.log("\n  Environment Overrides:");
+        if (process.env.UX_TOOLKIT_CONFIG_DIR) {
+          console.log(`    UX_TOOLKIT_CONFIG_DIR: ${process.env.UX_TOOLKIT_CONFIG_DIR}`);
+        }
+        if (process.env.OPENCODE_CONFIG_DIR) {
+          console.log(`    OPENCODE_CONFIG_DIR:   ${process.env.OPENCODE_CONFIG_DIR}`);
+        }
+        if (process.env.CLAUDE_CONFIG_DIR) {
+          console.log(`    CLAUDE_CONFIG_DIR:     ${process.env.CLAUDE_CONFIG_DIR}`);
+        }
+        if (process.env.XDG_CONFIG_HOME) {
+          console.log(`    XDG_CONFIG_HOME:       ${process.env.XDG_CONFIG_HOME}`);
+        }
+      }
+      console.log(`
+  Components:`);
+      console.log(`    Skills:   ${SKILLS.length}`);
+      console.log(`    Agents:   ${AGENTS.length}`);
+      console.log(`    Commands: ${COMMANDS.length}`);
+      break;
+    }
     case "list": {
       console.log("\nSkills:");
       SKILLS.forEach((s) => console.log(`  ${s.name.padEnd(25)} ${s.description}`));