{
  "id": "page:library-cli-mcp-development",
  "_kind": "Page",
  "_file": "wiki/library/cli-mcp-development.md",
  "_cluster": "wiki",
  "attributes": {
    "nodeKind": "Page",
    "title": "CLI and MCP Development Specialization (Library)",
    "displayName": "CLI and MCP Development Specialization (Library)",
    "slug": "library/cli-mcp-development",
    "articlePath": "wiki/library/cli-mcp-development.md",
    "article": "\n# CLI and MCP Development Specialization\n\n**Comprehensive guide to Command Line Interface Development, Model Context Protocol Development, Terminal Applications, Shell Scripting, and Developer Tools CLI.**\n\n## Overview\n\nThis specialization encompasses the design, development, and deployment of command-line interfaces and Model Context Protocol (MCP) implementations that enable AI-powered developer tools. It covers the full spectrum from simple shell scripts to complex interactive terminal applications and sophisticated MCP servers that extend AI capabilities.\n\n### Core Domains\n\n- **CLI Development**: Building robust command-line applications with intuitive argument parsing, helpful output, and excellent user experience\n- **MCP Development**: Implementing Model Context Protocol servers and tools that extend AI assistant capabilities\n- **Terminal Applications**: Creating interactive terminal user interfaces (TUI) with rich visual feedback\n- **Shell Scripting**: Automating tasks through portable, maintainable shell scripts\n- **Developer Tools**: Building productivity tools that integrate into development workflows\n\n## Roles and Responsibilities\n\n### CLI Developer\n\n**Primary Focus**: Design and implementation of command-line applications\n\n#### Core Responsibilities\n- **Command Design**: Create intuitive command structures and argument schemas\n- **Argument Parsing**: Implement robust parsing with validation and help generation\n- **Output Formatting**: Design human-readable and machine-parseable output formats\n- **Error Handling**: Provide clear, actionable error messages\n- **Documentation**: Write comprehensive help text and man pages\n- **Testing**: Implement CLI-specific testing strategies\n- **Distribution**: Package and distribute CLI tools across platforms\n\n#### Key Skills\n- **Languages**: Node.js/TypeScript, Python, Go, Rust\n- **Argument Parsers**: Commander.js, Yargs, argparse, Click, Cobra, clap\n- **Terminal Libraries**: Chalk, Inquirer, blessed, Rich, Bubble Tea\n- **Build Tools**: pkg, PyInstaller, goreleaser, cargo\n- **Testing**: Bats, pytest, go test, snapshot testing\n- **Documentation**: Help text generation, man page authoring\n\n#### Typical Workflows\n1. **New CLI Tool**: Design commands -> Implement argument parsing -> Add business logic -> Create output formatting -> Write tests -> Document usage\n2. **Feature Addition**: Analyze requirements -> Design command structure -> Implement with backwards compatibility -> Update documentation\n3. **Bug Fix**: Reproduce issue -> Analyze argument parsing/execution flow -> Fix and add regression test\n4. **Release**: Version bump -> Generate changelog -> Build binaries -> Publish to package managers\n\n### MCP Developer\n\n**Primary Focus**: Implementation of Model Context Protocol servers and tools\n\n#### Core Responsibilities\n- **MCP Server Development**: Build servers that expose tools and resources to AI assistants\n- **Tool Implementation**: Create MCP tools with clear schemas and reliable execution\n- **Resource Management**: Implement resource providers for dynamic content access\n- **Protocol Compliance**: Ensure correct implementation of MCP specification\n- **Error Handling**: Design robust error responses and recovery mechanisms\n- **Security**: Implement proper input validation and sandboxing\n- **Documentation**: Document tool capabilities and usage patterns\n\n#### Key Skills\n- **MCP SDK**: @modelcontextprotocol/sdk, mcp Python package\n- **Languages**: TypeScript/Node.js, Python\n- **JSON Schema**: Tool and resource schema definition\n- **Transport Protocols**: stdio, HTTP/SSE, WebSocket\n- **Security**: Input validation, sandboxing, permission models\n- **Testing**: MCP testing patterns, mock clients\n\n#### MCP Architecture Components\n- **Server**: Process that implements MCP protocol\n- **Tools**: Functions that AI can invoke with parameters\n- **Resources**: Content providers (files, APIs, databases)\n- **Prompts**: Pre-defined prompt templates\n- **Transport**: Communication layer (stdio, HTTP, WebSocket)\n\n#### Typical Workflows\n1. **New MCP Server**: Define capabilities -> Implement transport -> Create tools/resources -> Test with MCP client -> Document\n2. **Tool Development**: Design tool schema -> Implement handler -> Add validation -> Test edge cases -> Document parameters\n3. **Resource Provider**: Define resource URI scheme -> Implement content fetching -> Add caching -> Handle errors\n\n### Shell Script Developer\n\n**Primary Focus**: Automation through portable shell scripts\n\n#### Core Responsibilities\n- **Script Development**: Write maintainable, portable shell scripts\n- **Cross-Platform Compatibility**: Ensure scripts work across Unix variants\n- **Error Handling**: Implement robust error detection and recovery\n- **Documentation**: Add inline comments and usage documentation\n- **Security**: Avoid common shell scripting security pitfalls\n- **Testing**: Test scripts across different environments\n\n#### Key Skills\n- **Shells**: Bash, POSIX sh, Zsh\n- **Tools**: sed, awk, grep, find, xargs\n- **Best Practices**: ShellCheck, defensive programming\n- **Cross-Platform**: Cygwin, WSL, Git Bash compatibility\n\n### Terminal Application Developer\n\n**Primary Focus**: Interactive terminal user interfaces\n\n#### Core Responsibilities\n- **TUI Design**: Design intuitive terminal interfaces\n- **Input Handling**: Implement keyboard navigation and interaction\n- **Visual Elements**: Create progress bars, tables, menus, forms\n- **Accessibility**: Ensure compatibility with screen readers\n- **Performance**: Optimize rendering for smooth interaction\n- **Testing**: Test across different terminal emulators\n\n#### Key Skills\n- **TUI Frameworks**: Ink (React), blessed, Bubble Tea, Textual\n- **Terminal Protocols**: ANSI escape sequences, cursor control\n- **Layout**: Box model, flexbox-like layouts for terminal\n- **Input**: Raw input mode, mouse support, key combinations\n\n## CLI Design Principles\n\n### Command Structure Best Practices\n\n#### 1. Hierarchical Command Organization\n```\nmytool [global-options] <command> [command-options] [arguments]\n\nExamples:\n  git commit -m \"message\"\n  docker container ls --all\n  npm run build -- --watch\n```\n\n#### 2. Consistent Naming Conventions\n- Use lowercase, hyphenated command names\n- Verbs for actions: `create`, `delete`, `list`, `show`\n- Consistent flag naming: `--verbose`, `--output`, `--format`\n\n#### 3. Flag Design Guidelines\n```\nShort flags: -v, -h, -o\nLong flags: --verbose, --help, --output\nBoolean flags: --no-cache, --force\nValue flags: --output=file.txt, --format json\n```\n\n### Output Design\n\n#### Human-Readable Output\n- Use colors and formatting for clarity\n- Show progress for long operations\n- Provide clear success/error indicators\n- Use tables for structured data\n\n#### Machine-Parseable Output\n- Support JSON output (`--json`, `--output json`)\n- Support quiet mode (`--quiet`, `-q`)\n- Use exit codes consistently\n- Avoid mixing output with progress indicators\n\n### Error Handling\n\n#### Error Message Guidelines\n```\nError: Could not read configuration file\n  Path: ~/.config/mytool/config.yaml\n  Reason: Permission denied\n\nSuggestion: Run 'chmod 644 ~/.config/mytool/config.yaml' to fix permissions\n```\n\n- State what went wrong clearly\n- Include relevant context (paths, values)\n- Suggest how to fix the issue\n- Use appropriate exit codes\n\n### Exit Codes Convention\n```\n0   - Success\n1   - General error\n2   - Misuse of command (invalid arguments)\n64  - Command line usage error\n65  - Data format error\n66  - Cannot open input file\n73  - Cannot create output file\n74  - I/O error\n130 - Interrupted (Ctrl+C)\n```\n\n## Argument Parsing Patterns\n\n### Common Parser Libraries\n\n#### Node.js/TypeScript\n```typescript\n// Commander.js\nimport { Command } from 'commander';\n\nconst program = new Command();\nprogram\n  .name('mytool')\n  .description('A CLI tool description')\n  .version('1.0.0')\n  .option('-v, --verbose', 'Enable verbose output')\n  .option('-o, --output <file>', 'Output file path')\n  .argument('<input>', 'Input file')\n  .action((input, options) => {\n    // Handle command\n  });\n\n// Yargs\nimport yargs from 'yargs';\n\nconst argv = yargs(process.argv.slice(2))\n  .command('build <project>', 'Build a project', (yargs) => {\n    return yargs.positional('project', { describe: 'Project name' });\n  })\n  .option('verbose', { alias: 'v', type: 'boolean' })\n  .help()\n  .parse();\n```\n\n#### Python\n```python\n# Click\nimport click\n\n@click.command()\n@click.option('--verbose', '-v', is_flag=True, help='Enable verbose output')\n@click.option('--output', '-o', type=click.Path(), help='Output file')\n@click.argument('input_file', type=click.Path(exists=True))\ndef main(verbose, output, input_file):\n    \"\"\"Process INPUT_FILE and generate output.\"\"\"\n    pass\n\n# Argparse\nimport argparse\n\nparser = argparse.ArgumentParser(description='Process files')\nparser.add_argument('input', help='Input file path')\nparser.add_argument('-o', '--output', help='Output file path')\nparser.add_argument('-v', '--verbose', action='store_true')\nargs = parser.parse_args()\n```\n\n#### Go\n```go\n// Cobra\nvar rootCmd = &cobra.Command{\n    Use:   \"mytool\",\n    Short: \"A brief description\",\n    Run: func(cmd *cobra.Command, args []string) {\n        // Main logic\n    },\n}\n\nfunc init() {\n    rootCmd.PersistentFlags().BoolVarP(&verbose, \"verbose\", \"v\", false, \"verbose output\")\n    rootCmd.Flags().StringVarP(&output, \"output\", \"o\", \"\", \"output file\")\n}\n```\n\n### Argument Validation Patterns\n\n```typescript\n// Input validation with helpful errors\nfunction validateInput(options: Options): void {\n  if (!options.input) {\n    throw new ValidationError(\n      'Missing required argument: input',\n      'Provide an input file: mytool <input-file>'\n    );\n  }\n\n  if (!fs.existsSync(options.input)) {\n    throw new ValidationError(\n      `Input file not found: ${options.input}`,\n      'Check that the file exists and the path is correct'\n    );\n  }\n\n  if (options.format && !['json', 'yaml', 'xml'].includes(options.format)) {\n    throw new ValidationError(\n      `Invalid format: ${options.format}`,\n      'Supported formats: json, yaml, xml'\n    );\n  }\n}\n```\n\n## Model Context Protocol (MCP) Architecture\n\n### MCP Overview\n\nThe Model Context Protocol enables AI assistants to interact with external tools and resources through a standardized interface. MCP servers expose capabilities that AI models can discover and invoke.\n\n### Core MCP Concepts\n\n#### Server Structure\n```typescript\nimport { Server } from '@modelcontextprotocol/sdk/server/index.js';\nimport { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';\n\nconst server = new Server(\n  { name: 'my-mcp-server', version: '1.0.0' },\n  { capabilities: { tools: {}, resources: {} } }\n);\n\n// Tool registration\nserver.setRequestHandler(ListToolsRequestSchema, async () => ({\n  tools: [\n    {\n      name: 'search_files',\n      description: 'Search for files matching a pattern',\n      inputSchema: {\n        type: 'object',\n        properties: {\n          pattern: { type: 'string', description: 'Glob pattern' },\n          path: { type: 'string', description: 'Search directory' }\n        },\n        required: ['pattern']\n      }\n    }\n  ]\n}));\n\n// Tool execution\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  const { name, arguments: args } = request.params;\n\n  switch (name) {\n    case 'search_files':\n      return await searchFiles(args.pattern, args.path);\n    default:\n      throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);\n  }\n});\n\n// Start server\nconst transport = new StdioServerTransport();\nawait server.connect(transport);\n```\n\n#### Tool Definition Schema\n```typescript\ninterface ToolDefinition {\n  name: string;           // Unique tool identifier\n  description: string;    // Human-readable description for AI\n  inputSchema: {          // JSON Schema for parameters\n    type: 'object';\n    properties: Record<string, PropertySchema>;\n    required?: string[];\n  };\n}\n\n// Example tool with comprehensive schema\nconst readFileTool: ToolDefinition = {\n  name: 'read_file',\n  description: 'Read contents of a file. Returns file content as text.',\n  inputSchema: {\n    type: 'object',\n    properties: {\n      path: {\n        type: 'string',\n        description: 'Absolute path to the file to read'\n      },\n      encoding: {\n        type: 'string',\n        enum: ['utf8', 'base64', 'hex'],\n        default: 'utf8',\n        description: 'File encoding'\n      },\n      maxLines: {\n        type: 'number',\n        description: 'Maximum lines to read (omit for all)'\n      }\n    },\n    required: ['path']\n  }\n};\n```\n\n#### Resource Definition\n```typescript\n// Resources provide dynamic content access\nserver.setRequestHandler(ListResourcesRequestSchema, async () => ({\n  resources: [\n    {\n      uri: 'file:///workspace/config.json',\n      name: 'Project Configuration',\n      mimeType: 'application/json'\n    },\n    {\n      uri: 'api://github/repos/{owner}/{repo}',\n      name: 'GitHub Repository',\n      mimeType: 'application/json'\n    }\n  ]\n}));\n\nserver.setRequestHandler(ReadResourceRequestSchema, async (request) => {\n  const { uri } = request.params;\n\n  if (uri.startsWith('file://')) {\n    const path = uri.slice(7);\n    const content = await fs.readFile(path, 'utf-8');\n    return {\n      contents: [{ uri, mimeType: 'text/plain', text: content }]\n    };\n  }\n\n  throw new McpError(ErrorCode.InvalidRequest, `Unknown resource: ${uri}`);\n});\n```\n\n### MCP Transport Layers\n\n#### stdio Transport (Default)\n```typescript\n// Server-side\nconst transport = new StdioServerTransport();\nawait server.connect(transport);\n\n// Client-side (spawning server process)\nconst transport = new StdioClientTransport({\n  command: 'node',\n  args: ['./my-server.js']\n});\n```\n\n#### HTTP/SSE Transport\n```typescript\n// For web-based MCP servers\nimport express from 'express';\nimport { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';\n\nconst app = express();\n\napp.get('/sse', async (req, res) => {\n  const transport = new SSEServerTransport('/messages', res);\n  await server.connect(transport);\n});\n\napp.post('/messages', async (req, res) => {\n  // Handle incoming messages\n});\n```\n\n### MCP Best Practices\n\n#### Tool Design Guidelines\n1. **Clear Descriptions**: Write descriptions that help AI understand when to use the tool\n2. **Precise Schemas**: Define exact parameter types and constraints\n3. **Error Messages**: Return helpful error messages the AI can understand\n4. **Idempotency**: Design tools to be safely retryable when possible\n5. **Bounded Output**: Limit output size to avoid context overflow\n\n#### Security Considerations\n```typescript\n// Input validation\nfunction validatePath(path: string): void {\n  // Prevent path traversal\n  const normalized = path.normalize(path);\n  if (normalized.includes('..')) {\n    throw new McpError(ErrorCode.InvalidParams, 'Path traversal not allowed');\n  }\n\n  // Check against allowed directories\n  const allowed = ['/workspace', '/tmp'];\n  if (!allowed.some(dir => normalized.startsWith(dir))) {\n    throw new McpError(ErrorCode.InvalidParams, 'Path outside allowed directories');\n  }\n}\n\n// Rate limiting\nconst rateLimiter = new RateLimiter({ maxRequests: 100, windowMs: 60000 });\n\nserver.setRequestHandler(CallToolRequestSchema, async (request) => {\n  if (!rateLimiter.check()) {\n    throw new McpError(ErrorCode.InvalidRequest, 'Rate limit exceeded');\n  }\n  // ... handle request\n});\n```\n\n## Interactive Terminal Interfaces\n\n### TUI Framework Comparison\n\n| Framework | Language | Style | Best For |\n|-----------|----------|-------|----------|\n| Ink | TypeScript | React components | Complex UIs with state |\n| Blessed | Node.js | Widget-based | Full-screen applications |\n| Bubble Tea | Go | Elm architecture | Elegant, testable TUIs |\n| Textual | Python | Widget-based | Rich Python applications |\n| Rich | Python | Output formatting | Beautiful CLI output |\n\n### Common TUI Patterns\n\n#### Progress Indicators\n```typescript\n// Using ora for spinners\nimport ora from 'ora';\n\nconst spinner = ora('Loading...').start();\ntry {\n  await longOperation();\n  spinner.succeed('Complete');\n} catch (error) {\n  spinner.fail('Failed');\n}\n\n// Progress bar with cli-progress\nimport { SingleBar, Presets } from 'cli-progress';\n\nconst bar = new SingleBar({}, Presets.shades_classic);\nbar.start(100, 0);\nfor (let i = 0; i <= 100; i++) {\n  bar.update(i);\n  await delay(50);\n}\nbar.stop();\n```\n\n#### Interactive Prompts\n```typescript\n// Using Inquirer.js\nimport inquirer from 'inquirer';\n\nconst answers = await inquirer.prompt([\n  {\n    type: 'input',\n    name: 'name',\n    message: 'Project name:',\n    validate: (input) => input.length > 0 || 'Name is required'\n  },\n  {\n    type: 'list',\n    name: 'template',\n    message: 'Select template:',\n    choices: ['React', 'Vue', 'Angular', 'Svelte']\n  },\n  {\n    type: 'confirm',\n    name: 'typescript',\n    message: 'Use TypeScript?',\n    default: true\n  }\n]);\n```\n\n#### Tables and Structured Output\n```typescript\n// Using cli-table3\nimport Table from 'cli-table3';\n\nconst table = new Table({\n  head: ['Name', 'Status', 'Last Updated'],\n  style: { head: ['cyan'] }\n});\n\ntable.push(\n  ['api-server', 'Running', '2 minutes ago'],\n  ['worker', 'Stopped', '1 hour ago'],\n  ['scheduler', 'Running', '5 minutes ago']\n);\n\nconsole.log(table.toString());\n```\n\n## Cross-Platform CLI Considerations\n\n### Path Handling\n```typescript\nimport path from 'path';\nimport os from 'os';\n\n// Use path.join for cross-platform paths\nconst configPath = path.join(os.homedir(), '.config', 'mytool', 'config.json');\n\n// Handle Windows drive letters\nfunction normalizePath(inputPath: string): string {\n  return inputPath.replace(/\\\\/g, '/');\n}\n\n// Platform-specific config directories\nfunction getConfigDir(): string {\n  switch (process.platform) {\n    case 'win32':\n      return process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');\n    case 'darwin':\n      return path.join(os.homedir(), 'Library', 'Application Support');\n    default:\n      return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');\n  }\n}\n```\n\n### Shell Compatibility\n```bash\n#!/usr/bin/env bash\n# Use /usr/bin/env for portability\n\n# Check for required commands\ncommand -v jq >/dev/null 2>&1 || { echo \"jq is required\"; exit 1; }\n\n# Portable string manipulation (avoid bash-specific features for POSIX)\n# Bash-specific: ${var,,} for lowercase\n# Portable: $(echo \"$var\" | tr '[:upper:]' '[:lower:]')\n\n# Handle different sed versions (GNU vs BSD)\nif sed --version 2>/dev/null | grep -q GNU; then\n  sed -i 's/old/new/' file.txt\nelse\n  sed -i '' 's/old/new/' file.txt  # BSD sed\nfi\n```\n\n### Terminal Capabilities\n```typescript\nimport supportsColor from 'supports-color';\n\n// Check color support\nconst useColors = supportsColor.stdout && supportsColor.stdout.hasBasic;\n\n// Check if running in TTY\nconst isInteractive = process.stdin.isTTY && process.stdout.isTTY;\n\n// Fallback for non-interactive mode\nif (!isInteractive) {\n  // Use simple output without prompts\n  console.log(JSON.stringify(result));\n} else {\n  // Use interactive prompts and colors\n  displayInteractiveUI(result);\n}\n```\n\n## Testing Strategies\n\n### CLI Testing Approaches\n\n#### Unit Testing\n```typescript\n// Test argument parsing\ndescribe('CLI argument parsing', () => {\n  it('should parse input file argument', () => {\n    const args = parseArgs(['input.txt']);\n    expect(args.input).toBe('input.txt');\n  });\n\n  it('should parse output flag', () => {\n    const args = parseArgs(['input.txt', '-o', 'output.txt']);\n    expect(args.output).toBe('output.txt');\n  });\n});\n```\n\n#### Integration Testing\n```typescript\nimport { execSync, spawn } from 'child_process';\n\ndescribe('CLI integration', () => {\n  it('should process file and output JSON', () => {\n    const result = execSync('node ./cli.js input.txt --json', {\n      encoding: 'utf-8'\n    });\n    const output = JSON.parse(result);\n    expect(output.success).toBe(true);\n  });\n\n  it('should return error code for missing file', () => {\n    expect(() => {\n      execSync('node ./cli.js nonexistent.txt');\n    }).toThrow();\n  });\n});\n```\n\n#### Snapshot Testing\n```typescript\n// Capture and compare CLI output\ndescribe('CLI output snapshots', () => {\n  it('should match help output', () => {\n    const output = execSync('node ./cli.js --help', { encoding: 'utf-8' });\n    expect(output).toMatchSnapshot();\n  });\n});\n```\n\n### MCP Testing\n```typescript\nimport { Client } from '@modelcontextprotocol/sdk/client/index.js';\n\ndescribe('MCP Server', () => {\n  let client: Client;\n\n  beforeAll(async () => {\n    // Connect to test server\n    client = new Client({ name: 'test-client', version: '1.0.0' }, {});\n    await client.connect(transport);\n  });\n\n  it('should list available tools', async () => {\n    const tools = await client.listTools();\n    expect(tools.tools).toContainEqual(\n      expect.objectContaining({ name: 'read_file' })\n    );\n  });\n\n  it('should execute tool successfully', async () => {\n    const result = await client.callTool({\n      name: 'read_file',\n      arguments: { path: '/tmp/test.txt' }\n    });\n    expect(result.content[0].text).toContain('test content');\n  });\n});\n```\n\n## Distribution and Packaging\n\n### Node.js CLI Distribution\n\n#### npm Publishing\n```json\n{\n  \"name\": \"my-cli-tool\",\n  \"version\": \"1.0.0\",\n  \"bin\": {\n    \"mytool\": \"./dist/cli.js\"\n  },\n  \"files\": [\"dist\"],\n  \"engines\": {\n    \"node\": \">=18\"\n  }\n}\n```\n\n#### Single Executable (pkg/nexe)\n```bash\n# Using pkg\nnpx pkg . --targets node18-linux-x64,node18-macos-x64,node18-win-x64\n\n# Output: mytool-linux, mytool-macos, mytool-win.exe\n```\n\n### Python CLI Distribution\n\n#### PyPI Publishing\n```toml\n# pyproject.toml\n[project.scripts]\nmytool = \"mytool.cli:main\"\n\n[build-system]\nrequires = [\"setuptools>=61.0\"]\nbuild-backend = \"setuptools.build_meta\"\n```\n\n#### PyInstaller Binary\n```bash\npyinstaller --onefile --name mytool cli.py\n```\n\n### Go CLI Distribution\n\n#### goreleaser Configuration\n```yaml\n# .goreleaser.yml\nbuilds:\n  - main: ./cmd/mytool\n    binary: mytool\n    goos: [linux, darwin, windows]\n    goarch: [amd64, arm64]\n\narchives:\n  - format_overrides:\n      - goos: windows\n        format: zip\n\nbrews:\n  - tap:\n      owner: myorg\n      name: homebrew-tap\n    homepage: https://github.com/myorg/mytool\n    description: My CLI tool\n```\n\n### Homebrew Formula\n```ruby\nclass Mytool < Formula\n  desc \"My CLI tool description\"\n  homepage \"https://github.com/myorg/mytool\"\n  url \"https://github.com/myorg/mytool/archive/v1.0.0.tar.gz\"\n  sha256 \"...\"\n  license \"MIT\"\n\n  depends_on \"node\"\n\n  def install\n    system \"npm\", \"install\", *Language::Node.std_npm_install_args(libexec)\n    bin.install_symlink Dir[\"#{libexec}/bin/*\"]\n  end\n\n  test do\n    assert_match \"1.0.0\", shell_output(\"#{bin}/mytool --version\")\n  end\nend\n```\n\n## Goals and Objectives\n\n### CLI Development Goals\n- **Intuitive UX**: Users can discover and use commands without documentation\n- **Fast Execution**: Minimize startup time and operation latency\n- **Reliable Operation**: Consistent behavior across environments\n- **Clear Feedback**: Progress indication and helpful error messages\n- **Easy Distribution**: Simple installation across platforms\n\n### MCP Development Goals\n- **AI Integration**: Seamless integration with AI assistants\n- **Tool Reliability**: Tools that execute correctly and handle errors gracefully\n- **Security**: Safe execution with proper sandboxing and validation\n- **Discoverability**: Well-documented tools that AI can understand and use appropriately\n- **Performance**: Fast tool execution without blocking AI interactions\n\n### Terminal Application Goals\n- **Responsive UI**: Smooth, lag-free interaction\n- **Accessibility**: Work with screen readers and different terminal capabilities\n- **Cross-Platform**: Consistent experience across operating systems\n- **Intuitive Navigation**: Keyboard shortcuts and clear navigation patterns\n\n## Key Metrics\n\n### CLI Performance Metrics\n- **Startup Time**: Time from invocation to first output (target: <200ms)\n- **Command Completion Time**: Execution duration for common operations\n- **Memory Usage**: Peak memory consumption during operation\n- **Binary Size**: Distribution artifact size\n\n### MCP Quality Metrics\n- **Tool Success Rate**: Percentage of successful tool invocations\n- **Response Time**: Latency from request to response\n- **Error Rate**: Frequency of errors and failures\n- **Schema Compliance**: Adherence to defined schemas\n\n### User Experience Metrics\n- **Help Invocation Rate**: How often users need --help\n- **Error Resolution Time**: Time to resolve user errors\n- **Command Completion Rate**: Successful command completions vs. failures\n\n## Learning Path\n\n### Foundational Knowledge\n1. **Shell Basics**: Bash/Zsh fundamentals, pipes, redirection\n2. **Programming**: Node.js, Python, or Go proficiency\n3. **Terminal**: Understanding terminal emulation, ANSI codes\n4. **JSON**: JSON and JSON Schema for data interchange\n\n### Intermediate Skills\n1. **Argument Parsing**: Commander.js, Click, Cobra\n2. **CLI UX Design**: Output formatting, progress indicators\n3. **Testing**: CLI testing strategies and tools\n4. **Distribution**: npm/pip/brew publishing\n\n### Advanced Topics\n1. **MCP Implementation**: Full MCP server development\n2. **TUI Development**: Complex interactive applications\n3. **Cross-Platform**: Windows/macOS/Linux compatibility\n4. **Performance**: Startup optimization, lazy loading\n5. **Security**: Input validation, sandboxing, permissions\n\n## Career Progression\n\n### Entry Level: Junior CLI Developer\n- Focus: Basic CLI tools, argument parsing, simple scripts\n- Experience: 0-2 years\n\n### Mid Level: CLI Developer / MCP Developer\n- Focus: Complex CLI applications, MCP servers, distribution\n- Experience: 2-5 years\n\n### Senior Level: Senior CLI/Platform Developer\n- Focus: Developer tools architecture, CLI frameworks, MCP ecosystem\n- Experience: 5-8 years\n\n### Staff Level: Staff Developer Tools Engineer\n- Focus: Developer experience strategy, tool ecosystem design\n- Experience: 8+ years\n\n---\n\n**Created**: 2026-01-24\n**Version**: 1.0.0\n**Specialization**: CLI and MCP Development\n",
    "documents": [
      "specialization:cli-mcp-development"
    ]
  },
  "outgoingEdges": [
    {
      "from": "page:library-cli-mcp-development",
      "to": "specialization:cli-mcp-development",
      "kind": "documents"
    }
  ],
  "incomingEdges": [
    {
      "from": "page:index",
      "to": "page:library-cli-mcp-development",
      "kind": "contains_page"
    }
  ]
}