gopeak 2.2.0 → 2.2.1

package/README.md

@@ -54,7 +54,7 @@ gopeak
 }
 ```
 
-> `GOPEAK_TOOL_PROFILE=compact` is the default. It keeps prompt/tool-list token usage low while preserving access to the full toolset via catalog discovery.
+> `GOPEAK_TOOL_PROFILE=compact` is the default. It exposes 33 core tools with 22 dynamic tool groups (78 additional tools) that activate on demand — keeping token usage low while preserving full capability.
 
 ### 3) First prompts to try
 
@@ -67,9 +67,9 @@ gopeak
 ## Why GoPeak
 
 - **Real project feedback loop**: run the game, inspect logs, and fix in-context.
-- **95+ tools available** across scene/script/resource/runtime/LSP/DAP/input/assets.
-- **Token-efficient by default**: compact tool surface for lower context overhead.
-- **Discoverability built-in**: use `tool.catalog` (alias of `tool_catalog`) to find hidden or legacy tools by keyword.
+- **110+ tools available** across scene/script/resource/runtime/LSP/DAP/input/assets.
+- **Token-efficient by default**: compact tool surface (33 tools) + dynamic tool groups. Only activate what you need — no more 110-tool context bombs.
+- **Dynamic tool groups**: search with `tool.catalog` and matching groups auto-activate. Or manually activate with `tool.groups`.
 - **Deep Godot integration**: ClassDB queries, runtime inspection, debugger hooks, bridge-based scene/resource edits.
 
 ### Best For
@@ -84,8 +84,8 @@ gopeak
 
 GoPeak supports three exposure profiles:
 
-- `compact` (default): exposes a curated alias set (about 20 core tools)
-- `full`: exposes full legacy tool list (95+)
+- `compact` (default): 33 core tools + **22 dynamic tool groups** (78 additional tools activated on demand)
+- `full`: exposes full legacy tool list (110+)
 - `legacy`: same exposed behavior as `full`
 
 Configure with either:
@@ -93,18 +93,61 @@ Configure with either:
 - `GOPEAK_TOOL_PROFILE`
 - `MCP_TOOL_PROFILE` (fallback alias)
 
-### How to discover hidden tools in compact mode
+### Dynamic Tool Groups (compact mode)
 
-Call:
+In `compact` mode, 78 additional tools are organized into **22 groups** that activate automatically when needed:
 
-- `tool.catalog` (compact alias)
-- `tool_catalog` (legacy name)
-
-Example intent:
-
-> "Use `tool.catalog` with query `animation` and show relevant tools."
+| Group | Tools | Description |
+|---|---|---|
+| `scene_advanced` | 3 | Duplicate, reparent nodes, load sprites |
+| `uid` | 2 | UID management for resources |
+| `import_export` | 5 | Import pipeline, reimport, validate project |
+| `autoload` | 4 | Autoload singletons, main scene |
+| `signal` | 2 | Disconnect signals, list connections |
+| `runtime` | 4 | Live scene inspection, runtime properties, metrics |
+| `resource` | 4 | Create/modify materials, shaders, resources |
+| `animation` | 5 | Animations, tracks, animation tree, state machine |
+| `plugin` | 3 | Enable/disable/list editor plugins |
+| `input` | 1 | Input action mapping |
+| `tilemap` | 2 | TileSet and TileMap cell painting |
+| `audio` | 4 | Audio buses, effects, volume |
+| `navigation` | 2 | Navigation regions and agents |
+| `theme_ui` | 3 | Theme colors, font sizes, shaders |
+| `asset_store` | 3 | Search/download CC0 assets |
+| `testing` | 6 | Screenshots, viewport capture, input injection |
+| `dx_tools` | 4 | Error log, project health, find usages, scaffold |
+| `intent_tracking` | 9 | Intent capture, decision logs, handoff briefs |
+| `class_advanced` | 1 | Class inheritance inspection |
+| `lsp` | 3 | GDScript completions, hover, symbols |
+| `dap` | 6 | Breakpoints, stepping, stack traces |
+| `version_gate` | 2 | Version validation, patch verification |
+
+**How it works:**
+
+1. **Auto-activation via catalog**: Search with `tool.catalog` and matching groups activate automatically.
+   > "Use `tool.catalog` with query `animation` and show relevant tools."
+
+2. **Manual activation**: Directly activate a group with `tool.groups`.
+   > "Use `tool.groups` to activate the `dap` group for debugging."
+
+3. **Deactivation**: Remove groups when done to reduce context.
+   > "Use `tool.groups` to reset all active groups."
+
+The server sends `notifications/tools/list_changed` so MCP clients (Claude Code, Claude Desktop) automatically refresh the tool list.
+
+### Don't worry about tokens
+
+GoPeak uses **cursor-based pagination** for `tools/list` — even in `full` profile, tools are delivered in pages (default 33) instead of dumping all 110+ definitions at once. Your AI client fetches the next page only when it needs more.
+
+Set page size with `GOPEAK_TOOLS_PAGE_SIZE`:
 
-This lets assistants start with a small, efficient default surface but still find and use the full capability set when needed.
+```json
+{
+  "env": {
+    "GOPEAK_TOOLS_PAGE_SIZE": "25"
+  }
+}
+```
 
 ---
 
@@ -140,9 +183,38 @@ GoPeak also exposes two CLI bin names:
 
 ---
 
+## CI
+
+GitHub Actions runs on push/PR and executes:
+
+1. `npm run build`
+2. `npx tsc --noEmit`
+3. `npm run test:ci`
+
+Run the same checks locally:
+
+```bash
+npm run ci
+```
+
+---
+
+## Versioning & Release
+
+Use the built-in bump script to keep `package.json` and `server.json` in sync:
+
+```bash
+node scripts/bump-version.mjs patch
+node scripts/bump-version.mjs minor --dry-run
+```
+
+Full release checklist: [`docs/release-process.md`](docs/release-process.md).
+
+---
+
 ## Addons (Recommended)
 
-### Auto Reload + Runtime Addon installer
+### Auto Reload + Editor Bridge + Runtime Addon installer
 
 Install in your Godot project folder:
 
@@ -156,7 +228,7 @@ PowerShell:
 iwr https://raw.githubusercontent.com/HaD0Yun/godot-mcp/main/install-addon.ps1 -UseBasicParsing | iex
 ```
 
-Then enable plugin in **Project Settings → Plugins**.
+Then enable plugins in **Project Settings → Plugins** (especially `godot_mcp_editor` for bridge-backed scene/resource tools).
 
 ---
 
@@ -207,9 +279,11 @@ Visualize your entire project architecture with `visualizer.map` (`map_project`
 - "Press `ui_accept`, move mouse to (400, 300), click, then capture a screenshot."
 - "Inspect live scene tree and report nodes with missing scripts or invalid references."
 
-### Discovery in compact mode
+### Discovery & dynamic groups
 - "Use `tool.catalog` with query `tilemap` and list the most relevant tools."
+- "Activate the `dap` tool group for breakpoint debugging with `tool.groups`."
 - "Find import pipeline tools with `tool.catalog` query `import` and run the best one for texture settings."
+- "Reset all active tool groups with `tool.groups` to reduce context."
 
 ---
 
@@ -222,23 +296,27 @@ Visualize your entire project architecture with `visualizer.map` (`map_project`
 | `GOPEAK_TOOL_PROFILE` | Tool exposure profile: `compact`, `full`, `legacy` | `compact` |
 | `MCP_TOOL_PROFILE` | Fallback profile env alias | `compact` |
 | `GODOT_PATH` | Explicit Godot executable path | auto-detect |
+| `GODOT_BRIDGE_PORT` | Bridge/Visualizer HTTP+WS port override (aliases: `MCP_BRIDGE_PORT`, `GOPEAK_BRIDGE_PORT`) | `6505` |
 | `DEBUG` | Enable server debug logs (`true`/`false`) | `false` |
 | `LOG_MODE` | Recording mode: `lite` or `full` | `lite` |
+| `GOPEAK_TOOLS_PAGE_SIZE` | Number of tools per `tools/list` page (pagination) | `33` |
+| `GOPEAK_BRIDGE_PORT` | Port for unified bridge/visualizer server | `6505` |
+| `GOPEAK_BRIDGE_HOST` | Bind host for bridge/visualizer server | `127.0.0.1` |
 
 ### Ports
 
 | Port | Service |
 |---|---|
-| `6505` | Unified Godot Bridge + Visualizer server (+ `/health`, `/mcp`) |
+| `6505` (default) | Unified Godot Bridge + Visualizer server (+ `/health`, `/mcp`) on loopback by default |
 | `6005` | Godot LSP |
 | `6006` | Godot DAP |
 | `7777` | Runtime addon command socket (only needed for runtime tools) |
 
 ### Minimal port profiles
 
-- **Core editing only**: `6505`
-- **Core + runtime actions (screenshots/input/runtime inspect)**: `6505` + `7777`
-- **Full debugging + diagnostics**: `6505` + `6005` + `6006` + `7777`
+- **Core editing only**: bridge port (`GODOT_BRIDGE_PORT`, default `6505`)
+- **Core + runtime actions (screenshots/input/runtime inspect)**: bridge port + `7777`
+- **Full debugging + diagnostics**: bridge port + `6005` + `6006` + `7777`
 
 ---
 
@@ -248,12 +326,14 @@ Visualize your entire project architecture with `visualizer.map` (`map_project`
 - **No MCP tools visible** → restart your MCP client
 - **Project path invalid** → confirm `project.godot` exists
 - **Runtime tools not working** → install/enable runtime addon plugin
-- **Need a tool that is not visible** → run `tool.catalog` and search by capability keyword
+- **Need a tool that is not visible** → run `tool.catalog` to search and auto-activate matching groups, or use `tool.groups` to activate a specific group
 
 ---
 
 ## Docs & Project Links
 
+- [Architecture (MCP Platform Direction)](docs/architecture.md)
+- [Platform Roadmap (P1/P2/P3)](docs/platform-roadmap.md)
 - [CHANGELOG](CHANGELOG.md)
 - [ROADMAP](ROADMAP.md)
 - [CONTRIBUTING](CONTRIBUTING.md)

package/build/addon/godot_mcp_editor/mcp_client.gd

@@ -60,13 +60,30 @@ func _process(_delta: float) -> void:
 				_handle_disconnect()
 
 
-func connect_to_server(url: String = DEFAULT_URL) -> void:
-	server_url = url
+func connect_to_server(url: String = "") -> void:
+	server_url = _resolve_server_url(url)
 	_should_reconnect = true
 	_current_reconnect_delay = RECONNECT_DELAY
 	_attempt_connection()
 
 
+func _resolve_server_url(explicit_url: String) -> String:
+	if explicit_url != "":
+		return explicit_url
+
+	var env_keys := ["GODOT_BRIDGE_PORT", "MCP_BRIDGE_PORT", "GOPEAK_BRIDGE_PORT"]
+	for key in env_keys:
+		var raw := OS.get_environment(key)
+		if raw == "":
+			continue
+		if raw.is_valid_int():
+			var port := int(raw)
+			if port >= 1 and port <= 65535:
+				return "ws://127.0.0.1:%d/godot" % port
+
+	return DEFAULT_URL
+
+
 func disconnect_from_server() -> void:
 	_should_reconnect = false
 	if _reconnect_timer:

package/build/cli/check.js

@@ -0,0 +1,77 @@
+/**
+ * gopeak check — Update check logic
+ *
+ * Modes:
+ *   gopeak check         Interactive: show update status
+ *   gopeak check --bg    Background: refresh cache silently, exit
+ *   gopeak check --quiet Print one-liner only if update available
+ */
+import { getLocalVersion, fetchLatestVersion, compareSemver, isCacheFresh, updateCacheTimestamp, writeNotifyFile, clearNotifyFile, ensureGopeakDir, } from './utils.js';
+export async function checkForUpdates(args) {
+    const isBg = args.includes('--bg');
+    const isQuiet = args.includes('--quiet');
+    ensureGopeakDir();
+    // Background mode: refresh cache and exit silently
+    if (isBg) {
+        await backgroundCheck();
+        return;
+    }
+    // Interactive or quiet mode: always fetch fresh
+    const currentVersion = getLocalVersion();
+    const latestVersion = await fetchLatestVersion();
+    if (!latestVersion) {
+        if (!isQuiet) {
+            console.log('⚠️  Could not reach npm registry. Check your network.');
+        }
+        return;
+    }
+    if (compareSemver(latestVersion, currentVersion) > 0) {
+        if (isQuiet) {
+            console.log(`🚀 GoPeak v${latestVersion} available! Run: npm update -g gopeak`);
+        }
+        else {
+            printUpdateBox(currentVersion, latestVersion);
+        }
+    }
+    else {
+        if (!isQuiet) {
+            console.log(`✅ GoPeak v${currentVersion} is up to date.`);
+        }
+    }
+}
+/** Background check: called by shell hook (once per day). */
+async function backgroundCheck() {
+    // Skip if cache is fresh (< 24h)
+    if (isCacheFresh()) {
+        return;
+    }
+    const currentVersion = getLocalVersion();
+    const latestVersion = await fetchLatestVersion();
+    // Update timestamp regardless of result (avoid hammering on failure)
+    updateCacheTimestamp();
+    if (!latestVersion)
+        return;
+    if (compareSemver(latestVersion, currentVersion) > 0) {
+        const msg = `🚀 GoPeak v${latestVersion} available! (current: v${currentVersion})\n   Run: npm update -g gopeak`;
+        writeNotifyFile(msg);
+    }
+    else {
+        // No update — clear stale notification if any
+        clearNotifyFile();
+    }
+}
+function printUpdateBox(current, latest) {
+    const line1 = `  🚀 GoPeak v${latest} available! (current: v${current})`;
+    const line2 = `  npm update -g gopeak`;
+    const line3 = `  https://github.com/HaD0Yun/godot-mcp/releases`;
+    const maxLen = Math.max(line1.length, line2.length, line3.length) + 2;
+    const pad = (s) => s + ' '.repeat(Math.max(0, maxLen - s.length));
+    console.log('');
+    console.log('╔' + '═'.repeat(maxLen) + '╗');
+    console.log('║' + pad(line1) + '║');
+    console.log('║' + ' '.repeat(maxLen) + '║');
+    console.log('║' + pad(line2) + '║');
+    console.log('║' + pad(line3) + '║');
+    console.log('╚' + '═'.repeat(maxLen) + '╝');
+    console.log('');
+}

package/build/cli/notify.js

@@ -0,0 +1,88 @@
+/**
+ * gopeak notify — Interactive notification shown before AI CLI tools
+ *
+ * Called by the shell hook when a notification exists.
+ * Shows update prompt (y/n) and star prompt (y/n, one-time).
+ */
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
+import { createInterface } from 'readline';
+import { NOTIFY_FILE, STAR_PROMPTED_FILE, ensureGopeakDir, commandExists, runCommand, } from './utils.js';
+const REPO_URL = 'https://github.com/HaD0Yun/godot-mcp';
+export async function showNotification() {
+    ensureGopeakDir();
+    const hasUpdate = existsSync(NOTIFY_FILE);
+    const hasStarPrompted = existsSync(STAR_PROMPTED_FILE);
+    // Nothing to show → exit silently (fast path)
+    if (!hasUpdate && hasStarPrompted) {
+        return;
+    }
+    // --- Update notification ---
+    if (hasUpdate) {
+        const updateInfo = readFileSync(NOTIFY_FILE, 'utf-8').trim();
+        console.log('');
+        console.log(`  ${updateInfo}`);
+        console.log('');
+        const wantsUpdate = await askYesNo('  Update now? (y/n): ');
+        if (wantsUpdate) {
+            console.log('  Updating...');
+            const result = await runCommand('npm update -g gopeak');
+            if (result.code === 0) {
+                console.log('  ✅ Updated successfully!');
+            }
+            else {
+                console.log('  ⚠️  Update failed. Run manually: npm update -g gopeak');
+            }
+        }
+        // Remove notify file (shown once)
+        try {
+            unlinkSync(NOTIFY_FILE);
+        }
+        catch { /* ignore */ }
+        console.log('');
+    }
+    // --- Star prompt (one-time) ---
+    if (!hasStarPrompted) {
+        await askYesNo('  \u2b50 Star GoPeak on GitHub? (y/n): ');
+        // Star regardless of answer
+        await handleStar();
+        writeFileSync(STAR_PROMPTED_FILE, new Date().toISOString());
+        console.log('');
+    }
+}
+async function handleStar() {
+    const hasGh = await commandExists('gh');
+    if (!hasGh) {
+        console.log(`  ℹ️  gh CLI not installed. Star directly: ${REPO_URL}`);
+        return;
+    }
+    const authResult = await runCommand('gh auth status');
+    if (authResult.code !== 0) {
+        console.log(`  ℹ️  gh not authenticated. Star directly: ${REPO_URL}`);
+        return;
+    }
+    // Check if already starred
+    const checkResult = await runCommand('gh api user/starred/HaD0Yun/godot-mcp');
+    if (checkResult.code === 0) {
+        console.log('  ⭐ Already starred! Thank you!');
+        return;
+    }
+    const starResult = await runCommand('gh api -X PUT user/starred/HaD0Yun/godot-mcp');
+    if (starResult.code === 0) {
+        console.log('  ⭐ Starred! Thank you for your support!');
+    }
+    else {
+        console.log(`  ⚠️  Could not star automatically. Star directly: ${REPO_URL}`);
+    }
+}
+function askYesNo(prompt) {
+    return new Promise((resolve) => {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}

package/build/cli/setup.js

@@ -0,0 +1,115 @@
+/**
+ * gopeak setup — Install shell hooks into ~/.bashrc or ~/.zshrc
+ *
+ * Wraps AI CLI tools (claude, codex, gemini, opencode, omc, omx)
+ * with a precheck function that displays cached GoPeak update notifications.
+ */
+import { existsSync, readFileSync, writeFileSync, appendFileSync } from 'fs';
+import { getShellRcFile, getShellName, getLocalVersion, ensureGopeakDir, ONBOARDING_SHOWN_FILE, STAR_PROMPTED_FILE, } from './utils.js';
+const MARKER_START = '# >>> GoPeak shell hooks >>>';
+const MARKER_END = '# <<< GoPeak shell hooks <<<';
+/** The shell hook block that gets appended to the RC file. */
+function generateHookBlock() {
+    // Target commands (excluding omx — handled separately)
+    const targetList = 'claude codex gemini opencode omc';
+    const lines = [
+        MARKER_START,
+        '# GoPeak update notifications for AI CLI tools',
+        '# Installed by: gopeak setup | Remove with: gopeak uninstall',
+        '',
+        '__gopeak_precheck() {',
+        '  local notify="$HOME/.gopeak/notify"',
+        '  local star="$HOME/.gopeak/star-prompted"',
+        '  # If notification exists or star not yet prompted → interactive prompt',
+        '  if [ -f "$notify" ] || [ ! -f "$star" ]; then',
+        '    command -v gopeak &>/dev/null && gopeak notify',
+        '  fi',
+        '  # Background refresh for next time',
+        '  local ts="$HOME/.gopeak/last-check"',
+        '  if [ -f "$ts" ]; then',
+        '    local age=$(( $(date +%s) - $(cat "$ts") ))',
+        '    [ "$age" -lt 86400 ] && return',
+        '  fi',
+        '  command -v gopeak &>/dev/null && gopeak check --bg &>/dev/null & disown &>/dev/null',
+        '}',
+        '',
+        '# Wrap AI CLI tools: precheck \u2192 original command',
+        `for __gopeak_cmd in ${targetList}; do`,
+        '  if command -v "$__gopeak_cmd" &>/dev/null && ! declare -f "$__gopeak_cmd" &>/dev/null; then',
+        '    eval "${__gopeak_cmd}() { __gopeak_precheck; command ${__gopeak_cmd} \\"\\$@\\"; }"',
+        '  fi',
+        'done',
+        '',
+        '# omx: preserve existing function (e.g. --no-alt-screen wrapper)',
+        'if declare -f omx &>/dev/null; then',
+        '  eval "__gopeak_orig_omx() $(declare -f omx | sed \'1d\')"',
+        '  omx() { __gopeak_precheck; __gopeak_orig_omx "$@"; }',
+        'elif command -v omx &>/dev/null; then',
+        '  omx() { __gopeak_precheck; command omx "$@"; }',
+        'fi',
+        '',
+        'unset __gopeak_cmd',
+        MARKER_END,
+    ];
+    return lines.join('\n');
+}
+export async function setupShellHooks() {
+    const rcFile = getShellRcFile();
+    const shellName = getShellName();
+    // Check if RC file exists
+    if (!existsSync(rcFile)) {
+        console.log(`⚠️  ${rcFile} not found. Creating it.`);
+        writeFileSync(rcFile, '');
+    }
+    const content = readFileSync(rcFile, 'utf-8');
+    // Check if already installed
+    if (content.includes(MARKER_START)) {
+        // Replace existing block
+        const cleaned = removeHookBlock(content);
+        const hookBlock = generateHookBlock();
+        writeFileSync(rcFile, cleaned + '\n' + hookBlock + '\n');
+        console.log(`🔄 GoPeak shell hooks updated in ${rcFile}`);
+    }
+    else {
+        // Append new block
+        const hookBlock = generateHookBlock();
+        appendFileSync(rcFile, '\n' + hookBlock + '\n');
+        console.log(`✅ GoPeak shell hooks installed in ${rcFile}`);
+    }
+    console.log(`   Reload with: source ${rcFile}`);
+    console.log('');
+    // Show onboarding (once)
+    ensureGopeakDir();
+    if (!existsSync(ONBOARDING_SHOWN_FILE)) {
+        printOnboarding();
+        writeFileSync(ONBOARDING_SHOWN_FILE, new Date().toISOString());
+    }
+    // Suggest star (once)
+    if (!existsSync(STAR_PROMPTED_FILE)) {
+        console.log('⭐ If GoPeak helps your Godot workflow, please star us!');
+        console.log('   Run: gopeak star');
+        console.log('');
+    }
+}
+function removeHookBlock(content) {
+    const regex = new RegExp(`\\n?${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\n?`, 'g');
+    return content.replace(regex, '');
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function printOnboarding() {
+    const version = getLocalVersion();
+    console.log('╔══════════════════════════════════════════════════════╗');
+    console.log(`║  🎮 GoPeak v${version} — AI-Powered Godot Development`
+        + ' '.repeat(Math.max(0, 39 - version.length)) + '║');
+    console.log('║                                                      ║');
+    console.log('║  110+ tools for Godot Engine via MCP                 ║');
+    console.log('║                                                      ║');
+    console.log('║  📖 Docs:   https://github.com/HaD0Yun/godot-mcp   ║');
+    console.log('║  ⭐ Star:   gopeak star                              ║');
+    console.log('║  🔄 Update: npm update -g gopeak                     ║');
+    console.log('╚══════════════════════════════════════════════════════╝');
+    console.log('');
+}
+export { MARKER_START, MARKER_END };

package/build/cli/star.js

@@ -0,0 +1,51 @@
+/**
+ * gopeak star — GitHub star feature
+ *
+ * If gh CLI is installed and authenticated: auto-star.
+ * If not: print a friendly message with the URL.
+ * Never asks the user to install gh.
+ */
+import { commandExists, runCommand, STAR_PROMPTED_FILE, ensureGopeakDir } from './utils.js';
+import { existsSync, writeFileSync } from 'fs';
+const REPO = 'HaD0Yun/godot-mcp';
+const REPO_URL = `https://github.com/${REPO}`;
+export async function starGoPeak() {
+    // 1. Check if gh CLI exists
+    const hasGh = await commandExists('gh');
+    if (!hasGh) {
+        console.log(`ℹ️  gh CLI is not installed.`);
+        console.log(`   Please star GoPeak directly: ${REPO_URL}`);
+        markStarPrompted();
+        return;
+    }
+    // 2. Check gh authentication
+    const authResult = await runCommand('gh auth status');
+    if (authResult.code !== 0) {
+        console.log(`ℹ️  gh CLI is not authenticated.`);
+        console.log(`   Please star GoPeak directly: ${REPO_URL}`);
+        markStarPrompted();
+        return;
+    }
+    // 3. Check if already starred (REST: 204=starred, 404=not starred)
+    const checkResult = await runCommand(`gh api user/starred/${REPO}`);
+    if (checkResult.code === 0) {
+        console.log(`⭐ You've already starred GoPeak! Thank you!`);
+        markStarPrompted();
+        return;
+    }
+    // 4. Star it (PUT user/starred/:owner/:repo)
+    const starResult = await runCommand(`gh api -X PUT user/starred/${REPO}`);
+    if (starResult.code === 0) {
+        console.log(`⭐ Starred GoPeak! Thank you for your support!`);
+    }
+    else {
+        console.log(`⚠️  Could not star automatically. Please star directly: ${REPO_URL}`);
+    }
+    markStarPrompted();
+}
+function markStarPrompted() {
+    ensureGopeakDir();
+    if (!existsSync(STAR_PROMPTED_FILE)) {
+        writeFileSync(STAR_PROMPTED_FILE, new Date().toISOString());
+    }
+}

package/build/cli/uninstall.js

@@ -0,0 +1,26 @@
+/**
+ * gopeak uninstall — Remove shell hooks from RC file
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { getShellRcFile } from './utils.js';
+import { MARKER_START, MARKER_END } from './setup.js';
+export async function uninstallHooks() {
+    const rcFile = getShellRcFile();
+    if (!existsSync(rcFile)) {
+        console.log(`ℹ️  ${rcFile} not found. Nothing to remove.`);
+        return;
+    }
+    const content = readFileSync(rcFile, 'utf-8');
+    if (!content.includes(MARKER_START)) {
+        console.log('ℹ️  GoPeak shell hooks are not installed. Nothing to remove.');
+        return;
+    }
+    const regex = new RegExp(`\\n?${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\n?`, 'g');
+    const cleaned = content.replace(regex, '');
+    writeFileSync(rcFile, cleaned);
+    console.log(`✅ GoPeak shell hooks removed from ${rcFile}`);
+    console.log(`   Reload with: source ${rcFile}`);
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}