set-prompt 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -4,6 +4,27 @@ All notable changes to this project will be documented in this file.
 
 ---
 
+## [0.4.0] - 2026-04-10
+
+### Added
+- Cursor integration (`link cursor`) — creates plugin structure at `~/.cursor/` with backup/restore
+- `linkCommand` now shows a Link / Unlink summary before executing; exits early when there are no changes
+- All `unlink*` functions print a colored header banner on start (consistent with `link*`)
+- Console output: `removed` → red, `restored` → green, `backed up` → yellow
+- Console output: `Config loaded` is now green (consistent with `Config saved`)
+
+### Changed
+- Claude Code plugin: `~/.claude/plugins/installed_plugins.json` is now directly patched so `installPath` points to the source plugin directory — bypasses Claude Code's cache management that was deleting the symlink on startup
+- `install`: re-installing the same URL is blocked with a `set-prompt update` hint
+- `install`: re-installing a different URL shows a "Switching repo" warning with confirmation (default: No)
+- `install`: EPERM on directory rename is handled gracefully with a descriptive error message
+- `install`: existing repo backup is automatically removed after a successful clone
+
+### Disabled
+- `link codex` is temporarily unavailable in this release (implementation preserved, re-enable in next release)
+
+---
+
 ## [0.3.0] - 2026-04-06
 
 ### Added

package/README.md

@@ -80,16 +80,18 @@ set-prompt link claudecode   # link Claude Code only
 set-prompt link roocode      # link RooCode only
 set-prompt link openclaw     # link OpenClaw only
 set-prompt link antigravity  # link Antigravity only
+set-prompt link cursor       # link Cursor only
 ```
 
 The interactive mode shows all agents with their current state. **Check to link, uncheck to unlink** — existing directories are backed up before being replaced.
 
 | Agent | Where prompts land | What gets linked |
 |---|---|---|
-| Claude Code | `~/.set-prompt/claudecode/` (plugin) | `skills/`, `commands/`, `hooks/`, `agents/` |
+| Claude Code | `~/.set-prompt/claude-code/` (plugin) | `skills/`, `commands/`, `hooks/`, `agents/` |
 | RooCode | `~/.roo/` | `skills/`, `commands/` |
 | OpenClaw | `~/.openclaw/workspace/` | `skills/` |
 | Antigravity | `~/.gemini/antigravity/` | `skills/` |
+| Cursor | `~/.cursor/` (plugin) | `skills/`, `commands/` |
 
 ---
 
@@ -141,9 +143,10 @@ npm test                         # Run tests with vitest
 
 `set-prompt` modifies configuration files managed by third-party AI agent applications:
 
-- **Claude Code** — writes to `~/.claude/settings.json`
+- **Claude Code** — writes to `~/.claude/settings.json` and `~/.claude/plugins/installed_plugins.json`
 - **RooCode** — replaces directories in `~/.roo/`
 - **OpenClaw** — replaces directories in `~/.openclaw/workspace/`
+- **Cursor** — writes to `~/.cursor/`
 
 Before making any changes, `set-prompt` creates a backup and rolls back automatically on failure. However, you should be aware that:
 
@@ -164,14 +167,15 @@ Stored at `~/.set-prompt/config.json`, managed via `ConfigManager`.
 │       ├── skills/
 │       ├── commands/
 │       └── hooks/
-└── claudecode/         # Claude Code plugin output
+└── claude-code/        # Claude Code plugin output
     ├── .claude-plugin/
     │   └── marketplace.json
-    └── plugins/set-prompt/
+    └── plugins/sppt/
         ├── .claude-plugin/plugin.json
         ├── skills/      → symlink to repo/skills/
         ├── commands/    → symlink to repo/commands/
-        └── hooks/       → symlink to repo/hooks/
+        ├── hooks/       → symlink to repo/hooks/
+        └── agents/      → symlink to repo/agents/
 
 ~/.roo/                  # RooCode integration (symlinks)
 ├── SET_PROMPT_BACKUP/  # backup of original dirs before linking
@@ -195,7 +199,7 @@ Stored at `~/.set-prompt/config.json`, managed via `ConfigManager`.
 
 - **Node.js** 18+
 - **Git** (must be available in `PATH` for `set-prompt install`)
-- **Windows**: symlink creation requires either Developer Mode enabled or running as Administrator
+- **Windows only**: symlink creation requires Developer Mode enabled or running as Administrator (Linux/macOS work out of the box)
 
 ## 🤝 Contributing
 

package/dist/index.js

@@ -29,20 +29,26 @@ 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"]
+  ["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
@@ -65,12 +71,19 @@ 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(),
   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(),
   remote_url: z.string().nullable(),
@@ -78,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
@@ -91,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;
@@ -113,6 +128,9 @@ var ConfigManager = class {
   get antigravity() {
     return this._antigravity;
   }
+  get cursor() {
+    return this._cursor;
+  }
   set repo_path(v) {
     this._repo_path = v;
   }
@@ -134,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() {
@@ -154,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}`));
@@ -188,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;
@@ -196,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) {
@@ -563,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}...`);
@@ -587,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;
@@ -603,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);
@@ -625,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) {
@@ -637,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" }]
@@ -714,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)) {
@@ -761,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));
@@ -772,6 +857,7 @@ Setting up Claude Code plugin...`));
   if (settingsOk === false) {
     return;
   }
+  patchInstalledPlugins();
   configManager.claude_code = { path: CLAUDE_CODE_DIR };
   configManager.save();
 };
@@ -790,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) {
@@ -863,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) {
@@ -921,11 +1029,181 @@ Setting up OpenClaw integration...`));
   configManager.openclaw = { path: OPENCLAW_DIR, backup_path: OPENCLAW_BACKUP_DIR };
   configManager.save();
 };
+var linkAntigravity = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  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;
+    }
+  };
+  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 linkOk = await setAntigravityAssets();
+  if (linkOk === false) {
+    return;
+  }
+  configManager.antigravity = { path: ANTIGRAVITY_DIR, backup_path: ANTIGRAVITY_BACKUP_DIR };
+  configManager.save();
+};
 var linkCodex = async () => {
-  if (resolveRepoPath() == null) {
+  console.error(chalk4.red("\u274C Codex integration is not available in this version."));
+  return;
+};
+var linkCursor = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
     return;
   }
-  console.log(chalk4.yellow("Codex integration is not yet implemented."));
+  const CURSOR_LOCAL_DIR = "local";
+  const CURSOR_PLUGIN_NAME = "set-prompt";
+  const setCursorAssets = async () => {
+    try {
+      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.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) {
@@ -938,6 +1216,9 @@ var unlinkClaudeCode = async (force = false) => {
       return;
     }
   }
+  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 {
@@ -945,16 +1226,16 @@ var unlinkClaudeCode = async (force = false) => {
       const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
       fs4.copyFileSync(claudeSettingsPath, backupPath);
       const settings = JSON.parse(fs4.readFileSync(claudeSettingsPath, "utf-8"));
-      if (settings?.extraKnownMarketplaces?.[PLUGIN_NAME] !== void 0) {
-        delete settings.extraKnownMarketplaces[PLUGIN_NAME];
+      if (settings?.extraKnownMarketplaces?.[MARKET_NAME] !== void 0) {
+        delete settings.extraKnownMarketplaces[MARKET_NAME];
       }
-      if (settings?.enabledPlugins?.[`${PLUGIN_NAME}@${PLUGIN_NAME}`] !== void 0) {
-        delete settings.enabledPlugins[`${PLUGIN_NAME}@${PLUGIN_NAME}`];
+      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.dim(`  removed set-prompt entries from: ${claudeSettingsPath}`));
+        console.log(chalk4.red("  removed") + chalk4.dim(` set-prompt entries from: ${claudeSettingsPath}`));
       } catch (ex) {
         fs4.copyFileSync(backupPath, claudeSettingsPath);
         fs4.unlinkSync(backupPath);
@@ -964,9 +1245,60 @@ var unlinkClaudeCode = async (force = false) => {
       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 {
+      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 {
+        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."));
+      }
+    } 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 {
+      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}`));
+    }
+  }
   if (fs4.existsSync(CLAUDE_CODE_DIR)) {
     fs4.rmSync(CLAUDE_CODE_DIR, { recursive: true, force: true });
-    console.log(chalk4.dim(`  removed: ${CLAUDE_CODE_DIR}`));
+    console.log(chalk4.red("  removed") + chalk4.dim(`: ${CLAUDE_CODE_DIR}`));
   }
   configManager.claude_code = null;
   configManager.save();
@@ -982,12 +1314,15 @@ var unlinkRooCode = async (force = false) => {
       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 = path4.join(ROO_DIR, dir);
     if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
       fs4.unlinkSync(target);
-      console.log(chalk4.dim(`  removed symlink: ${target}`));
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
     }
   }
   if (fs4.existsSync(backupPath)) {
@@ -999,7 +1334,7 @@ var unlinkRooCode = async (force = false) => {
           continue;
         }
         fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  restored: ${dir}/`));
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
       }
       fs4.rmdirSync(backupPath);
     } catch (ex) {
@@ -1020,12 +1355,15 @@ var unlinkOpenclaw = async (force = false) => {
       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 = path4.join(OPENCLAW_DIR, dir);
     if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink()) {
       fs4.unlinkSync(target);
-      console.log(chalk4.dim(`  removed symlink: ${target}`));
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
     }
   }
   if (fs4.existsSync(backupPath)) {
@@ -1037,7 +1375,7 @@ var unlinkOpenclaw = async (force = false) => {
           continue;
         }
         fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  restored: ${dir}/`));
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
       }
       fs4.rmdirSync(backupPath);
     } catch (ex) {
@@ -1058,12 +1396,15 @@ var unlinkAntigravity = async (force = false) => {
       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.dim(`  removed symlink: ${target}`));
+      console.log(chalk4.red("  removed symlink") + chalk4.dim(`: ${target}`));
     }
   }
   if (fs4.existsSync(backupPath)) {
@@ -1075,7 +1416,7 @@ var unlinkAntigravity = async (force = false) => {
           continue;
         }
         fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  restored: ${dir}/`));
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
       }
       fs4.rmdirSync(backupPath);
     } catch (ex) {
@@ -1085,77 +1426,68 @@ var unlinkAntigravity = async (force = false) => {
   configManager.antigravity = null;
   configManager.save();
 };
-var linkAntigravity = async () => {
-  const repoPath = resolveRepoPath();
-  if (repoPath == null) {
-    return;
+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.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) {
-          dirsToBackup.push(dir);
-        }
-      }
-      if (dirsToBackup.length === 0) {
-        return true;
-      }
-      fs4.mkdirSync(ANTIGRAVITY_BACKUP_DIR, { recursive: true });
-      for (const dir of dirsToBackup) {
-        const src = path4.join(ANTIGRAVITY_DIR, dir);
-        const dest = path4.join(ANTIGRAVITY_BACKUP_DIR, dir);
-        fs4.renameSync(src, dest);
-        console.log(chalk4.dim(`  backed up: ${dir}/ \u2192 ${dest}`));
-      }
-      return true;
-    } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
-      return false;
+  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}`));
     }
-  };
-  const setAntigravityAssets = async () => {
+  }
+  if (fs4.existsSync(backupPath)) {
     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) {
+      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;
         }
-        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"));
+        fs4.renameSync(src, dest);
+        console.log(chalk4.green("  restored") + chalk4.dim(`: ${dir}/`));
       }
-      return true;
+      fs4.rmdirSync(backupPath);
     } catch (ex) {
-      console.error(chalk4.red(`\u274C Failed to create symlinks: ${ex.message}`));
-      return false;
+      console.error(chalk4.red(`  \u274C Failed to restore Codex backup: ${ex.message}`));
     }
-  };
-  const backupOk = await backupExistingAntigravityFiles();
-  if (backupOk === false) {
-    return;
   }
-  const linkOk = await setAntigravityAssets();
-  if (linkOk === false) {
-    return;
+  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;
+    }
   }
-  configManager.antigravity = { path: ANTIGRAVITY_DIR, backup_path: ANTIGRAVITY_BACKUP_DIR };
+  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) => {
@@ -1175,6 +1507,8 @@ var linkCommand = async (tool) => {
       await linkCodex();
     } else if (tool === "antigravity" /* ANTIGRAVITY */) {
       await linkAntigravity();
+    } else if (tool === "cursor" /* CURSOR */) {
+      await linkCursor();
     }
     return;
   }
@@ -1183,7 +1517,8 @@ var linkCommand = async (tool) => {
     ["roocode" /* ROOCODE */]: configManager.isRooCodeEnabled(),
     ["openclaw" /* OPENCLAW */]: configManager.isOpenclawEnabled(),
     ["codex" /* CODEX */]: configManager.isCodexEnabled(),
-    ["antigravity" /* ANTIGRAVITY */]: configManager.isAntigravityEnabled()
+    ["antigravity" /* ANTIGRAVITY */]: configManager.isAntigravityEnabled(),
+    ["cursor" /* CURSOR */]: configManager.isCursorEnabled()
   };
   const selected = await checkbox({
     message: "Which AI agent do you want to integrate?",
@@ -1193,6 +1528,19 @@ var linkCommand = async (tool) => {
       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);
@@ -1207,6 +1555,8 @@ var linkCommand = async (tool) => {
         await linkCodex();
       } else if (a.value === "antigravity" /* ANTIGRAVITY */) {
         await linkAntigravity();
+      } else if (a.value === "cursor" /* CURSOR */) {
+        await linkCursor();
       }
     }
     if (was && !now) {
@@ -1216,8 +1566,12 @@ var linkCommand = async (tool) => {
         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);
       }
     }
   }
@@ -1236,7 +1590,9 @@ var uninstallCommand = async () => {
   const hasRooCode = configManager.isRooCodeEnabled();
   const hasOpenclaw = configManager.isOpenclawEnabled();
   const hasAntigravity = configManager.isAntigravityEnabled();
-  if (targets.length === 0 && !hasClaudeCode && !hasRooCode && !hasOpenclaw && !hasAntigravity) {
+  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;
   }
@@ -1254,6 +1610,12 @@ var uninstallCommand = async () => {
   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) {
     console.log(chalk5.yellow("Cancelled."));
@@ -1271,6 +1633,12 @@ var uninstallCommand = async () => {
   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 });
     console.log(chalk5.dim(`  removed: ${t.path}`));

package/package.json

@@ -1,16 +1,16 @@
 {
     "name": "set-prompt",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "Sync your prompt library across AI coding tools from a single git repo",
     "main": "dist/index.js",
     "bin": {
-        "set-prompt": "./dist/index.js"
+        "set-prompt": "./dist/index.js",
+        "sppt": "./dist/index.js"
     },
     "type": "module",
     "scripts": {
         "start:dev": "tsx src/index.ts",
-        "build": "rimraf dist && tsup && npm run copy_bin",
-        "copy_bin": "cpx \"src/bin/set-prompt.js\" dist/bin",
+        "build": "rimraf dist && tsup",
         "test": "vitest --reporter=verbose"
     },
     "keywords": [
@@ -46,7 +46,6 @@
         "@types/fs-extra": "^11.0.4",
         "@types/node": "^25.4.0",
         "@vitest/coverage-v8": "^4.1.0",
-        "cpx": "^1.5.0",
         "memfs": "^4.56.11",
         "prettier": "^3.8.1",
         "rimraf": "^6.1.3",

package/dist/bin/set-prompt.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import '../index.js';