Improve prompts for cross os work

.gitignore

@@ -36,4 +36,7 @@ coverage/
 .idea
 .history
 
-server.log
+server.log
+
+# Local planning/documentation directories
+plans/

src/handlers/edit-search-handlers.ts

@@ -26,14 +26,17 @@ export async function handleSearchCode(args: unknown): Promise<ServerResult> {
     const parsed = SearchCodeArgsSchema.parse(args);
     const timeoutMs = parsed.timeoutMs || 30000; // 30 seconds default
 
+    // Limit maxResults to prevent overwhelming responses
+    const safeMaxResults = parsed.maxResults ? Math.min(parsed.maxResults, 5000) : 2000; // Default to 2000 instead of 1000
+
     // Apply timeout at the handler level
     const searchOperation = async () => {
         return await searchTextInFiles({
             rootPath: parsed.path,
             pattern: parsed.pattern,
             filePattern: parsed.filePattern,
             ignoreCase: parsed.ignoreCase,
-            maxResults: parsed.maxResults,
+            maxResults: safeMaxResults,
             includeHidden: parsed.includeHidden,
             contextLines: parsed.contextLines,
             // Don't pass timeoutMs down to the implementation
@@ -72,17 +75,36 @@ export async function handleSearchCode(args: unknown): Promise<ServerResult> {
         };
     }
 
-    // Format the results in a VS Code-like format
+    // Format the results in a VS Code-like format with early truncation
     let currentFile = "";
     let formattedResults = "";
+    const MAX_RESPONSE_SIZE = 900000; // 900KB limit - well below the 1MB API limit
+    let resultsProcessed = 0;
+    let totalResults = results.length;
 
-    results.forEach(result => {
+    for (const result of results) {
+        // Check if adding this result would exceed our limit
+        const newFileHeader = result.file !== currentFile ? `\n${result.file}:\n` : '';
+        const newLine = `  ${result.line}: ${result.match}\n`;
+        const potentialAddition = newFileHeader + newLine;
+
+        // If adding this would exceed the limit, truncate here
+        if (formattedResults.length + potentialAddition.length > MAX_RESPONSE_SIZE) {
+            const remainingResults = totalResults - resultsProcessed;
+            const avgResultLength = formattedResults.length / Math.max(resultsProcessed, 1);
+            const estimatedRemainingChars = remainingResults * avgResultLength;
+            const truncationMessage = `\n\n[Results truncated - ${remainingResults} more results available (approximately ${Math.round(estimatedRemainingChars).toLocaleString()} more characters). Try refining your search pattern or using a more specific file pattern to get fewer results.]`;
+            formattedResults += truncationMessage;
+            break;
+        }
+
         if (result.file !== currentFile) {
-            formattedResults += `\n${result.file}:\n`;
+            formattedResults += newFileHeader;
             currentFile = result.file;
         }
-        formattedResults += `  ${result.line}: ${result.match}\n`;
-    });
+        formattedResults += newLine;
+        resultsProcessed++;
+    }
 
     return {
         content: [{type: "text", text: formattedResults.trim()}],

src/server.ts

@@ -7,9 +7,13 @@ import {
     type CallToolRequest,
 } from "@modelcontextprotocol/sdk/types.js";
 import {zodToJsonSchema} from "zod-to-json-schema";
+import { getSystemInfo, getOSSpecificGuidance, getPathGuidance, getDevelopmentToolGuidance } from './utils/system-info.js';
 
-// Shared constants for tool descriptions
-const PATH_GUIDANCE = `IMPORTANT: Always use absolute paths (starting with '/' or drive letter like 'C:\\') for reliability. Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
+// Get system information once at startup
+const SYSTEM_INFO = getSystemInfo();
+const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
+const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
+const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
 
 const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
 
@@ -79,15 +83,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         console.error("Generating tools list...");
         return {
             tools: [
-                // 🚨🚨🚨 IMPORTANT: LOCAL FILE ANALYSIS TOOL SELECTION 🚨🚨🚨
-                // 
-                // FOR ANY LOCAL FILE WORK (CSV, JSON, logs, data analysis):
-                // ✅ ALWAYS USE: start_process + interact_with_process (with Python, R, etc.)
-                // ❌ NEVER USE: Analysis/REPL tool (CANNOT access local files and WILL FAIL)
-                //
-                // The analysis tool is browser-only and cannot read files from the user's computer.
-                // Always use processes for local file analysis!
-
                 // Configuration tools
                 {
                     name: "get_config",
@@ -99,7 +94,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - fileReadLineLimit (max lines for read_file, default 1000)
                         - fileWriteLineLimit (max lines per write_file call, default 50)
                         - telemetryEnabled (boolean for telemetry opt-in/out)
-                        -  version (version of the DesktopCommander)
+                        - version (version of the DesktopCommander)
+                        - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(GetConfigArgsSchema),
                 },
@@ -185,15 +181,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     description: `
                         Write or append to file contents. 
 
-                        🎯 CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
+                        CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
                         This is the normal, recommended way to write files - not an emergency measure.
 
                         STANDARD PROCESS FOR ANY FILE:
                         1. FIRST → write_file(filePath, firstChunk, {mode: 'rewrite'})  [≤30 lines]
                         2. THEN → write_file(filePath, secondChunk, {mode: 'append'})   [≤30 lines]
                         3. CONTINUE → write_file(filePath, nextChunk, {mode: 'append'}) [≤30 lines]
 
-                        ⚠️ ALWAYS CHUNK PROACTIVELY - don't wait for performance warnings!
+                        ALWAYS CHUNK PROACTIVELY - don't wait for performance warnings!
 
                         WHEN TO CHUNK (always be proactive):
                         1. Any file expected to be longer than 25-30 lines
@@ -347,19 +343,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     description: `
                         Start a new terminal process with intelligent state detection.
 
-                        🚨 PRIMARY TOOL FOR FILE ANALYSIS AND DATA PROCESSING
+                        PRIMARY TOOL FOR FILE ANALYSIS AND DATA PROCESSING
                         This is the ONLY correct tool for analyzing local files (CSV, JSON, logs, etc.).
                         The analysis tool CANNOT access local files and WILL FAIL - always use processes for file-based work.
 
-                        ⚠️ CRITICAL RULE: For ANY local file work, ALWAYS use this tool + interact_with_process, NEVER use analysis/REPL tool.
+                        CRITICAL RULE: For ANY local file work, ALWAYS use this tool + interact_with_process, NEVER use analysis/REPL tool.
 
-                        🪟 WINDOWS SHELL TROUBLESHOOTING:
-                        If Node.js or Python commands fail with "not recognized" errors on Windows:
-                        - Try different shells: specify shell parameter as "cmd" or "powershell.exe"
-                        - PowerShell may have execution policy restrictions for some tools
-                        - CMD typically has better compatibility with development tools like Node.js/Python
-                        - Example: start_process("node --version", shell="cmd") if PowerShell fails
-                        - Use set_config_value to change defaultShell if needed
+                        ${OS_GUIDANCE}
 
                         REQUIRED WORKFLOW FOR LOCAL FILES:
                         1. start_process("python3 -i") - Start Python REPL for data analysis
@@ -389,12 +379,12 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - Early exit prevents unnecessary waiting
 
                         STATES DETECTED:
-                        🔄 Process waiting for input (shows prompt)
-                        ✅ Process finished execution  
-                        ⏳ Process running (use read_process_output)
+                        Process waiting for input (shows prompt)
+                        Process finished execution  
+                        Process running (use read_process_output)
 
-                        ✅ ALWAYS USE FOR: Local file analysis, CSV processing, data exploration, system commands
-                        ❌ NEVER USE ANALYSIS TOOL FOR: Local file access (analysis tool is browser-only and WILL FAIL)
+                        ALWAYS USE FOR: Local file analysis, CSV processing, data exploration, system commands
+                        NEVER USE ANALYSIS TOOL FOR: Local file access (analysis tool is browser-only and WILL FAIL)
 
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
@@ -420,9 +410,9 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - Works with Python, Node.js, R, Julia, etc.
 
                         DETECTION STATES:
-                        🔄 Process waiting for input (ready for interact_with_process)
-                        ✅ Process finished execution
-                        ⏱️ Timeout reached (may still be running)
+                        Process waiting for input (ready for interact_with_process)
+                        Process finished execution
+                        Timeout reached (may still be running)
 
                         ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(ReadProcessOutputArgsSchema),
@@ -432,11 +422,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     description: `
                         Send input to a running process and automatically receive the response.
 
-                        🚨 CRITICAL: THIS IS THE PRIMARY TOOL FOR ALL LOCAL FILE ANALYSIS
+                        CRITICAL: THIS IS THE PRIMARY TOOL FOR ALL LOCAL FILE ANALYSIS
                         For ANY local file analysis (CSV, JSON, data processing), ALWAYS use this instead of the analysis tool.
                         The analysis tool CANNOT access local files and WILL FAIL - use processes for ALL file-based work.
 
-                        📁 FILE ANALYSIS PRIORITY ORDER (MANDATORY):
+                        FILE ANALYSIS PRIORITY ORDER (MANDATORY):
                         1. ALWAYS FIRST: Use this tool (start_process + interact_with_process) for local data analysis
                         2. ALTERNATIVE: Use command-line tools (cut, awk, grep) for quick processing  
                         3. NEVER EVER: Use analysis tool for local file access (IT WILL FAIL)
@@ -470,8 +460,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 
                         Returns execution result with status indicators.
 
-                        ✅ ALWAYS USE FOR: CSV analysis, JSON processing, file statistics, data visualization prep, ANY local file work
-                        ❌ NEVER USE ANALYSIS TOOL FOR: Local file access (it cannot read files from disk and WILL FAIL)
+                        ALWAYS USE FOR: CSV analysis, JSON processing, file statistics, data visualization prep, ANY local file work
+                        NEVER USE ANALYSIS TOOL FOR: Local file access (it cannot read files from disk and WILL FAIL)
 
                         ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(InteractWithProcessArgsSchema),
@@ -522,33 +512,6 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         ${CMD_PREFIX_DESCRIPTION}`,
                     inputSchema: zodToJsonSchema(KillProcessArgsSchema),
                 },
-
-                // 🚨🚨🚨 CRITICAL TOOL SELECTION GUIDANCE 🚨🚨🚨
-                //
-                // FOR LOCAL FILE ANALYSIS (CSV, JSON, logs, data files):
-                // ✅ ALWAYS USE: start_process + interact_with_process 
-                // ✅ ALTERNATIVE: Command-line tools (read_file, search_code, cut, awk, grep)
-                // ❌ NEVER EVER USE: Analysis tool (CANNOT access local files and WILL FAIL)
-                //
-                // 🔴 ANALYSIS/REPL TOOL LIMITATIONS:
-                // - CANNOT read files from user's computer/file system
-                // - ONLY works with uploaded files or web data
-                // - Browser-based JavaScript runtime only
-                // - NO access to pandas, numpy, or local Python libraries
-                //
-                // 🟢 PROCESS TOOLS ADVANTAGES:
-                // - CAN access ALL local files
-                // - Full system power (Python, R, databases, etc.)
-                // - Handle files of ANY size
-                // - Access to all installed libraries and tools
-                //
-                // MANDATORY WORKFLOW FOR LOCAL FILES:
-                // 1. start_process("python3 -i") 
-                // 2. interact_with_process(pid, "import pandas as pd")
-                // 3. interact_with_process(pid, "df = pd.read_csv('/path/to/file.csv')")
-                // 4. interact_with_process(pid, "print(df.head())")
-                //
-                // REMEMBER: "For local file analysis, ALWAYS use processes, NEVER use analysis tool"
             ],
         };
     } catch (error) {

src/terminal-manager.ts

@@ -3,6 +3,7 @@ import { TerminalSession, CommandExecutionResult, ActiveSession } from './types.
 import { DEFAULT_COMMAND_TIMEOUT } from './config.js';
 import { configManager } from './config-manager.js';
 import {capture} from "./utils/capture.js";
+import { analyzeProcessState } from './utils/process-detection.js';
 
 interface CompletedSession {
   pid: number;
@@ -57,16 +58,28 @@ export class TerminalManager {
 
     // For REPL interactions, we need to ensure stdin, stdout, and stderr are properly configured
     // Note: No special stdio options needed here, Node.js handles pipes by default
-    const spawnOptions = { 
-      shell: shellToUse
+
+    // Enhance SSH commands automatically
+    let enhancedCommand = command;
+    if (command.trim().startsWith('ssh ') && !command.includes(' -t')) {
+      enhancedCommand = command.replace(/^ssh /, 'ssh -t ');
+      console.log(`Enhanced SSH command: ${enhancedCommand}`);
+    }
+
+    const spawnOptions: any = { 
+      shell: shellToUse,
+      env: {
+        ...process.env,
+        TERM: 'xterm-256color'  // Better terminal compatibility
+      }
     };
 
     // Spawn the process with an empty array of arguments and our options
-    const process = spawn(command, [], spawnOptions);
+    const childProcess = spawn(enhancedCommand, [], spawnOptions);
     let output = '';
 
-    // Ensure process.pid is defined before proceeding
-    if (!process.pid) {
+    // Ensure childProcess.pid is defined before proceeding
+    if (!childProcess.pid) {
       // Return a consistent error object instead of throwing
       return {
         pid: -1,  // Use -1 to indicate an error state
@@ -76,42 +89,81 @@ export class TerminalManager {
     }
 
     const session: TerminalSession = {
-      pid: process.pid,
-      process,
+      pid: childProcess.pid,
+      process: childProcess,
       lastOutput: '',
       isBlocked: false,
       startTime: new Date()
     };
 
-    this.sessions.set(process.pid, session);
+    this.sessions.set(childProcess.pid, session);
 
     return new Promise((resolve) => {
-      process.stdout.on('data', (data) => {
+      let resolved = false;
+      let periodicCheck: NodeJS.Timeout | null = null;
+
+      // Quick prompt patterns for immediate detection
+      const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
+
+      const resolveOnce = (result: CommandExecutionResult) => {
+        if (resolved) return;
+        resolved = true;
+        if (periodicCheck) clearInterval(periodicCheck);
+        resolve(result);
+      };
+
+      childProcess.stdout.on('data', (data: any) => {
         const text = data.toString();
         output += text;
         session.lastOutput += text;
+
+        // Immediate check for obvious prompts
+        if (quickPromptPatterns.test(text)) {
+          session.isBlocked = true;
+          resolveOnce({
+            pid: childProcess.pid!,
+            output,
+            isBlocked: true
+          });
+        }
       });
 
-      process.stderr.on('data', (data) => {
+      childProcess.stderr.on('data', (data: any) => {
         const text = data.toString();
         output += text;
         session.lastOutput += text;
       });
 
+      // Periodic comprehensive check every 100ms
+      periodicCheck = setInterval(() => {
+        if (output.trim()) {
+          const processState = analyzeProcessState(output, childProcess.pid);
+          if (processState.isWaitingForInput) {
+            session.isBlocked = true;
+            resolveOnce({
+              pid: childProcess.pid!,
+              output,
+              isBlocked: true
+            });
+          }
+        }
+      }, 100);
+
+      // Timeout fallback
       setTimeout(() => {
         session.isBlocked = true;
-        resolve({
-          pid: process.pid!,
+        resolveOnce({
+          pid: childProcess.pid!,
           output,
           isBlocked: true
         });
       }, timeoutMs);
 
-      process.on('exit', (code) => {
-        if (process.pid) {
+      childProcess.on('exit', (code: any) => {
+        if (childProcess.pid) {
           // Store completed session before removing active session
-          this.completedSessions.set(process.pid, {
-            pid: process.pid,
+          this.completedSessions.set(childProcess.pid, {
+            pid: childProcess.pid,
             output: output + session.lastOutput, // Combine all output
             exitCode: code,
             startTime: session.startTime,
@@ -124,10 +176,10 @@ export class TerminalManager {
             this.completedSessions.delete(oldestKey);
           }
 
-          this.sessions.delete(process.pid);
+          this.sessions.delete(childProcess.pid);
         }
-        resolve({
-          pid: process.pid!,
+        resolveOnce({
+          pid: childProcess.pid!,
           output,
           isBlocked: false
         });