🚀 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

View on VS Code Marketplace →

🤔 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:

Feature	Our MCP ACS Debugger	Other MCP ACS Debuggers	VS Code Built-in	Chrome DevTools
AI Agent Integration	✅ Full MCP + VS Code	⚠️ Basic MCP only	❌ No AI integration	❌ No AI integration
Number of Tools	✅ 25+ tools	⚠️ 5-10 tools	⚠️ Limited API	⚠️ Manual only
Performance Profiling	✅ CPU, Memory, Timeline	❌ None	⚠️ Basic	✅ Advanced
Hang Detection	✅ Automatic	❌ None	❌ None	❌ Manual
Advanced Breakpoints	✅ 4 types	❌ Basic only	⚠️ Limited	✅ Advanced
Enterprise Security	✅ Full suite	❌ None	❌ None	❌ None
Test Coverage	✅ 94.53%	⚠️ <50% typical	N/A	N/A
TypeScript Support	✅ Full source maps	⚠️ Limited	✅ Good	✅ Good
Test Framework Integration	✅ Jest, Mocha, Vitest	❌ None	⚠️ Manual	⚠️ Manual
VS Code Extension	✅ Native	❌ None	N/A	❌ Separate tool
GitHub Copilot Integration	✅ Full	❌ None	⚠️ Limited	❌ None
Production Ready	✅ Yes	⚠️ Beta/Alpha	✅ Yes	✅ Yes
Cross-Platform	✅ Linux, macOS, Windows	⚠️ Limited	✅ Yes	✅ Yes
Deployment Options	✅ 4 options	⚠️ 1-2 options	N/A	N/A

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 ID
screenshot_capture_region - Capture rectangular screen regions with precise boundaries
screenshot_list_displays - List connected displays with resolutions and scaling
screenshot_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 rollback
fs_watch_directory - Monitor directories for real-time changes
fs_get_watch_events - Retrieve accumulated filesystem events
fs_stop_watch - Stop watch sessions and clean up resources
fs_search_files - Search by name, content, or metadata
fs_build_index - Build searchable index for fast searching
fs_create_symlink - Create symbolic links within workspace
fs_compute_checksum - Compute file checksums for integrity verification
fs_verify_checksum - Verify file checksums match expected values
fs_analyze_disk_usage - Analyze disk usage and identify large files
fs_copy_directory - Recursively copy directories with options
fs_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:

⚙️ 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 limits
process_terminate - Graceful or forced termination with timeout escalation
process_get_stats - Real-time CPU, memory, thread, and I/O statistics
process_send_stdin - Send input to interactive processes
process_get_output - Retrieve captured stdout and stderr
process_list - List all managed processes with status
process_get_status - Detailed process state and uptime
process_create_group - Create process groups and pipelines
process_add_to_group - Add processes to groups
process_terminate_group - Terminate all processes in a group
process_start_service - Start long-running services with auto-restart
process_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:

🛠️ 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: info@digitaldefiance.org
🚨 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: