auq-mcp-server 0.1.0

package/dist/tui/__tests__/session-watcher.test.js

@@ -0,0 +1,368 @@
+/**
+ * Unit tests for TUI session watcher functionality
+ */
+import { promises as fs } from "fs";
+import { join } from "path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { SESSION_FILES } from "../../session/types.js";
+import { createTUIWatcher, EnhancedTUISessionWatcher, getNextPendingSession, } from "../session-watcher.js";
+describe("TUI Session Watcher", () => {
+    const testDir = "/tmp/auq-tui-watcher-test";
+    const sessionDir = join(testDir, "sessions");
+    const testSessionId = "test-session-123";
+    const mockSessionRequest = {
+        questions: [
+            {
+                title: "Language",
+                options: [
+                    { description: "Dynamic web language", label: "JavaScript" },
+                    { description: "Typed JavaScript", label: "TypeScript" },
+                    { description: "Versatile and readable", label: "Python" },
+                ],
+                prompt: "What is your favorite programming language?",
+            },
+        ],
+        sessionId: testSessionId,
+        status: "pending",
+        timestamp: new Date().toISOString(),
+    };
+    beforeEach(async () => {
+        // Clean up test directory before each test
+        await fs.rm(testDir, { force: true, recursive: true }).catch(() => { });
+        await fs.mkdir(sessionDir, { recursive: true });
+    });
+    afterEach(async () => {
+        // Clean up test directory after each test
+        await fs.rm(testDir, { force: true, recursive: true }).catch(() => { });
+    });
+    describe("EnhancedTUISessionWatcher", () => {
+        describe("session event detection", () => {
+            it("should detect new sessions with loaded data", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    autoLoadData: true,
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const events = [];
+                watcher.startEnhancedWatching((event) => {
+                    events.push(event);
+                });
+                // Give watcher time to initialize
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Create a new session directory
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                // Create required session files
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                const statusFile = join(newSessionDir, SESSION_FILES.STATUS);
+                await Promise.all([
+                    fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2)),
+                    fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: testSessionId,
+                        status: "pending",
+                        totalQuestions: 1,
+                    })),
+                ]);
+                // Wait for debounce (100ms) + processing time
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(events).toHaveLength(1);
+                expect(events[0].type).toBe("session-created");
+                expect(events[0].sessionId).toBe(testSessionId);
+                expect(events[0].sessionRequest).toEqual(mockSessionRequest);
+                watcher.stop();
+            });
+            it("should handle autoLoadData disabled", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    autoLoadData: false,
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const events = [];
+                watcher.startEnhancedWatching((event) => {
+                    events.push(event);
+                });
+                // Give watcher time to initialize
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Create session directory and files
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2));
+                // Wait for debounce + processing
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(events).toHaveLength(1);
+                expect(events[0].type).toBe("session-created");
+                expect(events[0].sessionId).toBe(testSessionId);
+                expect(events[0].sessionRequest).toBeUndefined(); // Should not be loaded
+                watcher.stop();
+            });
+            it("should handle corrupted session files gracefully", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    autoLoadData: true,
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const events = [];
+                const consoleSpy = vi
+                    .spyOn(console, "warn")
+                    .mockImplementation(() => { });
+                watcher.startEnhancedWatching((event) => {
+                    events.push(event);
+                });
+                // Create session with corrupted request.json
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                const statusFile = join(newSessionDir, SESSION_FILES.STATUS);
+                // Write corrupted request.json and valid status.json
+                await Promise.all([
+                    fs.writeFile(requestFile, "invalid json content"),
+                    fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: testSessionId,
+                        status: "pending",
+                        totalQuestions: 1,
+                    })),
+                ]);
+                // Wait for debounce + processing
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(events).toHaveLength(1);
+                expect(events[0].type).toBe("session-created");
+                expect(events[0].sessionId).toBe(testSessionId);
+                expect(events[0].sessionRequest).toBeUndefined();
+                // Should have logged a warning about corrupted data
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to load session request"), expect.any(Error));
+                consoleSpy.mockRestore();
+                watcher.stop();
+            });
+        });
+        describe("event handlers", () => {
+            it("should support multiple event handlers", async () => {
+                const watcher = new EnhancedTUISessionWatcher({
+                    debounceMs: 100,
+                    sessionDir,
+                });
+                const mainEvents = [];
+                const customEvents = [];
+                watcher.addEventHandler("custom", (event) => {
+                    customEvents.push(event);
+                });
+                watcher.startEnhancedWatching((event) => {
+                    mainEvents.push(event);
+                });
+                // Give watcher time to initialize
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                // Create session
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2));
+                // Wait for debounce + processing
+                await new Promise((resolve) => setTimeout(resolve, 300));
+                expect(mainEvents).toHaveLength(1);
+                expect(customEvents).toHaveLength(1);
+                expect(customEvents[0]).toEqual(mainEvents[0]);
+                watcher.removeEventHandler("custom");
+                watcher.stop();
+            });
+            it("should handle event handler removal", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const customEvents = [];
+                watcher.addEventHandler("custom", (event) => {
+                    customEvents.push(event);
+                });
+                watcher.removeEventHandler("custom");
+                watcher.startEnhancedWatching(() => { });
+                // Create session
+                const newSessionDir = join(sessionDir, testSessionId);
+                await fs.mkdir(newSessionDir);
+                const requestFile = join(newSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, JSON.stringify(mockSessionRequest, null, 2));
+                // Wait for processing
+                await new Promise((resolve) => setTimeout(resolve, 100));
+                expect(customEvents).toHaveLength(0); // Should not have triggered
+                watcher.stop();
+            });
+        });
+        describe("session management", () => {
+            beforeEach(async () => {
+                // Create multiple test sessions
+                const sessions = [
+                    { completed: false, id: "session-1" },
+                    { completed: true, id: "session-2" },
+                    { completed: false, id: "session-3" },
+                ];
+                for (const session of sessions) {
+                    const sessionDir = join(testDir, "sessions", session.id);
+                    await fs.mkdir(sessionDir, { recursive: true });
+                    // Create request.json
+                    const requestFile = join(sessionDir, SESSION_FILES.REQUEST);
+                    await fs.writeFile(requestFile, JSON.stringify({
+                        ...mockSessionRequest,
+                        sessionId: session.id,
+                    }));
+                    // Create status.json
+                    const statusFile = join(sessionDir, SESSION_FILES.STATUS);
+                    await fs.writeFile(statusFile, JSON.stringify({
+                        createdAt: new Date().toISOString(),
+                        lastModified: new Date().toISOString(),
+                        sessionId: session.id,
+                        status: session.completed ? "completed" : "pending",
+                        totalQuestions: 1,
+                    }));
+                    // Create answers.json for completed sessions
+                    if (session.completed) {
+                        const answersFile = join(sessionDir, SESSION_FILES.ANSWERS);
+                        await fs.writeFile(answersFile, JSON.stringify({
+                            answers: [
+                                {
+                                    questionIndex: 0,
+                                    selectedOption: "JavaScript",
+                                    timestamp: new Date().toISOString(),
+                                },
+                            ],
+                            sessionId: session.id,
+                            timestamp: new Date().toISOString(),
+                        }));
+                    }
+                }
+            });
+            it("should get pending sessions correctly", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const pendingSessions = await watcher.getPendingSessions();
+                expect(pendingSessions).toHaveLength(2);
+                expect(pendingSessions).toContain("session-1");
+                expect(pendingSessions).toContain("session-3");
+                expect(pendingSessions).not.toContain("session-2");
+                // Should be sorted
+                expect(pendingSessions[0]).toBe("session-1");
+                expect(pendingSessions[1]).toBe("session-3");
+                watcher.stop();
+            });
+            it("should get session request data", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const sessionRequest = await watcher.getSessionRequest("session-1");
+                expect(sessionRequest).toBeTruthy();
+                expect(sessionRequest?.sessionId).toBe("session-1");
+                expect(sessionRequest?.questions).toHaveLength(1);
+                watcher.stop();
+            });
+            it("should handle non-existent session request", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                const consoleSpy = vi
+                    .spyOn(console, "warn")
+                    .mockImplementation(() => { });
+                const sessionRequest = await watcher.getSessionRequest("non-existent");
+                expect(sessionRequest).toBeNull();
+                expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to load session request"), expect.any(Error));
+                consoleSpy.mockRestore();
+                watcher.stop();
+            });
+            it("should check session pending status correctly", async () => {
+                const watcher = new EnhancedTUISessionWatcher({ sessionDir });
+                expect(await watcher.isSessionPending("session-1")).toBe(true);
+                expect(await watcher.isSessionPending("session-2")).toBe(false);
+                expect(await watcher.isSessionPending("session-3")).toBe(true);
+                expect(await watcher.isSessionPending("non-existent")).toBe(false);
+                watcher.stop();
+            });
+        });
+    });
+    describe("Utility Functions", () => {
+        describe("createTUIWatcher", () => {
+            it("should create an enhanced TUI session watcher", () => {
+                const watcher = createTUIWatcher({ sessionDir });
+                expect(watcher).toBeInstanceOf(EnhancedTUISessionWatcher);
+                expect(watcher.watchedPath).toBe(sessionDir);
+                watcher.stop();
+            });
+        });
+        describe("getNextPendingSession", () => {
+            beforeEach(async () => {
+                // Create test sessions
+                const sessions = [
+                    { id: "first-session", pending: true },
+                    { id: "second-session", pending: true },
+                ];
+                for (const session of sessions) {
+                    const sessionDir = join(testDir, "sessions", session.id);
+                    await fs.mkdir(sessionDir, { recursive: true });
+                    // Create required files
+                    const requestFile = join(sessionDir, SESSION_FILES.REQUEST);
+                    const statusFile = join(sessionDir, SESSION_FILES.STATUS);
+                    await Promise.all([
+                        fs.writeFile(requestFile, JSON.stringify({
+                            ...mockSessionRequest,
+                            sessionId: session.id,
+                        })),
+                        fs.writeFile(statusFile, JSON.stringify({
+                            createdAt: new Date().toISOString(),
+                            lastModified: new Date().toISOString(),
+                            sessionId: session.id,
+                            status: "pending",
+                            totalQuestions: 1,
+                        })),
+                    ]);
+                }
+            });
+            it("should get the next pending session", async () => {
+                const result = await getNextPendingSession({ sessionDir });
+                expect(result).toBeTruthy();
+                expect(result?.sessionId).toBe("first-session");
+                expect(result?.sessionRequest).toBeTruthy();
+                expect(result?.sessionRequest.sessionId).toBe("first-session");
+            });
+            it("should return null when no pending sessions", async () => {
+                // Clear all sessions
+                await fs.rm(sessionDir, { recursive: true });
+                await fs.mkdir(sessionDir);
+                const result = await getNextPendingSession({ sessionDir });
+                expect(result).toBeNull();
+            });
+            it("should handle sessions with corrupted data", async () => {
+                // Create session with corrupted request.json
+                const corruptedSessionDir = join(sessionDir, "corrupted-session");
+                await fs.mkdir(corruptedSessionDir);
+                const statusFile = join(corruptedSessionDir, SESSION_FILES.STATUS);
+                await fs.writeFile(statusFile, JSON.stringify({
+                    createdAt: new Date().toISOString(),
+                    lastModified: new Date().toISOString(),
+                    sessionId: "corrupted-session",
+                    status: "pending",
+                    totalQuestions: 1,
+                }));
+                // Create corrupted request.json
+                const requestFile = join(corruptedSessionDir, SESSION_FILES.REQUEST);
+                await fs.writeFile(requestFile, "invalid json");
+                const result = await getNextPendingSession({ sessionDir });
+                // Should skip corrupted session and return valid one
+                expect(result).toBeTruthy();
+                expect(result?.sessionId).toBe("first-session");
+            });
+        });
+    });
+    describe("Error Handling", () => {
+        it("should handle directory access errors", async () => {
+            const watcher = new EnhancedTUISessionWatcher({
+                sessionDir: "/invalid/directory/path",
+            });
+            const consoleSpy = vi.spyOn(console, "warn").mockImplementation(() => { });
+            const pendingSessions = await watcher.getPendingSessions();
+            expect(pendingSessions).toEqual([]);
+            expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Failed to scan for pending sessions"), expect.any(Error));
+            consoleSpy.mockRestore();
+            watcher.stop();
+        });
+        it("should handle missing watched path gracefully", async () => {
+            const watcher = new EnhancedTUISessionWatcher({
+                sessionDir: "/non/existent/path",
+            });
+            const sessionRequest = await watcher.getSessionRequest("any-id");
+            expect(sessionRequest).toBeNull();
+            watcher.stop();
+        });
+    });
+});

package/dist/tui/session-watcher.js

@@ -0,0 +1,183 @@
+/**
+ * TUI Session Watcher Module
+ *
+ * Provides TUI applications with the ability to detect new question sessions
+ * and coordinate with the MCP server through file system events.
+ */
+import { atomicReadFile } from "../session/atomic-operations.js";
+import { TUISessionWatcher } from "../session/file-watcher.js";
+import { SESSION_FILES } from "../session/types.js";
+/**
+ * Enhanced TUI Session Watcher with session data loading
+ */
+export class EnhancedTUISessionWatcher extends TUISessionWatcher {
+    autoLoadData;
+    eventHandlers = new Map();
+    constructor(config) {
+        // Map sessionDir to baseDir for parent class
+        super({
+            baseDir: config?.sessionDir,
+            debounceMs: config?.debounceMs,
+        });
+        this.autoLoadData = config?.autoLoadData ?? true;
+    }
+    /**
+     * Add custom event handler
+     */
+    addEventHandler(name, handler) {
+        this.eventHandlers.set(name, handler);
+    }
+    /**
+     * Get list of pending sessions (sessions without answers)
+     */
+    async getPendingSessions() {
+        const fs = await import("fs/promises");
+        const { join } = await import("path");
+        try {
+            const sessionDir = this.watchedPath;
+            const entries = await fs.readdir(sessionDir, { withFileTypes: true });
+            const pendingSessions = [];
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const sessionPath = join(sessionDir, entry.name);
+                const answersPath = join(sessionPath, SESSION_FILES.ANSWERS);
+                const statusPath = join(sessionPath, SESSION_FILES.STATUS);
+                try {
+                    // Check if answers file doesn't exist (pending session)
+                    await fs.access(answersPath);
+                }
+                catch {
+                    // Answers file doesn't exist - check if this is a valid session
+                    try {
+                        await fs.access(statusPath);
+                        pendingSessions.push(entry.name);
+                    }
+                    catch {
+                        // No status file - not a valid session
+                    }
+                }
+            }
+            return pendingSessions.sort(); // Sort for consistent ordering
+        }
+        catch (error) {
+            console.warn("Failed to scan for pending sessions:", error);
+            return [];
+        }
+    }
+    /**
+     * Get session request data for a specific session
+     */
+    async getSessionRequest(sessionId) {
+        const { join } = await import("path");
+        const sessionPath = join(this.watchedPath, sessionId);
+        try {
+            return await this.loadSessionRequest(sessionPath);
+        }
+        catch (error) {
+            console.warn(`Failed to load session request for ${sessionId}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Check if a session exists and is pending
+     */
+    async isSessionPending(sessionId) {
+        const { join } = await import("path");
+        const sessionPath = join(this.watchedPath, sessionId);
+        const answersPath = join(sessionPath, SESSION_FILES.ANSWERS);
+        const statusPath = join(sessionPath, SESSION_FILES.STATUS);
+        try {
+            const fs = await import("fs/promises");
+            // Check if status file exists (valid session)
+            await fs.access(statusPath);
+            // Check if answers file doesn't exist (pending)
+            try {
+                await fs.access(answersPath);
+                return false; // Answers exist - session is completed
+            }
+            catch {
+                return true; // No answers - session is pending
+            }
+        }
+        catch {
+            return false; // Not a valid session
+        }
+    }
+    /**
+     * Remove event handler
+     */
+    removeEventHandler(name) {
+        this.eventHandlers.delete(name);
+    }
+    /**
+     * Start watching with enhanced event handling
+     */
+    startEnhancedWatching(onSessionEvent) {
+        this.startWatching(async (sessionId, sessionPath) => {
+            const event = {
+                sessionId,
+                sessionPath,
+                timestamp: Date.now(),
+                type: "session-created",
+            };
+            // Auto-load session data if requested
+            if (this.autoLoadData) {
+                try {
+                    const sessionRequest = await this.loadSessionRequest(sessionPath);
+                    event.sessionRequest = sessionRequest;
+                }
+                catch (error) {
+                    console.warn(`Failed to load session request for ${sessionId}:`, error);
+                }
+            }
+            // Emit the event
+            onSessionEvent(event);
+            // Call any additional handlers
+            this.eventHandlers.forEach((handler) => handler(event));
+        });
+    }
+    /**
+     * Load session request data from file
+     */
+    async loadSessionRequest(sessionPath) {
+        const requestPath = `${sessionPath}/${SESSION_FILES.REQUEST}`;
+        try {
+            const content = await atomicReadFile(requestPath, {
+                encoding: "utf8",
+                maxRetries: 3,
+                retryDelay: 100,
+            });
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to load session request from ${requestPath}: ${error}`);
+        }
+    }
+}
+/**
+ * Create a simple TUI session watcher instance
+ */
+export function createTUIWatcher(config) {
+    return new EnhancedTUISessionWatcher(config);
+}
+/**
+ * Convenience function to get the next pending session
+ */
+export async function getNextPendingSession(config) {
+    const watcher = createTUIWatcher(config);
+    const pendingSessions = await watcher.getPendingSessions();
+    if (pendingSessions.length === 0) {
+        return null;
+    }
+    // Try each pending session until we find one with valid data
+    for (const sessionId of pendingSessions) {
+        const sessionRequest = await watcher.getSessionRequest(sessionId);
+        if (sessionRequest) {
+            return { sessionId, sessionRequest };
+        }
+        // Skip corrupted sessions and continue to next one
+    }
+    // No valid sessions found
+    return null;
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "auq-mcp-server",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "bin": {
+    "auq": "dist/bin/auq.js"
+  },
+  "files": [
+    "dist",
+    "scripts/postinstall.cjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "postinstall": "node scripts/postinstall.cjs",
+    "server": "node dist/src/server.js",
+    "start": "tsx src/server.ts",
+    "dev": "fastmcp dev src/server.ts",
+    "lint": "prettier --check . && eslint . && tsc --noEmit",
+    "test": "vitest run",
+    "format": "prettier --write . && eslint --fix ."
+  },
+  "keywords": [
+    "fastmcp",
+    "mcp",
+    "ask-user-questions",
+    "tui",
+    "terminal"
+  ],
+  "repository": {
+    "url": "git+https://github.com/paulp-o/ask-user-question-mcp.git"
+  },
+  "author": "Paul Park",
+  "homepage": "https://github.com/paulp-o/ask-user-question-mcp",
+  "type": "module",
+  "license": "MIT",
+  "description": "An MCP server that provides a tool to ask a user questions via the terminal",
+  "dependencies": {
+    "@inkjs/ui": "^2.0.0",
+    "@types/uuid": "^10.0.0",
+    "chalk": "^5.6.2",
+    "fastmcp": "^1.27.3",
+    "gradient-string": "^3.0.0",
+    "ink": "^6.4.0",
+    "ink-gradient": "^3.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^19.2.0",
+    "uuid": "^13.0.0",
+    "zod": "^3.24.4"
+  },
+  "release": {
+    "branches": [
+      "main"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/npm",
+      "@semantic-release/github"
+    ]
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.26.0",
+    "@tsconfig/node22": "^22.0.1",
+    "@types/react": "^19.2.2",
+    "eslint-config-prettier": "^10.1.3",
+    "eslint-plugin-perfectionist": "^4.12.3",
+    "jiti": "^2.4.2",
+    "prettier": "^3.5.3",
+    "semantic-release": "^24.2.3",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.0",
+    "vitest": "^3.1.3"
+  }
+}

package/scripts/postinstall.cjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for auq-mcp-server
+ * Provides instructions for setting up shell aliases
+ */
+
+const os = require('os');
+const path = require('path');
+
+// Check if this is a global installation
+const isGlobal = process.env.npm_config_global === 'true';
+
+if (!isGlobal) {
+  // Local install - no setup needed
+  process.exit(0);
+}
+
+console.log('\n✅ AUQ MCP Server installed successfully!\n');
+console.log('📝 Optional: Set up shell aliases for convenience\n');
+
+const homeDir = os.homedir();
+const shell = process.env.SHELL || '';
+
+// Determine shell config file
+let configFile = '';
+let aliasCommand = '';
+
+if (shell.includes('zsh')) {
+  configFile = path.join(homeDir, '.zshrc');
+  aliasCommand = 'alias auq="npx auq-mcp-server"';
+} else if (shell.includes('bash')) {
+  configFile = path.join(homeDir, '.bashrc');
+  aliasCommand = 'alias auq="npx auq-mcp-server"';
+} else if (shell.includes('fish')) {
+  configFile = path.join(homeDir, '.config/fish/config.fish');
+  aliasCommand = 'alias auq "npx auq-mcp-server"';
+}
+
+if (configFile) {
+  console.log(`To set up a shell alias, add this to your ${path.basename(configFile)}:\n`);
+  console.log(`  ${aliasCommand}\n`);
+  console.log(`Then restart your terminal or run: source ${configFile}\n`);
+} else {
+  console.log('To set up a shell alias, add this to your shell config:\n');
+  console.log('  alias auq="npx auq-mcp-server"\n');
+  console.log('Then restart your terminal.\n');
+}
+
+console.log('For MCP server setup with Claude Desktop or Cursor, see:');
+console.log('  https://github.com/paulp-o/ask-user-question-mcp#setup\n');