Agentic Control Framework
HTTP-SSESTDIOComprehensive autonomous agent framework with 64+ specialized tools for task management and automation
Comprehensive autonomous agent framework with 64+ specialized tools for task management and automation
Author: Abhilash Chadhar (FutureAtoms) Repository: agentic-control-framework
AI‑native orchestration layer (CLI + MCP) with 80+ tools for context engineering—retrieval, code editing, browser automation, terminal orchestration, and persistent memory—designed for Claude Code, Cursor, Codex, and VS Code. This README reflects the current code and tested integrations.
bin/acfbin/agentic-control-framework-mcp → src/mcp/server.jsconfig/examples/npm run test:cli, npm testWhat’s in the box
Key Features:
ACF turns the messy, multi-file, multi-step reality of software work into precise, addressable “context units” that LLMs can request, refine, and act on. It does this by combining a task graph, rich context surfaces, retrieval/edit tools, and guardrails — all accessible via CLI and MCP.
Task Graph as Source of Truth
Rich, On‑Demand Context Surfaces
getContext returns the exact task/subtask context block (including related files metadata and activity log).generateTaskFiles materializes one Markdown file per task (tasks/), and tasks-table.md gives a project overview.context <id> prints a human summary for humans and LLMs.Retrieval and Editing Tools (for context building and application)
search_code, tree, list_directory, get_file_info, read_file/read_multiple_files, read_url.edit_block applies surgical replacements using explicit old/new blocks (minimizes accidental drift).execute_command, list_processes, sessions) to verify context assumptions (tests, builds).Synchronization & Freshness
tasks.json and per‑task files; debounced change detection; tasks-table.md kept fresh.allowedDirectories and readonlyMode restrict the accessible filesystem scope.Planning from Product Docs (optional)
parsePrd, expandTask, reviseTasks convert PRDs or change requests into structured tasks via Gemini, then fold back into the task graph for traceable execution.Together, this provides a repeatable “context loop”: plan → retrieve → edit/verify → update state, with every step addressable by tools so MCP clients (Claude Code, Cursor, Codex, VS Code) can drive it reliably.
Bootstrap from PRD
tools/call: parsePrd { filePath } → tasks created with priorities and dependencies → generateTaskFiles for review.Focus a Model on the Next Action
tools/call: getNextTask → get the next actionable task considering dependencies/priority.tools/call: getContext { id } → fetch the task block; then read_file/search_code for surrounding code.Safe, Surgical Code Change
search_code to identify exact block; verify with read_file.edit_block { file_path, old_string, new_string, normalize_whitespace }.execute_command { command: "npm test" } or suite‑specific commands.Keep Context Fresh
start_file_watcher → modify files or tasks → file_watcher_status for stats → stop_file_watcher when done.ACF keeps a durable, queryable memory of what the agent (or human) did, when, and why. This persistent memory lives in .acf/tasks.json and per‑task files:
What is stored
createdAt, updatedAt, and activityLog[] entries with timestamped messages.updatedAt.parsePrd, expandTask, reviseTasks) also write clear activity messages.How LLMs write memory
--message "..." when changing state to append a human/LLM note to the activity log.
acf status 12 inprogress --message "Started implementing parser"acf update 12 --priority 750 --message "Raised priority due to deadline"message in tools/call arguments for updateStatus or updateTask.
tools/call { name: "updateStatus", arguments: { id: "12", newStatus: "done", message: "Tests green; merging" } }tools/call { name: "updateTask", arguments: { id: "12", priority: 820, message: "Escalated after stakeholder review" } }How to consume memory
acf context <id> (CLI) prints a rich, human‑readable context including the recent activityLog.tools/call: getContext { id } (MCP) returns the same structured block, ideal for LLM prompts.generateTaskFiles produces markdown snapshots; tasks-table.md shows a live overview synced from .acf/tasks.json via the file watcher.Requirements
npx playwright install.Install
cd agentic-control-framework && npm ciCLI (local)
./bin/acf init --project-name "Demo" --project-description "Getting started"./bin/acf add -t "First task" -p high./bin/acf list --format humanMCP Server (stdio)
node ./bin/agentic-control-framework-mcp --workspaceRoot $(pwd)config/examples/ for Claude Code, Cursor, and Codex.Overview
docs/README.mddocs/PROJECT-STRUCTURE.mddocs/architecture/overview.mddocs/architecture/mcp-integration.mdIntegrations (MCP Clients)
docs/INTEGRATIONS.mdconfig/examples/claude_code.jsonconfig/examples/cursor.mcp.jsonconfig/examples/codex.config.tomlCLAUDE.mdReference
docs/reference/cli_examples.mddocs/reference/mcp_examples.mdTesting & Validation
docs/TESTING_SUMMARY.mdscripts/testing/validate-doc-commands.shProposals & Ideas
docs/workspace-indexing-proposal.mdmindmap root((ACF Tools<br/>79 Total)) Core ACF Task Management listTasks addTask updateStatus getNextTask Priority System recalculatePriorities getPriorityStatistics bumpTaskPriority prioritizeTask File Watching initializeFileWatcher stopFileWatcher forceSyncTaskFiles Templates getPriorityTemplates addTaskWithTemplate File Operations Basic Operations read_file write_file copy_file delete_file Directory Ops list_directory create_directory tree search_files Terminal Command Execution execute_command read_output force_terminate Process Management list_processes kill_process Browser Automation Navigation browser_navigate browser_navigate_back browser_close Interaction browser_click browser_type browser_hover browser_drag Capture browser_take_screenshot browser_pdf_save browser_snapshot Tab Management browser_tab_list browser_tab_new browser_tab_close Search & Edit search_code edit_block System Integration AppleScript applescript_execute Configuration get_config set_config_value
Core task tools
Utilities
Note: Tools are advertised via tools/list from src/mcp/server.js, and each listed tool has a handler in the server.
Core environment variables
WORKSPACE_ROOT: default workspace path used by CLI/MCPALLOWED_DIRS: additional allowed directories (path-delimited)READONLY_MODE: set to true to disable write operationsACF_PATH: project root override for binsOptional/feature flags
GEMINI_API_KEY: enable AI-backed tools (parsePrd, expandTask, reviseTasks)ACF_SKIP_POSTINSTALL=1: skip all postinstall stepsACF_SKIP_PLAYWRIGHT=1: skip heavy Playwright browser downloadsACF_INSTALL_SHARP=1 or ACF_INSTALL_ALL=1: install optional sharpACF_ENABLE_BROWSER_TOOLS=1: enable Playwright browser tests (macOS default)ACF_ENABLE_APPLESCRIPT=1: enable AppleScript tests (macOS only)allowedDirectories and readonlyMode.read_url) are explicit; edits use edit_block with old/new content to minimize unintended changes.Command Execution:
- execute_command: Run shell commands with timeout
- read_output: Read from running processes
- force_terminate: Kill processes
- list_sessions: Show active terminal sessions
- list_processes: Show running processes
- kill_process: Terminate processes
Navigation:
- browser_navigate: Navigate to URLs
- browser_navigate_back: Go back
- browser_navigate_forward: Go forward
- browser_close: Close browser
Interaction:
- browser_click: Click elements
- browser_type: Type text
- browser_hover: Hover over elements
- browser_drag: Drag and drop
- browser_select_option: Select dropdown options
- browser_press_key: Keyboard input
Capture:
- browser_take_screenshot: Screenshots
- browser_snapshot: Accessibility snapshots
- browser_pdf_save: Save as PDF
Management:
- browser_tab_list: List browser tabs
- browser_tab_new: Open new tabs
- browser_tab_select: Switch tabs
- browser_tab_close: Close tabs
- browser_file_upload: Upload files
- browser_wait: Wait for time/conditions
- browser_resize: Resize window
- browser_handle_dialog: Handle alerts/dialogs
- browser_console_messages: Get console logs
- browser_network_requests: Monitor network
Code Operations:
- search_code: Advanced text/code search with ripgrep
- edit_block: Surgical text replacements
macOS Automation:
- applescript_execute: Run AppleScript for system integration
Server Management:
- get_config: Get server configuration
- set_config_value: Update configuration values
The repository is organized following standard practices with clean separation of concerns:
agentic-control-framework/
├── 📁 bin/ # CLI executables and entry points
├── 📁 src/ # Core source code and tool implementations
├── 📁 docs/ # Comprehensive documentation (organized by category)
├── 📁 test/ # Testing infrastructure and test suites
├── 📁 config/ # Configuration files and examples
├── 📁 scripts/ # Setup, deployment, and maintenance scripts
├── 📁 deployment/ # Cloud deployment configurations
├── 📁 tasks/ # Task management files
├── 📁 templates/ # Project templates
├── 📁 public/ # Static assets
└── 📁 data/ # Data directory
See also: docs/PROJECT-STRUCTURE.md
Use the ready-to-copy templates in config/examples/.
claude.jsonconfig/examples/claude_code.jsonconfig/examples/cursor.mcp.jsonconfig/examples/codex.config.tomlMore details: docs/INTEGRATIONS.md
npm testnpm run test:clinpm run coverage:allEnvironment flags
ACF_SKIP_POSTINSTALL=1 to skip all postinstall stepsACF_SKIP_PLAYWRIGHT=1 to skip Playwright browser downloads on installACF_INSTALL_SHARP=1 (or ACF_INSTALL_ALL=1) to install optional sharpACF_ENABLE_BROWSER_TOOLS=1 to enable Playwright browser tests (macOS only by default)ACF_ENABLE_APPLESCRIPT=1 to enable AppleScript tests (macOS only)Platform gating (CI-safe by default)
ACF_ENABLE_* env vars.| Component | Status | Details |
|---|---|---|
| CLI Mode | ✅ 100% Working | All task management and core tools functional |
| Local MCP | ✅ 100% Working | All core tools verified via MCP protocol |
| Cloud MCP | ✅ 100% Working | mcp-proxy integration, HTTP/SSE transport verified |
| IDE Integrations | ✅ 100% Working | Cursor, Claude Desktop, Claude Code, VS Code tested |
| Core ACF Tools | ✅ 25/25 Working | Task management, priority system, file generation |
| Filesystem Tools | ✅ 14/14 Working | File operations, directory management, search |
| Browser Tools | ✅ 25/25 Working | Playwright automation, screenshots, PDF generation |
| Terminal Tools | ✅ 6/6 Working | Command execution, process management |
| Search/Edit Tools | ✅ 3/3 Working | Code search with ripgrep, surgical editing |
| System Tools | ✅ 7/7 Working | AppleScript, configuration management |
| MCP Protocol | ✅ Supported | JSON-RPC 2.0; MCP 2025-03-26 (default) and 2024-11-05 |
All tests passing! See ACF-TESTING-SUMMARY.md for detailed test results
Latest Test Run: 100% Pass Rate (All Tests Passing)
Comprehensive Testing Completed (January 2025)
ACF has undergone extensive testing to ensure production readiness:
📊 View Complete Testing Report
📋 Need detailed setup instructions? See our comprehensive Platform Setup Guide for Windows, macOS, and Ubuntu with step-by-step instructions.
# Install Node.js 22+ (LTS) node --version # Install dependencies npm install # Install global MCP dependencies (for IDE integration) npm install -g mcp-proxy @modelcontextprotocol/inspector # Install browser dependencies (for automation tools) npx playwright install # Make CLI tools executable (macOS/Linux) chmod +x bin/*
Copy and customize configuration templates:
# Copy configuration templates cp config/examples/config.json ./config.json cp config/examples/claude-mcp-config.json ./claude-mcp-config.json # Update paths in configuration files export ACF_PATH="$(pwd)" export WORKSPACE_ROOT="$(pwd)" # Replace placeholders (Linux/macOS) sed -i 's|${ACF_PATH}|'$ACF_PATH'|g' *.json sed -i 's|${WORKSPACE_ROOT}|'$WORKSPACE_ROOT'|g' *.json # Or set environment variables instead echo 'export ACF_PATH="'$(pwd)'"' >> ~/.bashrc echo 'export WORKSPACE_ROOT="'$(pwd)'"' >> ~/.bashrc
📋 Need help with configuration? See config/README.md for detailed setup instructions.
Choose your preferred mode:
# Initialize project ./bin/acf init --project-name "My Project" --project-description "Getting started with ACF" # Start using CLI commands ./bin/acf add --title "First Task" --description "Test ACF functionality" --priority high ./bin/acf list
node ./bin/agentic-control-framework-mcp --workspaceRoot $(pwd)
# Terminal 1: Start ACF MCP Server node ./bin/agentic-control-framework-mcp --workspaceRoot $(pwd) # Terminal 2: Start mcp-proxy for HTTP/SSE access mcp-proxy --port 8080 node ./bin/agentic-control-framework-mcp --workspaceRoot $(pwd) # Server available at http://localhost:8080
# Test CLI functionality ./bin/acf --help # Test MCP server (in separate terminal) curl -X POST http://localhost:8080/stream -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"ping"}' # If using mcp-proxy # Run test suite npm test
graph LR subgraph "CLI Mode" CLI1[Direct Commands] CLI2[Automation Scripts] CLI3[CI/CD Integration] end subgraph "Local MCP Mode" MCP1[Claude Code] MCP2[Cursor IDE] MCP3[Claude Desktop] MCP4[VS Code] end subgraph "Remote MCP Mode" REM1[Web Clients] REM2[Distributed Teams] REM3[Cloud Deployment] REM4[Multi-Client Access] end CLI1 --> |Fast & Direct| ACF[ACF Core] CLI2 --> |Scriptable| ACF CLI3 --> |Automated| ACF MCP1 --> |Natural Language| ACF MCP2 --> |IDE Integration| ACF MCP3 --> |AI Assistant| ACF MCP4 --> |Extension| ACF REM1 --> |HTTP/SSE| PROXY[mcp-proxy] REM2 --> |Remote Access| PROXY REM3 --> |Scalable| PROXY REM4 --> |Concurrent| PROXY PROXY --> ACF ACF --> TOOLS[80+ Tools] style CLI1 fill:#e1f5fe style MCP1 fill:#f3e5f5 style REM1 fill:#e8f5e8 style ACF fill:#fff3e0 style TOOLS fill:#fce4ec
Perfect for: Automated scripts, local development, CI/CD integration
# Initialize project cd your-project ./path/to/acf/bin/acf init -n "My Project" -d "Project description" # Add tasks ./path/to/acf/bin/acf add -t "Implement feature" -d "Add new functionality" -p high # List tasks ./path/to/acf/bin/acf list # Update task status ./path/to/acf/bin/acf status 1 inprogress -m "Started working" # Add subtasks ./path/to/acf/bin/acf add-subtask 1 -t "Write tests" # Get next actionable task ./path/to/acf/bin/acf next # Generate task files ./path/to/acf/bin/acf generate
# Update task details ./path/to/acf/bin/acf update 1 -p medium --related-files "src/main.js,test/main.test.js" # Get task context ./path/to/acf/bin/acf get-context 1 # Remove completed tasks ./path/to/acf/bin/acf remove 1 # Generate markdown table ./path/to/acf/bin/acf list --table
ACF features a sophisticated numerical priority system that replaces traditional 4-level priorities with a flexible 1-1000 scale, providing fine-grained control and intelligent dependency management.
graph TD subgraph "Priority Ranges" CRIT[🚨 Critical<br/>900-1000<br/>Security, Blockers] HIGH[🔴 High<br/>700-899<br/>Important Features] MED[🟡 Medium<br/>400-699<br/>Standard Work] LOW[🟢 Low<br/>1-399<br/>Documentation] end subgraph "Priority Engine" PE[Priority Engine] DA[Dependency Analysis] TA[Time Decay] EW[Effort Weighting] UT[Uniqueness Tracker] end subgraph "Algorithms" DB[Dependency Boosts] CP[Critical Path] DO[Distribution Optimization] AR[Auto Recalculation] end subgraph "Operations" BUMP[Bump Priority] DEFER[Defer Priority] PRIO[Prioritize] DEPRIO[Deprioritize] RECALC[Recalculate All] end PE --> DA PE --> TA PE --> EW PE --> UT DA --> DB DA --> CP PE --> DO PE --> AR BUMP --> PE DEFER --> PE PRIO --> PE DEPRIO --> PE RECALC --> PE PE --> CRIT PE --> HIGH PE --> MED PE --> LOW style CRIT fill:#ffebee style HIGH fill:#fff3e0 style MED fill:#f9fbe7 style LOW fill:#e8f5e8 style PE fill:#e3f2fd
# Using numerical priorities (1-1000) ./bin/acf add "Critical security fix" --priority 950 ./bin/acf add "Feature implementation" --priority 650 ./bin/acf add "Documentation update" --priority 200 # Using string priorities (backward compatible) ./bin/acf add "Bug fix" --priority high ./bin/acf add "Cleanup task" --priority low
# Increase priority by amount ./bin/acf bump 123 --amount 100 # Decrease priority by amount ./bin/acf defer 123 --amount 50 # Set to high priority range (700-899) ./bin/acf prioritize 123 # Set to low priority range (1-399) ./bin/acf deprioritize 123 # View priority statistics and distribution ./bin/acf priority-stats # Analyze dependencies and critical paths ./bin/acf dependency-analysis # Trigger intelligent priority recalculation ./bin/acf recalculate-priorities
# Clean table format (default) ./bin/acf list --table ┌─────┬────────────────────┬──────────┐ │ ID │ Title │ Priority │ ├─────┼────────────────────┼──────────┤ │ 24 │ Critical Bug Fix │ 950 │ │ 25 │ Feature Request │ 650 │ └─────┴────────────────────┴──────────┘ # Human-readable with distribution stats ./bin/acf list --human 📊 Priority Distribution: 🚨 Critical (900+): 2 | 🔴 High (700-899): 5 | 🟡 Medium (500-699): 8 | 🟢 Low (<500): 3
For complete documentation, see:
# Daily standup automation #!/bin/bash echo "📊 Daily Standup Report" echo "=======================" ./bin/acf list --status inprogress echo "" echo "Next Priority Tasks:" ./bin/acf next # CI/CD Integration #!/bin/bash # In your CI pipeline ./bin/acf add -t "Deploy v$VERSION" -d "Deploy to production" -p high ./bin/acf status $TASK_ID done -m "Deployed successfully"
Perfect for: IDE integration (Cursor, Claude Desktop, Claude Code), local development
acf-localnode["/path/to/agentic-control-framework/bin/agentic-control-framework-mcp", "--workspaceRoot", "/path/to/your/project"]{ "WORKSPACE_ROOT": "/path/to/your/project", "ALLOWED_DIRS": "/path/to/your/project:/tmp", "READONLY_MODE": "false" }
{ "mcp.servers": { "acf-local": { "command": "node", "args": [ "/path/to/agentic-control-framework/bin/agentic-control-framework-mcp", "--workspaceRoot", "/path/to/your/project" ], "env": { "WORKSPACE_ROOT": "/path/to/your/project", "ALLOWED_DIRS": "/path/to/your/project:/tmp", "READONLY_MODE": "false" } } } }
⚠️ IMPORTANT: Use ONLY the Direct Executable Method - This is the ONLY method confirmed to work reliably
Configuration File Location:
~/Library/Application Support/Claude/claude_desktop_config.json%APPDATA%\Claude\claude_desktop_config.json~/.config/Claude/claude_desktop_config.jsonConfiguration (replace with your actual paths):
{ "mcpServers": { "agentic-control-framework": { "command": "/FULL/PATH/TO/agentic-control-framework/bin/agentic-control-framework-mcp", "env": { "ACF_PATH": "/FULL/PATH/TO/agentic-control-framework", "WORKSPACE_ROOT": "/FULL/PATH/TO/YOUR/WORKSPACE", "ALLOWED_DIRS": "/FULL/PATH/TO/YOUR/WORKSPACE:/tmp", "READONLY_MODE": "false", "BROWSER_HEADLESS": "false", "DEFAULT_SHELL": "/bin/bash" } } } }
⚠️ CRITICAL REQUIREMENTS:
~ACF_PATH to your ACF installation directoryWORKSPACE_ROOT to your project workspacebin/agentic-control-framework-mcp is executable: chmod +x bin/agentic-control-framework-mcpnode + args pattern - it fails in Claude DesktopConfigure ACF as an MCP server using Claude's built-in commands:
# Navigate to your project directory cd your-project-directory # Add ACF as an MCP server claude mcp add acf-server \ -e ACF_PATH="/path/to/agentic-control-framework" \ -e WORKSPACE_ROOT="$(pwd)" \ -e READONLY_MODE="false" \ -e BROWSER_HEADLESS="false" \ -e DEFAULT_SHELL="/bin/bash" \ -e NODE_ENV="production" \ -- node /path/to/agentic-control-framework/bin/agentic-control-framework-mcp --workspaceRoot "$(pwd)" # Start Claude with ACF tools available claude
Add to your Claude Code MCP settings:
{ "mcpServers": { "agentic-control-framework": { "type": "stdio", "command": "node", "args": [ "/path/to/agentic-control-framework/bin/agentic-control-framework-mcp", "--workspaceRoot", "/path/to/your/project" ], "env": { "ACF_PATH": "/path/to/agentic-control-framework", "WORKSPACE_ROOT": "/path/to/your/project", "READONLY_MODE": "false", "BROWSER_HEADLESS": "false", "DEFAULT_SHELL": "/bin/bash", "NODE_ENV": "production" } } } }
For team collaboration with shared MCP configuration:
# Navigate to your project directory cd /path/to/your/project # Add ACF as project-scoped MCP server (shared with team) claude mcp add acf-project -s project \ -e ACF_PATH="/path/to/agentic-control-framework" \ -e WORKSPACE_ROOT="$(pwd)" \ -e READONLY_MODE="false" \ -- node /path/to/agentic-control-framework/bin/agentic-control-framework-mcp --workspaceRoot "$(pwd)" # This creates a .mcp.json file that can be committed to version control # Team members can then use: claude # Start Claude with shared ACF tools claude
Once configured, you can use natural language with your AI assistant:
"Add a new high-priority task for implementing user authentication"
"Create a critical priority task (950) for fixing the security vulnerability"
"List all tasks that are currently in progress"
"Show me priority statistics and distribution of all tasks"
"Bump the priority of task #123 by 100 points"
"Analyze dependencies and show me the critical path"
"Read the contents of src/main.js and create a task for adding error handling"
"Execute the test suite and create a task if there are failures"
"Search for all TODO comments in the codebase and create tasks for them"
"Take a screenshot of the application login page"
"Write a new file called docs/api.md with API documentation"
"Recalculate all task priorities with dependency boosts enabled"
| Category | Tools | Status |
|---|---|---|
| Task Management | listTasks, addTask, updateStatus, getNextTask, priority tools | ✅ Working |
| Filesystem | read_file, write_file, list_directory, search_files | ✅ Working |
| Terminal | execute_command, list_processes, kill_process | ✅ Working |
| Browser | navigate, click, type, screenshot, pdf_save | ✅ Working |
| Search/Edit | search_code, edit_block | ✅ Working |
| AppleScript | applescript_execute (macOS only) | ✅ Working |
Perfect for: Remote access, web clients, multi-client support
# Install mcp-proxy npm install -g mcp-proxy # Start ACF with mcp-proxy export WORKSPACE_ROOT="/path/to/your/project" export ALLOWED_DIRS="/path/to/your/project:/tmp" mcp-proxy --port 8080 node bin/agentic-control-framework-mcp --workspaceRoot "$WORKSPACE_ROOT"
# Test connectivity (should return error about session ID - this is expected) curl -X POST http://localhost:8080/stream \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"ping"}' # MCP initialization (requires proper session handling) curl -X POST http://localhost:8080/stream \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0.0"}}}' # List available tools curl -X POST http://localhost:8080/stream \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}' # Call a tool curl -X POST http://localhost:8080/stream \ -H "Content-Type: application/json" \ -d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"listTasks","arguments":{}}}'
{ "mcp.servers": { "acf-cloud": { "transport": "sse", "endpoint": "http://localhost:8080/sse" } } }
# Authenticate gcloud auth login # Create project gcloud projects create acf-your-name-$(date +%s) export GCP_PROJECT_ID="your-project-id" # Deploy ./quick-deploy.sh gcp --proxy-only
# CLI approach ./bin/acf init -n "E-commerce App" -d "Build online store" ./bin/acf add -t "Setup project structure" -p high ./bin/acf add -t "Configure database" -p high ./bin/acf add -t "Implement user auth" -p medium ./bin/acf add -t "Add payment integration" -p medium ./bin/acf add -t "Deploy to production" -p low
// MCP approach - ask your AI assistant: "Search the codebase for any TODO comments and create tasks for each one" "Read all JavaScript files in src/ and create tasks for any functions missing error handling" "Take a screenshot of the app and create a task for any UI issues you notice"
#!/bin/bash # In your GitHub Actions workflow - name: Update project tasks run: | ./bin/acf add -t "Test release v${{ github.event.release.tag_name }}" -p high ./bin/acf status $TASK_ID inprogress -m "Running tests for ${{ github.sha }}" # Run tests npm test if [ $? -eq 0 ]; then ./bin/acf status $TASK_ID done -m "Tests passed" else ./bin/acf status $TASK_ID error -m "Tests failed" fi
// Via MCP in your IDE "Navigate to our staging site and take screenshots of the login, dashboard, and profile pages" "Fill out the contact form with test data and take a screenshot of the success page" "Test the mobile responsiveness by resizing to phone dimensions and taking screenshots"
# Comprehensive test suite node test-simple-tools.js # Individual component tests ./test-all-tools-comprehensive.sh
# Clone repository git clone https://github.com/your-org/agentic-control-framework.git cd agentic-control-framework # Install dependencies npm install # Setup development environment chmod +x bin/* export WORKSPACE_ROOT="$(pwd)" export ALLOWED_DIRS="$(pwd):/tmp" # Test CLI mode ./bin/acf list # Test MCP mode node bin/agentic-control-framework-mcp
# Check if tasks.json exists ls -la tasks.json # Verify permissions chmod +x bin/acf # Check Node.js version node --version # Should be 22+
# Check environment variables echo $WORKSPACE_ROOT echo $ALLOWED_DIRS # Test MCP server directly node bin/agentic-control-framework-mcp --help # Check file permissions ls -la bin/agentic-control-framework-mcp
# Check mcp-proxy installation npm list -g mcp-proxy # Test proxy connectivity curl -X POST http://localhost:8080/stream -H "Content-Type: application/json" -d '{"jsonrpc":"2.0","id":1,"method":"ping"}' # Check proxy logs mcp-proxy --port 8080 --debug node bin/agentic-control-framework-mcp --workspaceRoot $(pwd)
git checkout -b feature/amazing-featurenode test-simple-tools.jsgit commit -m 'Add amazing feature'git push origin feature/amazing-featureThis project is licensed under the MIT License - see the LICENSE file for details.
🚀 Ready to build your autonomous agent? Choose your mode and get started!
| Mode | Use Case | Setup Time | Status | Test Results |
|---|---|---|---|---|
| CLI | Scripts, automation | 2 minutes | ✅ Production Ready | 100% Pass Rate |
| Local MCP | IDE integration | 5 minutes | ✅ Production Ready | 25/25 Tests Passing |
| Cloud MCP | Remote access | 15 minutes | ✅ Production Ready | Full Integration Verified |
For detailed test results and improvement roadmap, see ACF-TESTING-SUMMARY.md.