🚀 AI Capability Extension Suite
What if AI agents could actually see, debug, and control your development environment?
We've built the most comprehensive suite of MCP servers that give AI agents superpowers they've never had before. This isn't just another tool collection—it's a paradigm shift that transforms AI assistants from code generators into intelligent development partners with runtime visibility, system control, and physical world access.
📝 Note: All packages have been split into individual Git submodules with their own repositories for better maintainability and independent versioning. Each package now has its own dedicated repository under the Digital-Defiance organization.
📦 Quick Index
🐛 MCP ACS Debugger
25+ debugging tools for AI agents | VS Code Extension | NPM | Docker
- ✅ VS Code Extension with GitHub Copilot integration
- ✅ 94.53% test coverage, 1,059 tests
- ✅ Performance profiling, hang detection, advanced breakpoints
- 🎯 Kiro Superpower in development - Enhanced AI debugging workflows
📸 MCP ACS Screenshot
Visual UI capture and analysis | VS Code Extension | NPM | Docker
- ✅ Full screen, window, and region capture
- ✅ PII masking with OCR integration
- ✅ 267 tests, cross-platform support
- 🎯 Kiro Superpower in development - AI-powered visual analysis
⚙️ MCP ACS Process
Enterprise-grade process management | VS Code Extension | NPM | Docker
- ✅ 12 process management tools
- ✅ 6 layers of security validation
- ✅ Resource monitoring and service management
- 🎯 Kiro Superpower in development - Intelligent process orchestration
🎯 Akira
Spec-driven development for GitHub Copilot | Repository
- ✅ EARS-compliant requirements engineering
- ✅ Property-based testing integration
- ✅ Structured Requirements → Design → Tasks → Execution workflow
- ✅ MCP-powered persistent context across chat sessions
🎯 Now Available on VS Code Marketplace
⚡ Install the VS Code Extension →
Our flagship MCP ACS Debugger is now available as a native VS Code extension, bringing professional-grade debugging capabilities directly to your editor with zero configuration required.
Why developers love it:
- ✅ One-click installation from VS Code Marketplace
- ✅ GitHub Copilot integration for AI-powered debugging
- ✅ 25+ debugging tools accessible to AI agents
- ✅ Zero configuration - works immediately after install
- ✅ Enterprise-grade quality with 94.53% test coverage
- ✅ 1,059 passing tests
🤔 The Problem We're Solving
AI agents today are powerful but blind:
- ❌ Can't see what code actually does when it runs
- ❌ Can't capture your screen or record demonstrations
- ❌ Can't manage files beyond basic read/write
- ❌ Can't control processes or applications
- ❌ Can't interact with your actual development environment
Result: You're stuck doing manual work that AI should handle.
🎯 What We've Built: The Complete Solution
The AI Capability Extension Suite provides 5 comprehensive MCP servers that give AI agents professional-grade capabilities, plus Akira:
🐛 1. MCP ACS Debugger
The most comprehensive debugging interface for AI agents - our flagship product
Repositories: Core | Server | VS Code Extension
✨ Now available as a VS Code extension! Install from Marketplace →
The Problem: AI agents were blind to runtime behavior. They could read your code and suggest fixes, but couldn't see what was actually happening when your code ran. Debugging remained a frustratingly manual process.
The Solution: AI agents can now debug like senior developers—setting breakpoints, inspecting variables, profiling performance, and detecting infinite loops in real-time. Available as both a standalone MCP server and a native VS Code extension with GitHub Copilot integration.
🎨 VS Code Extension Features
Zero-Configuration Setup:
- Install from VS Code Marketplace with one click
- Automatic MCP server integration
- No manual configuration required
- VS Code extension works with any language via Debug Adapter Protocol
- Standalone MCP server works with Node.js/JavaScript via Chrome DevTools Protocol
GitHub Copilot Integration:
- AI-powered debugging assistance in your editor
- Copilot can access debugging context and tools
- Natural language debugging commands
- Intelligent breakpoint suggestions
Native IDE Integration:
- Language Server Protocol (LSP) for code intelligence
- Debug Adapter Protocol (DAP) for seamless debugging
- Hover providers for variable inspection
- Code lens for breakpoint management
- Integrated debugging UI
Professional Debugging Workflow:
- Set breakpoints with right-click context menu
- Step through code with keyboard shortcuts
- Inspect variables in hover tooltips
- View call stack in debug panel
- Profile performance without leaving editor
Language Support:
- VS Code Extension: Multi-language support via Debug Adapter Protocol
- JavaScript/TypeScript, Python, Java, C/C++, Go, Rust, PHP, Ruby, and more
- Test Frameworks: Jest, Mocha, Vitest, pytest, JUnit, go test, cargo test
- Frameworks: React, Vue, Angular, Django, Spring Boot, and more
- Standalone MCP Server: Node.js/JavaScript only via Chrome DevTools Protocol
- Full TypeScript support with source maps
- Test Frameworks: Jest, Mocha, Vitest
- Frameworks: Express, Nest.js, React (Node.js SSR), and more
🔥 Why This Changes Everything
For Developers:
- "Debug this for me" becomes reality—AI investigates and fixes runtime issues
- Instant performance insights—AI identifies bottlenecks and memory leaks automatically
- Intelligent test debugging—AI debugs failing tests and suggests precise fixes
- Proactive hang detection—Never lose time to infinite loops again
For AI Agents:
- Runtime visibility—See what's actually happening when code executes
- Interactive debugging—Set breakpoints, step through code, inspect state
- Performance analysis—Profile CPU, memory, and execution timelines
- Intelligent problem solving—Combine static analysis with runtime behavior
🛠️ 25+ Professional Debugging Tools
Core Debugging (17 tools):
- 🚀 Session management (start, stop with clean shutdown)
- 🎯 Breakpoint operations (set, remove, toggle, list with conditional logic)
- ▶️ Execution control (continue, step over/into/out, pause)
- 🔍 Variable inspection (evaluate expressions, inspect objects, watch variables)
- 🗺️ Call stack navigation (get stack, switch frames)
- ⚠️ Hang detection (intelligent infinite loop identification)
Advanced Breakpoints (4 tools):
- 📝 Logpoints - Non-breaking observation with variable interpolation
- 🚨 Exception breakpoints - Break on caught/uncaught exceptions with filtering
- 🎯 Function breakpoints - Break on function entry with regex matching
- 🔢 Hit count conditions - Break after N hits or every Nth hit
Performance Profiling (4 tools):
- 🔥 CPU profiling - Real-time performance analysis with flame graphs
- 🧠 Memory profiling - Heap snapshots and leak detection
- 📉 Performance metrics - Timeline analysis and regression detection
- 📊 Resource monitoring - Track CPU, memory, and execution patterns
🏆 What Makes This Different
Comparison with Other Solutions:
Key Differentiators:
- 25+ tools vs basic breakpoint/step operations in alternatives
- Performance profiling (CPU, memory, timeline) - unique in MCP ecosystem
- Hang detection with infinite loop identification - no other MCP server has this
- Advanced breakpoint types (logpoints, exception, hit count, function)
- Enterprise security (authentication, rate limiting, PII masking, audit logging)
- Production readiness (graceful shutdown, circuit breakers, retry logic)
- Multi-language support via VS Code's Debug Adapter Protocol
- Source map support for TypeScript and transpiled languages
- Test framework integration (Jest, Mocha, Vitest, pytest, JUnit, go test, cargo test)
- 94.53% test coverage with 1,059 tests (most MCP servers have minimal testing)
- Property-based testing with 22 correctness properties
- Load testing with 100+ concurrent sessions
- Multiple deployment options (VS Code extension, NPM, Docker, binaries)
- Native VS Code integration with LSP/DAP protocols
- GitHub Copilot integration for AI-powered debugging
📊 Enterprise-Grade Quality
Most MCP servers are hobby projects. We've built enterprise software:
- 94.53% line coverage exceeding 90% enterprise target ✅
- 83.45% branch coverage approaching 85% target
- 1,059 tests with 99.81% pass rate
- Zero skipped tests ✅
- 22 correctness properties verified with fast-check
- Load testing (100+ concurrent debug sessions)
- Chaos testing (random failures, network issues)
- Security testing (authentication bypass attempts)
- Performance benchmarks (sub-100ms response times)
- Compatibility testing (Node.js 16-22, TypeScript 4.x-5.x)
🎮 Real-World Use Cases
"AI, debug this failing test"
You: "My Jest test is failing but I can't figure out why"
AI: *Sets breakpoints in test, inspects variables, identifies exact divergence*
AI: "Line 42: API returns string but test expects number. Here's the fix..."
"AI, find the performance bottleneck"
You: "This function is slow but I don't know why"
AI: *Starts CPU profiling, analyzes flame graphs, identifies hot paths*
AI: "Bottleneck in nested loop on line 156. Here's 10x faster version..."
"AI, why is my app hanging?"
You: "My Node.js app freezes randomly"
AI: *Detects infinite loop, captures call stack, identifies root cause*
AI: "Infinite loop in processQueue() - exit condition never true because..."
"AI, debug this Node.js issue"
You: "My Express server crashes on startup"
AI: *Sets breakpoints, inspects variables, traces execution*
AI: "Missing environment variable 'PORT' on line 23. Server tries to bind to undefined port..."
🚀 Get Started
Option 1: VS Code Extension (Recommended for VS Code users)
# Install from VS Code Marketplace
# Search for "MCP ACS Debugger" or visit:
# https://marketplace.visualstudio.com/items?itemName=digitaldefiance.ts-mcp-debugger
# Or install via command line
code --install-extension digitaldefiance.ts-mcp-debugger
Features:
- ✅ Zero configuration - Works out of the box
- ✅ GitHub Copilot integration - AI-powered debugging assistance
- ✅ Native VS Code debugging - Seamless IDE integration
- ✅ Language Server Protocol - Smart code intelligence
- ✅ Debug Adapter Protocol - Full debugging capabilities
Option 2: Standalone MCP Server (For other AI agents)
# NPM (Recommended)
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Docker
docker run digitaldefiance/mcp-debugger-server
# Configure your AI agent (Kiro, Amazon Q, etc.)
{
"servers": {
"debugger": {
"command": "mcp-debugger-server"
}
}
}
Option 3: From Source
# Clone and build
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build
# Run debugger server
node packages/mcp-debugger-server/dist/src/index.js
📚 Documentation:
- 👉 VS Code Extension Guide
- 👉 Complete debugger documentation
- 👉 Production status report
- 👉 MCP ACS Debugger Server Repository
- 👉 MCP ACS Debugger Core Repository
- 👉 VS Code Extension Repository
📦 Installation & Usage
VS Code Extension (Recommended for VS Code users):
-
Install from Marketplace:
- Open VS Code
- Go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)
- Search for "MCP ACS Debugger"
- Click Install
- Or visit: https://marketplace.visualstudio.com/items?itemName=digitaldefiance.ts-mcp-debugger
-
Start Debugging:
- VS Code extension: Open any source code file
- Standalone MCP server: Open JavaScript or TypeScript file
- Set breakpoints by clicking in the gutter
- Press F5 to start debugging
- Use GitHub Copilot to ask debugging questions
-
Use with Copilot:
You: "@workspace debug this failing test" Copilot: *Uses MCP debugger to investigate* Copilot: "Found the issue on line 42. The API returns..."
Standalone MCP Server (For other AI agents):
-
Install globally:
npm install -g @ai-capabilities-suite/mcp-debugger-server -
Configure your AI agent:
{ "mcpServers": { "debugger": { "command": "mcp-debugger-server" } } } -
Use with your AI agent:
You: "Debug my Node.js app" AI: *Uses MCP tools to start debugging session* AI: "Started debug session. Set breakpoint at app.js:42..."
📸 2. MCP ACS Screenshot
Transform AI agents from code readers into visual UI experts and documentation partners
Repositories: MCP ACS Screenshot | VS Code Extension
✨ Now available on NPM, Docker Hub, and VS Code Marketplace!
The Problem: AI agents were blind to your actual user interface. They could read HTML/CSS and suggest improvements, but couldn't see what users actually experience—broken layouts, poor contrast, misaligned elements, or accessibility issues.
The Solution: AI agents now have visual superpowers—they can see, analyze, and document your applications like a senior UX designer. From automated documentation generation to accessibility audits, AI can now work with what users actually see.
🎨 Key Features
Screenshot Capture:
- Full screen capture with multiple format support (PNG, JPEG, WebP, BMP)
- Window-specific capture by title or ID
- Region capture with precise boundary control
- Display management - list and target specific monitors
- Quality control - adjustable compression and optimization
Privacy & Security:
- PII masking with Tesseract OCR integration
- Window exclusion - skip sensitive applications
- Secure defaults - privacy-first configuration
- Permission handling - proper system permission checks
Cross-Platform Support:
- Linux: X11 and Wayland support
- macOS: Native screenshot APIs
- Windows: Windows API integration
- Docker: Headless capture with Xvfb
🛠️ 5 Professional Screenshot Tools
screenshot_capture_full- Capture entire screen with format options (PNG, JPEG, WebP, BMP)screenshot_capture_window- Capture specific application windows by title or IDscreenshot_capture_region- Capture rectangular screen regions with precise boundariesscreenshot_list_displays- List connected displays with resolutions and scalingscreenshot_list_windows- List visible windows with titles, positions, and dimensions
Privacy & Security Features:
- PII Masking - Automatically detect and blur sensitive information (emails, phone numbers, credit cards)
- Window Exclusion - Skip password managers and authentication dialogs
- Secure Defaults - Privacy-first configuration out of the box
- Permission Handling - Proper system permission checks and user consent
📊 Enterprise-Grade Quality
- 267 tests with 100% pass rate
- Full MCP protocol compliance verified
- E2E testing (25 tests) for protocol validation
- Unit testing (242 tests) for comprehensive coverage
- VSCode extension testing (80+ tests)
- Cross-platform validation (Linux, macOS, Windows)
- Graceful failure handling for headless environments
🚀 Get Started
NPM Package:
npm install -g @ai-capabilities-suite/mcp-screenshot
npx @ai-capabilities-suite/mcp-screenshot
Docker:
docker run -v $(pwd)/screenshots:/app/screenshots digitaldefiance/mcp-screenshot:latest
VSCode Extension:
- Search "MCP ACS Screenshot" in VS Code Extensions
- Or visit: https://marketplace.visualstudio.com/items?itemName=DigitalDefiance.mcp-screenshot
🎯 Revolutionary Use Cases
"AI, create professional documentation"
You: "Document the user onboarding flow"
AI: *Captures each step, analyzes UI elements*
AI: "Generated step-by-step guide with 8 annotated screenshots, user journey map, and accessibility notes..."
"AI, audit this design for accessibility"
You: "Check if this form meets WCAG standards"
AI: *Captures form, analyzes contrast and spacing*
AI: "Found 3 issues: Submit button has 2.1:1 contrast (needs 4.5:1), labels lack focus indicators, touch targets under 44px..."
"AI, help debug this responsive layout"
You: "Why does my navbar break on mobile?"
AI: *Captures multiple viewport sizes*
AI: "Navigation collapses at 768px but hamburger menu overlaps logo. Here's the CSS fix with before/after comparison..."
"AI, compare these two design options"
You: "Which landing page converts better?"
AI: *Captures both versions, analyzes visual hierarchy*
AI: "Version B has 34% better visual flow—CTA button more prominent, hero text clearer, social proof positioned optimally..."
"AI, create a bug report with visuals"
You: "The checkout form validation isn't working"
AI: *Captures error states and user flow*
AI: "Created detailed bug report with 5 screenshots showing error conditions, expected vs actual behavior, and reproduction steps..."
🔥 What This Changes
Before: AI worked blind, relying on code descriptions
- ❌ "The layout looks broken" → AI guesses what's wrong
- ❌ "Create documentation" → AI writes generic text without visuals
- ❌ "Check accessibility" → AI can only review code, not actual contrast
- ❌ "Debug responsive design" → AI can't see actual breakpoint behavior
After: AI sees and analyzes your actual user interface
- ✅ Visual debugging - AI identifies exact pixel-level issues
- ✅ Intelligent documentation - AI creates guides with real screenshots and annotations
- ✅ Accessibility audits - AI measures actual contrast ratios and spacing
- ✅ Responsive testing - AI captures and compares different screen sizes
- ✅ Design analysis - AI evaluates visual hierarchy and user experience
- ✅ Professional bug reports - AI creates detailed reports with visual evidence
📚 Documentation:
📁 3. MCP Filesystem
Advanced file operations beyond basic I/O with strict security boundaries
Repositories: MCP Filesystem | VS Code Extension
✨ Now available on NPM and VS Code Marketplace!
The Problem: AI agents needed advanced file operations beyond basic read/write, but without proper security boundaries, this posed significant risks—path traversal attacks, unauthorized access to system files, and exposure of sensitive credentials.
The Solution: AI agents now have enterprise-grade filesystem operations with 10 layers of security validation. From batch operations with atomic rollback to real-time directory watching, AI can now safely manage your workspace files.
🔥 Key Features
Advanced Operations:
- Batch operations - Execute multiple file operations atomically with rollback support
- Directory watching - Monitor filesystem changes in real-time with event filtering
- File search & indexing - Fast full-text search with metadata filtering
- Checksum operations - Compute and verify file integrity (MD5, SHA-1, SHA-256, SHA-512)
- Symlink management - Create and manage symbolic links within workspace boundaries
- Disk usage analysis - Analyze directory sizes and identify large files
- Directory operations - Recursive copy, sync, and atomic file replacement
Security (Defense-in-Depth):
- Workspace jail - All operations confined to configured workspace root
- 10-layer path validation - Multiple security checks prevent path traversal
- Hardcoded blocklists - System paths and sensitive files always blocked (cannot be disabled)
- Rate limiting - Configurable operation limits per minute
- Audit logging - Complete operation tracking for compliance
- Platform-specific security - Automatic OS-specific boundary enforcement
🛠️ 12 Professional Filesystem Tools
fs_batch_operations- Execute multiple operations atomically with rollbackfs_watch_directory- Monitor directories for real-time changesfs_get_watch_events- Retrieve accumulated filesystem eventsfs_stop_watch- Stop watch sessions and clean up resourcesfs_search_files- Search by name, content, or metadatafs_build_index- Build searchable index for fast searchingfs_create_symlink- Create symbolic links within workspacefs_compute_checksum- Compute file checksums for integrity verificationfs_verify_checksum- Verify file checksums match expected valuesfs_analyze_disk_usage- Analyze disk usage and identify large filesfs_copy_directory- Recursively copy directories with optionsfs_sync_directory- Sync directories by copying only newer/missing files
🚀 Get Started
NPM Package:
npm install -g @ai-capabilities-suite/mcp-filesystem
mcp-filesystem --config ./mcp-filesystem-config.json
VS Code Extension:
- Search "MCP ACS Filesystem" in VS Code Extensions
- Or visit: https://marketplace.visualstudio.com/items?itemName=DigitalDefiance.mcp-acs-filesystem
🎯 Revolutionary Use Cases
"AI, backup all my TypeScript files"
You: "Create atomic backup of all .ts files to backup folder"
AI: *Uses batch operations with rollback*
AI: "Backed up 47 TypeScript files (2.3 MB) atomically. All operations succeeded, no rollback needed."
"AI, watch for changes and rebuild"
You: "Watch src directory and notify me of changes"
AI: *Starts directory watch with filters*
AI: "Watching src/ recursively. Detected 3 changes: file1.ts modified, file2.ts created, file3.ts deleted."
"AI, find all TODOs in the codebase"
You: "Search for TODO comments in TypeScript files"
AI: *Builds index and searches content*
AI: "Found 23 TODO comments across 12 files. Most common: 'TODO: Add error handling' (5 occurrences)."
"AI, verify file integrity"
You: "Compute SHA-256 checksum for release.zip"
AI: *Computes checksum*
AI: "SHA-256: a3f5b8c2... File integrity verified against expected checksum."
"AI, analyze disk usage"
You: "What's taking up space in node_modules?"
AI: *Analyzes disk usage*
AI: "node_modules: 487 MB. Largest: webpack (45 MB), typescript (38 MB), @types/* (92 MB total)."
📚 Documentation:
- 👉 MCP Filesystem Documentation
- 👉 VS Code Extension Documentation
- 👉 Security Documentation
- 👉 Docker Deployment Guide
⚙️ 4. MCP ACS Process
Enterprise-grade process management with strict security boundaries
Repositories: MCP ACS Process | VS Code Extension
✨ Now available on NPM, Docker Hub, and VS Code Marketplace!
The Problem: AI agents couldn't safely manage system processes. They needed to run commands, monitor resources, and manage services, but without proper security boundaries, this posed significant risks—command injection, resource exhaustion, and privilege escalation.
The Solution: AI agents now have enterprise-grade process management with 6 layers of security validation. From launching processes with resource limits to managing long-running services with auto-restart, AI can now safely orchestrate your development environment.
🔥 Key Features
Process Management:
- Process launching with arguments and environment variables
- Resource monitoring - Track CPU, memory, threads, and I/O in real-time
- Output capture - Separate stdout and stderr streams
- Process termination - Graceful (SIGTERM) and forced (SIGKILL) with timeout escalation
- Interactive processes - Send stdin input and retrieve buffered output
- Timeout management - Automatic termination after specified duration
Service Management:
- Long-running services with auto-restart capabilities
- Health checks - Periodic validation of service health
- Restart policies - Configurable retry limits and backoff strategies
- Service lifecycle - Start, stop, restart, and monitor services
Process Groups:
- Group management - Organize related processes
- Pipeline creation - Chain processes with stdout/stdin piping
- Batch operations - Terminate entire groups at once
Security (Defense-in-Depth):
- Executable allowlist - Only pre-approved executables can run
- Argument validation - Prevent command injection attacks
- Environment sanitization - Remove dangerous environment variables
- Resource limits - CPU, memory, and time constraints
- Privilege prevention - Block setuid executables and privilege escalation
- Audit logging - Complete operation tracking for compliance
🛠️ 12 Professional Process Tools
process_start- Launch processes with arguments, environment, and resource limitsprocess_terminate- Graceful or forced termination with timeout escalationprocess_get_stats- Real-time CPU, memory, thread, and I/O statisticsprocess_send_stdin- Send input to interactive processesprocess_get_output- Retrieve captured stdout and stderrprocess_list- List all managed processes with statusprocess_get_status- Detailed process state and uptimeprocess_create_group- Create process groups and pipelinesprocess_add_to_group- Add processes to groupsprocess_terminate_group- Terminate all processes in a groupprocess_start_service- Start long-running services with auto-restartprocess_stop_service- Stop services and disable auto-restart
🔒 Enterprise Security
6 Layers of Security Validation:
-
Executable Allowlist - Only approved executables can be launched
- Supports absolute paths, basenames, and glob patterns
- Blocks shell interpreters by default (bash, sh, cmd.exe)
- Prevents setuid executable execution
-
Argument Validation - Prevents command injection
- Validates all command-line arguments
- Blocks shell metacharacters and injection patterns
- Sanitizes special characters
-
Environment Sanitization - Removes dangerous variables
- Strips LD_PRELOAD, LD_LIBRARY_PATH
- Removes privilege escalation vectors
- Validates environment variable names and values
-
Resource Limits - Prevents resource exhaustion
- CPU percentage limits (per-process)
- Memory limits (MB)
- CPU time limits (seconds)
- Automatic termination on limit exceeded
-
Privilege Prevention - No privilege escalation
- Blocks sudo, su, pkexec
- Prevents setuid executable execution
- Enforces least-privilege principle
-
Audit Logging - Complete operation tracking
- Logs all process operations
- Records security violations
- Tracks resource usage
- Compliance-ready audit trail
📊 Quality Metrics
- Comprehensive testing with unit, integration, and E2E tests
- Security-first design with defense-in-depth validation
- Production-ready with graceful error handling
- Cross-platform support (Linux, macOS, Windows)
- Docker deployment with secure defaults
🎯 Revolutionary Use Cases
"AI, run my build and monitor resources"
You: "Build the project and tell me if it uses too much memory"
AI: *Launches build with resource limits, monitors in real-time*
AI: "Build completed in 45s. Peak memory: 512MB (within limits). CPU averaged 65%."
"AI, start my development services"
You: "Start the API server and database with auto-restart"
AI: *Starts services with health checks and restart policies*
AI: "Started 2 services: api-server (PID 1234), postgres (PID 1235). Health checks enabled."
"AI, create a data processing pipeline"
You: "Process data.txt through grep, sort, and uniq"
AI: *Creates process group with pipeline*
AI: "Pipeline created: cat → grep → sort → uniq. Processing 10,000 lines..."
"AI, debug this hanging process"
You: "My script is stuck, what's it doing?"
AI: *Gets process stats and output*
AI: "Process consuming 100% CPU in infinite loop. Last output: 'Processing item 5000'. Shall I terminate it?"
"AI, run tests with timeout"
You: "Run the test suite but kill it if it takes more than 5 minutes"
AI: *Launches tests with 5-minute timeout*
AI: "Tests completed in 3m 42s. All 247 tests passed. Peak memory: 384MB."
🚀 Get Started
Docker (Recommended):
# Pull the image
docker pull digitaldefiance/mcp-process:latest
# Create configuration
cat > config/mcp-process-config.json << EOF
{
"allowedExecutables": ["node", "python3", "npm"],
"maxConcurrentProcesses": 10,
"enableAuditLog": true
}
EOF
# Run with docker-compose
docker-compose up -d
NPM:
# Install globally
npm install -g @ai-capabilities-suite/mcp-process
# Create config
mcp-process --create-config ./mcp-process-config.json
# Edit config to add allowed executables
# Then start server
mcp-process --config ./mcp-process-config.json
Configuration Example:
{
"allowedExecutables": ["node", "python3", "npm", "git"],
"defaultResourceLimits": {
"maxCpuPercent": 80,
"maxMemoryMB": 1024,
"maxCpuTime": 300
},
"maxConcurrentProcesses": 10,
"maxProcessLifetime": 3600,
"enableAuditLog": true,
"blockShellInterpreters": true,
"blockSetuidExecutables": true,
"allowProcessTermination": true,
"allowForcedTermination": false
}
📚 Documentation:
- 👉 Complete process management documentation
- 👉 Security implementation guide
- 👉 Docker deployment guide
- 👉 API reference and examples
🏗️ Architecture: Built for the AI Era
Multi-Platform Integration
┌──────────────────────────────────────────────────────────────┐
│ AI Agents & IDEs │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ VS Code │ │ Kiro │ │ Amazon Q │ │
│ │ + Copilot │ │ │ │ │ │
│ └──────┬───────┘ └──────┬───────┘ └──────┬───────┘ │
│ │ │ │ │
│ │ LSP/DAP │ MCP Protocol │ MCP Protocol │
│ │ │ │ │
└─────────┼─────────────────┼──────────────────┼───────────────┘
│ │ │
│ └──────┬───────────┘
│ │
┌─────────▼────────────────────────▼───────────────────────────┐
│ AI Capability Extension Suite │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ MCP ACS Debugger │ │
│ │ • 25+ debugging tools │ │
│ │ • VS Code extension with LSP/DAP integration │ │
│ │ • Standalone MCP server for other agents │ │
│ │ • 94.53% test coverage, 1,059 tests │ │
│ └────────────────────────────────────────────────────────┘ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ System Capabilities (In Development) │ │
│ │ • Screenshot • Recording • Filesystem • Process │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────┬────────────────────────────────────────────────┘
│ Chrome DevTools Protocol, System APIs
│
┌─────────────▼────────────────────────────────────────────────┐
│ Your Development Environment │
│ • Node.js processes with Inspector Protocol │
│ • File system and process management │
│ • Screen capture and recording │
│ • Full system access with security controls │
└───────────────────────────────────────────────────────────────┘
Integration Paths
1. VS Code Extension (Native Integration)
- Language Server Protocol (LSP) for code intelligence
- Debug Adapter Protocol (DAP) for debugging
- GitHub Copilot integration for AI assistance
- Zero configuration required
2. MCP Server (Universal Integration)
- Model Context Protocol for AI agent communication
- Works with Kiro, Amazon Q, Claude Desktop, and other MCP clients
- Flexible deployment (NPM, Docker, binaries)
- Configurable via JSON
🎮 Revolutionary Use Cases
🤖 "AI, debug and fix this issue"
You: "My app crashes when processing large files"
AI: *Starts debugger, sets breakpoints, profiles memory*
AI: "Memory leak in line 156. Buffer not released. Here's the fix..."
📸 "AI, document this feature"
You: "Create documentation for the new dashboard"
AI: *Captures screenshots, analyzes UI, generates docs*
AI: "Created comprehensive guide with 12 annotated screenshots..."
🎥 "AI, create a demo video"
You: "Show how the authentication flow works"
AI: *Records screen, adds annotations, exports video*
AI: "Generated 2-minute demo with voiceover script..."
📁 "AI, organize my project files"
You: "Restructure this codebase following best practices"
AI: *Analyzes structure, moves files, updates imports*
AI: "Reorganized 247 files into proper architecture..."
📦 Package Structure
🐛 Debugging Capabilities
- mcp-debugger-core - Core debugging engine with Chrome DevTools Protocol integration
- mcp-debugger-server - MCP server with 25+ professional debugging tools
- Breakpoints, variable inspection, execution control
- Performance profiling (CPU, memory, timeline)
- Hang detection and infinite loop identification
- TypeScript source map support
- Enterprise security and compliance features
- 94.53% test coverage with 1,059 tests
- See DEBUGGER-README.md for full details
🖥️ System Capabilities
- mcp-screenshot - Screen capture and image operations
- mcp-process - Process and application management with enterprise security
- mcp-recording - Screen recording and video operations (Planned)
- mcp-filesystem - Advanced file system operations (Planned)
🎨 VS Code Extensions
- vscode-mcp-debugger - VS Code extension for MCP debugging
- vscode-mcp-screenshot - VS Code extension for screenshot capture
🚀 Getting Started
Prerequisites
- Node.js 18+
- Yarn (workspace support)
- TypeScript 5+
Installation
# Clone the repository
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
# Install dependencies
yarn install
# Build all packages
yarn build
# Run tests
yarn test
Quick Start: MCP ACS Debugger
# Build debugger packages
npx nx build mcp-debugger-core
npx nx build mcp-debugger-server
# Run debugger tests
npx nx test mcp-debugger-core
npx nx test mcp-debugger-server
# Start debugger server
node packages/mcp-debugger-server/dist/src/index.js
📋 Development
Build Commands
# Build all packages
yarn build
# Build specific package
npx nx build mcp-debugger-core
npx nx build mcp-debugger-server
npx nx build mcp-screenshot
npx nx build mcp-core
# Build with watch mode
npx nx build mcp-screenshot --watch
Test Commands
# Run all tests
yarn test
# Test specific package
npx nx test mcp-debugger-core
npx nx test mcp-debugger-server
npx nx test mcp-screenshot
# Test with coverage
npx nx test mcp-debugger-core --coverage
# Run tests in watch mode
npx nx test mcp-screenshot --watch
Lint Commands
# Lint all packages
yarn lint
# Lint specific package
npx nx lint mcp-debugger-core
🏆 Production Status & Distribution
✅ MCP ACS Debugger
Distribution Channels:
- ✅ VS Code Marketplace - Native extension with Copilot integration
- ✅ NPM Registry - Global installation via npm
- ✅ Docker Hub - Containerized deployment
- ✅ GitHub Releases - Standalone binaries for all platforms
- � [MCP Registry - Submission in progress for official Model Context Protocol registry
Quality Metrics:
- 25+ professional debugging tools for AI agents
- Enterprise-grade security, compliance, and observability
- 94.53% test coverage exceeding industry standards (target: 90%)
- 83.45% branch coverage approaching target (target: 85%)
- 1,059 tests with 99.81% pass rate (1,050 passed, 2 flaky, 7 skipped)
- Production-ready with graceful shutdown, circuit breakers, retry logic
- Cross-platform support (Linux, macOS, Windows)
- Node.js compatibility tested on versions 16, 18, 20, 22
- TypeScript compatibility tested on versions 4.x and 5.x
Enterprise Features:
- 🔒 Security: Authentication, rate limiting, PII masking, audit logging
- 📊 Observability: Structured logging, metrics collection, health checks
- 🚀 Performance: CPU/memory profiling, performance timeline analysis
- 🛡️ Reliability: Circuit breakers, retry logic, graceful shutdown
- 📈 Scalability: Load tested with 100+ concurrent debug sessions
Documentation:
- 👉 VS Code Extension Guide
- 👉 Complete debugger documentation
- 👉 Production status report
- 👉 Installation guide
- 👉 API reference
🛠️ System Capabilities
- mcp-debugger: 25+ debugging tools with performance profiling, hang detection, advanced breakpoints
- mcp-screenshot: Screenshot capture with multiple formats (PNG, JPG, WebP)
- mcp-process: Process management with enterprise security
- mcp-recording: Screen recording with video encoding and frame extraction - Planned
- mcp-filesystem: Advanced file operations beyond basic read/write - Planned
📚 Documentation
Getting Started
- VS Code Extension Guide - Installation and usage for VS Code
- Quick Start Guide - Get up and running in 5 minutes
- Configuration Guide - Customize for your workflow
- Troubleshooting Guide - Common issues and solutions
Main Documentation
- README.md - This file (suite overview)
- DEBUGGER-README.md - Complete debugger documentation
- DEBUGGER-STATUS.md - Production readiness report
- MIGRATION-SUMMARY.md - Migration documentation
- MIGRATION-COMPLETE.md - Migration completion guide
Debugger Specs & Tasks
- .kiro-debugger/specs/ - Complete specifications
- .kiro-debugger/specs/mcp-debugger-tool/requirements.md - EARS-formatted requirements
- .kiro-debugger/specs/mcp-debugger-tool/design.md - Architecture and design
- .kiro-debugger/specs/mcp-debugger-tool/tasks.md - Detailed task breakdown
Package Documentation
- mcp-debugger-core - Core debugging engine
- mcp-debugger-server - MCP server
- mcp-screenshot - Screenshot capture server
- mcp-filesystem - Filesystem operations server
- mcp-process - Process management server
- mcp-recording - Recording and playback server
- vscode-mcp-debugger - VS Code debugging extension
- vscode-mcp-screenshot - VS Code screenshot extension
API Reference
- MCP Tools Reference - All 25+ debugging tools
- CDP Protocol Reference - Chrome DevTools Protocol integration
- LSP/DAP Reference - Language Server and Debug Adapter protocols
🤝 Contributing
We welcome contributions! This project follows a spec-driven development approach:
- Requirements documented in EARS format
- Design includes formal correctness properties
- Implementation follows detailed task plans
- Testing with property-based tests and comprehensive coverage
- Quality gates - all tests must pass before merging
How to Contribute
- Fork the repository
- Create a feature branch (
git checkout -b feature/amazing-feature) - Make your changes with tests
- Ensure all tests pass (
yarn test) - Commit your changes (
git commit -m 'Add amazing feature') - Push to the branch (
git push origin feature/amazing-feature) - Open a Pull Request
👥 Team
Digital Defiance
- 📧 Email: [email protected]
- 🚨 Security: SECURITY.md
- 🔗 LinkedIn: Digital Defiance
- 🌐 Website: digitaldefiance.org
📄 License
MIT License - See LICENSE for details
🎉 Join the Revolution
We're building the foundation for AI-powered development workflows.
By giving AI agents professional-grade capabilities, we're creating a future where:
- ✅ Bugs are investigated automatically while you focus on features
- ✅ Documentation is generated from actual system behavior
- ✅ Demos are created with a single command
- ✅ Code is organized following best practices automatically
- ✅ Junior developers have access to senior-level expertise
This isn't just a tool suite—it's the future of software development.
🚀 Quick Start Options
For VS Code Users (Recommended)
# Install from VS Code Marketplace
code --install-extension digitaldefiance.ts-mcp-debugger
# Or search "MCP ACS Debugger" in VS Code Extensions
For Other AI Agents (Kiro, Amazon Q, Claude)
# Install globally via NPM
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Or use Docker
docker run -p 3000:3000 digitaldefiance/mcp-debugger-server
# Or download standalone binary from GitHub Releases
For Contributors & Developers
# Clone and build from source
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build && yarn test
📊 Project Statistics
- Total Packages: 10 (5 production, 5 in development)
- Total Tests: 1,059 tests across all packages
- Test Pass Rate: 99.81% (1,050 passed, 2 flaky, 7 skipped)
- Code Coverage: 94.53% lines, 83.45% branches
- Lines of Code: 15,000+ lines of production code
- Documentation: 10,000+ lines of comprehensive documentation
- Supported Platforms: Linux, macOS, Windows
- Node.js Versions: 16, 18, 20, 22
- TypeScript Versions: 4.x, 5.x
🌟 Why Choose This Suite?
1. Production-Ready Quality
- Enterprise-grade testing with 94.53% coverage
- Property-based testing with 22 correctness properties
- Load testing with 100+ concurrent sessions
- Chaos testing for reliability validation
- Security testing for vulnerability detection
2. Multiple Integration Options
- Native VS Code extension with zero configuration
- Standalone MCP server for universal AI agent support
- Docker containers for easy deployment
- Standalone binaries for no-install usage
3. Comprehensive Feature Set
- 25+ debugging tools (most comprehensive in MCP ecosystem)
- Performance profiling (CPU, memory, timeline)
- Advanced breakpoint types (logpoints, exception, hit count, function)
- Enterprise security (authentication, rate limiting, PII masking)
- Production readiness (graceful shutdown, circuit breakers, retry logic)
4. Active Development & Support
- Regular updates and new features
- Responsive issue tracking on GitHub
- Comprehensive documentation and examples
- Community-driven development
5. Open Source & Extensible
- MIT License - use freely in any project
- Well-documented codebase for contributions
- Modular architecture for easy extension
- Active community contributions welcome
💬 Community & Support
Get Help:
Stay Updated:
- ⭐ Star this repository for updates
- 👀 Watch for new releases
- 🐦 Follow us on social media (coming soon)
- 📰 Subscribe to our newsletter (coming soon)
Contribute:
- 🔧 Submit pull requests
- 🐛 Report bugs and issues
- 💡 Suggest new features
- 📝 Improve documentation
- 🧪 Add test coverage
🏅 Recognition & Achievements
VS Code Marketplace
- ✅ Published Extension - MCP ACS TypeScript Debugger
- 🎯 Zero Configuration - Works immediately after installation
- 🤖 Copilot Integration - First MCP debugger with native Copilot support
- 🌍 Multi-Language - VS Code extension supports all languages; MCP server supports Node.js/JavaScript
- 📦 Professional Quality - Enterprise-grade extension with comprehensive testing
Distribution Channels
- ✅ VS Code Marketplace - Native extension for VS Code users
- ✅ NPM Registry - Global installation via
npm install -g - ✅ Docker Hub - Containerized deployment for production
- ✅ GitHub Releases - Standalone binaries for all platforms
- 🔄 MCP Registry - Official Model Context Protocol registry (submission in progress)
- 🔄 Homebrew - macOS package manager (formula in progress)
Quality Metrics
- 🏆 94.53% Test Coverage - Exceeding industry standard of 90%
- ✅ 1,059 Tests - Comprehensive test suite with 99.81% pass rate
- 🔒 Enterprise Security - Authentication, rate limiting, PII masking, audit logging
- 📊 Production Ready - Graceful shutdown, circuit breakers, retry logic
- 🌍 Cross-Platform - Linux, macOS, Windows support
- 🔧 Multi-Version - Node.js 16-22, TypeScript 4.x-5.x compatibility
Community Impact
- Model Context Protocol Ecosystem - Contributing to the MCP standard
- Open Source Excellence - MIT License, well-documented codebase
- Community Driven - Built with feedback from developers worldwide
- Active Development - Regular updates and new features
- Responsive Support - GitHub issues, discussions, and email support
🎯 Ready to Get Started?
For VS Code Users (Recommended)
Install the extension in 3 ways:
-
From VS Code:
- Open Extensions (Ctrl+Shift+X / Cmd+Shift+X)
- Search "MCP ACS Debugger"
- Click Install
-
From Command Line:
code --install-extension digitaldefiance.ts-mcp-debugger -
From Marketplace:
- Visit VS Code Marketplace
- Click "Install"
For Other AI Agents
Choose your installation method:
# NPM (Global installation)
npm install -g @digitaldefiance/mcp-debugger-server
# Docker (Containerized)
docker run -p 3000:3000 digitaldefiance/mcp-debugger-server
# Homebrew (macOS - coming soon)
brew install digitaldefiance/tap/mcp-debugger-server
# Download Binary (No installation)
# Visit: https://github.com/digital-defiance/ai-capabilities-suite/releases
For Contributors
# Clone and build from source
git clone https://github.com/digital-defiance/ai-capabilities-suite.git
cd ai-capabilities-suite
yarn install && yarn build && yarn test
📊 Installation Statistics
🔗 Individual Package Repositories
Core MCP Servers
- mcp-debugger-core - Core debugging engine with Chrome DevTools Protocol
- mcp-debugger-server - MCP debugging server with 25+ tools
- mcp-screenshot - Screenshot capture server with PII masking
- mcp-filesystem - Advanced filesystem operations server
- mcp-process - Process management and monitoring server
- mcp-recording - Screen recording and playback server
VS Code Extensions
- vscode-mcp-debugger - VS Code debugging extension with Copilot integration
- vscode-mcp-screenshot - VS Code screenshot extension with LSP features
- vscode-mcp-acs-process - VS Code process management extension with LSP features
Main Links
- Homepage: digitaldefiance.org
- Main Repository: ai-capabilities-suite
- Organization: Digital-Defiance
- NPM Packages: @ai-capabilities-suite
- Docker Hub: digitaldefiance
- Issues: GitHub Issues
- Discussions: GitHub Discussions
Built with ❤️ by the Digital Defiance team using Amazon Kiro, TypeScript, and the Model Context Protocol
Ready to give your AI agent superpowers? Install now! 🚀
🔧 Kiro MCP Configuration
Quick Setup for Kiro Users
Configure Kiro to use the AI Capability Extension Suite MCP servers by editing ~/.kiro/settings/mcp.json:
{
"mcpServers": {
"mcp-screenshot": {
"command": "npx",
"args": ["-y", "@ai-capabilities-suite/mcp-screenshot"]
},
"mcp-process": {
"command": "npx",
"args": [
"-y",
"@ai-capabilities-suite/mcp-process",
"--config",
"./mcp-process-config.json"
]
},
"mcp-debugger": {
"command": "npx",
"args": ["-y", "@ai-capabilities-suite/mcp-debugger-server"]
}
}
}
MCP ACS Process Configuration
Create mcp-process-config.json in your project directory or home directory:
{
"allowedExecutables": ["node", "python3", "npm", "yarn", "git"],
"defaultResourceLimits": {
"maxCpuPercent": 80,
"maxMemoryMB": 1024,
"maxCpuTime": 300
},
"maxConcurrentProcesses": 10,
"maxProcessLifetime": 3600,
"enableAuditLog": true,
"blockShellInterpreters": true,
"blockSetuidExecutables": true,
"allowProcessTermination": true,
"allowForcedTermination": false
}
Note: The config file requirement for mcp-process will be removed in an upcoming release, making it optional with sensible defaults.
Prerequisites
For Linux users (Ubuntu/Debian):
# Install Python setuptools for native dependencies
sudo apt-get install -y python3-setuptools build-essential
For macOS users:
# Install Xcode Command Line Tools
xcode-select --install
For Windows users:
# Install Visual Studio Build Tools
# Download from: https://visualstudio.microsoft.com/downloads/
Alternative: Global Installation
If you prefer global installation over npx:
# Install all three servers globally
npm install -g @ai-capabilities-suite/mcp-screenshot
npm install -g @ai-capabilities-suite/mcp-process
npm install -g @ai-capabilities-suite/mcp-debugger-server
# Then use direct commands in mcp.json
{
"mcpServers": {
"mcp-screenshot": {
"command": "mcp-screenshot"
},
"mcp-process": {
"command": "mcp-process",
"args": ["--config", "./mcp-process-config.json"]
},
"mcp-debugger": {
"command": "mcp-debugger"
}
}
}
Verification
After configuration, restart Kiro and verify the servers are connected:
You: "List available MCP tools"
Kiro: *Shows tools from mcp-screenshot, mcp-process, and mcp-debugger*
Troubleshooting
Connection issues:
- Ensure Node.js 18+ is installed:
node --version - Check Python setuptools:
python3 -c "import setuptools" - Verify packages are published:
npm view @ai-capabilities-suite/mcp-screenshot
Native dependency errors:
- Install build tools (see Prerequisites above)
- Clear npm cache:
npm cache clean --force - Reinstall with:
npm install -g --force @ai-capabilities-suite/mcp-screenshot
Config file not found:
- Use absolute path to config file in mcp.json
- Verify file exists:
ls -la ./mcp-process-config.json - Check JSON syntax:
cat mcp-process-config.json | jq
🎯 Akira
Spec-driven development powered by GitHub Copilot and MCP
Repository: Akira
The Problem: Traditional AI-assisted development lacks structure—requirements are vague, designs are inconsistent, and implementation happens without proper planning. AI agents generate code without understanding the full context or ensuring correctness.
The Solution: Akira brings professional software engineering methodology to AI-assisted development. Using the Easy Approach to Requirements Syntax (EARS) and INCOSE quality rules, Akira guides AI through a structured workflow: Requirements → Design → Tasks → Execution. With Model Context Protocol (MCP) integration, specifications persist across chat sessions, ensuring consistency and enabling property-based testing.
🎨 Key Features
Structured Spec-Driven Workflow:
- Requirements Phase - Generate EARS-compliant requirements with INCOSE validation
- Design Phase - Create technical designs with correctness properties
- Tasks Phase - Generate actionable implementation plans with proper hierarchy
- Execution Phase - Execute tasks with full context from requirements and design
Advanced Requirements Engineering:
- EARS Compliance - All requirements follow one of six EARS patterns
- INCOSE Quality Rules - Automatic validation against semantic quality standards
- Glossary Management - Automatic extraction and definition of technical terms
- User Story Structure - Consistent format with 2-5 acceptance criteria per requirement
Property-Based Testing Integration:
- Correctness Properties - Generate testable properties from acceptance criteria
- Universal Quantification - Properties formatted with explicit "For any" statements
- Round-Trip Properties - Automatic detection for parsing/serialization requirements
- Test Library Integration - Support for fast-check and other PBT libraries
Model Context Protocol (MCP) Integration:
- Persistent Context - Spec documents remain accessible across chat sessions
- Structured Tools - Programmatic access to spec operations via MCP tools
- State Management - Track workflow progress and task completion
- File Operations - Read, write, and update spec documents through MCP
🛠️ Workflow Phases
- Requirements - Generate user stories with EARS patterns and INCOSE validation
- Design - Create technical design with correctness properties for PBT
- Tasks - Generate actionable implementation plan with 2-level hierarchy
- Execution - Execute tasks with full context loading and status tracking
🎯 Revolutionary Use Cases
"AI, create a spec for user authentication"
You: "@spec create user-authentication"
AI: *Generates EARS-compliant requirements*
AI: "Created spec with 8 requirements (5 ubiquitous, 2 event-driven, 1 state-driven).
All requirements validated against INCOSE rules. Ready for design phase."
"AI, generate correctness properties"
You: "@spec approve requirements user-auth"
AI: *Moves to design phase, extracts properties*
AI: "Generated 12 correctness properties:
- For any valid credentials, login succeeds
- For any expired token, re-authentication required
- For any user, password hash is irreversible
Ready for implementation."
"AI, execute the implementation plan"
You: "@spec execute user-auth"
AI: *Loads full context, executes tasks*
AI: "Executing task 1.1: Implement password hashing...
✅ Implemented with bcrypt
✅ Added property test: password hashing is one-way
Moving to task 1.2..."
🚀 Get Started
Install from VS Code:
- Search "Akira" in VS Code Extensions
- Or visit: VS Code Marketplace (Coming Soon)
Usage with GitHub Copilot:
# Create a new spec
@spec create feature-name
# List all specs
@spec list
# Execute tasks
@spec execute feature-name
# Approve workflow phases
@spec approve requirements feature-name
@spec approve design feature-name
@spec approve tasks feature-name
📚 Documentation:
