mcp-perforce-server 2.0.1 → 2.1.1

package/dist/server.js

@@ -54,8 +54,116 @@ const log = {
     info: (...args) => shouldLog('info') && console.error('[INFO]', ...args),
     debug: (...args) => shouldLog('debug') && console.error('[DEBUG]', ...args),
 };
+const TOOL_HANDLERS = {
+    'p4.info': tools.p4Info,
+    'p4.status': tools.p4Status,
+    'p4.add': tools.p4Add,
+    'p4.edit': tools.p4Edit,
+    'p4.delete': tools.p4Delete,
+    'p4.revert': tools.p4Revert,
+    'p4.sync': tools.p4Sync,
+    'p4.opened': tools.p4Opened,
+    'p4.diff': tools.p4Diff,
+    'p4.diff2': tools.p4Diff2,
+    'p4.changelist.create': tools.p4ChangelistCreate,
+    'p4.changelist.update': tools.p4ChangelistUpdate,
+    'p4.changelist.submit': tools.p4ChangelistSubmit,
+    'p4.submit': tools.p4Submit,
+    'p4.describe': tools.p4Describe,
+    'p4.filelog': tools.p4Filelog,
+    'p4.clients': tools.p4Clients,
+    'p4.config.detect': tools.p4ConfigDetect,
+    'p4.resolve': tools.p4Resolve,
+    'p4.shelve': tools.p4Shelve,
+    'p4.unshelve': tools.p4Unshelve,
+    'p4.changes': tools.p4Changes,
+    'p4.blame': tools.p4Blame,
+    'p4.copy': tools.p4Copy,
+    'p4.move': tools.p4Move,
+    'p4.integrate': tools.p4Integrate,
+    'p4.merge': tools.p4Merge,
+    'p4.print': tools.p4Print,
+    'p4.fstat': tools.p4Fstat,
+    'p4.streams': tools.p4Streams,
+    'p4.stream': tools.p4Stream,
+    'p4.grep': tools.p4Grep,
+    'p4.files': tools.p4Files,
+    'p4.dirs': tools.p4Dirs,
+    'p4.users': tools.p4Users,
+    'p4.user': tools.p4User,
+    'p4.client': tools.p4Client,
+    'p4.jobs': tools.p4Jobs,
+    'p4.job': tools.p4Job,
+    'p4.fixes': tools.p4Fixes,
+    'p4.labels': tools.p4Labels,
+    'p4.label': tools.p4Label,
+    'p4.sizes': tools.p4Sizes,
+    'p4.have': tools.p4Have,
+    'p4.where': tools.p4Where,
+    'p4.audit': tools.p4Audit,
+    'p4.compliance': tools.p4Compliance,
+};
+const WRITE_TOOLS = new Set([
+    'p4.add',
+    'p4.edit',
+    'p4.delete',
+    'p4.revert',
+    'p4.sync',
+    'p4.changelist.create',
+    'p4.changelist.update',
+    'p4.changelist.submit',
+    'p4.submit',
+    'p4.resolve',
+    'p4.shelve',
+    'p4.unshelve',
+    'p4.copy',
+    'p4.move',
+    'p4.integrate',
+    'p4.merge',
+]);
+const CACHEABLE_TOOLS = new Set(Object.keys(TOOL_HANDLERS).filter((toolName) => !WRITE_TOOLS.has(toolName)));
+function getPerformanceMode() {
+    const mode = (process.env.P4_PERFORMANCE_MODE || 'fast').toLowerCase();
+    if (mode === 'balanced' || mode === 'secure') {
+        return mode;
+    }
+    return 'fast';
+}
+function getDefaultResponseCacheTtlMs() {
+    switch (getPerformanceMode()) {
+        case 'secure':
+            return 1000;
+        case 'balanced':
+            return 3000;
+        case 'fast':
+        default:
+            return 5000;
+    }
+}
+function getDefaultResponseCacheMaxEntries() {
+    switch (getPerformanceMode()) {
+        case 'secure':
+            return 100;
+        case 'balanced':
+            return 250;
+        case 'fast':
+        default:
+            return 400;
+    }
+}
+function getEnvInt(name, fallback) {
+    const parsed = parseInt(process.env[name] || '', 10);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
 class MCPPerforceServer {
     constructor() {
+        this.prettyJson = process.env.P4_PRETTY_JSON === 'true';
+        this.responseCacheEnabled = process.env.P4_RESPONSE_CACHE !== 'false';
+        this.responseCacheTtlMs = getEnvInt('P4_RESPONSE_CACHE_TTL_MS', getDefaultResponseCacheTtlMs());
+        this.responseCacheMaxEntries = getEnvInt('P4_RESPONSE_CACHE_MAX_ENTRIES', getDefaultResponseCacheMaxEntries());
+        this.responseCache = new Map();
+        this.inFlightReadRequests = new Map();
+        this.cacheEpoch = 0;
         this.server = new index_js_1.Server({
             name: 'mcp-perforce-server',
             version: '1.2.0',
@@ -88,6 +196,89 @@ class MCPPerforceServer {
             process.exit(0);
         });
     }
+    serializeResult(value) {
+        if (this.prettyJson) {
+            return JSON.stringify(value, null, 2);
+        }
+        return JSON.stringify(value);
+    }
+    toTextResponse(value) {
+        return {
+            content: [{ type: 'text', text: this.serializeResult(value) }],
+        };
+    }
+    getCachedResult(cacheKey) {
+        const entry = this.responseCache.get(cacheKey);
+        if (!entry) {
+            return undefined;
+        }
+        if (Date.now() > entry.expiresAt) {
+            this.responseCache.delete(cacheKey);
+            return undefined;
+        }
+        return entry.value;
+    }
+    setCachedResult(cacheKey, value) {
+        if (this.responseCacheMaxEntries <= 0 || this.responseCacheTtlMs <= 0) {
+            return;
+        }
+        if (this.responseCache.size >= this.responseCacheMaxEntries) {
+            const oldestKey = this.responseCache.keys().next().value;
+            if (oldestKey) {
+                this.responseCache.delete(oldestKey);
+            }
+        }
+        this.responseCache.set(cacheKey, {
+            value,
+            expiresAt: Date.now() + this.responseCacheTtlMs,
+        });
+    }
+    clearReadCache() {
+        this.cacheEpoch += 1;
+        if (this.responseCache.size > 0) {
+            this.responseCache.clear();
+        }
+    }
+    buildCacheKey(name, args) {
+        return `${name}:${JSON.stringify(args ?? {})}`;
+    }
+    async executeTool(name, args) {
+        const handler = TOOL_HANDLERS[name];
+        if (!handler) {
+            throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        }
+        return handler(this.context, args);
+    }
+    async executeToolWithCaching(name, args) {
+        if (!this.responseCacheEnabled || !CACHEABLE_TOOLS.has(name)) {
+            return this.executeTool(name, args);
+        }
+        const cacheKey = this.buildCacheKey(name, args);
+        const cachedResult = this.getCachedResult(cacheKey);
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const inFlight = this.inFlightReadRequests.get(cacheKey);
+        if (inFlight) {
+            return inFlight;
+        }
+        const pending = this.executeTool(name, args);
+        this.inFlightReadRequests.set(cacheKey, pending);
+        const startedEpoch = this.cacheEpoch;
+        try {
+            const result = await pending;
+            if (startedEpoch === this.cacheEpoch &&
+                result &&
+                typeof result === 'object' &&
+                result.ok === true) {
+                this.setCachedResult(cacheKey, result);
+            }
+            return result;
+        }
+        finally {
+            this.inFlightReadRequests.delete(cacheKey);
+        }
+    }
     setupToolHandlers() {
         this.server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
             log.debug('Listing available tools');
@@ -265,7 +456,7 @@ class MCPPerforceServer {
                     },
                     {
                         name: 'p4.diff',
-                        description: 'Show differences for files',
+                        description: 'Show differences for workspace files (opened or local vs depot)',
                         inputSchema: {
                             type: 'object',
                             properties: {
@@ -286,6 +477,33 @@ class MCPPerforceServer {
                             additionalProperties: false,
                         },
                     },
+                    {
+                        name: 'p4.diff2',
+                        description: 'Compare two depot paths server-side (depot-to-depot diff, no client mapping required)',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                sourcePath: {
+                                    type: 'string',
+                                    description: 'First depot filespec/path to compare (required)',
+                                },
+                                targetPath: {
+                                    type: 'string',
+                                    description: 'Second depot filespec/path to compare (required)',
+                                },
+                                summaryOnly: {
+                                    type: 'boolean',
+                                    description: 'If true, list differing files only like diff2 -q (default: true). If false, include full diff output.',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory for config detection (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['sourcePath', 'targetPath'],
+                            additionalProperties: false,
+                        },
+                    },
                     {
                         name: 'p4.changelist.create',
                         description: 'Create a new changelist',
@@ -383,12 +601,15 @@ class MCPPerforceServer {
                     },
                     {
                         name: 'p4.describe',
-                        description: 'Describe a changelist',
+                        description: 'Describe a changelist with metadata and affected files (equivalent to p4 describe -s)',
                         inputSchema: {
                             type: 'object',
                             properties: {
                                 changelist: {
-                                    type: 'string',
+                                    oneOf: [
+                                        { type: 'string' },
+                                        { type: 'number' },
+                                    ],
                                     description: 'Changelist number (required)',
                                 },
                                 workspacePath: {
@@ -653,6 +874,147 @@ class MCPPerforceServer {
                             additionalProperties: false,
                         },
                     },
+                    {
+                        name: 'p4.integrate',
+                        description: 'Integrate files from source to target',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                source: {
+                                    type: 'string',
+                                    description: 'Source filespec/path (required)',
+                                },
+                                target: {
+                                    type: 'string',
+                                    description: 'Target filespec/path (required)',
+                                },
+                                changelist: {
+                                    type: 'string',
+                                    description: 'Changelist number (optional)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['source', 'target'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.merge',
+                        description: 'Merge files from source to target',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                source: {
+                                    type: 'string',
+                                    description: 'Source filespec/path (required)',
+                                },
+                                target: {
+                                    type: 'string',
+                                    description: 'Target filespec/path (required)',
+                                },
+                                changelist: {
+                                    type: 'string',
+                                    description: 'Changelist number (optional)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['source', 'target'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.print',
+                        description: 'Print file content from the depot',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                filespec: {
+                                    type: 'string',
+                                    description: 'Depot filespec to print (required)',
+                                },
+                                quiet: {
+                                    type: 'boolean',
+                                    description: 'Suppress file headers (optional, defaults to true)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['filespec'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.fstat',
+                        description: 'Get file metadata from depot/workspace',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                filespec: {
+                                    type: 'string',
+                                    description: 'Filespec to inspect (required)',
+                                },
+                                max: {
+                                    type: 'number',
+                                    description: 'Maximum number of results (optional)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['filespec'],
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.streams',
+                        description: 'List streams',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                stream: {
+                                    type: 'string',
+                                    description: 'Optional stream path filter',
+                                },
+                                max: {
+                                    type: 'number',
+                                    description: 'Maximum number of results (optional)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            additionalProperties: false,
+                        },
+                    },
+                    {
+                        name: 'p4.stream',
+                        description: 'Get stream spec details',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                stream: {
+                                    type: 'string',
+                                    description: 'Stream path/name (required)',
+                                },
+                                workspacePath: {
+                                    type: 'string',
+                                    description: 'Path to workspace directory (optional, defaults to current directory)',
+                                },
+                            },
+                            required: ['stream'],
+                            additionalProperties: false,
+                        },
+                    },
                     {
                         name: 'p4.grep',
                         description: 'Search for text patterns across depot files',
@@ -1029,95 +1391,10 @@ class MCPPerforceServer {
                         log.info('Forced garbage collection');
                     }
                 }
-                // Route to appropriate tool implementation
-                let result;
-                switch (name) {
-                    case 'p4.info':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Info(this.context, args), null, 2) }] };
-                    case 'p4.status':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Status(this.context, args), null, 2) }] };
-                    case 'p4.add':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Add(this.context, args), null, 2) }] };
-                    case 'p4.edit':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Edit(this.context, args), null, 2) }] };
-                    case 'p4.delete':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Delete(this.context, args), null, 2) }] };
-                    case 'p4.revert':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Revert(this.context, args), null, 2) }] };
-                    case 'p4.sync':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Sync(this.context, args), null, 2) }] };
-                    case 'p4.opened':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Opened(this.context, args), null, 2) }] };
-                    case 'p4.diff':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Diff(this.context, args), null, 2) }] };
-                    case 'p4.changelist.create':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4ChangelistCreate(this.context, args), null, 2) }] };
-                    case 'p4.changelist.update':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4ChangelistUpdate(this.context, args), null, 2) }] };
-                    case 'p4.changelist.submit':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4ChangelistSubmit(this.context, args), null, 2) }] };
-                    case 'p4.submit':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Submit(this.context, args), null, 2) }] };
-                    case 'p4.describe':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Describe(this.context, args), null, 2) }] };
-                    case 'p4.filelog':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Filelog(this.context, args), null, 2) }] };
-                    case 'p4.clients':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Clients(this.context, args), null, 2) }] };
-                    case 'p4.config.detect':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4ConfigDetect(this.context, args), null, 2) }] };
-                    // High Priority Tools
-                    case 'p4.resolve':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Resolve(this.context, args), null, 2) }] };
-                    case 'p4.shelve':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Shelve(this.context, args), null, 2) }] };
-                    case 'p4.unshelve':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Unshelve(this.context, args), null, 2) }] };
-                    case 'p4.changes':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Changes(this.context, args), null, 2) }] };
-                    case 'p4.blame':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Blame(this.context, args), null, 2) }] };
-                    // Medium Priority Tools
-                    case 'p4.copy':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Copy(this.context, args), null, 2) }] };
-                    case 'p4.move':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Move(this.context, args), null, 2) }] };
-                    case 'p4.grep':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Grep(this.context, args), null, 2) }] };
-                    case 'p4.files':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Files(this.context, args), null, 2) }] };
-                    case 'p4.dirs':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Dirs(this.context, args), null, 2) }] };
-                    // Advanced/Low Priority Tools
-                    case 'p4.users':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Users(this.context, args), null, 2) }] };
-                    case 'p4.user':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4User(this.context, args), null, 2) }] };
-                    case 'p4.client':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Client(this.context, args), null, 2) }] };
-                    case 'p4.jobs':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Jobs(this.context, args), null, 2) }] };
-                    case 'p4.job':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Job(this.context, args), null, 2) }] };
-                    case 'p4.fixes':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Fixes(this.context, args), null, 2) }] };
-                    case 'p4.labels':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Labels(this.context, args), null, 2) }] };
-                    case 'p4.label':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Label(this.context, args), null, 2) }] };
-                    case 'p4.sizes':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Sizes(this.context, args), null, 2) }] };
-                    case 'p4.have':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Have(this.context, args), null, 2) }] };
-                    case 'p4.where':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Where(this.context, args), null, 2) }] };
-                    // Compliance and Security Tools
-                    case 'p4.audit':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Audit(this.context, args), null, 2) }] };
-                    case 'p4.compliance':
-                        return { content: [{ type: 'text', text: JSON.stringify(await tools.p4Compliance(this.context, args), null, 2) }] };
-                    default:
-                        throw new types_js_1.McpError(types_js_1.ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+                const toolArgs = (args || {});
+                const result = await this.executeToolWithCaching(name, toolArgs);
+                if (WRITE_TOOLS.has(name) && result && typeof result === 'object' && result.ok) {
+                    this.clearReadCache();
                 }
                 // Audit log successful operation
                 this.context.security.logAuditEntry({
@@ -1125,11 +1402,11 @@ class MCPPerforceServer {
                     user: result?.configUsed?.P4USER || 'unknown',
                     client: result?.configUsed?.P4CLIENT || 'unknown',
                     operation: name,
-                    args: args || {},
+                    args: toolArgs,
                     result: 'success',
                     duration: Date.now() - startTime,
                 });
-                return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
+                return this.toTextResponse(result);
             }
             catch (error) {
                 const duration = Date.now() - startTime;
@@ -1171,47 +1448,53 @@ if (require.main === module) {
     }
     // Handle help flag
     if (process.argv.includes('--help') || process.argv.includes('-h')) {
-        console.log(`
-MCP Perforce Server v${packageJson.version}
-===========================
-
-A production-ready MCP (Model Context Protocol) server for Perforce operations.
-
-Usage:
-  mcp-perforce-server          Start the MCP server (stdio transport)
-  mcp-perforce-server --help   Show this help message
-  mcp-perforce-server --version Show version information
-
-Environment Variables:
-  P4_READONLY_MODE=false      Enable write operations (default: true)
-  P4_DISABLE_DELETE=false     Enable delete operations (default: true)
-  P4_PATH=/path/to/p4         Custom p4 executable path
-  P4CONFIG=.p4config         Config file name (default: .p4config)
-  LOG_LEVEL=info             Logging level: error,warn,info,debug
-
-Compliance & Security:
-  P4_ENABLE_AUDIT_LOGGING=true   Enable audit logging (default: false)
-  P4_ENABLE_RATE_LIMITING=false  Disable rate limiting (default: true)
-  P4_ENABLE_MEMORY_LIMITS=false  Disable memory limits (default: true)
-  P4_ENABLE_INPUT_SANITIZATION=false Disable input sanitization (default: true)
-  P4_MAX_MEMORY_MB=1024         Memory limit in MB (default: 512)
-  P4_AUDIT_RETENTION_DAYS=365   Audit log retention days (default: 90)
-  P4_RATE_LIMIT_REQUESTS=100    Max requests per window (default: 100)
-  P4_RATE_LIMIT_WINDOW_MS=600000 Rate limit window ms (default: 10min)
-  P4_RATE_LIMIT_BLOCK_MS=3600000 Rate limit block duration ms (default: 1hr)
-
-Configuration:
-  Place a .p4config file in your project root or parent directories:
-
-  P4PORT=your-server:1666
-  P4USER=your-username
-  P4CLIENT=your-workspace-name
-
-IDE Integration:
-  Configure your IDE's MCP client to use this server.
-  See README.md for VS Code and Cursor setup instructions.
-
-For more information: https://github.com/iPraBhu/mcp-perforce-server
+        console.log(`
+MCP Perforce Server v${packageJson.version}
+===========================
+
+A production-ready MCP (Model Context Protocol) server for Perforce operations.
+
+Usage:
+  mcp-perforce-server          Start the MCP server (stdio transport)
+  mcp-perforce-server --help   Show this help message
+  mcp-perforce-server --version Show version information
+
+Environment Variables:
+  P4_READONLY_MODE=false      Enable write operations (default: read-only enabled)
+  P4_DISABLE_DELETE=false     Enable delete operations (default: delete disabled)  
+  P4_PATH=/path/to/p4         Custom p4 executable path
+  P4CONFIG=.p4config         Config file name (default: .p4config)
+  LOG_LEVEL=info             Logging level: error,warn,info,debug
+  P4_PERFORMANCE_MODE=fast    Performance profile: fast|balanced|secure (default: fast)
+  P4_TIMEOUT_MS=5000          Command timeout in milliseconds (default by mode)
+  P4_PRETTY_JSON=true         Pretty-print JSON responses (default: compact JSON)
+  P4_RESPONSE_CACHE=false     Disable read-result cache (default: enabled)
+  P4_RESPONSE_CACHE_TTL_MS=5000 Cache TTL in ms (default by mode: fast 5000, balanced 3000, secure 1000)
+  P4_RESPONSE_CACHE_MAX_ENTRIES=400 Max cached responses (default by mode)
+
+Compliance & Security:
+  P4_ENABLE_AUDIT_LOGGING=true|false   Override audit logging (default in fast mode: false)
+  P4_ENABLE_RATE_LIMITING=true|false   Override rate limiting (default in fast mode: false)
+  P4_ENABLE_MEMORY_LIMITS=true|false   Override memory limits (default in fast mode: false)
+  P4_ENABLE_INPUT_SANITIZATION=false Disable input sanitization (default: enabled)
+  P4_MAX_MEMORY_MB=1024         Memory limit in MB (default: 512)
+  P4_AUDIT_RETENTION_DAYS=365   Audit log retention days (default: 90)
+  P4_RATE_LIMIT_REQUESTS=100    Max requests per window (default: 100)
+  P4_RATE_LIMIT_WINDOW_MS=600000 Rate limit window ms (default: 10min)
+  P4_RATE_LIMIT_BLOCK_MS=3600000 Rate limit block duration ms (default: 1hr)
+
+Configuration:
+  Place a .p4config file in your project root or parent directories:
+
+  P4PORT=your-server:1666
+  P4USER=your-username
+  P4CLIENT=your-workspace-name
+
+IDE Integration:
+  Configure your IDE's MCP client to use this server.
+  See README.md for VS Code and Cursor setup instructions.
+
+For more information: https://github.com/iPraBhu/mcp-perforce-server
 `);
         process.exit(0);
     }