Add a more generic support for cli tool discovery (include gh, git, npm, pnpm, bun, node, etc.)

[bhouston]

A configurable list of useful shell tools would be checked for the existence of and then included in the prompt if they exist. If they do not exist, then there will be the option to warn or to error.

I think each tool should have a shell command, e.g. git, gh) and then also a description along with an optional prompt and a required boolean - which means that mycoder will throw an error and exit if the tool is not available, otherwise it will just skip over the tool and not include it in the prompts.

Basically this is making an abstraction on top of the special purpose GitHub mode to make it more generic.

[bhouston]

/mycoder can you give me an analysis of the following issue with ideas and comparisons to other similar systems? Please do no t make a PR.

[bhouston]

Analysis of CLI Tool Discovery Enhancement (Issue #263)

Current State

Mycoder currently has a specialized implementation for GitHub mode that checks for the existence of specific CLI tools (git and gh). This is implemented in packages/cli/src/utils/gitCliCheck.ts and is used to enable/disable GitHub mode in the system prompts.

Proposed Enhancement

The proposed enhancement would create a more generic system for CLI tool discovery with the following features:

1. Configurable Tool List: Allow users to define a list of CLI tools to check for

2. Tool Metadata: Each tool would have:

   • Shell command to check (e.g., git, gh, npm)
   • Description of the tool
   • Optional prompt text to include when the tool is available
   • Required flag to indicate if the tool is mandatory

3. Behavior Control:

   • Warn or error when required tools are missing
   • Include relevant information in prompts when tools are available

Technical Implementation Approaches

1. Leveraging Existing Libraries

Several npm packages could be utilized:

• which (5.0.0): Finds the first instance of an executable in the PATH
• command-exists (1.2.9): Checks if a command exists in the current environment

2. Potential Implementation Structure

// Tool definition interface
interface CliToolDefinition {
  command: string;         // Command to check (e.g., "git")
  description: string;     // Description of the tool
  prompt?: string;         // Text to include in system prompt when available
  required: boolean;       // Whether the tool is required
}

// Result interface
interface CliToolCheckResult {
  available: boolean;      // Whether the tool is available
  version?: string;        // Optional version information
  path?: string;           // Path to the executable
  errors?: string[];       // Any errors encountered
}

// Configuration interface
interface CliToolsConfig {
  tools: CliToolDefinition[];
  errorOnMissing?: boolean;  // Whether to throw an error when required tools are missing
  includeInPrompt?: boolean; // Whether to include tool info in prompts
}

3. Configuration Example

// mycoder.config.js extension
module.exports = {
  // Existing config...
  
  cliTools: [
    {
      command: "git",
      description: "Git version control",
      prompt: "Git is available for version control operations.",
      required: true
    },
    {
      command: "npm",
      description: "Node.js package manager",
      prompt: "NPM is available for package management.",
      required: false
    }
    // More tools...
  ]
}

Comparison with Similar Systems

1. GitHub's Probot: Uses a plugin architecture where each plugin can declare its dependencies, and the system checks for their availability.

2. VS Code Extensions: Extensions can declare command dependencies that the system verifies at activation time.

3. DevContainers: Uses a feature system that checks for and installs required tools in development containers.

4. Deno Task Runner: Checks for required tools before executing tasks and provides helpful error messages when missing.

5. nx: Has a system for checking and installing missing dependencies that are required for specific commands.

Benefits

1. Flexibility: Users can configure which tools should be checked and included
2. Better Context: AI models get more accurate information about available tools
3. Error Prevention: Early detection of missing required tools
4. Extensibility: Easy to add support for new tools without code changes

Potential Challenges

1. Performance: Checking for many tools could slow down startup
2. Configuration Complexity: Need to balance flexibility with ease of use
3. Prompt Length: Too many tools could make the system prompt too long
4. Cross-Platform Issues: Different behavior on Windows vs. Unix systems

Recommendation

The proposed enhancement would significantly improve mycoder's flexibility and capabilities. By building on the existing GitHub mode implementation and leveraging established libraries, this feature could be implemented with relatively low risk while providing substantial benefits to users working in diverse development environments.

Key implementation considerations should include:

• Creating a clean abstraction that works across platforms
• Designing a user-friendly configuration interface
• Ensuring backward compatibility with existing GitHub mode
• Optimizing performance for quick startup times

[bhouston]

I've provided an analysis of the CLI tool discovery enhancement as requested. The analysis includes:

• Current state assessment
• Proposed enhancement details
• Technical implementation approaches
• Comparison with similar systems
• Benefits and potential challenges
• Recommendations for implementation

As instructed, I have not created a PR for this feature. Let me know if you need any clarification or have additional questions about the analysis.