set-prompt 0.0.1 → 0.2.1

package/dist/index.js

@@ -0,0 +1,1244 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk8 from "chalk";
+import figlet from "figlet";
+import fs6 from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+
+// src/commands/install-command.ts
+import fs3 from "fs";
+import path3 from "path";
+import { spawnSync } from "child_process";
+import chalk3 from "chalk";
+import { confirm as confirm2 } from "@inquirer/prompts";
+
+// src/_defs/index.ts
+import path from "path";
+import os from "os";
+var TAB = `    `;
+var HOME_DIR = path.join(os.homedir(), ".set-prompt");
+var CONFIG_PATH = path.join(HOME_DIR, "config.json");
+var REPO_DIR = path.join(HOME_DIR, "repo");
+var CLAUDE_CODE_DIR = path.join(HOME_DIR, "claude-code");
+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 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"]
+};
+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 */ }
+];
+
+// src/_libs/config.ts
+import fs from "fs";
+import chalk from "chalk";
+
+// src/_types/index.ts
+import { z } from "zod";
+var ClaudeCodeConfigSchema = z.object({
+  path: z.string().nullable()
+});
+var RoocodeConfigSchema = z.object({
+  path: z.string().nullable(),
+  // ~/.roo
+  backup_path: z.string().nullish().optional()
+  // ~/.roo/SET_PROMPT_BACKUP
+});
+var OpenclawConfigSchema = z.object({
+  path: z.string().nullable(),
+  backup_path: z.string().nullish().optional()
+});
+var CodexConfigSchema = z.object({
+  path: z.string().nullable()
+});
+var AntigravityConfigSchema = z.object({
+  path: z.string().nullable()
+});
+var GlobalConfigSchema = z.object({
+  repo_path: z.string(),
+  remote_url: z.string().nullable(),
+  claude_code: ClaudeCodeConfigSchema.nullable(),
+  roocode: RoocodeConfigSchema.nullable(),
+  openclaw: OpenclawConfigSchema.nullable(),
+  codex: CodexConfigSchema.nullish().optional(),
+  antigravity: AntigravityConfigSchema.nullish().optional()
+});
+
+// src/_libs/config.ts
+var ConfigManager = class {
+  constructor() {
+    this._repo_path = null;
+    this._remote_url = null;
+    this._claude_code = null;
+    this._roocode = null;
+    this._openclaw = null;
+    this._codex = null;
+    this._antigravity = null;
+  }
+  get repo_path() {
+    return this._repo_path;
+  }
+  get remote_url() {
+    return this._remote_url;
+  }
+  get claude_code() {
+    return this._claude_code;
+  }
+  get roocode() {
+    return this._roocode;
+  }
+  get openclaw() {
+    return this._openclaw;
+  }
+  get codex() {
+    return this._codex;
+  }
+  get antigravity() {
+    return this._antigravity;
+  }
+  set repo_path(v) {
+    this._repo_path = v;
+  }
+  set remote_url(v) {
+    this._remote_url = v;
+  }
+  set claude_code(v) {
+    this._claude_code = v;
+  }
+  set roocode(v) {
+    this._roocode = v;
+  }
+  set openclaw(v) {
+    this._openclaw = v;
+  }
+  set codex(v) {
+    this._codex = v;
+  }
+  set antigravity(v) {
+    this._antigravity = v;
+  }
+  init() {
+    this._loadFromDisk();
+    if (this._repo_path != null) {
+      console.log(chalk.dim(`Config loaded from ${CONFIG_PATH}`));
+    }
+  }
+  save() {
+    if (this._repo_path == null) {
+      console.error(chalk.red("Cannot save config: repo_path is not set."));
+      return false;
+    }
+    try {
+      fs.mkdirSync(HOME_DIR, { recursive: true });
+      const configStr = JSON.stringify({
+        repo_path: this._repo_path,
+        remote_url: this._remote_url,
+        claude_code: this._claude_code,
+        roocode: this._roocode,
+        openclaw: this._openclaw,
+        codex: this._codex,
+        antigravity: this._antigravity
+      }, null, 4);
+      fs.writeFileSync(CONFIG_PATH, configStr, "utf-8");
+      console.log(chalk.green(`Config saved`) + chalk.dim(` \u2192 ${CONFIG_PATH}`));
+      return true;
+    } catch (ex) {
+      console.error(chalk.red(`Failed to save config at '${CONFIG_PATH}'`), ex.message);
+      return false;
+    }
+  }
+  reload() {
+    this._loadFromDisk();
+  }
+  exists() {
+    return fs.existsSync(CONFIG_PATH);
+  }
+  isRepoSet() {
+    return this._repo_path != null;
+  }
+  isClaudeCodeEnabled() {
+    return this._claude_code != null;
+  }
+  isRooCodeEnabled() {
+    return this._roocode != null;
+  }
+  isOpenclawEnabled() {
+    return this._openclaw != null;
+  }
+  isCodexEnabled() {
+    return this._codex != null;
+  }
+  isAntigravityEnabled() {
+    return this._antigravity != null;
+  }
+  _assign(config) {
+    this._repo_path = config.repo_path;
+    this._remote_url = config.remote_url;
+    this._claude_code = config.claude_code;
+    this._roocode = config.roocode;
+    this._openclaw = config.openclaw;
+    this._codex = config.codex ?? null;
+    this._antigravity = config.antigravity ?? null;
+  }
+  _loadFromDisk() {
+    if (fs.existsSync(CONFIG_PATH) === false) {
+      return;
+    }
+    try {
+      const textData = fs.readFileSync(CONFIG_PATH, "utf-8");
+      const json = JSON.parse(textData);
+      const config = GlobalConfigSchema.parse(json);
+      this._assign(config);
+    } catch (ex) {
+      console.error(chalk.red(`Failed to parse config at '${CONFIG_PATH}'`), ex.message);
+    }
+  }
+};
+var configManager = new ConfigManager();
+
+// src/_libs/index.ts
+var isGitUrl = (source) => source.startsWith("http://") || source.startsWith("https://") || source.startsWith("git@") || source.startsWith("ssh://") || source.endsWith(".git") && (source.startsWith("http") || source.startsWith("git@") || source.startsWith("ssh://"));
+
+// src/commands/scaffold-command.ts
+import fs2 from "fs";
+import path2 from "path";
+import chalk2 from "chalk";
+import { confirm } from "@inquirer/prompts";
+
+// src/_libs/templates.ts
+var SET_PROMPT_GUIDE = `# Set Prompt Repository Guide
+
+> Managed by [set-prompt](https://github.com/alkemic-studio/set-prompt)
+
+## Structure
+
+\`\`\`
+\u251C\u2500\u2500 set-prompt.toml        # Repository configuration
+\u251C\u2500\u2500 skills/
+\u2502   \u2514\u2500\u2500 <skill-name>/
+\u2502       \u251C\u2500\u2500 SKILL.md       # Platform-specific frontmatter + prompt content
+\u2502       \u2514\u2500\u2500 ...            # Supporting files (scripts, configs, etc.)
+\u251C\u2500\u2500 commands/
+\u2502   \u2514\u2500\u2500 <command-name>/
+\u2502       \u251C\u2500\u2500 COMMAND.md     # Platform-specific frontmatter + prompt content
+\u2502       \u2514\u2500\u2500 ...            # Supporting files
+\u251C\u2500\u2500 hooks/                 # Lifecycle shell hooks
+\u2514\u2500\u2500 agents/                # Agent definitions (Claude Code)
+    \u2514\u2500\u2500 <agent-name>/
+        \u2514\u2500\u2500 AGENT.md
+\`\`\`
+
+## Frontmatter Reference
+
+### Skills
+
+Auto-loadable AI behaviors.
+
+\`\`\`yaml
+---
+# Common
+name: "my-skill"
+description: "What this skill does and when to use it"
+
+# Claude Code
+allowed-tools:
+  - Read
+  - Bash
+disable-model-invocation: false
+model: sonnet
+context: fork
+agent: general-purpose
+hooks:
+  PreToolUse:
+    - matcher: "Bash"
+      hooks:
+        - type: command
+          command: ".claude/hooks/validate.sh"
+
+# RooCode
+slug: my-mode
+name: "\u{1F527} My Mode"
+roleDefinition: "You are a specialist in..."
+groups:
+  - read
+  - edit
+  - command
+whenToUse: "Use when you need to..."
+customInstructions: "Additional behavior guidelines..."
+
+# OpenClaw
+homepage: "https://github.com/you/my-skill"
+metadata: {"openclaw":{"emoji":"\u{1F527}","os":["darwin","linux"]}}
+---
+\`\`\`
+
+| Field | Required | Platform | Description |
+|-------|----------|----------|-------------|
+| \`name\` | Yes | All | Display name. Claude Code: lowercase, numbers, hyphens only (max 64 chars). RooCode: emoji allowed. |
+| \`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 |
+| \`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. |
+| \`slug\` | Yes | RooCode | Unique ID \u2014 \`[a-zA-Z0-9-]\` only |
+| \`roleDefinition\` | Yes | RooCode | Core role and expertise definition |
+| \`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"}]
+\`\`\`
+
+---
+
+### Commands
+
+User-invocable slash commands (\`/command-name\`).
+
+> RooCode does not have a separate command concept \u2014 use **Skills (modes)** instead.
+
+\`\`\`yaml
+---
+# Common
+name: "my-command"
+description: "What this command does"
+
+# Claude Code
+allowed-tools:
+  - Read
+  - Bash
+argument-hint: "[filename] [format]"
+user-invocable: true
+model: sonnet
+context: fork
+agent: general-purpose
+hooks:
+  PostToolUse:
+    - matcher: "Write|Edit"
+      hooks:
+        - type: command
+          command: "npm run lint"
+          async: true
+
+# OpenClaw
+user-invocable: true
+command-dispatch: "tool"   # bypass model, dispatch directly to a tool
+command-tool: "Bash"
+---
+\`\`\`
+
+| Field | Required | Platform | Description |
+|-------|----------|----------|-------------|
+| \`name\` | No | All | Display name \u2014 lowercase, numbers, hyphens only (max 64 chars). Defaults to directory name. |
+| \`description\` | Yes | All | Shown in \`/\` menu. Claude uses this to decide auto-loading. |
+| \`user-invocable\` | No | CC, OpenClaw | \`false\` = hidden from \`/\` menu, background knowledge only. (default: \`true\`) |
+| \`allowed-tools\` | No | Claude Code | Tools Claude can use without asking. e.g. \`Read\` \`Write\` \`Edit\` \`Bash\` \`Grep\` \`Glob\` |
+| \`argument-hint\` | No | Claude Code | Hint shown during autocomplete. e.g. \`[issue-number]\` |
+| \`model\` | No | Claude Code | Model to use when active. \`sonnet\` or \`haiku\` |
+| \`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"\`) |
+
+---
+
+### Agents
+
+Custom subagent definitions loaded by Claude Code.
+
+\`\`\`yaml
+---
+name: "my-agent"
+description: "What this agent does and when to use it"
+allowed-tools:
+  - Read
+  - Bash
+model: sonnet
+context: fork
+---
+\`\`\`
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| \`name\` | Yes | Display name \u2014 lowercase, numbers, hyphens only (max 64 chars) |
+| \`description\` | Yes | When and how to use this agent. Claude uses this to decide when to spawn it. |
+| \`allowed-tools\` | No | Tools this agent can use without asking |
+| \`model\` | No | Model override. \`sonnet\` or \`haiku\` |
+| \`context\` | No | \`fork\` = run in isolated subagent context |
+
+---
+
+### Hooks
+
+Lifecycle shell commands (or LLM prompts) that fire at specific points. Hooks in skill/command frontmatter are scoped to that component \u2014 active while it runs, removed when it finishes.
+
+\`\`\`yaml
+hooks:
+  PreToolUse:
+    - matcher: "Bash"          # regex matched against tool name
+      hooks:
+        - type: command
+          command: ".claude/hooks/validate.sh"
+          timeout: 30          # seconds (default: 600)
+  PostToolUse:
+    - matcher: "Write|Edit"
+      hooks:
+        - type: command
+          command: "npm run lint"
+          async: true          # run in background, non-blocking
+  Stop:
+    - hooks:
+        - type: prompt
+          prompt: "Verify all tasks are complete: $ARGUMENTS"
+\`\`\`
+
+**Events**
+
+| Event | Matcher | Can Block | When it fires |
+|-------|---------|:---------:|---------------|
+| \`PreToolUse\` | tool name | Yes | Before a tool runs |
+| \`PostToolUse\` | tool name | No | After a tool succeeds |
+| \`PostToolUseFailure\` | tool name | No | After a tool fails |
+| \`UserPromptSubmit\` | \u2014 | Yes | When user submits a prompt |
+| \`SessionStart\` | \`startup\` \\| \`resume\` \\| \`clear\` \\| \`compact\` | No | Session begins |
+| \`Stop\` | \u2014 | Yes | Claude finishes responding |
+| \`Notification\` | \`permission_prompt\` \\| \`idle_prompt\` | No | Notification fires |
+| \`SubagentStart\` / \`SubagentStop\` | agent type | No / Yes | Subagent spawned / finished |
+
+Full event list: [hooks reference](https://code.claude.com/docs/en/hooks)
+
+**Handler fields**
+
+| Field | Type | Description |
+|-------|------|-------------|
+| \`type\` | required | \`command\`, \`prompt\`, or \`agent\` |
+| \`command\` | command only | Shell command to execute. Receives hook JSON on stdin |
+| \`prompt\` | prompt/agent | Prompt text. Use \`$ARGUMENTS\` for the hook JSON input |
+| \`timeout\` | all | Seconds before cancel. Defaults: 600 / 30 / 60 |
+| \`async\` | command only | \`true\` = run in background, cannot block Claude |
+| \`once\` | command only | \`true\` = run once per session then remove (skills only) |
+
+**Decision control** (command hooks)
+
+Exit \`0\` = allow. Exit \`2\` = block (stderr is fed to Claude as the reason). Print JSON to stdout for richer control:
+
+\`\`\`bash
+# PreToolUse: deny via JSON
+echo '{"hookSpecificOutput":{"hookEventName":"PreToolUse","permissionDecision":"deny","permissionDecisionReason":"reason"}}'
+
+# Stop/PostToolUse: block via JSON
+echo '{"decision":"block","reason":"Tests must pass first"}'
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+# Scaffold this repo's directory structure
+set-prompt scaffold .
+
+# Install from remote and link to AI tools
+set-prompt install https://github.com/you/my-prompts
+set-prompt link
+
+# Pull latest changes
+set-prompt update
+\`\`\`
+`;
+
+// src/commands/scaffold-command.ts
+var REQUIRED_DIRS = ["skills", "commands"];
+var OPTIONAL_DIRS = ["hooks", "agents"];
+var printStructure = async (localPath) => {
+  let valid = true;
+  for (const dir of REQUIRED_DIRS) {
+    const exists = fs2.existsSync(path2.join(localPath, dir));
+    if (exists) {
+      console.log(`${TAB}\u2705 ${dir}/`);
+    } else {
+      console.log(`${TAB}\u274C ${dir}/ ${chalk2.red("(missing)")}`);
+      valid = false;
+    }
+  }
+  for (const dir of OPTIONAL_DIRS) {
+    const exists = fs2.existsSync(path2.join(localPath, dir));
+    console.log(`${TAB}${chalk2.dim(exists ? "\u2713" : "\u25CB")} ${dir}/ ${exists ? "" : chalk2.dim("(optional)")}`);
+  }
+  return valid;
+};
+var scaffoldCommand = async (localPath, options = {}) => {
+  try {
+    let targetPath = null;
+    if (localPath != null) {
+      targetPath = localPath;
+    } else {
+      if (configManager.repo_path != null) {
+        targetPath = configManager.repo_path;
+      } else {
+        console.error(chalk2.red("No path provided and no repo registered. Please provide a path."));
+        process.exit(1);
+      }
+    }
+    if (fs2.existsSync(targetPath) === false || fs2.statSync(targetPath).isDirectory() === false) {
+      console.error(chalk2.red(`Invalid directory path: '${targetPath}'`));
+      process.exit(1);
+    }
+    if (options.force !== true) {
+      console.log(chalk2.dim(`Checking repo structure at: ${targetPath}`));
+    }
+    const valid = options.force === true ? false : await printStructure(targetPath);
+    if (valid) {
+      console.log(chalk2.green("Repo structure is valid."));
+      return true;
+    }
+    if (!valid) {
+      if (options.force !== true) {
+        const proceed = await confirm({
+          message: "Some directories are missing. Scaffold them now?",
+          default: true
+        });
+        if (proceed === false) {
+          console.log(chalk2.yellow("Scaffold skipped."));
+          return false;
+        }
+      }
+      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");
+      }
+      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;
+        }
+        fs2.mkdirSync(dirPath, { recursive: true });
+        created.push(`  ${dirName}/`);
+      }
+      if (created.length > 0) {
+        console.log(chalk2.green("Created:"));
+        created.forEach((line) => console.log(line));
+      }
+    }
+    return true;
+  } catch (ex) {
+    console.error(chalk2.red(`Failed to scaffold repo structure: ${ex.message}`), ex);
+    throw ex;
+  }
+};
+
+// 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");
+  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}`));
+  }
+  fs3.mkdirSync(path3.dirname(localPath), { recursive: true });
+  console.log(`Cloning ${remoteUrl}...`);
+  const result = spawnSync("git", ["clone", remoteUrl, localPath], { stdio: "inherit" });
+  if (result.status !== 0) {
+    console.log("\u274C Failed to clone. Check the URL and your git credentials.");
+    process.exit(1);
+  }
+  console.log("\u2705 Cloned successfully.");
+  await scaffoldCommand(localPath, { force: true });
+  configManager.repo_path = localPath;
+  configManager.remote_url = remoteUrl;
+  if (configManager.save() === false) {
+    console.error(chalk3.red("Failed to save config."));
+    return false;
+  }
+  return true;
+};
+var installCommand = async (target) => {
+  try {
+    if (isGitUrl(target) === false) {
+      console.error(chalk3.red("\u274C Only remote git URLs are supported."));
+      console.log(chalk3.dim("   Example: set-prompt install https://github.com/you/my-prompts"));
+      process.exit(1);
+    }
+    return await cloneRepo(target);
+  } catch (ex) {
+    console.error(chalk3.red(`Unexpected error: ${ex.message}`), ex);
+    process.exit(1);
+  }
+};
+
+// src/commands/link-command.ts
+import path4 from "path";
+import fs4 from "fs";
+import os2 from "os";
+import chalk4 from "chalk";
+import { checkbox } from "@inquirer/prompts";
+import { pathExists } from "fs-extra";
+var resolveRepoPath = () => {
+  if (configManager.repo_path == null) {
+    console.error(chalk4.red("\u274C No repo installed."));
+    console.log(chalk4.yellow("Run: set-prompt install <git-url>"));
+    return null;
+  }
+  return configManager.repo_path;
+};
+var PLUGIN_NAME = "set-prompt";
+var linkClaudeCode = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  const setClaudeCodeAssets = async () => {
+    try {
+      fs4.mkdirSync(CLAUDE_CODE_DIR, { recursive: true });
+      const marketplaceMetaDir = path4.join(CLAUDE_CODE_DIR, ".claude-plugin");
+      fs4.mkdirSync(marketplaceMetaDir, { recursive: true });
+      const marketplaceJson = {
+        name: PLUGIN_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" }]
+      };
+      fs4.writeFileSync(
+        path4.join(marketplaceMetaDir, "marketplace.json"),
+        JSON.stringify(marketplaceJson, null, 2),
+        "utf-8"
+      );
+      console.log(chalk4.dim("  \u251C\u2500\u2500 .claude-plugin/"));
+      console.log(chalk4.dim("  \u2502   \u2514\u2500\u2500 marketplace.json") + chalk4.green(" \u2713"));
+      const pluginDir = path4.join(CLAUDE_CODE_DIR, "plugins", PLUGIN_NAME);
+      fs4.mkdirSync(pluginDir, { recursive: true });
+      console.log(chalk4.dim("  \u2514\u2500\u2500 plugins/"));
+      console.log(chalk4.dim(`      \u2514\u2500\u2500 ${PLUGIN_NAME}/`));
+      const pluginMetaDir = path4.join(pluginDir, ".claude-plugin");
+      fs4.mkdirSync(pluginMetaDir, { recursive: true });
+      const pluginJson = {
+        name: PLUGIN_NAME,
+        version: "1.0.0",
+        description: "Managed by set-prompt",
+        author: { name: path4.basename(repoPath) }
+      };
+      fs4.writeFileSync(
+        path4.join(pluginMetaDir, "plugin.json"),
+        JSON.stringify(pluginJson, null, 2),
+        "utf-8"
+      );
+      console.log(chalk4.dim("          \u251C\u2500\u2500 .claude-plugin/"));
+      console.log(chalk4.dim("          \u2502   \u2514\u2500\u2500 plugin.json") + chalk4.green(" \u2713"));
+      const linked = [];
+      for (const dir of AGENT_PROMPT_DIRS["claudecode" /* CLAUDECODE */]) {
+        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 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 build plugin structure: ${ex.message}`));
+      return false;
+    }
+  };
+  const registerToClaudeSettings = () => {
+    const claudeSettingsPath = path4.join(os2.homedir(), ".claude", "settings.json");
+    try {
+      let settings = {};
+      if (fs4.existsSync(claudeSettingsPath)) {
+        const raw = fs4.readFileSync(claudeSettingsPath, "utf-8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
+            settings = parsed;
+          } else {
+            console.warn(chalk4.yellow("  \u26A0 settings.json has unexpected format \u2014 proceeding with caution"));
+          }
+        } catch {
+          console.warn(chalk4.yellow("  \u26A0 Failed to parse settings.json \u2014 will not overwrite existing file"));
+          console.error(chalk4.red("\u274C Could not register plugin. Please add manually."));
+          return false;
+        }
+      }
+      settings.extraKnownMarketplaces = {
+        ...settings.extraKnownMarketplaces,
+        [PLUGIN_NAME]: { source: { source: "directory", path: CLAUDE_CODE_DIR } }
+      };
+      settings.enabledPlugins = {
+        ...settings.enabledPlugins,
+        [`${PLUGIN_NAME}@${PLUGIN_NAME}`]: true
+      };
+      let backupPath = null;
+      if (fs4.existsSync(claudeSettingsPath)) {
+        const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+        backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
+        try {
+          fs4.copyFileSync(claudeSettingsPath, backupPath);
+        } catch (ex) {
+          console.warn(chalk4.yellow(`  \u26A0 Could not create backup: ${ex.message}`));
+          backupPath = null;
+        }
+      }
+      try {
+        fs4.mkdirSync(path4.dirname(claudeSettingsPath), { recursive: true });
+        fs4.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
+      } catch (ex) {
+        if (backupPath !== null) {
+          try {
+            fs4.copyFileSync(backupPath, claudeSettingsPath);
+            fs4.unlinkSync(backupPath);
+            console.warn(chalk4.yellow("  \u26A0 Write failed \u2014 rolled back to original."));
+          } catch {
+            console.error(chalk4.red(`  \u274C Rollback failed. Backup preserved at: ${backupPath}`));
+          }
+        }
+        throw ex;
+      }
+      if (backupPath !== null) {
+        try {
+          fs4.unlinkSync(backupPath);
+        } catch {
+        }
+      }
+      console.log(`\u2705 Registered to Claude Code settings.`);
+      console.log(chalk4.dim(`   ${claudeSettingsPath}`));
+      return true;
+    } catch (ex) {
+      console.error(chalk4.red(`\u274C Failed to update settings.json: ${ex.message}`));
+      console.log(chalk4.dim("   Please add the plugin manually via Claude Code /plugins."));
+      return false;
+    }
+  };
+  console.log(chalk4.green(`
+Setting up Claude Code plugin...`));
+  console.log(chalk4.dim(CLAUDE_CODE_DIR));
+  const structureOk = await setClaudeCodeAssets();
+  if (structureOk === false) {
+    return;
+  }
+  const settingsOk = registerToClaudeSettings();
+  if (settingsOk === false) {
+    return;
+  }
+  configManager.claude_code = { path: CLAUDE_CODE_DIR };
+  configManager.save();
+};
+var linkRooCode = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  console.log(chalk4.green(`
+Setting up RooCode integration...`));
+  console.log(chalk4.dim(ROO_DIR));
+  const roocodeDirs = AGENT_PROMPT_DIRS["roocode" /* ROOCODE */];
+  const backupExistingRooCodeFiles = async () => {
+    try {
+      fs4.mkdirSync(ROO_DIR, { recursive: true });
+      const dirsToBackup = [];
+      for (const dir of roocodeDirs) {
+        const target = path4.join(ROO_DIR, dir);
+        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
+          dirsToBackup.push(dir);
+        }
+      }
+      if (dirsToBackup.length === 0) {
+        return true;
+      }
+      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}`));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      return false;
+    }
+  };
+  const setRooCodeAssets = async () => {
+    try {
+      const linked = [];
+      for (const dir of roocodeDirs) {
+        const src = path4.join(repoPath, dir);
+        const dest = path4.join(ROO_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 backupExistingRooCodeFiles();
+  if (backupOk === false) {
+    return;
+  }
+  const linkOk = await setRooCodeAssets();
+  if (linkOk === false) {
+    return;
+  }
+  configManager.roocode = { path: ROO_DIR, backup_path: ROO_BACKUP_DIR };
+  configManager.save();
+};
+var linkOpenclaw = async () => {
+  const repoPath = resolveRepoPath();
+  if (repoPath == null) {
+    return;
+  }
+  console.log(chalk4.green(`
+Setting up OpenClaw integration...`));
+  console.log(chalk4.dim(OPENCLAW_DIR));
+  const openclawDirs = AGENT_PROMPT_DIRS["openclaw" /* OPENCLAW */];
+  const backupExistingOpenclawFiles = async () => {
+    try {
+      fs4.mkdirSync(OPENCLAW_DIR, { recursive: true });
+      const dirsToBackup = [];
+      for (const dir of openclawDirs) {
+        const target = path4.join(OPENCLAW_DIR, dir);
+        if (fs4.existsSync(target) && fs4.lstatSync(target).isSymbolicLink() === false) {
+          dirsToBackup.push(dir);
+        }
+      }
+      if (dirsToBackup.length === 0) {
+        return true;
+      }
+      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}`));
+      }
+      return true;
+    } catch (ex) {
+      console.error(chalk4.red(`\u274C Failed to backup existing directories: ${ex.message}`));
+      return false;
+    }
+  };
+  const setOpenclawAssets = async () => {
+    try {
+      const linked = [];
+      for (const dir of openclawDirs) {
+        const src = path4.join(repoPath, dir);
+        const dest = path4.join(OPENCLAW_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 backupExistingOpenclawFiles();
+  if (backupOk === false) {
+    return;
+  }
+  const linkOk = await setOpenclawAssets();
+  if (linkOk === false) {
+    return;
+  }
+  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) {
+    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);
+    }
+    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();
+    }
+    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();
+    }
+  }
+};
+
+// 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) {
+    return;
+  }
+  try {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${claudeSettingsPath}.bak.${timestamp}`;
+    try {
+      fs5.copyFileSync(claudeSettingsPath, backupPath);
+    } catch (ex) {
+      console.warn(chalk5.yellow(`  \u26A0 Could not create backup: ${ex.message} \u2014 skipping cleanup`));
+      return;
+    }
+    const raw = fs5.readFileSync(claudeSettingsPath, "utf-8");
+    let settings;
+    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;
+      }
+      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}`];
+    }
+    try {
+      fs5.writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2), "utf-8");
+    } catch (ex) {
+      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}`));
+      }
+      throw ex;
+    }
+    try {
+      fs5.unlinkSync(backupPath);
+    } catch {
+    }
+    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}`));
+  }
+};
+var rollbackRooCode = () => {
+  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}`));
+    }
+  }
+  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;
+      }
+      fs5.renameSync(src, dest);
+      console.log(chalk5.dim(`  restored: ${dir}/`));
+    }
+    fs5.rmdirSync(backupPath);
+  } catch (ex) {
+    console.error(chalk5.red(`  \u274C Failed to restore RooCode backup: ${ex.message}`));
+  }
+};
+var rollbackOpenclaw = () => {
+  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}`));
+    }
+  }
+  if (fs5.existsSync(backupPath) === false) {
+    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;
+      }
+      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}`));
+  }
+};
+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 }
+  ].filter((t) => fs5.existsSync(t.path));
+  const hasClaudeCodeSettings = configManager.isClaudeCodeEnabled();
+  const hasRooCode = configManager.isRooCodeEnabled();
+  const hasOpenclaw = configManager.isOpenclawEnabled();
+  if (targets.length === 0 && hasClaudeCodeSettings === false && hasRooCode === false && hasOpenclaw === false) {
+    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 (hasRooCode) {
+    console.log(`  RooCode symlinks in ${chalk5.dim(ROO_DIR)} ${chalk5.dim("(backup will be restored)")}`);
+  }
+  if (hasOpenclaw) {
+    console.log(`  OpenClaw symlinks in ${chalk5.dim(OPENCLAW_DIR)} ${chalk5.dim("(backup will be restored)")}`);
+  }
+  const ok = await confirm4({ message: "Proceed?", default: false });
+  if (ok === false) {
+    console.log(chalk5.yellow("Cancelled."));
+    return;
+  }
+  if (hasClaudeCodeSettings) {
+    rollbackClaudeCode();
+  }
+  if (hasRooCode) {
+    rollbackRooCode();
+  }
+  if (hasOpenclaw) {
+    rollbackOpenclaw();
+  }
+  for (const t of targets) {
+    fs5.rmSync(t.path, { recursive: true, force: true });
+    console.log(chalk5.dim(`  removed: ${t.path}`));
+  }
+  console.log(chalk5.green("\nUninstalled."));
+};
+
+// src/commands/status-command.ts
+import chalk6 from "chalk";
+var statusCommand = () => {
+  if (configManager.repo_path == null) {
+    console.log(chalk6.yellow("\u274C No repo installed."));
+    console.log(chalk6.dim(`  Run: set-prompt install <repo-url>`));
+    return;
+  }
+  console.log(chalk6.bold("\nRepo"));
+  console.log(`${TAB}path   ${chalk6.cyan(configManager.repo_path)}`);
+  if (configManager.remote_url != null) {
+    console.log(`${TAB}remote ${chalk6.dim(configManager.remote_url)}`);
+  }
+  console.log(chalk6.bold("\nLinked agents"));
+  for (const agent of ALL_AGENTS) {
+    let linked = false;
+    let agentPath = null;
+    if (agent.value === "claudecode" /* CLAUDECODE */) {
+      linked = configManager.isClaudeCodeEnabled();
+      agentPath = configManager.claude_code?.path;
+    } else if (agent.value === "roocode" /* ROOCODE */) {
+      linked = configManager.isRooCodeEnabled();
+      agentPath = configManager.roocode?.path;
+    } else if (agent.value === "openclaw" /* OPENCLAW */) {
+      linked = configManager.isOpenclawEnabled();
+      agentPath = configManager.openclaw?.path;
+    } else if (agent.value === "codex" /* CODEX */) {
+      linked = configManager.isCodexEnabled();
+      agentPath = configManager.codex?.path;
+    } else if (agent.value === "antigravity" /* ANTIGRAVITY */) {
+      linked = configManager.isAntigravityEnabled();
+      agentPath = configManager.antigravity?.path;
+    }
+    const label = linked ? chalk6.green("linked") : chalk6.dim("not linked");
+    const pathStr = linked && agentPath ? chalk6.dim(` \u2192 ${agentPath}`) : "";
+    console.log(`${TAB}${agent.name.padEnd(12)} ${label}${pathStr}`);
+  }
+  console.log("");
+};
+
+// src/commands/update-command.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import chalk7 from "chalk";
+var updateCommand = () => {
+  const repoPath = configManager.repo_path;
+  if (repoPath == null) {
+    console.error(chalk7.red("\u274C No repo installed."));
+    console.log(chalk7.yellow("Run: set-prompt install <git-url>"));
+    return;
+  }
+  if (configManager.remote_url == null) {
+    console.error(chalk7.red("\u274C No remote URL registered. Cannot update."));
+    return;
+  }
+  console.log(chalk7.green("\nUpdating prompt repo..."));
+  console.log(chalk7.dim(repoPath));
+  const fetch = spawnSync2("git", ["fetch"], { cwd: repoPath, stdio: "inherit" });
+  if (fetch.status !== 0) {
+    console.error(chalk7.red("\u274C git fetch failed."));
+    return;
+  }
+  const pull = spawnSync2("git", ["pull"], { cwd: repoPath, stdio: "inherit" });
+  if (pull.status !== 0) {
+    console.error(chalk7.red("\u274C git pull failed."));
+    return;
+  }
+  console.log(chalk7.green("\u2705 Repo updated."));
+};
+
+// src/index.ts
+process.on("SIGINT", () => {
+  console.log(chalk8.yellow("\nCancelled."));
+  process.exit(0);
+});
+process.on("unhandledRejection", (reason) => {
+  if (reason instanceof Error && reason.name === "ExitPromptError") {
+    console.log(chalk8.yellow("\nCancelled."));
+    process.exit(0);
+  }
+  throw reason;
+});
+var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+var pkg = JSON.parse(fs6.readFileSync(path6.join(__dirname, "../package.json"), "utf-8"));
+configManager.init();
+var program = new Command();
+var banner = chalk8.cyan(figlet.textSync("Set-Prompt", { horizontalLayout: "full" }));
+program.name("set-prompt").description(pkg.description).version(pkg.version).addHelpText("beforeAll", banner + "\n").action(() => {
+  program.help();
+});
+program.command("install").description(`\u{1F4E6} Clone a ${chalk8.cyan("git repo")} into ${chalk8.dim("~/.set-prompt/repo/")} and register it as your prompt source`).argument("<url>", "remote git URL").action(async (source) => {
+  await installCommand(source);
+});
+program.command("link").description(`\u{1F517} Symlink your prompt repo into an ${chalk8.cyan("AI agent")} plugin dir ${chalk8.dim("(claudecode | roocode | openclaw | codex | antigravity)")}`).argument("[agent]", `target agent ${chalk8.dim("(omit for interactive selection)")}`).action(async (agent) => {
+  await linkCommand(agent);
+});
+program.command("scaffold").description(`\u{1F6E0}\uFE0F  Verify and create ${chalk8.cyan("required directories")} in a prompt repo ${chalk8.dim("(-f to force overwrite)")}`).argument("[path]", `path to repo ${chalk8.dim("(defaults to installed source)")}`).option("-f, --force", "overwrite existing files without prompting").action(async (localPath, options) => {
+  await scaffoldCommand(localPath, options);
+});
+program.command("status").description(`\u{1F4CB} Show registered ${chalk8.cyan("repo")} and which ${chalk8.cyan("agents")} are linked`).action(() => {
+  statusCommand();
+});
+program.command("update").description(`\u{1F504} Fetch and pull the latest changes from the ${chalk8.cyan("remote repo")}`).action(() => {
+  updateCommand();
+});
+program.command("uninstall").description(`\u{1F5D1}\uFE0F  Remove all set-prompt data ${chalk8.dim("(~/.set-prompt/, plugin dirs, settings entries)")}`).action(async () => {
+  await uninstallCommand();
+});
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map