set-prompt 0.2.1 → 0.4.0

package/dist/index.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import chalk8 from "chalk";
 import figlet from "figlet";
 import fs6 from "fs";
-import path6 from "path";
+import path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/commands/install-command.ts
@@ -27,20 +27,28 @@ var ROO_DIR = path.join(os.homedir(), ".roo");
 var ROO_BACKUP_DIR = path.join(ROO_DIR, "SET_PROMPT_BACKUP");
 var OPENCLAW_DIR = path.join(os.homedir(), ".openclaw", "workspace");
 var OPENCLAW_BACKUP_DIR = path.join(OPENCLAW_DIR, "SET_PROMPT_BACKUP");
+var ANTIGRAVITY_DIR = path.join(os.homedir(), ".gemini", "antigravity");
+var ANTIGRAVITY_BACKUP_DIR = path.join(ANTIGRAVITY_DIR, "SET_PROMPT_BACKUP");
+var CODEX_DIR = path.join(os.homedir(), ".codex");
+var CODEX_BACKUP_DIR = path.join(CODEX_DIR, "SET_PROMPT_BACKUP");
+var CURSOR_DIR = path.join(HOME_DIR, "cursor");
+var CURSOR_PLUGIN_DIR = path.join(os.homedir(), ".cursor", "plugins", "local", "set-prompt");
 var PROMPT_DIR_NAMES = ["skills", "commands", "hooks", "agents"];
 var AGENT_PROMPT_DIRS = {
   ["claudecode" /* CLAUDECODE */]: ["skills", "commands", "hooks", "agents"],
   ["roocode" /* ROOCODE */]: ["skills", "commands"],
   ["openclaw" /* OPENCLAW */]: ["skills"],
   ["codex" /* CODEX */]: ["skills", "commands"],
-  ["antigravity" /* ANTIGRAVITY */]: ["skills", "commands"]
+  ["antigravity" /* ANTIGRAVITY */]: ["skills"],
+  ["cursor" /* CURSOR */]: ["skills", "agents", "rules"]
 };
 var ALL_AGENTS = [
   { name: "Claude Code", value: "claudecode" /* CLAUDECODE */ },
   { name: "RooCode", value: "roocode" /* ROOCODE */ },
   { name: "OpenClaw", value: "openclaw" /* OPENCLAW */ },
   { name: "Codex", value: "codex" /* CODEX */ },
-  { name: "Antigravity", value: "antigravity" /* ANTIGRAVITY */ }
+  { name: "Antigravity", value: "antigravity" /* ANTIGRAVITY */ },
+  { name: "Cursor", value: "cursor" /* CURSOR */ }
 ];
 
 // src/_libs/config.ts
@@ -63,10 +71,18 @@ var OpenclawConfigSchema = z.object({
   backup_path: z.string().nullish().optional()
 });
 var CodexConfigSchema = z.object({
-  path: z.string().nullable()
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
 });
 var AntigravityConfigSchema = z.object({
-  path: z.string().nullable()
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
+});
+var CursorConfigSchema = z.object({
+  path: z.string().nullable(),
+  // ~/.set-prompt/cursor (플러그인 파일 구조)
+  plugin_dir: z.string().nullable()
+  // ~/.cursor/plugins/set-prompt (설치 symlink)
 });
 var GlobalConfigSchema = z.object({
   repo_path: z.string(),
@@ -75,7 +91,8 @@ var GlobalConfigSchema = z.object({
   roocode: RoocodeConfigSchema.nullable(),
   openclaw: OpenclawConfigSchema.nullable(),
   codex: CodexConfigSchema.nullish().optional(),
-  antigravity: AntigravityConfigSchema.nullish().optional()
+  antigravity: AntigravityConfigSchema.nullish().optional(),
+  cursor: CursorConfigSchema.nullish().optional()
 });
 
 // src/_libs/config.ts
@@ -88,6 +105,7 @@ var ConfigManager = class {
     this._openclaw = null;
     this._codex = null;
     this._antigravity = null;
+    this._cursor = null;
   }
   get repo_path() {
     return this._repo_path;
@@ -110,6 +128,9 @@ var ConfigManager = class {
   get antigravity() {
     return this._antigravity;
   }
+  get cursor() {
+    return this._cursor;
+  }
   set repo_path(v) {
     this._repo_path = v;
   }
@@ -131,10 +152,13 @@ var ConfigManager = class {
   set antigravity(v) {
     this._antigravity = v;
   }
+  set cursor(v) {
+    this._cursor = v;
+  }
   init() {
     this._loadFromDisk();
     if (this._repo_path != null) {
-      console.log(chalk.dim(`Config loaded from ${CONFIG_PATH}`));
+      console.log(chalk.green(`Config loaded`) + chalk.dim(` from ${CONFIG_PATH}`));
     }
   }
   save() {
@@ -151,7 +175,8 @@ var ConfigManager = class {
         roocode: this._roocode,
         openclaw: this._openclaw,
         codex: this._codex,
-        antigravity: this._antigravity
+        antigravity: this._antigravity,
+        cursor: this._cursor
       }, null, 4);
       fs.writeFileSync(CONFIG_PATH, configStr, "utf-8");
       console.log(chalk.green(`Config saved`) + chalk.dim(` \u2192 ${CONFIG_PATH}`));
@@ -185,6 +210,9 @@ var ConfigManager = class {
   isAntigravityEnabled() {
     return this._antigravity != null;
   }
+  isCursorEnabled() {
+    return this._cursor != null;
+  }
   _assign(config) {
     this._repo_path = config.repo_path;
     this._remote_url = config.remote_url;
@@ -193,6 +221,7 @@ var ConfigManager = class {
     this._openclaw = config.openclaw;
     this._codex = config.codex ?? null;
     this._antigravity = config.antigravity ?? null;
+    this._cursor = config.cursor ?? null;
   }
   _loadFromDisk() {
     if (fs.existsSync(CONFIG_PATH) === false) {
@@ -282,15 +311,20 @@ customInstructions: "Additional behavior guidelines..."
 
 # OpenClaw
 homepage: "https://github.com/you/my-skill"
-metadata: {"openclaw":{"emoji":"\u{1F527}","os":["darwin","linux"]}}
+user-invocable: true
+disable-model-invocation: false
+metadata: {"os":["darwin","linux"],"requires":{"bins":["git"],"env":["MY_API_KEY"]}}
+
+# Antigravity
+name: my-skill
+description: "What this skill does and when to use it"
 ---
 \`\`\`
 
 | Field | Required | Platform | Description |
 |-------|----------|----------|-------------|
-| \`name\` | Yes | All | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). RooCode: emoji allowed. |
+| \`name\` | Yes | All | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). RooCode: emoji allowed. Antigravity: optional, defaults to folder name. |
 | \`description\` | Yes | All | What it does and when to use it. Claude uses this to decide auto-loading. |
-| \`disable-model-invocation\` | No | CC, OpenClaw | \`true\` = prevent auto-loading, manual \`/name\` only. (default: \`false\`) |
 | \`allowed-tools\` | No | Claude Code | Tools Claude can use without asking. e.g. \`Read\` \`Write\` \`Edit\` \`Bash\` \`Grep\` \`Glob\` |
 | \`model\` | No | Claude Code | Model to use when active. \`sonnet\` or \`haiku\` |
 | \`context\` | No | Claude Code | \`fork\` = run in a forked subagent context |
@@ -301,15 +335,14 @@ metadata: {"openclaw":{"emoji":"\u{1F527}","os":["darwin","linux"]}}
 | \`groups\` | Yes | RooCode | Tool permissions: \`read\` \`edit\` \`command\` \`mcp\` \`browser\` |
 | \`whenToUse\` | No | RooCode | Guide for auto mode selection |
 | \`customInstructions\` | No | RooCode | Additional behavior guidelines |
-| \`homepage\` | No | OpenClaw | Website URL shown in the Skills UI |
-| \`metadata\` | No | OpenClaw | Single-line JSON for platform gating. e.g. \`os\`, \`requires.bins\`, \`requires.env\` |
-
-RooCode file-restricted edit example:
-\`\`\`yaml
-groups:
-  - read
-  - [edit, {fileRegex: '\\.(md|ts)$', description: "Markdown and TS only"}]
-\`\`\`
+| \`groups\` (restricted) | No | RooCode | Restrict edit to file patterns: \`[edit, {fileRegex: '\\.(md|ts)$', description: "..."}]\` |
+| \`metadata\` | No | OpenClaw | Single-line JSON for platform gating: \`os\` (platform filter), \`requires.bins\` (required binaries), \`requires.env\` (required env vars) |
+| \`homepage\` | No | OpenClaw | URL shown as "Website" in the macOS Skills UI. Also settable via \`metadata.openclaw.homepage\`. |
+| \`user-invocable\` | No | OpenClaw | \`false\` = hidden from \`/\` menu. (default: \`true\`) |
+| \`disable-model-invocation\` | No | CC, OpenClaw | \`true\` = skill excluded from model prompt, still available via user invocation. (default: \`false\`) |
+| \`command-dispatch\` | No | OpenClaw | \`"tool"\` = bypass model, dispatch directly to a tool |
+| \`command-tool\` | No | OpenClaw | Tool to invoke when \`command-dispatch: "tool"\` |
+| \`command-arg-mode\` | No | OpenClaw | How arguments are forwarded to the tool. (default: \`"raw"\`) |
 
 ---
 
@@ -360,9 +393,6 @@ command-tool: "Bash"
 | \`context\` | No | Claude Code | \`fork\` = run in a forked subagent context |
 | \`agent\` | No | Claude Code | Subagent type when \`context: fork\`. e.g. \`general-purpose\` \`Explore\` \`Plan\` |
 | \`hooks\` | No | Claude Code | Lifecycle hooks for pre/post processing. |
-| \`command-dispatch\` | No | OpenClaw | \`"tool"\` = bypass model, dispatch directly to a tool |
-| \`command-tool\` | No | OpenClaw | Tool to invoke when \`command-dispatch: "tool"\` |
-| \`command-arg-mode\` | No | OpenClaw | How arguments are forwarded to the tool. (default: \`"raw"\`) |
 
 ---
 
@@ -527,18 +557,23 @@ var scaffoldCommand = async (localPath, options = {}) => {
       }
       const created = [];
       const guideMdPath = path2.join(targetPath, "SET_PROMPT_GUIDE.md");
-      if (options.force === true || fs2.existsSync(guideMdPath) === false) {
-        fs2.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
-        created.push("  SET_PROMPT_GUIDE.md");
-      }
+      fs2.writeFileSync(guideMdPath, SET_PROMPT_GUIDE, { encoding: "utf-8", flag: "w" });
+      created.push("  SET_PROMPT_GUIDE.md");
       for (const dirName of PROMPT_DIR_NAMES) {
         const dirPath = path2.join(targetPath, dirName);
         if (fs2.existsSync(dirPath)) {
           console.warn(chalk2.yellow(`Directory already exists: '${dirName}' (skipping)`));
-          continue;
+        } else {
+          fs2.mkdirSync(dirPath, { recursive: true });
+          created.push(`  ${dirName}/`);
+        }
+        const gitkeepPath = path2.join(dirPath, ".gitkeep");
+        if (!fs2.existsSync(gitkeepPath)) {
+          fs2.writeFileSync(gitkeepPath, "", { encoding: "utf-8" });
+          if (!created.includes(`  ${dirName}/`)) {
+            created.push(`  ${dirName}/.gitkeep`);
+          }
         }
-        fs2.mkdirSync(dirPath, { recursive: true });
-        created.push(`  ${dirName}/`);
       }
       if (created.length > 0) {
         console.log(chalk2.green("Created:"));
@@ -554,21 +589,23 @@ var scaffoldCommand = async (localPath, options = {}) => {
 
 // src/commands/install-command.ts
 var cloneRepo = async (remoteUrl) => {
-  const proceed = await confirm2({
-    message: `Clone and register "${remoteUrl}"?`,
-    default: true
-  });
-  if (proceed == false) {
-    console.log(chalk3.yellow("Cancelled."));
-    return false;
-  }
   const localPath = path3.join(HOME_DIR, "repo");
+  let backupPath = null;
   if (fs3.existsSync(localPath) == true) {
-    console.warn(chalk3.yellow(`Existing repo found. Backing up before proceeding.`));
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = path3.join(HOME_DIR, `repo.bak.${timestamp}`);
-    fs3.renameSync(localPath, backupPath);
-    console.log(chalk3.dim(`  Backed up to: ${backupPath}`));
+    backupPath = path3.join(HOME_DIR, `repo.bak.${timestamp}`);
+    try {
+      fs3.renameSync(localPath, backupPath);
+      console.log(chalk3.yellow("  backed up") + chalk3.dim(` existing repo \u2192 ${backupPath}`));
+    } catch (ex) {
+      if (ex.code === "EPERM") {
+        console.error(chalk3.red("\u274C Cannot rename existing repo \u2014 it may be open in another process."));
+        console.log(chalk3.dim(`   Close any editors or terminals using: ${localPath}`));
+      } else {
+        console.error(chalk3.red(`\u274C Failed to backup existing repo: ${ex.message}`));
+      }
+      return false;
+    }
   }
   fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
   console.log(`Cloning ${remoteUrl}...`);
@@ -578,6 +615,10 @@ var cloneRepo = async (remoteUrl) => {
     process.exit(1);
   }
   console.log("\u2705 Cloned successfully.");
+  if (backupPath != null) {
+    fs3.rmSync(backupPath, { recursive: true, force: true });
+    console.log(chalk3.red("  removed") + chalk3.dim(` backup \u2192 ${backupPath}`));
+  }
   await scaffoldCommand(localPath, { force: true });
   configManager.repo_path = localPath;
   configManager.remote_url = remoteUrl;
@@ -594,6 +635,26 @@ var installCommand = async (target) => {
       console.log(chalk3.dim("   Example: set-prompt install https://github.com/you/my-prompts"));
       process.exit(1);
     }
+    const normalizeUrl = (url) => url.replace(/\.git$/, "").toLowerCase();
+    if (configManager.repo_path != null) {
+      if (normalizeUrl(configManager.remote_url ?? "") === normalizeUrl(target)) {
+        console.error(chalk3.red(`\u274C Already installed from the same URL: ${target}`));
+        console.log(chalk3.dim("   Use `set-prompt update` to pull the latest changes."));
+        return false;
+      }
+      console.warn(chalk3.yellow(`\u26A0 Switching repo: ${configManager.remote_url} \u2192 ${target}`));
+      const proceed = await confirm2({ message: "Replace existing installation?", default: false });
+      if (!proceed) {
+        console.log(chalk3.yellow("Cancelled."));
+        return false;
+      }
+    } else {
+      const proceed = await confirm2({ message: `Clone and register "${target}"?`, default: true });
+      if (!proceed) {
+        console.log(chalk3.yellow("Cancelled."));
+        return false;
+      }
+    }
     return await cloneRepo(target);
   } catch (ex) {
     console.error(chalk3.red(`Unexpected error: ${ex.message}`), ex);
@@ -606,7 +667,7 @@ import path4 from "path";
 import fs4 from "fs";
 import os2 from "os";
 import chalk4 from "chalk";
-import { checkbox } from "@inquirer/prompts";
+import { confirm as confirm3, checkbox } from "@inquirer/prompts";
 import { pathExists } from "fs-extra";
 var resolveRepoPath = () => {
   if (configManager.repo_path == null) {
@@ -616,7 +677,8 @@ var resolveRepoPath = () => {
   }
   return configManager.repo_path;
 };
-var PLUGIN_NAME = "set-prompt";
+var MARKET_NAME = "set-prompt";
+var PLUGIN_NAME = "sppt";
 var linkClaudeCode = async () => {
   const repoPath = resolveRepoPath();
   if (repoPath == null) {
@@ -628,7 +690,7 @@ var linkClaudeCode = async () => {
       const marketplaceMetaDir = path4.join(CLAUDE_CODE_DIR, ".claude-plugin");
       fs4.mkdirSync(marketplaceMetaDir, { recursive: true });
       const marketplaceJson = {
-        name: PLUGIN_NAME,
+        name: MARKET_NAME,
         owner: { name: os2.userInfo().username },
         metadata: { description: "Managed by set-prompt", version: "1.0.0" },
         plugins: [{ name: PLUGIN_NAME, source: `./plugins/${PLUGIN_NAME}`, description: "Managed by set-prompt" }]
@@ -705,11 +767,11 @@ var linkClaudeCode = async () => {
       }
       settings.extraKnownMarketplaces = {
         ...settings.extraKnownMarketplaces,
-        [PLUGIN_NAME]: { source: { source: "directory", path: CLAUDE_CODE_DIR } }
+        [MARKET_NAME]: { source: { source: "directory", path: CLAUDE_CODE_DIR } }
       };
       settings.enabledPlugins = {
         ...settings.enabledPlugins,
-        [`${PLUGIN_NAME}@${PLUGIN_NAME}`]: true
+        [`${PLUGIN_NAME}@${MARKET_NAME}`]: true
       };
       let backupPath = null;
       if (fs4.existsSync(claudeSettingsPath)) {
@@ -752,6 +814,38 @@ var linkClaudeCode = async () => {
       return false;
     }
   };
+  const patchInstalledPlugins = () => {
+    const installPath = path4.join(CLAUDE_CODE_DIR, "plugins", PLUGIN_NAME);
+    const installedPluginsPath = path4.join(os2.homedir(), ".claude", "plugins", "installed_plugins.json");
+    const pluginKey = `${PLUGIN_NAME}@${MARKET_NAME}`;
+    try {
+      let data = { version: 2, plugins: {} };
+      if (fs4.existsSync(installedPluginsPath)) {
+        try {
+          data = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+        } catch {
+        }
+      }
+      if (data.plugins == null) {
+        data.plugins = {};
+      }
+      data.plugins[pluginKey] = [
+        {
+          scope: "user",
+          installPath,
+          version: "1.0.0",
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      ];
+      fs4.mkdirSync(path4.dirname(installedPluginsPath), { recursive: true });
+      fs4.writeFileSync(installedPluginsPath, JSON.stringify(data, null, 2), "utf-8");
+      console.log(`\u2705 Patched installed_plugins.json \u2192 installPath points to source.`);
+      console.log(chalk4.dim(`   ${installPath}`));
+    } catch (ex) {
+      console.warn(chalk4.yellow(`  \u26A0 Could not patch installed_plugins.json: ${ex.message}`));
+    }
+  };
   console.log(chalk4.green(`
 Setting up Claude Code plugin...`));
   console.log(chalk4.dim(CLAUDE_CODE_DIR));
@@ -763,6 +857,7 @@ Setting up Claude Code plugin...`));
   if (settingsOk === false) {
     return;
   }
+  patchInstalledPlugins();
   configManager.claude_code = { path: CLAUDE_CODE_DIR };
   configManager.save();
 };
@@ -781,19 +876,30 @@ Setting up RooCode integration...`));
       const dirsToBackup = [];
       for (const dir of roocodeDirs) {
         const target = path4.join(ROO_DIR, dir);
-        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
+        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false && fs4.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
+      console.log(chalk4.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk4.dim(`    - ${path4.join(ROO_DIR, dir)}`));
+      }
+      console.log(chalk4.yellow(`  They will be backed up to: `) + chalk4.dim(ROO_BACKUP_DIR));
+      const ok = await confirm3({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk4.yellow("Skipped RooCode linking."));
+        return false;
+      }
       fs4.mkdirSync(ROO_BACKUP_DIR, { recursive: true });
       for (const dir of dirsToBackup) {
         const src = path4.join(ROO_DIR, dir);
         const dest = path4.join(ROO_BACKUP_DIR, dir);
         fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  backed up: ${dir}/ \u2192 ${dest}`));
+        console.log(chalk4.yellow("  backed up") + chalk4.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
@@ -854,19 +960,30 @@ Setting up OpenClaw integration...`));
       const dirsToBackup = [];
       for (const dir of openclawDirs) {
         const target = path4.join(OPENCLAW_DIR, dir);
-        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
+        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false && fs4.readdirSync(target).length > 0) {
           dirsToBackup.push(dir);
         }
       }
       if (dirsToBackup.length === 0) {
         return true;
       }
+      console.log(chalk4.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk4.dim(`    - ${path4.join(OPENCLAW_DIR, dir)}`));
+      }
+      console.log(chalk4.yellow(`  They will be backed up to: `) + chalk4.dim(OPENCLAW_BACKUP_DIR));
+      const ok = await confirm3({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk4.yellow("Skipped OpenClaw linking."));
+        return false;
+      }
       fs4.mkdirSync(OPENCLAW_BACKUP_DIR, { recursive: true });
       for (const dir of dirsToBackup) {
         const src = path4.join(OPENCLAW_DIR, dir);
         const dest = path4.join(OPENCLAW_BACKUP_DIR, dir);
         fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  backed up: ${dir}/ \u2192 ${dest}`));
+        console.log(chalk4.yellow("  backed up") + chalk4.dim(`: ${dir}/ \u2192 ${dest}`));
       }
       return true;
     } catch (ex) {
@@ -912,219 +1029,615 @@ Setting up OpenClaw integration...`));
   configManager.openclaw = { path: OPENCLAW_DIR, backup_path: OPENCLAW_BACKUP_DIR };
   configManager.save();
 };
-var linkCodex = async () => {
-  if (resolveRepoPath() == null) {
-    return;
-  }
-  console.log(chalk4.yellow("Codex integration is not yet implemented."));
-};
 var linkAntigravity = async () => {
-  if (resolveRepoPath() == null) {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
     return;
   }
-  console.log(chalk4.yellow("Antigravity integration is not yet implemented."));
-};
-var linkCommand = async (tool) => {
-  if (tool != null) {
-    const known = ALL_AGENTS.some((a) => a.value === tool);
-    if (known === false) {
-      console.log(chalk4.red(`Unknown vendor: ${tool}`));
-      process.exit(1);
+  console.log(chalk4.green(`
+Setting up Antigravity integration...`));
+  console.log(chalk4.dim(ANTIGRAVITY_DIR));
+  const antigravityDirs = AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */];
+  const backupExistingAntigravityFiles = async () => {
+    try {
+      fs4.mkdirSync(ANTIGRAVITY_DIR, { recursive: true });
+      const dirsToBackup = [];
+      for (const dir of antigravityDirs) {
+        const target = path4.join(ANTIGRAVITY_DIR, dir);
+        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false && fs4.readdirSync(target).length > 0) {
+          dirsToBackup.push(dir);
+        }
+      }
+      if (dirsToBackup.length === 0) {
+        return true;
+      }
+      console.log(chalk4.yellow(`
+  \u26A0 The following existing directories will be replaced by symlinks:`));
+      for (const dir of dirsToBackup) {
+        console.log(chalk4.dim(`    - ${path4.join(ANTIGRAVITY_DIR, dir)}`));
+      }
+      console.log(chalk4.yellow(`  They will be backed up to: `) + chalk4.dim(ANTIGRAVITY_BACKUP_DIR));
+      const ok = await confirm3({ message: "Back up existing directories?", default: true });
+      if (!ok) {
+        console.log(chalk4.yellow("Skipped Antigravity linking."));
+        return false;
+      }
+      fs4.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
+      for (const dir of antigravityDirs) {
+        const src = path4.join(ANTIGRAVITY_DIR, dir);
+        const dest = path4.join(ANTIGRAVITY_BACKUP_DIR, dir);
+        fs4.renameSync(src, dest);
+        console.log(chalk4.yellow("  backed up") + chalk4.dim(`: ${dir}/ \u2192 ${dest}`));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      return false;
     }
-    if (tool === "claudecode" /* CLAUDECODE */) {
-      await linkClaudeCode();
-    } else if (tool === "roocode" /* ROOCODE */) {
-      await linkRooCode();
-    } else if (tool === "openclaw" /* OPENCLAW */) {
-      await linkOpenclaw();
-    } else if (tool === "codex" /* CODEX */) {
-      await linkCodex();
-    } else if (tool === "antigravity" /* ANTIGRAVITY */) {
-      await linkAntigravity();
+  };
+  const setAntigravityAssets = async () => {
+    try {
+      const linked = [];
+      for (const dir of antigravityDirs) {
+        const src = path4.join(repoPath, dir);
+        const dest = path4.join(ANTIGRAVITY_DIR, dir);
+        if (await pathExists(src) === false) {
+          continue;
+        }
+        if (fs4.existsSync(dest)) {
+          fs4.rmSync(dest, { recursive: true, force: true });
+        }
+        const symlinkType = process.platform === "win32" ? "junction" : "dir";
+        fs4.symlinkSync(src, dest, symlinkType);
+        linked.push({ dir, src });
+      }
+      for (const { dir, src } of linked) {
+        const isLast = linked[linked.length - 1].dir === dir;
+        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        console.log(chalk4.dim(`  ${branch} `) + chalk4.bold(`${dir}/`) + chalk4.dim(` \u2192 ${src}`) + chalk4.green(" \u2713"));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk4.red(`\u274C Failed to create symlinks: ${ex.message}`));
+      return false;
     }
+  };
+  const backupOk = await backupExistingAntigravityFiles();
+  if (backupOk === false) {
     return;
   }
-  const selected = await checkbox({
-    message: "Which AI agent do you want to integrate?",
-    choices: ALL_AGENTS.map((a) => {
-      const applied = a.value === "claudecode" /* CLAUDECODE */ ? configManager.isClaudeCodeEnabled() : a.value === "roocode" /* ROOCODE */ ? configManager.isRooCodeEnabled() : a.value === "openclaw" /* OPENCLAW */ ? configManager.isOpenclawEnabled() : a.value === "codex" /* CODEX */ ? configManager.isCodexEnabled() : a.value === "antigravity" /* ANTIGRAVITY */ ? configManager.isAntigravityEnabled() : false;
-      return {
-        name: applied ? `${a.name} ${chalk4.dim("(applied)")}` : a.name,
-        value: a.value,
-        checked: applied
-      };
-    })
-  });
-  for (const a of selected) {
-    if (a === "claudecode" /* CLAUDECODE */) {
-      await linkClaudeCode();
-    } else if (a === "roocode" /* ROOCODE */) {
-      await linkRooCode();
-    } else if (a === "openclaw" /* OPENCLAW */) {
-      await linkOpenclaw();
-    } else if (a === "codex" /* CODEX */) {
-      await linkCodex();
-    } else if (a === "antigravity" /* ANTIGRAVITY */) {
-      await linkAntigravity();
-    }
+  const linkOk = await setAntigravityAssets();
+  if (linkOk === false) {
+    return;
   }
+  configManager.antigravity = { path: ANTIGRAVITY_DIR, backup_path: ANTIGRAVITY_BACKUP_DIR };
+  configManager.save();
 };
-
-// src/commands/uninstall-command.ts
-import fs5 from "fs";
-import path5 from "path";
-import os3 from "os";
-import chalk5 from "chalk";
-import { confirm as confirm4 } from "@inquirer/prompts";
-var PLUGIN_NAME2 = "set-prompt";
-var rollbackClaudeCode = () => {
-  const claudeSettingsPath = path5.join(os3.homedir(), ".claude", "settings.json");
-  if (fs5.existsSync(claudeSettingsPath) === false) {
+var linkCodex = async () => {
+  console.error(chalk4.red("\u274C Codex integration is not available in this version."));
+  return;
+};
+var linkCursor = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
     return;
   }
-  try {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
+  const CURSOR_LOCAL_DIR = "local";
+  const CURSOR_PLUGIN_NAME = "set-prompt";
+  const setCursorAssets = async () => {
     try {
-      fs5.copyFileSync(claudeSettingsPath, backupPath);
+      const marketplaceMetaDir = path4.join(CURSOR_DIR, ".cursor-plugin");
+      fs4.mkdirSync(marketplaceMetaDir, { recursive: true });
+      const marketplaceJson = {
+        name: CURSOR_PLUGIN_NAME,
+        owner: { name: os2.userInfo().username },
+        metadata: { description: "Managed by set-prompt" },
+        plugins: [{ name: CURSOR_PLUGIN_NAME, source: `./plugins/${CURSOR_LOCAL_DIR}/${CURSOR_PLUGIN_NAME}`, description: "Managed by set-prompt" }]
+      };
+      fs4.writeFileSync(
+        path4.join(marketplaceMetaDir, "marketplace.json"),
+        JSON.stringify(marketplaceJson, null, 2),
+        "utf-8"
+      );
+      console.log(chalk4.dim("  \u251C\u2500\u2500 .cursor-plugin/"));
+      console.log(chalk4.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk4.green(" \u2713"));
+      const pluginDir = path4.join(CURSOR_DIR, "plugins", CURSOR_LOCAL_DIR, CURSOR_PLUGIN_NAME);
+      const pluginMetaDir = path4.join(pluginDir, ".cursor-plugin");
+      fs4.mkdirSync(pluginMetaDir, { recursive: true });
+      const cursorDirs = AGENT_PROMPT_DIRS["cursor" /* CURSOR */];
+      const pluginJson = {
+        name: CURSOR_PLUGIN_NAME,
+        displayName: "set-prompt",
+        version: "1.0.0",
+        description: "Managed by set-prompt"
+      };
+      for (const dir of cursorDirs) {
+        pluginJson[dir] = `./${dir}/`;
+      }
+      fs4.writeFileSync(
+        path4.join(pluginMetaDir, "plugin.json"),
+        JSON.stringify(pluginJson, null, 2),
+        "utf-8"
+      );
+      console.log(chalk4.dim("  \u2514\u2500\u2500 plugins/"));
+      console.log(chalk4.dim(`      \u2514\u2500\u2500 ${CURSOR_PLUGIN_NAME}/`));
+      console.log(chalk4.dim("          \u251C\u2500\u2500 .cursor-plugin/"));
+      console.log(chalk4.dim("          \u2502   \u2514\u2500\u2500 plugin.json") + chalk4.green(" \u2713"));
+      const linked = [];
+      for (const dir of cursorDirs) {
+        const src = path4.join(repoPath, dir);
+        const dest = path4.join(pluginDir, dir);
+        if (await pathExists(src) === false) {
+          continue;
+        }
+        if (fs4.existsSync(dest)) {
+          fs4.rmSync(dest, { recursive: true, force: true });
+        }
+        const symlinkType2 = process.platform === "win32" ? "junction" : "dir";
+        fs4.symlinkSync(src, dest, symlinkType2);
+        linked.push({ dir, src });
+      }
+      for (const { dir, src } of linked) {
+        const isLast = linked[linked.length - 1].dir === dir;
+        const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+        console.log(chalk4.dim(`          ${branch} `) + chalk4.bold(`${dir}/`) + chalk4.dim(` \u2192 ${src}`) + chalk4.green(" \u2713"));
+      }
+      fs4.rmSync(CURSOR_PLUGIN_DIR, { recursive: true, force: true });
+      fs4.mkdirSync(path4.dirname(CURSOR_PLUGIN_DIR), { recursive: true });
+      const symlinkType = process.platform === "win32" ? "junction" : "dir";
+      fs4.symlinkSync(pluginDir, CURSOR_PLUGIN_DIR, symlinkType);
+      console.log(chalk4.green(`
+\u2705 Installed to Cursor plugins.`));
+      console.log(chalk4.dim(`   ${CURSOR_PLUGIN_DIR}`));
+      return true;
     } catch (ex) {
-      console.warn(chalk5.yellow(`  \u26A0 Could not create backup: ${ex.message} \u2014 skipping cleanup`));
+      console.error(chalk4.red(`\u274C Failed to build Cursor plugin structure: ${ex.message}`));
+      return false;
+    }
+  };
+  console.log(chalk4.green(`
+Setting up Cursor plugin...`));
+  console.log(chalk4.dim(CURSOR_DIR));
+  const structureOk = await setCursorAssets();
+  if (structureOk === false) {
+    return;
+  }
+  configManager.cursor = { path: CURSOR_DIR, plugin_dir: CURSOR_PLUGIN_DIR };
+  configManager.save();
+};
+var unlinkClaudeCode = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove Claude Code plugin dir (${CLAUDE_CODE_DIR}) and settings entries?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk4.yellow("Cancelled."));
       return;
     }
-    const raw = fs5.readFileSync(claudeSettingsPath, "utf-8");
-    let settings;
+  }
+  console.log(chalk4.red(`
+Removing Claude Code plugin...`));
+  console.log(chalk4.dim(CLAUDE_CODE_DIR));
+  const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
+  if (fs4.existsSync(claudeSettingsPath)) {
     try {
-      const parsed = JSON.parse(raw);
-      if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
-        console.warn(chalk5.yellow("  \u26A0 settings.json has unexpected format \u2014 skipping cleanup"));
-        fs5.unlinkSync(backupPath);
-        return;
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
+      fs4.copyFileSync(claudeSettingsPath, backupPath);
+      const settings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
+      if (settings?.extraKnownMarketplaces?.[MARKET_NAME] !== void 0) {
+        delete settings.extraKnownMarketplaces[MARKET_NAME];
       }
-      settings = parsed;
-    } catch {
-      console.warn(chalk5.yellow("  \u26A0 Failed to parse settings.json \u2014 skipping cleanup"));
-      fs5.unlinkSync(backupPath);
-      return;
-    }
-    if (settings.extraKnownMarketplaces?.[PLUGIN_NAME2] !== void 0) {
-      delete settings.extraKnownMarketplaces[PLUGIN_NAME2];
-    }
-    if (settings.enabledPlugins?.[`${PLUGIN_NAME2}@${PLUGIN_NAME2}`] !== void 0) {
-      delete settings.enabledPlugins[`${PLUGIN_NAME2}@${PLUGIN_NAME2}`];
+      if (settings?.enabledPlugins?.[`${PLUGIN_NAME}@${MARKET_NAME}`] !== void 0) {
+        delete settings.enabledPlugins[`${PLUGIN_NAME}@${MARKET_NAME}`];
+      }
+      try {
+        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
+        fs4.unlinkSync(backupPath);
+        console.log(chalk4.red("  removed") + chalk4.dim(` set-prompt entries from: ${claudeSettingsPath}`));
+      } catch (ex) {
+        fs4.copyFileSync(backupPath, claudeSettingsPath);
+        fs4.unlinkSync(backupPath);
+        console.warn(chalk4.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+      }
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
     }
+  }
+  const claudePluginsDir = path4.join(os2.homedir(), ".claude", "plugins");
+  const installedPluginsPath = path4.join(claudePluginsDir, "installed_plugins.json");
+  if (fs4.existsSync(installedPluginsPath)) {
     try {
-      fs5.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
-    } catch (ex) {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${installedPluginsPath}.bak.${timestamp}`;
+      fs4.copyFileSync(installedPluginsPath, backupPath);
+      const installed = JSON.parse(fs4.readFileSync(installedPluginsPath, "utf-8"));
+      if (installed?.plugins && typeof installed.plugins === "object") {
+        for (const key of Object.keys(installed.plugins)) {
+          if (key.endsWith(`@${MARKET_NAME}`)) {
+            delete installed.plugins[key];
+          }
+        }
+      }
       try {
-        fs5.copyFileSync(backupPath, claudeSettingsPath);
-        fs5.unlinkSync(backupPath);
-        console.warn(chalk5.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
-      } catch {
-        console.error(chalk5.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+        fs4.writeFileSync(installedPluginsPath, JSON.stringify(installed, null, 2), "utf-8");
+        fs4.unlinkSync(backupPath);
+        console.log(chalk4.red("  removed") + chalk4.dim(` set-prompt entries from: ${installedPluginsPath}`));
+      } catch (ex) {
+        fs4.copyFileSync(backupPath, installedPluginsPath);
+        fs4.unlinkSync(backupPath);
+        console.warn(chalk4.yellow("  \u26A0 Write failed \u2014 rolled back installed_plugins.json."));
       }
-      throw ex;
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to clean up installed_plugins.json: ${ex.message}`));
     }
+  }
+  const knownMarketplacesPath = path4.join(claudePluginsDir, "known_marketplaces.json");
+  if (fs4.existsSync(knownMarketplacesPath)) {
     try {
-      fs5.unlinkSync(backupPath);
-    } catch {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${knownMarketplacesPath}.bak.${timestamp}`;
+      fs4.copyFileSync(knownMarketplacesPath, backupPath);
+      const marketplaces = JSON.parse(fs4.readFileSync(knownMarketplacesPath, "utf-8"));
+      if (marketplaces?.[MARKET_NAME] !== void 0) {
+        delete marketplaces[MARKET_NAME];
+      }
+      try {
+        fs4.writeFileSync(knownMarketplacesPath, JSON.stringify(marketplaces, null, 2), "utf-8");
+        fs4.unlinkSync(backupPath);
+        console.log(chalk4.red("  removed") + chalk4.dim(` set-prompt entry from: ${knownMarketplacesPath}`));
+      } catch (ex) {
+        fs4.copyFileSync(backupPath, knownMarketplacesPath);
+        fs4.unlinkSync(backupPath);
+        console.warn(chalk4.yellow("  \u26A0 Write failed \u2014 rolled back known_marketplaces.json."));
+      }
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to clean up known_marketplaces.json: ${ex.message}`));
     }
-    console.log(chalk5.dim(`  removed set-prompt entries from: ${claudeSettingsPath}`));
-  } catch (ex) {
-    console.error(chalk5.red(`  \u274C Failed to clean up settings.json: ${ex.message}`));
   }
+  if (fs4.existsSync(CLAUDE_CODE_DIR)) {
+    fs4.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
+    console.log(chalk4.red("  removed") + chalk4.dim(`: ${CLAUDE_CODE_DIR}`));
+  }
+  configManager.claude_code = null;
+  configManager.save();
 };
-var rollbackRooCode = () => {
+var unlinkRooCode = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove RooCode symlinks from ${ROO_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk4.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk4.red(`
+Removing RooCode integration...`));
+  console.log(chalk4.dim(ROO_DIR));
   const backupPath = configManager.roocode?.backup_path ?? ROO_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
-    const target = path5.join(ROO_DIR, dir);
-    if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink()) {
-      fs5.unlinkSync(target);
-      console.log(chalk5.dim(`  removed symlink: ${target}`));
+    const target = path4.join(ROO_DIR, dir);
+    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
+      fs4.unlinkSync(target);
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
     }
   }
-  if (fs5.existsSync(backupPath) === false) {
-    return;
-  }
-  try {
-    for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
-      const src = path5.join(backupPath, dir);
-      const dest = path5.join(ROO_DIR, dir);
-      if (fs5.existsSync(src) === false) {
-        continue;
+  if (fs4.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["roocode" /* ROOCODE */]) {
+        const src = path4.join(backupPath, dir);
+        const dest = path4.join(ROO_DIR, dir);
+        if (!fs4.existsSync(src)) {
+          continue;
+        }
+        fs4.renameSync(src, dest);
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
       }
-      fs5.renameSync(src, dest);
-      console.log(chalk5.dim(`  restored: ${dir}/`));
+      fs4.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
     }
-    fs5.rmdirSync(backupPath);
-  } catch (ex) {
-    console.error(chalk5.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
   }
+  configManager.roocode = null;
+  configManager.save();
 };
-var rollbackOpenclaw = () => {
+var unlinkOpenclaw = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove OpenClaw symlinks from ${OPENCLAW_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk4.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk4.red(`
+Removing OpenClaw integration...`));
+  console.log(chalk4.dim(OPENCLAW_DIR));
   const backupPath = configManager.openclaw?.backup_path ?? OPENCLAW_BACKUP_DIR;
   for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
-    const target = path5.join(OPENCLAW_DIR, dir);
-    if (fs5.existsSync(target) && fs5.lstatSync(target).isSymbolicLink()) {
-      fs5.unlinkSync(target);
-      console.log(chalk5.dim(`  removed symlink: ${target}`));
+    const target = path4.join(OPENCLAW_DIR, dir);
+    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
+      fs4.unlinkSync(target);
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
     }
   }
-  if (fs5.existsSync(backupPath) === false) {
+  if (fs4.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
+        const src = path4.join(backupPath, dir);
+        const dest = path4.join(OPENCLAW_DIR, dir);
+        if (!fs4.existsSync(src)) {
+          continue;
+        }
+        fs4.renameSync(src, dest);
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
+      }
+      fs4.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
+    }
+  }
+  configManager.openclaw = null;
+  configManager.save();
+};
+var unlinkAntigravity = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove Antigravity symlinks from ${ANTIGRAVITY_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk4.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk4.red(`
+Removing Antigravity integration...`));
+  console.log(chalk4.dim(ANTIGRAVITY_DIR));
+  const backupPath = configManager.antigravity?.backup_path ?? ANTIGRAVITY_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
+    const target = path4.join(ANTIGRAVITY_DIR, dir);
+    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
+      fs4.unlinkSync(target);
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
+    }
+  }
+  if (fs4.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["antigravity" /* ANTIGRAVITY */]) {
+        const src = path4.join(backupPath, dir);
+        const dest = path4.join(ANTIGRAVITY_DIR, dir);
+        if (!fs4.existsSync(src)) {
+          continue;
+        }
+        fs4.renameSync(src, dest);
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
+      }
+      fs4.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to restore Antigravity backup: ${ex.message}`));
+    }
+  }
+  configManager.antigravity = null;
+  configManager.save();
+};
+var unlinkCodex = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove Codex symlinks from ${CODEX_DIR}?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk4.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk4.red(`
+Removing Codex integration...`));
+  console.log(chalk4.dim(CODEX_DIR));
+  const backupPath = configManager.codex?.backup_path ?? CODEX_BACKUP_DIR;
+  for (const dir of AGENT_PROMPT_DIRS["codex" /* CODEX */]) {
+    const target = path4.join(CODEX_DIR, dir);
+    if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
+      fs4.unlinkSync(target);
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
+    }
+  }
+  if (fs4.existsSync(backupPath)) {
+    try {
+      for (const dir of AGENT_PROMPT_DIRS["codex" /* CODEX */]) {
+        const src = path4.join(backupPath, dir);
+        const dest = path4.join(CODEX_DIR, dir);
+        if (!fs4.existsSync(src)) {
+          continue;
+        }
+        fs4.renameSync(src, dest);
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
+      }
+      fs4.rmdirSync(backupPath);
+    } catch (ex) {
+      console.error(chalk4.red(`  \u274C Failed to restore Codex backup: ${ex.message}`));
+    }
+  }
+  configManager.codex = null;
+  configManager.save();
+};
+var unlinkCursor = async (force = false) => {
+  if (!force) {
+    const ok = await confirm3({
+      message: `Remove Cursor plugin dir (${CURSOR_PLUGIN_DIR}) and plugin structure?`,
+      default: false
+    });
+    if (!ok) {
+      console.log(chalk4.yellow("Cancelled."));
+      return;
+    }
+  }
+  console.log(chalk4.red(`
+Removing Cursor plugin...`));
+  console.log(chalk4.dim(CURSOR_PLUGIN_DIR));
+  fs4.rmSync(CURSOR_PLUGIN_DIR, { recursive: true, force: true });
+  console.log(chalk4.red("  removed") + chalk4.dim(`: ${CURSOR_PLUGIN_DIR}`));
+  if (fs4.existsSync(CURSOR_DIR)) {
+    fs4.rmSync(CURSOR_DIR, { recursive: true, force: true });
+    console.log(chalk4.red("  removed") + chalk4.dim(`: ${CURSOR_DIR}`));
+  }
+  configManager.cursor = null;
+  configManager.save();
+};
+var linkCommand = async (tool) => {
+  if (tool != null) {
+    const known = ALL_AGENTS.some((a) => a.value === tool);
+    if (!known) {
+      console.log(chalk4.red(`Unknown vendor: ${tool}`));
+      process.exit(1);
+    }
+    if (tool === "claudecode" /* CLAUDECODE */) {
+      await linkClaudeCode();
+    } else if (tool === "roocode" /* ROOCODE */) {
+      await linkRooCode();
+    } else if (tool === "openclaw" /* OPENCLAW */) {
+      await linkOpenclaw();
+    } else if (tool === "codex" /* CODEX */) {
+      await linkCodex();
+    } else if (tool === "antigravity" /* ANTIGRAVITY */) {
+      await linkAntigravity();
+    } else if (tool === "cursor" /* CURSOR */) {
+      await linkCursor();
+    }
     return;
   }
-  try {
-    for (const dir of AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */]) {
-      const src = path5.join(backupPath, dir);
-      const dest = path5.join(OPENCLAW_DIR, dir);
-      if (fs5.existsSync(src) === false) {
-        continue;
+  const prevLinked = {
+    ["claudecode" /* CLAUDECODE */]: configManager.isClaudeCodeEnabled(),
+    ["roocode" /* ROOCODE */]: configManager.isRooCodeEnabled(),
+    ["openclaw" /* OPENCLAW */]: configManager.isOpenclawEnabled(),
+    ["codex" /* CODEX */]: configManager.isCodexEnabled(),
+    ["antigravity" /* ANTIGRAVITY */]: configManager.isAntigravityEnabled(),
+    ["cursor" /* CURSOR */]: configManager.isCursorEnabled()
+  };
+  const selected = await checkbox({
+    message: "Which AI agent do you want to integrate?",
+    choices: ALL_AGENTS.map((a) => ({
+      name: prevLinked[a.value] ? `${a.name} ${chalk4.dim("(applied)")}` : a.name,
+      value: a.value,
+      checked: prevLinked[a.value]
+    }))
+  });
+  const toLink = ALL_AGENTS.filter((a) => !prevLinked[a.value] && selected.includes(a.value));
+  const toUnlink = ALL_AGENTS.filter((a) => prevLinked[a.value] && !selected.includes(a.value));
+  console.log();
+  if (toLink.length > 0) {
+    console.log(chalk4.green("  Link   ") + chalk4.dim("\u2192 ") + toLink.map((a) => chalk4.bold(a.name)).join(chalk4.dim(", ")));
+  }
+  if (toUnlink.length > 0) {
+    console.log(chalk4.red("  Unlink ") + chalk4.dim("\u2192 ") + toUnlink.map((a) => chalk4.bold(a.name)).join(chalk4.dim(", ")));
+  }
+  console.log();
+  if (toLink.length === 0 && toUnlink.length === 0) {
+    return;
+  }
+  for (const a of ALL_AGENTS) {
+    const was = prevLinked[a.value];
+    const now = selected.includes(a.value);
+    if (!was && now) {
+      if (a.value === "claudecode" /* CLAUDECODE */) {
+        await linkClaudeCode();
+      } else if (a.value === "roocode" /* ROOCODE */) {
+        await linkRooCode();
+      } else if (a.value === "openclaw" /* OPENCLAW */) {
+        await linkOpenclaw();
+      } else if (a.value === "codex" /* CODEX */) {
+        await linkCodex();
+      } else if (a.value === "antigravity" /* ANTIGRAVITY */) {
+        await linkAntigravity();
+      } else if (a.value === "cursor" /* CURSOR */) {
+        await linkCursor();
+      }
+    }
+    if (was && !now) {
+      if (a.value === "claudecode" /* CLAUDECODE */) {
+        await unlinkClaudeCode(true);
+      } else if (a.value === "roocode" /* ROOCODE */) {
+        await unlinkRooCode(true);
+      } else if (a.value === "openclaw" /* OPENCLAW */) {
+        await unlinkOpenclaw(true);
+      } else if (a.value === "codex" /* CODEX */) {
+        await unlinkCodex(true);
+      } else if (a.value === "antigravity" /* ANTIGRAVITY */) {
+        await unlinkAntigravity(true);
+      } else if (a.value === "cursor" /* CURSOR */) {
+        await unlinkCursor(true);
       }
-      fs5.renameSync(src, dest);
-      console.log(chalk5.dim(`  restored: ${dir}/`));
     }
-    fs5.rmdirSync(backupPath);
-  } catch (ex) {
-    console.error(chalk5.red(`  \u274C Failed to restore OpenClaw backup: ${ex.message}`));
   }
 };
+
+// src/commands/uninstall-command.ts
+import fs5 from "fs";
+import chalk5 from "chalk";
+import { confirm as confirm4 } from "@inquirer/prompts";
 var uninstallCommand = async () => {
   const targets = [
-    { label: `Claude Code plugin dir  ${chalk5.dim(CLAUDE_CODE_DIR)}`, path: CLAUDE_CODE_DIR },
-    { label: `Config file             ${chalk5.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
-    { label: `Home dir                ${chalk5.dim(HOME_DIR)}`, path: HOME_DIR }
+    { label: `Config file  ${chalk5.dim(CONFIG_PATH)}`, path: CONFIG_PATH },
+    { label: `Home dir     ${chalk5.dim(HOME_DIR)}`, path: HOME_DIR }
   ].filter((t) => fs5.existsSync(t.path));
-  const hasClaudeCodeSettings = configManager.isClaudeCodeEnabled();
+  const hasClaudeCode = configManager.isClaudeCodeEnabled();
   const hasRooCode = configManager.isRooCodeEnabled();
   const hasOpenclaw = configManager.isOpenclawEnabled();
-  if (targets.length === 0 && hasClaudeCodeSettings === false && hasRooCode === false && hasOpenclaw === false) {
+  const hasAntigravity = configManager.isAntigravityEnabled();
+  const hasCodex = configManager.isCodexEnabled();
+  const hasCursor = configManager.isCursorEnabled();
+  if (targets.length === 0 && !hasClaudeCode && !hasRooCode && !hasOpenclaw && !hasAntigravity && !hasCodex && !hasCursor) {
     console.log(chalk5.yellow("Nothing to remove."));
     return;
   }
   console.log(chalk5.red("\nThe following will be removed:"));
   targets.forEach((t) => console.log(`  ${t.label}`));
-  if (hasClaudeCodeSettings) {
-    const claudeSettingsPath = path5.join(os3.homedir(), ".claude", "settings.json");
-    console.log(`  set-prompt entries in ${chalk5.dim(claudeSettingsPath)}`);
+  if (hasClaudeCode) {
+    console.log(`  Claude Code plugin dir  ${chalk5.dim(CLAUDE_CODE_DIR)}`);
   }
   if (hasRooCode) {
-    console.log(`  RooCode symlinks in ${chalk5.dim(ROO_DIR)} ${chalk5.dim("(backup will be restored)")}`);
+    console.log(`  RooCode symlinks ${chalk5.dim("(backup will be restored)")}`);
   }
   if (hasOpenclaw) {
-    console.log(`  OpenClaw symlinks in ${chalk5.dim(OPENCLAW_DIR)} ${chalk5.dim("(backup will be restored)")}`);
+    console.log(`  OpenClaw symlinks ${chalk5.dim("(backup will be restored)")}`);
+  }
+  if (hasAntigravity) {
+    console.log(`  Antigravity symlinks ${chalk5.dim("(backup will be restored)")}`);
+  }
+  if (hasCodex) {
+    console.log(`  Codex symlinks ${chalk5.dim("(backup will be restored)")}`);
+  }
+  if (hasCursor) {
+    console.log(`  Cursor plugin dir ${chalk5.dim("(symlink will be removed)")}`);
   }
   const ok = await confirm4({ message: "Proceed?", default: false });
-  if (ok === false) {
+  if (!ok) {
     console.log(chalk5.yellow("Cancelled."));
     return;
   }
-  if (hasClaudeCodeSettings) {
-    rollbackClaudeCode();
+  if (hasClaudeCode) {
+    await unlinkClaudeCode(true);
   }
   if (hasRooCode) {
-    rollbackRooCode();
+    await unlinkRooCode(true);
   }
   if (hasOpenclaw) {
-    rollbackOpenclaw();
+    await unlinkOpenclaw(true);
+  }
+  if (hasAntigravity) {
+    await unlinkAntigravity(true);
+  }
+  if (hasCodex) {
+    await unlinkCodex(true);
+  }
+  if (hasCursor) {
+    await unlinkCursor(true);
   }
   for (const t of targets) {
     fs5.rmSync(t.path, { recursive: true, force: true });
@@ -1214,8 +1727,8 @@ process.on("unhandledRejection", (reason) => {
   }
   throw reason;
 });
-var __dirname = path6.dirname(fileURLToPath(import.meta.url));
-var pkg = JSON.parse(fs6.readFileSync(path6.join(__dirname, "../package.json"), "utf-8"));
+var __dirname = path5.dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(fs6.readFileSync(path5.join(__dirname, "../package.json"), "utf-8"));
 configManager.init();
 var program = new Command();
 var banner = chalk8.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));