@colmbus72/yeehaw 0.1.0

package/dist/lib/github.d.ts

@@ -0,0 +1,43 @@
+export interface GitHubIssue {
+    number: number;
+    title: string;
+    state: 'open' | 'closed';
+    author: string;
+    labels: string[];
+    createdAt: string;
+    updatedAt: string;
+    commentsCount: number;
+    body: string | null;
+    url: string;
+}
+export interface GitHubRepo {
+    owner: string;
+    repo: string;
+}
+/**
+ * Parse a GitHub URL to extract owner and repo.
+ * Handles formats like:
+ * - https://github.com/owner/repo
+ * - https://github.com/owner/repo.git
+ * - git@github.com:owner/repo.git
+ */
+export declare function parseGitHubUrl(url: string): GitHubRepo | null;
+/**
+ * Check if gh CLI is installed and authenticated.
+ */
+export declare function isGhCliAvailable(): boolean;
+/**
+ * Fetch issues for a GitHub repository using gh CLI.
+ */
+export declare function fetchGitHubIssues(owner: string, repo: string, options?: {
+    state?: 'open' | 'closed' | 'all';
+    limit?: number;
+}): GitHubIssue[];
+/**
+ * Fetch a single issue with full details.
+ */
+export declare function fetchGitHubIssue(owner: string, repo: string, issueNumber: number): GitHubIssue | null;
+/**
+ * Open an issue in the default browser.
+ */
+export declare function openIssueInBrowser(url: string): void;

package/dist/lib/github.js

@@ -0,0 +1,111 @@
+import { execaSync } from 'execa';
+/**
+ * Parse a GitHub URL to extract owner and repo.
+ * Handles formats like:
+ * - https://github.com/owner/repo
+ * - https://github.com/owner/repo.git
+ * - git@github.com:owner/repo.git
+ */
+export function parseGitHubUrl(url) {
+    // HTTPS format
+    const httpsMatch = url.match(/github\.com\/([^/]+)\/([^/.\s]+)/);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], repo: httpsMatch[2].replace(/\.git$/, '') };
+    }
+    // SSH format
+    const sshMatch = url.match(/github\.com:([^/]+)\/([^/.\s]+)/);
+    if (sshMatch) {
+        return { owner: sshMatch[1], repo: sshMatch[2].replace(/\.git$/, '') };
+    }
+    return null;
+}
+/**
+ * Check if gh CLI is installed and authenticated.
+ */
+export function isGhCliAvailable() {
+    try {
+        execaSync('gh', ['auth', 'status']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Fetch issues for a GitHub repository using gh CLI.
+ */
+export function fetchGitHubIssues(owner, repo, options = {}) {
+    const { state = 'open', limit = 50 } = options;
+    try {
+        const result = execaSync('gh', [
+            'issue', 'list',
+            '--repo', `${owner}/${repo}`,
+            '--state', state,
+            '--limit', String(limit),
+            '--json', 'number,title,state,author,labels,createdAt,updatedAt,comments,body,url',
+        ]);
+        const issues = JSON.parse(result.stdout);
+        return issues.map((issue) => ({
+            number: issue.number,
+            title: issue.title,
+            state: issue.state.toLowerCase(),
+            author: issue.author.login,
+            labels: issue.labels.map((l) => l.name),
+            createdAt: issue.createdAt,
+            updatedAt: issue.updatedAt,
+            commentsCount: issue.comments.length,
+            body: issue.body || null,
+            url: issue.url,
+        }));
+    }
+    catch (err) {
+        console.error('[github] Failed to fetch issues:', err);
+        return [];
+    }
+}
+/**
+ * Fetch a single issue with full details.
+ */
+export function fetchGitHubIssue(owner, repo, issueNumber) {
+    try {
+        const result = execaSync('gh', [
+            'issue', 'view', String(issueNumber),
+            '--repo', `${owner}/${repo}`,
+            '--json', 'number,title,state,author,labels,createdAt,updatedAt,comments,body,url',
+        ]);
+        const issue = JSON.parse(result.stdout);
+        return {
+            number: issue.number,
+            title: issue.title,
+            state: issue.state.toLowerCase(),
+            author: issue.author.login,
+            labels: issue.labels.map((l) => l.name),
+            createdAt: issue.createdAt,
+            updatedAt: issue.updatedAt,
+            commentsCount: issue.comments.length,
+            body: issue.body || null,
+            url: issue.url,
+        };
+    }
+    catch (err) {
+        console.error('[github] Failed to fetch issue:', err);
+        return null;
+    }
+}
+/**
+ * Open an issue in the default browser.
+ */
+export function openIssueInBrowser(url) {
+    try {
+        execaSync('open', [url]);
+    }
+    catch {
+        // Fallback for Linux
+        try {
+            execaSync('xdg-open', [url]);
+        }
+        catch {
+            // Ignore if can't open
+        }
+    }
+}

package/dist/lib/hotkeys.d.ts

@@ -0,0 +1,27 @@
+export type HotkeyScope = 'global' | 'global-dashboard' | 'project-context' | 'barn-context' | 'wiki-view' | 'issues-view' | 'livestock-detail' | 'logs-view' | 'night-sky' | 'list' | 'content';
+export type HotkeyCategory = 'navigation' | 'action' | 'system';
+export interface Hotkey {
+    key: string;
+    description: string;
+    category: HotkeyCategory;
+    scopes: HotkeyScope[];
+    panel?: string;
+}
+export declare const HOTKEYS: Hotkey[];
+/**
+ * Get hotkeys for a specific view and optional panel focus
+ */
+export declare function getHotkeysForContext(scope: HotkeyScope, focusedPanel?: string, includeGlobal?: boolean): Hotkey[];
+/**
+ * Get hotkeys formatted for the help overlay (grouped by category)
+ */
+export declare function getHotkeysGrouped(scope: HotkeyScope, focusedPanel?: string): {
+    navigation: Hotkey[];
+    action: Hotkey[];
+    system: Hotkey[];
+};
+/**
+ * Format hotkeys as a single-line hint string
+ * Example: "[n] new  [e] edit  [d] delete  [q] back"
+ */
+export declare function formatHotkeyHints(scope: HotkeyScope, focusedPanel?: string, maxKeys?: number): string;

package/dist/lib/hotkeys.js

@@ -0,0 +1,92 @@
+// src/lib/hotkeys.ts
+export const HOTKEYS = [
+    // === GLOBAL (everywhere) ===
+    { key: '?', description: 'Toggle help', category: 'system', scopes: ['global'] },
+    { key: 'q', description: 'Back / Detach', category: 'system', scopes: ['global'] },
+    { key: 'Esc', description: 'Back / Cancel', category: 'system', scopes: ['global'] },
+    // === LIST NAVIGATION (any focused list) ===
+    { key: 'j/k', description: 'Navigate up/down', category: 'navigation', scopes: ['list'] },
+    { key: 'g/G', description: 'Go to first/last', category: 'navigation', scopes: ['list'] },
+    { key: 'Enter', description: 'Select item', category: 'navigation', scopes: ['list'] },
+    // === CONTENT NAVIGATION (markdown panels) ===
+    { key: 'j/k', description: 'Scroll up/down', category: 'navigation', scopes: ['content'] },
+    { key: 'g/G', description: 'Jump to top/bottom', category: 'navigation', scopes: ['content'] },
+    { key: 'PgUp/PgDn', description: 'Scroll page', category: 'navigation', scopes: ['content'] },
+    // === GLOBAL DASHBOARD ===
+    { key: 'Tab', description: 'Switch panel', category: 'navigation', scopes: ['global-dashboard', 'project-context', 'barn-context', 'wiki-view', 'issues-view'] },
+    { key: 'Q', description: 'Quit Yeehaw', category: 'system', scopes: ['global-dashboard'] },
+    { key: 'c', description: 'New Claude session', category: 'action', scopes: ['global-dashboard', 'project-context'] },
+    { key: '1-9', description: 'Quick switch window', category: 'action', scopes: ['global-dashboard', 'project-context'] },
+    { key: 's', description: 'Open shell session', category: 'action', scopes: ['global-dashboard', 'project-context', 'barn-context', 'livestock-detail'], panel: 'barns' },
+    // === CONTEXT-AWARE ACTIONS ===
+    { key: 'n', description: 'New (in focused panel)', category: 'action', scopes: ['global-dashboard', 'project-context', 'barn-context', 'wiki-view'] },
+    { key: 'e', description: 'Edit selected', category: 'action', scopes: ['project-context', 'barn-context', 'wiki-view'] },
+    { key: 'd', description: 'Delete (with confirm)', category: 'action', scopes: ['project-context', 'barn-context', 'wiki-view'] },
+    { key: 'D', description: 'Delete container (type name)', category: 'action', scopes: ['project-context', 'barn-context'] },
+    // === PROJECT CONTEXT ===
+    { key: 'w', description: 'Open wiki', category: 'action', scopes: ['project-context'] },
+    { key: 'i', description: 'Open issues', category: 'action', scopes: ['project-context'] },
+    // === ISSUES VIEW ===
+    { key: 'r', description: 'Refresh issues', category: 'action', scopes: ['issues-view'] },
+    { key: 'o', description: 'Open in browser', category: 'action', scopes: ['issues-view'] },
+    // === LIVESTOCK DETAIL ===
+    { key: 'l', description: 'View logs', category: 'action', scopes: ['livestock-detail'] },
+    // === LOGS VIEW ===
+    { key: 'r', description: 'Refresh logs', category: 'action', scopes: ['logs-view'] },
+    // === NIGHT SKY (screensaver) ===
+    { key: 'v', description: 'Visualizer', category: 'navigation', scopes: ['global-dashboard'] },
+    { key: 'c', description: 'Spawn cloud', category: 'action', scopes: ['night-sky'] },
+    { key: 'r', description: 'Randomize', category: 'action', scopes: ['night-sky'] },
+];
+/**
+ * Get hotkeys for a specific view and optional panel focus
+ */
+export function getHotkeysForContext(scope, focusedPanel, includeGlobal = true) {
+    return HOTKEYS.filter((h) => {
+        // Include if scope matches
+        const scopeMatch = h.scopes.includes(scope) ||
+            (includeGlobal && h.scopes.includes('global'));
+        // If hotkey has panel requirement, check it
+        if (h.panel && focusedPanel && h.panel !== focusedPanel) {
+            return false;
+        }
+        return scopeMatch;
+    });
+}
+/**
+ * Get hotkeys formatted for the help overlay (grouped by category)
+ */
+export function getHotkeysGrouped(scope, focusedPanel) {
+    const hotkeys = getHotkeysForContext(scope, focusedPanel);
+    return {
+        navigation: hotkeys.filter((h) => h.category === 'navigation'),
+        action: hotkeys.filter((h) => h.category === 'action'),
+        system: hotkeys.filter((h) => h.category === 'system'),
+    };
+}
+/**
+ * Format hotkeys as a single-line hint string
+ * Example: "[n] new  [e] edit  [d] delete  [q] back"
+ */
+export function formatHotkeyHints(scope, focusedPanel, maxKeys = 6) {
+    const hotkeys = getHotkeysForContext(scope, focusedPanel, true);
+    // Prioritize: actions first, then navigation, then system (except always include q)
+    const prioritized = [
+        ...hotkeys.filter((h) => h.category === 'action'),
+        ...hotkeys.filter((h) => h.category === 'navigation'),
+        ...hotkeys.filter((h) => h.category === 'system' && h.key !== 'q' && h.key !== '?'),
+        ...hotkeys.filter((h) => h.key === 'q' || h.key === '?'),
+    ];
+    // Dedupe by key
+    const seen = new Set();
+    const unique = prioritized.filter((h) => {
+        if (seen.has(h.key))
+            return false;
+        seen.add(h.key);
+        return true;
+    });
+    return unique
+        .slice(0, maxKeys)
+        .map((h) => `[${h.key}] ${h.description.toLowerCase()}`)
+        .join('  ');
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,10 @@
+export * from './paths.js';
+export * from './config.js';
+export * from './tmux.js';
+export * from './git.js';
+export * from './livestock.js';
+export * from './hotkeys.js';
+export * from './shell.js';
+export * from './errors.js';
+export * from './mcp-validation.js';
+export * from './detection.js';

package/dist/lib/index.js

@@ -0,0 +1,10 @@
+export * from './paths.js';
+export * from './config.js';
+export * from './tmux.js';
+export * from './git.js';
+export * from './livestock.js';
+export * from './hotkeys.js';
+export * from './shell.js';
+export * from './errors.js';
+export * from './mcp-validation.js';
+export * from './detection.js';

package/dist/lib/livestock.d.ts

@@ -0,0 +1,51 @@
+import type { Livestock, Barn } from '../types.js';
+/**
+ * Resolve a relative path within a livestock to an absolute path.
+ * For local livestock, returns the local absolute path.
+ * For remote livestock, returns the remote absolute path (for use with SSH).
+ */
+export declare function resolveLivestockPath(livestock: Livestock, relativePath: string): string;
+/**
+ * Build SSH command prefix for a barn
+ */
+export declare function buildSshCommand(barn: Barn): string[];
+/**
+ * Read a file from livestock (local or remote via SSH)
+ */
+export declare function readLivestockFile(livestock: Livestock, relativePath: string): Promise<{
+    content: string;
+    error?: string;
+}>;
+/**
+ * Read log files from livestock with filtering options
+ */
+export declare function readLivestockLogs(livestock: Livestock, options?: {
+    lines?: number;
+    pattern?: string;
+}): Promise<{
+    content: string;
+    error?: string;
+}>;
+/**
+ * Parse .env file content into key-value pairs
+ */
+export declare function parseEnvFile(content: string): Record<string, string>;
+/**
+ * Read env file from livestock, optionally hiding values
+ */
+export declare function readLivestockEnv(livestock: Livestock, showValues?: boolean): Promise<{
+    content: string;
+    error?: string;
+}>;
+/**
+ * Detected framework configuration suggestions
+ */
+export interface DetectedConfig {
+    framework?: 'laravel' | 'django' | 'rails' | 'node' | 'unknown';
+    log_path?: string;
+    env_path?: string;
+}
+/**
+ * Detect framework and suggest log_path/env_path based on project structure
+ */
+export declare function detectLivestockConfig(path: string, barn?: Barn): Promise<DetectedConfig>;

package/dist/lib/livestock.js

@@ -0,0 +1,233 @@
+import { join, isAbsolute } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { execa } from 'execa';
+import { loadBarn } from './config.js';
+import { shellEscape } from './shell.js';
+import { getErrorMessage } from './errors.js';
+/**
+ * Resolve a relative path within a livestock to an absolute path.
+ * For local livestock, returns the local absolute path.
+ * For remote livestock, returns the remote absolute path (for use with SSH).
+ */
+export function resolveLivestockPath(livestock, relativePath) {
+    if (isAbsolute(relativePath)) {
+        return relativePath;
+    }
+    return join(livestock.path, relativePath);
+}
+/**
+ * Build SSH command prefix for a barn
+ */
+export function buildSshCommand(barn) {
+    const args = ['ssh'];
+    if (barn.port && barn.port !== 22) {
+        args.push('-p', String(barn.port));
+    }
+    if (barn.identity_file) {
+        args.push('-i', barn.identity_file);
+    }
+    args.push(`${barn.user}@${barn.host}`);
+    return args;
+}
+/**
+ * Read a file from livestock (local or remote via SSH)
+ */
+export async function readLivestockFile(livestock, relativePath) {
+    const fullPath = resolveLivestockPath(livestock, relativePath);
+    // Local livestock
+    if (!livestock.barn) {
+        try {
+            if (!existsSync(fullPath)) {
+                return { content: '', error: `File not found: ${fullPath}` };
+            }
+            const content = readFileSync(fullPath, 'utf-8');
+            return { content };
+        }
+        catch (err) {
+            return { content: '', error: `Failed to read file: ${err}` };
+        }
+    }
+    // Remote livestock - SSH to barn
+    const barn = loadBarn(livestock.barn);
+    if (!barn) {
+        return { content: '', error: `Barn not found: ${livestock.barn}` };
+    }
+    if (!barn.host || !barn.user) {
+        return { content: '', error: `Barn '${barn.name}' is not configured for SSH` };
+    }
+    try {
+        const sshArgs = buildSshCommand(barn);
+        // Use shellEscape for the path to prevent injection
+        const result = await execa(sshArgs[0], [...sshArgs.slice(1), `cat ${shellEscape(fullPath)}`]);
+        return { content: result.stdout };
+    }
+    catch (err) {
+        return { content: '', error: `SSH error: ${getErrorMessage(err)}` };
+    }
+}
+/**
+ * Read log files from livestock with filtering options
+ */
+export async function readLivestockLogs(livestock, options = {}) {
+    if (!livestock.log_path) {
+        return { content: '', error: 'log_path not configured for this livestock' };
+    }
+    const { lines = 100, pattern } = options;
+    const logPath = resolveLivestockPath(livestock, livestock.log_path);
+    // Build the command with proper escaping
+    let cmd;
+    const escapedLogPath = shellEscape(logPath);
+    const escapedLines = String(lines); // lines is a number, safe
+    if (pattern) {
+        // Escape the grep pattern for shell
+        const escapedPattern = shellEscape(pattern);
+        // grep with tail
+        cmd = `find ${escapedLogPath} -name '*.log' -type f 2>/dev/null | xargs tail -n ${escapedLines} 2>/dev/null | grep -i ${escapedPattern} || true`;
+    }
+    else {
+        // Just tail the logs
+        cmd = `find ${escapedLogPath} -name '*.log' -type f 2>/dev/null | xargs tail -n ${escapedLines} 2>/dev/null || true`;
+    }
+    // Local livestock
+    if (!livestock.barn) {
+        try {
+            const result = await execa('sh', ['-c', cmd]);
+            if (!result.stdout.trim()) {
+                return { content: '', error: `No log files found in ${logPath}` };
+            }
+            return { content: result.stdout };
+        }
+        catch (err) {
+            return { content: '', error: `Failed to read logs: ${getErrorMessage(err)}` };
+        }
+    }
+    // Remote livestock - SSH
+    const barn = loadBarn(livestock.barn);
+    if (!barn) {
+        return { content: '', error: `Barn not found: ${livestock.barn}` };
+    }
+    if (!barn.host || !barn.user) {
+        return { content: '', error: `Barn '${barn.name}' is not configured for SSH` };
+    }
+    try {
+        const sshArgs = buildSshCommand(barn);
+        const result = await execa(sshArgs[0], [...sshArgs.slice(1), cmd]);
+        if (!result.stdout.trim()) {
+            return { content: '', error: `No log files found in ${logPath}` };
+        }
+        return { content: result.stdout };
+    }
+    catch (err) {
+        return { content: '', error: `SSH error: ${getErrorMessage(err)}` };
+    }
+}
+/**
+ * Parse .env file content into key-value pairs
+ */
+export function parseEnvFile(content) {
+    const result = {};
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip comments and empty lines
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Remove surrounding quotes
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+/**
+ * Read env file from livestock, optionally hiding values
+ */
+export async function readLivestockEnv(livestock, showValues = false) {
+    if (!livestock.env_path) {
+        return { content: '', error: 'env_path not configured for this livestock' };
+    }
+    const result = await readLivestockFile(livestock, livestock.env_path);
+    if (result.error) {
+        return result;
+    }
+    if (showValues) {
+        return result;
+    }
+    // Parse and return keys only
+    const parsed = parseEnvFile(result.content);
+    const keysOnly = Object.keys(parsed)
+        .map(key => `${key}=<hidden>`)
+        .join('\n');
+    return { content: keysOnly };
+}
+/**
+ * Check if a file exists (local or remote via SSH)
+ */
+async function fileExists(path, fullPath, barn) {
+    if (!barn) {
+        // Local check
+        return existsSync(join(path, fullPath));
+    }
+    // Remote check via SSH
+    if (!barn.host || !barn.user) {
+        return false;
+    }
+    try {
+        const sshArgs = buildSshCommand(barn);
+        const testPath = join(path, fullPath);
+        // Use shellEscape for the path
+        await execa(sshArgs[0], [...sshArgs.slice(1), `test -e ${shellEscape(testPath)}`]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Detect framework and suggest log_path/env_path based on project structure
+ */
+export async function detectLivestockConfig(path, barn) {
+    const result = {};
+    // Laravel: artisan file
+    if (await fileExists(path, 'artisan', barn)) {
+        result.framework = 'laravel';
+        result.log_path = 'storage/logs/';
+        result.env_path = '.env';
+        return result;
+    }
+    // Django: manage.py
+    if (await fileExists(path, 'manage.py', barn)) {
+        result.framework = 'django';
+        result.log_path = 'logs/';
+        result.env_path = '.env';
+        return result;
+    }
+    // Rails: Gemfile + bin/rails
+    if (await fileExists(path, 'Gemfile', barn) && await fileExists(path, 'bin/rails', barn)) {
+        result.framework = 'rails';
+        result.log_path = 'log/';
+        result.env_path = '.env';
+        return result;
+    }
+    // Node: package.json
+    if (await fileExists(path, 'package.json', barn)) {
+        result.framework = 'node';
+        result.log_path = 'logs/';
+        result.env_path = '.env';
+        return result;
+    }
+    // Generic fallback: check if .env exists
+    if (await fileExists(path, '.env', barn)) {
+        result.framework = 'unknown';
+        result.env_path = '.env';
+        return result;
+    }
+    return result;
+}

package/dist/lib/mcp-validation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * MCP tool arguments come as Record<string, unknown> | undefined.
+ * These helpers safely extract and validate values.
+ */
+export interface McpArgs {
+    [key: string]: unknown;
+}
+/**
+ * Get a required string argument, throwing if missing or wrong type
+ */
+export declare function requireString(args: McpArgs | undefined, key: string): string;
+/**
+ * Get an optional string argument
+ */
+export declare function optionalString(args: McpArgs | undefined, key: string): string | undefined;
+/**
+ * Get an optional number argument
+ */
+export declare function optionalNumber(args: McpArgs | undefined, key: string): number | undefined;
+/**
+ * Get an optional boolean argument with default
+ */
+export declare function optionalBoolean(args: McpArgs | undefined, key: string, defaultValue: boolean): boolean;
+/**
+ * Wrapper to handle validation errors and return MCP error response
+ */
+export declare function validateArgs<T>(args: McpArgs | undefined, validator: (args: McpArgs | undefined) => T): {
+    data: T;
+    error?: never;
+} | {
+    data?: never;
+    error: string;
+};

package/dist/lib/mcp-validation.js

@@ -0,0 +1,62 @@
+// src/lib/mcp-validation.ts
+import { isString, isNumber, isBoolean } from './errors.js';
+/**
+ * Get a required string argument, throwing if missing or wrong type
+ */
+export function requireString(args, key) {
+    const value = args?.[key];
+    if (!isString(value)) {
+        throw new Error(`Missing or invalid required parameter: ${key}`);
+    }
+    return value;
+}
+/**
+ * Get an optional string argument
+ */
+export function optionalString(args, key) {
+    const value = args?.[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!isString(value)) {
+        throw new Error(`Invalid parameter type for ${key}: expected string`);
+    }
+    return value;
+}
+/**
+ * Get an optional number argument
+ */
+export function optionalNumber(args, key) {
+    const value = args?.[key];
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!isNumber(value)) {
+        throw new Error(`Invalid parameter type for ${key}: expected number`);
+    }
+    return value;
+}
+/**
+ * Get an optional boolean argument with default
+ */
+export function optionalBoolean(args, key, defaultValue) {
+    const value = args?.[key];
+    if (value === undefined || value === null) {
+        return defaultValue;
+    }
+    if (!isBoolean(value)) {
+        throw new Error(`Invalid parameter type for ${key}: expected boolean`);
+    }
+    return value;
+}
+/**
+ * Wrapper to handle validation errors and return MCP error response
+ */
+export function validateArgs(args, validator) {
+    try {
+        return { data: validator(args) };
+    }
+    catch (err) {
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}