gopeak 2.1.0 → 2.2.1

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, '\\$&');
+}

package/build/cli/utils.js

@@ -0,0 +1,149 @@
+/**
+ * GoPeak CLI Utilities
+ * Shared helpers for version checking, caching, and shell detection.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import { get as httpsGet } from 'https';
+const execAsync = promisify(exec);
+/* ------------------------------------------------------------------ */
+/*  Paths                                                              */
+/* ------------------------------------------------------------------ */
+const GOPEAK_DIR = join(homedir(), '.gopeak');
+const LAST_CHECK_FILE = join(GOPEAK_DIR, 'last-check');
+const NOTIFY_FILE = join(GOPEAK_DIR, 'notify');
+const ONBOARDING_SHOWN_FILE = join(GOPEAK_DIR, 'onboarding-shown');
+const STAR_PROMPTED_FILE = join(GOPEAK_DIR, 'star-prompted');
+export { GOPEAK_DIR, LAST_CHECK_FILE, NOTIFY_FILE, ONBOARDING_SHOWN_FILE, STAR_PROMPTED_FILE };
+export function ensureGopeakDir() {
+    if (!existsSync(GOPEAK_DIR)) {
+        mkdirSync(GOPEAK_DIR, { recursive: true });
+    }
+}
+/* ------------------------------------------------------------------ */
+/*  Version                                                            */
+/* ------------------------------------------------------------------ */
+export function getLocalVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Walk up from build/cli/utils.js → project root
+        const pkgPath = join(__dirname, '..', '..', 'package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+/** Fetch latest version from npm registry (no dependencies). */
+export function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        const url = 'https://registry.npmjs.org/gopeak/latest';
+        const timeout = setTimeout(() => resolve(null), 5000);
+        httpsGet(url, (res) => {
+            let data = '';
+            res.on('data', (chunk) => { data += chunk; });
+            res.on('end', () => {
+                clearTimeout(timeout);
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version ?? null);
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+            res.on('error', () => { clearTimeout(timeout); resolve(null); });
+        }).on('error', () => { clearTimeout(timeout); resolve(null); });
+    });
+}
+/** Compare two semver strings. Returns 1 if a > b, -1 if a < b, 0 if equal. */
+export function compareSemver(a, b) {
+    const pa = a.replace(/^v/, '').split('.').map(Number);
+    const pb = b.replace(/^v/, '').split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const na = pa[i] ?? 0;
+        const nb = pb[i] ?? 0;
+        if (na > nb)
+            return 1;
+        if (na < nb)
+            return -1;
+    }
+    return 0;
+}
+/* ------------------------------------------------------------------ */
+/*  Cache                                                              */
+/* ------------------------------------------------------------------ */
+/** Check if the last update check was less than `maxAgeSeconds` ago. */
+export function isCacheFresh(maxAgeSeconds = 86400) {
+    try {
+        if (!existsSync(LAST_CHECK_FILE))
+            return false;
+        const ts = parseInt(readFileSync(LAST_CHECK_FILE, 'utf-8').trim(), 10);
+        return (Date.now() / 1000 - ts) < maxAgeSeconds;
+    }
+    catch {
+        return false;
+    }
+}
+export function updateCacheTimestamp() {
+    ensureGopeakDir();
+    writeFileSync(LAST_CHECK_FILE, String(Math.floor(Date.now() / 1000)));
+}
+export function writeNotifyFile(message) {
+    ensureGopeakDir();
+    writeFileSync(NOTIFY_FILE, message);
+}
+export function clearNotifyFile() {
+    try {
+        if (existsSync(NOTIFY_FILE))
+            unlinkSync(NOTIFY_FILE);
+    }
+    catch { /* ignore */ }
+}
+/* ------------------------------------------------------------------ */
+/*  Shell detection                                                    */
+/* ------------------------------------------------------------------ */
+export function getShellRcFile() {
+    const shell = process.env.SHELL ?? '';
+    if (shell.includes('zsh'))
+        return join(homedir(), '.zshrc');
+    return join(homedir(), '.bashrc');
+}
+export function getShellName() {
+    const shell = process.env.SHELL ?? '';
+    if (shell.includes('zsh'))
+        return 'zsh';
+    return 'bash';
+}
+/* ------------------------------------------------------------------ */
+/*  Command helpers                                                    */
+/* ------------------------------------------------------------------ */
+export async function commandExists(cmd) {
+    try {
+        await execAsync(`command -v ${cmd}`);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runCommand(cmd) {
+    try {
+        const { stdout, stderr } = await execAsync(cmd);
+        return { stdout: stdout.trim(), stderr: stderr.trim(), code: 0 };
+    }
+    catch (err) {
+        return {
+            stdout: (err.stdout ?? '').trim(),
+            stderr: (err.stderr ?? '').trim(),
+            code: err.code ?? 1,
+        };
+    }
+}

package/build/cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * GoPeak CLI Entrypoint
+ *
+ * Routes subcommands or falls through to the MCP server.
+ *
+ *   gopeak              → Start MCP server (default, backward-compatible)
+ *   gopeak setup        → Install shell hooks
+ *   gopeak check        → Check for updates
+ *   gopeak star         → Star on GitHub
+ *   gopeak uninstall    → Remove shell hooks
+ *   gopeak version      → Print version
+ *   gopeak help         → Show help
+ */
+import { getLocalVersion } from './cli/utils.js';
+const args = process.argv.slice(2);
+const command = args[0];
+const CLI_COMMANDS = ['setup', 'check', 'star', 'notify', 'uninstall', 'version', 'help', '--version', '-v', '--help', '-h'];
+async function main() {
+    // If no args or not a CLI command → start MCP server (original behavior)
+    if (!command || !CLI_COMMANDS.includes(command)) {
+        // Dynamic import to avoid loading MCP SDK for CLI-only commands
+        await import('./index.js');
+        return;
+    }
+    switch (command) {
+        case 'setup': {
+            const { setupShellHooks } = await import('./cli/setup.js');
+            await setupShellHooks();
+            break;
+        }
+        case 'check': {
+            const { checkForUpdates } = await import('./cli/check.js');
+            await checkForUpdates(args.slice(1));
+            break;
+        }
+        case 'star': {
+            const { starGoPeak } = await import('./cli/star.js');
+            await starGoPeak();
+            break;
+        }
+        case 'notify': {
+            const { showNotification } = await import('./cli/notify.js');
+            await showNotification();
+            break;
+        }
+        case 'uninstall': {
+            const { uninstallHooks } = await import('./cli/uninstall.js');
+            await uninstallHooks();
+            break;
+        }
+        case 'version':
+        case '--version':
+        case '-v': {
+            console.log(`gopeak v${getLocalVersion()}`);
+            break;
+        }
+        case 'help':
+        case '--help':
+        case '-h': {
+            printHelp();
+            break;
+        }
+    }
+}
+function printHelp() {
+    const version = getLocalVersion();
+    console.log(`
+GoPeak v${version} — AI-Powered Godot Development via MCP
+
+Usage:
+  gopeak                Start MCP server (default)
+  gopeak setup          Install shell hooks for update notifications
+  gopeak check          Check for GoPeak updates
+  gopeak check --bg     Background check (used by shell hooks)
+  gopeak check --quiet  Print only if update available
+  gopeak star           Star GoPeak on GitHub
+  gopeak uninstall      Remove shell hooks
+  gopeak version        Show current version
+  gopeak help           Show this help
+
+Shell hooks wrap these commands with update notifications:
+  claude, codex, gemini, opencode, omc, omx
+
+More info: https://github.com/HaD0Yun/godot-mcp
+`.trim());
+}
+main().catch((err) => {
+    console.error('gopeak:', err.message ?? err);
+    process.exit(1);
+});