refactor(mcp): Enforce projectRoot and centralize path validation

This commit refactors how project paths are handled in MCP direct functions to improve reliability, particularly when session context is incomplete or missing.

Key changes: 1) Made projectRoot required in MCP tools. 2) Refactored findTasksJsonPath to return {tasksPath, validatedProjectRoot}. 3) Updated all direct functions to pass session to findTasksJsonPath. 4) Updated analyzeTaskComplexityDirect to use the validated root for output path resolution.

This ensures operations relying on project context receive an explicitly provided and validated project root directory, resolving errors caused by incorrect path resolution.

.changeset/all-parks-sort.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+- Fix expand-all command bugs that caused NaN errors with --all option and JSON formatting errors with research enabled. Improved error handling to provide clear feedback when subtask generation fails, including task IDs and actionable suggestions.

.changeset/brave-doors-open.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Ensures add-task also has manual creation flags like --title/-t, --description/-d etc.

.changeset/happy-snails-train.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+fix threshold parameter validation and testing for analyze-complexity.

.changeset/silly-horses-grin.md

@@ -0,0 +1,5 @@
+---
+'task-master-ai': patch
+---
+
+Adjusts the taskmaster.mdc rules for init and parse-prd so the LLM correctly reaches for the next steps rather than trying to reinitialize or access tasks not yet created until PRD has been parsed."

.changeset/thirty-items-kiss.md

@@ -0,0 +1,11 @@
+---
+'task-master-ai': patch
+---
+
+Two improvements to MCP tools:
+
+1. Adjusts the response sent to the MCP client for `initialize-project` tool so it includes an explicit `next_steps` object. This is in an effort to reduce variability in what the LLM chooses to do as soon as the confirmation of initialized project. Instead of arbitrarily looking for tasks, it will know that a PRD is required next and will steer the user towards that before reaching for the parse-prd command.
+
+2. Updates the `parse_prd` tool parameter description to explicitly mention support for .md file formats, clarifying that users can provide PRD documents in various text formats including Markdown.
+
+3. Updates the `parse_prd` tool `numTasks` param description to encourage the LLM agent to use a number of tasks to break down the PRD into that is logical relative to project complexity.

.changeset/two-bats-smoke.md

@@ -2,6 +2,36 @@
 "task-master-ai": patch
 ---
 
+- **Major Usability & Stability Enhancements:**
+  - Taskmaster can now be seamlessly used either via the globally installed `task-master` CLI (npm package) or directly via the MCP server (e.g., within Cursor). Onboarding/initialization is supported through both methods.
+  - MCP implementation is now complete and stable, making it the preferred method for integrated environments.
+- **Bug Fixes & Reliability:**
+  - Fixed MCP server invocation issue in `mcp.json` shipped with `task-master init`.
+  - Resolved issues with CLI error messages for flags and unknown commands, added confirmation prompts for destructive actions (e.g., `remove-task`).
+  - Numerous other CLI and MCP tool bugs fixed across the suite (details may be in other changesets like `@all-parks-sort.md`).
+- **Core Functionality & Commands:**
+  - Added complete `remove-task` functionality for permanent task deletion.
+  - Implemented `initialize_project` MCP tool for easier setup in integrated environments.
+  - Introduced AsyncOperationManager for handling long-running operations (e.g., `expand`, `analyze`) in the background via MCP, with status checking.
+- **Interface & Configuration:**
+  - Renamed MCP tools for intuitive usage (`list-tasks` → `get-tasks`, `show-task` → `get-task`).
+  - Added binary alias `task-master-mcp-server`.
+  - Clarified environment configuration: `.env` for npm package, `.cursor/mcp.json` for MCP.
+  - Updated model configurations (context window, temperature, defaults) for improved performance/consistency.
+- **Internal Refinements & Fixes:**
+  - Refactored AI tool patterns, implemented Logger Wrapper, fixed critical issues in `analyze-project-complexity`, `update-task`, `update-subtask`, `set-task-status`, `update`, `expand-task`, `parse-prd`, `expand-all`.
+  - Standardized and improved silent mode implementation across MCP tools to prevent JSON response issues.
+  - Improved parameter handling and project root detection for MCP tools.
+  - Centralized AI client utilities and refactored AI services.
+  - Optimized `get-task` MCP response payload.
+- **Dependency & Licensing:**
+  - Removed dependency on non-existent package `@model-context-protocol/sdk`.
+  - Updated license to MIT + Commons Clause v1.0.
+- **Documentation & UI:**
+  - Added comprehensive `taskmaster.mdc` command/tool reference and other rule updates (specific rule adjustments may be in other changesets like `@silly-horses-grin.md`).
+  - Enhanced CLI progress bars and status displays. Added "cancelled" status.
+  - Updated README, added tutorial/examples guide, supported client list documentation.
+
 - Adjusts the MCP server invokation in the mcp.json we ship with `task-master init`. Fully functional now.
 - Rename the npx -y command. It's now `npx -y task-master-ai task-master-mcp`
 - Add additional binary alias: `task-master-mcp-server` pointing to the same MCP server script

.cursor/mcp.json

@@ -1,20 +1,18 @@
 {
-    "mcpServers": {
+	"mcpServers": {
-        "taskmaster-ai": {
+		"taskmaster-ai": {
-            "command": "node",
+			"command": "node",
-            "args": [
+			"args": ["./mcp-server/server.js"],
-                "./mcp-server/server.js"
+			"env": {
-            ],
+				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
-            "env": {
+				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
-                "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
+				"MODEL": "claude-3-7-sonnet-20250219",
-                "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
+				"PERPLEXITY_MODEL": "sonar-pro",
-                "MODEL": "claude-3-7-sonnet-20250219",
+				"MAX_TOKENS": 64000,
-                "PERPLEXITY_MODEL": "sonar-pro",
+				"TEMPERATURE": 0.2,
-                "MAX_TOKENS": 128000,
+				"DEFAULT_SUBTASKS": 5,
-                "TEMPERATURE": 0.2,
+				"DEFAULT_PRIORITY": "medium"
-                "DEFAULT_SUBTASKS": 5,
+			}
-                "DEFAULT_PRIORITY": "medium"
+		}
-            }
+	}
-        }
-    }
 }

.cursor/rules/architecture.mdc

@@ -14,13 +14,13 @@ alwaysApply: false
     - **Purpose**: Defines and registers all CLI commands using Commander.js.
     - **Responsibilities** (See also: [`commands.mdc`](mdc:.cursor/rules/commands.mdc)):
       - Parses command-line arguments and options.
-      - Invokes appropriate functions from other modules to execute commands.
+      - Invokes appropriate functions from other modules to execute commands (e.g., calls `initializeProject` from `init.js` for the `init` command).
       - Handles user input and output related to command execution.
       - Implements input validation and error handling for CLI commands.
     - **Key Components**:
       - `programInstance` (Commander.js `Command` instance): Manages command definitions.
       - `registerCommands(programInstance)`: Function to register all application commands.
-      - Command action handlers: Functions executed when a specific command is invoked.
+      - Command action handlers: Functions executed when a specific command is invoked, delegating to core modules.
 
   - **[`task-manager.js`](mdc:scripts/modules/task-manager.js): Task Data Management**
     - **Purpose**: Manages task data, including loading, saving, creating, updating, deleting, and querying tasks.
@@ -148,10 +148,23 @@ alwaysApply: false
         - Robust error handling for background tasks
       - **Usage**: Used for CPU-intensive operations like task expansion and PRD parsing
 
+  - **[`init.js`](mdc:scripts/init.js): Project Initialization Logic**
+    - **Purpose**: Contains the core logic for setting up a new Task Master project structure.
+    - **Responsibilities**:
+      - Creates necessary directories (`.cursor/rules`, `scripts`, `tasks`).
+      - Copies template files (`.env.example`, `.gitignore`, rule files, `dev.js`, etc.).
+      - Creates or merges `package.json` with required dependencies and scripts.
+      - Sets up MCP configuration (`.cursor/mcp.json`).
+      - Optionally initializes a git repository and installs dependencies.
+      - Handles user prompts for project details *if* called without skip flags (`-y`).
+    - **Key Function**:
+      - `initializeProject(options)`: The main function exported and called by the `init` command's action handler in [`commands.js`](mdc:scripts/modules/commands.js). It receives parsed options directly.
+    - **Note**: This script is used as a module and no longer handles its own argument parsing or direct execution via a separate `bin` file.
+
 - **Data Flow and Module Dependencies**:
 
-  - **Commands Initiate Actions**: User commands entered via the CLI (handled by [`commands.js`](mdc:scripts/modules/commands.js)) are the entry points for most operations.
+  - **Commands Initiate Actions**: User commands entered via the CLI (parsed by `commander` based on definitions in [`commands.js`](mdc:scripts/modules/commands.js)) are the entry points for most operations.
-  - **Command Handlers Delegate to Managers**: Command handlers in [`commands.js`](mdc:scripts/modules/commands.js) call functions in [`task-manager.js`](mdc:scripts/modules/task-manager.js) and [`dependency-manager.js`](mdc:scripts/modules/dependency-manager.js) to perform core task and dependency management logic.
+  - **Command Handlers Delegate to Core Logic**: Action handlers within [`commands.js`](mdc:scripts/modules/commands.js) call functions in core modules like [`task-manager.js`](mdc:scripts/modules/task-manager.js), [`dependency-manager.js`](mdc:scripts/modules/dependency-manager.js), and [`init.js`](mdc:scripts/init.js) (for the `init` command) to perform the actual work.
   - **UI for Presentation**:  [`ui.js`](mdc:scripts/modules/ui.js) is used by command handlers and task/dependency managers to display information to the user. UI functions primarily consume data and format it for output, without modifying core application state.
   - **Utilities for Common Tasks**: [`utils.js`](mdc:scripts/modules/utils.js) provides helper functions used by all other modules for configuration, logging, file operations, and common data manipulations.
   - **AI Services Integration**: AI functionalities (complexity analysis, task expansion, PRD parsing) are invoked from [`task-manager.js`](mdc:scripts/modules/task-manager.js) and potentially [`commands.js`](mdc:scripts/modules/commands.js), likely using functions that would reside in a dedicated `ai-services.js` module or be integrated within `utils.js` or `task-manager.js`.

.cursor/rules/commands.mdc

@@ -24,7 +24,7 @@ While this document details the implementation of Task Master's **CLI commands**
   programInstance
     .command('command-name')
     .description('Clear, concise description of what the command does')
-    .option('-s, --short-option <value>', 'Option description', 'default value')
+    .option('-o, --option <value>', 'Option description', 'default value')
     .option('--long-option <value>', 'Option description')
     .action(async (options) => {
       // Command implementation
@@ -34,7 +34,8 @@ While this document details the implementation of Task Master's **CLI commands**
 - **Command Handler Organization**:
   - ✅ DO: Keep action handlers concise and focused
   - ✅ DO: Extract core functionality to appropriate modules
-  - ✅ DO: Include validation for required parameters
+  - ✅ DO: Have the action handler import and call the relevant function(s) from core modules (e.g., `task-manager.js`, `init.js`), passing the parsed `options`.
+  - ✅ DO: Perform basic parameter validation (e.g., checking for required options) within the action handler or at the start of the called core function.
   - ❌ DON'T: Implement business logic in command handlers
 
 ## Best Practices for Removal/Delete Commands

.cursor/rules/taskmaster.mdc

@@ -37,7 +37,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `addAliases`: `Add shell aliases (tm, taskmaster) (default: false).` (CLI: `--aliases`)
     *   `yes`: `Skip prompts and use defaults/provided arguments (default: false).` (CLI: `-y, --yes`)
 *   **Usage:** Run this once at the beginning of a new project, typically via an integrated tool like Cursor. Operates on the current working directory of the MCP server. 
-
+*   **Important:** Once complete, you *MUST* parse a prd in order to generate tasks. There will be no tasks files until then. The next step after initializing should be to create a PRD using the example PRD in scripts/example_prd.txt. 
 
 ### 2. Parse PRD (`parse_prd`)
 
@@ -51,7 +51,7 @@ This document provides a detailed reference for interacting with Taskmaster, cov
     *   `force`: `Use this to allow Taskmaster to overwrite an existing 'tasks.json' without asking for confirmation.` (CLI: `-f, --force`)
 *   **Usage:** Useful for bootstrapping a project from an existing requirements document.
 *   **Notes:** Task Master will strictly adhere to any specific requirements mentioned in the PRD (libraries, database schemas, frameworks, tech stacks, etc.) while filling in any gaps where the PRD isn't fully specified. Tasks are designed to provide the most direct implementation path while avoiding over-engineering.
-*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress.
+*   **Important:** This MCP tool makes AI calls and can take up to a minute to complete. Please inform users to hang tight while the operation is in progress. If the user does not have a PRD, suggest discussing their idea and then use the example PRD in scripts/example_prd.txt as a template for creating the PRD based on their idea, for use with parse-prd.
 
 ---
 

.cursor/rules/tests.mdc

@@ -5,6 +5,8 @@ globs: "**/*.test.js,tests/**/*"
 
 # Testing Guidelines for Task Master CLI
 
+*Note:* Never use asynchronous operations in tests. Always mock tests properly based on the way the tested functions are defined and used. Do not arbitrarily create tests. Based them on the low-level details and execution of the underlying code being tested. 
+
 ## Test Organization Structure
 
 - **Unit Tests** (See [`architecture.mdc`](mdc:.cursor/rules/architecture.mdc) for module breakdown)
@@ -88,6 +90,122 @@ describe('Feature or Function Name', () => {
 });
 ```
 
+## Commander.js Command Testing Best Practices
+
+When testing CLI commands built with Commander.js, several special considerations must be made to avoid common pitfalls:
+
+- **Direct Action Handler Testing**
+  - ✅ **DO**: Test the command action handlers directly rather than trying to mock the entire Commander.js chain
+  - ✅ **DO**: Create simplified test-specific implementations of command handlers that match the original behavior
+  - ✅ **DO**: Explicitly handle all options, including defaults and shorthand flags (e.g., `-p` for `--prompt`)
+  - ✅ **DO**: Include null/undefined checks in test implementations for parameters that might be optional
+  - ✅ **DO**: Use fixtures from `tests/fixtures/` for consistent sample data across tests
+  
+  ```javascript
+  // ✅ DO: Create a simplified test version of the command handler
+  const testAddTaskAction = async (options) => {
+    options = options || {}; // Ensure options aren't undefined
+    
+    // Validate parameters
+    const isManualCreation = options.title && options.description;
+    const prompt = options.prompt || options.p; // Handle shorthand flags
+    
+    if (!prompt && !isManualCreation) {
+      throw new Error('Expected error message');
+    }
+    
+    // Call the mocked task manager
+    return mockTaskManager.addTask(/* parameters */);
+  };
+  
+  test('should handle required parameters correctly', async () => {
+    // Call the test implementation directly
+    await expect(async () => {
+      await testAddTaskAction({ file: 'tasks.json' });
+    }).rejects.toThrow('Expected error message');
+  });
+  ```
+
+- **Commander Chain Mocking (If Necessary)**
+  - ✅ **DO**: Mock ALL chainable methods (`option`, `argument`, `action`, `on`, etc.)
+  - ✅ **DO**: Return `this` (or the mock object) from all chainable method mocks
+  - ✅ **DO**: Remember to mock not only the initial object but also all objects returned by methods
+  - ✅ **DO**: Implement a mechanism to capture the action handler for direct testing
+  
+  ```javascript
+  // If you must mock the Commander.js chain:
+  const mockCommand = {
+    command: jest.fn().mockReturnThis(),
+    description: jest.fn().mockReturnThis(),
+    option: jest.fn().mockReturnThis(),
+    argument: jest.fn().mockReturnThis(), // Don't forget this one
+    action: jest.fn(fn => { 
+      actionHandler = fn; // Capture the handler for testing
+      return mockCommand; 
+    }),
+    on: jest.fn().mockReturnThis() // Don't forget this one
+  };
+  ```
+
+- **Parameter Handling**
+  - ✅ **DO**: Check for both main flag and shorthand flags (e.g., `prompt` and `p`)
+  - ✅ **DO**: Handle parameters like Commander would (comma-separated lists, etc.)
+  - ✅ **DO**: Set proper default values as defined in the command
+  - ✅ **DO**: Validate that required parameters are actually required in tests
+  
+  ```javascript
+  // Parse dependencies like Commander would
+  const dependencies = options.dependencies 
+    ? options.dependencies.split(',').map(id => id.trim())
+    : [];
+  ```
+
+- **Environment and Session Handling**
+  - ✅ **DO**: Properly mock session objects when required by functions
+  - ✅ **DO**: Reset environment variables between tests if modified
+  - ✅ **DO**: Use a consistent pattern for environment-dependent tests
+  
+  ```javascript
+  // Session parameter mock pattern
+  const sessionMock = { session: process.env };
+  
+  // In test:
+  expect(mockAddTask).toHaveBeenCalledWith(
+    expect.any(String),
+    'Test prompt',
+    [],
+    'medium',
+    sessionMock,
+    false,
+    null,
+    null
+  );
+  ```
+
+- **Common Pitfalls to Avoid**
+  - ❌ **DON'T**: Try to use the real action implementation without proper mocking
+  - ❌ **DON'T**: Mock Commander partially - either mock it completely or test the action directly
+  - ❌ **DON'T**: Forget to handle optional parameters that may be undefined
+  - ❌ **DON'T**: Neglect to test shorthand flag functionality (e.g., `-p`, `-r`)
+  - ❌ **DON'T**: Create circular dependencies in your test mocks
+  - ❌ **DON'T**: Access variables before initialization in your test implementations
+  - ❌ **DON'T**: Include actual command execution in unit tests
+  - ❌ **DON'T**: Overwrite the same file path in multiple tests
+  
+  ```javascript
+  // ❌ DON'T: Create circular references in mocks
+  const badMock = {
+    method: jest.fn().mockImplementation(() => badMock.method())
+  };
+  
+  // ❌ DON'T: Access uninitialized variables
+  const badImplementation = () => {
+    const result = uninitialized;
+    let uninitialized = 'value';
+    return result;
+  };
+  ```
+
 ## Jest Module Mocking Best Practices
 
 - **Mock Hoisting Behavior**
@@ -552,6 +670,102 @@ npm test -- -t "pattern to match"
   });
   ```
 
+## Testing AI Service Integrations
+
+- **DO NOT import real AI service clients**
+  - ❌ DON'T: Import actual AI clients from their libraries
+  - ✅ DO: Create fully mocked versions that return predictable responses
+
+  ```javascript
+  // ❌ DON'T: Import and instantiate real AI clients
+  import { Anthropic } from '@anthropic-ai/sdk';
+  const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+  // ✅ DO: Mock the entire module with controlled behavior
+  jest.mock('@anthropic-ai/sdk', () => ({
+    Anthropic: jest.fn().mockImplementation(() => ({
+      messages: {
+        create: jest.fn().mockResolvedValue({
+          content: [{ type: 'text', text: 'Mocked AI response' }]
+        })
+      }
+    }))
+  }));
+  ```
+
+- **DO NOT rely on environment variables for API keys**
+  - ❌ DON'T: Assume environment variables are set in tests
+  - ✅ DO: Set mock environment variables in test setup
+
+  ```javascript
+  // In tests/setup.js or at the top of test file
+  process.env.ANTHROPIC_API_KEY = 'test-mock-api-key-for-tests';
+  process.env.PERPLEXITY_API_KEY = 'test-mock-perplexity-key-for-tests';
+  ```
+
+- **DO NOT use real AI client initialization logic**
+  - ❌ DON'T: Use code that attempts to initialize or validate real AI clients
+  - ✅ DO: Create test-specific paths that bypass client initialization
+
+  ```javascript
+  // ❌ DON'T: Test functions that require valid AI client initialization
+  // This will fail without proper API keys or network access
+  test('should use AI client', async () => {
+    const result = await functionThatInitializesAIClient();
+    expect(result).toBeDefined();
+  });
+
+  // ✅ DO: Test with bypassed initialization or manual task paths
+  test('should handle manual task creation without AI', () => {
+    // Using a path that doesn't require AI client initialization
+    const result = addTaskDirect({ 
+      title: 'Manual Task', 
+      description: 'Test Description'
+    }, mockLogger);
+    
+    expect(result.success).toBe(true);
+  });
+  ```
+
+## Testing Asynchronous Code
+
+- **DO NOT rely on asynchronous operations in tests**
+  - ❌ DON'T: Use real async/await or Promise resolution in tests
+  - ✅ DO: Make all mocks return synchronous values when possible
+
+  ```javascript
+  // ❌ DON'T: Use real async functions that might fail unpredictably
+  test('should handle async operation', async () => {
+    const result = await realAsyncFunction(); // Can time out or fail for external reasons
+    expect(result).toBe(expectedValue);
+  });
+
+  // ✅ DO: Make async operations synchronous in tests
+  test('should handle operation', () => {
+    mockAsyncFunction.mockReturnValue({ success: true, data: 'test' });
+    const result = functionUnderTest();
+    expect(result).toEqual({ success: true, data: 'test' });
+  });
+  ```
+
+- **DO NOT test exact error messages**
+  - ❌ DON'T: Assert on exact error message text that might change
+  - ✅ DO: Test for error presence and general properties
+
+  ```javascript
+  // ❌ DON'T: Test for exact error message text
+  expect(result.error).toBe('Could not connect to API: Network error');
+
+  // ✅ DO: Test for general error properties or message patterns
+  expect(result.success).toBe(false);
+  expect(result.error).toContain('Could not connect');
+  // Or even better:
+  expect(result).toMatchObject({ 
+    success: false,
+    error: expect.stringContaining('connect')
+  });
+  ```
+
 ## Reliable Testing Techniques
 
 - **Create Simplified Test Functions**
@@ -564,99 +778,125 @@ npm test -- -t "pattern to match"
   const setTaskStatus = async (taskId, newStatus) => {
     const tasksPath = 'tasks/tasks.json';
     const data = await readJSON(tasksPath);
-    // Update task status logic
+    // [implementation]
     await writeJSON(tasksPath, data);
-    return data;
+    return { success: true };
   };
   
-  // Test-friendly simplified function (easy to test)
+  // Test-friendly version (easier to test)
-  const testSetTaskStatus = (tasksData, taskIdInput, newStatus) => {
+  const updateTaskStatus = (tasks, taskId, newStatus) => {
-    // Same core logic without file operations
+    // Pure logic without side effects
-    // Update task status logic on provided tasksData object
+    const updatedTasks = [...tasks];
-    return tasksData; // Return updated data for assertions
+    const taskIndex = findTaskById(updatedTasks, taskId);
+    if (taskIndex === -1) return { success: false, error: 'Task not found' };
+    updatedTasks[taskIndex].status = newStatus;
+    return { success: true, tasks: updatedTasks };
   };
   ```
 
-- **Avoid Real File System Operations**
-  - Never write to real files during tests
-  - Create test-specific versions of file operation functions
-  - Mock all file system operations including read, write, exists, etc.
-  - Verify function behavior using the in-memory data structures
-  
-  ```javascript
-  // Mock file operations
-  const mockReadJSON = jest.fn();
-  const mockWriteJSON = jest.fn();
-  
-  jest.mock('../../scripts/modules/utils.js', () => ({
-    readJSON: mockReadJSON,
-    writeJSON: mockWriteJSON,
-  }));
-  
-  test('should update task status correctly', () => {
-    // Setup mock data
-    const testData = JSON.parse(JSON.stringify(sampleTasks));
-    mockReadJSON.mockReturnValue(testData);
-    
-    // Call the function that would normally modify files
-    const result = testSetTaskStatus(testData, '1', 'done');
-    
-    // Assert on the in-memory data structure
-    expect(result.tasks[0].status).toBe('done');
-  });
-  ```
-
-- **Data Isolation Between Tests**
-  - Always create fresh copies of test data for each test
-  - Use `JSON.parse(JSON.stringify(original))` for deep cloning
-  - Reset all mocks before each test with `jest.clearAllMocks()`
-  - Avoid state that persists between tests
-  
-  ```javascript
-  beforeEach(() => {
-    jest.clearAllMocks();
-    // Deep clone the test data
-    testTasksData = JSON.parse(JSON.stringify(sampleTasks));
-  });
-  ```
-
-- **Test All Path Variations**
-  - Regular tasks and subtasks
-  - Single items and multiple items
-  - Success paths and error paths
-  - Edge cases (empty data, invalid inputs, etc.)
-  
-  ```javascript
-  // Multiple test cases covering different scenarios
-  test('should update regular task status', () => {
-    /* test implementation */
-  });
-  
-  test('should update subtask status', () => {
-    /* test implementation */
-  });
-  
-  test('should update multiple tasks when given comma-separated IDs', () => {
-    /* test implementation */
-  });
-  
-  test('should throw error for non-existent task ID', () => {
-    /* test implementation */
-  });
-  ```
-
-- **Stabilize Tests With Predictable Input/Output**
-  - Use consistent, predictable test fixtures
-  - Avoid random values or time-dependent data
-  - Make tests deterministic for reliable CI/CD
-  - Control all variables that might affect test outcomes
-  
-  ```javascript
-  // Use a specific known date instead of current date
-  const fixedDate = new Date('2023-01-01T12:00:00Z');
-  jest.spyOn(global, 'Date').mockImplementation(() => fixedDate);
-  ```
-
 See [tests/README.md](mdc:tests/README.md) for more details on the testing approach.
 
 Refer to [jest.config.js](mdc:jest.config.js) for Jest configuration options.
+
+## Variable Hoisting and Module Initialization Issues
+
+When testing ES modules or working with complex module imports, you may encounter variable hoisting and initialization issues. These can be particularly tricky to debug and often appear as "Cannot access 'X' before initialization" errors.
+
+- **Understanding Module Initialization Order**
+  - ✅ **DO**: Declare and initialize global variables at the top of modules
+  - ✅ **DO**: Use proper function declarations to avoid hoisting issues
+  - ✅ **DO**: Initialize variables before they are referenced, especially in imported modules
+  - ✅ **DO**: Be aware that imports are hoisted to the top of the file
+  
+  ```javascript
+  // ✅ DO: Define global state variables at the top of the module
+  let silentMode = false; // Declare and initialize first
+  
+  const CONFIG = { /* configuration */ };
+  
+  function isSilentMode() {
+    return silentMode; // Reference variable after it's initialized
+  }
+  
+  function log(level, message) {
+    if (isSilentMode()) return; // Use the function instead of accessing variable directly
+    // ...
+  }
+  ```
+
+- **Testing Modules with Initialization-Dependent Functions**
+  - ✅ **DO**: Create test-specific implementations that initialize all variables correctly
+  - ✅ **DO**: Use factory functions in mocks to ensure proper initialization order
+  - ✅ **DO**: Be careful with how you mock or stub functions that depend on module state
+  
+  ```javascript
+  // ✅ DO: Test-specific implementation that avoids initialization issues
+  const testLog = (level, ...args) => {
+    // Local implementation with proper initialization
+    const isSilent = false; // Explicit initialization
+    if (isSilent) return;
+    // Test implementation...
+  };
+  ```
+
+- **Common Hoisting-Related Errors to Avoid**
+  - ❌ **DON'T**: Reference variables before their declaration in module scope
+  - ❌ **DON'T**: Create circular dependencies between modules
+  - ❌ **DON'T**: Rely on variable initialization order across module boundaries
+  - ❌ **DON'T**: Define functions that use hoisted variables before they're initialized
+  
+  ```javascript
+  // ❌ DON'T: Create reference-before-initialization patterns
+  function badFunction() {
+    if (silentMode) { /* ... */ } // ReferenceError if silentMode is declared later
+  }
+  
+  let silentMode = false;
+  
+  // ❌ DON'T: Create cross-module references that depend on initialization order
+  // module-a.js
+  import { getSetting } from './module-b.js';
+  export const config = { value: getSetting() };
+  
+  // module-b.js
+  import { config } from './module-a.js';
+  export function getSetting() {
+    return config.value; // Circular dependency causing initialization issues
+  }
+  ```
+
+- **Dynamic Imports as a Solution**
+  - ✅ **DO**: Use dynamic imports (`import()`) to avoid initialization order issues
+  - ✅ **DO**: Structure modules to avoid circular dependencies that cause initialization issues
+  - ✅ **DO**: Consider factory functions for modules with complex state
+  
+  ```javascript
+  // ✅ DO: Use dynamic imports to avoid initialization issues
+  async function getTaskManager() {
+    return import('./task-manager.js');
+  }
+  
+  async function someFunction() {
+    const taskManager = await getTaskManager();
+    return taskManager.someMethod();
+  }
+  ```
+
+- **Testing Approach for Modules with Initialization Issues**
+  - ✅ **DO**: Create self-contained test implementations rather than using real implementations
+  - ✅ **DO**: Mock dependencies at module boundaries instead of trying to mock deep dependencies
+  - ✅ **DO**: Isolate module-specific state in tests
+  
+  ```javascript
+  // ✅ DO: Create isolated test implementation instead of reusing module code
+  test('should log messages when not in silent mode', () => {
+    // Local test implementation instead of importing from module
+    const testLog = (level, message) => {
+      if (false) return; // Always non-silent for this test
+      mockConsole(level, message);
+    };
+    
+    testLog('info', 'test message');
+    expect(mockConsole).toHaveBeenCalledWith('info', 'test message');
+  });
+  ``` 

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,39 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: 'bug: '
+labels: bug
+assignees: ''
+---
+
+### Description
+
+Detailed description of the problem, including steps to reproduce the issue.
+
+### Steps to Reproduce
+
+1. Step-by-step instructions to reproduce the issue
+2. Include command examples or UI interactions
+
+### Expected Behavior
+
+Describe clearly what the expected outcome or behavior should be.
+
+### Actual Behavior
+
+Describe clearly what the actual outcome or behavior is.
+
+### Screenshots or Logs
+
+Provide screenshots, logs, or error messages if applicable.
+
+### Environment
+
+- Task Master version:
+- Node.js version:
+- Operating system:
+- IDE (if applicable):
+
+### Additional Context
+
+Any additional information or context that might help diagnose the issue.

.github/ISSUE_TEMPLATE/enhancements---feature-requests.md

@@ -0,0 +1,51 @@
+---
+name: Enhancements & feature requests
+about: Suggest an idea for this project
+title: 'feat: '
+labels: enhancement
+assignees: ''
+---
+
+> "Direct quote or clear summary of user request or need or user story."
+
+### Motivation
+
+Detailed explanation of why this feature is important. Describe the problem it solves or the benefit it provides.
+
+### Proposed Solution
+
+Clearly describe the proposed feature, including:
+
+- High-level overview of the feature
+- Relevant technologies or integrations
+- How it fits into the existing workflow or architecture
+
+### High-Level Workflow
+
+1. Step-by-step description of how the feature will be implemented
+2. Include necessary intermediate milestones
+
+### Key Elements
+
+- Bullet-point list of technical or UX/UI enhancements
+- Mention specific integrations or APIs
+- Highlight changes needed in existing data models or commands
+
+### Example Workflow
+
+Provide a clear, concrete example demonstrating the feature:
+
+```shell
+$ task-master [action]
+→ Expected response/output
+```
+
+### Implementation Considerations
+
+- Dependencies on external components or APIs
+- Backward compatibility requirements
+- Potential performance impacts or resource usage
+
+### Out of Scope (Future Considerations)
+
+Clearly list any features or improvements not included but relevant for future iterations.

.github/ISSUE_TEMPLATE/feedback.md

@@ -0,0 +1,31 @@
+---
+name: Feedback
+about: Give us specific feedback on the product/approach/tech
+title: 'feedback: '
+labels: feedback
+assignees: ''
+---
+
+### Feedback Summary
+
+Provide a clear summary or direct quote from user feedback.
+
+### User Context
+
+Explain the user's context or scenario in which this feedback was provided.
+
+### User Impact
+
+Describe how this feedback affects the user experience or workflow.
+
+### Suggestions
+
+Provide any initial thoughts, potential solutions, or improvements based on the feedback.
+
+### Relevant Screenshots or Examples
+
+Attach screenshots, logs, or examples that illustrate the feedback.
+
+### Additional Notes
+
+Any additional context or related information.

.github/workflows/ci.yml

@@ -14,7 +14,7 @@ permissions:
   contents: read
 
 jobs:
-  build:
+  setup:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
@@ -24,21 +24,55 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: "npm"
+          cache: 'npm'
+
+      - name: Install Dependencies
+        id: install
+        run: npm ci
+        timeout-minutes: 2
 
       - name: Cache node_modules
         uses: actions/cache@v4
         with:
-          path: |
+          path: node_modules
-            node_modules
+          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
-            */*/node_modules
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
 
-      - name: Install Dependencies
+  format-check:
-        run: npm ci
+    needs: setup
-        timeout-minutes: 2
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Restore node_modules
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
+
+      - name: Format Check
+        run: npm run format-check
+        env:
+          FORCE_COLOR: 1
+
+  test:
+    needs: setup
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 20
+
+      - name: Restore node_modules
+        uses: actions/cache@v4
+        with:
+          path: node_modules
+          key: ${{ runner.os }}-node-modules-${{ hashFiles('**/package-lock.json') }}
 
       - name: Run Tests
         run: |
@@ -47,13 +81,13 @@ jobs:
           NODE_ENV: test
           CI: true
           FORCE_COLOR: 1
-        timeout-minutes: 15
+        timeout-minutes: 10
 
       - name: Upload Test Results
         if: always()
         uses: actions/upload-artifact@v4
         with:
-          name: test-results-node
+          name: test-results
           path: |
             test-results
             coverage

.github/workflows/release.yml

@@ -14,7 +14,7 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: 20
-          cache: "npm"
+          cache: 'npm'
 
       - name: Cache node_modules
         uses: actions/cache@v4

.prettierignore

@@ -0,0 +1,6 @@
+# Ignore artifacts:
+build
+coverage
+.changeset
+tasks
+package-lock.json

.prettierrc

@@ -0,0 +1,11 @@
+{
+	"printWidth": 80,
+	"tabWidth": 2,
+	"useTabs": true,
+	"semi": true,
+	"singleQuote": true,
+	"trailingComma": "none",
+	"bracketSpacing": true,
+	"arrowParens": "always",
+	"endOfLine": "lf"
+}

.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+	"recommendations": ["esbenp.prettier-vscode"]
+}

LICENSE.md

@@ -1,90 +0,0 @@
-# Dual License
-
-This project is licensed under two separate licenses:
-
-1. [Business Source License 1.1](#business-source-license-11) (BSL 1.1) for commercial use of Task Master itself
-2. [Apache License 2.0](#apache-license-20) for all other uses
-
-## Business Source License 1.1
-
-Terms: https://mariadb.com/bsl11/
-
-Licensed Work: Task Master AI
-Additional Use Grant: You may use Task Master AI to create and commercialize your own projects and products.
-
-Change Date: 2025-03-30
-Change License: None
-
-The Licensed Work is subject to the Business Source License 1.1. If you are interested in using the Licensed Work in a way that competes directly with Task Master, please contact the licensors.
-
-### Licensor
-
-- Eyal Toledano (GitHub: @eyaltoledano)
-- Ralph (GitHub: @Crunchyman-ralph)
-
-### Commercial Use Restrictions
-
-This license explicitly restricts certain commercial uses of Task Master AI to the Licensors listed above. Restricted commercial uses include:
-
-1. Creating commercial products or services that directly compete with Task Master AI
-2. Selling Task Master AI itself as a service
-3. Offering Task Master AI's functionality as a commercial managed service
-4. Reselling or redistributing Task Master AI for a fee
-
-### Explicitly Permitted Uses
-
-The following uses are explicitly allowed under this license:
-
-1. Using Task Master AI to create and commercialize your own projects
-2. Using Task Master AI in commercial environments for internal development
-3. Building and selling products or services that were created using Task Master AI
-4. Using Task Master AI for commercial development as long as you're not selling Task Master AI itself
-
-### Additional Terms
-
-1. The right to commercialize Task Master AI itself is exclusively reserved for the Licensors
-2. No party may create commercial products that directly compete with Task Master AI without explicit written permission
-3. Forks of this repository are subject to the same restrictions regarding direct competition
-4. Contributors agree that their contributions will be subject to this same dual licensing structure
-
-## Apache License 2.0
-
-For all uses other than those restricted above. See [APACHE-LICENSE](./APACHE-LICENSE) for the full license text.
-
-### Permitted Use Definition
-
-You may use Task Master AI for any purpose, including commercial purposes, as long as you are not:
-
-1. Creating a direct competitor to Task Master AI
-2. Selling Task Master AI itself as a service
-3. Redistributing Task Master AI for a fee
-
-### Requirements for Use
-
-1. You must include appropriate copyright notices
-2. You must state significant changes made to the software
-3. You must preserve all license notices
-
-## Questions and Commercial Licensing
-
-For questions about licensing or to inquire about commercial use that may compete with Task Master, please contact:
-
-- Eyal Toledano (GitHub: @eyaltoledano)
-- Ralph (GitHub: @Crunchyman-ralph)
-
-## Examples
-
-### ✅ Allowed Uses
-
-- Using Task Master to create a commercial SaaS product
-- Using Task Master in your company for development
-- Creating and selling products that were built using Task Master
-- Using Task Master to generate code for commercial projects
-- Offering consulting services where you use Task Master
-
-### ❌ Restricted Uses
-
-- Creating a competing AI task management tool
-- Selling access to Task Master as a service
-- Creating a hosted version of Task Master
-- Reselling Task Master's functionality

README-task-master.md

@@ -58,6 +58,7 @@ This will prompt you for project details and set up a new project with the neces
 ### Important Notes
 
 1. **ES Modules Configuration:**
+
    - This project uses ES Modules (ESM) instead of CommonJS.
    - This is set via `"type": "module"` in your package.json.
    - Use `import/export` syntax instead of `require()`.

README.md

@@ -1,8 +1,6 @@
 # Task Master [![GitHub stars](https://img.shields.io/github/stars/eyaltoledano/claude-task-master?style=social)](https://github.com/eyaltoledano/claude-task-master/stargazers)
 
-[![CI](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml/badge.svg)](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml) [![npm version](https://badge.fury.io/js/task-master-ai.svg)](https://badge.fury.io/js/task-master-ai)
+[![CI](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml/badge.svg)](https://github.com/eyaltoledano/claude-task-master/actions/workflows/ci.yml) [![npm version](https://badge.fury.io/js/task-master-ai.svg)](https://badge.fury.io/js/task-master-ai) ![Discord Follow](https://dcbadge.limes.pink/api/server/https://discord.gg/2ms58QJjqp?style=flat) [![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)
-
-![Discord Follow](https://dcbadge.limes.pink/api/server/https://discord.gg/2ms58QJjqp?style=flat) [![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)
 
 ### By [@eyaltoledano](https://x.com/eyaltoledano) & [@RalphEcom](https://x.com/RalphEcom)
 
@@ -26,22 +24,22 @@ MCP (Model Control Protocol) provides the easiest way to get started with Task M
 
 ```json
 {
-  "mcpServers": {
+	"mcpServers": {
-    "taskmaster-ai": {
+		"taskmaster-ai": {
-      "command": "npx",
+			"command": "npx",
-      "args": ["-y", "task-master-ai", "mcp-server"],
+			"args": ["-y", "--package", "task-master-ai", "task-master-mcp"],
-      "env": {
+			"env": {
-        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
+				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
-        "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
+				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
-        "MODEL": "claude-3-7-sonnet-20250219",
+				"MODEL": "claude-3-7-sonnet-20250219",
-        "PERPLEXITY_MODEL": "sonar-pro",
+				"PERPLEXITY_MODEL": "sonar-pro",
-        "MAX_TOKENS": 128000,
+				"MAX_TOKENS": 128000,
-        "TEMPERATURE": 0.2,
+				"TEMPERATURE": 0.2,
-        "DEFAULT_SUBTASKS": 5,
+				"DEFAULT_SUBTASKS": 5,
-        "DEFAULT_PRIORITY": "medium"
+				"DEFAULT_PRIORITY": "medium"
-      }
+			}
-    }
+		}
-  }
+	}
 }
 ```
 
@@ -133,6 +131,12 @@ cd claude-task-master
 node scripts/init.js
 ```
 
+## Contributors
+
+<a href="https://github.com/eyaltoledano/claude-task-master/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=eyaltoledano/claude-task-master" alt="Task Master project contributors" />
+</a>
+
 ## Star History
 
 [![Star History Chart](https://api.star-history.com/svg?repos=eyaltoledano/claude-task-master&type=Timeline)](https://www.star-history.com/#eyaltoledano/claude-task-master&Timeline)

assets/scripts_README.md

@@ -21,9 +21,11 @@ In an AI-driven development process—particularly with tools like [Cursor](http
 The script can be configured through environment variables in a `.env` file at the root of the project:
 
 ### Required Configuration
+
 - `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
 
 ### Optional Configuration
+
 - `MODEL`: Specify which Claude model to use (default: "claude-3-7-sonnet-20250219")
 - `MAX_TOKENS`: Maximum tokens for model responses (default: 4000)
 - `TEMPERATURE`: Temperature for model responses (default: 0.7)
@@ -39,6 +41,7 @@ The script can be configured through environment variables in a `.env` file at t
 ## How It Works
 
 1. **`tasks.json`**:
+
    - A JSON file at the project root containing an array of tasks (each with `id`, `title`, `description`, `status`, etc.).
    - The `meta` field can store additional info like the project's name, version, or reference to the PRD.
    - Tasks can have `subtasks` for more detailed implementation steps.
@@ -111,6 +114,7 @@ task-master update --file=custom-tasks.json --from=5 --prompt="Change database f
 ```
 
 Notes:
+
 - The `--prompt` parameter is required and should explain the changes or new context
 - Only tasks that aren't marked as 'done' will be updated
 - Tasks with ID >= the specified --from value will be updated
@@ -134,6 +138,7 @@ task-master set-status --id=1,2,3 --status=done
 ```
 
 Notes:
+
 - When marking a parent task as "done", all of its subtasks will automatically be marked as "done" as well
 - Common status values are 'done', 'pending', and 'deferred', but any string is accepted
 - You can specify multiple task IDs by separating them with commas
@@ -183,6 +188,7 @@ task-master clear-subtasks --all
 ```
 
 Notes:
+
 - After clearing subtasks, task files are automatically regenerated
 - This is useful when you want to regenerate subtasks with a different approach
 - Can be combined with the `expand` command to immediately generate new subtasks
@@ -198,6 +204,7 @@ The script integrates with two AI services:
 The Perplexity integration uses the OpenAI client to connect to Perplexity's API, which provides enhanced research capabilities for generating more informed subtasks. If the Perplexity API is unavailable or encounters an error, the script will automatically fall back to using Anthropic's Claude.
 
 To use the Perplexity integration:
+
 1. Obtain a Perplexity API key
 2. Add `PERPLEXITY_API_KEY` to your `.env` file
 3. Optionally specify `PERPLEXITY_MODEL` in your `.env` file (default: "sonar-medium-online")
@@ -206,6 +213,7 @@ To use the Perplexity integration:
 ## Logging
 
 The script supports different logging levels controlled by the `LOG_LEVEL` environment variable:
+
 - `debug`: Detailed information, typically useful for troubleshooting
 - `info`: Confirmation that things are working as expected (default)
 - `warn`: Warning messages that don't prevent execution
@@ -228,17 +236,20 @@ task-master remove-dependency --id=<id> --depends-on=<id>
 These commands:
 
 1. **Allow precise dependency management**:
+
    - Add dependencies between tasks with automatic validation
    - Remove dependencies when they're no longer needed
    - Update task files automatically after changes
 
 2. **Include validation checks**:
+
    - Prevent circular dependencies (a task depending on itself)
    - Prevent duplicate dependencies
    - Verify that both tasks exist before adding/removing dependencies
    - Check if dependencies exist before attempting to remove them
 
 3. **Provide clear feedback**:
+
    - Success messages confirm when dependencies are added/removed
    - Error messages explain why operations failed (if applicable)
 
@@ -263,6 +274,7 @@ task-master validate-dependencies --file=custom-tasks.json
 ```
 
 This command:
+
 - Scans all tasks and subtasks for non-existent dependencies
 - Identifies potential self-dependencies (tasks referencing themselves)
 - Reports all found issues without modifying files
@@ -284,6 +296,7 @@ task-master fix-dependencies --file=custom-tasks.json
 ```
 
 This command:
+
 1. **Validates all dependencies** across tasks and subtasks
 2. **Automatically removes**:
    - References to non-existent tasks and subtasks
@@ -321,6 +334,7 @@ task-master analyze-complexity --research
 ```
 
 Notes:
+
 - The command uses Claude to analyze each task's complexity (or Perplexity with --research flag)
 - Tasks are scored on a scale of 1-10
 - Each task receives a recommended number of subtasks based on DEFAULT_SUBTASKS configuration
@@ -345,33 +359,35 @@ task-master expand --id=8 --num=5 --prompt="Custom prompt"
 ```
 
 When a complexity report exists:
+
 - The `expand` command will use the recommended subtask count from the report (unless overridden)
 - It will use the tailored expansion prompt from the report (unless a custom prompt is provided)
 - When using `--all`, tasks are sorted by complexity score (highest first)
 - The `--research` flag is preserved from the complexity analysis to expansion
 
 The output report structure is:
+
 ```json
 {
-  "meta": {
+	"meta": {
-    "generatedAt": "2023-06-15T12:34:56.789Z",
+		"generatedAt": "2023-06-15T12:34:56.789Z",
-    "tasksAnalyzed": 20,
+		"tasksAnalyzed": 20,
-    "thresholdScore": 5,
+		"thresholdScore": 5,
-    "projectName": "Your Project Name",
+		"projectName": "Your Project Name",
-    "usedResearch": true
+		"usedResearch": true
-  },
+	},
-  "complexityAnalysis": [
+	"complexityAnalysis": [
-    {
+		{
-      "taskId": 8,
+			"taskId": 8,
-      "taskTitle": "Develop Implementation Drift Handling",
+			"taskTitle": "Develop Implementation Drift Handling",
-      "complexityScore": 9.5,
+			"complexityScore": 9.5,
-      "recommendedSubtasks": 6,
+			"recommendedSubtasks": 6,
-      "expansionPrompt": "Create subtasks that handle detecting...",
+			"expansionPrompt": "Create subtasks that handle detecting...",
-      "reasoning": "This task requires sophisticated logic...",
+			"reasoning": "This task requires sophisticated logic...",
-      "expansionCommand": "task-master expand --id=8 --num=6 --prompt=\"Create subtasks...\" --research"
+			"expansionCommand": "task-master expand --id=8 --num=6 --prompt=\"Create subtasks...\" --research"
-    },
+		}
-    // More tasks sorted by complexity score (highest first)
+		// More tasks sorted by complexity score (highest first)
-  ]
+	]
 }
 ```
 

bin/task-master-init.js

@@ -1,30 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Claude Task Master Init
- * Direct executable for the init command
- */
-
-import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
-import { dirname, resolve } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-// Get the path to the init script
-const initScriptPath = resolve(__dirname, '../scripts/init.js');
-
-// Pass through all arguments
-const args = process.argv.slice(2);
-
-// Spawn the init script with all arguments
-const child = spawn('node', [initScriptPath, ...args], {
-  stdio: 'inherit',
-  cwd: process.cwd()
-});
-
-// Handle exit
-child.on('close', (code) => {
-  process.exit(code);
-}); 

bin/task-master.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node --trace-deprecation
 
 /**
  * Task Master
@@ -44,30 +44,36 @@ const initScriptPath = resolve(__dirname, '../scripts/init.js');
 
 // Helper function to run dev.js with arguments
 function runDevScript(args) {
-  // Debug: Show the transformed arguments when DEBUG=1 is set
+	// Debug: Show the transformed arguments when DEBUG=1 is set
-  if (process.env.DEBUG === '1') {
+	if (process.env.DEBUG === '1') {
-    console.error('\nDEBUG - CLI Wrapper Analysis:');
+		console.error('\nDEBUG - CLI Wrapper Analysis:');
-    console.error('- Original command: ' + process.argv.join(' '));
+		console.error('- Original command: ' + process.argv.join(' '));
-    console.error('- Transformed args: ' + args.join(' '));
+		console.error('- Transformed args: ' + args.join(' '));
-    console.error('- dev.js will receive: node ' + devScriptPath + ' ' + args.join(' ') + '\n');
+		console.error(
-  }
+			'- dev.js will receive: node ' +
+				devScriptPath +
+				' ' +
+				args.join(' ') +
+				'\n'
+		);
+	}
 
-  // For testing: If TEST_MODE is set, just print args and exit
+	// For testing: If TEST_MODE is set, just print args and exit
-  if (process.env.TEST_MODE === '1') {
+	if (process.env.TEST_MODE === '1') {
-    console.log('Would execute:');
+		console.log('Would execute:');
-    console.log(`node ${devScriptPath} ${args.join(' ')}`);
+		console.log(`node ${devScriptPath} ${args.join(' ')}`);
-    process.exit(0);
+		process.exit(0);
-    return;
+		return;
-  }
+	}
 
-  const child = spawn('node', [devScriptPath, ...args], {
+	const child = spawn('node', [devScriptPath, ...args], {
-    stdio: 'inherit',
+		stdio: 'inherit',
-    cwd: process.cwd()
+		cwd: process.cwd()
-  });
+	});
 
-  child.on('close', (code) => {
+	child.on('close', (code) => {
-    process.exit(code);
+		process.exit(code);
-  });
+	});
 }
 
 // Helper function to detect camelCase and convert to kebab-case
@@ -79,228 +85,239 @@ const toKebabCase = (str) => str.replace(/([A-Z])/g, '-$1').toLowerCase();
  * @returns {Function} Wrapper action function
  */
 function createDevScriptAction(commandName) {
-  return (options, cmd) => {
+	return (options, cmd) => {
-    // Check for camelCase flags and error out with helpful message
+		// Check for camelCase flags and error out with helpful message
-    const camelCaseFlags = detectCamelCaseFlags(process.argv);
+		const camelCaseFlags = detectCamelCaseFlags(process.argv);
 
-    // If camelCase flags were found, show error and exit
+		// If camelCase flags were found, show error and exit
-    if (camelCaseFlags.length > 0) {
+		if (camelCaseFlags.length > 0) {
-      console.error('\nError: Please use kebab-case for CLI flags:');
+			console.error('\nError: Please use kebab-case for CLI flags:');
-      camelCaseFlags.forEach(flag => {
+			camelCaseFlags.forEach((flag) => {
-        console.error(`  Instead of: --${flag.original}`);
+				console.error(`  Instead of: --${flag.original}`);
-        console.error(`  Use:        --${flag.kebabCase}`);
+				console.error(`  Use:        --${flag.kebabCase}`);
-      });
+			});
-      console.error('\nExample: task-master parse-prd --num-tasks=5 instead of --numTasks=5\n');
+			console.error(
-      process.exit(1);
+				'\nExample: task-master parse-prd --num-tasks=5 instead of --numTasks=5\n'
-    }
+			);
+			process.exit(1);
+		}
 
-    // Since we've ensured no camelCase flags, we can now just:
+		// Since we've ensured no camelCase flags, we can now just:
-    // 1. Start with the command name
+		// 1. Start with the command name
-    const args = [commandName];
+		const args = [commandName];
 
-    // 3. Get positional arguments and explicit flags from the command line
+		// 3. Get positional arguments and explicit flags from the command line
-    const commandArgs = [];
+		const commandArgs = [];
-    const positionals = new Set(); // Track positional args we've seen
+		const positionals = new Set(); // Track positional args we've seen
 
-    // Find the command in raw process.argv to extract args
+		// Find the command in raw process.argv to extract args
-    const commandIndex = process.argv.indexOf(commandName);
+		const commandIndex = process.argv.indexOf(commandName);
-    if (commandIndex !== -1) {
+		if (commandIndex !== -1) {
-      // Process all args after the command name
+			// Process all args after the command name
-      for (let i = commandIndex + 1; i < process.argv.length; i++) {
+			for (let i = commandIndex + 1; i < process.argv.length; i++) {
-        const arg = process.argv[i];
+				const arg = process.argv[i];
 
-        if (arg.startsWith('--')) {
+				if (arg.startsWith('--')) {
-          // It's a flag - pass through as is
+					// It's a flag - pass through as is
-          commandArgs.push(arg);
+					commandArgs.push(arg);
-          // Skip the next arg if this is a flag with a value (not --flag=value format)
+					// Skip the next arg if this is a flag with a value (not --flag=value format)
-          if (!arg.includes('=') && 
+					if (
-              i + 1 < process.argv.length && 
+						!arg.includes('=') &&
-              !process.argv[i+1].startsWith('--')) {
+						i + 1 < process.argv.length &&
-            commandArgs.push(process.argv[++i]);
+						!process.argv[i + 1].startsWith('--')
-          }
+					) {
-        } else if (!positionals.has(arg)) {
+						commandArgs.push(process.argv[++i]);
-          // It's a positional argument we haven't seen
+					}
-          commandArgs.push(arg);
+				} else if (!positionals.has(arg)) {
-          positionals.add(arg);
+					// It's a positional argument we haven't seen
-        }
+					commandArgs.push(arg);
-      }
+					positionals.add(arg);
-    }
+				}
+			}
+		}
 
-    // Add all command line args we collected
+		// Add all command line args we collected
-    args.push(...commandArgs);
+		args.push(...commandArgs);
 
-    // 4. Add default options from Commander if not specified on command line
+		// 4. Add default options from Commander if not specified on command line
-    // Track which options we've seen on the command line
+		// Track which options we've seen on the command line
-    const userOptions = new Set();
+		const userOptions = new Set();
-    for (const arg of commandArgs) {
+		for (const arg of commandArgs) {
-      if (arg.startsWith('--')) {
+			if (arg.startsWith('--')) {
-        // Extract option name (without -- and value)
+				// Extract option name (without -- and value)
-        const name = arg.split('=')[0].slice(2);
+				const name = arg.split('=')[0].slice(2);
-        userOptions.add(name);
+				userOptions.add(name);
 
-        // Add the kebab-case version too, to prevent duplicates
+				// Add the kebab-case version too, to prevent duplicates
-        const kebabName = name.replace(/([A-Z])/g, '-$1').toLowerCase();
+				const kebabName = name.replace(/([A-Z])/g, '-$1').toLowerCase();
-        userOptions.add(kebabName);
+				userOptions.add(kebabName);
 
-        // Add the camelCase version as well
+				// Add the camelCase version as well
-        const camelName = kebabName.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+				const camelName = kebabName.replace(/-([a-z])/g, (_, letter) =>
-        userOptions.add(camelName);
+					letter.toUpperCase()
-      }
+				);
-    }
+				userOptions.add(camelName);
+			}
+		}
 
-    // Add Commander-provided defaults for options not specified by user
+		// Add Commander-provided defaults for options not specified by user
-    Object.entries(options).forEach(([key, value]) => {
+		Object.entries(options).forEach(([key, value]) => {
-      // Debug output to see what keys we're getting
+			// Debug output to see what keys we're getting
-      if (process.env.DEBUG === '1') {
+			if (process.env.DEBUG === '1') {
-        console.error(`DEBUG - Processing option: ${key} = ${value}`);
+				console.error(`DEBUG - Processing option: ${key} = ${value}`);
-      }
+			}
 
-      // Special case for numTasks > num-tasks (a known problem case)
+			// Special case for numTasks > num-tasks (a known problem case)
-      if (key === 'numTasks') {
+			if (key === 'numTasks') {
-        if (process.env.DEBUG === '1') {
+				if (process.env.DEBUG === '1') {
-          console.error('DEBUG - Converting numTasks to num-tasks');
+					console.error('DEBUG - Converting numTasks to num-tasks');
-        }
+				}
-        if (!userOptions.has('num-tasks') && !userOptions.has('numTasks')) {
+				if (!userOptions.has('num-tasks') && !userOptions.has('numTasks')) {
-          args.push(`--num-tasks=${value}`);
+					args.push(`--num-tasks=${value}`);
-        }
+				}
-        return;
+				return;
-      }
+			}
 
-      // Skip built-in Commander properties and options the user provided
+			// Skip built-in Commander properties and options the user provided
-      if (['parent', 'commands', 'options', 'rawArgs'].includes(key) || userOptions.has(key)) {
+			if (
-        return;
+				['parent', 'commands', 'options', 'rawArgs'].includes(key) ||
-      }
+				userOptions.has(key)
+			) {
+				return;
+			}
 
-      // Also check the kebab-case version of this key
+			// Also check the kebab-case version of this key
-      const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
+			const kebabKey = key.replace(/([A-Z])/g, '-$1').toLowerCase();
-      if (userOptions.has(kebabKey)) {
+			if (userOptions.has(kebabKey)) {
-        return;
+				return;
-      }
+			}
 
-      // Add default values, using kebab-case for the parameter name
+			// Add default values, using kebab-case for the parameter name
-      if (value !== undefined) {
+			if (value !== undefined) {
-        if (typeof value === 'boolean') {
+				if (typeof value === 'boolean') {
-          if (value === true) {
+					if (value === true) {
-            args.push(`--${kebabKey}`);
+						args.push(`--${kebabKey}`);
-          } else if (value === false && key === 'generate') {
+					} else if (value === false && key === 'generate') {
-            args.push('--skip-generate');
+						args.push('--skip-generate');
-          }
+					}
-        } else {
+				} else {
-          // Always use kebab-case for option names
+					// Always use kebab-case for option names
-          args.push(`--${kebabKey}=${value}`);
+					args.push(`--${kebabKey}=${value}`);
-        }
+				}
-      }
+			}
-    });
+		});
 
-    // Special handling for parent parameter (uses -p)
+		// Special handling for parent parameter (uses -p)
-    if (options.parent && !args.includes('-p') && !userOptions.has('parent')) {
+		if (options.parent && !args.includes('-p') && !userOptions.has('parent')) {
-      args.push('-p', options.parent);
+			args.push('-p', options.parent);
-    }
+		}
 
-    // Debug output for troubleshooting
+		// Debug output for troubleshooting
-    if (process.env.DEBUG === '1') {
+		if (process.env.DEBUG === '1') {
-      console.error('DEBUG - Command args:', commandArgs);
+			console.error('DEBUG - Command args:', commandArgs);
-      console.error('DEBUG - User options:', Array.from(userOptions));
+			console.error('DEBUG - User options:', Array.from(userOptions));
-      console.error('DEBUG - Commander options:', options);
+			console.error('DEBUG - Commander options:', options);
-      console.error('DEBUG - Final args:', args);
+			console.error('DEBUG - Final args:', args);
-    }
+		}
 
-    // Run the script with our processed args
+		// Run the script with our processed args
-    runDevScript(args);
+		runDevScript(args);
-  };
+	};
 }
 
-// Special case for the 'init' command which uses a different script
+// // Special case for the 'init' command which uses a different script
-function registerInitCommand(program) {
+// function registerInitCommand(program) {
-  program
+// 	program
-    .command('init')
+// 		.command('init')
-    .description('Initialize a new project')
+// 		.description('Initialize a new project')
-    .option('-y, --yes', 'Skip prompts and use default values')
+// 		.option('-y, --yes', 'Skip prompts and use default values')
-    .option('-n, --name <name>', 'Project name')
+// 		.option('-n, --name <name>', 'Project name')
-    .option('-d, --description <description>', 'Project description')
+// 		.option('-d, --description <description>', 'Project description')
-    .option('-v, --version <version>', 'Project version')
+// 		.option('-v, --version <version>', 'Project version')
-    .option('-a, --author <author>', 'Author name')
+// 		.option('-a, --author <author>', 'Author name')
-    .option('--skip-install', 'Skip installing dependencies')
+// 		.option('--skip-install', 'Skip installing dependencies')
-    .option('--dry-run', 'Show what would be done without making changes')
+// 		.option('--dry-run', 'Show what would be done without making changes')
-    .action((options) => {
+// 		.action((options) => {
-      // Pass through any options to the init script
+// 			// Pass through any options to the init script
-      const args = ['--yes', 'name', 'description', 'version', 'author', 'skip-install', 'dry-run']
+// 			const args = [
-        .filter(opt => options[opt])
+// 				'--yes',
-        .map(opt => {
+// 				'name',
-          if (opt === 'yes' || opt === 'skip-install' || opt === 'dry-run') {
+// 				'description',
-            return `--${opt}`;
+// 				'version',
-          }
+// 				'author',
-          return `--${opt}=${options[opt]}`;
+// 				'skip-install',
-        });
+// 				'dry-run'
+// 			]
+// 				.filter((opt) => options[opt])
+// 				.map((opt) => {
+// 					if (opt === 'yes' || opt === 'skip-install' || opt === 'dry-run') {
+// 						return `--${opt}`;
+// 					}
+// 					return `--${opt}=${options[opt]}`;
+// 				});
 
-      const child = spawn('node', [initScriptPath, ...args], {
+// 			const child = spawn('node', [initScriptPath, ...args], {
-        stdio: 'inherit',
+// 				stdio: 'inherit',
-        cwd: process.cwd()
+// 				cwd: process.cwd()
-      });
+// 			});
 
-      child.on('close', (code) => {
+// 			child.on('close', (code) => {
-        process.exit(code);
+// 				process.exit(code);
-      });
+// 			});
-    });
+// 		});
-}
+// }
 
 // Set up the command-line interface
 const program = new Command();
 
 program
-  .name('task-master')
+	.name('task-master')
-  .description('Claude Task Master CLI')
+	.description('Claude Task Master CLI')
-  .version(version)
+	.version(version)
-  .addHelpText('afterAll', () => {
+	.addHelpText('afterAll', () => {
-    // Use the same help display function as dev.js for consistency
+		// Use the same help display function as dev.js for consistency
-    displayHelp();
+		displayHelp();
-    return ''; // Return empty string to prevent commander's default help
+		return ''; // Return empty string to prevent commander's default help
-  });
+	});
 
 // Add custom help option to directly call our help display
 program.helpOption('-h, --help', 'Display help information');
 program.on('--help', () => {
-  displayHelp();
+	displayHelp();
 });
 
-// Add special case commands
+// // Add special case commands
-registerInitCommand(program);
+// registerInitCommand(program);
 
 program
-  .command('dev')
+	.command('dev')
-  .description('Run the dev.js script')
+	.description('Run the dev.js script')
-  .action(() => {
+	.action(() => {
-    const args = process.argv.slice(process.argv.indexOf('dev') + 1);
+		const args = process.argv.slice(process.argv.indexOf('dev') + 1);
-    runDevScript(args);
+		runDevScript(args);
-  });
+	});
 
 // Use a temporary Command instance to get all command definitions
 const tempProgram = new Command();
 registerCommands(tempProgram);
 
 // For each command in the temp instance, add a modified version to our actual program
-tempProgram.commands.forEach(cmd => {
+tempProgram.commands.forEach((cmd) => {
-  if (['init', 'dev'].includes(cmd.name())) {
+	if (['dev'].includes(cmd.name())) {
-    // Skip commands we've already defined specially
+		// Skip commands we've already defined specially
-    return;
+		return;
-  }
+	}
 
-  // Create a new command with the same name and description
+	// Create a new command with the same name and description
-  const newCmd = program
+	const newCmd = program.command(cmd.name()).description(cmd.description());
-    .command(cmd.name())
-    .description(cmd.description());
 
-  // Copy all options
+	// Copy all options
-  cmd.options.forEach(opt => {
+	cmd.options.forEach((opt) => {
-    newCmd.option(
+		newCmd.option(opt.flags, opt.description, opt.defaultValue);
-      opt.flags,
+	});
-      opt.description,
-      opt.defaultValue
-    );
-  });
 
-  // Set the action to proxy to dev.js
+	// Set the action to proxy to dev.js
-  newCmd.action(createDevScriptAction(cmd.name()));
+	newCmd.action(createDevScriptAction(cmd.name()));
 });
 
 // Parse the command line arguments
@@ -308,47 +325,56 @@ program.parse(process.argv);
 
 // Add global error handling for unknown commands and options
 process.on('uncaughtException', (err) => {
-  // Check if this is a commander.js unknown option error
+	// Check if this is a commander.js unknown option error
-  if (err.code === 'commander.unknownOption') {
+	if (err.code === 'commander.unknownOption') {
-    const option = err.message.match(/'([^']+)'/)?.[1];
+		const option = err.message.match(/'([^']+)'/)?.[1];
-    const commandArg = process.argv.find(arg => !arg.startsWith('-') && 
+		const commandArg = process.argv.find(
-                                            arg !== 'task-master' && 
+			(arg) =>
-                                            !arg.includes('/') && 
+				!arg.startsWith('-') &&
-                                            arg !== 'node');
+				arg !== 'task-master' &&
-    const command = commandArg || 'unknown';
+				!arg.includes('/') &&
+				arg !== 'node'
+		);
+		const command = commandArg || 'unknown';
 
-    console.error(chalk.red(`Error: Unknown option '${option}'`));
+		console.error(chalk.red(`Error: Unknown option '${option}'`));
-    console.error(chalk.yellow(`Run 'task-master ${command} --help' to see available options for this command`));
+		console.error(
-    process.exit(1);
+			chalk.yellow(
-  }
+				`Run 'task-master ${command} --help' to see available options for this command`
+			)
+		);
+		process.exit(1);
+	}
 
-  // Check if this is a commander.js unknown command error
+	// Check if this is a commander.js unknown command error
-  if (err.code === 'commander.unknownCommand') {
+	if (err.code === 'commander.unknownCommand') {
-    const command = err.message.match(/'([^']+)'/)?.[1];
+		const command = err.message.match(/'([^']+)'/)?.[1];
 
-    console.error(chalk.red(`Error: Unknown command '${command}'`));
+		console.error(chalk.red(`Error: Unknown command '${command}'`));
-    console.error(chalk.yellow(`Run 'task-master --help' to see available commands`));
+		console.error(
-    process.exit(1);
+			chalk.yellow(`Run 'task-master --help' to see available commands`)
-  }
+		);
+		process.exit(1);
+	}
 
-  // Handle other uncaught exceptions
+	// Handle other uncaught exceptions
-  console.error(chalk.red(`Error: ${err.message}`));
+	console.error(chalk.red(`Error: ${err.message}`));
-  if (process.env.DEBUG === '1') {
+	if (process.env.DEBUG === '1') {
-    console.error(err);
+		console.error(err);
-  }
+	}
-  process.exit(1);
+	process.exit(1);
 });
 
 // Show help if no command was provided (just 'task-master' with no args)
 if (process.argv.length <= 2) {
-  displayBanner();
+	displayBanner();
-  displayHelp();
+	displayHelp();
-  process.exit(0);
+	process.exit(0);
 }
 
 // Add exports at the end of the file
 if (typeof module !== 'undefined') {
-  module.exports = {
+	module.exports = {
-    detectCamelCaseFlags
+		detectCamelCaseFlags
-  };
+	};
 }

context/MCP_INTEGRATION.md

@@ -41,39 +41,39 @@ Core functions should follow this pattern to support both CLI and MCP use:
  * @returns {Object|undefined} - Returns data when source is 'mcp'
  */
 function exampleFunction(param1, param2, options = {}) {
-  try {
+	try {
-    // Skip UI for MCP
+		// Skip UI for MCP
-    if (options.source !== 'mcp') {
+		if (options.source !== 'mcp') {
-      displayBanner();
+			displayBanner();
-      console.log(chalk.blue('Processing operation...'));
+			console.log(chalk.blue('Processing operation...'));
-    }
+		}
 
-    // Do the core business logic
+		// Do the core business logic
-    const result = doSomething(param1, param2);
+		const result = doSomething(param1, param2);
 
-    // For MCP, return structured data
+		// For MCP, return structured data
-    if (options.source === 'mcp') {
+		if (options.source === 'mcp') {
-      return {
+			return {
-        success: true,
+				success: true,
-        data: result
+				data: result
-      };
+			};
-    }
+		}
 
-    // For CLI, display output
+		// For CLI, display output
-    console.log(chalk.green('Operation completed successfully!'));
+		console.log(chalk.green('Operation completed successfully!'));
-  } catch (error) {
+	} catch (error) {
-    // Handle errors based on source
+		// Handle errors based on source
-    if (options.source === 'mcp') {
+		if (options.source === 'mcp') {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: error.message
+				error: error.message
-      };
+			};
-    }
+		}
 
-    // CLI error handling
+		// CLI error handling
-    console.error(chalk.red(`Error: ${error.message}`));
+		console.error(chalk.red(`Error: ${error.message}`));
-    process.exit(1);
+		process.exit(1);
-  }
+	}
 }
 ```
 
@@ -89,17 +89,17 @@ export const simpleFunction = adaptForMcp(originalFunction);
 
 // Split implementation - completely different code paths for CLI vs MCP
 export const complexFunction = sourceSplitFunction(
-  // CLI version with UI
+	// CLI version with UI
-  function(param1, param2) {
+	function (param1, param2) {
-    displayBanner();
+		displayBanner();
-    console.log(`Processing ${param1}...`);
+		console.log(`Processing ${param1}...`);
-    // ... CLI implementation
+		// ... CLI implementation
-  },
+	},
-  // MCP version with structured return
+	// MCP version with structured return
-  function(param1, param2, options = {}) {
+	function (param1, param2, options = {}) {
-    // ... MCP implementation
+		// ... MCP implementation
-    return { success: true, data };
+		return { success: true, data };
-  }
+	}
 );
 ```
 
@@ -119,39 +119,39 @@ When adding new features, follow these steps to ensure CLI and MCP compatibility
 ```javascript
 // In scripts/modules/task-manager.js
 export async function newFeature(param1, param2, options = {}) {
-  try {
+	try {
-    // Source-specific UI
+		// Source-specific UI
-    if (options.source !== 'mcp') {
+		if (options.source !== 'mcp') {
-      displayBanner();
+			displayBanner();
-      console.log(chalk.blue('Running new feature...'));
+			console.log(chalk.blue('Running new feature...'));
-    }
+		}
 
-    // Shared core logic
+		// Shared core logic
-    const result = processFeature(param1, param2);
+		const result = processFeature(param1, param2);
 
-    // Source-specific return handling
+		// Source-specific return handling
-    if (options.source === 'mcp') {
+		if (options.source === 'mcp') {
-      return {
+			return {
-        success: true,
+				success: true,
-        data: result
+				data: result
-      };
+			};
-    }
+		}
 
-    // CLI output
+		// CLI output
-    console.log(chalk.green('Feature completed successfully!'));
+		console.log(chalk.green('Feature completed successfully!'));
-    displayOutput(result);
+		displayOutput(result);
-  } catch (error) {
+	} catch (error) {
-    // Error handling based on source
+		// Error handling based on source
-    if (options.source === 'mcp') {
+		if (options.source === 'mcp') {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: error.message
+				error: error.message
-      };
+			};
-    }
+		}
 
-    console.error(chalk.red(`Error: ${error.message}`));
+		console.error(chalk.red(`Error: ${error.message}`));
-    process.exit(1);
+		process.exit(1);
-  }
+	}
 }
 ```
 
@@ -163,12 +163,12 @@ import { newFeature } from '../../../scripts/modules/task-manager.js';
 
 // Add to exports
 export default {
-  // ... existing functions
+	// ... existing functions
 
-  async newFeature(args = {}, options = {}) {
+	async newFeature(args = {}, options = {}) {
-    const { param1, param2 } = args;
+		const { param1, param2 } = args;
-    return executeFunction(newFeature, [param1, param2], options);
+		return executeFunction(newFeature, [param1, param2], options);
-  }
+	}
 };
 ```
 
@@ -177,8 +177,8 @@ export default {
 ```javascript
 // In mcp-server/src/tools/utils.js
 const commandMap = {
-  // ... existing mappings
+	// ... existing mappings
-  'new-feature': 'newFeature'
+	'new-feature': 'newFeature'
 };
 ```
 
@@ -186,53 +186,53 @@ const commandMap = {
 
 ```javascript
 // In mcp-server/src/tools/newFeature.js
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  executeTaskMasterCommand,
+	executeTaskMasterCommand,
-  createContentResponse,
+	createContentResponse,
-  createErrorResponse,
+	createErrorResponse
-} from "./utils.js";
+} from './utils.js';
 
 export function registerNewFeatureTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "newFeature",
+		name: 'newFeature',
-    description: "Run the new feature",
+		description: 'Run the new feature',
-    parameters: z.object({
+		parameters: z.object({
-      param1: z.string().describe("First parameter"),
+			param1: z.string().describe('First parameter'),
-      param2: z.number().optional().describe("Second parameter"),
+			param2: z.number().optional().describe('Second parameter'),
-      file: z.string().optional().describe("Path to the tasks file"),
+			file: z.string().optional().describe('Path to the tasks file'),
-      projectRoot: z.string().describe("Root directory of the project")
+			projectRoot: z.string().describe('Root directory of the project')
-    }),
+		}),
-    execute: async (args, { log }) => {
+		execute: async (args, { log }) => {
-      try {
+			try {
-        log.info(`Running new feature with args: ${JSON.stringify(args)}`);
+				log.info(`Running new feature with args: ${JSON.stringify(args)}`);
 
-        const cmdArgs = [];
+				const cmdArgs = [];
-        if (args.param1) cmdArgs.push(`--param1=${args.param1}`);
+				if (args.param1) cmdArgs.push(`--param1=${args.param1}`);
-        if (args.param2) cmdArgs.push(`--param2=${args.param2}`);
+				if (args.param2) cmdArgs.push(`--param2=${args.param2}`);
-        if (args.file) cmdArgs.push(`--file=${args.file}`);
+				if (args.file) cmdArgs.push(`--file=${args.file}`);
 
-        const projectRoot = args.projectRoot;
+				const projectRoot = args.projectRoot;
 
-        // Execute the command
+				// Execute the command
-        const result = await executeTaskMasterCommand(
+				const result = await executeTaskMasterCommand(
-          "new-feature",
+					'new-feature',
-          log,
+					log,
-          cmdArgs,
+					cmdArgs,
-          projectRoot
+					projectRoot
-        );
+				);
 
-        if (!result.success) {
+				if (!result.success) {
-          throw new Error(result.error);
+					throw new Error(result.error);
-        }
+				}
 
-        return createContentResponse(result.stdout);
+				return createContentResponse(result.stdout);
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in new feature: ${error.message}`);
+				log.error(`Error in new feature: ${error.message}`);
-        return createErrorResponse(`Error in new feature: ${error.message}`);
+				return createErrorResponse(`Error in new feature: ${error.message}`);
-      }
+			}
-    },
+		}
-  });
+	});
 }
 ```
 
@@ -240,11 +240,11 @@ export function registerNewFeatureTool(server) {
 
 ```javascript
 // In mcp-server/src/tools/index.js
-import { registerNewFeatureTool } from "./newFeature.js";
+import { registerNewFeatureTool } from './newFeature.js';
 
 export function registerTaskMasterTools(server) {
-  // ... existing registrations
+	// ... existing registrations
-  registerNewFeatureTool(server);
+	registerNewFeatureTool(server);
 }
 ```
 

docs/ai-client-utils-example.md

@@ -7,56 +7,54 @@ This document provides examples of how to use the new AI client utilities with A
 ```javascript
 // In your direct function implementation:
 import {
-  getAnthropicClientForMCP, 
+	getAnthropicClientForMCP,
-  getModelConfig, 
+	getModelConfig,
-  handleClaudeError 
+	handleClaudeError
 } from '../utils/ai-client-utils.js';
 
 export async function someAiOperationDirect(args, log, context) {
-  try {
+	try {
-    // Initialize Anthropic client with session from context
+		// Initialize Anthropic client with session from context
-    const client = getAnthropicClientForMCP(context.session, log);
+		const client = getAnthropicClientForMCP(context.session, log);
 
-    // Get model configuration with defaults or session overrides
+		// Get model configuration with defaults or session overrides
-    const modelConfig = getModelConfig(context.session);
+		const modelConfig = getModelConfig(context.session);
 
-    // Make API call with proper error handling
+		// Make API call with proper error handling
-    try {
+		try {
-      const response = await client.messages.create({
+			const response = await client.messages.create({
-        model: modelConfig.model,
+				model: modelConfig.model,
-        max_tokens: modelConfig.maxTokens,
+				max_tokens: modelConfig.maxTokens,
-        temperature: modelConfig.temperature,
+				temperature: modelConfig.temperature,
-        messages: [
+				messages: [{ role: 'user', content: 'Your prompt here' }]
-          { role: 'user', content: 'Your prompt here' }
+			});
-        ]
-      });
 
-      return {
+			return {
-        success: true,
+				success: true,
-        data: response
+				data: response
-      };
+			};
-    } catch (apiError) {
+		} catch (apiError) {
-      // Use helper to get user-friendly error message
+			// Use helper to get user-friendly error message
-      const friendlyMessage = handleClaudeError(apiError);
+			const friendlyMessage = handleClaudeError(apiError);
 
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'AI_API_ERROR',
+					code: 'AI_API_ERROR',
-          message: friendlyMessage
+					message: friendlyMessage
-        }
+				}
-      };
+			};
-    }
+		}
-  } catch (error) {
+	} catch (error) {
-    // Handle client initialization errors
+		// Handle client initialization errors
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'AI_CLIENT_ERROR',
+				code: 'AI_CLIENT_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }
 ```
 
@@ -64,86 +62,85 @@ export async function someAiOperationDirect(args, log, context) {
 
 ```javascript
 // In your MCP tool implementation:
-import { AsyncOperationManager, StatusCodes } from '../../utils/async-operation-manager.js';
+import {
+	AsyncOperationManager,
+	StatusCodes
+} from '../../utils/async-operation-manager.js';
 import { someAiOperationDirect } from '../../core/direct-functions/some-ai-operation.js';
 
 export async function someAiOperation(args, context) {
-  const { session, mcpLog } = context;
+	const { session, mcpLog } = context;
-  const log = mcpLog || console;
+	const log = mcpLog || console;
 
-  try {
+	try {
-    // Create operation description
+		// Create operation description
-    const operationDescription = `AI operation: ${args.someParam}`;
+		const operationDescription = `AI operation: ${args.someParam}`;
 
-    // Start async operation
+		// Start async operation
-    const operation = AsyncOperationManager.createOperation(
+		const operation = AsyncOperationManager.createOperation(
-      operationDescription,
+			operationDescription,
-      async (reportProgress) => {
+			async (reportProgress) => {
-        try {
+				try {
-          // Initial progress report
+					// Initial progress report
-          reportProgress({
+					reportProgress({
-            progress: 0,
+						progress: 0,
-            status: 'Starting AI operation...'
+						status: 'Starting AI operation...'
-          });
+					});
 
-          // Call direct function with session and progress reporting
+					// Call direct function with session and progress reporting
-          const result = await someAiOperationDirect(
+					const result = await someAiOperationDirect(args, log, {
-            args, 
+						reportProgress,
-            log, 
+						mcpLog: log,
-            {
+						session
-              reportProgress,
+					});
-              mcpLog: log,
-              session
-            }
-          );
 
-          // Final progress update
+					// Final progress update
-          reportProgress({
+					reportProgress({
-            progress: 100,
+						progress: 100,
-            status: result.success ? 'Operation completed' : 'Operation failed',
+						status: result.success ? 'Operation completed' : 'Operation failed',
-            result: result.data,
+						result: result.data,
-            error: result.error
+						error: result.error
-          });
+					});
 
-          return result;
+					return result;
-        } catch (error) {
+				} catch (error) {
-          // Handle errors in the operation
+					// Handle errors in the operation
-          reportProgress({
+					reportProgress({
-            progress: 100,
+						progress: 100,
-            status: 'Operation failed',
+						status: 'Operation failed',
-            error: {
+						error: {
-              message: error.message,
+							message: error.message,
-              code: error.code || 'OPERATION_FAILED'
+							code: error.code || 'OPERATION_FAILED'
-            }
+						}
-          });
+					});
-          throw error;
+					throw error;
-        }
+				}
-      }
+			}
-    );
+		);
 
-    // Return immediate response with operation ID
+		// Return immediate response with operation ID
-    return {
+		return {
-      status: StatusCodes.ACCEPTED,
+			status: StatusCodes.ACCEPTED,
-      body: {
+			body: {
-        success: true,
+				success: true,
-        message: 'Operation started',
+				message: 'Operation started',
-        operationId: operation.id
+				operationId: operation.id
-      }
+			}
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    // Handle errors in the MCP tool
+		// Handle errors in the MCP tool
-    log.error(`Error in someAiOperation: ${error.message}`);
+		log.error(`Error in someAiOperation: ${error.message}`);
-    return {
+		return {
-      status: StatusCodes.INTERNAL_SERVER_ERROR,
+			status: StatusCodes.INTERNAL_SERVER_ERROR,
-      body: {
+			body: {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'OPERATION_FAILED',
+					code: 'OPERATION_FAILED',
-          message: error.message
+					message: error.message
-        }
+				}
-      }
+			}
-    };
+		};
-  }
+	}
 }
 ```
 
@@ -152,57 +149,55 @@ export async function someAiOperation(args, context) {
 ```javascript
 // In your direct function:
 import {
-  getPerplexityClientForMCP, 
+	getPerplexityClientForMCP,
-  getBestAvailableAIModel 
+	getBestAvailableAIModel
 } from '../utils/ai-client-utils.js';
 
 export async function researchOperationDirect(args, log, context) {
-  try {
+	try {
-    // Get the best AI model for this operation based on needs
+		// Get the best AI model for this operation based on needs
-    const { type, client } = await getBestAvailableAIModel(
+		const { type, client } = await getBestAvailableAIModel(
-      context.session, 
+			context.session,
-      { requiresResearch: true },
+			{ requiresResearch: true },
-      log
+			log
-    );
+		);
 
-    // Report which model we're using
+		// Report which model we're using
-    if (context.reportProgress) {
+		if (context.reportProgress) {
-      await context.reportProgress({
+			await context.reportProgress({
-        progress: 10,
+				progress: 10,
-        status: `Using ${type} model for research...`
+				status: `Using ${type} model for research...`
-      });
+			});
-    }
+		}
 
-    // Make API call based on the model type
+		// Make API call based on the model type
-    if (type === 'perplexity') {
+		if (type === 'perplexity') {
-      // Call Perplexity
+			// Call Perplexity
-      const response = await client.chat.completions.create({
+			const response = await client.chat.completions.create({
-        model: context.session?.env?.PERPLEXITY_MODEL || 'sonar-medium-online',
+				model: context.session?.env?.PERPLEXITY_MODEL || 'sonar-medium-online',
-        messages: [
+				messages: [{ role: 'user', content: args.researchQuery }],
-          { role: 'user', content: args.researchQuery }
+				temperature: 0.1
-        ],
+			});
-        temperature: 0.1
-      });
 
-      return {
+			return {
-        success: true,
+				success: true,
-        data: response.choices[0].message.content
+				data: response.choices[0].message.content
-      };
+			};
-    } else {
+		} else {
-      // Call Claude as fallback
+			// Call Claude as fallback
-      // (Implementation depends on specific needs)
+			// (Implementation depends on specific needs)
-      // ...
+			// ...
-    }
+		}
-  } catch (error) {
+	} catch (error) {
-    // Handle errors
+		// Handle errors
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'RESEARCH_ERROR',
+				code: 'RESEARCH_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }
 ```
 
@@ -214,9 +209,9 @@ import { getModelConfig } from '../utils/ai-client-utils.js';
 
 // Using custom defaults for a specific operation
 const operationDefaults = {
-  model: 'claude-3-haiku-20240307',  // Faster, smaller model
+	model: 'claude-3-haiku-20240307', // Faster, smaller model
-  maxTokens: 1000,                  // Lower token limit
+	maxTokens: 1000, // Lower token limit
-  temperature: 0.2                  // Lower temperature for more deterministic output
+	temperature: 0.2 // Lower temperature for more deterministic output
 };
 
 // Get model config with operation-specific defaults
@@ -224,30 +219,34 @@ const modelConfig = getModelConfig(context.session, operationDefaults);
 
 // Now use modelConfig in your API calls
 const response = await client.messages.create({
-  model: modelConfig.model,
+	model: modelConfig.model,
-  max_tokens: modelConfig.maxTokens,
+	max_tokens: modelConfig.maxTokens,
-  temperature: modelConfig.temperature,
+	temperature: modelConfig.temperature
-  // Other parameters...
+	// Other parameters...
 });
 ```
 
 ## Best Practices
 
 1. **Error Handling**:
+
    - Always use try/catch blocks around both client initialization and API calls
    - Use `handleClaudeError` to provide user-friendly error messages
    - Return standardized error objects with code and message
 
 2. **Progress Reporting**:
+
    - Report progress at key points (starting, processing, completing)
    - Include meaningful status messages
    - Include error details in progress reports when failures occur
 
 3. **Session Handling**:
+
    - Always pass the session from the context to the AI client getters
    - Use `getModelConfig` to respect user settings from session
 
 4. **Model Selection**:
+
    - Use `getBestAvailableAIModel` when you need to select between different models
    - Set `requiresResearch: true` when you need Perplexity capabilities
 

docs/tutorial.md

@@ -14,22 +14,22 @@ MCP (Model Control Protocol) provides the easiest way to get started with Task M
 
 ```json
 {
-  "mcpServers": {
+	"mcpServers": {
-    "taskmaster-ai": {
+		"taskmaster-ai": {
-      "command": "npx",
+			"command": "npx",
-      "args": ["-y", "task-master-ai", "mcp-server"],
+			"args": ["-y", "--package", "task-master-ai", "task-master-mcp"],
-      "env": {
+			"env": {
-        "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
+				"ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
-        "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
+				"PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
-        "MODEL": "claude-3-7-sonnet-20250219",
+				"MODEL": "claude-3-7-sonnet-20250219",
-        "PERPLEXITY_MODEL": "sonar-pro",
+				"PERPLEXITY_MODEL": "sonar-pro",
-        "MAX_TOKENS": 128000,
+				"MAX_TOKENS": 128000,
-        "TEMPERATURE": 0.2,
+				"TEMPERATURE": 0.2,
-        "DEFAULT_SUBTASKS": 5,
+				"DEFAULT_SUBTASKS": 5,
-        "DEFAULT_PRIORITY": "medium"
+				"DEFAULT_PRIORITY": "medium"
-      }
+			}
-    }
+		}
-  }
+	}
 }
 ```
 

entries.json

@@ -1,41 +0,0 @@
-import os
-import json
-
-# Path to Cursor's history folder
-history_path = os.path.expanduser('~/Library/Application Support/Cursor/User/History')
-
-# File to search for
-target_file = 'tasks/tasks.json'
-
-# Function to search through all entries.json files
-def search_entries_for_file(history_path, target_file):
-    matching_folders = []
-    for folder in os.listdir(history_path):
-        folder_path = os.path.join(history_path, folder)
-        if not os.path.isdir(folder_path):
-            continue
-
-        # Look for entries.json
-        entries_file = os.path.join(folder_path, 'entries.json')
-        if not os.path.exists(entries_file):
-            continue
-
-        # Parse entries.json to find the resource key
-        with open(entries_file, 'r') as f:
-            data = json.load(f)
-            resource = data.get('resource', None)
-            if resource and target_file in resource:
-                matching_folders.append(folder_path)
-
-    return matching_folders
-
-# Search for the target file
-matching_folders = search_entries_for_file(history_path, target_file)
-
-# Output the matching folders
-if matching_folders:
-    print(f"Found {target_file} in the following folders:")
-    for folder in matching_folders:
-        print(folder)
-else:
-    print(f"No matches found for {target_file}.")

index.js

@@ -41,27 +41,27 @@ export const devScriptPath = resolve(__dirname, './scripts/dev.js');
 
 // Export a function to initialize a new project programmatically
 export const initProject = async (options = {}) => {
-  const init = await import('./scripts/init.js');
+	const init = await import('./scripts/init.js');
-  return init.initializeProject(options);
+	return init.initializeProject(options);
 };
 
 // Export a function to run init as a CLI command
 export const runInitCLI = async () => {
-  // Using spawn to ensure proper handling of stdio and process exit
+	// Using spawn to ensure proper handling of stdio and process exit
-  const child = spawn('node', [resolve(__dirname, './scripts/init.js')], {
+	const child = spawn('node', [resolve(__dirname, './scripts/init.js')], {
-    stdio: 'inherit',
+		stdio: 'inherit',
-    cwd: process.cwd()
+		cwd: process.cwd()
-  });
+	});
 
-  return new Promise((resolve, reject) => {
+	return new Promise((resolve, reject) => {
-    child.on('close', (code) => {
+		child.on('close', (code) => {
-      if (code === 0) {
+			if (code === 0) {
-        resolve();
+				resolve();
-      } else {
+			} else {
-        reject(new Error(`Init script exited with code ${code}`));
+				reject(new Error(`Init script exited with code ${code}`));
-      }
+			}
-    });
+		});
-  });
+	});
 };
 
 // Export version information
@@ -69,81 +69,81 @@ export const version = packageJson.version;
 
 // CLI implementation
 if (import.meta.url === `file://${process.argv[1]}`) {
-  const program = new Command();
+	const program = new Command();
 
-  program
+	program
-    .name('task-master')
+		.name('task-master')
-    .description('Claude Task Master CLI')
+		.description('Claude Task Master CLI')
-    .version(version);
+		.version(version);
 
-  program
+	program
-    .command('init')
+		.command('init')
-    .description('Initialize a new project')
+		.description('Initialize a new project')
-    .action(() => {
+		.action(() => {
-      runInitCLI().catch(err => {
+			runInitCLI().catch((err) => {
-        console.error('Init failed:', err.message);
+				console.error('Init failed:', err.message);
-        process.exit(1);
+				process.exit(1);
-      });
+			});
-    });
+		});
 
-  program
+	program
-    .command('dev')
+		.command('dev')
-    .description('Run the dev.js script')
+		.description('Run the dev.js script')
-    .allowUnknownOption(true)
+		.allowUnknownOption(true)
-    .action(() => {
+		.action(() => {
-      const args = process.argv.slice(process.argv.indexOf('dev') + 1);
+			const args = process.argv.slice(process.argv.indexOf('dev') + 1);
-      const child = spawn('node', [devScriptPath, ...args], {
+			const child = spawn('node', [devScriptPath, ...args], {
-        stdio: 'inherit',
+				stdio: 'inherit',
-        cwd: process.cwd()
+				cwd: process.cwd()
-      });
+			});
 
-      child.on('close', (code) => {
+			child.on('close', (code) => {
-        process.exit(code);
+				process.exit(code);
-      });
+			});
-    });
+		});
 
-  // Add shortcuts for common dev.js commands
+	// Add shortcuts for common dev.js commands
-  program
+	program
-    .command('list')
+		.command('list')
-    .description('List all tasks')
+		.description('List all tasks')
-    .action(() => {
+		.action(() => {
-      const child = spawn('node', [devScriptPath, 'list'], {
+			const child = spawn('node', [devScriptPath, 'list'], {
-        stdio: 'inherit',
+				stdio: 'inherit',
-        cwd: process.cwd()
+				cwd: process.cwd()
-      });
+			});
 
-      child.on('close', (code) => {
+			child.on('close', (code) => {
-        process.exit(code);
+				process.exit(code);
-      });
+			});
-    });
+		});
 
-  program
+	program
-    .command('next')
+		.command('next')
-    .description('Show the next task to work on')
+		.description('Show the next task to work on')
-    .action(() => {
+		.action(() => {
-      const child = spawn('node', [devScriptPath, 'next'], {
+			const child = spawn('node', [devScriptPath, 'next'], {
-        stdio: 'inherit',
+				stdio: 'inherit',
-        cwd: process.cwd()
+				cwd: process.cwd()
-      });
+			});
 
-      child.on('close', (code) => {
+			child.on('close', (code) => {
-        process.exit(code);
+				process.exit(code);
-      });
+			});
-    });
+		});
 
-  program
+	program
-    .command('generate')
+		.command('generate')
-    .description('Generate task files')
+		.description('Generate task files')
-    .action(() => {
+		.action(() => {
-      const child = spawn('node', [devScriptPath, 'generate'], {
+			const child = spawn('node', [devScriptPath, 'generate'], {
-        stdio: 'inherit',
+				stdio: 'inherit',
-        cwd: process.cwd()
+				cwd: process.cwd()
-      });
+			});
 
-      child.on('close', (code) => {
+			child.on('close', (code) => {
-        process.exit(code);
+				process.exit(code);
-      });
+			});
-    });
+		});
 
-  program.parse(process.argv);
+	program.parse(process.argv);
 }

jest.config.js

@@ -1,56 +1,56 @@
 export default {
-  // Use Node.js environment for testing
+	// Use Node.js environment for testing
-  testEnvironment: 'node',
+	testEnvironment: 'node',
 
-  // Automatically clear mock calls between every test
+	// Automatically clear mock calls between every test
-  clearMocks: true,
+	clearMocks: true,
 
-  // Indicates whether the coverage information should be collected while executing the test
+	// Indicates whether the coverage information should be collected while executing the test
-  collectCoverage: false,
+	collectCoverage: false,
 
-  // The directory where Jest should output its coverage files
+	// The directory where Jest should output its coverage files
-  coverageDirectory: 'coverage',
+	coverageDirectory: 'coverage',
 
-  // A list of paths to directories that Jest should use to search for files in
+	// A list of paths to directories that Jest should use to search for files in
-  roots: ['<rootDir>/tests'],
+	roots: ['<rootDir>/tests'],
 
-  // The glob patterns Jest uses to detect test files
+	// The glob patterns Jest uses to detect test files
-  testMatch: [
+	testMatch: [
-    '**/__tests__/**/*.js',
+		'**/__tests__/**/*.js',
-    '**/?(*.)+(spec|test).js',
+		'**/?(*.)+(spec|test).js',
-    '**/tests/*.test.js'
+		'**/tests/*.test.js'
-  ],
+	],
 
-  // Transform files
+	// Transform files
-  transform: {},
+	transform: {},
 
-  // Disable transformations for node_modules
+	// Disable transformations for node_modules
-  transformIgnorePatterns: ['/node_modules/'],
+	transformIgnorePatterns: ['/node_modules/'],
 
-  // Set moduleNameMapper for absolute paths
+	// Set moduleNameMapper for absolute paths
-  moduleNameMapper: {
+	moduleNameMapper: {
-    '^@/(.*)$': '<rootDir>/$1'
+		'^@/(.*)$': '<rootDir>/$1'
-  },
+	},
 
-  // Setup module aliases
+	// Setup module aliases
-  moduleDirectories: ['node_modules', '<rootDir>'],
+	moduleDirectories: ['node_modules', '<rootDir>'],
 
-  // Configure test coverage thresholds
+	// Configure test coverage thresholds
-  coverageThreshold: {
+	coverageThreshold: {
-    global: {
+		global: {
-      branches: 80,
+			branches: 80,
-      functions: 80,
+			functions: 80,
-      lines: 80,
+			lines: 80,
-      statements: 80
+			statements: 80
-    }
+		}
-  },
+	},
 
-  // Generate coverage report in these formats
+	// Generate coverage report in these formats
-  coverageReporters: ['text', 'lcov'],
+	coverageReporters: ['text', 'lcov'],
 
-  // Verbose output
+	// Verbose output
-  verbose: true,
+	verbose: true,
 
-  // Setup file
+	// Setup file
-  setupFilesAfterEnv: ['<rootDir>/tests/setup.js']
+	setupFilesAfterEnv: ['<rootDir>/tests/setup.js']
 };

mcp-server/server.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
-import TaskMasterMCPServer from "./src/index.js";
+import TaskMasterMCPServer from './src/index.js';
-import dotenv from "dotenv";
+import dotenv from 'dotenv';
-import logger from "./src/logger.js";
+import logger from './src/logger.js';
 
 // Load environment variables
 dotenv.config();
@@ -11,25 +11,25 @@ dotenv.config();
  * Start the MCP server
  */
 async function startServer() {
-  const server = new TaskMasterMCPServer();
+	const server = new TaskMasterMCPServer();
 
-  // Handle graceful shutdown
+	// Handle graceful shutdown
-  process.on("SIGINT", async () => {
+	process.on('SIGINT', async () => {
-    await server.stop();
+		await server.stop();
-    process.exit(0);
+		process.exit(0);
-  });
+	});
 
-  process.on("SIGTERM", async () => {
+	process.on('SIGTERM', async () => {
-    await server.stop();
+		await server.stop();
-    process.exit(0);
+		process.exit(0);
-  });
+	});
 
-  try {
+	try {
-    await server.start();
+		await server.start();
-  } catch (error) {
+	} catch (error) {
-    logger.error(`Failed to start MCP server: ${error.message}`);
+		logger.error(`Failed to start MCP server: ${error.message}`);
-    process.exit(1);
+		process.exit(1);
-  }
+	}
 }
 
 // Start the server

mcp-server/src/core/__tests__/context-manager.test.js

@@ -2,84 +2,90 @@ import { jest } from '@jest/globals';
 import { ContextManager } from '../context-manager.js';
 
 describe('ContextManager', () => {
-  let contextManager;
+	let contextManager;
 
-  beforeEach(() => {
+	beforeEach(() => {
-    contextManager = new ContextManager({
+		contextManager = new ContextManager({
-      maxCacheSize: 10,
+			maxCacheSize: 10,
-      ttl: 1000, // 1 second for testing
+			ttl: 1000, // 1 second for testing
-      maxContextSize: 1000
+			maxContextSize: 1000
-    });
+		});
-  });
+	});
 
-  describe('getContext', () => {
+	describe('getContext', () => {
-    it('should create a new context when not in cache', async () => {
+		it('should create a new context when not in cache', async () => {
-      const context = await contextManager.getContext('test-id', { test: true });
+			const context = await contextManager.getContext('test-id', {
-      expect(context.id).toBe('test-id');
+				test: true
-      expect(context.metadata.test).toBe(true);
+			});
-      expect(contextManager.stats.misses).toBe(1);
+			expect(context.id).toBe('test-id');
-      expect(contextManager.stats.hits).toBe(0);
+			expect(context.metadata.test).toBe(true);
-    });
+			expect(contextManager.stats.misses).toBe(1);
+			expect(contextManager.stats.hits).toBe(0);
+		});
 
-    it('should return cached context when available', async () => {
+		it('should return cached context when available', async () => {
-      // First call creates the context
+			// First call creates the context
-      await contextManager.getContext('test-id', { test: true });
+			await contextManager.getContext('test-id', { test: true });
 
-      // Second call should hit cache
+			// Second call should hit cache
-      const context = await contextManager.getContext('test-id', { test: true });
+			const context = await contextManager.getContext('test-id', {
-      expect(context.id).toBe('test-id');
+				test: true
-      expect(context.metadata.test).toBe(true);
+			});
-      expect(contextManager.stats.hits).toBe(1);
+			expect(context.id).toBe('test-id');
-      expect(contextManager.stats.misses).toBe(1);
+			expect(context.metadata.test).toBe(true);
-    });
+			expect(contextManager.stats.hits).toBe(1);
+			expect(contextManager.stats.misses).toBe(1);
+		});
 
-    it('should respect TTL settings', async () => {
+		it('should respect TTL settings', async () => {
-      // Create context
+			// Create context
-      await contextManager.getContext('test-id', { test: true });
+			await contextManager.getContext('test-id', { test: true });
 
-      // Wait for TTL to expire
+			// Wait for TTL to expire
-      await new Promise(resolve => setTimeout(resolve, 1100));
+			await new Promise((resolve) => setTimeout(resolve, 1100));
 
-      // Should create new context
+			// Should create new context
-      await contextManager.getContext('test-id', { test: true });
+			await contextManager.getContext('test-id', { test: true });
-      expect(contextManager.stats.misses).toBe(2);
+			expect(contextManager.stats.misses).toBe(2);
-      expect(contextManager.stats.hits).toBe(0);
+			expect(contextManager.stats.hits).toBe(0);
-    });
+		});
-  });
+	});
 
-  describe('updateContext', () => {
+	describe('updateContext', () => {
-    it('should update existing context metadata', async () => {
+		it('should update existing context metadata', async () => {
-      await contextManager.getContext('test-id', { initial: true });
+			await contextManager.getContext('test-id', { initial: true });
-      const updated = await contextManager.updateContext('test-id', { updated: true });
+			const updated = await contextManager.updateContext('test-id', {
+				updated: true
+			});
 
-      expect(updated.metadata.initial).toBe(true);
+			expect(updated.metadata.initial).toBe(true);
-      expect(updated.metadata.updated).toBe(true);
+			expect(updated.metadata.updated).toBe(true);
-    });
+		});
-  });
+	});
 
-  describe('invalidateContext', () => {
+	describe('invalidateContext', () => {
-    it('should remove context from cache', async () => {
+		it('should remove context from cache', async () => {
-      await contextManager.getContext('test-id', { test: true });
+			await contextManager.getContext('test-id', { test: true });
-      contextManager.invalidateContext('test-id', { test: true });
+			contextManager.invalidateContext('test-id', { test: true });
 
-      // Should be a cache miss
+			// Should be a cache miss
-      await contextManager.getContext('test-id', { test: true });
+			await contextManager.getContext('test-id', { test: true });
-      expect(contextManager.stats.invalidations).toBe(1);
+			expect(contextManager.stats.invalidations).toBe(1);
-      expect(contextManager.stats.misses).toBe(2);
+			expect(contextManager.stats.misses).toBe(2);
-    });
+		});
-  });
+	});
 
-  describe('getStats', () => {
+	describe('getStats', () => {
-    it('should return current cache statistics', async () => {
+		it('should return current cache statistics', async () => {
-      await contextManager.getContext('test-id', { test: true });
+			await contextManager.getContext('test-id', { test: true });
-      const stats = contextManager.getStats();
+			const stats = contextManager.getStats();
 
-      expect(stats.hits).toBe(0);
+			expect(stats.hits).toBe(0);
-      expect(stats.misses).toBe(1);
+			expect(stats.misses).toBe(1);
-      expect(stats.invalidations).toBe(0);
+			expect(stats.invalidations).toBe(0);
-      expect(stats.size).toBe(1);
+			expect(stats.size).toBe(1);
-      expect(stats.maxSize).toBe(10);
+			expect(stats.maxSize).toBe(10);
-      expect(stats.ttl).toBe(1000);
+			expect(stats.ttl).toBe(1000);
-    });
+		});
-  });
+	});
 });

mcp-server/src/core/context-manager.js

@@ -15,155 +15,156 @@ import { LRUCache } from 'lru-cache';
  */
 
 export class ContextManager {
-  /**
+	/**
-   * Create a new ContextManager instance
+	 * Create a new ContextManager instance
-   * @param {ContextManagerConfig} config - Configuration options
+	 * @param {ContextManagerConfig} config - Configuration options
-   */
+	 */
-  constructor(config = {}) {
+	constructor(config = {}) {
-    this.config = {
+		this.config = {
-      maxCacheSize: config.maxCacheSize || 1000,
+			maxCacheSize: config.maxCacheSize || 1000,
-      ttl: config.ttl || 1000 * 60 * 5, // 5 minutes default
+			ttl: config.ttl || 1000 * 60 * 5, // 5 minutes default
-      maxContextSize: config.maxContextSize || 4000
+			maxContextSize: config.maxContextSize || 4000
-    };
+		};
 
-    // Initialize LRU cache for context data
+		// Initialize LRU cache for context data
-    this.cache = new LRUCache({
+		this.cache = new LRUCache({
-      max: this.config.maxCacheSize,
+			max: this.config.maxCacheSize,
-      ttl: this.config.ttl,
+			ttl: this.config.ttl,
-      updateAgeOnGet: true
+			updateAgeOnGet: true
-    });
+		});
 
-    // Cache statistics
+		// Cache statistics
-    this.stats = {
+		this.stats = {
-      hits: 0,
+			hits: 0,
-      misses: 0,
+			misses: 0,
-      invalidations: 0
+			invalidations: 0
-    };
+		};
-  }
+	}
 
-  /**
+	/**
-   * Create a new context or retrieve from cache
+	 * Create a new context or retrieve from cache
-   * @param {string} contextId - Unique identifier for the context
+	 * @param {string} contextId - Unique identifier for the context
-   * @param {Object} metadata - Additional metadata for the context
+	 * @param {Object} metadata - Additional metadata for the context
-   * @returns {Object} Context object with metadata
+	 * @returns {Object} Context object with metadata
-   */
+	 */
-  async getContext(contextId, metadata = {}) {
+	async getContext(contextId, metadata = {}) {
-    const cacheKey = this._getCacheKey(contextId, metadata);
+		const cacheKey = this._getCacheKey(contextId, metadata);
 
-    // Try to get from cache first
+		// Try to get from cache first
-    const cached = this.cache.get(cacheKey);
+		const cached = this.cache.get(cacheKey);
-    if (cached) {
+		if (cached) {
-      this.stats.hits++;
+			this.stats.hits++;
-      return cached;
+			return cached;
-    }
+		}
 
-    this.stats.misses++;
+		this.stats.misses++;
 
-    // Create new context if not in cache
+		// Create new context if not in cache
-    const context = {
+		const context = {
-      id: contextId,
+			id: contextId,
-      metadata: {
+			metadata: {
-        ...metadata,
+				...metadata,
-        created: new Date().toISOString()
+				created: new Date().toISOString()
-      }
+			}
-    };
+		};
 
-    // Cache the new context
+		// Cache the new context
-    this.cache.set(cacheKey, context);
+		this.cache.set(cacheKey, context);
 
-    return context;
+		return context;
-  }
+	}
 
-  /**
+	/**
-   * Update an existing context
+	 * Update an existing context
-   * @param {string} contextId - Context identifier
+	 * @param {string} contextId - Context identifier
-   * @param {Object} updates - Updates to apply to the context
+	 * @param {Object} updates - Updates to apply to the context
-   * @returns {Object} Updated context
+	 * @returns {Object} Updated context
-   */
+	 */
-  async updateContext(contextId, updates) {
+	async updateContext(contextId, updates) {
-    const context = await this.getContext(contextId);
+		const context = await this.getContext(contextId);
 
-    // Apply updates to context
+		// Apply updates to context
-    Object.assign(context.metadata, updates);
+		Object.assign(context.metadata, updates);
 
-    // Update cache
+		// Update cache
-    const cacheKey = this._getCacheKey(contextId, context.metadata);
+		const cacheKey = this._getCacheKey(contextId, context.metadata);
-    this.cache.set(cacheKey, context);
+		this.cache.set(cacheKey, context);
 
-    return context;
+		return context;
-  }
+	}
 
-  /**
+	/**
-   * Invalidate a context in the cache
+	 * Invalidate a context in the cache
-   * @param {string} contextId - Context identifier
+	 * @param {string} contextId - Context identifier
-   * @param {Object} metadata - Metadata used in the cache key
+	 * @param {Object} metadata - Metadata used in the cache key
-   */
+	 */
-  invalidateContext(contextId, metadata = {}) {
+	invalidateContext(contextId, metadata = {}) {
-    const cacheKey = this._getCacheKey(contextId, metadata);
+		const cacheKey = this._getCacheKey(contextId, metadata);
-    this.cache.delete(cacheKey);
+		this.cache.delete(cacheKey);
-    this.stats.invalidations++;
+		this.stats.invalidations++;
-  }
+	}
 
-  /**
+	/**
-   * Get cached data associated with a specific key.
+	 * Get cached data associated with a specific key.
-   * Increments cache hit stats if found.
+	 * Increments cache hit stats if found.
-   * @param {string} key - The cache key.
+	 * @param {string} key - The cache key.
-   * @returns {any | undefined} The cached data or undefined if not found/expired.
+	 * @returns {any | undefined} The cached data or undefined if not found/expired.
-   */
+	 */
-  getCachedData(key) {
+	getCachedData(key) {
-    const cached = this.cache.get(key);
+		const cached = this.cache.get(key);
-    if (cached !== undefined) { // Check for undefined specifically, as null/false might be valid cached values
+		if (cached !== undefined) {
-      this.stats.hits++;
+			// Check for undefined specifically, as null/false might be valid cached values
-      return cached;
+			this.stats.hits++;
-    }
+			return cached;
-    this.stats.misses++;
+		}
-    return undefined;
+		this.stats.misses++;
-  }
+		return undefined;
+	}
 
-  /**
+	/**
-   * Set data in the cache with a specific key.
+	 * Set data in the cache with a specific key.
-   * @param {string} key - The cache key.
+	 * @param {string} key - The cache key.
-   * @param {any} data - The data to cache.
+	 * @param {any} data - The data to cache.
-   */
+	 */
-  setCachedData(key, data) {
+	setCachedData(key, data) {
-    this.cache.set(key, data);
+		this.cache.set(key, data);
-  }
+	}
 
-  /**
+	/**
-   * Invalidate a specific cache key.
+	 * Invalidate a specific cache key.
-   * Increments invalidation stats.
+	 * Increments invalidation stats.
-   * @param {string} key - The cache key to invalidate.
+	 * @param {string} key - The cache key to invalidate.
-   */
+	 */
-  invalidateCacheKey(key) {
+	invalidateCacheKey(key) {
-    this.cache.delete(key);
+		this.cache.delete(key);
-    this.stats.invalidations++;
+		this.stats.invalidations++;
-  }
+	}
 
-  /**
+	/**
-   * Get cache statistics
+	 * Get cache statistics
-   * @returns {Object} Cache statistics
+	 * @returns {Object} Cache statistics
-   */
+	 */
-  getStats() {
+	getStats() {
-    return {
+		return {
-      hits: this.stats.hits,
+			hits: this.stats.hits,
-      misses: this.stats.misses,
+			misses: this.stats.misses,
-      invalidations: this.stats.invalidations,
+			invalidations: this.stats.invalidations,
-      size: this.cache.size,
+			size: this.cache.size,
-      maxSize: this.config.maxCacheSize,
+			maxSize: this.config.maxCacheSize,
-      ttl: this.config.ttl
+			ttl: this.config.ttl
-    };
+		};
-  }
+	}
 
-  /**
+	/**
-   * Generate a cache key from context ID and metadata
+	 * Generate a cache key from context ID and metadata
-   * @private
+	 * @private
-   * @deprecated No longer used for direct cache key generation outside the manager.
+	 * @deprecated No longer used for direct cache key generation outside the manager.
-   *             Prefer generating specific keys in calling functions.
+	 *             Prefer generating specific keys in calling functions.
-   */
+	 */
-  _getCacheKey(contextId, metadata) {
+	_getCacheKey(contextId, metadata) {
-    // Kept for potential backward compatibility or internal use if needed later.
+		// Kept for potential backward compatibility or internal use if needed later.
-    return `${contextId}:${JSON.stringify(metadata)}`;
+		return `${contextId}:${JSON.stringify(metadata)}`;
-  }
+	}
 }
 
 // Export a singleton instance with default config

mcp-server/src/core/direct-functions/add-dependency.js

@@ -5,7 +5,10 @@
 
 import { addDependency } from '../../../../scripts/modules/dependency-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Direct function wrapper for addDependency with error handling.
@@ -18,68 +21,76 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Result object with success status and data/error information
  */
-export async function addDependencyDirect(args, log) {
+export async function addDependencyDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Adding dependency with args: ${JSON.stringify(args)}`);
+		log.info(`Adding dependency with args: ${JSON.stringify(args)}`);
 
-    // Validate required parameters
+		// Validate required parameters
-    if (!args.id) {
+		if (!args.id) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Task ID (id) is required'
+					message: 'Task ID (id) is required'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    if (!args.dependsOn) {
+		if (!args.dependsOn) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Dependency ID (dependsOn) is required'
+					message: 'Dependency ID (dependsOn) is required'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Format IDs for the core function
+		// Format IDs for the core function
-    const taskId = args.id.includes && args.id.includes('.') ? args.id : parseInt(args.id, 10);
+		const taskId =
-    const dependencyId = args.dependsOn.includes && args.dependsOn.includes('.') ? args.dependsOn : parseInt(args.dependsOn, 10);
+			args.id.includes && args.id.includes('.')
+				? args.id
+				: parseInt(args.id, 10);
+		const dependencyId =
+			args.dependsOn.includes && args.dependsOn.includes('.')
+				? args.dependsOn
+				: parseInt(args.dependsOn, 10);
 
-    log.info(`Adding dependency: task ${taskId} will depend on ${dependencyId}`);
+		log.info(
+			`Adding dependency: task ${taskId} will depend on ${dependencyId}`
+		);
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Call the core function
+		// Call the core function
-    await addDependency(tasksPath, taskId, dependencyId);
+		await addDependency(tasksPath, taskId, dependencyId);
 
-    // Restore normal logging
+		// Restore normal logging
-    disableSilentMode();
+		disableSilentMode();
 
-    return {
+		return {
-      success: true,
+			success: true,
-      data: {
+			data: {
-        message: `Successfully added dependency: Task ${taskId} now depends on ${dependencyId}`,
+				message: `Successfully added dependency: Task ${taskId} now depends on ${dependencyId}`,
-        taskId: taskId,
+				taskId: taskId,
-        dependencyId: dependencyId
+				dependencyId: dependencyId
-      }
+			}
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Make sure to restore normal logging even if there's an error
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error in addDependencyDirect: ${error.message}`);
+		log.error(`Error in addDependencyDirect: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'CORE_FUNCTION_ERROR',
+				code: 'CORE_FUNCTION_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/add-subtask.js

@@ -4,7 +4,10 @@
 
 import { addSubtask } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Add a subtask to an existing task
@@ -22,107 +25,119 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: string}>}
  */
-export async function addSubtaskDirect(args, log) {
+export async function addSubtaskDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
+		log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
 
-    if (!args.id) {
+		if (!args.id) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Parent task ID is required'
+					message: 'Parent task ID is required'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Either taskId or title must be provided
+		// Either taskId or title must be provided
-    if (!args.taskId && !args.title) {
+		if (!args.taskId && !args.title) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Either taskId or title must be provided'
+					message: 'Either taskId or title must be provided'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Parse dependencies if provided
+		// Parse dependencies if provided
-    let dependencies = [];
+		let dependencies = [];
-    if (args.dependencies) {
+		if (args.dependencies) {
-      dependencies = args.dependencies.split(',').map(id => {
+			dependencies = args.dependencies.split(',').map((id) => {
-        // Handle both regular IDs and dot notation
+				// Handle both regular IDs and dot notation
-        return id.includes('.') ? id.trim() : parseInt(id.trim(), 10);
+				return id.includes('.') ? id.trim() : parseInt(id.trim(), 10);
-      });
+			});
-    }
+		}
 
-    // Convert existingTaskId to a number if provided
+		// Convert existingTaskId to a number if provided
-    const existingTaskId = args.taskId ? parseInt(args.taskId, 10) : null;
+		const existingTaskId = args.taskId ? parseInt(args.taskId, 10) : null;
 
-    // Convert parent ID to a number
+		// Convert parent ID to a number
-    const parentId = parseInt(args.id, 10);
+		const parentId = parseInt(args.id, 10);
 
-    // Determine if we should generate files
+		// Determine if we should generate files
-    const generateFiles = !args.skipGenerate;
+		const generateFiles = !args.skipGenerate;
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Case 1: Convert existing task to subtask
+		// Case 1: Convert existing task to subtask
-    if (existingTaskId) {
+		if (existingTaskId) {
-      log.info(`Converting task ${existingTaskId} to a subtask of ${parentId}`);
+			log.info(`Converting task ${existingTaskId} to a subtask of ${parentId}`);
-      const result = await addSubtask(tasksPath, parentId, existingTaskId, null, generateFiles);
+			const result = await addSubtask(
+				tasksPath,
+				parentId,
+				existingTaskId,
+				null,
+				generateFiles
+			);
 
-      // Restore normal logging
+			// Restore normal logging
-      disableSilentMode();
+			disableSilentMode();
 
-      return {
+			return {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: `Task ${existingTaskId} successfully converted to a subtask of task ${parentId}`,
+					message: `Task ${existingTaskId} successfully converted to a subtask of task ${parentId}`,
-          subtask: result
+					subtask: result
-        }
+				}
-      };
+			};
-    } 
+		}
-    // Case 2: Create new subtask
+		// Case 2: Create new subtask
-    else {
+		else {
-      log.info(`Creating new subtask for parent task ${parentId}`);
+			log.info(`Creating new subtask for parent task ${parentId}`);
 
-      const newSubtaskData = {
+			const newSubtaskData = {
-        title: args.title,
+				title: args.title,
-        description: args.description || '',
+				description: args.description || '',
-        details: args.details || '',
+				details: args.details || '',
-        status: args.status || 'pending',
+				status: args.status || 'pending',
-        dependencies: dependencies
+				dependencies: dependencies
-      };
+			};
 
-      const result = await addSubtask(tasksPath, parentId, null, newSubtaskData, generateFiles);
+			const result = await addSubtask(
+				tasksPath,
+				parentId,
+				null,
+				newSubtaskData,
+				generateFiles
+			);
 
-      // Restore normal logging
+			// Restore normal logging
-      disableSilentMode();
+			disableSilentMode();
 
-      return {
+			return {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: `New subtask ${parentId}.${result.id} successfully created`,
+					message: `New subtask ${parentId}.${result.id} successfully created`,
-          subtask: result
+					subtask: result
-        }
+				}
-      };
+			};
-    }
+		}
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Make sure to restore normal logging even if there's an error
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error in addSubtaskDirect: ${error.message}`);
+		log.error(`Error in addSubtaskDirect: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'CORE_FUNCTION_ERROR',
+				code: 'CORE_FUNCTION_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/add-task.js

@@ -5,172 +5,238 @@
 
 import { addTask } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
-import { getAnthropicClientForMCP, getModelConfig } from '../utils/ai-client-utils.js';
+	enableSilentMode,
-import { _buildAddTaskPrompt, parseTaskJsonResponse, _handleAnthropicStream } from '../../../../scripts/modules/ai-services.js';
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import {
+	getAnthropicClientForMCP,
+	getModelConfig
+} from '../utils/ai-client-utils.js';
+import {
+	_buildAddTaskPrompt,
+	parseTaskJsonResponse,
+	_handleAnthropicStream
+} from '../../../../scripts/modules/ai-services.js';
 
 /**
  * Direct function wrapper for adding a new task with error handling.
  *
  * @param {Object} args - Command arguments
- * @param {string} args.prompt - Description of the task to add
+ * @param {string} [args.prompt] - Description of the task to add (required if not using manual fields)
- * @param {Array<number>} [args.dependencies=[]] - Task dependencies as array of IDs
+ * @param {string} [args.title] - Task title (for manual task creation)
+ * @param {string} [args.description] - Task description (for manual task creation)
+ * @param {string} [args.details] - Implementation details (for manual task creation)
+ * @param {string} [args.testStrategy] - Test strategy (for manual task creation)
+ * @param {string} [args.dependencies] - Comma-separated list of task IDs this task depends on
  * @param {string} [args.priority='medium'] - Task priority (high, medium, low)
- * @param {string} [args.file] - Path to the tasks file
+ * @param {string} [args.file='tasks/tasks.json'] - Path to the tasks file
  * @param {string} [args.projectRoot] - Project root directory
- * @param {boolean} [args.research] - Whether to use research capabilities for task creation
+ * @param {boolean} [args.research=false] - Whether to use research capabilities for task creation
  * @param {Object} log - Logger object
  * @param {Object} context - Additional context (reportProgress, session)
  * @returns {Promise<Object>} - Result object { success: boolean, data?: any, error?: { code: string, message: string } }
  */
-export async function addTaskDirect(args, log, context = {}) {
+export async function addTaskDirect(args, log, { session }) {
-  try {
+	try {
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Check required parameters
+		// Check if this is manual task creation or AI-driven task creation
-    if (!args.prompt) {
+		const isManualCreation = args.title && args.description;
-      log.error('Missing required parameter: prompt');
-      disableSilentMode();
-      return {
-        success: false,
-        error: {
-          code: 'MISSING_PARAMETER',
-          message: 'The prompt parameter is required for adding a task'
-        }
-      };
-    }
 
-    // Extract and prepare parameters
+		// Check required parameters
-    const prompt = args.prompt;
+		if (!args.prompt && !isManualCreation) {
-    const dependencies = Array.isArray(args.dependencies) 
+			log.error(
-      ? args.dependencies 
+				'Missing required parameters: either prompt or title+description must be provided'
-      : (args.dependencies ? String(args.dependencies).split(',').map(id => parseInt(id.trim(), 10)) : []);
+			);
-    const priority = args.priority || 'medium';
+			disableSilentMode();
+			return {
+				success: false,
+				error: {
+					code: 'MISSING_PARAMETER',
+					message:
+						'Either the prompt parameter or both title and description parameters are required for adding a task'
+				}
+			};
+		}
 
-    log.info(`Adding new task with prompt: "${prompt}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`);
+		// Extract and prepare parameters
+		const prompt = args.prompt;
+		const dependencies = Array.isArray(args.dependencies)
+			? args.dependencies
+			: args.dependencies
+				? String(args.dependencies)
+						.split(',')
+						.map((id) => parseInt(id.trim(), 10))
+				: [];
+		const priority = args.priority || 'medium';
 
-    // Extract context parameters for advanced functionality
+		let manualTaskData = null;
-    // Commenting out reportProgress extraction
-    // const { reportProgress, session } = context; 
-    const { session } = context; // Keep session
 
-    // Initialize AI client with session environment
+		if (isManualCreation) {
-    let localAnthropic;
+			// Create manual task data object
-    try {
+			manualTaskData = {
-      localAnthropic = getAnthropicClientForMCP(session, log);
+				title: args.title,
-    } catch (error) {
+				description: args.description,
-      log.error(`Failed to initialize Anthropic client: ${error.message}`);
+				details: args.details || '',
-      disableSilentMode();
+				testStrategy: args.testStrategy || ''
-      return {
+			};
-        success: false,
-        error: {
-          code: 'AI_CLIENT_ERROR',
-          message: `Cannot initialize AI client: ${error.message}`
-        }
-      };
-    }
 
-    // Get model configuration from session
+			log.info(
-    const modelConfig = getModelConfig(session);
+				`Adding new task manually with title: "${args.title}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`
+			);
 
-    // Read existing tasks to provide context
+			// Call the addTask function with manual task data
-    let tasksData;
+			const newTaskId = await addTask(
-    try {
+				tasksPath,
-      const fs = await import('fs');
+				null, // No prompt needed for manual creation
-      tasksData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+				dependencies,
-    } catch (error) {
+				priority,
-      log.warn(`Could not read existing tasks for context: ${error.message}`);
+				{
-      tasksData = { tasks: [] };
+					mcpLog: log,
-    }
+					session
+				},
+				'json', // Use JSON output format to prevent console output
+				null, // No custom environment
+				manualTaskData // Pass the manual task data
+			);
 
-    // Build prompts for AI
+			// Restore normal logging
-    const { systemPrompt, userPrompt } = _buildAddTaskPrompt(prompt, tasksData.tasks);
+			disableSilentMode();
 
-    // Make the AI call using the streaming helper
+			return {
-    let responseText;
+				success: true,
-    try {
+				data: {
-      responseText = await _handleAnthropicStream(
+					taskId: newTaskId,
-        localAnthropic,
+					message: `Successfully added new task #${newTaskId}`
-        {
+				}
-          model: modelConfig.model,
+			};
-          max_tokens: modelConfig.maxTokens,
+		} else {
-          temperature: modelConfig.temperature,
+			// AI-driven task creation
-          messages: [{ role: "user", content: userPrompt }],
+			log.info(
-          system: systemPrompt
+				`Adding new task with prompt: "${prompt}", dependencies: [${dependencies.join(', ')}], priority: ${priority}`
-        },
+			);
-        {
-          // reportProgress: context.reportProgress, // Commented out to prevent Cursor stroking out 
-          mcpLog: log
-        }
-      );
-    } catch (error) {
-      log.error(`AI processing failed: ${error.message}`);
-      disableSilentMode();
-      return {
-        success: false,
-        error: {
-          code: 'AI_PROCESSING_ERROR',
-          message: `Failed to generate task with AI: ${error.message}`
-        }
-      };
-    }
 
-    // Parse the AI response
+			// Initialize AI client with session environment
-    let taskDataFromAI;
+			let localAnthropic;
-    try {
+			try {
-      taskDataFromAI = parseTaskJsonResponse(responseText);
+				localAnthropic = getAnthropicClientForMCP(session, log);
-    } catch (error) {
+			} catch (error) {
-      log.error(`Failed to parse AI response: ${error.message}`);
+				log.error(`Failed to initialize Anthropic client: ${error.message}`);
-      disableSilentMode();
+				disableSilentMode();
-      return {
+				return {
-        success: false,
+					success: false,
-        error: {
+					error: {
-          code: 'RESPONSE_PARSING_ERROR',
+						code: 'AI_CLIENT_ERROR',
-          message: `Failed to parse AI response: ${error.message}`
+						message: `Cannot initialize AI client: ${error.message}`
-        }
+					}
-      };
+				};
-    }
+			}
 
-    // Call the addTask function with 'json' outputFormat to prevent console output when called via MCP
+			// Get model configuration from session
-    const newTaskId = await addTask(
+			const modelConfig = getModelConfig(session);
-      tasksPath, 
-      prompt, 
-      dependencies, 
-      priority, 
-      { 
-        // reportProgress, // Commented out
-        mcpLog: log, 
-        session,
-        taskDataFromAI // Pass the parsed AI result
-      }, 
-      'json'
-    );
 
-    // Restore normal logging
+			// Read existing tasks to provide context
-    disableSilentMode();
+			let tasksData;
+			try {
+				const fs = await import('fs');
+				tasksData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+			} catch (error) {
+				log.warn(`Could not read existing tasks for context: ${error.message}`);
+				tasksData = { tasks: [] };
+			}
 
-    return {
+			// Build prompts for AI
-      success: true,
+			const { systemPrompt, userPrompt } = _buildAddTaskPrompt(
-      data: {
+				prompt,
-        taskId: newTaskId,
+				tasksData.tasks
-        message: `Successfully added new task #${newTaskId}`
+			);
-      }
-    };
-  } catch (error) {
-    // Make sure to restore normal logging even if there's an error
-    disableSilentMode();
 
-    log.error(`Error in addTaskDirect: ${error.message}`);
+			// Make the AI call using the streaming helper
-    return {
+			let responseText;
-      success: false,
+			try {
-      error: {
+				responseText = await _handleAnthropicStream(
-        code: 'ADD_TASK_ERROR',
+					localAnthropic,
-        message: error.message
+					{
-      }
+						model: modelConfig.model,
-    };
+						max_tokens: modelConfig.maxTokens,
-  }
+						temperature: modelConfig.temperature,
+						messages: [{ role: 'user', content: userPrompt }],
+						system: systemPrompt
+					},
+					{
+						mcpLog: log
+					}
+				);
+			} catch (error) {
+				log.error(`AI processing failed: ${error.message}`);
+				disableSilentMode();
+				return {
+					success: false,
+					error: {
+						code: 'AI_PROCESSING_ERROR',
+						message: `Failed to generate task with AI: ${error.message}`
+					}
+				};
+			}
+
+			// Parse the AI response
+			let taskDataFromAI;
+			try {
+				taskDataFromAI = parseTaskJsonResponse(responseText);
+			} catch (error) {
+				log.error(`Failed to parse AI response: ${error.message}`);
+				disableSilentMode();
+				return {
+					success: false,
+					error: {
+						code: 'RESPONSE_PARSING_ERROR',
+						message: `Failed to parse AI response: ${error.message}`
+					}
+				};
+			}
+
+			// Call the addTask function with 'json' outputFormat to prevent console output when called via MCP
+			const newTaskId = await addTask(
+				tasksPath,
+				prompt,
+				dependencies,
+				priority,
+				{
+					mcpLog: log,
+					session
+				},
+				'json',
+				null,
+				taskDataFromAI // Pass the parsed AI result as the manual task data
+			);
+
+			// Restore normal logging
+			disableSilentMode();
+
+			return {
+				success: true,
+				data: {
+					taskId: newTaskId,
+					message: `Successfully added new task #${newTaskId}`
+				}
+			};
+		}
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error in addTaskDirect: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'ADD_TASK_ERROR',
+				message: error.message
+			}
+		};
+	}
 }

mcp-server/src/core/direct-functions/analyze-task-complexity.js

@@ -3,8 +3,17 @@
  */
 
 import { analyzeTaskComplexity } from '../../../../scripts/modules/task-manager.js';
-import { findTasksJsonPath } from '../utils/path-utils.js';
+import {
-import { enableSilentMode, disableSilentMode, isSilentMode, readJSON } from '../../../../scripts/modules/utils.js';
+	findTasksJsonPath,
+	resolveProjectPath,
+	ensureDirectoryExists
+} from '../utils/path-utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode,
+	readJSON
+} from '../../../../scripts/modules/utils.js';
 import fs from 'fs';
 import path from 'path';
 
@@ -21,136 +30,158 @@ import path from 'path';
  * @param {Object} [context={}] - Context object containing session data
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function analyzeTaskComplexityDirect(args, log, context = {}) {
+export async function analyzeTaskComplexityDirect(args, log, { session }) {
-  const { session } = context; // Only extract session, not reportProgress
+	try {
+		log.info(`Analyzing task complexity with args: ${JSON.stringify(args)}`);
 
-  try {
+		// Find the tasks.json path AND get the validated project root
-    log.info(`Analyzing task complexity with args: ${JSON.stringify(args)}`);
+		const { tasksPath, validatedProjectRoot } = findTasksJsonPath(
+			args,
+			log,
+			session
+		);
+		log.info(
+			`Using tasks file: ${tasksPath} located within project root: ${validatedProjectRoot}`
+		);
 
-    // Find the tasks.json path
+		// Determine and resolve the output path using the VALIDATED root
-    const tasksPath = findTasksJsonPath(args, log);
+		const relativeOutputPath =
+			args.output || 'scripts/task-complexity-report.json';
+		const absoluteOutputPath = resolveProjectPath(
+			relativeOutputPath,
+			validatedProjectRoot,
+			log
+		);
 
-    // Determine output path
+		// Ensure the output directory exists
-    let outputPath = args.output || 'scripts/task-complexity-report.json';
+		ensureDirectoryExists(path.dirname(absoluteOutputPath), log);
-    if (!path.isAbsolute(outputPath) && args.projectRoot) {
-      outputPath = path.join(args.projectRoot, outputPath);
-    }
 
-    log.info(`Analyzing task complexity from: ${tasksPath}`);
+		log.info(`Output report will be saved to: ${absoluteOutputPath}`);
-    log.info(`Output report will be saved to: ${outputPath}`);
 
-    if (args.research) {
+		if (args.research) {
-      log.info('Using Perplexity AI for research-backed complexity analysis');
+			log.info('Using Perplexity AI for research-backed complexity analysis');
-    }
+		}
 
-    // Create options object for analyzeTaskComplexity
+		// Create options object for analyzeTaskComplexity
-    const options = {
+		const options = {
-      file: tasksPath,
+			file: tasksPath,
-      output: outputPath,
+			output: absoluteOutputPath,
-      model: args.model,
+			model: args.model,
-      threshold: args.threshold,
+			threshold: args.threshold,
-      research: args.research === true
+			research: args.research === true
-    };
+		};
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    const wasSilent = isSilentMode();
+		const wasSilent = isSilentMode();
-    if (!wasSilent) {
+		if (!wasSilent) {
-      enableSilentMode();
+			enableSilentMode();
-    }
+		}
 
-    // Create a logWrapper that matches the expected mcpLog interface as specified in utilities.mdc
+		// Create a logWrapper that matches the expected mcpLog interface as specified in utilities.mdc
-    const logWrapper = {
+		const logWrapper = {
-      info: (message, ...args) => log.info(message, ...args),
+			info: (message, ...args) => log.info(message, ...args),
-      warn: (message, ...args) => log.warn(message, ...args),
+			warn: (message, ...args) => log.warn(message, ...args),
-      error: (message, ...args) => log.error(message, ...args),
+			error: (message, ...args) => log.error(message, ...args),
-      debug: (message, ...args) => log.debug && log.debug(message, ...args),
+			debug: (message, ...args) => log.debug && log.debug(message, ...args),
-      success: (message, ...args) => log.info(message, ...args) // Map success to info
+			success: (message, ...args) => log.info(message, ...args) // Map success to info
-    };
+		};
 
-    try {
+		try {
-      // Call the core function with session and logWrapper as mcpLog
+			// Call the core function with session and logWrapper as mcpLog
-      await analyzeTaskComplexity(options, {
+			await analyzeTaskComplexity(options, {
-        session,
+				session,
-        mcpLog: logWrapper // Use the wrapper instead of passing log directly
+				mcpLog: logWrapper // Use the wrapper instead of passing log directly
-      });
+			});
-    } catch (error) {
+		} catch (error) {
-      log.error(`Error in analyzeTaskComplexity: ${error.message}`);
+			log.error(`Error in analyzeTaskComplexity: ${error.message}`);
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'ANALYZE_ERROR',
+					code: 'ANALYZE_ERROR',
-          message: `Error running complexity analysis: ${error.message}`
+					message: `Error running complexity analysis: ${error.message}`
-        }
+				}
-      };
+			};
-    } finally {
+		} finally {
-      // Always restore normal logging in finally block, but only if we enabled it
+			// Always restore normal logging in finally block, but only if we enabled it
-      if (!wasSilent) {
+			if (!wasSilent) {
-        disableSilentMode();
+				disableSilentMode();
-      }
+			}
-    }
+		}
 
-    // Verify the report file was created
+		// Verify the report file was created
-    if (!fs.existsSync(outputPath)) {
+		if (!fs.existsSync(absoluteOutputPath)) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'ANALYZE_ERROR',
+					code: 'ANALYZE_ERROR',
-          message: 'Analysis completed but no report file was created'
+					message: 'Analysis completed but no report file was created'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Read the report file
+		// Read the report file
-    let report;
+		let report;
-    try {
+		try {
-      report = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+			report = JSON.parse(fs.readFileSync(absoluteOutputPath, 'utf8'));
 
-      // Important: Handle different report formats
+			// Important: Handle different report formats
-      // The core function might return an array or an object with a complexityAnalysis property
+			// The core function might return an array or an object with a complexityAnalysis property
-      const analysisArray = Array.isArray(report) ? report : 
+			const analysisArray = Array.isArray(report)
-                           (report.complexityAnalysis || []);
+				? report
+				: report.complexityAnalysis || [];
 
-      // Count tasks by complexity
+			// Count tasks by complexity
-      const highComplexityTasks = analysisArray.filter(t => t.complexityScore >= 8).length;
+			const highComplexityTasks = analysisArray.filter(
-      const mediumComplexityTasks = analysisArray.filter(t => t.complexityScore >= 5 && t.complexityScore < 8).length;
+				(t) => t.complexityScore >= 8
-      const lowComplexityTasks = analysisArray.filter(t => t.complexityScore < 5).length;
+			).length;
+			const mediumComplexityTasks = analysisArray.filter(
+				(t) => t.complexityScore >= 5 && t.complexityScore < 8
+			).length;
+			const lowComplexityTasks = analysisArray.filter(
+				(t) => t.complexityScore < 5
+			).length;
 
-      return {
+			return {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: `Task complexity analysis complete. Report saved to ${outputPath}`,
+					message: `Task complexity analysis complete. Report saved to ${absoluteOutputPath}`,
-          reportPath: outputPath,
+					reportPath: absoluteOutputPath,
-          reportSummary: {
+					reportSummary: {
-            taskCount: analysisArray.length,
+						taskCount: analysisArray.length,
-            highComplexityTasks,
+						highComplexityTasks,
-            mediumComplexityTasks,
+						mediumComplexityTasks,
-            lowComplexityTasks
+						lowComplexityTasks
-          }
+					}
-        }
+				}
-      };
+			};
-    } catch (parseError) {
+		} catch (parseError) {
-      log.error(`Error parsing report file: ${parseError.message}`);
+			log.error(`Error parsing report file: ${parseError.message}`);
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'REPORT_PARSE_ERROR',
+					code: 'REPORT_PARSE_ERROR',
-          message: `Error parsing complexity report: ${parseError.message}`
+					message: `Error parsing complexity report: ${parseError.message}`
-        }
+				}
-      };
+			};
-    }
+		}
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Centralized error catching for issues like invalid root, file not found, core errors etc.
-    if (isSilentMode()) {
+		if (isSilentMode()) {
-      disableSilentMode();
+			disableSilentMode();
-    }
+		}
 
-    log.error(`Error in analyzeTaskComplexityDirect: ${error.message}`);
+		log.error(`Error in analyzeTaskComplexityDirect: ${error.message}`, {
-    return {
+			code: error.code,
-      success: false,
+			details: error.details,
-      error: {
+			stack: error.stack
-        code: 'CORE_FUNCTION_ERROR',
+		});
-        message: error.message
+		return {
-      }
+			success: false,
-    };
+			error: {
-  }
+				code: error.code || 'ANALYZE_COMPLEXITY_ERROR',
+				message: error.message
+			},
+			fromCache: false // Assume errors are not from cache
+		};
+	}
 }

mcp-server/src/core/direct-functions/cache-stats.js

@@ -12,21 +12,21 @@ import { contextManager } from '../context-manager.js';
  * @returns {Object} - Cache statistics
  */
 export async function getCacheStatsDirect(args, log) {
-  try {
+	try {
-    log.info('Retrieving cache statistics');
+		log.info('Retrieving cache statistics');
-    const stats = contextManager.getStats();
+		const stats = contextManager.getStats();
-    return {
+		return {
-      success: true,
+			success: true,
-      data: stats
+			data: stats
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    log.error(`Error getting cache stats: ${error.message}`);
+		log.error(`Error getting cache stats: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'CACHE_STATS_ERROR',
+				code: 'CACHE_STATS_ERROR',
-        message: error.message || 'Unknown error occurred'
+				message: error.message || 'Unknown error occurred'
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/clear-subtasks.js

@@ -4,7 +4,10 @@
 
 import { clearSubtasks } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import fs from 'fs';
 
 /**
@@ -17,96 +20,97 @@ import fs from 'fs';
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function clearSubtasksDirect(args, log) {
+export async function clearSubtasksDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
+		log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
 
-    // Either id or all must be provided
+		// Either id or all must be provided
-    if (!args.id && !args.all) {
+		if (!args.id && !args.all) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Either task IDs with id parameter or all parameter must be provided'
+					message:
-        }
+						'Either task IDs with id parameter or all parameter must be provided'
-      };
+				}
-    }
+			};
+		}
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Check if tasks.json exists
+		// Check if tasks.json exists
-    if (!fs.existsSync(tasksPath)) {
+		if (!fs.existsSync(tasksPath)) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'FILE_NOT_FOUND_ERROR',
+					code: 'FILE_NOT_FOUND_ERROR',
-          message: `Tasks file not found at ${tasksPath}`
+					message: `Tasks file not found at ${tasksPath}`
-        }
+				}
-      };
+			};
-    }
+		}
 
-    let taskIds;
+		let taskIds;
 
-    // If all is specified, get all task IDs
+		// If all is specified, get all task IDs
-    if (args.all) {
+		if (args.all) {
-      log.info('Clearing subtasks from all tasks');
+			log.info('Clearing subtasks from all tasks');
-      const data = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+			const data = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
-      if (!data || !data.tasks || data.tasks.length === 0) {
+			if (!data || !data.tasks || data.tasks.length === 0) {
-        return {
+				return {
-          success: false,
+					success: false,
-          error: {
+					error: {
-            code: 'INPUT_VALIDATION_ERROR',
+						code: 'INPUT_VALIDATION_ERROR',
-            message: 'No valid tasks found in the tasks file'
+						message: 'No valid tasks found in the tasks file'
-          }
+					}
-        };
+				};
-      }
+			}
-      taskIds = data.tasks.map(t => t.id).join(',');
+			taskIds = data.tasks.map((t) => t.id).join(',');
-    } else {
+		} else {
-      // Use the provided task IDs
+			// Use the provided task IDs
-      taskIds = args.id;
+			taskIds = args.id;
-    }
+		}
 
-    log.info(`Clearing subtasks from tasks: ${taskIds}`);
+		log.info(`Clearing subtasks from tasks: ${taskIds}`);
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Call the core function
+		// Call the core function
-    clearSubtasks(tasksPath, taskIds);
+		clearSubtasks(tasksPath, taskIds);
 
-    // Restore normal logging
+		// Restore normal logging
-    disableSilentMode();
+		disableSilentMode();
 
-    // Read the updated data to provide a summary
+		// Read the updated data to provide a summary
-    const updatedData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
+		const updatedData = JSON.parse(fs.readFileSync(tasksPath, 'utf8'));
-    const taskIdArray = taskIds.split(',').map(id => parseInt(id.trim(), 10));
+		const taskIdArray = taskIds.split(',').map((id) => parseInt(id.trim(), 10));
 
-    // Build a summary of what was done
+		// Build a summary of what was done
-    const clearedTasksCount = taskIdArray.length;
+		const clearedTasksCount = taskIdArray.length;
-    const taskSummary = taskIdArray.map(id => {
+		const taskSummary = taskIdArray.map((id) => {
-      const task = updatedData.tasks.find(t => t.id === id);
+			const task = updatedData.tasks.find((t) => t.id === id);
-      return task ? { id, title: task.title } : { id, title: 'Task not found' };
+			return task ? { id, title: task.title } : { id, title: 'Task not found' };
-    });
+		});
 
-    return {
+		return {
-      success: true,
+			success: true,
-      data: {
+			data: {
-        message: `Successfully cleared subtasks from ${clearedTasksCount} task(s)`,
+				message: `Successfully cleared subtasks from ${clearedTasksCount} task(s)`,
-        tasksCleared: taskSummary
+				tasksCleared: taskSummary
-      }
+			}
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Make sure to restore normal logging even if there's an error
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error in clearSubtasksDirect: ${error.message}`);
+		log.error(`Error in clearSubtasksDirect: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'CORE_FUNCTION_ERROR',
+				code: 'CORE_FUNCTION_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/complexity-report.js

@@ -3,7 +3,11 @@
  * Direct function implementation for displaying complexity analysis report
  */
 
-import { readComplexityReport, enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	readComplexityReport,
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
 import path from 'path';
@@ -15,107 +19,115 @@ import path from 'path';
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Result object with success status and data/error information
  */
-export async function complexityReportDirect(args, log) {
+export async function complexityReportDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Getting complexity report with args: ${JSON.stringify(args)}`);
+		log.info(`Getting complexity report with args: ${JSON.stringify(args)}`);
 
-    // Get tasks file path to determine project root for the default report location
+		// Get tasks file path to determine project root for the default report location
-    let tasksPath;
+		let tasksPath;
-    try {
+		try {
-      tasksPath = findTasksJsonPath(args, log);
+			tasksPath = findTasksJsonPath(args, log, session);
-    } catch (error) {
+		} catch (error) {
-      log.warn(`Tasks file not found, using current directory: ${error.message}`);
+			log.warn(
-      // Continue with default or specified report path
+				`Tasks file not found, using current directory: ${error.message}`
-    }
+			);
+			// Continue with default or specified report path
+		}
 
-    // Get report file path from args or use default
+		// Get report file path from args or use default
-    const reportPath = args.file || path.join(process.cwd(), 'scripts', 'task-complexity-report.json');
+		const reportPath =
+			args.file ||
+			path.join(process.cwd(), 'scripts', 'task-complexity-report.json');
 
-    log.info(`Looking for complexity report at: ${reportPath}`);
+		log.info(`Looking for complexity report at: ${reportPath}`);
 
-    // Generate cache key based on report path
+		// Generate cache key based on report path
-    const cacheKey = `complexityReport:${reportPath}`;
+		const cacheKey = `complexityReport:${reportPath}`;
 
-    // Define the core action function to read the report
+		// Define the core action function to read the report
-    const coreActionFn = async () => {
+		const coreActionFn = async () => {
-      try {
+			try {
-        // Enable silent mode to prevent console logs from interfering with JSON response
+				// Enable silent mode to prevent console logs from interfering with JSON response
-        enableSilentMode();
+				enableSilentMode();
 
-        const report = readComplexityReport(reportPath);
+				const report = readComplexityReport(reportPath);
 
-        // Restore normal logging
+				// Restore normal logging
-        disableSilentMode();
+				disableSilentMode();
 
-        if (!report) {
+				if (!report) {
-          log.warn(`No complexity report found at ${reportPath}`);
+					log.warn(`No complexity report found at ${reportPath}`);
-          return { 
+					return {
-            success: false, 
+						success: false,
-            error: { 
+						error: {
-              code: 'FILE_NOT_FOUND_ERROR', 
+							code: 'FILE_NOT_FOUND_ERROR',
-              message: `No complexity report found at ${reportPath}. Run 'analyze-complexity' first.` 
+							message: `No complexity report found at ${reportPath}. Run 'analyze-complexity' first.`
-            }
+						}
-          };
+					};
-        }
+				}
 
-        return {
+				return {
-          success: true,
+					success: true,
-          data: {
+					data: {
-            report,
+						report,
-            reportPath
+						reportPath
-          }
+					}
-        };
+				};
-      } catch (error) {
+			} catch (error) {
-        // Make sure to restore normal logging even if there's an error
+				// Make sure to restore normal logging even if there's an error
-        disableSilentMode();
+				disableSilentMode();
 
-        log.error(`Error reading complexity report: ${error.message}`);
+				log.error(`Error reading complexity report: ${error.message}`);
-        return { 
+				return {
-          success: false, 
+					success: false,
-          error: { 
+					error: {
-            code: 'READ_ERROR', 
+						code: 'READ_ERROR',
-            message: error.message 
+						message: error.message
-          }
+					}
-        };
+				};
-      }
+			}
-    };
+		};
 
-    // Use the caching utility
+		// Use the caching utility
-    try {
+		try {
-      const result = await getCachedOrExecute({
+			const result = await getCachedOrExecute({
-        cacheKey,
+				cacheKey,
-        actionFn: coreActionFn,
+				actionFn: coreActionFn,
-        log
+				log
-      });
+			});
-      log.info(`complexityReportDirect completed. From cache: ${result.fromCache}`);
+			log.info(
-      return result; // Returns { success, data/error, fromCache }
+				`complexityReportDirect completed. From cache: ${result.fromCache}`
-    } catch (error) {
+			);
-      // Catch unexpected errors from getCachedOrExecute itself
+			return result; // Returns { success, data/error, fromCache }
-      // Ensure silent mode is disabled
+		} catch (error) {
-      disableSilentMode();
+			// Catch unexpected errors from getCachedOrExecute itself
+			// Ensure silent mode is disabled
+			disableSilentMode();
 
-      log.error(`Unexpected error during getCachedOrExecute for complexityReport: ${error.message}`);
+			log.error(
-      return { 
+				`Unexpected error during getCachedOrExecute for complexityReport: ${error.message}`
-        success: false, 
+			);
-        error: { 
+			return {
-          code: 'UNEXPECTED_ERROR', 
+				success: false,
-          message: error.message 
+				error: {
-        }, 
+					code: 'UNEXPECTED_ERROR',
-        fromCache: false 
+					message: error.message
-      };
+				},
-    }
+				fromCache: false
-  } catch (error) {
+			};
-    // Ensure silent mode is disabled if an outer error occurs
+		}
-    disableSilentMode();
+	} catch (error) {
+		// Ensure silent mode is disabled if an outer error occurs
+		disableSilentMode();
 
-    log.error(`Error in complexityReportDirect: ${error.message}`);
+		log.error(`Error in complexityReportDirect: ${error.message}`);
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { 
+			error: {
-        code: 'UNEXPECTED_ERROR', 
+				code: 'UNEXPECTED_ERROR',
-        message: error.message 
+				message: error.message
-      }, 
+			},
-      fromCache: false 
+			fromCache: false
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/expand-all-tasks.js

@@ -3,7 +3,11 @@
  */
 
 import { expandAllTasks } from '../../../../scripts/modules/task-manager.js';
-import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
 import { getAnthropicClientForMCP } from '../utils/ai-client-utils.js';
 import path from 'path';
@@ -22,99 +26,99 @@ import fs from 'fs';
  * @param {Object} context - Context object containing session
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function expandAllTasksDirect(args, log, context = {}) {
+export async function expandAllTasksDirect(args, log, { session }) {
-  const { session } = context; // Only extract session, not reportProgress
+	try {
+		log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
 
-  try {
+		// Enable silent mode early to prevent any console output
-    log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
+		enableSilentMode();
 
-    // Enable silent mode early to prevent any console output
+		try {
-    enableSilentMode();
+			// Find the tasks.json path
+			const tasksPath = findTasksJsonPath(args, log, session);
 
-    try {
+			// Parse parameters
-      // Find the tasks.json path
+			const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
-      const tasksPath = findTasksJsonPath(args, log);
+			const useResearch = args.research === true;
+			const additionalContext = args.prompt || '';
+			const forceFlag = args.force === true;
 
-      // Parse parameters
+			log.info(
-      const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
+				`Expanding all tasks with ${numSubtasks || 'default'} subtasks each...`
-      const useResearch = args.research === true;
+			);
-      const additionalContext = args.prompt || '';
-      const forceFlag = args.force === true;
 
-      log.info(`Expanding all tasks with ${numSubtasks || 'default'} subtasks each...`);
+			if (useResearch) {
+				log.info('Using Perplexity AI for research-backed subtask generation');
 
-      if (useResearch) {
+				// Initialize AI client for research-backed expansion
-        log.info('Using Perplexity AI for research-backed subtask generation');
+				try {
+					await getAnthropicClientForMCP(session, log);
+				} catch (error) {
+					// Ensure silent mode is disabled before returning error
+					disableSilentMode();
 
-        // Initialize AI client for research-backed expansion
+					log.error(`Failed to initialize AI client: ${error.message}`);
-        try {
+					return {
-          await getAnthropicClientForMCP(session, log);
+						success: false,
-        } catch (error) {
+						error: {
-          // Ensure silent mode is disabled before returning error
+							code: 'AI_CLIENT_ERROR',
-          disableSilentMode();
+							message: `Cannot initialize AI client: ${error.message}`
+						}
+					};
+				}
+			}
 
-          log.error(`Failed to initialize AI client: ${error.message}`);
+			if (additionalContext) {
-          return {
+				log.info(`Additional context: "${additionalContext}"`);
-            success: false,
+			}
-            error: {
+			if (forceFlag) {
-              code: 'AI_CLIENT_ERROR',
+				log.info('Force regeneration of subtasks is enabled');
-              message: `Cannot initialize AI client: ${error.message}`
+			}
-            }
-          };
-        }
-      }
 
-      if (additionalContext) {
+			// Call the core function with session context for AI operations
-        log.info(`Additional context: "${additionalContext}"`);
+			// and outputFormat as 'json' to prevent UI elements
-      }
+			const result = await expandAllTasks(
-      if (forceFlag) {
+				tasksPath,
-        log.info('Force regeneration of subtasks is enabled');
+				numSubtasks,
-      }
+				useResearch,
+				additionalContext,
+				forceFlag,
+				{ mcpLog: log, session },
+				'json' // Use JSON output format to prevent UI elements
+			);
 
-      // Call the core function with session context for AI operations
+			// The expandAllTasks function now returns a result object
-      // and outputFormat as 'json' to prevent UI elements
+			return {
-      const result = await expandAllTasks(
+				success: true,
-        tasksPath,
+				data: {
-        numSubtasks, 
+					message: 'Successfully expanded all pending tasks with subtasks',
-        useResearch, 
+					details: {
-        additionalContext, 
+						numSubtasks: numSubtasks,
-        forceFlag, 
+						research: useResearch,
-        { mcpLog: log, session },
+						prompt: additionalContext,
-        'json' // Use JSON output format to prevent UI elements
+						force: forceFlag,
-      );
+						tasksExpanded: result.expandedCount,
+						totalEligibleTasks: result.tasksToExpand
+					}
+				}
+			};
+		} finally {
+			// Restore normal logging in finally block to ensure it runs even if there's an error
+			disableSilentMode();
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled if an error occurs
+		if (isSilentMode()) {
+			disableSilentMode();
+		}
 
-      // The expandAllTasks function now returns a result object
+		log.error(`Error in expandAllTasksDirect: ${error.message}`);
-      return {
+		return {
-        success: true,
+			success: false,
-        data: {
+			error: {
-          message: "Successfully expanded all pending tasks with subtasks",
+				code: 'CORE_FUNCTION_ERROR',
-          details: {
+				message: error.message
-            numSubtasks: numSubtasks,
+			}
-            research: useResearch,
+		};
-            prompt: additionalContext,
+	}
-            force: forceFlag,
-            tasksExpanded: result.expandedCount,
-            totalEligibleTasks: result.tasksToExpand
-          }
-        }
-      };
-    } finally {
-      // Restore normal logging in finally block to ensure it runs even if there's an error
-      disableSilentMode();
-    }
-  } catch (error) {
-    // Ensure silent mode is disabled if an error occurs
-    if (isSilentMode()) {
-      disableSilentMode();
-    }
-    
-    log.error(`Error in expandAllTasksDirect: ${error.message}`);
-    return {
-      success: false,
-      error: {
-        code: 'CORE_FUNCTION_ERROR',
-        message: error.message
-      }
-    };
-  }
 }

mcp-server/src/core/direct-functions/expand-task.js

@@ -4,9 +4,18 @@
  */
 
 import { expandTask } from '../../../../scripts/modules/task-manager.js';
-import { readJSON, writeJSON, enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	readJSON,
+	writeJSON,
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { getAnthropicClientForMCP, getModelConfig } from '../utils/ai-client-utils.js';
+import {
+	getAnthropicClientForMCP,
+	getModelConfig
+} from '../utils/ai-client-utils.js';
 import path from 'path';
 import fs from 'fs';
 
@@ -18,232 +27,247 @@ import fs from 'fs';
  * @param {Object} context - Context object containing session and reportProgress
  * @returns {Promise<Object>} - Task expansion result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
-export async function expandTaskDirect(args, log, context = {}) {
+export async function expandTaskDirect(args, log, { session }) {
-  const { session } = context;
+	// Log session root data for debugging
+	log.info(
+		`Session data in expandTaskDirect: ${JSON.stringify({
+			hasSession: !!session,
+			sessionKeys: session ? Object.keys(session) : [],
+			roots: session?.roots,
+			rootsStr: JSON.stringify(session?.roots)
+		})}`
+	);
 
-  // Log session root data for debugging
+	let tasksPath;
-  log.info(`Session data in expandTaskDirect: ${JSON.stringify({
+	try {
-    hasSession: !!session,
+		// If a direct file path is provided, use it directly
-    sessionKeys: session ? Object.keys(session) : [],
+		if (args.file && fs.existsSync(args.file)) {
-    roots: session?.roots,
+			log.info(
-    rootsStr: JSON.stringify(session?.roots)
+				`[expandTaskDirect] Using explicitly provided tasks file: ${args.file}`
-  })}`);
+			);
+			tasksPath = args.file;
+		} else {
+			// Find the tasks path through standard logic
+			log.info(
+				`[expandTaskDirect] No direct file path provided or file not found at ${args.file}, searching using findTasksJsonPath`
+			);
+			tasksPath = findTasksJsonPath(args, log, session);
+		}
+	} catch (error) {
+		log.error(
+			`[expandTaskDirect] Error during tasksPath determination: ${error.message}`
+		);
 
-  let tasksPath;
+		// Include session roots information in error
-  try {
+		const sessionRootsInfo = session
-    // If a direct file path is provided, use it directly
+			? `\nSession.roots: ${JSON.stringify(session.roots)}\n` +
-    if (args.file && fs.existsSync(args.file)) {
+				`Current Working Directory: ${process.cwd()}\n` +
-      log.info(`[expandTaskDirect] Using explicitly provided tasks file: ${args.file}`);
+				`Args.projectRoot: ${args.projectRoot}\n` +
-      tasksPath = args.file;
+				`Args.file: ${args.file}\n`
-    } else {
+			: '\nSession object not available';
-      // Find the tasks path through standard logic
-      log.info(`[expandTaskDirect] No direct file path provided or file not found at ${args.file}, searching using findTasksJsonPath`);
-      tasksPath = findTasksJsonPath(args, log);
-    }
-  } catch (error) {
-    log.error(`[expandTaskDirect] Error during tasksPath determination: ${error.message}`);
 
-    // Include session roots information in error
+		return {
-    const sessionRootsInfo = session ? 
+			success: false,
-      `\nSession.roots: ${JSON.stringify(session.roots)}\n` +
+			error: {
-      `Current Working Directory: ${process.cwd()}\n` +
+				code: 'FILE_NOT_FOUND_ERROR',
-      `Args.projectRoot: ${args.projectRoot}\n` +
+				message: `Error determining tasksPath: ${error.message}${sessionRootsInfo}`
-      `Args.file: ${args.file}\n` : 
+			},
-      '\nSession object not available';
+			fromCache: false
+		};
+	}
 
-    return { 
+	log.info(`[expandTaskDirect] Determined tasksPath: ${tasksPath}`);
-      success: false, 
-      error: { 
-        code: 'FILE_NOT_FOUND_ERROR', 
-        message: `Error determining tasksPath: ${error.message}${sessionRootsInfo}` 
-      }, 
-      fromCache: false 
-    };
-  }
 
-  log.info(`[expandTaskDirect] Determined tasksPath: ${tasksPath}`);
+	// Validate task ID
+	const taskId = args.id ? parseInt(args.id, 10) : null;
+	if (!taskId) {
+		log.error('Task ID is required');
+		return {
+			success: false,
+			error: {
+				code: 'INPUT_VALIDATION_ERROR',
+				message: 'Task ID is required'
+			},
+			fromCache: false
+		};
+	}
 
-  // Validate task ID
+	// Process other parameters
-  const taskId = args.id ? parseInt(args.id, 10) : null;
+	const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
-  if (!taskId) {
+	const useResearch = args.research === true;
-    log.error('Task ID is required');
+	const additionalContext = args.prompt || '';
-    return { 
-      success: false, 
-      error: { 
-        code: 'INPUT_VALIDATION_ERROR', 
-        message: 'Task ID is required' 
-      }, 
-      fromCache: false 
-    };
-  }
 
-  // Process other parameters
+	// Initialize AI client if needed (for expandTask function)
-  const numSubtasks = args.num ? parseInt(args.num, 10) : undefined;
+	try {
-  const useResearch = args.research === true;
+		// This ensures the AI client is available by checking it
-  const additionalContext = args.prompt || '';
+		if (useResearch) {
+			log.info('Verifying AI client for research-backed expansion');
+			await getAnthropicClientForMCP(session, log);
+		}
+	} catch (error) {
+		log.error(`Failed to initialize AI client: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'AI_CLIENT_ERROR',
+				message: `Cannot initialize AI client: ${error.message}`
+			},
+			fromCache: false
+		};
+	}
 
-  // Initialize AI client if needed (for expandTask function)
+	try {
-  try {
+		log.info(
-    // This ensures the AI client is available by checking it
+			`[expandTaskDirect] Expanding task ${taskId} into ${numSubtasks || 'default'} subtasks. Research: ${useResearch}`
-    if (useResearch) {
+		);
-      log.info('Verifying AI client for research-backed expansion');
-      await getAnthropicClientForMCP(session, log);
-    }
-  } catch (error) {
-    log.error(`Failed to initialize AI client: ${error.message}`);
-    return {
-      success: false,
-      error: {
-        code: 'AI_CLIENT_ERROR',
-        message: `Cannot initialize AI client: ${error.message}`
-      },
-      fromCache: false
-    };
-  }
 
-  try {
+		// Read tasks data
-    log.info(`[expandTaskDirect] Expanding task ${taskId} into ${numSubtasks || 'default'} subtasks. Research: ${useResearch}`);
+		log.info(`[expandTaskDirect] Attempting to read JSON from: ${tasksPath}`);
+		const data = readJSON(tasksPath);
+		log.info(
+			`[expandTaskDirect] Result of readJSON: ${data ? 'Data read successfully' : 'readJSON returned null or undefined'}`
+		);
 
-    // Read tasks data
+		if (!data || !data.tasks) {
-    log.info(`[expandTaskDirect] Attempting to read JSON from: ${tasksPath}`);
+			log.error(
-    const data = readJSON(tasksPath);
+				`[expandTaskDirect] readJSON failed or returned invalid data for path: ${tasksPath}`
-    log.info(`[expandTaskDirect] Result of readJSON: ${data ? 'Data read successfully' : 'readJSON returned null or undefined'}`);
+			);
+			return {
+				success: false,
+				error: {
+					code: 'INVALID_TASKS_FILE',
+					message: `No valid tasks found in ${tasksPath}. readJSON returned: ${JSON.stringify(data)}`
+				},
+				fromCache: false
+			};
+		}
 
-    if (!data || !data.tasks) {
+		// Find the specific task
-      log.error(`[expandTaskDirect] readJSON failed or returned invalid data for path: ${tasksPath}`);
+		log.info(`[expandTaskDirect] Searching for task ID ${taskId} in data`);
-      return {
+		const task = data.tasks.find((t) => t.id === taskId);
-        success: false,
+		log.info(`[expandTaskDirect] Task found: ${task ? 'Yes' : 'No'}`);
-        error: {
-          code: 'INVALID_TASKS_FILE',
-          message: `No valid tasks found in ${tasksPath}. readJSON returned: ${JSON.stringify(data)}`
-        },
-        fromCache: false
-      };
-    }
 
-    // Find the specific task
+		if (!task) {
-    log.info(`[expandTaskDirect] Searching for task ID ${taskId} in data`);
+			return {
-    const task = data.tasks.find(t => t.id === taskId);
+				success: false,
-    log.info(`[expandTaskDirect] Task found: ${task ? 'Yes' : 'No'}`);
+				error: {
+					code: 'TASK_NOT_FOUND',
+					message: `Task with ID ${taskId} not found`
+				},
+				fromCache: false
+			};
+		}
 
-    if (!task) {
+		// Check if task is completed
-      return { 
+		if (task.status === 'done' || task.status === 'completed') {
-        success: false, 
+			return {
-        error: { 
+				success: false,
-          code: 'TASK_NOT_FOUND', 
+				error: {
-          message: `Task with ID ${taskId} not found` 
+					code: 'TASK_COMPLETED',
-        }, 
+					message: `Task ${taskId} is already marked as ${task.status} and cannot be expanded`
-        fromCache: false
+				},
-      };
+				fromCache: false
-    }
+			};
+		}
 
-    // Check if task is completed
+		// Check for existing subtasks
-    if (task.status === 'done' || task.status === 'completed') {
+		const hasExistingSubtasks = task.subtasks && task.subtasks.length > 0;
-      return { 
-        success: false, 
-        error: { 
-          code: 'TASK_COMPLETED', 
-          message: `Task ${taskId} is already marked as ${task.status} and cannot be expanded` 
-        }, 
-        fromCache: false
-      };
-    }
 
-    // Check for existing subtasks
+		// If the task already has subtasks, just return it (matching core behavior)
-    const hasExistingSubtasks = task.subtasks && task.subtasks.length > 0;
+		if (hasExistingSubtasks) {
+			log.info(`Task ${taskId} already has ${task.subtasks.length} subtasks`);
+			return {
+				success: true,
+				data: {
+					task,
+					subtasksAdded: 0,
+					hasExistingSubtasks
+				},
+				fromCache: false
+			};
+		}
 
-    // If the task already has subtasks, just return it (matching core behavior)
+		// Keep a copy of the task before modification
-    if (hasExistingSubtasks) {
+		const originalTask = JSON.parse(JSON.stringify(task));
-      log.info(`Task ${taskId} already has ${task.subtasks.length} subtasks`);
-      return { 
-        success: true, 
-        data: { 
-          task,
-          subtasksAdded: 0,
-          hasExistingSubtasks
-        }, 
-        fromCache: false 
-      };
-    }
 
-    // Keep a copy of the task before modification
+		// Tracking subtasks count before expansion
-    const originalTask = JSON.parse(JSON.stringify(task));
+		const subtasksCountBefore = task.subtasks ? task.subtasks.length : 0;
 
-    // Tracking subtasks count before expansion
+		// Create a backup of the tasks.json file
-    const subtasksCountBefore = task.subtasks ? task.subtasks.length : 0;
+		const backupPath = path.join(path.dirname(tasksPath), 'tasks.json.bak');
+		fs.copyFileSync(tasksPath, backupPath);
 
-    // Create a backup of the tasks.json file
+		// Directly modify the data instead of calling the CLI function
-    const backupPath = path.join(path.dirname(tasksPath), 'tasks.json.bak');
+		if (!task.subtasks) {
-    fs.copyFileSync(tasksPath, backupPath);
+			task.subtasks = [];
+		}
 
-    // Directly modify the data instead of calling the CLI function
+		// Save tasks.json with potentially empty subtasks array
-    if (!task.subtasks) {
+		writeJSON(tasksPath, data);
-      task.subtasks = [];
-    }
 
-    // Save tasks.json with potentially empty subtasks array
+		// Process the request
-    writeJSON(tasksPath, data);
+		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
 
-    // Process the request
+			// Call expandTask with session context to ensure AI client is properly initialized
-    try {
+			const result = await expandTask(
-      // Enable silent mode to prevent console logs from interfering with JSON response
+				tasksPath,
-      enableSilentMode();
+				taskId,
+				numSubtasks,
+				useResearch,
+				additionalContext,
+				{ mcpLog: log, session } // Only pass mcpLog and session, NOT reportProgress
+			);
 
-      // Call expandTask with session context to ensure AI client is properly initialized
+			// Restore normal logging
-      const result = await expandTask(
+			disableSilentMode();
-        tasksPath,
-        taskId, 
-        numSubtasks, 
-        useResearch, 
-        additionalContext, 
-        { mcpLog: log, session } // Only pass mcpLog and session, NOT reportProgress
-      );
 
-      // Restore normal logging
+			// Read the updated data
-      disableSilentMode();
+			const updatedData = readJSON(tasksPath);
+			const updatedTask = updatedData.tasks.find((t) => t.id === taskId);
 
-      // Read the updated data
+			// Calculate how many subtasks were added
-      const updatedData = readJSON(tasksPath);
+			const subtasksAdded = updatedTask.subtasks
-      const updatedTask = updatedData.tasks.find(t => t.id === taskId);
+				? updatedTask.subtasks.length - subtasksCountBefore
+				: 0;
 
-      // Calculate how many subtasks were added
+			// Return the result
-      const subtasksAdded = updatedTask.subtasks ? 
+			log.info(
-        updatedTask.subtasks.length - subtasksCountBefore : 0;
+				`Successfully expanded task ${taskId} with ${subtasksAdded} new subtasks`
+			);
+			return {
+				success: true,
+				data: {
+					task: updatedTask,
+					subtasksAdded,
+					hasExistingSubtasks
+				},
+				fromCache: false
+			};
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
 
-      // Return the result
+			log.error(`Error expanding task: ${error.message}`);
-      log.info(`Successfully expanded task ${taskId} with ${subtasksAdded} new subtasks`);
+			return {
-      return { 
+				success: false,
-        success: true, 
+				error: {
-        data: { 
+					code: 'CORE_FUNCTION_ERROR',
-          task: updatedTask,
+					message: error.message || 'Failed to expand task'
-          subtasksAdded,
+				},
-          hasExistingSubtasks
+				fromCache: false
-        }, 
+			};
-        fromCache: false 
+		}
-      };
+	} catch (error) {
-    } catch (error) {
+		log.error(`Error expanding task: ${error.message}`);
-      // Make sure to restore normal logging even if there's an error
+		return {
-      disableSilentMode();
+			success: false,
-      
+			error: {
-      log.error(`Error expanding task: ${error.message}`);
+				code: 'CORE_FUNCTION_ERROR',
-      return { 
+				message: error.message || 'Failed to expand task'
-        success: false, 
+			},
-        error: { 
+			fromCache: false
-          code: 'CORE_FUNCTION_ERROR', 
+		};
-          message: error.message || 'Failed to expand task' 
+	}
-        }, 
-        fromCache: false 
-      };
-    }
-  } catch (error) {
-    log.error(`Error expanding task: ${error.message}`);
-    return { 
-      success: false, 
-      error: { 
-        code: 'CORE_FUNCTION_ERROR', 
-        message: error.message || 'Failed to expand task' 
-      }, 
-      fromCache: false 
-    };
-  }
 }

mcp-server/src/core/direct-functions/fix-dependencies.js

@@ -4,7 +4,10 @@
 
 import { fixDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import fs from 'fs';
 
 /**
@@ -15,51 +18,51 @@ import fs from 'fs';
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function fixDependenciesDirect(args, log) {
+export async function fixDependenciesDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Fixing invalid dependencies in tasks...`);
+		log.info(`Fixing invalid dependencies in tasks...`);
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Verify the file exists
+		// Verify the file exists
-    if (!fs.existsSync(tasksPath)) {
+		if (!fs.existsSync(tasksPath)) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'FILE_NOT_FOUND',
+					code: 'FILE_NOT_FOUND',
-          message: `Tasks file not found at ${tasksPath}`
+					message: `Tasks file not found at ${tasksPath}`
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Call the original command function
+		// Call the original command function
-    await fixDependenciesCommand(tasksPath);
+		await fixDependenciesCommand(tasksPath);
 
-    // Restore normal logging
+		// Restore normal logging
-    disableSilentMode();
+		disableSilentMode();
 
-    return {
+		return {
-      success: true,
+			success: true,
-      data: {
+			data: {
-        message: 'Dependencies fixed successfully',
+				message: 'Dependencies fixed successfully',
-        tasksPath
+				tasksPath
-      }
+			}
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Make sure to restore normal logging even if there's an error
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error fixing dependencies: ${error.message}`);
+		log.error(`Error fixing dependencies: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'FIX_DEPENDENCIES_ERROR',
+				code: 'FIX_DEPENDENCIES_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/generate-task-files.js

@@ -4,7 +4,10 @@
  */
 
 import { generateTaskFiles } from '../../../../scripts/modules/task-manager.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
 import path from 'path';
 
@@ -15,73 +18,77 @@ import path from 'path';
  * @param {Object} log - Logger object.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
-export async function generateTaskFilesDirect(args, log) {
+export async function generateTaskFilesDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Generating task files with args: ${JSON.stringify(args)}`);
+		log.info(`Generating task files with args: ${JSON.stringify(args)}`);
 
-    // Get tasks file path
+		// Get tasks file path
-    let tasksPath;
+		let tasksPath;
-    try {
+		try {
-      tasksPath = findTasksJsonPath(args, log);
+			tasksPath = findTasksJsonPath(args, log, session);
-    } catch (error) {
+		} catch (error) {
-      log.error(`Error finding tasks file: ${error.message}`);
+			log.error(`Error finding tasks file: ${error.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { code: 'TASKS_FILE_ERROR', message: error.message },
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    // Get output directory (defaults to the same directory as the tasks file)
+		// Get output directory (defaults to the same directory as the tasks file)
-    let outputDir = args.output;
+		let outputDir = args.output;
-    if (!outputDir) {
+		if (!outputDir) {
-      outputDir = path.dirname(tasksPath);
+			outputDir = path.dirname(tasksPath);
-    }
+		}
 
-    log.info(`Generating task files from ${tasksPath} to ${outputDir}`);
+		log.info(`Generating task files from ${tasksPath} to ${outputDir}`);
 
-    // Execute core generateTaskFiles function in a separate try/catch
+		// Execute core generateTaskFiles function in a separate try/catch
-    try {
+		try {
-      // Enable silent mode to prevent logs from being written to stdout
+			// Enable silent mode to prevent logs from being written to stdout
-      enableSilentMode();
+			enableSilentMode();
 
-      // The function is synchronous despite being awaited elsewhere
+			// The function is synchronous despite being awaited elsewhere
-      generateTaskFiles(tasksPath, outputDir);
+			generateTaskFiles(tasksPath, outputDir);
 
-      // Restore normal logging after task generation
+			// Restore normal logging after task generation
-      disableSilentMode();
+			disableSilentMode();
-    } catch (genError) {
+		} catch (genError) {
-      // Make sure to restore normal logging even if there's an error
+			// Make sure to restore normal logging even if there's an error
-      disableSilentMode();
+			disableSilentMode();
 
-      log.error(`Error in generateTaskFiles: ${genError.message}`);
+			log.error(`Error in generateTaskFiles: ${genError.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { code: 'GENERATE_FILES_ERROR', message: genError.message },
+				error: { code: 'GENERATE_FILES_ERROR', message: genError.message },
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    // Return success with file paths
+		// Return success with file paths
-    return {
+		return {
-      success: true,
+			success: true,
-      data: {
+			data: {
-        message: `Successfully generated task files`,
+				message: `Successfully generated task files`,
-        tasksPath,
+				tasksPath,
-        outputDir,
+				outputDir,
-        taskFiles: 'Individual task files have been generated in the output directory'
+				taskFiles:
-      },
+					'Individual task files have been generated in the output directory'
-      fromCache: false // This operation always modifies state and should never be cached
+			},
-    };
+			fromCache: false // This operation always modifies state and should never be cached
-  } catch (error) {
+		};
-    // Make sure to restore normal logging if an outer error occurs
+	} catch (error) {
-    disableSilentMode();
+		// Make sure to restore normal logging if an outer error occurs
+		disableSilentMode();
 
-    log.error(`Error generating task files: ${error.message}`);
+		log.error(`Error generating task files: ${error.message}`);
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { code: 'GENERATE_TASKS_ERROR', message: error.message || 'Unknown error generating task files' },
+			error: {
-      fromCache: false 
+				code: 'GENERATE_TASKS_ERROR',
-    };
+				message: error.message || 'Unknown error generating task files'
-  }
+			},
+			fromCache: false
+		};
+	}
 }

mcp-server/src/core/direct-functions/initialize-project-direct.js

@@ -0,0 +1,138 @@
+import path from 'path';
+import { initializeProject, log as initLog } from '../../../../scripts/init.js'; // Import core function and its logger if needed separately
+import {
+	enableSilentMode,
+	disableSilentMode
+	// isSilentMode // Not used directly here
+} from '../../../../scripts/modules/utils.js';
+import { getProjectRootFromSession } from '../../tools/utils.js'; // Adjust path if necessary
+import os from 'os'; // Import os module for home directory check
+
+/**
+ * Direct function wrapper for initializing a project.
+ * Derives target directory from session, sets CWD, and calls core init logic.
+ * @param {object} args - Arguments containing project details and options (projectName, projectDescription, yes, etc.)
+ * @param {object} log - The FastMCP logger instance.
+ * @param {object} context - The context object, must contain { session }.
+ * @returns {Promise<{success: boolean, data?: any, error?: {code: string, message: string}}>} - Standard result object.
+ */
+export async function initializeProjectDirect(args, log, { session }) {
+	const homeDir = os.homedir();
+	let targetDirectory = null;
+
+	log.info(
+		`CONTEXT received in direct function: ${context ? JSON.stringify(Object.keys(context)) : 'MISSING or Falsy'}`
+	);
+	log.info(
+		`SESSION extracted in direct function: ${session ? 'Exists' : 'MISSING or Falsy'}`
+	);
+	log.info(`Args received in direct function: ${JSON.stringify(args)}`);
+
+	// --- Determine Target Directory ---
+	// 1. Prioritize projectRoot passed directly in args
+	// Ensure it's not null, '/', or the home directory
+	if (
+		args.projectRoot &&
+		args.projectRoot !== '/' &&
+		args.projectRoot !== homeDir
+	) {
+		log.info(`Using projectRoot directly from args: ${args.projectRoot}`);
+		targetDirectory = args.projectRoot;
+	} else {
+		// 2. If args.projectRoot is missing or invalid, THEN try session (as a fallback)
+		log.warn(
+			`args.projectRoot ('${args.projectRoot}') is missing or invalid. Attempting to derive from session.`
+		);
+		const sessionDerivedPath = getProjectRootFromSession(session, log);
+		// Validate the session-derived path as well
+		if (
+			sessionDerivedPath &&
+			sessionDerivedPath !== '/' &&
+			sessionDerivedPath !== homeDir
+		) {
+			log.info(
+				`Using project root derived from session: ${sessionDerivedPath}`
+			);
+			targetDirectory = sessionDerivedPath;
+		} else {
+			log.error(
+				`Could not determine a valid project root. args.projectRoot='${args.projectRoot}', sessionDerivedPath='${sessionDerivedPath}'`
+			);
+		}
+	}
+
+	// 3. Validate the final targetDirectory
+	if (!targetDirectory) {
+		// This error now covers cases where neither args.projectRoot nor session provided a valid path
+		return {
+			success: false,
+			error: {
+				code: 'INVALID_TARGET_DIRECTORY',
+				message: `Cannot initialize project: Could not determine a valid target directory. Please ensure a workspace/folder is open or specify projectRoot.`,
+				details: `Attempted args.projectRoot: ${args.projectRoot}`
+			},
+			fromCache: false
+		};
+	}
+
+	// --- Proceed with validated targetDirectory ---
+	log.info(`Validated target directory for initialization: ${targetDirectory}`);
+
+	const originalCwd = process.cwd();
+	let resultData;
+	let success = false;
+	let errorResult = null;
+
+	log.info(
+		`Temporarily changing CWD to ${targetDirectory} for initialization.`
+	);
+	process.chdir(targetDirectory); // Change CWD to the *validated* targetDirectory
+
+	enableSilentMode(); // Enable silent mode BEFORE calling the core function
+	try {
+		// Always force yes: true when called via MCP to avoid interactive prompts
+		const options = {
+			name: args.projectName,
+			description: args.projectDescription,
+			version: args.projectVersion,
+			author: args.authorName,
+			skipInstall: args.skipInstall,
+			aliases: args.addAliases,
+			yes: true // Force yes mode
+		};
+
+		log.info(`Initializing project with options: ${JSON.stringify(options)}`);
+		const result = await initializeProject(options); // Call core logic
+
+		// Format success result for handleApiResult
+		resultData = {
+			message: 'Project initialized successfully.',
+			next_step:
+				'Now that the project is initialized, the next step is to create the tasks by parsing a PRD. This will create the tasks folder and the initial task files (tasks folder will be created when parse-prd is run). The parse-prd tool will require a prd.txt file as input (typically found in the project root directory, scripts/ directory). You can create a prd.txt file by asking the user about their idea, and then using the scripts/example_prd.txt file as a template to genrate a prd.txt file in scripts/. You may skip all of this if the user already has a prd.txt file. You can THEN use the parse-prd tool to create the tasks. So: step 1 after initialization is to create a prd.txt file in scripts/prd.txt or confirm the user already has one. Step 2 is to use the parse-prd tool to create the tasks. Do not bother looking for tasks after initialization, just use the parse-prd tool to create the tasks after creating a prd.txt from which to parse the tasks. You do NOT need to reinitialize the project to parse-prd.',
+			...result // Include details returned by initializeProject
+		};
+		success = true;
+		log.info(
+			`Project initialization completed successfully in ${targetDirectory}.`
+		);
+	} catch (error) {
+		log.error(`Core initializeProject failed: ${error.message}`);
+		errorResult = {
+			code: 'INITIALIZATION_FAILED',
+			message: `Core project initialization failed: ${error.message}`,
+			details: error.stack
+		};
+		success = false;
+	} finally {
+		disableSilentMode(); // ALWAYS disable silent mode in finally
+		log.info(`Restoring original CWD: ${originalCwd}`);
+		process.chdir(originalCwd); // Change back to original CWD
+	}
+
+	// Return in format expected by handleApiResult
+	if (success) {
+		return { success: true, data: resultData, fromCache: false };
+	} else {
+		return { success: false, error: errorResult, fromCache: false };
+	}
+}

mcp-server/src/core/direct-functions/list-tasks.js

@@ -6,7 +6,10 @@
 import { listTasks } from '../../../../scripts/modules/task-manager.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Direct function wrapper for listTasks with error handling and caching.
@@ -15,69 +18,103 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object.
  * @returns {Promise<Object>} - Task list result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }.
  */
-export async function listTasksDirect(args, log) {
+export async function listTasksDirect(args, log, { session }) {
-  let tasksPath;
+	let tasksPath;
-  try {
+	try {
-    // Find the tasks path first - needed for cache key and execution
+		// Find the tasks path first - needed for cache key and execution
-    tasksPath = findTasksJsonPath(args, log);
+		tasksPath = findTasksJsonPath(args, log, session);
-  } catch (error) {
+	} catch (error) {
-    if (error.code === 'TASKS_FILE_NOT_FOUND') {
+		if (error.code === 'TASKS_FILE_NOT_FOUND') {
-      log.error(`Tasks file not found: ${error.message}`);
+			log.error(`Tasks file not found: ${error.message}`);
-      // Return the error structure expected by the calling tool/handler
+			// Return the error structure expected by the calling tool/handler
-      return { success: false, error: { code: error.code, message: error.message }, fromCache: false };
+			return {
-    }
+				success: false,
-    log.error(`Unexpected error finding tasks file: ${error.message}`);
+				error: { code: error.code, message: error.message },
-    // Re-throw for outer catch or return structured error
+				fromCache: false
-     return { success: false, error: { code: 'FIND_TASKS_PATH_ERROR', message: error.message }, fromCache: false };
+			};
-  }
+		}
+		log.error(`Unexpected error finding tasks file: ${error.message}`);
+		// Re-throw for outer catch or return structured error
+		return {
+			success: false,
+			error: { code: 'FIND_TASKS_PATH_ERROR', message: error.message },
+			fromCache: false
+		};
+	}
 
-  // Generate cache key *after* finding tasksPath
+	// Generate cache key *after* finding tasksPath
-  const statusFilter = args.status || 'all';
+	const statusFilter = args.status || 'all';
-  const withSubtasks = args.withSubtasks || false;
+	const withSubtasks = args.withSubtasks || false;
-  const cacheKey = `listTasks:${tasksPath}:${statusFilter}:${withSubtasks}`;
+	const cacheKey = `listTasks:${tasksPath}:${statusFilter}:${withSubtasks}`;
 
-  // Define the action function to be executed on cache miss
+	// Define the action function to be executed on cache miss
-  const coreListTasksAction = async () => {
+	const coreListTasksAction = async () => {
-    try {
+		try {
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			// Enable silent mode to prevent console logs from interfering with JSON response
-      enableSilentMode();
+			enableSilentMode();
 
-      log.info(`Executing core listTasks function for path: ${tasksPath}, filter: ${statusFilter}, subtasks: ${withSubtasks}`);
+			log.info(
-      const resultData = listTasks(tasksPath, statusFilter, withSubtasks, 'json');
+				`Executing core listTasks function for path: ${tasksPath}, filter: ${statusFilter}, subtasks: ${withSubtasks}`
+			);
+			const resultData = listTasks(
+				tasksPath,
+				statusFilter,
+				withSubtasks,
+				'json'
+			);
 
-      if (!resultData || !resultData.tasks) {
+			if (!resultData || !resultData.tasks) {
-        log.error('Invalid or empty response from listTasks core function');
+				log.error('Invalid or empty response from listTasks core function');
-        return { success: false, error: { code: 'INVALID_CORE_RESPONSE', message: 'Invalid or empty response from listTasks core function' } };
+				return {
-      }
+					success: false,
-      log.info(`Core listTasks function retrieved ${resultData.tasks.length} tasks`);
+					error: {
+						code: 'INVALID_CORE_RESPONSE',
+						message: 'Invalid or empty response from listTasks core function'
+					}
+				};
+			}
+			log.info(
+				`Core listTasks function retrieved ${resultData.tasks.length} tasks`
+			);
 
-      // Restore normal logging
+			// Restore normal logging
-      disableSilentMode();
+			disableSilentMode();
 
-      return { success: true, data: resultData };
+			return { success: true, data: resultData };
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
 
-    } catch (error) {
+			log.error(`Core listTasks function failed: ${error.message}`);
-      // Make sure to restore normal logging even if there's an error
+			return {
-      disableSilentMode();
+				success: false,
+				error: {
+					code: 'LIST_TASKS_CORE_ERROR',
+					message: error.message || 'Failed to list tasks'
+				}
+			};
+		}
+	};
 
-      log.error(`Core listTasks function failed: ${error.message}`);
+	// Use the caching utility
-      return { success: false, error: { code: 'LIST_TASKS_CORE_ERROR', message: error.message || 'Failed to list tasks' } };
+	try {
-    }
+		const result = await getCachedOrExecute({
-  };
+			cacheKey,
-
+			actionFn: coreListTasksAction,
-  // Use the caching utility
+			log
-  try {
+		});
-      const result = await getCachedOrExecute({
+		log.info(`listTasksDirect completed. From cache: ${result.fromCache}`);
-          cacheKey,
+		return result; // Returns { success, data/error, fromCache }
-          actionFn: coreListTasksAction,
+	} catch (error) {
-          log
+		// Catch unexpected errors from getCachedOrExecute itself (though unlikely)
-      });
+		log.error(
-      log.info(`listTasksDirect completed. From cache: ${result.fromCache}`);
+			`Unexpected error during getCachedOrExecute for listTasks: ${error.message}`
-      return result; // Returns { success, data/error, fromCache }
+		);
-  } catch(error) {
+		console.error(error.stack);
-      // Catch unexpected errors from getCachedOrExecute itself (though unlikely)
+		return {
-      log.error(`Unexpected error during getCachedOrExecute for listTasks: ${error.message}`);
+			success: false,
-      console.error(error.stack);
+			error: { code: 'CACHE_UTIL_ERROR', message: error.message },
-      return { success: false, error: { code: 'CACHE_UTIL_ERROR', message: error.message }, fromCache: false };
+			fromCache: false
-  }
+		};
+	}
 }

mcp-server/src/core/direct-functions/next-task.js

@@ -7,7 +7,10 @@ import { findNextTask } from '../../../../scripts/modules/task-manager.js';
 import { readJSON } from '../../../../scripts/modules/utils.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Direct function wrapper for finding the next task to work on with error handling and caching.
@@ -16,107 +19,114 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Next task result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
-export async function nextTaskDirect(args, log) {
+export async function nextTaskDirect(args, log, { session }) {
-  let tasksPath;
+	let tasksPath;
-  try {
+	try {
-    // Find the tasks path first - needed for cache key and execution
+		// Find the tasks path first - needed for cache key and execution
-    tasksPath = findTasksJsonPath(args, log);
+		tasksPath = findTasksJsonPath(args, log, session);
-  } catch (error) {
+	} catch (error) {
-    log.error(`Tasks file not found: ${error.message}`);
+		log.error(`Tasks file not found: ${error.message}`);
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { 
+			error: {
-        code: 'FILE_NOT_FOUND_ERROR', 
+				code: 'FILE_NOT_FOUND_ERROR',
-        message: error.message 
+				message: error.message
-      }, 
+			},
-      fromCache: false 
+			fromCache: false
-    };
+		};
-  }
+	}
 
-  // Generate cache key using task path
+	// Generate cache key using task path
-  const cacheKey = `nextTask:${tasksPath}`;
+	const cacheKey = `nextTask:${tasksPath}`;
 
-  // Define the action function to be executed on cache miss
+	// Define the action function to be executed on cache miss
-  const coreNextTaskAction = async () => {
+	const coreNextTaskAction = async () => {
-    try {
+		try {
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			// Enable silent mode to prevent console logs from interfering with JSON response
-      enableSilentMode();
+			enableSilentMode();
 
-      log.info(`Finding next task from ${tasksPath}`);
+			log.info(`Finding next task from ${tasksPath}`);
 
-      // Read tasks data
+			// Read tasks data
-      const data = readJSON(tasksPath);
+			const data = readJSON(tasksPath);
-      if (!data || !data.tasks) {
+			if (!data || !data.tasks) {
-        return { 
+				return {
-          success: false, 
+					success: false,
-          error: { 
+					error: {
-            code: 'INVALID_TASKS_FILE', 
+						code: 'INVALID_TASKS_FILE',
-            message: `No valid tasks found in ${tasksPath}` 
+						message: `No valid tasks found in ${tasksPath}`
-          } 
+					}
-        };
+				};
-      }
+			}
 
-      // Find the next task
+			// Find the next task
-      const nextTask = findNextTask(data.tasks);
+			const nextTask = findNextTask(data.tasks);
 
-      if (!nextTask) {
+			if (!nextTask) {
-        log.info('No eligible next task found. All tasks are either completed or have unsatisfied dependencies');
+				log.info(
-        return { 
+					'No eligible next task found. All tasks are either completed or have unsatisfied dependencies'
-          success: true, 
+				);
-          data: { 
+				return {
-            message: 'No eligible next task found. All tasks are either completed or have unsatisfied dependencies',
+					success: true,
-            nextTask: null,
+					data: {
-            allTasks: data.tasks 
+						message:
-          } 
+							'No eligible next task found. All tasks are either completed or have unsatisfied dependencies',
-        };
+						nextTask: null,
-      }
+						allTasks: data.tasks
+					}
+				};
+			}
 
-      // Restore normal logging
+			// Restore normal logging
-      disableSilentMode();
+			disableSilentMode();
 
-      // Return the next task data with the full tasks array for reference
+			// Return the next task data with the full tasks array for reference
-      log.info(`Successfully found next task ${nextTask.id}: ${nextTask.title}`);
+			log.info(
-      return { 
+				`Successfully found next task ${nextTask.id}: ${nextTask.title}`
-        success: true, 
+			);
-        data: { 
+			return {
-          nextTask, 
+				success: true,
-          allTasks: data.tasks 
+				data: {
-        } 
+					nextTask,
-      };
+					allTasks: data.tasks
-    } catch (error) {
+				}
-      // Make sure to restore normal logging even if there's an error
+			};
-      disableSilentMode();
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
 
-      log.error(`Error finding next task: ${error.message}`);
+			log.error(`Error finding next task: ${error.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { 
+				error: {
-          code: 'CORE_FUNCTION_ERROR', 
+					code: 'CORE_FUNCTION_ERROR',
-          message: error.message || 'Failed to find next task' 
+					message: error.message || 'Failed to find next task'
-        } 
+				}
-      };
+			};
-    }
+		}
-  };
+	};
 
-  // Use the caching utility
+	// Use the caching utility
-  try {
+	try {
-    const result = await getCachedOrExecute({
+		const result = await getCachedOrExecute({
-      cacheKey,
+			cacheKey,
-      actionFn: coreNextTaskAction,
+			actionFn: coreNextTaskAction,
-      log
+			log
-    });
+		});
-    log.info(`nextTaskDirect completed. From cache: ${result.fromCache}`);
+		log.info(`nextTaskDirect completed. From cache: ${result.fromCache}`);
-    return result; // Returns { success, data/error, fromCache }
+		return result; // Returns { success, data/error, fromCache }
-  } catch (error) {
+	} catch (error) {
-    // Catch unexpected errors from getCachedOrExecute itself
+		// Catch unexpected errors from getCachedOrExecute itself
-    log.error(`Unexpected error during getCachedOrExecute for nextTask: ${error.message}`);
+		log.error(
-    return { 
+			`Unexpected error during getCachedOrExecute for nextTask: ${error.message}`
-      success: false, 
+		);
-      error: { 
+		return {
-        code: 'UNEXPECTED_ERROR', 
+			success: false,
-        message: error.message 
+			error: {
-      }, 
+				code: 'UNEXPECTED_ERROR',
-      fromCache: false 
+				message: error.message
-    };
+			},
-  }
+			fromCache: false
+		};
+	}
 }

mcp-server/src/core/direct-functions/parse-prd.js

@@ -5,10 +5,17 @@
 
 import path from 'path';
 import fs from 'fs';
+import os from 'os'; // Import os module for home directory check
 import { parsePRD } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
-import { getAnthropicClientForMCP, getModelConfig } from '../utils/ai-client-utils.js';
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import {
+	getAnthropicClientForMCP,
+	getModelConfig
+} from '../utils/ai-client-utils.js';
 
 /**
  * Direct function wrapper for parsing PRD documents and generating tasks.
@@ -19,132 +26,206 @@ import { getAnthropicClientForMCP, getModelConfig } from '../utils/ai-client-uti
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
 export async function parsePRDDirect(args, log, context = {}) {
-  const { session } = context; // Only extract session, not reportProgress
+	const { session } = context; // Only extract session, not reportProgress
 
-  try {
+	try {
-    log.info(`Parsing PRD document with args: ${JSON.stringify(args)}`);
+		log.info(`Parsing PRD document with args: ${JSON.stringify(args)}`);
 
-    // Initialize AI client for PRD parsing
+		// Initialize AI client for PRD parsing
-    let aiClient;
+		let aiClient;
-    try {
+		try {
-      aiClient = getAnthropicClientForMCP(session, log);
+			aiClient = getAnthropicClientForMCP(session, log);
-    } catch (error) {
+		} catch (error) {
-      log.error(`Failed to initialize AI client: ${error.message}`);
+			log.error(`Failed to initialize AI client: ${error.message}`);
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'AI_CLIENT_ERROR',
+					code: 'AI_CLIENT_ERROR',
-          message: `Cannot initialize AI client: ${error.message}`
+					message: `Cannot initialize AI client: ${error.message}`
-        },
+				},
-        fromCache: false
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    // Parameter validation and path resolution
+		// --- Parameter validation and path resolution ---
-    if (!args.input) {
+		if (!args.input) {
-      const errorMessage = 'No input file specified. Please provide an input PRD document path.';
+			const errorMessage =
-      log.error(errorMessage);
+				'No input file specified. Please provide an input PRD document path.';
-      return { 
+			log.error(errorMessage);
-        success: false, 
+			return {
-        error: { code: 'MISSING_INPUT_FILE', message: errorMessage },
+				success: false,
-        fromCache: false 
+				error: { code: 'MISSING_INPUT_FILE', message: errorMessage },
-      };
+				fromCache: false
-    }
+			};
+		}
 
-    // Resolve input path (relative to project root if provided)
+		// Validate projectRoot
-    const projectRoot = args.projectRoot || process.cwd();
+		if (!args.projectRoot) {
-    const inputPath = path.isAbsolute(args.input) ? args.input : path.resolve(projectRoot, args.input);
+			const errorMessage = 'Project root is required but was not provided';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_PROJECT_ROOT', message: errorMessage },
+				fromCache: false
+			};
+		}
 
-    // Determine output path
+		const homeDir = os.homedir();
-    let outputPath;
+		// Disallow invalid projectRoot values
-    if (args.output) {
+		if (args.projectRoot === '/' || args.projectRoot === homeDir) {
-      outputPath = path.isAbsolute(args.output) ? args.output : path.resolve(projectRoot, args.output);
+			const errorMessage = `Invalid project root: ${args.projectRoot}. Cannot use root or home directory.`;
-    } else {
+			log.error(errorMessage);
-      // Default to tasks/tasks.json in the project root
+			return {
-      outputPath = path.resolve(projectRoot, 'tasks', 'tasks.json');
+				success: false,
-    }
+				error: { code: 'INVALID_PROJECT_ROOT', message: errorMessage },
+				fromCache: false
+			};
+		}
 
-    // Verify input file exists
+		// Resolve input path (relative to validated project root)
-    if (!fs.existsSync(inputPath)) {
+		const projectRoot = args.projectRoot;
-      const errorMessage = `Input file not found: ${inputPath}`;
+		log.info(`Using validated project root: ${projectRoot}`);
-      log.error(errorMessage);
-      return { 
-        success: false, 
-        error: { code: 'INPUT_FILE_NOT_FOUND', message: errorMessage },
-        fromCache: false 
-      };
-    }
 
-    // Parse number of tasks - handle both string and number values
+		// Make sure the project root directory exists
-    let numTasks = 10; // Default
+		if (!fs.existsSync(projectRoot)) {
-    if (args.numTasks) {
+			const errorMessage = `Project root directory does not exist: ${projectRoot}`;
-      numTasks = typeof args.numTasks === 'string' ? parseInt(args.numTasks, 10) : args.numTasks;
+			log.error(errorMessage);
-      if (isNaN(numTasks)) {
+			return {
-        numTasks = 10; // Fallback to default if parsing fails
+				success: false,
-        log.warn(`Invalid numTasks value: ${args.numTasks}. Using default: 10`);
+				error: { code: 'PROJECT_ROOT_NOT_FOUND', message: errorMessage },
-      }
+				fromCache: false
-    }
+			};
+		}
 
-    log.info(`Preparing to parse PRD from ${inputPath} and output to ${outputPath} with ${numTasks} tasks`);
+		// Resolve input path relative to validated project root
+		const inputPath = path.isAbsolute(args.input)
+			? args.input
+			: path.resolve(projectRoot, args.input);
 
-    // Create the logger wrapper for proper logging in the core function
+		log.info(`Resolved input path: ${inputPath}`);
-    const logWrapper = {
-      info: (message, ...args) => log.info(message, ...args),
-      warn: (message, ...args) => log.warn(message, ...args),
-      error: (message, ...args) => log.error(message, ...args),
-      debug: (message, ...args) => log.debug && log.debug(message, ...args),
-      success: (message, ...args) => log.info(message, ...args) // Map success to info
-    };
 
-    // Get model config from session
+		// Determine output path
-    const modelConfig = getModelConfig(session);
+		let outputPath;
+		if (args.output) {
+			outputPath = path.isAbsolute(args.output)
+				? args.output
+				: path.resolve(projectRoot, args.output);
+		} else {
+			// Default to tasks/tasks.json in the project root
+			outputPath = path.resolve(projectRoot, 'tasks', 'tasks.json');
+		}
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		log.info(`Resolved output path: ${outputPath}`);
-    enableSilentMode();
-    try {
-      // Execute core parsePRD function with AI client
-      await parsePRD(inputPath, outputPath, numTasks, { 
-        mcpLog: logWrapper, 
-        session 
-      }, aiClient, modelConfig);
 
-      // Since parsePRD doesn't return a value but writes to a file, we'll read the result
+		// Verify input file exists
-      // to return it to the caller
+		if (!fs.existsSync(inputPath)) {
-      if (fs.existsSync(outputPath)) {
+			const errorMessage = `Input file not found: ${inputPath}`;
-        const tasksData = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+			log.error(errorMessage);
-        log.info(`Successfully parsed PRD and generated ${tasksData.tasks?.length || 0} tasks`);
+			return {
+				success: false,
+				error: {
+					code: 'INPUT_FILE_NOT_FOUND',
+					message: errorMessage,
+					details: `Checked path: ${inputPath}\nProject root: ${projectRoot}\nInput argument: ${args.input}`
+				},
+				fromCache: false
+			};
+		}
 
-        return {
+		// Parse number of tasks - handle both string and number values
-          success: true,
+		let numTasks = 10; // Default
-          data: {
+		if (args.numTasks) {
-            message: `Successfully generated ${tasksData.tasks?.length || 0} tasks from PRD`,
+			numTasks =
-            taskCount: tasksData.tasks?.length || 0,
+				typeof args.numTasks === 'string'
-            outputPath
+					? parseInt(args.numTasks, 10)
-          },
+					: args.numTasks;
-          fromCache: false // This operation always modifies state and should never be cached
+			if (isNaN(numTasks)) {
-        };
+				numTasks = 10; // Fallback to default if parsing fails
-      } else {
+				log.warn(`Invalid numTasks value: ${args.numTasks}. Using default: 10`);
-        const errorMessage = `Tasks file was not created at ${outputPath}`;
+			}
-        log.error(errorMessage);
+		}
-        return { 
-          success: false, 
-          error: { code: 'OUTPUT_FILE_NOT_CREATED', message: errorMessage },
-          fromCache: false 
-        };
-      }
-    } finally {
-      // Always restore normal logging
-      disableSilentMode();
-    }
-  } catch (error) {
-    // Make sure to restore normal logging even if there's an error
-    disableSilentMode();
 
-    log.error(`Error parsing PRD: ${error.message}`);
+		log.info(
-    return { 
+			`Preparing to parse PRD from ${inputPath} and output to ${outputPath} with ${numTasks} tasks`
-      success: false, 
+		);
-      error: { code: 'PARSE_PRD_ERROR', message: error.message || 'Unknown error parsing PRD' },
+
-      fromCache: false 
+		// Create the logger wrapper for proper logging in the core function
-    };
+		const logWrapper = {
-  }
+			info: (message, ...args) => log.info(message, ...args),
+			warn: (message, ...args) => log.warn(message, ...args),
+			error: (message, ...args) => log.error(message, ...args),
+			debug: (message, ...args) => log.debug && log.debug(message, ...args),
+			success: (message, ...args) => log.info(message, ...args) // Map success to info
+		};
+
+		// Get model config from session
+		const modelConfig = getModelConfig(session);
+
+		// Enable silent mode to prevent console logs from interfering with JSON response
+		enableSilentMode();
+		try {
+			// Make sure the output directory exists
+			const outputDir = path.dirname(outputPath);
+			if (!fs.existsSync(outputDir)) {
+				log.info(`Creating output directory: ${outputDir}`);
+				fs.mkdirSync(outputDir, { recursive: true });
+			}
+
+			// Execute core parsePRD function with AI client
+			await parsePRD(
+				inputPath,
+				outputPath,
+				numTasks,
+				{
+					mcpLog: logWrapper,
+					session
+				},
+				aiClient,
+				modelConfig
+			);
+
+			// Since parsePRD doesn't return a value but writes to a file, we'll read the result
+			// to return it to the caller
+			if (fs.existsSync(outputPath)) {
+				const tasksData = JSON.parse(fs.readFileSync(outputPath, 'utf8'));
+				log.info(
+					`Successfully parsed PRD and generated ${tasksData.tasks?.length || 0} tasks`
+				);
+
+				return {
+					success: true,
+					data: {
+						message: `Successfully generated ${tasksData.tasks?.length || 0} tasks from PRD`,
+						taskCount: tasksData.tasks?.length || 0,
+						outputPath
+					},
+					fromCache: false // This operation always modifies state and should never be cached
+				};
+			} else {
+				const errorMessage = `Tasks file was not created at ${outputPath}`;
+				log.error(errorMessage);
+				return {
+					success: false,
+					error: { code: 'OUTPUT_FILE_NOT_CREATED', message: errorMessage },
+					fromCache: false
+				};
+			}
+		} finally {
+			// Always restore normal logging
+			disableSilentMode();
+		}
+	} catch (error) {
+		// Make sure to restore normal logging even if there's an error
+		disableSilentMode();
+
+		log.error(`Error parsing PRD: ${error.message}`);
+		return {
+			success: false,
+			error: {
+				code: 'PARSE_PRD_ERROR',
+				message: error.message || 'Unknown error parsing PRD'
+			},
+			fromCache: false
+		};
+	}
 }

mcp-server/src/core/direct-functions/remove-dependency.js

@@ -4,7 +4,10 @@
 
 import { removeDependency } from '../../../../scripts/modules/dependency-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Remove a dependency from a task
@@ -16,68 +19,76 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function removeDependencyDirect(args, log) {
+export async function removeDependencyDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Removing dependency with args: ${JSON.stringify(args)}`);
+		log.info(`Removing dependency with args: ${JSON.stringify(args)}`);
 
-    // Validate required parameters
+		// Validate required parameters
-    if (!args.id) {
+		if (!args.id) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Task ID (id) is required'
+					message: 'Task ID (id) is required'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    if (!args.dependsOn) {
+		if (!args.dependsOn) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Dependency ID (dependsOn) is required'
+					message: 'Dependency ID (dependsOn) is required'
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Format IDs for the core function
+		// Format IDs for the core function
-    const taskId = args.id.includes && args.id.includes('.') ? args.id : parseInt(args.id, 10);
+		const taskId =
-    const dependencyId = args.dependsOn.includes && args.dependsOn.includes('.') ? args.dependsOn : parseInt(args.dependsOn, 10);
+			args.id.includes && args.id.includes('.')
+				? args.id
+				: parseInt(args.id, 10);
+		const dependencyId =
+			args.dependsOn.includes && args.dependsOn.includes('.')
+				? args.dependsOn
+				: parseInt(args.dependsOn, 10);
 
-    log.info(`Removing dependency: task ${taskId} no longer depends on ${dependencyId}`);
+		log.info(
+			`Removing dependency: task ${taskId} no longer depends on ${dependencyId}`
+		);
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Call the core function
+		// Call the core function
-    await removeDependency(tasksPath, taskId, dependencyId);
+		await removeDependency(tasksPath, taskId, dependencyId);
 
-    // Restore normal logging
+		// Restore normal logging
-    disableSilentMode();
+		disableSilentMode();
 
-    return {
+		return {
-      success: true,
+			success: true,
-      data: {
+			data: {
-        message: `Successfully removed dependency: Task ${taskId} no longer depends on ${dependencyId}`,
+				message: `Successfully removed dependency: Task ${taskId} no longer depends on ${dependencyId}`,
-        taskId: taskId,
+				taskId: taskId,
-        dependencyId: dependencyId
+				dependencyId: dependencyId
-      }
+			}
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Make sure to restore normal logging even if there's an error
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error in removeDependencyDirect: ${error.message}`);
+		log.error(`Error in removeDependencyDirect: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'CORE_FUNCTION_ERROR',
+				code: 'CORE_FUNCTION_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/remove-subtask.js

@@ -4,7 +4,10 @@
 
 import { removeSubtask } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Remove a subtask from its parent task
@@ -17,79 +20,87 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function removeSubtaskDirect(args, log) {
+export async function removeSubtaskDirect(args, log, { session }) {
-  try {
+	try {
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
+		log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
 
-    if (!args.id) {
+		if (!args.id) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Subtask ID is required and must be in format "parentId.subtaskId"'
+					message:
-        }
+						'Subtask ID is required and must be in format "parentId.subtaskId"'
-      };
+				}
-    }
+			};
+		}
 
-    // Validate subtask ID format
+		// Validate subtask ID format
-    if (!args.id.includes('.')) {
+		if (!args.id.includes('.')) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'INPUT_VALIDATION_ERROR',
+					code: 'INPUT_VALIDATION_ERROR',
-          message: `Invalid subtask ID format: ${args.id}. Expected format: "parentId.subtaskId"`
+					message: `Invalid subtask ID format: ${args.id}. Expected format: "parentId.subtaskId"`
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Convert convertToTask to a boolean
+		// Convert convertToTask to a boolean
-    const convertToTask = args.convert === true;
+		const convertToTask = args.convert === true;
 
-    // Determine if we should generate files
+		// Determine if we should generate files
-    const generateFiles = !args.skipGenerate;
+		const generateFiles = !args.skipGenerate;
 
-    log.info(`Removing subtask ${args.id} (convertToTask: ${convertToTask}, generateFiles: ${generateFiles})`);
+		log.info(
+			`Removing subtask ${args.id} (convertToTask: ${convertToTask}, generateFiles: ${generateFiles})`
+		);
 
-    const result = await removeSubtask(tasksPath, args.id, convertToTask, generateFiles);
+		const result = await removeSubtask(
+			tasksPath,
+			args.id,
+			convertToTask,
+			generateFiles
+		);
 
-    // Restore normal logging
+		// Restore normal logging
-    disableSilentMode();
+		disableSilentMode();
 
-    if (convertToTask && result) {
+		if (convertToTask && result) {
-      // Return info about the converted task
+			// Return info about the converted task
-      return {
+			return {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: `Subtask ${args.id} successfully converted to task #${result.id}`,
+					message: `Subtask ${args.id} successfully converted to task #${result.id}`,
-          task: result
+					task: result
-        }
+				}
-      };
+			};
-    } else {
+		} else {
-      // Return simple success message for deletion
+			// Return simple success message for deletion
-      return {
+			return {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: `Subtask ${args.id} successfully removed`
+					message: `Subtask ${args.id} successfully removed`
-        }
+				}
-      };
+			};
-    }
+		}
-  } catch (error) {
+	} catch (error) {
-    // Ensure silent mode is disabled even if an outer error occurs
+		// Ensure silent mode is disabled even if an outer error occurs
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error in removeSubtaskDirect: ${error.message}`);
+		log.error(`Error in removeSubtaskDirect: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'CORE_FUNCTION_ERROR',
+				code: 'CORE_FUNCTION_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/remove-task.js

@@ -4,7 +4,10 @@
  */
 
 import { removeTask } from '../../../../scripts/modules/task-manager.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
 
 /**
@@ -14,91 +17,91 @@ import { findTasksJsonPath } from '../utils/path-utils.js';
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Remove task result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: false }
  */
-export async function removeTaskDirect(args, log) {
+export async function removeTaskDirect(args, log, { session }) {
-  try {
+	try {
-    // Find the tasks path first
+		// Find the tasks path first
-    let tasksPath;
+		let tasksPath;
-    try {
+		try {
-      tasksPath = findTasksJsonPath(args, log);
+			tasksPath = findTasksJsonPath(args, log, session);
-    } catch (error) {
+		} catch (error) {
-      log.error(`Tasks file not found: ${error.message}`);
+			log.error(`Tasks file not found: ${error.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { 
+				error: {
-          code: 'FILE_NOT_FOUND_ERROR', 
+					code: 'FILE_NOT_FOUND_ERROR',
-          message: error.message 
+					message: error.message
-        }, 
+				},
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    // Validate task ID parameter
+		// Validate task ID parameter
-    const taskId = args.id;
+		const taskId = args.id;
-    if (!taskId) {
+		if (!taskId) {
-      log.error('Task ID is required');
+			log.error('Task ID is required');
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { 
+				error: {
-          code: 'INPUT_VALIDATION_ERROR', 
+					code: 'INPUT_VALIDATION_ERROR',
-          message: 'Task ID is required' 
+					message: 'Task ID is required'
-        }, 
+				},
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    // Skip confirmation in the direct function since it's handled by the client
+		// Skip confirmation in the direct function since it's handled by the client
-    log.info(`Removing task with ID: ${taskId} from ${tasksPath}`);
+		log.info(`Removing task with ID: ${taskId} from ${tasksPath}`);
 
-    try {
+		try {
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			// Enable silent mode to prevent console logs from interfering with JSON response
-      enableSilentMode();
+			enableSilentMode();
 
-      // Call the core removeTask function
+			// Call the core removeTask function
-      const result = await removeTask(tasksPath, taskId);
+			const result = await removeTask(tasksPath, taskId);
 
-      // Restore normal logging
+			// Restore normal logging
-      disableSilentMode();
+			disableSilentMode();
 
-      log.info(`Successfully removed task: ${taskId}`);
+			log.info(`Successfully removed task: ${taskId}`);
 
-      // Return the result
+			// Return the result
-      return {
+			return {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: result.message,
+					message: result.message,
-          taskId: taskId,
+					taskId: taskId,
-          tasksPath: tasksPath,
+					tasksPath: tasksPath,
-          removedTask: result.removedTask
+					removedTask: result.removedTask
-        },
+				},
-        fromCache: false
+				fromCache: false
-      };
+			};
-    } catch (error) {
+		} catch (error) {
-      // Make sure to restore normal logging even if there's an error
+			// Make sure to restore normal logging even if there's an error
-      disableSilentMode();
+			disableSilentMode();
 
-      log.error(`Error removing task: ${error.message}`);
+			log.error(`Error removing task: ${error.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { 
+				error: {
-          code: error.code || 'REMOVE_TASK_ERROR', 
+					code: error.code || 'REMOVE_TASK_ERROR',
-          message: error.message || 'Failed to remove task' 
+					message: error.message || 'Failed to remove task'
-        }, 
+				},
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
-  } catch (error) {
+	} catch (error) {
-    // Ensure silent mode is disabled even if an outer error occurs
+		// Ensure silent mode is disabled even if an outer error occurs
-    disableSilentMode();
+		disableSilentMode();
 
-    // Catch any unexpected errors
+		// Catch any unexpected errors
-    log.error(`Unexpected error in removeTaskDirect: ${error.message}`);
+		log.error(`Unexpected error in removeTaskDirect: ${error.message}`);
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { 
+			error: {
-        code: 'UNEXPECTED_ERROR', 
+				code: 'UNEXPECTED_ERROR',
-        message: error.message 
+				message: error.message
-      }, 
+			},
-      fromCache: false 
+			fromCache: false
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/direct-functions/set-task-status.js

@@ -5,7 +5,11 @@
 
 import { setTaskStatus } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode,
+	isSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Direct function wrapper for setTaskStatus with error handling.
@@ -14,99 +18,107 @@ import { enableSilentMode, disableSilentMode, isSilentMode } from '../../../../s
  * @param {Object} log - Logger object.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
-export async function setTaskStatusDirect(args, log) {
+export async function setTaskStatusDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Setting task status with args: ${JSON.stringify(args)}`);
+		log.info(`Setting task status with args: ${JSON.stringify(args)}`);
 
-    // Check required parameters
+		// Check required parameters
-    if (!args.id) {
+		if (!args.id) {
-      const errorMessage = 'No task ID specified. Please provide a task ID to update.';
+			const errorMessage =
-      log.error(errorMessage);
+				'No task ID specified. Please provide a task ID to update.';
-      return { 
+			log.error(errorMessage);
-        success: false, 
+			return {
-        error: { code: 'MISSING_TASK_ID', message: errorMessage },
+				success: false,
-        fromCache: false 
+				error: { code: 'MISSING_TASK_ID', message: errorMessage },
-      };
+				fromCache: false
-    }
+			};
+		}
 
-    if (!args.status) {
+		if (!args.status) {
-      const errorMessage = 'No status specified. Please provide a new status value.';
+			const errorMessage =
-      log.error(errorMessage);
+				'No status specified. Please provide a new status value.';
-      return { 
+			log.error(errorMessage);
-        success: false, 
+			return {
-        error: { code: 'MISSING_STATUS', message: errorMessage },
+				success: false,
-        fromCache: false 
+				error: { code: 'MISSING_STATUS', message: errorMessage },
-      };
+				fromCache: false
-    }
+			};
+		}
 
-    // Get tasks file path
+		// Get tasks file path
-    let tasksPath;
+		let tasksPath;
-    try {
+		try {
-      // The enhanced findTasksJsonPath will now search in parent directories if needed
+			// The enhanced findTasksJsonPath will now search in parent directories if needed
-      tasksPath = findTasksJsonPath(args, log);
+			tasksPath = findTasksJsonPath(args, log, session);
-      log.info(`Found tasks file at: ${tasksPath}`);
+			log.info(`Found tasks file at: ${tasksPath}`);
-    } catch (error) {
+		} catch (error) {
-      log.error(`Error finding tasks file: ${error.message}`);
+			log.error(`Error finding tasks file: ${error.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { 
+				error: {
-          code: 'TASKS_FILE_ERROR', 
+					code: 'TASKS_FILE_ERROR',
-          message: `${error.message}\n\nPlease ensure you are in a Task Master project directory or use the --project-root parameter to specify the path to your project.`
+					message: `${error.message}\n\nPlease ensure you are in a Task Master project directory or use the --project-root parameter to specify the path to your project.`
-        },
+				},
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    // Execute core setTaskStatus function
+		// Execute core setTaskStatus function
-    const taskId = args.id;
+		const taskId = args.id;
-    const newStatus = args.status;
+		const newStatus = args.status;
 
-    log.info(`Setting task ${taskId} status to "${newStatus}"`);
+		log.info(`Setting task ${taskId} status to "${newStatus}"`);
 
-    // Call the core function with proper silent mode handling
+		// Call the core function with proper silent mode handling
-    let result;
+		let result;
-    enableSilentMode(); // Enable silent mode before calling core function
+		enableSilentMode(); // Enable silent mode before calling core function
-    try {
+		try {
-      // Call the core function
+			// Call the core function
-      await setTaskStatus(tasksPath, taskId, newStatus, { mcpLog: log });
+			await setTaskStatus(tasksPath, taskId, newStatus, { mcpLog: log });
 
-      log.info(`Successfully set task ${taskId} status to ${newStatus}`);
+			log.info(`Successfully set task ${taskId} status to ${newStatus}`);
 
-      // Return success data
+			// Return success data
-      result = {
+			result = {
-        success: true,
+				success: true,
-        data: {
+				data: {
-          message: `Successfully updated task ${taskId} status to "${newStatus}"`,
+					message: `Successfully updated task ${taskId} status to "${newStatus}"`,
-          taskId,
+					taskId,
-          status: newStatus,
+					status: newStatus,
-          tasksPath
+					tasksPath
-        },
+				},
-        fromCache: false // This operation always modifies state and should never be cached
+				fromCache: false // This operation always modifies state and should never be cached
-      };
+			};
-    } catch (error) {
+		} catch (error) {
-      log.error(`Error setting task status: ${error.message}`);
+			log.error(`Error setting task status: ${error.message}`);
-      result = { 
+			result = {
-        success: false, 
+				success: false,
-        error: { code: 'SET_STATUS_ERROR', message: error.message || 'Unknown error setting task status' },
+				error: {
-        fromCache: false 
+					code: 'SET_STATUS_ERROR',
-      };
+					message: error.message || 'Unknown error setting task status'
-    } finally {
+				},
-      // ALWAYS restore normal logging in finally block
+				fromCache: false
-      disableSilentMode();
+			};
-    }
+		} finally {
+			// ALWAYS restore normal logging in finally block
+			disableSilentMode();
+		}
 
-    return result;
+		return result;
-  } catch (error) {
+	} catch (error) {
-    // Ensure silent mode is disabled if there was an uncaught error in the outer try block
+		// Ensure silent mode is disabled if there was an uncaught error in the outer try block
-    if (isSilentMode()) {
+		if (isSilentMode()) {
-      disableSilentMode();
+			disableSilentMode();
-    }
+		}
 
-    log.error(`Error setting task status: ${error.message}`);
+		log.error(`Error setting task status: ${error.message}`);
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { code: 'SET_STATUS_ERROR', message: error.message || 'Unknown error setting task status' },
+			error: {
-      fromCache: false 
+				code: 'SET_STATUS_ERROR',
-    };
+				message: error.message || 'Unknown error setting task status'
-  }
+			},
+			fromCache: false
+		};
+	}
 }

mcp-server/src/core/direct-functions/show-task.js

@@ -7,7 +7,10 @@ import { findTaskById } from '../../../../scripts/modules/utils.js';
 import { readJSON } from '../../../../scripts/modules/utils.js';
 import { getCachedOrExecute } from '../../tools/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 
 /**
  * Direct function wrapper for showing task details with error handling and caching.
@@ -16,121 +19,123 @@ import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules
  * @param {Object} log - Logger object
  * @returns {Promise<Object>} - Task details result { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
-export async function showTaskDirect(args, log) {
+export async function showTaskDirect(args, log, { session }) {
-  let tasksPath;
+	let tasksPath;
-  try {
+	try {
-    // Find the tasks path first - needed for cache key and execution
+		// Find the tasks path first - needed for cache key and execution
-    tasksPath = findTasksJsonPath(args, log);
+		tasksPath = findTasksJsonPath(args, log, session);
-  } catch (error) {
+	} catch (error) {
-    log.error(`Tasks file not found: ${error.message}`);
+		log.error(`Tasks file not found: ${error.message}`);
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { 
+			error: {
-        code: 'FILE_NOT_FOUND_ERROR', 
+				code: 'FILE_NOT_FOUND_ERROR',
-        message: error.message 
+				message: error.message
-      }, 
+			},
-      fromCache: false 
+			fromCache: false
-    };
+		};
-  }
+	}
 
-  // Validate task ID
+	// Validate task ID
-  const taskId = args.id;
+	const taskId = args.id;
-  if (!taskId) {
+	if (!taskId) {
-    log.error('Task ID is required');
+		log.error('Task ID is required');
-    return { 
+		return {
-      success: false, 
+			success: false,
-      error: { 
+			error: {
-        code: 'INPUT_VALIDATION_ERROR', 
+				code: 'INPUT_VALIDATION_ERROR',
-        message: 'Task ID is required' 
+				message: 'Task ID is required'
-      }, 
+			},
-      fromCache: false 
+			fromCache: false
-    };
+		};
-  }
+	}
 
-  // Generate cache key using task path and ID
+	// Generate cache key using task path and ID
-  const cacheKey = `showTask:${tasksPath}:${taskId}`;
+	const cacheKey = `showTask:${tasksPath}:${taskId}`;
 
-  // Define the action function to be executed on cache miss
+	// Define the action function to be executed on cache miss
-  const coreShowTaskAction = async () => {
+	const coreShowTaskAction = async () => {
-    try {
+		try {
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			// Enable silent mode to prevent console logs from interfering with JSON response
-      enableSilentMode();
+			enableSilentMode();
 
-      log.info(`Retrieving task details for ID: ${taskId} from ${tasksPath}`);
+			log.info(`Retrieving task details for ID: ${taskId} from ${tasksPath}`);
 
-      // Read tasks data
+			// Read tasks data
-      const data = readJSON(tasksPath);
+			const data = readJSON(tasksPath);
-      if (!data || !data.tasks) {
+			if (!data || !data.tasks) {
-        return { 
+				return {
-          success: false, 
+					success: false,
-          error: { 
+					error: {
-            code: 'INVALID_TASKS_FILE', 
+						code: 'INVALID_TASKS_FILE',
-            message: `No valid tasks found in ${tasksPath}` 
+						message: `No valid tasks found in ${tasksPath}`
-          } 
+					}
-        };
+				};
-      }
+			}
 
-      // Find the specific task
+			// Find the specific task
-      const task = findTaskById(data.tasks, taskId);
+			const task = findTaskById(data.tasks, taskId);
 
-      if (!task) {
+			if (!task) {
-        return { 
+				return {
-          success: false, 
+					success: false,
-          error: { 
+					error: {
-            code: 'TASK_NOT_FOUND', 
+						code: 'TASK_NOT_FOUND',
-            message: `Task with ID ${taskId} not found` 
+						message: `Task with ID ${taskId} not found`
-          } 
+					}
-        };
+				};
-      }
+			}
 
-      // Restore normal logging
+			// Restore normal logging
-      disableSilentMode();
+			disableSilentMode();
 
-      // Return the task data with the full tasks array for reference
+			// Return the task data with the full tasks array for reference
-      // (needed for formatDependenciesWithStatus function in UI)
+			// (needed for formatDependenciesWithStatus function in UI)
-      log.info(`Successfully found task ${taskId}`);
+			log.info(`Successfully found task ${taskId}`);
-      return { 
+			return {
-        success: true, 
+				success: true,
-        data: { 
+				data: {
-          task, 
+					task,
-          allTasks: data.tasks 
+					allTasks: data.tasks
-        } 
+				}
-      };
+			};
-    } catch (error) {
+		} catch (error) {
-      // Make sure to restore normal logging even if there's an error
+			// Make sure to restore normal logging even if there's an error
-      disableSilentMode();
+			disableSilentMode();
 
-      log.error(`Error showing task: ${error.message}`);
+			log.error(`Error showing task: ${error.message}`);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { 
+				error: {
-          code: 'CORE_FUNCTION_ERROR', 
+					code: 'CORE_FUNCTION_ERROR',
-          message: error.message || 'Failed to show task details' 
+					message: error.message || 'Failed to show task details'
-        } 
+				}
-      };
+			};
-    }
+		}
-  };
+	};
 
-  // Use the caching utility
+	// Use the caching utility
-  try {
+	try {
-    const result = await getCachedOrExecute({
+		const result = await getCachedOrExecute({
-      cacheKey,
+			cacheKey,
-      actionFn: coreShowTaskAction,
+			actionFn: coreShowTaskAction,
-      log
+			log
-    });
+		});
-    log.info(`showTaskDirect completed. From cache: ${result.fromCache}`);
+		log.info(`showTaskDirect completed. From cache: ${result.fromCache}`);
-    return result; // Returns { success, data/error, fromCache }
+		return result; // Returns { success, data/error, fromCache }
-  } catch (error) {
+	} catch (error) {
-    // Catch unexpected errors from getCachedOrExecute itself
+		// Catch unexpected errors from getCachedOrExecute itself
-    disableSilentMode();
+		disableSilentMode();
-    log.error(`Unexpected error during getCachedOrExecute for showTask: ${error.message}`);
+		log.error(
-    return { 
+			`Unexpected error during getCachedOrExecute for showTask: ${error.message}`
-      success: false, 
+		);
-      error: { 
+		return {
-        code: 'UNEXPECTED_ERROR', 
+			success: false,
-        message: error.message 
+			error: {
-      }, 
+				code: 'UNEXPECTED_ERROR',
-      fromCache: false 
+				message: error.message
-    };
+			},
-  }
+			fromCache: false
+		};
+	}
 }

mcp-server/src/core/direct-functions/update-subtask-by-id.js

@@ -4,9 +4,15 @@
  */
 
 import { updateSubtaskById } from '../../../../scripts/modules/task-manager.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { getAnthropicClientForMCP, getPerplexityClientForMCP } from '../utils/ai-client-utils.js';
+import {
+	getAnthropicClientForMCP,
+	getPerplexityClientForMCP
+} from '../utils/ai-client-utils.js';
 
 /**
  * Direct function wrapper for updateSubtaskById with error handling.
@@ -16,155 +22,170 @@ import { getAnthropicClientForMCP, getPerplexityClientForMCP } from '../utils/ai
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
-export async function updateSubtaskByIdDirect(args, log, context = {}) {
+export async function updateSubtaskByIdDirect(args, log, { session }) {
-  const { session } = context; // Only extract session, not reportProgress
+	try {
+		log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
 
-  try {
+		// Check required parameters
-    log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
+		if (!args.id) {
+			const errorMessage =
+				'No subtask ID specified. Please provide a subtask ID to update.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_SUBTASK_ID', message: errorMessage },
+				fromCache: false
+			};
+		}
 
-    // Check required parameters
+		if (!args.prompt) {
-    if (!args.id) {
+			const errorMessage =
-      const errorMessage = 'No subtask ID specified. Please provide a subtask ID to update.';
+				'No prompt specified. Please provide a prompt with information to add to the subtask.';
-      log.error(errorMessage);
+			log.error(errorMessage);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { code: 'MISSING_SUBTASK_ID', message: errorMessage },
+				error: { code: 'MISSING_PROMPT', message: errorMessage },
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    if (!args.prompt) {
+		// Validate subtask ID format
-      const errorMessage = 'No prompt specified. Please provide a prompt with information to add to the subtask.';
+		const subtaskId = args.id;
-      log.error(errorMessage);
+		if (typeof subtaskId !== 'string' && typeof subtaskId !== 'number') {
-      return { 
+			const errorMessage = `Invalid subtask ID type: ${typeof subtaskId}. Subtask ID must be a string or number.`;
-        success: false, 
+			log.error(errorMessage);
-        error: { code: 'MISSING_PROMPT', message: errorMessage },
+			return {
-        fromCache: false 
+				success: false,
-      };
+				error: { code: 'INVALID_SUBTASK_ID_TYPE', message: errorMessage },
-    }
+				fromCache: false
+			};
+		}
 
-    // Validate subtask ID format
+		const subtaskIdStr = String(subtaskId);
-    const subtaskId = args.id;
+		if (!subtaskIdStr.includes('.')) {
-    if (typeof subtaskId !== 'string' && typeof subtaskId !== 'number') {
+			const errorMessage = `Invalid subtask ID format: ${subtaskIdStr}. Subtask ID must be in format "parentId.subtaskId" (e.g., "5.2").`;
-      const errorMessage = `Invalid subtask ID type: ${typeof subtaskId}. Subtask ID must be a string or number.`;
+			log.error(errorMessage);
-      log.error(errorMessage);
+			return {
-      return {
+				success: false,
-        success: false,
+				error: { code: 'INVALID_SUBTASK_ID_FORMAT', message: errorMessage },
-        error: { code: 'INVALID_SUBTASK_ID_TYPE', message: errorMessage },
+				fromCache: false
-        fromCache: false
+			};
-      };
+		}
-    }
 
-    const subtaskIdStr = String(subtaskId);
+		// Get tasks file path
-    if (!subtaskIdStr.includes('.')) {
+		let tasksPath;
-      const errorMessage = `Invalid subtask ID format: ${subtaskIdStr}. Subtask ID must be in format "parentId.subtaskId" (e.g., "5.2").`;
+		try {
-      log.error(errorMessage);
+			tasksPath = findTasksJsonPath(args, log, session);
-      return { 
+		} catch (error) {
-        success: false, 
+			log.error(`Error finding tasks file: ${error.message}`);
-        error: { code: 'INVALID_SUBTASK_ID_FORMAT', message: errorMessage },
+			return {
-        fromCache: false 
+				success: false,
-      };
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-    }
+				fromCache: false
+			};
+		}
 
-    // Get tasks file path
+		// Get research flag
-    let tasksPath;
+		const useResearch = args.research === true;
-    try {
-      tasksPath = findTasksJsonPath(args, log);
-    } catch (error) {
-      log.error(`Error finding tasks file: ${error.message}`);
-      return { 
-        success: false, 
-        error: { code: 'TASKS_FILE_ERROR', message: error.message },
-        fromCache: false 
-      };
-    }
 
-    // Get research flag
+		log.info(
-    const useResearch = args.research === true;
+			`Updating subtask with ID ${subtaskIdStr} with prompt "${args.prompt}" and research: ${useResearch}`
+		);
 
-    log.info(`Updating subtask with ID ${subtaskIdStr} with prompt "${args.prompt}" and research: ${useResearch}`);
+		// Initialize the appropriate AI client based on research flag
+		try {
+			if (useResearch) {
+				// Initialize Perplexity client
+				await getPerplexityClientForMCP(session);
+			} else {
+				// Initialize Anthropic client
+				await getAnthropicClientForMCP(session);
+			}
+		} catch (error) {
+			log.error(`AI client initialization error: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: error.message || 'Failed to initialize AI client'
+				},
+				fromCache: false
+			};
+		}
 
-    // Initialize the appropriate AI client based on research flag
+		try {
-    try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
-      if (useResearch) {
+			enableSilentMode();
-        // Initialize Perplexity client
-        await getPerplexityClientForMCP(session);
-      } else {
-        // Initialize Anthropic client
-        await getAnthropicClientForMCP(session);
-      }
-    } catch (error) {
-      log.error(`AI client initialization error: ${error.message}`);
-      return {
-        success: false,
-        error: { code: 'AI_CLIENT_ERROR', message: error.message || 'Failed to initialize AI client' },
-        fromCache: false
-      };
-    }
 
-    try {
+			// Create a logger wrapper object to handle logging without breaking the mcpLog[level] calls
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			// This ensures outputFormat is set to 'json' while still supporting proper logging
-      enableSilentMode();
+			const logWrapper = {
+				info: (message) => log.info(message),
+				warn: (message) => log.warn(message),
+				error: (message) => log.error(message),
+				debug: (message) => log.debug && log.debug(message),
+				success: (message) => log.info(message) // Map success to info if needed
+			};
 
-      // Create a logger wrapper object to handle logging without breaking the mcpLog[level] calls
+			// Execute core updateSubtaskById function
-      // This ensures outputFormat is set to 'json' while still supporting proper logging
+			// Pass both session and logWrapper as mcpLog to ensure outputFormat is 'json'
-      const logWrapper = {
+			const updatedSubtask = await updateSubtaskById(
-        info: (message) => log.info(message),
+				tasksPath,
-        warn: (message) => log.warn(message),
+				subtaskIdStr,
-        error: (message) => log.error(message),
+				args.prompt,
-        debug: (message) => log.debug && log.debug(message),
+				useResearch,
-        success: (message) => log.info(message) // Map success to info if needed
+				{
-      };
+					session,
+					mcpLog: logWrapper
+				}
+			);
 
-      // Execute core updateSubtaskById function
+			// Restore normal logging
-      // Pass both session and logWrapper as mcpLog to ensure outputFormat is 'json'
+			disableSilentMode();
-      const updatedSubtask = await updateSubtaskById(tasksPath, subtaskIdStr, args.prompt, useResearch, { 
-        session,
-        mcpLog: logWrapper 
-      });
 
-      // Restore normal logging
+			// Handle the case where the subtask couldn't be updated (e.g., already marked as done)
-      disableSilentMode();
+			if (!updatedSubtask) {
+				return {
+					success: false,
+					error: {
+						code: 'SUBTASK_UPDATE_FAILED',
+						message:
+							'Failed to update subtask. It may be marked as completed, or another error occurred.'
+					},
+					fromCache: false
+				};
+			}
 
-      // Handle the case where the subtask couldn't be updated (e.g., already marked as done)
+			// Return the updated subtask information
-      if (!updatedSubtask) {
+			return {
-        return {
+				success: true,
-          success: false,
+				data: {
-          error: { 
+					message: `Successfully updated subtask with ID ${subtaskIdStr}`,
-            code: 'SUBTASK_UPDATE_FAILED', 
+					subtaskId: subtaskIdStr,
-            message: 'Failed to update subtask. It may be marked as completed, or another error occurred.' 
+					parentId: subtaskIdStr.split('.')[0],
-          },
+					subtask: updatedSubtask,
-          fromCache: false
+					tasksPath,
-        };
+					useResearch
-      }
+				},
+				fromCache: false // This operation always modifies state and should never be cached
+			};
+		} catch (error) {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+			throw error; // Rethrow to be caught by outer catch block
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled
+		disableSilentMode();
 
-      // Return the updated subtask information
+		log.error(`Error updating subtask by ID: ${error.message}`);
-      return {
+		return {
-        success: true,
+			success: false,
-        data: {
+			error: {
-          message: `Successfully updated subtask with ID ${subtaskIdStr}`,
+				code: 'UPDATE_SUBTASK_ERROR',
-          subtaskId: subtaskIdStr,
+				message: error.message || 'Unknown error updating subtask'
-          parentId: subtaskIdStr.split('.')[0],
+			},
-          subtask: updatedSubtask,
+			fromCache: false
-          tasksPath,
+		};
-          useResearch
+	}
-        },
-        fromCache: false // This operation always modifies state and should never be cached
-      };
-    } catch (error) {
-      // Make sure to restore normal logging even if there's an error
-      disableSilentMode();
-      throw error; // Rethrow to be caught by outer catch block
-    }
-  } catch (error) {
-    // Ensure silent mode is disabled
-    disableSilentMode();
-    
-    log.error(`Error updating subtask by ID: ${error.message}`);
-    return { 
-      success: false, 
-      error: { code: 'UPDATE_SUBTASK_ERROR', message: error.message || 'Unknown error updating subtask' },
-      fromCache: false 
-    };
-  }
 }

mcp-server/src/core/direct-functions/update-task-by-id.js

@@ -5,10 +5,13 @@
 
 import { updateTaskById } from '../../../../scripts/modules/task-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
 import {
-  getAnthropicClientForMCP, 
+	enableSilentMode,
-  getPerplexityClientForMCP 
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
+import {
+	getAnthropicClientForMCP,
+	getPerplexityClientForMCP
 } from '../utils/ai-client-utils.js';
 
 /**
@@ -19,154 +22,162 @@ import {
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
-export async function updateTaskByIdDirect(args, log, context = {}) {
+export async function updateTaskByIdDirect(args, log, { session }) {
-  const { session } = context; // Only extract session, not reportProgress
+	try {
+		log.info(`Updating task with args: ${JSON.stringify(args)}`);
 
-  try {
+		// Check required parameters
-    log.info(`Updating task with args: ${JSON.stringify(args)}`);
+		if (!args.id) {
+			const errorMessage =
+				'No task ID specified. Please provide a task ID to update.';
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: { code: 'MISSING_TASK_ID', message: errorMessage },
+				fromCache: false
+			};
+		}
 
-    // Check required parameters
+		if (!args.prompt) {
-    if (!args.id) {
+			const errorMessage =
-      const errorMessage = 'No task ID specified. Please provide a task ID to update.';
+				'No prompt specified. Please provide a prompt with new information for the task update.';
-      log.error(errorMessage);
+			log.error(errorMessage);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { code: 'MISSING_TASK_ID', message: errorMessage },
+				error: { code: 'MISSING_PROMPT', message: errorMessage },
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    if (!args.prompt) {
+		// Parse taskId - handle both string and number values
-      const errorMessage = 'No prompt specified. Please provide a prompt with new information for the task update.';
+		let taskId;
-      log.error(errorMessage);
+		if (typeof args.id === 'string') {
-      return { 
+			// Handle subtask IDs (e.g., "5.2")
-        success: false, 
+			if (args.id.includes('.')) {
-        error: { code: 'MISSING_PROMPT', message: errorMessage },
+				taskId = args.id; // Keep as string for subtask IDs
-        fromCache: false 
+			} else {
-      };
+				// Parse as integer for main task IDs
-    }
+				taskId = parseInt(args.id, 10);
+				if (isNaN(taskId)) {
+					const errorMessage = `Invalid task ID: ${args.id}. Task ID must be a positive integer or subtask ID (e.g., "5.2").`;
+					log.error(errorMessage);
+					return {
+						success: false,
+						error: { code: 'INVALID_TASK_ID', message: errorMessage },
+						fromCache: false
+					};
+				}
+			}
+		} else {
+			taskId = args.id;
+		}
 
-    // Parse taskId - handle both string and number values
+		// Get tasks file path
-    let taskId;
+		let tasksPath;
-    if (typeof args.id === 'string') {
+		try {
-      // Handle subtask IDs (e.g., "5.2")
+			tasksPath = findTasksJsonPath(args, log, session);
-      if (args.id.includes('.')) {
+		} catch (error) {
-        taskId = args.id; // Keep as string for subtask IDs
+			log.error(`Error finding tasks file: ${error.message}`);
-      } else {
+			return {
-        // Parse as integer for main task IDs
+				success: false,
-        taskId = parseInt(args.id, 10);
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-        if (isNaN(taskId)) {
+				fromCache: false
-          const errorMessage = `Invalid task ID: ${args.id}. Task ID must be a positive integer or subtask ID (e.g., "5.2").`;
+			};
-          log.error(errorMessage);
+		}
-          return { 
-            success: false, 
-            error: { code: 'INVALID_TASK_ID', message: errorMessage },
-            fromCache: false 
-          };
-        }
-      }
-    } else {
-      taskId = args.id;
-    }
 
-    // Get tasks file path
+		// Get research flag
-    let tasksPath;
+		const useResearch = args.research === true;
-    try {
-      tasksPath = findTasksJsonPath(args, log);
-    } catch (error) {
-      log.error(`Error finding tasks file: ${error.message}`);
-      return { 
-        success: false, 
-        error: { code: 'TASKS_FILE_ERROR', message: error.message },
-        fromCache: false 
-      };
-    }
 
-    // Get research flag
+		// Initialize appropriate AI client based on research flag
-    const useResearch = args.research === true;
+		let aiClient;
+		try {
+			if (useResearch) {
+				log.info('Using Perplexity AI for research-backed task update');
+				aiClient = await getPerplexityClientForMCP(session, log);
+			} else {
+				log.info('Using Claude AI for task update');
+				aiClient = getAnthropicClientForMCP(session, log);
+			}
+		} catch (error) {
+			log.error(`Failed to initialize AI client: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: `Cannot initialize AI client: ${error.message}`
+				},
+				fromCache: false
+			};
+		}
 
-    // Initialize appropriate AI client based on research flag
+		log.info(
-    let aiClient;
+			`Updating task with ID ${taskId} with prompt "${args.prompt}" and research: ${useResearch}`
-    try {
+		);
-      if (useResearch) {
-        log.info('Using Perplexity AI for research-backed task update');
-        aiClient = await getPerplexityClientForMCP(session, log);
-      } else {
-        log.info('Using Claude AI for task update');
-        aiClient = getAnthropicClientForMCP(session, log);
-      }
-    } catch (error) {
-      log.error(`Failed to initialize AI client: ${error.message}`);
-      return {
-        success: false,
-        error: {
-          code: 'AI_CLIENT_ERROR',
-          message: `Cannot initialize AI client: ${error.message}`
-        },
-        fromCache: false
-      };
-    }
 
-    log.info(`Updating task with ID ${taskId} with prompt "${args.prompt}" and research: ${useResearch}`);
+		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
 
-    try {
+			// Create a logger wrapper that matches what updateTaskById expects
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			const logWrapper = {
-      enableSilentMode();
+				info: (message) => log.info(message),
+				warn: (message) => log.warn(message),
+				error: (message) => log.error(message),
+				debug: (message) => log.debug && log.debug(message),
+				success: (message) => log.info(message) // Map success to info since many loggers don't have success
+			};
 
-      // Create a logger wrapper that matches what updateTaskById expects
+			// Execute core updateTaskById function with proper parameters
-      const logWrapper = {
+			await updateTaskById(
-        info: (message) => log.info(message),
+				tasksPath,
-        warn: (message) => log.warn(message),
+				taskId,
-        error: (message) => log.error(message),
+				args.prompt,
-        debug: (message) => log.debug && log.debug(message),
+				useResearch,
-        success: (message) => log.info(message) // Map success to info since many loggers don't have success
+				{
-      };
+					mcpLog: logWrapper, // Use our wrapper object that has the expected method structure
+					session
+				},
+				'json'
+			);
 
-      // Execute core updateTaskById function with proper parameters
+			// Since updateTaskById doesn't return a value but modifies the tasks file,
-      await updateTaskById(
+			// we'll return a success message
-        tasksPath, 
+			return {
-        taskId, 
+				success: true,
-        args.prompt, 
+				data: {
-        useResearch, 
+					message: `Successfully updated task with ID ${taskId} based on the prompt`,
-        { 
+					taskId,
-          mcpLog: logWrapper, // Use our wrapper object that has the expected method structure
+					tasksPath,
-          session 
+					useResearch
-        },
+				},
-        'json'
+				fromCache: false // This operation always modifies state and should never be cached
-      );
+			};
+		} catch (error) {
+			log.error(`Error updating task by ID: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'UPDATE_TASK_ERROR',
+					message: error.message || 'Unknown error updating task'
+				},
+				fromCache: false
+			};
+		} finally {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled
+		disableSilentMode();
 
-      // Since updateTaskById doesn't return a value but modifies the tasks file,
+		log.error(`Error updating task by ID: ${error.message}`);
-      // we'll return a success message
+		return {
-      return {
+			success: false,
-        success: true,
+			error: {
-        data: {
+				code: 'UPDATE_TASK_ERROR',
-          message: `Successfully updated task with ID ${taskId} based on the prompt`,
+				message: error.message || 'Unknown error updating task'
-          taskId,
+			},
-          tasksPath,
+			fromCache: false
-          useResearch
+		};
-        },
+	}
-        fromCache: false // This operation always modifies state and should never be cached
-      };
-    } catch (error) {
-      log.error(`Error updating task by ID: ${error.message}`);
-      return { 
-        success: false, 
-        error: { code: 'UPDATE_TASK_ERROR', message: error.message || 'Unknown error updating task' },
-        fromCache: false 
-      };
-    } finally {
-      // Make sure to restore normal logging even if there's an error
-      disableSilentMode();
-    }
-  } catch (error) {
-    // Ensure silent mode is disabled
-    disableSilentMode();
-    
-    log.error(`Error updating task by ID: ${error.message}`);
-    return { 
-      success: false, 
-      error: { code: 'UPDATE_TASK_ERROR', message: error.message || 'Unknown error updating task' },
-      fromCache: false 
-    };
-  }
 }

mcp-server/src/core/direct-functions/update-tasks.js

@@ -4,11 +4,14 @@
  */
 
 import { updateTasks } from '../../../../scripts/modules/task-manager.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
 import {
-  getAnthropicClientForMCP, 
+	getAnthropicClientForMCP,
-  getPerplexityClientForMCP 
+	getPerplexityClientForMCP
 } from '../utils/ai-client-utils.js';
 
 /**
@@ -19,153 +22,157 @@ import {
  * @param {Object} context - Context object containing session data.
  * @returns {Promise<Object>} - Result object with success status and data/error information.
  */
-export async function updateTasksDirect(args, log, context = {}) {
+export async function updateTasksDirect(args, log, { session }) {
-  const { session } = context; // Only extract session, not reportProgress
+	try {
+		log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
 
-  try {
+		// Check for the common mistake of using 'id' instead of 'from'
-    log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
+		if (args.id !== undefined && args.from === undefined) {
+			const errorMessage =
+				"You specified 'id' parameter but 'update' requires 'from' parameter. Use 'from' for this tool or use 'update_task' tool if you want to update a single task.";
+			log.error(errorMessage);
+			return {
+				success: false,
+				error: {
+					code: 'PARAMETER_MISMATCH',
+					message: errorMessage,
+					suggestion:
+						"Use 'from' parameter instead of 'id', or use the 'update_task' tool for single task updates"
+				},
+				fromCache: false
+			};
+		}
 
-    // Check for the common mistake of using 'id' instead of 'from'
+		// Check required parameters
-    if (args.id !== undefined && args.from === undefined) {
+		if (!args.from) {
-      const errorMessage = "You specified 'id' parameter but 'update' requires 'from' parameter. Use 'from' for this tool or use 'update_task' tool if you want to update a single task.";
+			const errorMessage =
-      log.error(errorMessage);
+				'No from ID specified. Please provide a task ID to start updating from.';
-      return { 
+			log.error(errorMessage);
-        success: false, 
+			return {
-        error: { 
+				success: false,
-          code: 'PARAMETER_MISMATCH', 
+				error: { code: 'MISSING_FROM_ID', message: errorMessage },
-          message: errorMessage,
+				fromCache: false
-          suggestion: "Use 'from' parameter instead of 'id', or use the 'update_task' tool for single task updates"
+			};
-        },
+		}
-        fromCache: false 
-      };
-    }
 
-    // Check required parameters
+		if (!args.prompt) {
-    if (!args.from) {
+			const errorMessage =
-      const errorMessage = 'No from ID specified. Please provide a task ID to start updating from.';
+				'No prompt specified. Please provide a prompt with new context for task updates.';
-      log.error(errorMessage);
+			log.error(errorMessage);
-      return { 
+			return {
-        success: false, 
+				success: false,
-        error: { code: 'MISSING_FROM_ID', message: errorMessage },
+				error: { code: 'MISSING_PROMPT', message: errorMessage },
-        fromCache: false 
+				fromCache: false
-      };
+			};
-    }
+		}
 
-    if (!args.prompt) {
+		// Parse fromId - handle both string and number values
-      const errorMessage = 'No prompt specified. Please provide a prompt with new context for task updates.';
+		let fromId;
-      log.error(errorMessage);
+		if (typeof args.from === 'string') {
-      return { 
+			fromId = parseInt(args.from, 10);
-        success: false, 
+			if (isNaN(fromId)) {
-        error: { code: 'MISSING_PROMPT', message: errorMessage },
+				const errorMessage = `Invalid from ID: ${args.from}. Task ID must be a positive integer.`;
-        fromCache: false 
+				log.error(errorMessage);
-      };
+				return {
-    }
+					success: false,
+					error: { code: 'INVALID_FROM_ID', message: errorMessage },
+					fromCache: false
+				};
+			}
+		} else {
+			fromId = args.from;
+		}
 
-    // Parse fromId - handle both string and number values
+		// Get tasks file path
-    let fromId;
+		let tasksPath;
-    if (typeof args.from === 'string') {
+		try {
-      fromId = parseInt(args.from, 10);
+			tasksPath = findTasksJsonPath(args, log, session);
-      if (isNaN(fromId)) {
+		} catch (error) {
-        const errorMessage = `Invalid from ID: ${args.from}. Task ID must be a positive integer.`;
+			log.error(`Error finding tasks file: ${error.message}`);
-        log.error(errorMessage);
+			return {
-        return { 
+				success: false,
-          success: false, 
+				error: { code: 'TASKS_FILE_ERROR', message: error.message },
-          error: { code: 'INVALID_FROM_ID', message: errorMessage },
+				fromCache: false
-          fromCache: false 
+			};
-        };
+		}
-      }
-    } else {
-      fromId = args.from;
-    }
 
-    // Get tasks file path
+		// Get research flag
-    let tasksPath;
+		const useResearch = args.research === true;
-    try {
-      tasksPath = findTasksJsonPath(args, log);
-    } catch (error) {
-      log.error(`Error finding tasks file: ${error.message}`);
-      return { 
-        success: false, 
-        error: { code: 'TASKS_FILE_ERROR', message: error.message },
-        fromCache: false 
-      };
-    }
 
-    // Get research flag
+		// Initialize appropriate AI client based on research flag
-    const useResearch = args.research === true;
+		let aiClient;
+		try {
+			if (useResearch) {
+				log.info('Using Perplexity AI for research-backed task updates');
+				aiClient = await getPerplexityClientForMCP(session, log);
+			} else {
+				log.info('Using Claude AI for task updates');
+				aiClient = getAnthropicClientForMCP(session, log);
+			}
+		} catch (error) {
+			log.error(`Failed to initialize AI client: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'AI_CLIENT_ERROR',
+					message: `Cannot initialize AI client: ${error.message}`
+				},
+				fromCache: false
+			};
+		}
 
-    // Initialize appropriate AI client based on research flag
+		log.info(
-    let aiClient;
+			`Updating tasks from ID ${fromId} with prompt "${args.prompt}" and research: ${useResearch}`
-    try {
+		);
-      if (useResearch) {
-        log.info('Using Perplexity AI for research-backed task updates');
-        aiClient = await getPerplexityClientForMCP(session, log);
-      } else {
-        log.info('Using Claude AI for task updates');
-        aiClient = getAnthropicClientForMCP(session, log);
-      }
-    } catch (error) {
-      log.error(`Failed to initialize AI client: ${error.message}`);
-      return {
-        success: false,
-        error: {
-          code: 'AI_CLIENT_ERROR',
-          message: `Cannot initialize AI client: ${error.message}`
-        },
-        fromCache: false
-      };
-    }
 
-    log.info(`Updating tasks from ID ${fromId} with prompt "${args.prompt}" and research: ${useResearch}`);
+		try {
+			// Enable silent mode to prevent console logs from interfering with JSON response
+			enableSilentMode();
 
-    try {
+			// Execute core updateTasks function, passing the AI client and session
-      // Enable silent mode to prevent console logs from interfering with JSON response
+			await updateTasks(tasksPath, fromId, args.prompt, useResearch, {
-      enableSilentMode();
+				mcpLog: log,
+				session
+			});
 
-      // Execute core updateTasks function, passing the AI client and session
+			// Since updateTasks doesn't return a value but modifies the tasks file,
-      await updateTasks(
+			// we'll return a success message
-        tasksPath, 
+			return {
-        fromId, 
+				success: true,
-        args.prompt, 
+				data: {
-        useResearch, 
+					message: `Successfully updated tasks from ID ${fromId} based on the prompt`,
-        { 
+					fromId,
-          mcpLog: log, 
+					tasksPath,
-          session 
+					useResearch
-        }
+				},
-      );
+				fromCache: false // This operation always modifies state and should never be cached
+			};
+		} catch (error) {
+			log.error(`Error updating tasks: ${error.message}`);
+			return {
+				success: false,
+				error: {
+					code: 'UPDATE_TASKS_ERROR',
+					message: error.message || 'Unknown error updating tasks'
+				},
+				fromCache: false
+			};
+		} finally {
+			// Make sure to restore normal logging even if there's an error
+			disableSilentMode();
+		}
+	} catch (error) {
+		// Ensure silent mode is disabled
+		disableSilentMode();
 
-      // Since updateTasks doesn't return a value but modifies the tasks file,
+		log.error(`Error updating tasks: ${error.message}`);
-      // we'll return a success message
+		return {
-      return {
+			success: false,
-        success: true,
+			error: {
-        data: {
+				code: 'UPDATE_TASKS_ERROR',
-          message: `Successfully updated tasks from ID ${fromId} based on the prompt`,
+				message: error.message || 'Unknown error updating tasks'
-          fromId,
+			},
-          tasksPath,
+			fromCache: false
-          useResearch
+		};
-        },
+	}
-        fromCache: false // This operation always modifies state and should never be cached
-      };
-    } catch (error) {
-      log.error(`Error updating tasks: ${error.message}`);
-      return { 
-        success: false, 
-        error: { code: 'UPDATE_TASKS_ERROR', message: error.message || 'Unknown error updating tasks' },
-        fromCache: false 
-      };
-    } finally {
-      // Make sure to restore normal logging even if there's an error
-      disableSilentMode();
-    }
-  } catch (error) {
-    // Ensure silent mode is disabled
-    disableSilentMode();
-    
-    log.error(`Error updating tasks: ${error.message}`);
-    return { 
-      success: false, 
-      error: { code: 'UPDATE_TASKS_ERROR', message: error.message || 'Unknown error updating tasks' },
-      fromCache: false 
-    };
-  }
 }

mcp-server/src/core/direct-functions/validate-dependencies.js

@@ -4,7 +4,10 @@
 
 import { validateDependenciesCommand } from '../../../../scripts/modules/dependency-manager.js';
 import { findTasksJsonPath } from '../utils/path-utils.js';
-import { enableSilentMode, disableSilentMode } from '../../../../scripts/modules/utils.js';
+import {
+	enableSilentMode,
+	disableSilentMode
+} from '../../../../scripts/modules/utils.js';
 import fs from 'fs';
 
 /**
@@ -15,51 +18,51 @@ import fs from 'fs';
  * @param {Object} log - Logger object
  * @returns {Promise<{success: boolean, data?: Object, error?: {code: string, message: string}}>}
  */
-export async function validateDependenciesDirect(args, log) {
+export async function validateDependenciesDirect(args, log, { session }) {
-  try {
+	try {
-    log.info(`Validating dependencies in tasks...`);
+		log.info(`Validating dependencies in tasks...`);
 
-    // Find the tasks.json path
+		// Find the tasks.json path
-    const tasksPath = findTasksJsonPath(args, log);
+		const tasksPath = findTasksJsonPath(args, log, session);
 
-    // Verify the file exists
+		// Verify the file exists
-    if (!fs.existsSync(tasksPath)) {
+		if (!fs.existsSync(tasksPath)) {
-      return {
+			return {
-        success: false,
+				success: false,
-        error: {
+				error: {
-          code: 'FILE_NOT_FOUND',
+					code: 'FILE_NOT_FOUND',
-          message: `Tasks file not found at ${tasksPath}`
+					message: `Tasks file not found at ${tasksPath}`
-        }
+				}
-      };
+			};
-    }
+		}
 
-    // Enable silent mode to prevent console logs from interfering with JSON response
+		// Enable silent mode to prevent console logs from interfering with JSON response
-    enableSilentMode();
+		enableSilentMode();
 
-    // Call the original command function
+		// Call the original command function
-    await validateDependenciesCommand(tasksPath);
+		await validateDependenciesCommand(tasksPath);
 
-    // Restore normal logging
+		// Restore normal logging
-    disableSilentMode();
+		disableSilentMode();
 
-    return {
+		return {
-      success: true,
+			success: true,
-      data: {
+			data: {
-        message: 'Dependencies validated successfully',
+				message: 'Dependencies validated successfully',
-        tasksPath
+				tasksPath
-      }
+			}
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    // Make sure to restore normal logging even if there's an error
+		// Make sure to restore normal logging even if there's an error
-    disableSilentMode();
+		disableSilentMode();
 
-    log.error(`Error validating dependencies: ${error.message}`);
+		log.error(`Error validating dependencies: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: {
+			error: {
-        code: 'VALIDATION_ERROR',
+				code: 'VALIDATION_ERROR',
-        message: error.message
+				message: error.message
-      }
+			}
-    };
+		};
-  }
+	}
 }

mcp-server/src/core/task-master-core.js

@@ -28,69 +28,71 @@ import { fixDependenciesDirect } from './direct-functions/fix-dependencies.js';
 import { complexityReportDirect } from './direct-functions/complexity-report.js';
 import { addDependencyDirect } from './direct-functions/add-dependency.js';
 import { removeTaskDirect } from './direct-functions/remove-task.js';
+import { initializeProjectDirect } from './direct-functions/initialize-project-direct.js';
 
 // Re-export utility functions
 export { findTasksJsonPath } from './utils/path-utils.js';
 
 // Re-export AI client utilities
 export {
-  getAnthropicClientForMCP, 
+	getAnthropicClientForMCP,
-  getPerplexityClientForMCP, 
+	getPerplexityClientForMCP,
-  getModelConfig, 
+	getModelConfig,
-  getBestAvailableAIModel,
+	getBestAvailableAIModel,
-  handleClaudeError
+	handleClaudeError
 } from './utils/ai-client-utils.js';
 
 // Use Map for potential future enhancements like introspection or dynamic dispatch
 export const directFunctions = new Map([
-  ['listTasksDirect', listTasksDirect],
+	['listTasksDirect', listTasksDirect],
-  ['getCacheStatsDirect', getCacheStatsDirect],
+	['getCacheStatsDirect', getCacheStatsDirect],
-  ['parsePRDDirect', parsePRDDirect],
+	['parsePRDDirect', parsePRDDirect],
-  ['updateTasksDirect', updateTasksDirect],
+	['updateTasksDirect', updateTasksDirect],
-  ['updateTaskByIdDirect', updateTaskByIdDirect],
+	['updateTaskByIdDirect', updateTaskByIdDirect],
-  ['updateSubtaskByIdDirect', updateSubtaskByIdDirect],
+	['updateSubtaskByIdDirect', updateSubtaskByIdDirect],
-  ['generateTaskFilesDirect', generateTaskFilesDirect],
+	['generateTaskFilesDirect', generateTaskFilesDirect],
-  ['setTaskStatusDirect', setTaskStatusDirect],
+	['setTaskStatusDirect', setTaskStatusDirect],
-  ['showTaskDirect', showTaskDirect],
+	['showTaskDirect', showTaskDirect],
-  ['nextTaskDirect', nextTaskDirect],
+	['nextTaskDirect', nextTaskDirect],
-  ['expandTaskDirect', expandTaskDirect],
+	['expandTaskDirect', expandTaskDirect],
-  ['addTaskDirect', addTaskDirect],
+	['addTaskDirect', addTaskDirect],
-  ['addSubtaskDirect', addSubtaskDirect],
+	['addSubtaskDirect', addSubtaskDirect],
-  ['removeSubtaskDirect', removeSubtaskDirect],
+	['removeSubtaskDirect', removeSubtaskDirect],
-  ['analyzeTaskComplexityDirect', analyzeTaskComplexityDirect],
+	['analyzeTaskComplexityDirect', analyzeTaskComplexityDirect],
-  ['clearSubtasksDirect', clearSubtasksDirect],
+	['clearSubtasksDirect', clearSubtasksDirect],
-  ['expandAllTasksDirect', expandAllTasksDirect],
+	['expandAllTasksDirect', expandAllTasksDirect],
-  ['removeDependencyDirect', removeDependencyDirect],
+	['removeDependencyDirect', removeDependencyDirect],
-  ['validateDependenciesDirect', validateDependenciesDirect],
+	['validateDependenciesDirect', validateDependenciesDirect],
-  ['fixDependenciesDirect', fixDependenciesDirect],
+	['fixDependenciesDirect', fixDependenciesDirect],
-  ['complexityReportDirect', complexityReportDirect],
+	['complexityReportDirect', complexityReportDirect],
-  ['addDependencyDirect', addDependencyDirect],
+	['addDependencyDirect', addDependencyDirect],
-  ['removeTaskDirect', removeTaskDirect]
+	['removeTaskDirect', removeTaskDirect]
 ]);
 
 // Re-export all direct function implementations
 export {
-  listTasksDirect,
+	listTasksDirect,
-  getCacheStatsDirect,
+	getCacheStatsDirect,
-  parsePRDDirect,
+	parsePRDDirect,
-  updateTasksDirect,
+	updateTasksDirect,
-  updateTaskByIdDirect,
+	updateTaskByIdDirect,
-  updateSubtaskByIdDirect,
+	updateSubtaskByIdDirect,
-  generateTaskFilesDirect,
+	generateTaskFilesDirect,
-  setTaskStatusDirect,
+	setTaskStatusDirect,
-  showTaskDirect,
+	showTaskDirect,
-  nextTaskDirect,
+	nextTaskDirect,
-  expandTaskDirect,
+	expandTaskDirect,
-  addTaskDirect,
+	addTaskDirect,
-  addSubtaskDirect,
+	addSubtaskDirect,
-  removeSubtaskDirect,
+	removeSubtaskDirect,
-  analyzeTaskComplexityDirect,
+	analyzeTaskComplexityDirect,
-  clearSubtasksDirect,
+	clearSubtasksDirect,
-  expandAllTasksDirect,
+	expandAllTasksDirect,
-  removeDependencyDirect,
+	removeDependencyDirect,
-  validateDependenciesDirect,
+	validateDependenciesDirect,
-  fixDependenciesDirect,
+	fixDependenciesDirect,
-  complexityReportDirect,
+	complexityReportDirect,
-  addDependencyDirect,
+	addDependencyDirect,
-  removeTaskDirect
+	removeTaskDirect,
+	initializeProjectDirect
 };

mcp-server/src/core/utils/ai-client-utils.js

@@ -11,9 +11,9 @@ dotenv.config();
 
 // Default model configuration from CLI environment
 const DEFAULT_MODEL_CONFIG = {
-  model: 'claude-3-7-sonnet-20250219',
+	model: 'claude-3-7-sonnet-20250219',
-  maxTokens: 64000,
+	maxTokens: 64000,
-  temperature: 0.2
+	temperature: 0.2
 };
 
 /**
@@ -24,25 +24,28 @@ const DEFAULT_MODEL_CONFIG = {
  * @throws {Error} If API key is missing
  */
 export function getAnthropicClientForMCP(session, log = console) {
-  try {
+	try {
-    // Extract API key from session.env or fall back to environment variables
+		// Extract API key from session.env or fall back to environment variables
-    const apiKey = session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
+		const apiKey =
+			session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY;
 
-    if (!apiKey) {
+		if (!apiKey) {
-      throw new Error('ANTHROPIC_API_KEY not found in session environment or process.env');
+			throw new Error(
-    }
+				'ANTHROPIC_API_KEY not found in session environment or process.env'
+			);
+		}
 
-    // Initialize and return a new Anthropic client
+		// Initialize and return a new Anthropic client
-    return new Anthropic({ 
+		return new Anthropic({
-      apiKey,
+			apiKey,
-      defaultHeaders: {
+			defaultHeaders: {
-        'anthropic-beta': 'output-128k-2025-02-19'  // Include header for increased token limit
+				'anthropic-beta': 'output-128k-2025-02-19' // Include header for increased token limit
-      }
+			}
-    });
+		});
-  } catch (error) {
+	} catch (error) {
-    log.error(`Failed to initialize Anthropic client: ${error.message}`);
+		log.error(`Failed to initialize Anthropic client: ${error.message}`);
-    throw error;
+		throw error;
-  }
+	}
 }
 
 /**
@@ -53,26 +56,29 @@ export function getAnthropicClientForMCP(session, log = console) {
  * @throws {Error} If API key is missing or OpenAI package can't be imported
  */
 export async function getPerplexityClientForMCP(session, log = console) {
-  try {
+	try {
-    // Extract API key from session.env or fall back to environment variables
+		// Extract API key from session.env or fall back to environment variables
-    const apiKey = session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY;
+		const apiKey =
+			session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY;
 
-    if (!apiKey) {
+		if (!apiKey) {
-      throw new Error('PERPLEXITY_API_KEY not found in session environment or process.env');
+			throw new Error(
-    }
+				'PERPLEXITY_API_KEY not found in session environment or process.env'
+			);
+		}
 
-    // Dynamically import OpenAI (it may not be used in all contexts)
+		// Dynamically import OpenAI (it may not be used in all contexts)
-    const { default: OpenAI } = await import('openai');
+		const { default: OpenAI } = await import('openai');
 
-    // Initialize and return a new OpenAI client configured for Perplexity
+		// Initialize and return a new OpenAI client configured for Perplexity
-    return new OpenAI({
+		return new OpenAI({
-      apiKey, 
+			apiKey,
-      baseURL: 'https://api.perplexity.ai'
+			baseURL: 'https://api.perplexity.ai'
-    });
+		});
-  } catch (error) {
+	} catch (error) {
-    log.error(`Failed to initialize Perplexity client: ${error.message}`);
+		log.error(`Failed to initialize Perplexity client: ${error.message}`);
-    throw error;
+		throw error;
-  }
+	}
 }
 
 /**
@@ -82,12 +88,12 @@ export async function getPerplexityClientForMCP(session, log = console) {
  * @returns {Object} Model configuration with model, maxTokens, and temperature
  */
 export function getModelConfig(session, defaults = DEFAULT_MODEL_CONFIG) {
-  // Get values from session or fall back to defaults
+	// Get values from session or fall back to defaults
-  return {
+	return {
-    model: session?.env?.MODEL || defaults.model,
+		model: session?.env?.MODEL || defaults.model,
-    maxTokens: parseInt(session?.env?.MAX_TOKENS || defaults.maxTokens),
+		maxTokens: parseInt(session?.env?.MAX_TOKENS || defaults.maxTokens),
-    temperature: parseFloat(session?.env?.TEMPERATURE || defaults.temperature)
+		temperature: parseFloat(session?.env?.TEMPERATURE || defaults.temperature)
-  };
+	};
 }
 
 /**
@@ -100,59 +106,78 @@ export function getModelConfig(session, defaults = DEFAULT_MODEL_CONFIG) {
  * @returns {Promise<Object>} Selected model info with type and client
  * @throws {Error} If no AI models are available
  */
-export async function getBestAvailableAIModel(session, options = {}, log = console) {
+export async function getBestAvailableAIModel(
-  const { requiresResearch = false, claudeOverloaded = false } = options;
+	session,
+	options = {},
+	log = console
+) {
+	const { requiresResearch = false, claudeOverloaded = false } = options;
 
-  // Test case: When research is needed but no Perplexity, use Claude
+	// Test case: When research is needed but no Perplexity, use Claude
-  if (requiresResearch && 
+	if (
-      !(session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY) && 
+		requiresResearch &&
-      (session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)) {
+		!(session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY) &&
-    try {
+		(session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)
-      log.warn('Perplexity not available for research, using Claude');
+	) {
-      const client = getAnthropicClientForMCP(session, log);
+		try {
-      return { type: 'claude', client };
+			log.warn('Perplexity not available for research, using Claude');
-    } catch (error) {
+			const client = getAnthropicClientForMCP(session, log);
-      log.error(`Claude not available: ${error.message}`);
+			return { type: 'claude', client };
-      throw new Error('No AI models available for research');
+		} catch (error) {
-    }
+			log.error(`Claude not available: ${error.message}`);
-  }
+			throw new Error('No AI models available for research');
+		}
+	}
 
-  // Regular path: Perplexity for research when available
+	// Regular path: Perplexity for research when available
-  if (requiresResearch && (session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY)) {
+	if (
-    try {
+		requiresResearch &&
-      const client = await getPerplexityClientForMCP(session, log);
+		(session?.env?.PERPLEXITY_API_KEY || process.env.PERPLEXITY_API_KEY)
-      return { type: 'perplexity', client };
+	) {
-    } catch (error) {
+		try {
-      log.warn(`Perplexity not available: ${error.message}`);
+			const client = await getPerplexityClientForMCP(session, log);
-      // Fall through to Claude as backup
+			return { type: 'perplexity', client };
-    }
+		} catch (error) {
-  }
+			log.warn(`Perplexity not available: ${error.message}`);
+			// Fall through to Claude as backup
+		}
+	}
 
-  // Test case: Claude for overloaded scenario
+	// Test case: Claude for overloaded scenario
-  if (claudeOverloaded && (session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)) {
+	if (
-    try {
+		claudeOverloaded &&
-      log.warn('Claude is overloaded but no alternatives are available. Proceeding with Claude anyway.');
+		(session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)
-      const client = getAnthropicClientForMCP(session, log);
+	) {
-      return { type: 'claude', client };
+		try {
-    } catch (error) {
+			log.warn(
-      log.error(`Claude not available despite being overloaded: ${error.message}`);
+				'Claude is overloaded but no alternatives are available. Proceeding with Claude anyway.'
-      throw new Error('No AI models available');
+			);
-    }
+			const client = getAnthropicClientForMCP(session, log);
-  }
+			return { type: 'claude', client };
+		} catch (error) {
+			log.error(
+				`Claude not available despite being overloaded: ${error.message}`
+			);
+			throw new Error('No AI models available');
+		}
+	}
 
-  // Default case: Use Claude when available and not overloaded
+	// Default case: Use Claude when available and not overloaded
-  if (!claudeOverloaded && (session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)) {
+	if (
-    try {
+		!claudeOverloaded &&
-      const client = getAnthropicClientForMCP(session, log);
+		(session?.env?.ANTHROPIC_API_KEY || process.env.ANTHROPIC_API_KEY)
-      return { type: 'claude', client };
+	) {
-    } catch (error) {
+		try {
-      log.warn(`Claude not available: ${error.message}`);
+			const client = getAnthropicClientForMCP(session, log);
-      // Fall through to error if no other options
+			return { type: 'claude', client };
-    }
+		} catch (error) {
-  }
+			log.warn(`Claude not available: ${error.message}`);
+			// Fall through to error if no other options
+		}
+	}
 
-  // If we got here, no models were successfully initialized
+	// If we got here, no models were successfully initialized
-  throw new Error('No AI models available. Please check your API keys.');
+	throw new Error('No AI models available. Please check your API keys.');
 }
 
 /**
@@ -161,28 +186,28 @@ export async function getBestAvailableAIModel(session, options = {}, log = conso
  * @returns {string} User-friendly error message
  */
 export function handleClaudeError(error) {
-  // Check if it's a structured error response
+	// Check if it's a structured error response
-  if (error.type === 'error' && error.error) {
+	if (error.type === 'error' && error.error) {
-    switch (error.error.type) {
+		switch (error.error.type) {
-      case 'overloaded_error':
+			case 'overloaded_error':
-        return 'Claude is currently experiencing high demand and is overloaded. Please wait a few minutes and try again.';
+				return 'Claude is currently experiencing high demand and is overloaded. Please wait a few minutes and try again.';
-      case 'rate_limit_error':
+			case 'rate_limit_error':
-        return 'You have exceeded the rate limit. Please wait a few minutes before making more requests.';
+				return 'You have exceeded the rate limit. Please wait a few minutes before making more requests.';
-      case 'invalid_request_error':
+			case 'invalid_request_error':
-        return 'There was an issue with the request format. If this persists, please report it as a bug.';
+				return 'There was an issue with the request format. If this persists, please report it as a bug.';
-      default:
+			default:
-        return `Claude API error: ${error.error.message}`;
+				return `Claude API error: ${error.error.message}`;
-    }
+		}
-  }
+	}
 
-  // Check for network/timeout errors
+	// Check for network/timeout errors
-  if (error.message?.toLowerCase().includes('timeout')) {
+	if (error.message?.toLowerCase().includes('timeout')) {
-    return 'The request to Claude timed out. Please try again.';
+		return 'The request to Claude timed out. Please try again.';
-  }
+	}
-  if (error.message?.toLowerCase().includes('network')) {
+	if (error.message?.toLowerCase().includes('network')) {
-    return 'There was a network error connecting to Claude. Please check your internet connection and try again.';
+		return 'There was a network error connecting to Claude. Please check your internet connection and try again.';
-  }
+	}
 
-  // Default error message
+	// Default error message
-  return `Error communicating with Claude: ${error.message}`;
+	return `Error communicating with Claude: ${error.message}`;
 }

mcp-server/src/core/utils/async-manager.js

@@ -1,213 +1,247 @@
 import { v4 as uuidv4 } from 'uuid';
 
 class AsyncOperationManager {
-    constructor() {
+	constructor() {
-        this.operations = new Map(); // Stores active operation state
+		this.operations = new Map(); // Stores active operation state
-        this.completedOperations = new Map(); // Stores completed operations
+		this.completedOperations = new Map(); // Stores completed operations
-        this.maxCompletedOperations = 100; // Maximum number of completed operations to store
+		this.maxCompletedOperations = 100; // Maximum number of completed operations to store
-        this.listeners = new Map(); // For potential future notifications
+		this.listeners = new Map(); // For potential future notifications
-    }
+	}
 
-    /**
+	/**
-     * Adds an operation to be executed asynchronously.
+	 * Adds an operation to be executed asynchronously.
-     * @param {Function} operationFn - The async function to execute (e.g., a Direct function).
+	 * @param {Function} operationFn - The async function to execute (e.g., a Direct function).
-     * @param {Object} args - Arguments to pass to the operationFn.
+	 * @param {Object} args - Arguments to pass to the operationFn.
-     * @param {Object} context - The MCP tool context { log, reportProgress, session }.
+	 * @param {Object} context - The MCP tool context { log, reportProgress, session }.
-     * @returns {string} The unique ID assigned to this operation.
+	 * @returns {string} The unique ID assigned to this operation.
-     */
+	 */
-    addOperation(operationFn, args, context) {
+	addOperation(operationFn, args, context) {
-        const operationId = `op-${uuidv4()}`;
+		const operationId = `op-${uuidv4()}`;
-        const operation = {
+		const operation = {
-            id: operationId,
+			id: operationId,
-            status: 'pending',
+			status: 'pending',
-            startTime: Date.now(),
+			startTime: Date.now(),
-            endTime: null,
+			endTime: null,
-            result: null,
+			result: null,
-            error: null,
+			error: null,
-            // Store necessary parts of context, especially log for background execution
+			// Store necessary parts of context, especially log for background execution
-            log: context.log, 
+			log: context.log,
-            reportProgress: context.reportProgress, // Pass reportProgress through
+			reportProgress: context.reportProgress, // Pass reportProgress through
-            session: context.session // Pass session through if needed by the operationFn
+			session: context.session // Pass session through if needed by the operationFn
-        };
+		};
-        this.operations.set(operationId, operation);
+		this.operations.set(operationId, operation);
-        this.log(operationId, 'info', `Operation added.`);
+		this.log(operationId, 'info', `Operation added.`);
 
-        // Start execution in the background (don't await here)
+		// Start execution in the background (don't await here)
-        this._runOperation(operationId, operationFn, args, context).catch(err => {
+		this._runOperation(operationId, operationFn, args, context).catch((err) => {
-            // Catch unexpected errors during the async execution setup itself
+			// Catch unexpected errors during the async execution setup itself
-             this.log(operationId, 'error', `Critical error starting operation: ${err.message}`, { stack: err.stack });
+			this.log(
-             operation.status = 'failed';
+				operationId,
-             operation.error = { code: 'MANAGER_EXECUTION_ERROR', message: err.message };
+				'error',
-             operation.endTime = Date.now();
+				`Critical error starting operation: ${err.message}`,
+				{ stack: err.stack }
+			);
+			operation.status = 'failed';
+			operation.error = {
+				code: 'MANAGER_EXECUTION_ERROR',
+				message: err.message
+			};
+			operation.endTime = Date.now();
 
-             // Move to completed operations
+			// Move to completed operations
-             this._moveToCompleted(operationId);
+			this._moveToCompleted(operationId);
-        });
+		});
 
-        return operationId;
+		return operationId;
-    }
+	}
 
-    /**
+	/**
-     * Internal function to execute the operation.
+	 * Internal function to execute the operation.
-     * @param {string} operationId - The ID of the operation.
+	 * @param {string} operationId - The ID of the operation.
-     * @param {Function} operationFn - The async function to execute.
+	 * @param {Function} operationFn - The async function to execute.
-     * @param {Object} args - Arguments for the function.
+	 * @param {Object} args - Arguments for the function.
-     * @param {Object} context - The original MCP tool context.
+	 * @param {Object} context - The original MCP tool context.
-     */
+	 */
-    async _runOperation(operationId, operationFn, args, context) {
+	async _runOperation(operationId, operationFn, args, context) {
-        const operation = this.operations.get(operationId);
+		const operation = this.operations.get(operationId);
-        if (!operation) return; // Should not happen
+		if (!operation) return; // Should not happen
 
-        operation.status = 'running';
+		operation.status = 'running';
-        this.log(operationId, 'info', `Operation running.`);
+		this.log(operationId, 'info', `Operation running.`);
-        this.emit('statusChanged', { operationId, status: 'running' });
+		this.emit('statusChanged', { operationId, status: 'running' });
 
-        try {
+		try {
-            // Pass the necessary context parts to the direct function
+			// Pass the necessary context parts to the direct function
-            // The direct function needs to be adapted if it needs reportProgress
+			// The direct function needs to be adapted if it needs reportProgress
-            // We pass the original context's log, plus our wrapped reportProgress
+			// We pass the original context's log, plus our wrapped reportProgress
-            const result = await operationFn(args, operation.log, { 
+			const result = await operationFn(args, operation.log, {
-                reportProgress: (progress) => this._handleProgress(operationId, progress), 
+				reportProgress: (progress) =>
-                mcpLog: operation.log, // Pass log as mcpLog if direct fn expects it
+					this._handleProgress(operationId, progress),
-                session: operation.session 
+				mcpLog: operation.log, // Pass log as mcpLog if direct fn expects it
-            });
+				session: operation.session
+			});
 
-            operation.status = result.success ? 'completed' : 'failed';
+			operation.status = result.success ? 'completed' : 'failed';
-            operation.result = result.success ? result.data : null;
+			operation.result = result.success ? result.data : null;
-            operation.error = result.success ? null : result.error;
+			operation.error = result.success ? null : result.error;
-            this.log(operationId, 'info', `Operation finished with status: ${operation.status}`);
+			this.log(
+				operationId,
+				'info',
+				`Operation finished with status: ${operation.status}`
+			);
+		} catch (error) {
+			this.log(
+				operationId,
+				'error',
+				`Operation failed with error: ${error.message}`,
+				{ stack: error.stack }
+			);
+			operation.status = 'failed';
+			operation.error = {
+				code: 'OPERATION_EXECUTION_ERROR',
+				message: error.message
+			};
+		} finally {
+			operation.endTime = Date.now();
+			this.emit('statusChanged', {
+				operationId,
+				status: operation.status,
+				result: operation.result,
+				error: operation.error
+			});
 
-        } catch (error) {
+			// Move to completed operations if done or failed
-            this.log(operationId, 'error', `Operation failed with error: ${error.message}`, { stack: error.stack });
+			if (operation.status === 'completed' || operation.status === 'failed') {
-            operation.status = 'failed';
+				this._moveToCompleted(operationId);
-            operation.error = { code: 'OPERATION_EXECUTION_ERROR', message: error.message };
+			}
-        } finally {
+		}
-            operation.endTime = Date.now();
+	}
-            this.emit('statusChanged', { operationId, status: operation.status, result: operation.result, error: operation.error });
 
-            // Move to completed operations if done or failed
+	/**
-            if (operation.status === 'completed' || operation.status === 'failed') {
+	 * Move an operation from active operations to completed operations history.
-                this._moveToCompleted(operationId);
+	 * @param {string} operationId - The ID of the operation to move.
-            }
+	 * @private
-        }
+	 */
-    }
+	_moveToCompleted(operationId) {
+		const operation = this.operations.get(operationId);
+		if (!operation) return;
 
-    /**
+		// Store only the necessary data in completed operations
-     * Move an operation from active operations to completed operations history.
+		const completedData = {
-     * @param {string} operationId - The ID of the operation to move.
+			id: operation.id,
-     * @private
+			status: operation.status,
-     */
+			startTime: operation.startTime,
-    _moveToCompleted(operationId) {
+			endTime: operation.endTime,
-        const operation = this.operations.get(operationId);
+			result: operation.result,
-        if (!operation) return;
+			error: operation.error
+		};
 
-        // Store only the necessary data in completed operations
+		this.completedOperations.set(operationId, completedData);
-        const completedData = {
+		this.operations.delete(operationId);
-            id: operation.id,
-            status: operation.status,
-            startTime: operation.startTime,
-            endTime: operation.endTime,
-            result: operation.result,
-            error: operation.error,
-        };
 
-        this.completedOperations.set(operationId, completedData);
+		// Trim completed operations if exceeding maximum
-        this.operations.delete(operationId);
+		if (this.completedOperations.size > this.maxCompletedOperations) {
+			// Get the oldest operation (sorted by endTime)
+			const oldest = [...this.completedOperations.entries()].sort(
+				(a, b) => a[1].endTime - b[1].endTime
+			)[0];
 
-        // Trim completed operations if exceeding maximum
+			if (oldest) {
-        if (this.completedOperations.size > this.maxCompletedOperations) {
+				this.completedOperations.delete(oldest[0]);
-            // Get the oldest operation (sorted by endTime)
+			}
-            const oldest = [...this.completedOperations.entries()]
+		}
-                .sort((a, b) => a[1].endTime - b[1].endTime)[0];
+	}
 
-            if (oldest) {
+	/**
-                this.completedOperations.delete(oldest[0]);
+	 * Handles progress updates from the running operation and forwards them.
-            }
+	 * @param {string} operationId - The ID of the operation reporting progress.
-        }
+	 * @param {Object} progress - The progress object { progress, total? }.
-    }
+	 */
+	_handleProgress(operationId, progress) {
+		const operation = this.operations.get(operationId);
+		if (operation && operation.reportProgress) {
+			try {
+				// Use the reportProgress function captured from the original context
+				operation.reportProgress(progress);
+				this.log(
+					operationId,
+					'debug',
+					`Reported progress: ${JSON.stringify(progress)}`
+				);
+			} catch (err) {
+				this.log(
+					operationId,
+					'warn',
+					`Failed to report progress: ${err.message}`
+				);
+				// Don't stop the operation, just log the reporting failure
+			}
+		}
+	}
 
-    /**
+	/**
-     * Handles progress updates from the running operation and forwards them.
+	 * Retrieves the status and result/error of an operation.
-     * @param {string} operationId - The ID of the operation reporting progress.
+	 * @param {string} operationId - The ID of the operation.
-     * @param {Object} progress - The progress object { progress, total? }.
+	 * @returns {Object | null} The operation details or null if not found.
-     */
+	 */
-    _handleProgress(operationId, progress) {
+	getStatus(operationId) {
-        const operation = this.operations.get(operationId);
+		// First check active operations
-        if (operation && operation.reportProgress) {
+		const operation = this.operations.get(operationId);
-            try {
+		if (operation) {
-                 // Use the reportProgress function captured from the original context
+			return {
-                operation.reportProgress(progress); 
+				id: operation.id,
-                this.log(operationId, 'debug', `Reported progress: ${JSON.stringify(progress)}`);
+				status: operation.status,
-            } catch(err) {
+				startTime: operation.startTime,
-                this.log(operationId, 'warn', `Failed to report progress: ${err.message}`);
+				endTime: operation.endTime,
-                // Don't stop the operation, just log the reporting failure
+				result: operation.result,
-            }
+				error: operation.error
-        }
+			};
-     }
+		}
 
-    /**
+		// Then check completed operations
-     * Retrieves the status and result/error of an operation.
+		const completedOperation = this.completedOperations.get(operationId);
-     * @param {string} operationId - The ID of the operation.
+		if (completedOperation) {
-     * @returns {Object | null} The operation details or null if not found.
+			return completedOperation;
-     */
+		}
-    getStatus(operationId) {
-        // First check active operations
-        const operation = this.operations.get(operationId);
-        if (operation) {
-            return {
-                id: operation.id,
-                status: operation.status,
-                startTime: operation.startTime,
-                endTime: operation.endTime,
-                result: operation.result,
-                error: operation.error,
-            };
-        }
 
-        // Then check completed operations
+		// Operation not found in either active or completed
-        const completedOperation = this.completedOperations.get(operationId);
+		return {
-        if (completedOperation) {
+			error: {
-            return completedOperation;
+				code: 'OPERATION_NOT_FOUND',
-        }
+				message: `Operation ID ${operationId} not found. It may have been completed and removed from history, or the ID may be invalid.`
+			},
+			status: 'not_found'
+		};
+	}
 
-        // Operation not found in either active or completed
+	/**
-        return {
+	 * Internal logging helper to prefix logs with the operation ID.
-            error: {
+	 * @param {string} operationId - The ID of the operation.
-                code: 'OPERATION_NOT_FOUND',
+	 * @param {'info'|'warn'|'error'|'debug'} level - Log level.
-                message: `Operation ID ${operationId} not found. It may have been completed and removed from history, or the ID may be invalid.`
+	 * @param {string} message - Log message.
-            },
+	 * @param {Object} [meta] - Additional metadata.
-            status: 'not_found'
+	 */
-        };
+	log(operationId, level, message, meta = {}) {
-    }
+		const operation = this.operations.get(operationId);
+		// Use the logger instance associated with the operation if available, otherwise console
+		const logger = operation?.log || console;
+		const logFn = logger[level] || logger.log || console.log; // Fallback
+		logFn(`[AsyncOp ${operationId}] ${message}`, meta);
+	}
 
-     /**
+	// --- Basic Event Emitter ---
-     * Internal logging helper to prefix logs with the operation ID.
+	on(eventName, listener) {
-     * @param {string} operationId - The ID of the operation.
+		if (!this.listeners.has(eventName)) {
-     * @param {'info'|'warn'|'error'|'debug'} level - Log level.
+			this.listeners.set(eventName, []);
-     * @param {string} message - Log message.
+		}
-     * @param {Object} [meta] - Additional metadata.
+		this.listeners.get(eventName).push(listener);
-     */
+	}
-    log(operationId, level, message, meta = {}) {
-         const operation = this.operations.get(operationId);
-         // Use the logger instance associated with the operation if available, otherwise console
-         const logger = operation?.log || console;
-         const logFn = logger[level] || logger.log || console.log; // Fallback
-         logFn(`[AsyncOp ${operationId}] ${message}`, meta);
-     }
 
-    // --- Basic Event Emitter ---
+	emit(eventName, data) {
-    on(eventName, listener) {
+		if (this.listeners.has(eventName)) {
-        if (!this.listeners.has(eventName)) {
+			this.listeners.get(eventName).forEach((listener) => listener(data));
-            this.listeners.set(eventName, []);
+		}
-        }
+	}
-        this.listeners.get(eventName).push(listener);
-    }
-
-    emit(eventName, data) {
-        if (this.listeners.has(eventName)) {
-            this.listeners.get(eventName).forEach(listener => listener(data));
-        }
-    }
 }
 
 // Export a singleton instance

mcp-server/src/core/utils/env-utils.js

@@ -6,38 +6,42 @@
  * @returns {Promise<any>} The result of the actionFn.
  */
 export async function withSessionEnv(sessionEnv, actionFn) {
-    if (!sessionEnv || typeof sessionEnv !== 'object' || Object.keys(sessionEnv).length === 0) {
+	if (
-      // If no sessionEnv is provided, just run the action directly
+		!sessionEnv ||
-      return await actionFn();
+		typeof sessionEnv !== 'object' ||
-    }
+		Object.keys(sessionEnv).length === 0
+	) {
+		// If no sessionEnv is provided, just run the action directly
+		return await actionFn();
+	}
 
-    const originalEnv = {};
+	const originalEnv = {};
-    const keysToRestore = [];
+	const keysToRestore = [];
 
-    // Set environment variables from sessionEnv
+	// Set environment variables from sessionEnv
-    for (const key in sessionEnv) {
+	for (const key in sessionEnv) {
-      if (Object.prototype.hasOwnProperty.call(sessionEnv, key)) {
+		if (Object.prototype.hasOwnProperty.call(sessionEnv, key)) {
-        // Store original value if it exists, otherwise mark for deletion
+			// Store original value if it exists, otherwise mark for deletion
-        if (process.env[key] !== undefined) {
+			if (process.env[key] !== undefined) {
-          originalEnv[key] = process.env[key];
+				originalEnv[key] = process.env[key];
-        }
+			}
-        keysToRestore.push(key);
+			keysToRestore.push(key);
-        process.env[key] = sessionEnv[key];
+			process.env[key] = sessionEnv[key];
-      }
+		}
-    }
+	}
 
-    try {
+	try {
-      // Execute the provided action function
+		// Execute the provided action function
-      return await actionFn();
+		return await actionFn();
-    } finally {
+	} finally {
-      // Restore original environment variables
+		// Restore original environment variables
-      for (const key of keysToRestore) {
+		for (const key of keysToRestore) {
-        if (Object.prototype.hasOwnProperty.call(originalEnv, key)) {
+			if (Object.prototype.hasOwnProperty.call(originalEnv, key)) {
-          process.env[key] = originalEnv[key];
+				process.env[key] = originalEnv[key];
-        } else {
+			} else {
-          // If the key didn't exist originally, delete it
+				// If the key didn't exist originally, delete it
-          delete process.env[key];
+				delete process.env[key];
-        }
+			}
-      }
+		}
-    }
+	}
-  } 
+}

mcp-server/src/core/utils/path-utils.js

@@ -12,49 +12,49 @@ import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import os from 'os';
+// Removed lastFoundProjectRoot as it's not suitable for MCP server
+// Assuming getProjectRootFromSession is available
+import { getProjectRootFromSession } from '../../tools/utils.js';
 
-// Store last found project root to improve performance on subsequent calls (primarily for CLI)
+// Project marker files that indicate a potential project root (can be kept for potential future use or logging)
-export let lastFoundProjectRoot = null;
-
-// Project marker files that indicate a potential project root
 export const PROJECT_MARKERS = [
-  // Task Master specific
+	// Task Master specific
-  'tasks.json',
+	'tasks.json',
-  'tasks/tasks.json',
+	'tasks/tasks.json',
 
-  // Common version control
+	// Common version control
-  '.git',
+	'.git',
-  '.svn',
+	'.svn',
 
-  // Common package files
+	// Common package files
-  'package.json',
+	'package.json',
-  'pyproject.toml',
+	'pyproject.toml',
-  'Gemfile',
+	'Gemfile',
-  'go.mod',
+	'go.mod',
-  'Cargo.toml',
+	'Cargo.toml',
 
-  // Common IDE/editor folders
+	// Common IDE/editor folders
-  '.cursor',
+	'.cursor',
-  '.vscode',
+	'.vscode',
-  '.idea',
+	'.idea',
 
-  // Common dependency directories (check if directory)
+	// Common dependency directories (check if directory)
-  'node_modules',
+	'node_modules',
-  'venv',
+	'venv',
-  '.venv',
+	'.venv',
 
-  // Common config files
+	// Common config files
-  '.env',
+	'.env',
-  '.eslintrc',
+	'.eslintrc',
-  'tsconfig.json',
+	'tsconfig.json',
-  'babel.config.js',
+	'babel.config.js',
-  'jest.config.js',
+	'jest.config.js',
-  'webpack.config.js',
+	'webpack.config.js',
 
-  // Common CI/CD files
+	// Common CI/CD files
-  '.github/workflows',
+	'.github/workflows',
-  '.gitlab-ci.yml',
+	'.gitlab-ci.yml',
-  '.circleci/config.yml'
+	'.circleci/config.yml'
 ];
 
 /**
@@ -63,210 +63,308 @@ export const PROJECT_MARKERS = [
  * @returns {string} - Absolute path to the package installation directory
  */
 export function getPackagePath() {
-  // When running from source, __dirname is the directory containing this file
+	// When running from source, __dirname is the directory containing this file
-  // When running from npm, we need to find the package root
+	// When running from npm, we need to find the package root
-  const thisFilePath = fileURLToPath(import.meta.url);
+	const thisFilePath = fileURLToPath(import.meta.url);
-  const thisFileDir = path.dirname(thisFilePath);
+	const thisFileDir = path.dirname(thisFilePath);
 
-  // Navigate from core/utils up to the package root
+	// Navigate from core/utils up to the package root
-  // In dev: /path/to/task-master/mcp-server/src/core/utils -> /path/to/task-master
+	// In dev: /path/to/task-master/mcp-server/src/core/utils -> /path/to/task-master
-  // In npm: /path/to/node_modules/task-master/mcp-server/src/core/utils -> /path/to/node_modules/task-master
+	// In npm: /path/to/node_modules/task-master/mcp-server/src/core/utils -> /path/to/node_modules/task-master
-  return path.resolve(thisFileDir, '../../../../');
+	return path.resolve(thisFileDir, '../../../../');
 }
 
 /**
- * Finds the absolute path to the tasks.json file based on project root and arguments.
+ * Finds the absolute path to the tasks.json file and returns the validated project root.
+ * Determines the project root using args and session, validates it, searches for tasks.json.
+ *
  * @param {Object} args - Command arguments, potentially including 'projectRoot' and 'file'.
  * @param {Object} log - Logger object.
- * @returns {string} - Absolute path to the tasks.json file.
+ * @param {Object} session - MCP session object.
- * @throws {Error} - If tasks.json cannot be found.
+ * @returns {Promise<{tasksPath: string, validatedProjectRoot: string}>} - Object containing absolute path to tasks.json and the validated root.
+ * @throws {Error} - If a valid project root cannot be determined or tasks.json cannot be found.
  */
-export function findTasksJsonPath(args, log) {
+export function findTasksJsonPath(args, log, session) {
-  // PRECEDENCE ORDER for finding tasks.json:
+	const homeDir = os.homedir();
-  // 1. Explicitly provided `projectRoot` in args (Highest priority, expected in MCP context)
+	let targetDirectory = null;
-  // 2. Previously found/cached `lastFoundProjectRoot` (primarily for CLI performance)
+	let rootSource = 'unknown';
-  // 3. Search upwards from current working directory (`process.cwd()`) - CLI usage
 
-  // 1. If project root is explicitly provided (e.g., from MCP session), use it directly
+	log.info(
-  if (args.projectRoot) {
+		`Finding tasks.json path. Args: ${JSON.stringify(args)}, Session available: ${!!session}`
-    const projectRoot = args.projectRoot;
+	);
-    log.info(`Using explicitly provided project root: ${projectRoot}`);
-    try {
-      // This will throw if tasks.json isn't found within this root
-      return findTasksJsonInDirectory(projectRoot, args.file, log); 
-    } catch (error) {
-      // Include debug info in error
-      const debugInfo = {
-        projectRoot,
-        currentDir: process.cwd(),
-        serverDir: path.dirname(process.argv[1]),
-        possibleProjectRoot: path.resolve(path.dirname(process.argv[1]), '../..'),
-        lastFoundProjectRoot,
-        searchedPaths: error.message
-      };
 
-      error.message = `Tasks file not found in any of the expected locations relative to project root "${projectRoot}" (from session).\nDebug Info: ${JSON.stringify(debugInfo, null, 2)}`;
+	// --- Determine Target Directory ---
-      throw error;
+	if (
-    }
+		args.projectRoot &&
-  }
+		args.projectRoot !== '/' &&
+		args.projectRoot !== homeDir
+	) {
+		log.info(`Using projectRoot directly from args: ${args.projectRoot}`);
+		targetDirectory = args.projectRoot;
+		rootSource = 'args.projectRoot';
+	} else {
+		log.warn(
+			`args.projectRoot ('${args.projectRoot}') is missing or invalid. Attempting to derive from session.`
+		);
+		const sessionDerivedPath = getProjectRootFromSession(session, log);
+		if (
+			sessionDerivedPath &&
+			sessionDerivedPath !== '/' &&
+			sessionDerivedPath !== homeDir
+		) {
+			log.info(
+				`Using project root derived from session: ${sessionDerivedPath}`
+			);
+			targetDirectory = sessionDerivedPath;
+			rootSource = 'session';
+		} else {
+			log.error(
+				`Could not derive a valid project root from session. Session path='${sessionDerivedPath}'`
+			);
+		}
+	}
 
-  // --- Fallback logic primarily for CLI or when projectRoot isn't passed --- 
+	// --- Validate the final targetDirectory ---
+	if (!targetDirectory) {
+		const error = new Error(
+			`Cannot find tasks.json: Could not determine a valid project root directory. Please ensure a workspace/folder is open or specify projectRoot.`
+		);
+		error.code = 'INVALID_PROJECT_ROOT';
+		error.details = {
+			attemptedArgsProjectRoot: args.projectRoot,
+			sessionAvailable: !!session,
+			// Add session derived path attempt for better debugging
+			attemptedSessionDerivedPath: getProjectRootFromSession(session, {
+				info: () => {},
+				warn: () => {},
+				error: () => {}
+			}), // Call again silently for details
+			finalDeterminedRoot: targetDirectory // Will be null here
+		};
+		log.error(`Validation failed: ${error.message}`, error.details);
+		throw error;
+	}
 
-  // 2. If we have a last known project root that worked, try it first
+	// --- Verify targetDirectory exists ---
-  if (lastFoundProjectRoot) {
+	if (!fs.existsSync(targetDirectory)) {
-    log.info(`Trying last known project root: ${lastFoundProjectRoot}`);
+		const error = new Error(
-    try {
+			`Determined project root directory does not exist: ${targetDirectory}`
-      // Use the cached root
+		);
-      const tasksPath = findTasksJsonInDirectory(lastFoundProjectRoot, args.file, log); 
+		error.code = 'PROJECT_ROOT_NOT_FOUND';
-      return tasksPath; // Return if found in cached root
+		error.details = {
-    } catch (error) {
+			/* ... add details ... */
-      log.info(`Task file not found in last known project root, continuing search.`);
+		};
-      // Continue with search if not found in cache
+		log.error(error.message, error.details);
-    }
+		throw error;
-  }
+	}
+	if (!fs.statSync(targetDirectory).isDirectory()) {
+		const error = new Error(
+			`Determined project root path is not a directory: ${targetDirectory}`
+		);
+		error.code = 'PROJECT_ROOT_NOT_A_DIRECTORY';
+		error.details = {
+			/* ... add details ... */
+		};
+		log.error(error.message, error.details);
+		throw error;
+	}
 
-  // 3. Start search from current directory (most common CLI scenario)
+	// --- Search within the validated targetDirectory ---
-  const startDir = process.cwd();
+	log.info(
-  log.info(`Searching for tasks.json starting from current directory: ${startDir}`);
+		`Validated project root (${rootSource}): ${targetDirectory}. Searching for tasks file.`
-  
+	);
-  // Try to find tasks.json by walking up the directory tree from cwd
+	try {
-  try {
+		const tasksPath = findTasksJsonInDirectory(targetDirectory, args.file, log);
-    // This will throw if not found in the CWD tree
+		// Return both the tasks path and the validated root
-    return findTasksJsonWithParentSearch(startDir, args.file, log); 
+		return { tasksPath: tasksPath, validatedProjectRoot: targetDirectory };
-  } catch (error) {
+	} catch (error) {
-    // If all attempts fail, augment and throw the original error from CWD search
+		// Augment the error
-    error.message = `${error.message}\n\nPossible solutions:\n1. Run the command from your project directory containing tasks.json\n2. Use --project-root=/path/to/project to specify the project location (if using CLI)\n3. Ensure the project root is correctly passed from the client (if using MCP)\n\nCurrent working directory: ${startDir}\nLast known project root: ${lastFoundProjectRoot}\nProject root from args: ${args.projectRoot}`;
+		error.message = `Tasks file not found within validated project root "${targetDirectory}" (source: ${rootSource}). Ensure 'tasks.json' exists at the root or in a 'tasks/' subdirectory.\nOriginal Error: ${error.message}`;
-    throw error;
+		error.details = {
-  }
+			...(error.details || {}), // Keep original details if any
+			validatedProjectRoot: targetDirectory,
+			rootSource: rootSource,
+			attemptedArgsProjectRoot: args.projectRoot,
+			sessionAvailable: !!session
+		};
+		log.error(`Search failed: ${error.message}`, error.details);
+		throw error;
+	}
 }
 
 /**
- * Check if a directory contains any project marker files or directories
+ * Search for tasks.json in a specific directory (now assumes dirPath is a validated project root)
- * @param {string} dirPath - Directory to check
+ * @param {string} dirPath - The validated project root directory to search in.
- * @returns {boolean} - True if the directory contains any project markers
+ * @param {string} explicitFilePath - Optional explicit file path relative to dirPath (e.g., args.file)
- */
-function hasProjectMarkers(dirPath) {
-  return PROJECT_MARKERS.some(marker => {
-    const markerPath = path.join(dirPath, marker);
-    // Check if the marker exists as either a file or directory
-    return fs.existsSync(markerPath);
-  });
-}
-
-/**
- * Search for tasks.json in a specific directory
- * @param {string} dirPath - Directory to search in
- * @param {string} explicitFilePath - Optional explicit file path relative to dirPath
  * @param {Object} log - Logger object
  * @returns {string} - Absolute path to tasks.json
- * @throws {Error} - If tasks.json cannot be found
+ * @throws {Error} - If tasks.json cannot be found in the standard locations within dirPath.
  */
 function findTasksJsonInDirectory(dirPath, explicitFilePath, log) {
-  const possiblePaths = [];
+	const possiblePaths = [];
 
-  // 1. If a file is explicitly provided relative to dirPath
+	// 1. If an explicit file path is provided (relative to dirPath)
-  if (explicitFilePath) {
+	if (explicitFilePath) {
-    possiblePaths.push(path.resolve(dirPath, explicitFilePath));
+		// Ensure it's treated as relative to the project root if not absolute
-  }
+		const resolvedExplicitPath = path.isAbsolute(explicitFilePath)
+			? explicitFilePath
+			: path.resolve(dirPath, explicitFilePath);
+		possiblePaths.push(resolvedExplicitPath);
+		log.info(`Explicit file path provided, checking: ${resolvedExplicitPath}`);
+	}
 
-  // 2. Check the standard locations relative to dirPath
+	// 2. Check the standard locations relative to dirPath
-  possiblePaths.push(
+	possiblePaths.push(
-    path.join(dirPath, 'tasks.json'),
+		path.join(dirPath, 'tasks.json'),
-    path.join(dirPath, 'tasks', 'tasks.json')
+		path.join(dirPath, 'tasks', 'tasks.json')
-  );
+	);
 
-  log.info(`Checking potential task file paths: ${possiblePaths.join(', ')}`);
+	// Deduplicate paths in case explicitFilePath matches a standard location
+	const uniquePaths = [...new Set(possiblePaths)];
 
-  // Find the first existing path
+	log.info(
-  for (const p of possiblePaths) {
+		`Checking for tasks file in validated root ${dirPath}. Potential paths: ${uniquePaths.join(', ')}`
-    log.info(`Checking if exists: ${p}`);
+	);
-    const exists = fs.existsSync(p);
-    log.info(`Path ${p} exists: ${exists}`);
 
-    if (exists) {
+	// Find the first existing path
-      log.info(`Found tasks file at: ${p}`);
+	for (const p of uniquePaths) {
-      // Store the project root for future use
+		// log.info(`Checking if exists: ${p}`); // Can reduce verbosity
-      lastFoundProjectRoot = dirPath;
+		const exists = fs.existsSync(p);
-      return p;
+		// log.info(`Path ${p} exists: ${exists}`); // Can reduce verbosity
-    }
-  }
 
-  // If no file was found, throw an error
+		if (exists) {
-  const error = new Error(`Tasks file not found in any of the expected locations relative to ${dirPath}: ${possiblePaths.join(', ')}`);
+			log.info(`Found tasks file at: ${p}`);
-  error.code = 'TASKS_FILE_NOT_FOUND';
+			// No need to set lastFoundProjectRoot anymore
-  throw error;
+			return p;
+		}
+	}
+
+	// If no file was found, throw an error
+	const error = new Error(
+		`Tasks file not found in any of the expected locations within directory ${dirPath}: ${uniquePaths.join(', ')}`
+	);
+	error.code = 'TASKS_FILE_NOT_FOUND_IN_ROOT';
+	error.details = { searchedDirectory: dirPath, checkedPaths: uniquePaths };
+	throw error;
+}
+
+// Removed findTasksJsonWithParentSearch, hasProjectMarkers, and findTasksWithNpmConsideration
+// as the project root is now determined upfront and validated.
+
+/**
+ * Resolves a relative path against the project root, ensuring it's within the project.
+ * @param {string} relativePath - The relative path (e.g., 'scripts/report.json').
+ * @param {string} projectRoot - The validated absolute path to the project root.
+ * @param {Object} log - Logger object.
+ * @returns {string} - The absolute path.
+ * @throws {Error} - If the resolved path is outside the project root or resolution fails.
+ */
+export function resolveProjectPath(relativePath, projectRoot, log) {
+	if (!projectRoot || !path.isAbsolute(projectRoot)) {
+		log.error(
+			`Cannot resolve project path: Invalid projectRoot provided: ${projectRoot}`
+		);
+		throw new Error(
+			`Internal Error: Cannot resolve project path due to invalid projectRoot: ${projectRoot}`
+		);
+	}
+	if (!relativePath || typeof relativePath !== 'string') {
+		log.error(
+			`Cannot resolve project path: Invalid relativePath provided: ${relativePath}`
+		);
+		throw new Error(
+			`Internal Error: Cannot resolve project path due to invalid relativePath: ${relativePath}`
+		);
+	}
+
+	// If relativePath is already absolute, check if it's within the project root
+	if (path.isAbsolute(relativePath)) {
+		if (!relativePath.startsWith(projectRoot)) {
+			log.error(
+				`Path Security Violation: Absolute path \"${relativePath}\" provided is outside the project root \"${projectRoot}\"`
+			);
+			throw new Error(
+				`Provided absolute path is outside the project directory: ${relativePath}`
+			);
+		}
+		log.info(
+			`Provided path is already absolute and within project root: ${relativePath}`
+		);
+		return relativePath; // Return as is if valid absolute path within project
+	}
+
+	// Resolve relative path against project root
+	const absolutePath = path.resolve(projectRoot, relativePath);
+
+	// Security check: Ensure the resolved path is still within the project root boundary
+	// Normalize paths to handle potential .. usages properly before comparison
+	const normalizedAbsolutePath = path.normalize(absolutePath);
+	const normalizedProjectRoot = path.normalize(projectRoot + path.sep); // Ensure trailing separator for accurate startsWith check
+
+	if (
+		!normalizedAbsolutePath.startsWith(normalizedProjectRoot) &&
+		normalizedAbsolutePath !== path.normalize(projectRoot)
+	) {
+		log.error(
+			`Path Security Violation: Resolved path \"${normalizedAbsolutePath}\" is outside project root \"${normalizedProjectRoot}\"`
+		);
+		throw new Error(
+			`Resolved path is outside the project directory: ${relativePath}`
+		);
+	}
+
+	log.info(`Resolved project path: \"${relativePath}\" -> \"${absolutePath}\"`);
+	return absolutePath;
 }
 
 /**
- * Recursively search for tasks.json in the given directory and parent directories
+ * Ensures a directory exists, creating it if necessary.
- * Also looks for project markers to identify potential project roots
+ * Also verifies that if the path already exists, it is indeed a directory.
- * @param {string} startDir - Directory to start searching from
+ * @param {string} dirPath - The absolute path to the directory.
- * @param {string} explicitFilePath - Optional explicit file path
+ * @param {Object} log - Logger object.
- * @param {Object} log - Logger object
- * @returns {string} - Absolute path to tasks.json
- * @throws {Error} - If tasks.json cannot be found in any parent directory
  */
-function findTasksJsonWithParentSearch(startDir, explicitFilePath, log) {
+export function ensureDirectoryExists(dirPath, log) {
-  let currentDir = startDir;
+	// Validate dirPath is an absolute path before proceeding
-  const rootDir = path.parse(currentDir).root;
+	if (!path.isAbsolute(dirPath)) {
+		log.error(
+			`Cannot ensure directory: Path provided is not absolute: ${dirPath}`
+		);
+		throw new Error(
+			`Internal Error: ensureDirectoryExists requires an absolute path.`
+		);
+	}
 
-  // Keep traversing up until we hit the root directory
+	if (!fs.existsSync(dirPath)) {
-  while (currentDir !== rootDir) {
+		log.info(`Directory does not exist, creating recursively: ${dirPath}`);
-    // First check for tasks.json directly
+		try {
-    try {
+			fs.mkdirSync(dirPath, { recursive: true });
-      return findTasksJsonInDirectory(currentDir, explicitFilePath, log);
+			log.info(`Successfully created directory: ${dirPath}`);
-    } catch (error) {
+		} catch (error) {
-      // If tasks.json not found but the directory has project markers,
+			log.error(`Failed to create directory ${dirPath}: ${error.message}`);
-      // log it as a potential project root (helpful for debugging)
+			// Re-throw the error after logging
-      if (hasProjectMarkers(currentDir)) {
+			throw new Error(
-        log.info(`Found project markers in ${currentDir}, but no tasks.json`);
+				`Could not create directory: ${dirPath}. Reason: ${error.message}`
-      }
+			);
-      
+		}
-      // Move up to parent directory
+	} else {
-      const parentDir = path.dirname(currentDir);
+		// Path exists, verify it's a directory
-      
+		try {
-      // Check if we've reached the root
+			const stats = fs.statSync(dirPath);
-      if (parentDir === currentDir) {
+			if (!stats.isDirectory()) {
-        break;
+				log.error(`Path exists but is not a directory: ${dirPath}`);
-      }
+				throw new Error(
-      
+					`Expected directory but found file at path: ${dirPath}`
-      log.info(`Tasks file not found in ${currentDir}, searching in parent directory: ${parentDir}`);
+				);
-      currentDir = parentDir;
+			}
-    }
+			log.info(`Directory already exists and is valid: ${dirPath}`);
-  }
+		} catch (error) {
-  
+			// Handle potential errors from statSync (e.g., permissions) or the explicit throw above
-  // If we've searched all the way to the root and found nothing
+			log.error(
-  const error = new Error(`Tasks file not found in ${startDir} or any parent directory.`);
+				`Error checking existing directory ${dirPath}: ${error.message}`
-  error.code = 'TASKS_FILE_NOT_FOUND';
+			);
-  throw error;
+			throw new Error(
-}
+				`Error verifying existing directory: ${dirPath}. Reason: ${error.message}`
-
+			);
-// Note: findTasksWithNpmConsideration is not used by findTasksJsonPath and might be legacy or used elsewhere.
+		}
-// If confirmed unused, it could potentially be removed in a separate cleanup.
+	}
-function findTasksWithNpmConsideration(startDir, log) {
-  // First try our recursive parent search from cwd
-  try {
-    return findTasksJsonWithParentSearch(startDir, null, log);
-  } catch (error) {
-    // If that fails, try looking relative to the executable location
-    const execPath = process.argv[1];
-    const execDir = path.dirname(execPath);
-    log.info(`Looking for tasks file relative to executable at: ${execDir}`);
-    
-    try {
-      return findTasksJsonWithParentSearch(execDir, null, log);
-    } catch (secondError) {
-      // If that also fails, check standard locations in user's home directory
-      const homeDir = os.homedir();
-      log.info(`Looking for tasks file in home directory: ${homeDir}`);
-      
-      try {
-        // Check standard locations in home dir
-        return findTasksJsonInDirectory(path.join(homeDir, '.task-master'), null, log);
-      } catch (thirdError) {
-        // If all approaches fail, throw the original error
-        throw error;
-      }
-    }
-  }
 }

mcp-server/src/index.js

@@ -1,10 +1,10 @@
-import { FastMCP } from "fastmcp";
+import { FastMCP } from 'fastmcp';
-import path from "path";
+import path from 'path';
-import dotenv from "dotenv";
+import dotenv from 'dotenv';
-import { fileURLToPath } from "url";
+import { fileURLToPath } from 'url';
-import fs from "fs";
+import fs from 'fs';
-import logger from "./logger.js";
+import logger from './logger.js';
-import { registerTaskMasterTools } from "./tools/index.js";
+import { registerTaskMasterTools } from './tools/index.js';
 import { asyncOperationManager } from './core/utils/async-manager.js';
 
 // Load environment variables
@@ -18,74 +18,74 @@ const __dirname = path.dirname(__filename);
  * Main MCP server class that integrates with Task Master
  */
 class TaskMasterMCPServer {
-  constructor() {
+	constructor() {
-    // Get version from package.json using synchronous fs
+		// Get version from package.json using synchronous fs
-    const packagePath = path.join(__dirname, "../../package.json");
+		const packagePath = path.join(__dirname, '../../package.json');
-    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf8"));
+		const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
 
-    this.options = {
+		this.options = {
-      name: "Task Master MCP Server",
+			name: 'Task Master MCP Server',
-      version: packageJson.version,
+			version: packageJson.version
-    };
+		};
 
-    this.server = new FastMCP(this.options);
+		this.server = new FastMCP(this.options);
-    this.initialized = false;
+		this.initialized = false;
 
-    this.server.addResource({});
+		this.server.addResource({});
 
-    this.server.addResourceTemplate({});
+		this.server.addResourceTemplate({});
 
-    // Make the manager accessible (e.g., pass it to tool registration)
+		// Make the manager accessible (e.g., pass it to tool registration)
-    this.asyncManager = asyncOperationManager;
+		this.asyncManager = asyncOperationManager;
 
-    // Bind methods
+		// Bind methods
-    this.init = this.init.bind(this);
+		this.init = this.init.bind(this);
-    this.start = this.start.bind(this);
+		this.start = this.start.bind(this);
-    this.stop = this.stop.bind(this);
+		this.stop = this.stop.bind(this);
 
-    // Setup logging
+		// Setup logging
-    this.logger = logger;
+		this.logger = logger;
-  }
+	}
 
-  /**
+	/**
-   * Initialize the MCP server with necessary tools and routes
+	 * Initialize the MCP server with necessary tools and routes
-   */
+	 */
-  async init() {
+	async init() {
-    if (this.initialized) return;
+		if (this.initialized) return;
 
-    // Pass the manager instance to the tool registration function
+		// Pass the manager instance to the tool registration function
-    registerTaskMasterTools(this.server, this.asyncManager);
+		registerTaskMasterTools(this.server, this.asyncManager);
 
-    this.initialized = true;
+		this.initialized = true;
 
-    return this;
+		return this;
-  }
+	}
 
-  /**
+	/**
-   * Start the MCP server
+	 * Start the MCP server
-   */
+	 */
-  async start() {
+	async start() {
-    if (!this.initialized) {
+		if (!this.initialized) {
-      await this.init();
+			await this.init();
-    }
+		}
 
-    // Start the FastMCP server with increased timeout
+		// Start the FastMCP server with increased timeout
-    await this.server.start({
+		await this.server.start({
-      transportType: "stdio",
+			transportType: 'stdio',
-      timeout: 120000 // 2 minutes timeout (in milliseconds)
+			timeout: 120000 // 2 minutes timeout (in milliseconds)
-    });
+		});
 
-    return this;
+		return this;
-  }
+	}
 
-  /**
+	/**
-   * Stop the MCP server
+	 * Stop the MCP server
-   */
+	 */
-  async stop() {
+	async stop() {
-    if (this.server) {
+		if (this.server) {
-      await this.server.stop();
+			await this.server.stop();
-    }
+		}
-  }
+	}
 }
 
 // Export the manager from here as well, if needed elsewhere

mcp-server/src/logger.js

@@ -1,19 +1,19 @@
-import chalk from "chalk";
+import chalk from 'chalk';
-import { isSilentMode } from "../../scripts/modules/utils.js";
+import { isSilentMode } from '../../scripts/modules/utils.js';
 
 // Define log levels
 const LOG_LEVELS = {
-  debug: 0,
+	debug: 0,
-  info: 1,
+	info: 1,
-  warn: 2,
+	warn: 2,
-  error: 3,
+	error: 3,
-  success: 4,
+	success: 4
 };
 
 // Get log level from environment or default to info
 const LOG_LEVEL = process.env.LOG_LEVEL
-  ? LOG_LEVELS[process.env.LOG_LEVEL.toLowerCase()] ?? LOG_LEVELS.info
+	? (LOG_LEVELS[process.env.LOG_LEVEL.toLowerCase()] ?? LOG_LEVELS.info)
-  : LOG_LEVELS.info;
+	: LOG_LEVELS.info;
 
 /**
  * Logs a message with the specified level
@@ -21,56 +21,66 @@ const LOG_LEVEL = process.env.LOG_LEVEL
  * @param  {...any} args - Arguments to log
  */
 function log(level, ...args) {
-  // Skip logging if silent mode is enabled
+	// Skip logging if silent mode is enabled
-  if (isSilentMode()) {
+	if (isSilentMode()) {
-    return;
+		return;
-  }
+	}
 
-  // Use text prefixes instead of emojis
+	// Use text prefixes instead of emojis
-  const prefixes = {
+	const prefixes = {
-    debug: chalk.gray("[DEBUG]"),
+		debug: chalk.gray('[DEBUG]'),
-    info: chalk.blue("[INFO]"),
+		info: chalk.blue('[INFO]'),
-    warn: chalk.yellow("[WARN]"),
+		warn: chalk.yellow('[WARN]'),
-    error: chalk.red("[ERROR]"),
+		error: chalk.red('[ERROR]'),
-    success: chalk.green("[SUCCESS]"),
+		success: chalk.green('[SUCCESS]')
-  };
+	};
 
-  if (LOG_LEVELS[level] !== undefined && LOG_LEVELS[level] >= LOG_LEVEL) {
+	if (LOG_LEVELS[level] !== undefined && LOG_LEVELS[level] >= LOG_LEVEL) {
-    const prefix = prefixes[level] || "";
+		const prefix = prefixes[level] || '';
-    let coloredArgs = args;
+		let coloredArgs = args;
 
-    try {
+		try {
-      switch(level) {
+			switch (level) {
-        case "error":
+				case 'error':
-          coloredArgs = args.map(arg => typeof arg === 'string' ? chalk.red(arg) : arg);
+					coloredArgs = args.map((arg) =>
-          break;
+						typeof arg === 'string' ? chalk.red(arg) : arg
-        case "warn":
+					);
-          coloredArgs = args.map(arg => typeof arg === 'string' ? chalk.yellow(arg) : arg);
+					break;
-          break;
+				case 'warn':
-        case "success":
+					coloredArgs = args.map((arg) =>
-          coloredArgs = args.map(arg => typeof arg === 'string' ? chalk.green(arg) : arg);
+						typeof arg === 'string' ? chalk.yellow(arg) : arg
-          break;
+					);
-        case "info":
+					break;
-          coloredArgs = args.map(arg => typeof arg === 'string' ? chalk.blue(arg) : arg);
+				case 'success':
-          break;
+					coloredArgs = args.map((arg) =>
-        case "debug":
+						typeof arg === 'string' ? chalk.green(arg) : arg
-          coloredArgs = args.map(arg => typeof arg === 'string' ? chalk.gray(arg) : arg);
+					);
-          break;
+					break;
-        // default: use original args (no color)
+				case 'info':
-      }
+					coloredArgs = args.map((arg) =>
-    } catch (colorError) {
+						typeof arg === 'string' ? chalk.blue(arg) : arg
-      // Fallback if chalk fails on an argument
+					);
-      // Use console.error here for internal logger errors, separate from normal logging
+					break;
-      console.error("Internal Logger Error applying chalk color:", colorError);
+				case 'debug':
-      coloredArgs = args;
+					coloredArgs = args.map((arg) =>
-    }
+						typeof arg === 'string' ? chalk.gray(arg) : arg
+					);
+					break;
+				// default: use original args (no color)
+			}
+		} catch (colorError) {
+			// Fallback if chalk fails on an argument
+			// Use console.error here for internal logger errors, separate from normal logging
+			console.error('Internal Logger Error applying chalk color:', colorError);
+			coloredArgs = args;
+		}
 
-    // Revert to console.log - FastMCP's context logger (context.log)
+		// Revert to console.log - FastMCP's context logger (context.log)
-    // is responsible for directing logs correctly (e.g., to stderr)
+		// is responsible for directing logs correctly (e.g., to stderr)
-    // during tool execution without upsetting the client connection.
+		// during tool execution without upsetting the client connection.
-    // Logs outside of tool execution (like startup) will go to stdout.
+		// Logs outside of tool execution (like startup) will go to stdout.
-    console.log(prefix, ...coloredArgs);
+		console.log(prefix, ...coloredArgs);
-  }
+	}
 }
 
 /**
@@ -78,16 +88,19 @@ function log(level, ...args) {
  * @returns {Object} Logger object with info, error, debug, warn, and success methods
  */
 export function createLogger() {
-  const createLogMethod = (level) => (...args) => log(level, ...args);
+	const createLogMethod =
+		(level) =>
+		(...args) =>
+			log(level, ...args);
 
-  return {
+	return {
-    debug: createLogMethod("debug"),
+		debug: createLogMethod('debug'),
-    info: createLogMethod("info"),
+		info: createLogMethod('info'),
-    warn: createLogMethod("warn"),
+		warn: createLogMethod('warn'),
-    error: createLogMethod("error"),
+		error: createLogMethod('error'),
-    success: createLogMethod("success"),
+		success: createLogMethod('success'),
-    log: log, // Also expose the raw log function
+		log: log // Also expose the raw log function
-  };
+	};
 }
 
 // Export a default logger instance

mcp-server/src/tools/add-dependency.js

@@ -3,63 +3,81 @@
  * Tool for adding a dependency to a task
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { addDependencyDirect } from "../core/task-master-core.js";
+import { addDependencyDirect } from '../core/task-master-core.js';
 
 /**
  * Register the addDependency tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerAddDependencyTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "add_dependency",
+		name: 'add_dependency',
-    description: "Add a dependency relationship between two tasks",
+		description: 'Add a dependency relationship between two tasks',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("ID of task that will depend on another task"),
+			id: z.string().describe('ID of task that will depend on another task'),
-      dependsOn: z.string().describe("ID of task that will become a dependency"),
+			dependsOn: z
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+				.string()
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+				.describe('ID of task that will become a dependency'),
-    }),
+			file: z
-    execute: async (args, { log, session, reportProgress }) => {
+				.string()
-      try {
+				.optional()
-        log.info(`Adding dependency for task ${args.id} to depend on ${args.dependsOn}`);
+				.describe(
-        reportProgress({ progress: 0 });
+					'Absolute path to the tasks file (default: tasks/tasks.json)'
+				),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(
+					`Adding dependency for task ${args.id} to depend on ${args.dependsOn}`
+				);
+				reportProgress({ progress: 0 });
 
-        // Get project root using the utility function
+				// Get project root using the utility function
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        // Fallback to args.projectRoot if session didn't provide one
+				// Fallback to args.projectRoot if session didn't provide one
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        // Call the direct function with the resolved rootFolder
+				// Call the direct function with the resolved rootFolder
-        const result = await addDependencyDirect({
+				const result = await addDependencyDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { reportProgress, mcpLog: log, session});
+						...args
+					},
+					log,
+					{ reportProgress, mcpLog: log, session }
+				);
 
-        reportProgress({ progress: 100 });
+				reportProgress({ progress: 100 });
 
-        // Log result
+				// Log result
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully added dependency: ${result.data.message}`);
+					log.info(`Successfully added dependency: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to add dependency: ${result.error.message}`);
+					log.error(`Failed to add dependency: ${result.error.message}`);
-        }
+				}
 
-        // Use handleApiResult to format the response
+				// Use handleApiResult to format the response
-        return handleApiResult(result, log, 'Error adding dependency');
+				return handleApiResult(result, log, 'Error adding dependency');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in addDependency tool: ${error.message}`);
+				log.error(`Error in addDependency tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/add-subtask.js

@@ -3,61 +3,96 @@
  * Tool for adding subtasks to existing tasks
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { addSubtaskDirect } from "../core/task-master-core.js";
+import { addSubtaskDirect } from '../core/task-master-core.js';
 
 /**
  * Register the addSubtask tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerAddSubtaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "add_subtask",
+		name: 'add_subtask',
-    description: "Add a subtask to an existing task",
+		description: 'Add a subtask to an existing task',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("Parent task ID (required)"),
+			id: z.string().describe('Parent task ID (required)'),
-      taskId: z.string().optional().describe("Existing task ID to convert to subtask"),
+			taskId: z
-      title: z.string().optional().describe("Title for the new subtask (when creating a new subtask)"),
+				.string()
-      description: z.string().optional().describe("Description for the new subtask"),
+				.optional()
-      details: z.string().optional().describe("Implementation details for the new subtask"),
+				.describe('Existing task ID to convert to subtask'),
-      status: z.string().optional().describe("Status for the new subtask (default: 'pending')"),
+			title: z
-      dependencies: z.string().optional().describe("Comma-separated list of dependency IDs for the new subtask"),
+				.string()
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+				.optional()
-      skipGenerate: z.boolean().optional().describe("Skip regenerating task files"),
+				.describe('Title for the new subtask (when creating a new subtask)'),
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+			description: z
-    }),
+				.string()
-    execute: async (args, { log, session, reportProgress }) => {
+				.optional()
-      try {
+				.describe('Description for the new subtask'),
-        log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
+			details: z
+				.string()
+				.optional()
+				.describe('Implementation details for the new subtask'),
+			status: z
+				.string()
+				.optional()
+				.describe("Status for the new subtask (default: 'pending')"),
+			dependencies: z
+				.string()
+				.optional()
+				.describe('Comma-separated list of dependency IDs for the new subtask'),
+			file: z
+				.string()
+				.optional()
+				.describe(
+					'Absolute path to the tasks file (default: tasks/tasks.json)'
+				),
+			skipGenerate: z
+				.boolean()
+				.optional()
+				.describe('Skip regenerating task files'),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Adding subtask with args: ${JSON.stringify(args)}`);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await addSubtaskDirect({
+				const result = await addSubtaskDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { reportProgress, mcpLog: log, session});
+						...args
+					},
+					log,
+					{ reportProgress, mcpLog: log, session }
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Subtask added successfully: ${result.data.message}`);
+					log.info(`Subtask added successfully: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to add subtask: ${result.error.message}`);
+					log.error(`Failed to add subtask: ${result.error.message}`);
-        }
+				}
 
-        return handleApiResult(result, log, 'Error adding subtask');
+				return handleApiResult(result, log, 'Error adding subtask');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in addSubtask tool: ${error.message}`);
+				log.error(`Error in addSubtask tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/add-task.js

@@ -3,56 +3,98 @@
  * Tool to add a new task using AI
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  createErrorResponse,
+	createErrorResponse,
-  createContentResponse,
+	createContentResponse,
-  getProjectRootFromSession,
+	getProjectRootFromSession,
-  executeTaskMasterCommand,
+	executeTaskMasterCommand,
-  handleApiResult
+	handleApiResult
-} from "./utils.js";
+} from './utils.js';
-import { addTaskDirect } from "../core/task-master-core.js";
+import { addTaskDirect } from '../core/task-master-core.js';
 
 /**
  * Register the addTask tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerAddTaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "add_task",
+		name: 'add_task',
-    description: "Add a new task using AI",
+		description: 'Add a new task using AI',
-    parameters: z.object({
+		parameters: z.object({
-      prompt: z.string().describe("Description of the task to add"),
+			prompt: z
-      dependencies: z.string().optional().describe("Comma-separated list of task IDs this task depends on"),
+				.string()
-      priority: z.string().optional().describe("Task priority (high, medium, low)"),
+				.optional()
-      file: z.string().optional().describe("Path to the tasks file"),
+				.describe(
-      projectRoot: z.string().optional().describe("Root directory of the project"),
+					'Description of the task to add (required if not using manual fields)'
-      research: z.boolean().optional().describe("Whether to use research capabilities for task creation")
+				),
-    }),
+			title: z
-    execute: async (args, { log, reportProgress, session }) => {
+				.string()
-      try {
+				.optional()
-        log.info(`Starting add-task with args: ${JSON.stringify(args)}`);
+				.describe('Task title (for manual task creation)'),
+			description: z
+				.string()
+				.optional()
+				.describe('Task description (for manual task creation)'),
+			details: z
+				.string()
+				.optional()
+				.describe('Implementation details (for manual task creation)'),
+			testStrategy: z
+				.string()
+				.optional()
+				.describe('Test strategy (for manual task creation)'),
+			dependencies: z
+				.string()
+				.optional()
+				.describe('Comma-separated list of task IDs this task depends on'),
+			priority: z
+				.string()
+				.optional()
+				.describe('Task priority (high, medium, low)'),
+			file: z
+				.string()
+				.optional()
+				.describe('Path to the tasks file (default: tasks/tasks.json)'),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				),
+			research: z
+				.boolean()
+				.optional()
+				.describe('Whether to use research capabilities for task creation')
+		}),
+		execute: async (args, { log, reportProgress, session }) => {
+			try {
+				log.info(`Starting add-task with args: ${JSON.stringify(args)}`);
 
-        // Get project root from session
+				// Get project root from session
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        // Call the direct function
+				// Call the direct function
-        const result = await addTaskDirect({
+				const result = await addTaskDirect(
-          ...args,
+					{
-          projectRoot: rootFolder
+						...args,
-        }, log, { reportProgress, session });
+						projectRoot: rootFolder
+					},
+					log,
+					{ reportProgress, session }
+				);
 
-        // Return the result
+				// Return the result
-        return handleApiResult(result, log);
+				return handleApiResult(result, log);
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in add-task tool: ${error.message}`);
+				log.error(`Error in add-task tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    }
+		}
-  });
+	});
 }

mcp-server/src/tools/analyze.js

@@ -3,58 +3,79 @@
  * Tool for analyzing task complexity and generating recommendations
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse
-  getProjectRootFromSession
+	// getProjectRootFromSession // No longer needed here
-} from "./utils.js";
+} from './utils.js';
-import { analyzeTaskComplexityDirect } from "../core/task-master-core.js";
+import { analyzeTaskComplexityDirect } from '../core/task-master-core.js';
 
 /**
  * Register the analyze tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerAnalyzeTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "analyze_project_complexity",
+		name: 'analyze_project_complexity',
-    description: "Analyze task complexity and generate expansion recommendations",
+		description:
-    parameters: z.object({
+			'Analyze task complexity and generate expansion recommendations. Requires the project root path.',
-      output: z.string().optional().describe("Output file path for the report (default: scripts/task-complexity-report.json)"),
+		parameters: z.object({
-      model: z.string().optional().describe("LLM model to use for analysis (defaults to configured model)"),
+			projectRoot: z
-      threshold: z.union([z.number(), z.string()]).optional().describe("Minimum complexity score to recommend expansion (1-10) (default: 5)"),
+				.string()
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+				.describe(
-      research: z.boolean().optional().describe("Use Perplexity AI for research-backed complexity analysis"),
+					'Required. Absolute path to the root directory of the project being analyzed.'
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+				),
-    }),
+			output: z
-    execute: async (args, { log, session }) => {
+				.string()
-      try {
+				.optional()
-        log.info(`Analyzing task complexity with args: ${JSON.stringify(args)}`);
+				.describe(
+					'Output file path for the report, relative to projectRoot (default: scripts/task-complexity-report.json)'
+				),
+			threshold: z.coerce
+				.number()
+				.min(1)
+				.max(10)
+				.optional()
+				.describe(
+					'Minimum complexity score to recommend expansion (1-10) (default: 5). If the complexity score is below this threshold, the tool will not recommend adding subtasks.'
+				),
+			research: z
+				.boolean()
+				.optional()
+				.describe('Use Perplexity AI for research-backed complexity analysis')
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(
+					`Analyzing task complexity with required projectRoot: ${args.projectRoot}, other args: ${JSON.stringify(args)}`
+				);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				const result = await analyzeTaskComplexityDirect(args, log, {
+					session
+				});
 
-        if (!rootFolder && args.projectRoot) {
+				if (result.success && result.data) {
-          rootFolder = args.projectRoot;
+					log.info(`Task complexity analysis complete: ${result.data.message}`);
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(
-        }
+						`Report summary: ${JSON.stringify(result.data.reportSummary)}`
+					);
+				} else if (!result.success && result.error) {
+					log.error(
+						`Failed to analyze task complexity: ${result.error.message} (Code: ${result.error.code})`
+					);
+				}
 
-        const result = await analyzeTaskComplexityDirect({
+				return handleApiResult(result, log, 'Error analyzing task complexity');
-          projectRoot: rootFolder,
+			} catch (error) {
-          ...args
+				log.error(
-        }, log, { session });
+					`Unexpected error in analyze tool execute method: ${error.message}`,
-        
+					{ stack: error.stack }
-        if (result.success) {
+				);
-          log.info(`Task complexity analysis complete: ${result.data.message}`);
+				return createErrorResponse(
-          log.info(`Report summary: ${JSON.stringify(result.data.reportSummary)}`);
+					`Unexpected error in analyze tool: ${error.message}`
-        } else {
+				);
-          log.error(`Failed to analyze task complexity: ${result.error.message}`);
+			}
-        }
+		}
-        
+	});
-        return handleApiResult(result, log, 'Error analyzing task complexity');
-      } catch (error) {
-        log.error(`Error in analyze tool: ${error.message}`);
-        return createErrorResponse(error.message);
-      }
-    },
-  });
 }

mcp-server/src/tools/clear-subtasks.js

@@ -3,61 +3,80 @@
  * Tool for clearing subtasks from parent tasks
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { clearSubtasksDirect } from "../core/task-master-core.js";
+import { clearSubtasksDirect } from '../core/task-master-core.js';
 
 /**
  * Register the clearSubtasks tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerClearSubtasksTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "clear_subtasks",
+		name: 'clear_subtasks',
-    description: "Clear subtasks from specified tasks",
+		description: 'Clear subtasks from specified tasks',
-    parameters: z.object({
+		parameters: z
-      id: z.string().optional().describe("Task IDs (comma-separated) to clear subtasks from"),
+			.object({
-      all: z.boolean().optional().describe("Clear subtasks from all tasks"),
+				id: z
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+					.string()
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+					.optional()
-    }).refine(data => data.id || data.all, {
+					.describe('Task IDs (comma-separated) to clear subtasks from'),
-      message: "Either 'id' or 'all' parameter must be provided",
+				all: z.boolean().optional().describe('Clear subtasks from all tasks'),
-      path: ["id", "all"]
+				file: z
-    }),
+					.string()
-    execute: async (args, { log, session, reportProgress }) => {
+					.optional()
-      try {
+					.describe(
-        log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
+						'Absolute path to the tasks file (default: tasks/tasks.json)'
-        await reportProgress({ progress: 0 });
+					),
+				projectRoot: z
+					.string()
+					.optional()
+					.describe(
+						'Root directory of the project (default: current working directory)'
+					)
+			})
+			.refine((data) => data.id || data.all, {
+				message: "Either 'id' or 'all' parameter must be provided",
+				path: ['id', 'all']
+			}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Clearing subtasks with args: ${JSON.stringify(args)}`);
+				await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await clearSubtasksDirect({
+				const result = await clearSubtasksDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { reportProgress, mcpLog: log, session});
+						...args
+					},
+					log,
+					{ reportProgress, mcpLog: log, session }
+				);
 
-        reportProgress({ progress: 100 });
+				reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Subtasks cleared successfully: ${result.data.message}`);
+					log.info(`Subtasks cleared successfully: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to clear subtasks: ${result.error.message}`);
+					log.error(`Failed to clear subtasks: ${result.error.message}`);
-        }
+				}
 
-        return handleApiResult(result, log, 'Error clearing subtasks');
+				return handleApiResult(result, log, 'Error clearing subtasks');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in clearSubtasks tool: ${error.message}`);
+				log.error(`Error in clearSubtasks tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/complexity-report.js

@@ -3,56 +3,81 @@
  * Tool for displaying the complexity analysis report
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { complexityReportDirect } from "../core/task-master-core.js";
+import { complexityReportDirect } from '../core/task-master-core.js';
 
 /**
  * Register the complexityReport tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerComplexityReportTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "complexity_report",
+		name: 'complexity_report',
-    description: "Display the complexity analysis report in a readable format",
+		description: 'Display the complexity analysis report in a readable format',
-    parameters: z.object({
+		parameters: z.object({
-      file: z.string().optional().describe("Path to the report file (default: scripts/task-complexity-report.json)"),
+			file: z
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+				.string()
-    }),
+				.optional()
-    execute: async (args, { log, session, reportProgress }) => {
+				.describe(
-      try {
+					'Path to the report file (default: scripts/task-complexity-report.json)'
-        log.info(`Getting complexity report with args: ${JSON.stringify(args)}`);
+				),
-        // await reportProgress({ progress: 0 });
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(
+					`Getting complexity report with args: ${JSON.stringify(args)}`
+				);
+				// await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await complexityReportDirect({
+				const result = await complexityReportDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log/*, { reportProgress, mcpLog: log, session}*/);
+						...args
+					},
+					log /*, { reportProgress, mcpLog: log, session}*/
+				);
 
-        // await reportProgress({ progress: 100 });
+				// await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully retrieved complexity report${result.fromCache ? ' (from cache)' : ''}`);
+					log.info(
-        } else {
+						`Successfully retrieved complexity report${result.fromCache ? ' (from cache)' : ''}`
-          log.error(`Failed to retrieve complexity report: ${result.error.message}`);
+					);
-        }
+				} else {
+					log.error(
+						`Failed to retrieve complexity report: ${result.error.message}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error retrieving complexity report');
+				return handleApiResult(
-      } catch (error) {
+					result,
-        log.error(`Error in complexity-report tool: ${error.message}`);
+					log,
-        return createErrorResponse(`Failed to retrieve complexity report: ${error.message}`);
+					'Error retrieving complexity report'
-      }
+				);
-    },
+			} catch (error) {
-  });
+				log.error(`Error in complexity-report tool: ${error.message}`);
+				return createErrorResponse(
+					`Failed to retrieve complexity report: ${error.message}`
+				);
+			}
+		}
+	});
 }

mcp-server/src/tools/expand-all.js

@@ -3,57 +3,89 @@
  * Tool for expanding all pending tasks with subtasks
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { expandAllTasksDirect } from "../core/task-master-core.js";
+import { expandAllTasksDirect } from '../core/task-master-core.js';
 
 /**
  * Register the expandAll tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerExpandAllTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "expand_all",
+		name: 'expand_all',
-    description: "Expand all pending tasks into subtasks",
+		description: 'Expand all pending tasks into subtasks',
-    parameters: z.object({
+		parameters: z.object({
-      num: z.string().optional().describe("Number of subtasks to generate for each task"),
+			num: z
-      research: z.boolean().optional().describe("Enable Perplexity AI for research-backed subtask generation"),
+				.string()
-      prompt: z.string().optional().describe("Additional context to guide subtask generation"),
+				.optional()
-      force: z.boolean().optional().describe("Force regeneration of subtasks for tasks that already have them"),
+				.describe('Number of subtasks to generate for each task'),
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+			research: z
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+				.boolean()
-    }),
+				.optional()
-    execute: async (args, { log, session }) => {
+				.describe(
-      try {
+					'Enable Perplexity AI for research-backed subtask generation'
-        log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
+				),
+			prompt: z
+				.string()
+				.optional()
+				.describe('Additional context to guide subtask generation'),
+			force: z
+				.boolean()
+				.optional()
+				.describe(
+					'Force regeneration of subtasks for tasks that already have them'
+				),
+			file: z
+				.string()
+				.optional()
+				.describe(
+					'Absolute path to the tasks file (default: tasks/tasks.json)'
+				),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Expanding all tasks with args: ${JSON.stringify(args)}`);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await expandAllTasksDirect({
+				const result = await expandAllTasksDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { session });
+						...args
+					},
+					log,
+					{ session }
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully expanded all tasks: ${result.data.message}`);
+					log.info(`Successfully expanded all tasks: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to expand all tasks: ${result.error?.message || 'Unknown error'}`);
+					log.error(
-        }
+						`Failed to expand all tasks: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error expanding all tasks');
+				return handleApiResult(result, log, 'Error expanding all tasks');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in expand-all tool: ${error.message}`);
+				log.error(`Error in expand-all tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/expand-task.js

@@ -3,75 +3,88 @@
  * Tool to expand a task into subtasks
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { expandTaskDirect } from "../core/task-master-core.js";
+import { expandTaskDirect } from '../core/task-master-core.js';
-import fs from "fs";
+import fs from 'fs';
-import path from "path";
+import path from 'path';
 
 /**
  * Register the expand-task tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerExpandTaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "expand_task",
+		name: 'expand_task',
-    description: "Expand a task into subtasks for detailed implementation",
+		description: 'Expand a task into subtasks for detailed implementation',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("ID of task to expand"),
+			id: z.string().describe('ID of task to expand'),
-      num: z.union([z.string(), z.number()]).optional().describe("Number of subtasks to generate"),
+			num: z
-      research: z.boolean().optional().describe("Use Perplexity AI for research-backed generation"),
+				.union([z.string(), z.number()])
-      prompt: z.string().optional().describe("Additional context for subtask generation"),
+				.optional()
-      file: z.string().optional().describe("Path to the tasks file"),
+				.describe('Number of subtasks to generate'),
-      projectRoot: z
+			research: z
-        .string()
+				.boolean()
-        .optional()
+				.optional()
-        .describe(
+				.describe('Use Perplexity AI for research-backed generation'),
-          "Root directory of the project (default: current working directory)"
+			prompt: z
-        ),
+				.string()
-    }),
+				.optional()
-    execute: async (args, { log, reportProgress, session }) => {
+				.describe('Additional context for subtask generation'),
-      try {
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-        log.info(`Starting expand-task with args: ${JSON.stringify(args)}`);
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Starting expand-task with args: ${JSON.stringify(args)}`);
 
-        // Get project root from session
+				// Get project root from session
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        log.info(`Project root resolved to: ${rootFolder}`);
+				log.info(`Project root resolved to: ${rootFolder}`);
 
-        // Check for tasks.json in the standard locations
+				// Check for tasks.json in the standard locations
-        const tasksJsonPath = path.join(rootFolder, 'tasks', 'tasks.json');
+				const tasksJsonPath = path.join(rootFolder, 'tasks', 'tasks.json');
 
-        if (fs.existsSync(tasksJsonPath)) {
+				if (fs.existsSync(tasksJsonPath)) {
-          log.info(`Found tasks.json at ${tasksJsonPath}`);
+					log.info(`Found tasks.json at ${tasksJsonPath}`);
-          // Add the file parameter directly to args
+					// Add the file parameter directly to args
-          args.file = tasksJsonPath;
+					args.file = tasksJsonPath;
-        } else {
+				} else {
-          log.warn(`Could not find tasks.json at ${tasksJsonPath}`);
+					log.warn(`Could not find tasks.json at ${tasksJsonPath}`);
-        }
+				}
 
-        // Call direct function with only session in the context, not reportProgress
+				// Call direct function with only session in the context, not reportProgress
-        // Use the pattern recommended in the MCP guidelines
+				// Use the pattern recommended in the MCP guidelines
-        const result = await expandTaskDirect({
+				const result = await expandTaskDirect(
-          ...args,
+					{
-          projectRoot: rootFolder
+						...args,
-        }, log, { session }); // Only pass session, NOT reportProgress
+						projectRoot: rootFolder
+					},
+					log,
+					{ session }
+				); // Only pass session, NOT reportProgress
 
-        // Return the result
+				// Return the result
-        return handleApiResult(result, log, 'Error expanding task');
+				return handleApiResult(result, log, 'Error expanding task');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in expand task tool: ${error.message}`);
+				log.error(`Error in expand task tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/fix-dependencies.js

@@ -3,56 +3,65 @@
  * Tool for automatically fixing invalid task dependencies
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { fixDependenciesDirect } from "../core/task-master-core.js";
+import { fixDependenciesDirect } from '../core/task-master-core.js';
 
 /**
  * Register the fixDependencies tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerFixDependenciesTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "fix_dependencies",
+		name: 'fix_dependencies',
-    description: "Fix invalid dependencies in tasks automatically",
+		description: 'Fix invalid dependencies in tasks automatically',
-    parameters: z.object({
+		parameters: z.object({
-      file: z.string().optional().describe("Path to the tasks file"),
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+			projectRoot: z
-    }),
+				.string()
-    execute: async (args, { log, session, reportProgress }) => {
+				.optional()
-      try {
+				.describe(
-        log.info(`Fixing dependencies with args: ${JSON.stringify(args)}`);
+					'Root directory of the project (default: current working directory)'
-        await reportProgress({ progress: 0 });
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Fixing dependencies with args: ${JSON.stringify(args)}`);
+				await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await fixDependenciesDirect({
+				const result = await fixDependenciesDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { reportProgress, mcpLog: log, session});
+						...args
+					},
+					log,
+					{ reportProgress, mcpLog: log, session }
+				);
 
-        await reportProgress({ progress: 100 });
+				await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully fixed dependencies: ${result.data.message}`);
+					log.info(`Successfully fixed dependencies: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to fix dependencies: ${result.error.message}`);
+					log.error(`Failed to fix dependencies: ${result.error.message}`);
-        }
+				}
 
-        return handleApiResult(result, log, 'Error fixing dependencies');
+				return handleApiResult(result, log, 'Error fixing dependencies');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in fixDependencies tool: ${error.message}`);
+				log.error(`Error in fixDependencies tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    }
+		}
-  });
+	});
 }

mcp-server/src/tools/generate.js

@@ -3,62 +3,71 @@
  * Tool to generate individual task files from tasks.json
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { generateTaskFilesDirect } from "../core/task-master-core.js";
+import { generateTaskFilesDirect } from '../core/task-master-core.js';
 
 /**
  * Register the generate tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerGenerateTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "generate",
+		name: 'generate',
-    description: "Generates individual task files in tasks/ directory based on tasks.json",
+		description:
-    parameters: z.object({
+			'Generates individual task files in tasks/ directory based on tasks.json',
-      file: z.string().optional().describe("Path to the tasks file"),
+		parameters: z.object({
-      output: z.string().optional().describe("Output directory (default: same directory as tasks file)"),
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-      projectRoot: z
+			output: z
-        .string()
+				.string()
-        .optional()
+				.optional()
-        .describe(
+				.describe('Output directory (default: same directory as tasks file)'),
-          "Root directory of the project (default: current working directory)"
+			projectRoot: z
-        ),
+				.string()
-    }),
+				.optional()
-    execute: async (args, { log, session, reportProgress }) => {
+				.describe(
-      try {
+					'Root directory of the project (default: current working directory)'
-        log.info(`Generating task files with args: ${JSON.stringify(args)}`);
+				)
-        // await reportProgress({ progress: 0 });
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Generating task files with args: ${JSON.stringify(args)}`);
+				// await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await generateTaskFilesDirect({
+				const result = await generateTaskFilesDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log/*, { reportProgress, mcpLog: log, session}*/);
+						...args
+					},
+					log /*, { reportProgress, mcpLog: log, session}*/
+				);
 
-        // await reportProgress({ progress: 100 });
+				// await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully generated task files: ${result.data.message}`);
+					log.info(`Successfully generated task files: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to generate task files: ${result.error?.message || 'Unknown error'}`);
+					log.error(
-        }
+						`Failed to generate task files: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error generating task files');
+				return handleApiResult(result, log, 'Error generating task files');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in generate tool: ${error.message}`);
+				log.error(`Error in generate tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/get-operation-status.js

@@ -8,35 +8,40 @@ import { createErrorResponse, createContentResponse } from './utils.js'; // Assu
  * @param {AsyncOperationManager} asyncManager - The async operation manager.
  */
 export function registerGetOperationStatusTool(server, asyncManager) {
-    server.addTool({
+	server.addTool({
-        name: 'get_operation_status',
+		name: 'get_operation_status',
-        description: 'Retrieves the status and result/error of a background operation.',
+		description:
-        parameters: z.object({
+			'Retrieves the status and result/error of a background operation.',
-            operationId: z.string().describe('The ID of the operation to check.'),
+		parameters: z.object({
-        }),
+			operationId: z.string().describe('The ID of the operation to check.')
-        execute: async (args, { log }) => {
+		}),
-            try {
+		execute: async (args, { log }) => {
-                const { operationId } = args;
+			try {
-                log.info(`Checking status for operation ID: ${operationId}`);
+				const { operationId } = args;
+				log.info(`Checking status for operation ID: ${operationId}`);
 
-                const status = asyncManager.getStatus(operationId);
+				const status = asyncManager.getStatus(operationId);
 
-                // Status will now always return an object, but it might have status='not_found'
+				// Status will now always return an object, but it might have status='not_found'
-                if (status.status === 'not_found') {
+				if (status.status === 'not_found') {
-                    log.warn(`Operation ID not found: ${operationId}`);
+					log.warn(`Operation ID not found: ${operationId}`);
-                    return createErrorResponse(
+					return createErrorResponse(
-                        status.error?.message || `Operation ID not found: ${operationId}`, 
+						status.error?.message || `Operation ID not found: ${operationId}`,
-                        status.error?.code || 'OPERATION_NOT_FOUND'
+						status.error?.code || 'OPERATION_NOT_FOUND'
-                    );
+					);
-                }
+				}
 
-                log.info(`Status for ${operationId}: ${status.status}`);
+				log.info(`Status for ${operationId}: ${status.status}`);
-                return createContentResponse(status);
+				return createContentResponse(status);
-
+			} catch (error) {
-            } catch (error) {
+				log.error(`Error in get_operation_status tool: ${error.message}`, {
-                log.error(`Error in get_operation_status tool: ${error.message}`, { stack: error.stack });
+					stack: error.stack
-                return createErrorResponse(`Failed to get operation status: ${error.message}`, 'GET_STATUS_ERROR');
+				});
-            }
+				return createErrorResponse(
-        },
+					`Failed to get operation status: ${error.message}`,
-    });
+					'GET_STATUS_ERROR'
+				);
+			}
+		}
+	});
 }

mcp-server/src/tools/get-task.js

@@ -3,13 +3,13 @@
  * Tool to get task details by ID
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { showTaskDirect } from "../core/task-master-core.js";
+import { showTaskDirect } from '../core/task-master-core.js';
 
 /**
  * Custom processor function that removes allTasks from the response
@@ -17,16 +17,16 @@ import { showTaskDirect } from "../core/task-master-core.js";
  * @returns {Object} - The processed data with allTasks removed
  */
 function processTaskResponse(data) {
-  if (!data) return data;
+	if (!data) return data;
 
-  // If we have the expected structure with task and allTasks
+	// If we have the expected structure with task and allTasks
-  if (data.task) {
+	if (data.task) {
-    // Return only the task object, removing the allTasks array
+		// Return only the task object, removing the allTasks array
-    return data.task;
+		return data.task;
-  }
+	}
 
-  // If structure is unexpected, return as is
+	// If structure is unexpected, return as is
-  return data;
+	return data;
 }
 
 /**
@@ -34,59 +34,75 @@ function processTaskResponse(data) {
  * @param {Object} server - FastMCP server instance
  */
 export function registerShowTaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "get_task",
+		name: 'get_task',
-    description: "Get detailed information about a specific task",
+		description: 'Get detailed information about a specific task',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("Task ID to get"),
+			id: z.string().describe('Task ID to get'),
-      file: z.string().optional().describe("Path to the tasks file"),
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-      projectRoot: z
+			projectRoot: z
-        .string()
+				.string()
-        .optional()
+				.optional()
-        .describe(
+				.describe(
-          "Root directory of the project (default: current working directory)"
+					'Root directory of the project (default: current working directory)'
-        ),
+				)
-    }),
+		}),
-    execute: async (args, { log, session, reportProgress }) => {
+		execute: async (args, { log, session, reportProgress }) => {
-      // Log the session right at the start of execute
+			// Log the session right at the start of execute
-      log.info(`Session object received in execute: ${JSON.stringify(session)}`); // Use JSON.stringify for better visibility
+			log.info(
+				`Session object received in execute: ${JSON.stringify(session)}`
+			); // Use JSON.stringify for better visibility
 
-      try {
+			try {
-        log.info(`Getting task details for ID: ${args.id}`);
+				log.info(`Getting task details for ID: ${args.id}`);
 
-        log.info(`Session object received in execute: ${JSON.stringify(session)}`); // Use JSON.stringify for better visibility
+				log.info(
+					`Session object received in execute: ${JSON.stringify(session)}`
+				); // Use JSON.stringify for better visibility
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        } else if (!rootFolder) {
+				} else if (!rootFolder) {
-          // Ensure we always have *some* root, even if session failed and args didn't provide one
+					// Ensure we always have *some* root, even if session failed and args didn't provide one
-          rootFolder = process.cwd();
+					rootFolder = process.cwd();
-          log.warn(`Session and args failed to provide root, using CWD: ${rootFolder}`);
+					log.warn(
-        }
+						`Session and args failed to provide root, using CWD: ${rootFolder}`
+					);
+				}
 
-        log.info(`Attempting to use project root: ${rootFolder}`); // Log the final resolved root
+				log.info(`Attempting to use project root: ${rootFolder}`); // Log the final resolved root
 
-        log.info(`Root folder: ${rootFolder}`); // Log the final resolved root
+				log.info(`Root folder: ${rootFolder}`); // Log the final resolved root
-        const result = await showTaskDirect({
+				const result = await showTaskDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log);
+						...args
+					},
+					log
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully retrieved task details for ID: ${args.id}${result.fromCache ? ' (from cache)' : ''}`);
+					log.info(
-        } else {
+						`Successfully retrieved task details for ID: ${args.id}${result.fromCache ? ' (from cache)' : ''}`
-          log.error(`Failed to get task: ${result.error.message}`);
+					);
-        }
+				} else {
+					log.error(`Failed to get task: ${result.error.message}`);
+				}
 
-        // Use our custom processor function to remove allTasks from the response
+				// Use our custom processor function to remove allTasks from the response
-        return handleApiResult(result, log, 'Error retrieving task details', processTaskResponse);
+				return handleApiResult(
-      } catch (error) {
+					result,
-        log.error(`Error in get-task tool: ${error.message}\n${error.stack}`); // Add stack trace
+					log,
-        return createErrorResponse(`Failed to get task: ${error.message}`);
+					'Error retrieving task details',
-      }
+					processTaskResponse
-    },
+				);
-  });
+			} catch (error) {
+				log.error(`Error in get-task tool: ${error.message}\n${error.stack}`); // Add stack trace
+				return createErrorResponse(`Failed to get task: ${error.message}`);
+			}
+		}
+	});
 }

mcp-server/src/tools/get-tasks.js

@@ -3,63 +3,79 @@
  * Tool to get all tasks from Task Master
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  createErrorResponse,
+	createErrorResponse,
-  handleApiResult,
+	handleApiResult,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { listTasksDirect } from "../core/task-master-core.js";
+import { listTasksDirect } from '../core/task-master-core.js';
 
 /**
  * Register the getTasks tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerListTasksTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "get_tasks",
+		name: 'get_tasks',
-    description: "Get all tasks from Task Master, optionally filtering by status and including subtasks.",
+		description:
-    parameters: z.object({
+			'Get all tasks from Task Master, optionally filtering by status and including subtasks.',
-      status: z.string().optional().describe("Filter tasks by status (e.g., 'pending', 'done')"),
+		parameters: z.object({
-      withSubtasks: z
+			status: z
-        .boolean()
+				.string()
-        .optional()
+				.optional()
-        .describe("Include subtasks nested within their parent tasks in the response"),
+				.describe("Filter tasks by status (e.g., 'pending', 'done')"),
-      file: z.string().optional().describe("Path to the tasks file (relative to project root or absolute)"),
+			withSubtasks: z
-      projectRoot: z
+				.boolean()
-        .string()
+				.optional()
-        .optional()
+				.describe(
-        .describe(
+					'Include subtasks nested within their parent tasks in the response'
-          "Root directory of the project (default: automatically detected from session or CWD)"
+				),
-        ),
+			file: z
-    }),
+				.string()
-    execute: async (args, { log, session, reportProgress }) => {
+				.optional()
-      try {
+				.describe(
-        log.info(`Getting tasks with filters: ${JSON.stringify(args)}`);
+					'Path to the tasks file (relative to project root or absolute)'
-        // await reportProgress({ progress: 0 });
+				),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: automatically detected from session or CWD)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Getting tasks with filters: ${JSON.stringify(args)}`);
+				// await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await listTasksDirect({
+				const result = await listTasksDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log/*, { reportProgress, mcpLog: log, session}*/);
+						...args
+					},
+					log /*, { reportProgress, mcpLog: log, session}*/
+				);
 
-        // await reportProgress({ progress: 100 });
+				// await reportProgress({ progress: 100 });
 
-        log.info(`Retrieved ${result.success ? (result.data?.tasks?.length || 0) : 0} tasks${result.fromCache ? ' (from cache)' : ''}`);
+				log.info(
-        return handleApiResult(result, log, 'Error getting tasks');
+					`Retrieved ${result.success ? result.data?.tasks?.length || 0 : 0} tasks${result.fromCache ? ' (from cache)' : ''}`
-      } catch (error) {
+				);
-        log.error(`Error getting tasks: ${error.message}`);
+				return handleApiResult(result, log, 'Error getting tasks');
-        return createErrorResponse(error.message);
+			} catch (error) {
-      }
+				log.error(`Error getting tasks: ${error.message}`);
-    },
+				return createErrorResponse(error.message);
-  });
+			}
+		}
+	});
 }
 
 // We no longer need the formatTasksResponse function as we're returning raw JSON data

mcp-server/src/tools/index.js

@@ -3,28 +3,28 @@
  * Export all Task Master CLI tools for MCP server
  */
 
-import { registerListTasksTool } from "./get-tasks.js";
+import { registerListTasksTool } from './get-tasks.js';
-import logger from "../logger.js";
+import logger from '../logger.js';
-import { registerSetTaskStatusTool } from "./set-task-status.js";
+import { registerSetTaskStatusTool } from './set-task-status.js';
-import { registerParsePRDTool } from "./parse-prd.js";
+import { registerParsePRDTool } from './parse-prd.js';
-import { registerUpdateTool } from "./update.js";
+import { registerUpdateTool } from './update.js';
-import { registerUpdateTaskTool } from "./update-task.js";
+import { registerUpdateTaskTool } from './update-task.js';
-import { registerUpdateSubtaskTool } from "./update-subtask.js";
+import { registerUpdateSubtaskTool } from './update-subtask.js';
-import { registerGenerateTool } from "./generate.js";
+import { registerGenerateTool } from './generate.js';
-import { registerShowTaskTool } from "./get-task.js";
+import { registerShowTaskTool } from './get-task.js';
-import { registerNextTaskTool } from "./next-task.js";
+import { registerNextTaskTool } from './next-task.js';
-import { registerExpandTaskTool } from "./expand-task.js";
+import { registerExpandTaskTool } from './expand-task.js';
-import { registerAddTaskTool } from "./add-task.js";
+import { registerAddTaskTool } from './add-task.js';
-import { registerAddSubtaskTool } from "./add-subtask.js";
+import { registerAddSubtaskTool } from './add-subtask.js';
-import { registerRemoveSubtaskTool } from "./remove-subtask.js";
+import { registerRemoveSubtaskTool } from './remove-subtask.js';
-import { registerAnalyzeTool } from "./analyze.js";
+import { registerAnalyzeTool } from './analyze.js';
-import { registerClearSubtasksTool } from "./clear-subtasks.js";
+import { registerClearSubtasksTool } from './clear-subtasks.js';
-import { registerExpandAllTool } from "./expand-all.js";
+import { registerExpandAllTool } from './expand-all.js';
-import { registerRemoveDependencyTool } from "./remove-dependency.js";
+import { registerRemoveDependencyTool } from './remove-dependency.js';
-import { registerValidateDependenciesTool } from "./validate-dependencies.js";
+import { registerValidateDependenciesTool } from './validate-dependencies.js';
-import { registerFixDependenciesTool } from "./fix-dependencies.js";
+import { registerFixDependenciesTool } from './fix-dependencies.js';
-import { registerComplexityReportTool } from "./complexity-report.js";
+import { registerComplexityReportTool } from './complexity-report.js';
-import { registerAddDependencyTool } from "./add-dependency.js";
+import { registerAddDependencyTool } from './add-dependency.js';
 import { registerRemoveTaskTool } from './remove-task.js';
 import { registerInitializeProjectTool } from './initialize-project.js';
 import { asyncOperationManager } from '../core/utils/async-manager.js';
@@ -35,39 +35,37 @@ import { asyncOperationManager } from '../core/utils/async-manager.js';
  * @param {asyncOperationManager} asyncManager - The async operation manager instance
  */
 export function registerTaskMasterTools(server, asyncManager) {
-  try {
+	try {
-    // Register each tool
+		// Register each tool
-    registerListTasksTool(server);
+		registerListTasksTool(server);
-    registerSetTaskStatusTool(server);
+		registerSetTaskStatusTool(server);
-    registerParsePRDTool(server);
+		registerParsePRDTool(server);
-    registerUpdateTool(server);
+		registerUpdateTool(server);
-    registerUpdateTaskTool(server);
+		registerUpdateTaskTool(server);
-    registerUpdateSubtaskTool(server);
+		registerUpdateSubtaskTool(server);
-    registerGenerateTool(server);
+		registerGenerateTool(server);
-    registerShowTaskTool(server);
+		registerShowTaskTool(server);
-    registerNextTaskTool(server);
+		registerNextTaskTool(server);
-    registerExpandTaskTool(server);
+		registerExpandTaskTool(server);
-    registerAddTaskTool(server, asyncManager);
+		registerAddTaskTool(server, asyncManager);
-    registerAddSubtaskTool(server);
+		registerAddSubtaskTool(server);
-    registerRemoveSubtaskTool(server);
+		registerRemoveSubtaskTool(server);
-    registerAnalyzeTool(server);
+		registerAnalyzeTool(server);
-    registerClearSubtasksTool(server);
+		registerClearSubtasksTool(server);
-    registerExpandAllTool(server);
+		registerExpandAllTool(server);
-    registerRemoveDependencyTool(server);
+		registerRemoveDependencyTool(server);
-    registerValidateDependenciesTool(server);
+		registerValidateDependenciesTool(server);
-    registerFixDependenciesTool(server);
+		registerFixDependenciesTool(server);
-    registerComplexityReportTool(server);
+		registerComplexityReportTool(server);
-    registerAddDependencyTool(server);
+		registerAddDependencyTool(server);
-    registerRemoveTaskTool(server);
+		registerRemoveTaskTool(server);
-    registerInitializeProjectTool(server);
+		registerInitializeProjectTool(server);
-  } catch (error) {
+	} catch (error) {
-    logger.error(`Error registering Task Master tools: ${error.message}`);
+		logger.error(`Error registering Task Master tools: ${error.message}`);
-    throw error;
+		throw error;
-  }
+	}
-
-  logger.info('Registered Task Master MCP tools');
 }
 
 export default {
-  registerTaskMasterTools,
+	registerTaskMasterTools
 };

mcp-server/src/tools/initialize-project.js

@@ -1,62 +1,94 @@
-import { z } from "zod";
+import { z } from 'zod';
-import { execSync } from 'child_process';
+import {
-import { createContentResponse, createErrorResponse } from "./utils.js"; // Only need response creators
+	createContentResponse,
+	createErrorResponse,
+	handleApiResult
+} from './utils.js';
+import { initializeProjectDirect } from '../core/task-master-core.js';
 
 export function registerInitializeProjectTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "initialize_project", // snake_case for tool name
+		name: 'initialize_project',
-    description: "Initializes a new Task Master project structure in the current working directory by running 'task-master init'.",
+		description:
-    parameters: z.object({
+			"Initializes a new Task Master project structure by calling the core initialization logic. Derives target directory from client session. If project details (name, description, author) are not provided, prompts the user or skips if 'yes' flag is true. DO NOT run without parameters.",
-      projectName: z.string().optional().describe("The name for the new project."),
+		parameters: z.object({
-      projectDescription: z.string().optional().describe("A brief description for the project."),
+			projectName: z
-      projectVersion: z.string().optional().describe("The initial version for the project (e.g., '0.1.0')."),
+				.string()
-      authorName: z.string().optional().describe("The author's name."),
+				.optional()
-      skipInstall: z.boolean().optional().default(false).describe("Skip installing dependencies automatically."),
+				.describe(
-      addAliases: z.boolean().optional().default(false).describe("Add shell aliases (tm, taskmaster) to shell config file."),
+					'The name for the new project. If not provided, prompt the user for it.'
-      yes: z.boolean().optional().default(false).describe("Skip prompts and use default values or provided arguments."),
+				),
-      // projectRoot is not needed here as 'init' works on the current directory
+			projectDescription: z
-    }),
+				.string()
-    execute: async (args, { log }) => { // Destructure context to get log
+				.optional()
-      try {
+				.describe(
-        log.info(`Executing initialize_project with args: ${JSON.stringify(args)}`);
+					'A brief description for the project. If not provided, prompt the user for it.'
+				),
+			projectVersion: z
+				.string()
+				.optional()
+				.describe(
+					"The initial version for the project (e.g., '0.1.0'). User input not needed unless user requests to override."
+				),
+			authorName: z
+				.string()
+				.optional()
+				.describe(
+					"The author's name. User input not needed unless user requests to override."
+				),
+			skipInstall: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe(
+					'Skip installing dependencies automatically. Never do this unless you are sure the project is already installed.'
+				),
+			addAliases: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe(
+					'Add shell aliases (tm, taskmaster) to shell config file. User input not needed.'
+				),
+			yes: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe(
+					"Skip prompts and use default values or provided arguments. Use true if you wish to skip details like the project name, etc. If the project information required for the initialization is not available or provided by the user, prompt if the user wishes to provide them (name, description, author) or skip them. If the user wishes to skip, set the 'yes' flag to true and do not set any other parameters."
+				),
+			projectRoot: z
+				.string()
+				.describe(
+					'The root directory for the project. ALWAYS SET THIS TO THE PROJECT ROOT DIRECTORY. IF NOT SET, THE TOOL WILL NOT WORK.'
+				)
+		}),
+		execute: async (args, context) => {
+			const { log } = context;
+			const session = context.session;
 
-        // Construct the command arguments carefully
+			log.info(
-        // Using npx ensures it uses the locally installed version if available, or fetches it
+				'>>> Full Context Received by Tool:',
-        let command = 'npx task-master init';
+				JSON.stringify(context, null, 2)
-        const cliArgs = [];
+			);
-        if (args.projectName) cliArgs.push(`--name "${args.projectName.replace(/"/g, '\\"')}"`); // Escape quotes
+			log.info(`Context received in tool function: ${context}`);
-        if (args.projectDescription) cliArgs.push(`--description "${args.projectDescription.replace(/"/g, '\\"')}"`);
+			log.info(
-        if (args.projectVersion) cliArgs.push(`--version "${args.projectVersion.replace(/"/g, '\\"')}"`);
+				`Session received in tool function: ${session ? session : 'undefined'}`
-        if (args.authorName) cliArgs.push(`--author "${args.authorName.replace(/"/g, '\\"')}"`);
+			);
-        if (args.skipInstall) cliArgs.push('--skip-install');
-        if (args.addAliases) cliArgs.push('--aliases');
-        if (args.yes) cliArgs.push('--yes');
 
-        command += ' ' + cliArgs.join(' ');
+			try {
+				log.info(
+					`Executing initialize_project tool with args: ${JSON.stringify(args)}`
+				);
 
-        log.info(`Constructed command: ${command}`);
+				const result = await initializeProjectDirect(args, log, { session });
 
-        // Execute the command in the current working directory of the server process
+				return handleApiResult(result, log, 'Initialization failed');
-        // Capture stdout/stderr. Use a reasonable timeout (e.g., 5 minutes)
+			} catch (error) {
-        const output = execSync(command, { encoding: 'utf8', stdio: 'pipe', timeout: 300000 });
+				const errorMessage = `Project initialization tool failed: ${error.message || 'Unknown error'}`;
-
+				log.error(errorMessage, error);
-        log.info(`Initialization output:\n${output}`);
+				return createErrorResponse(errorMessage, { details: error.stack });
-
+			}
-        // Return a standard success response manually
+		}
-        return createContentResponse(
+	});
-             "Project initialized successfully.",
-             { output: output } // Include output in the data payload
-        );
-
-      } catch (error) {
-        // Catch errors from execSync or timeouts
-        const errorMessage = `Project initialization failed: ${error.message}`;
-        const errorDetails = error.stderr?.toString() || error.stdout?.toString() || error.message; // Provide stderr/stdout if available
-        log.error(`${errorMessage}\nDetails: ${errorDetails}`);
-
-        // Return a standard error response manually
-        return createErrorResponse(errorMessage, { details: errorDetails });
-      }
-    }
-  });
 }

mcp-server/src/tools/next-task.js

@@ -3,61 +3,69 @@
  * Tool to find the next task to work on
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { nextTaskDirect } from "../core/task-master-core.js";
+import { nextTaskDirect } from '../core/task-master-core.js';
 
 /**
  * Register the next-task tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerNextTaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "next_task",
+		name: 'next_task',
-    description: "Find the next task to work on based on dependencies and status",
+		description:
-    parameters: z.object({
+			'Find the next task to work on based on dependencies and status',
-      file: z.string().optional().describe("Path to the tasks file"),
+		parameters: z.object({
-      projectRoot: z
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-        .string()
+			projectRoot: z
-        .optional()
+				.string()
-        .describe(
+				.optional()
-          "Root directory of the project (default: current working directory)"
+				.describe(
-        ),
+					'Root directory of the project (default: current working directory)'
-    }),
+				)
-    execute: async (args, { log, session, reportProgress }) => {
+		}),
-      try {
+		execute: async (args, { log, session, reportProgress }) => {
-        log.info(`Finding next task with args: ${JSON.stringify(args)}`);
+			try {
-        // await reportProgress({ progress: 0 });
+				log.info(`Finding next task with args: ${JSON.stringify(args)}`);
+				// await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await nextTaskDirect({
+				const result = await nextTaskDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log/*, { reportProgress, mcpLog: log, session}*/);
+						...args
+					},
+					log /*, { reportProgress, mcpLog: log, session}*/
+				);
 
-        // await reportProgress({ progress: 100 });
+				// await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully found next task: ${result.data?.task?.id || 'No available tasks'}`);
+					log.info(
-        } else {
+						`Successfully found next task: ${result.data?.task?.id || 'No available tasks'}`
-          log.error(`Failed to find next task: ${result.error?.message || 'Unknown error'}`);
+					);
-        }
+				} else {
+					log.error(
+						`Failed to find next task: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error finding next task');
+				return handleApiResult(result, log, 'Error finding next task');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in nextTask tool: ${error.message}`);
+				log.error(`Error in nextTask tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/parse-prd.js

@@ -3,61 +3,97 @@
  * Tool to parse PRD document and generate tasks
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { parsePRDDirect } from "../core/task-master-core.js";
+import { parsePRDDirect } from '../core/task-master-core.js';
 
 /**
  * Register the parsePRD tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerParsePRDTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "parse_prd",
+		name: 'parse_prd',
-    description: "Parse a Product Requirements Document (PRD) or text file to automatically generate initial tasks.",
+		description:
-    parameters: z.object({
+			"Parse a Product Requirements Document (PRD) text file to automatically generate initial tasks. Reinitializing the project is not necessary to run this tool. It is recommended to run parse-prd after initializing the project and creating/importing a prd.txt file in the project root's scripts/ directory.",
-      input: z.string().default("tasks/tasks.json").describe("Path to the PRD document file (relative to project root or absolute)"),
+		parameters: z.object({
-      numTasks: z.string().optional().describe("Approximate number of top-level tasks to generate (default: 10)"),
+			input: z
-      output: z.string().optional().describe("Output path for tasks.json file (relative to project root or absolute, default: tasks/tasks.json)"),
+				.string()
-      force: z.boolean().optional().describe("Allow overwriting an existing tasks.json file."),
+				.default('scripts/prd.txt')
-      projectRoot: z
+				.describe('Absolute path to the PRD document file (.txt, .md, etc.)'),
-        .string()
+			numTasks: z
-        .optional()
+				.string()
-        .describe(
+				.optional()
-          "Root directory of the project (default: automatically detected from session or CWD)"
+				.describe(
-        ),
+					'Approximate number of top-level tasks to generate (default: 10). As the agent, if you have enough information, ensure to enter a number of tasks that would logically scale with project complexity. Avoid entering numbers above 50 due to context window limitations.'
-    }),
+				),
-    execute: async (args, { log, session }) => {
+			output: z
-      try {
+				.string()
-        log.info(`Parsing PRD with args: ${JSON.stringify(args)}`);
+				.optional()
+				.describe(
+					'Output absolute path for tasks.json file (default: tasks/tasks.json)'
+				),
+			force: z
+				.boolean()
+				.optional()
+				.describe('Allow overwriting an existing tasks.json file.'),
+			projectRoot: z
+				.string()
+				.describe(
+					'Absolute path to the root directory of the project. Required - ALWAYS SET THIS TO THE PROJECT ROOT DIRECTORY.'
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Parsing PRD with args: ${JSON.stringify(args)}`);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				// Make sure projectRoot is passed directly in args or derive from session
+				// We prioritize projectRoot from args over session-derived path
+				let rootFolder = args.projectRoot;
 
-        if (!rootFolder && args.projectRoot) {
+				// Only if args.projectRoot is undefined or null, try to get it from session
-          rootFolder = args.projectRoot;
+				if (!rootFolder) {
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.warn(
-        }
+						'projectRoot not provided in args, attempting to derive from session'
+					);
+					rootFolder = getProjectRootFromSession(session, log);
 
-        const result = await parsePRDDirect({
+					if (!rootFolder) {
-          projectRoot: rootFolder,
+						const errorMessage =
-          ...args
+							'Could not determine project root directory. Please provide projectRoot parameter.';
-        }, log, { session });
+						log.error(errorMessage);
+						return createErrorResponse(errorMessage);
+					}
+				}
 
-        if (result.success) {
+				log.info(`Using project root: ${rootFolder} for PRD parsing`);
-          log.info(`Successfully parsed PRD: ${result.data.message}`);
-        } else {
-          log.error(`Failed to parse PRD: ${result.error?.message || 'Unknown error'}`);
-        }
 
-        return handleApiResult(result, log, 'Error parsing PRD');
+				const result = await parsePRDDirect(
-      } catch (error) {
+					{
-        log.error(`Error in parse-prd tool: ${error.message}`);
+						projectRoot: rootFolder,
-        return createErrorResponse(error.message);
+						...args
-      }
+					},
-    },
+					log,
-  });
+					{ session }
+				);
+
+				if (result.success) {
+					log.info(`Successfully parsed PRD: ${result.data.message}`);
+				} else {
+					log.error(
+						`Failed to parse PRD: ${result.error?.message || 'Unknown error'}`
+					);
+				}
+
+				return handleApiResult(result, log, 'Error parsing PRD');
+			} catch (error) {
+				log.error(`Error in parse-prd tool: ${error.message}`);
+				return createErrorResponse(error.message);
+			}
+		}
+	});
 }

mcp-server/src/tools/remove-dependency.js

@@ -3,58 +3,73 @@
  * Tool for removing a dependency from a task
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { removeDependencyDirect } from "../core/task-master-core.js";
+import { removeDependencyDirect } from '../core/task-master-core.js';
 
 /**
  * Register the removeDependency tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerRemoveDependencyTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "remove_dependency",
+		name: 'remove_dependency',
-    description: "Remove a dependency from a task",
+		description: 'Remove a dependency from a task',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("Task ID to remove dependency from"),
+			id: z.string().describe('Task ID to remove dependency from'),
-      dependsOn: z.string().describe("Task ID to remove as a dependency"),
+			dependsOn: z.string().describe('Task ID to remove as a dependency'),
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+			file: z
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+				.string()
-    }),
+				.optional()
-    execute: async (args, { log, session, reportProgress }) => {
+				.describe(
-      try {
+					'Absolute path to the tasks file (default: tasks/tasks.json)'
-        log.info(`Removing dependency for task ${args.id} from ${args.dependsOn} with args: ${JSON.stringify(args)}`);
+				),
-        // await reportProgress({ progress: 0 });
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(
+					`Removing dependency for task ${args.id} from ${args.dependsOn} with args: ${JSON.stringify(args)}`
+				);
+				// await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await removeDependencyDirect({
+				const result = await removeDependencyDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log/*, { reportProgress, mcpLog: log, session}*/);
+						...args
+					},
+					log /*, { reportProgress, mcpLog: log, session}*/
+				);
 
-        // await reportProgress({ progress: 100 });
+				// await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully removed dependency: ${result.data.message}`);
+					log.info(`Successfully removed dependency: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to remove dependency: ${result.error.message}`);
+					log.error(`Failed to remove dependency: ${result.error.message}`);
-        }
+				}
 
-        return handleApiResult(result, log, 'Error removing dependency');
+				return handleApiResult(result, log, 'Error removing dependency');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in removeDependency tool: ${error.message}`);
+				log.error(`Error in removeDependency tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    }
+		}
-  });
+	});
 }

mcp-server/src/tools/remove-subtask.js

@@ -3,59 +3,84 @@
  * Tool for removing subtasks from parent tasks
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { removeSubtaskDirect } from "../core/task-master-core.js";
+import { removeSubtaskDirect } from '../core/task-master-core.js';
 
 /**
  * Register the removeSubtask tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerRemoveSubtaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "remove_subtask",
+		name: 'remove_subtask',
-    description: "Remove a subtask from its parent task",
+		description: 'Remove a subtask from its parent task',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("Subtask ID to remove in format 'parentId.subtaskId' (required)"),
+			id: z
-      convert: z.boolean().optional().describe("Convert the subtask to a standalone task instead of deleting it"),
+				.string()
-      file: z.string().optional().describe("Path to the tasks file (default: tasks/tasks.json)"),
+				.describe(
-      skipGenerate: z.boolean().optional().describe("Skip regenerating task files"),
+					"Subtask ID to remove in format 'parentId.subtaskId' (required)"
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+				),
-    }),
+			convert: z
-    execute: async (args, { log, session, reportProgress }) => {
+				.boolean()
-      try {
+				.optional()
-        log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
+				.describe(
-        // await reportProgress({ progress: 0 });
+					'Convert the subtask to a standalone task instead of deleting it'
+				),
+			file: z
+				.string()
+				.optional()
+				.describe(
+					'Absolute path to the tasks file (default: tasks/tasks.json)'
+				),
+			skipGenerate: z
+				.boolean()
+				.optional()
+				.describe('Skip regenerating task files'),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Removing subtask with args: ${JSON.stringify(args)}`);
+				// await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await removeSubtaskDirect({
+				const result = await removeSubtaskDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log/*, { reportProgress, mcpLog: log, session}*/);
+						...args
+					},
+					log /*, { reportProgress, mcpLog: log, session}*/
+				);
 
-        // await reportProgress({ progress: 100 });
+				// await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Subtask removed successfully: ${result.data.message}`);
+					log.info(`Subtask removed successfully: ${result.data.message}`);
-        } else {
+				} else {
-          log.error(`Failed to remove subtask: ${result.error.message}`);
+					log.error(`Failed to remove subtask: ${result.error.message}`);
-        }
+				}
 
-        return handleApiResult(result, log, 'Error removing subtask');
+				return handleApiResult(result, log, 'Error removing subtask');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in removeSubtask tool: ${error.message}`);
+				log.error(`Error in removeSubtask tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/remove-task.js

@@ -3,69 +3,79 @@
  * Tool to remove a task by ID
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { removeTaskDirect } from "../core/task-master-core.js";
+import { removeTaskDirect } from '../core/task-master-core.js';
 
 /**
  * Register the remove-task tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerRemoveTaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "remove_task",
+		name: 'remove_task',
-    description: "Remove a task or subtask permanently from the tasks list",
+		description: 'Remove a task or subtask permanently from the tasks list',
-    parameters: z.object({
+		parameters: z.object({
-      id: z.string().describe("ID of the task or subtask to remove (e.g., '5' or '5.2')"),
+			id: z
-      file: z.string().optional().describe("Path to the tasks file"),
+				.string()
-      projectRoot: z
+				.describe("ID of the task or subtask to remove (e.g., '5' or '5.2')"),
-        .string()
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-        .optional()
+			projectRoot: z
-        .describe(
+				.string()
-          "Root directory of the project (default: current working directory)"
+				.optional()
-        ),
+				.describe(
-      confirm: z.boolean().optional().describe("Whether to skip confirmation prompt (default: false)")
+					'Root directory of the project (default: current working directory)'
-    }),
+				),
-    execute: async (args, { log, session }) => {
+			confirm: z
-      try {
+				.boolean()
-        log.info(`Removing task with ID: ${args.id}`);
+				.optional()
+				.describe('Whether to skip confirmation prompt (default: false)')
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Removing task with ID: ${args.id}`);
 
-        // Get project root from session
+				// Get project root from session
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        } else if (!rootFolder) {
+				} else if (!rootFolder) {
-          // Ensure we have a default if nothing else works
+					// Ensure we have a default if nothing else works
-          rootFolder = process.cwd();
+					rootFolder = process.cwd();
-          log.warn(`Session and args failed to provide root, using CWD: ${rootFolder}`);
+					log.warn(
-        }
+						`Session and args failed to provide root, using CWD: ${rootFolder}`
+					);
+				}
 
-        log.info(`Using project root: ${rootFolder}`);
+				log.info(`Using project root: ${rootFolder}`);
 
-        // Assume client has already handled confirmation if needed
+				// Assume client has already handled confirmation if needed
-        const result = await removeTaskDirect({
+				const result = await removeTaskDirect(
-          id: args.id,
+					{
-          file: args.file,
+						id: args.id,
-          projectRoot: rootFolder
+						file: args.file,
-        }, log);
+						projectRoot: rootFolder
+					},
+					log
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully removed task: ${args.id}`);
+					log.info(`Successfully removed task: ${args.id}`);
-        } else {
+				} else {
-          log.error(`Failed to remove task: ${result.error.message}`);
+					log.error(`Failed to remove task: ${result.error.message}`);
-        }
+				}
 
-        return handleApiResult(result, log, 'Error removing task');
+				return handleApiResult(result, log, 'Error removing task');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in remove-task tool: ${error.message}`);
+				log.error(`Error in remove-task tool: ${error.message}`);
-        return createErrorResponse(`Failed to remove task: ${error.message}`);
+				return createErrorResponse(`Failed to remove task: ${error.message}`);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/set-task-status.js

@@ -3,68 +3,81 @@
  * Tool to set the status of a task
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { setTaskStatusDirect } from "../core/task-master-core.js";
+import { setTaskStatusDirect } from '../core/task-master-core.js';
 
 /**
  * Register the setTaskStatus tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerSetTaskStatusTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "set_task_status",
+		name: 'set_task_status',
-    description: "Set the status of one or more tasks or subtasks.",
+		description: 'Set the status of one or more tasks or subtasks.',
-    parameters: z.object({
+		parameters: z.object({
-      id: z
+			id: z
-        .string()
+				.string()
-        .describe("Task ID or subtask ID (e.g., '15', '15.2'). Can be comma-separated for multiple updates."),
+				.describe(
-      status: z
+					"Task ID or subtask ID (e.g., '15', '15.2'). Can be comma-separated for multiple updates."
-        .string()
+				),
-        .describe("New status to set (e.g., 'pending', 'done', 'in-progress', 'review', 'deferred', 'cancelled'."),
+			status: z
-      file: z.string().optional().describe("Path to the tasks file"),
+				.string()
-      projectRoot: z
+				.describe(
-        .string()
+					"New status to set (e.g., 'pending', 'done', 'in-progress', 'review', 'deferred', 'cancelled'."
-        .optional()
+				),
-        .describe(
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-          "Root directory of the project (default: automatically detected)"
+			projectRoot: z
-        ),
+				.string()
-    }),
+				.optional()
-    execute: async (args, { log, session }) => {
+				.describe(
-      try {
+					'Root directory of the project (default: automatically detected)'
-        log.info(`Setting status of task(s) ${args.id} to: ${args.status}`);
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Setting status of task(s) ${args.id} to: ${args.status}`);
 
-        // Get project root from session
+				// Get project root from session
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        // Call the direct function with the project root
+				// Call the direct function with the project root
-        const result = await setTaskStatusDirect({
+				const result = await setTaskStatusDirect(
-          ...args,
+					{
-          projectRoot: rootFolder
+						...args,
-        }, log);
+						projectRoot: rootFolder
+					},
+					log
+				);
 
-        // Log the result
+				// Log the result
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully updated status for task(s) ${args.id} to "${args.status}": ${result.data.message}`);
+					log.info(
-        } else {
+						`Successfully updated status for task(s) ${args.id} to "${args.status}": ${result.data.message}`
-          log.error(`Failed to update task status: ${result.error?.message || 'Unknown error'}`);
+					);
-        }
+				} else {
+					log.error(
+						`Failed to update task status: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        // Format and return the result
+				// Format and return the result
-        return handleApiResult(result, log, 'Error setting task status');
+				return handleApiResult(result, log, 'Error setting task status');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in setTaskStatus tool: ${error.message}`);
+				log.error(`Error in setTaskStatus tool: ${error.message}`);
-        return createErrorResponse(`Error setting task status: ${error.message}`);
+				return createErrorResponse(
-      }
+					`Error setting task status: ${error.message}`
-    },
+				);
-  });
+			}
+		}
+	});
 }

mcp-server/src/tools/update-subtask.js

@@ -3,61 +3,75 @@
  * Tool to append additional information to a specific subtask
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { updateSubtaskByIdDirect } from "../core/task-master-core.js";
+import { updateSubtaskByIdDirect } from '../core/task-master-core.js';
 
 /**
  * Register the update-subtask tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerUpdateSubtaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "update_subtask",
+		name: 'update_subtask',
-    description: "Appends additional information to a specific subtask without replacing existing content",
+		description:
-    parameters: z.object({
+			'Appends additional information to a specific subtask without replacing existing content',
-      id: z.string().describe("ID of the subtask to update in format \"parentId.subtaskId\" (e.g., \"5.2\")"),
+		parameters: z.object({
-      prompt: z.string().describe("Information to add to the subtask"),
+			id: z
-      research: z.boolean().optional().describe("Use Perplexity AI for research-backed updates"),
+				.string()
-      file: z.string().optional().describe("Path to the tasks file"),
+				.describe(
-      projectRoot: z
+					'ID of the subtask to update in format "parentId.subtaskId" (e.g., "5.2")'
-        .string()
+				),
-        .optional()
+			prompt: z.string().describe('Information to add to the subtask'),
-        .describe(
+			research: z
-          "Root directory of the project (default: current working directory)"
+				.boolean()
-        ),
+				.optional()
-    }),
+				.describe('Use Perplexity AI for research-backed updates'),
-    execute: async (args, { log, session }) => {
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-      try {
+			projectRoot: z
-        log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Updating subtask with args: ${JSON.stringify(args)}`);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await updateSubtaskByIdDirect({
+				const result = await updateSubtaskByIdDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { session });
+						...args
+					},
+					log,
+					{ session }
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully updated subtask with ID ${args.id}`);
+					log.info(`Successfully updated subtask with ID ${args.id}`);
-        } else {
+				} else {
-          log.error(`Failed to update subtask: ${result.error?.message || 'Unknown error'}`);
+					log.error(
-        }
+						`Failed to update subtask: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error updating subtask');
+				return handleApiResult(result, log, 'Error updating subtask');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in update_subtask tool: ${error.message}`);
+				log.error(`Error in update_subtask tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/update-task.js

@@ -3,61 +3,75 @@
  * Tool to update a single task by ID with new information
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { updateTaskByIdDirect } from "../core/task-master-core.js";
+import { updateTaskByIdDirect } from '../core/task-master-core.js';
 
 /**
  * Register the update-task tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerUpdateTaskTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "update_task",
+		name: 'update_task',
-    description: "Updates a single task by ID with new information or context provided in the prompt.",
+		description:
-    parameters: z.object({
+			'Updates a single task by ID with new information or context provided in the prompt.',
-      id: z.string().describe("ID of the task or subtask (e.g., '15', '15.2') to update"),
+		parameters: z.object({
-      prompt: z.string().describe("New information or context to incorporate into the task"),
+			id: z
-      research: z.boolean().optional().describe("Use Perplexity AI for research-backed updates"),
+				.string()
-      file: z.string().optional().describe("Path to the tasks file"),
+				.describe("ID of the task or subtask (e.g., '15', '15.2') to update"),
-      projectRoot: z
+			prompt: z
-        .string()
+				.string()
-        .optional()
+				.describe('New information or context to incorporate into the task'),
-        .describe(
+			research: z
-          "Root directory of the project (default: current working directory)"
+				.boolean()
-        ),
+				.optional()
-    }),
+				.describe('Use Perplexity AI for research-backed updates'),
-    execute: async (args, { log, session }) => {
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-      try {
+			projectRoot: z
-        log.info(`Updating task with args: ${JSON.stringify(args)}`);
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Updating task with args: ${JSON.stringify(args)}`);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await updateTaskByIdDirect({
+				const result = await updateTaskByIdDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { session });
+						...args
+					},
+					log,
+					{ session }
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully updated task with ID ${args.id}`);
+					log.info(`Successfully updated task with ID ${args.id}`);
-        } else {
+				} else {
-          log.error(`Failed to update task: ${result.error?.message || 'Unknown error'}`);
+					log.error(
-        }
+						`Failed to update task: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error updating task');
+				return handleApiResult(result, log, 'Error updating task');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in update_task tool: ${error.message}`);
+				log.error(`Error in update_task tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/update.js

@@ -3,61 +3,79 @@
  * Tool to update tasks based on new context/prompt
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { updateTasksDirect } from "../core/task-master-core.js";
+import { updateTasksDirect } from '../core/task-master-core.js';
 
 /**
  * Register the update tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerUpdateTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "update",
+		name: 'update',
-    description: "Update multiple upcoming tasks (with ID >= 'from' ID) based on new context or changes provided in the prompt. Use 'update_task' instead for a single specific task.",
+		description:
-    parameters: z.object({
+			"Update multiple upcoming tasks (with ID >= 'from' ID) based on new context or changes provided in the prompt. Use 'update_task' instead for a single specific task.",
-      from: z.string().describe("Task ID from which to start updating (inclusive). IMPORTANT: This tool uses 'from', not 'id'"),
+		parameters: z.object({
-      prompt: z.string().describe("Explanation of changes or new context to apply"),
+			from: z
-      research: z.boolean().optional().describe("Use Perplexity AI for research-backed updates"),
+				.string()
-      file: z.string().optional().describe("Path to the tasks file"),
+				.describe(
-      projectRoot: z
+					"Task ID from which to start updating (inclusive). IMPORTANT: This tool uses 'from', not 'id'"
-        .string()
+				),
-        .optional()
+			prompt: z
-        .describe(
+				.string()
-          "Root directory of the project (default: current working directory)"
+				.describe('Explanation of changes or new context to apply'),
-        ),
+			research: z
-    }),
+				.boolean()
-    execute: async (args, { log, session }) => {
+				.optional()
-      try {
+				.describe('Use Perplexity AI for research-backed updates'),
-        log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
+			file: z.string().optional().describe('Absolute path to the tasks file'),
+			projectRoot: z
+				.string()
+				.optional()
+				.describe(
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session }) => {
+			try {
+				log.info(`Updating tasks with args: ${JSON.stringify(args)}`);
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await updateTasksDirect({
+				const result = await updateTasksDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { session });
+						...args
+					},
+					log,
+					{ session }
+				);
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully updated tasks from ID ${args.from}: ${result.data.message}`);
+					log.info(
-        } else {
+						`Successfully updated tasks from ID ${args.from}: ${result.data.message}`
-          log.error(`Failed to update tasks: ${result.error?.message || 'Unknown error'}`);
+					);
-        }
+				} else {
+					log.error(
+						`Failed to update tasks: ${result.error?.message || 'Unknown error'}`
+					);
+				}
 
-        return handleApiResult(result, log, 'Error updating tasks');
+				return handleApiResult(result, log, 'Error updating tasks');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in update tool: ${error.message}`);
+				log.error(`Error in update tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-server/src/tools/utils.js

@@ -3,13 +3,13 @@
  * Utility functions for Task Master CLI integration
  */
 
-import { spawnSync } from "child_process";
+import { spawnSync } from 'child_process';
-import path from "path";
+import path from 'path';
 import fs from 'fs';
 import { contextManager } from '../core/context-manager.js'; // Import the singleton
 
 // Import path utilities to ensure consistent path resolution
-import { lastFoundProjectRoot, PROJECT_MARKERS } from '../core/utils/path-utils.js';
+import { PROJECT_MARKERS } from '../core/utils/path-utils.js';
 
 /**
  * Get normalized project root path
@@ -18,53 +18,65 @@ import { lastFoundProjectRoot, PROJECT_MARKERS } from '../core/utils/path-utils.
  * @returns {string} - Normalized absolute path to project root
  */
 function getProjectRoot(projectRootRaw, log) {
-  // PRECEDENCE ORDER:
+	// PRECEDENCE ORDER:
-  // 1. Environment variable override
+	// 1. Environment variable override
-  // 2. Explicitly provided projectRoot in args
+	// 2. Explicitly provided projectRoot in args
-  // 3. Previously found/cached project root
+	// 3. Previously found/cached project root
-  // 4. Current directory if it has project markers
+	// 4. Current directory if it has project markers
-  // 5. Current directory with warning
+	// 5. Current directory with warning
 
-  // 1. Check for environment variable override
+	// 1. Check for environment variable override
-  if (process.env.TASK_MASTER_PROJECT_ROOT) {
+	if (process.env.TASK_MASTER_PROJECT_ROOT) {
-    const envRoot = process.env.TASK_MASTER_PROJECT_ROOT;
+		const envRoot = process.env.TASK_MASTER_PROJECT_ROOT;
-    const absolutePath = path.isAbsolute(envRoot) 
+		const absolutePath = path.isAbsolute(envRoot)
-      ? envRoot 
+			? envRoot
-      : path.resolve(process.cwd(), envRoot);
+			: path.resolve(process.cwd(), envRoot);
-    log.info(`Using project root from TASK_MASTER_PROJECT_ROOT environment variable: ${absolutePath}`);
+		log.info(
-    return absolutePath;
+			`Using project root from TASK_MASTER_PROJECT_ROOT environment variable: ${absolutePath}`
-  }
+		);
+		return absolutePath;
+	}
 
-  // 2. If project root is explicitly provided, use it
+	// 2. If project root is explicitly provided, use it
-  if (projectRootRaw) {
+	if (projectRootRaw) {
-    const absolutePath = path.isAbsolute(projectRootRaw) 
+		const absolutePath = path.isAbsolute(projectRootRaw)
-      ? projectRootRaw 
+			? projectRootRaw
-      : path.resolve(process.cwd(), projectRootRaw);
+			: path.resolve(process.cwd(), projectRootRaw);
 
-    log.info(`Using explicitly provided project root: ${absolutePath}`);
+		log.info(`Using explicitly provided project root: ${absolutePath}`);
-    return absolutePath;
+		return absolutePath;
-  }
+	}
 
-  // 3. If we have a last found project root from a tasks.json search, use that for consistency
+	// 3. If we have a last found project root from a tasks.json search, use that for consistency
-  if (lastFoundProjectRoot) {
+	if (lastFoundProjectRoot) {
-    log.info(`Using last known project root where tasks.json was found: ${lastFoundProjectRoot}`);
+		log.info(
-    return lastFoundProjectRoot;
+			`Using last known project root where tasks.json was found: ${lastFoundProjectRoot}`
-  }
+		);
+		return lastFoundProjectRoot;
+	}
 
-  // 4. Check if the current directory has any indicators of being a task-master project
+	// 4. Check if the current directory has any indicators of being a task-master project
-  const currentDir = process.cwd();
+	const currentDir = process.cwd();
-  if (PROJECT_MARKERS.some(marker => {
+	if (
-    const markerPath = path.join(currentDir, marker);
+		PROJECT_MARKERS.some((marker) => {
-    return fs.existsSync(markerPath);
+			const markerPath = path.join(currentDir, marker);
-  })) {
+			return fs.existsSync(markerPath);
-    log.info(`Using current directory as project root (found project markers): ${currentDir}`);
+		})
-    return currentDir;
+	) {
-  }
+		log.info(
+			`Using current directory as project root (found project markers): ${currentDir}`
+		);
+		return currentDir;
+	}
 
-  // 5. Default to current working directory but warn the user
+	// 5. Default to current working directory but warn the user
-  log.warn(`No task-master project detected in current directory. Using ${currentDir} as project root.`);
+	log.warn(
-  log.warn('Consider using --project-root to specify the correct project location or set TASK_MASTER_PROJECT_ROOT environment variable.');
+		`No task-master project detected in current directory. Using ${currentDir} as project root.`
-  return currentDir;
+	);
+	log.warn(
+		'Consider using --project-root to specify the correct project location or set TASK_MASTER_PROJECT_ROOT environment variable.'
+	);
+	return currentDir;
 }
 
 /**
@@ -74,81 +86,87 @@ function getProjectRoot(projectRootRaw, log) {
  * @returns {string|null} - The absolute path to the project root, or null if not found.
  */
 function getProjectRootFromSession(session, log) {
-  try {
+	try {
-    // Add detailed logging of session structure
+		// Add detailed logging of session structure
-    log.info(`Session object: ${JSON.stringify({
+		log.info(
-      hasSession: !!session,
+			`Session object: ${JSON.stringify({
-      hasRoots: !!session?.roots,
+				hasSession: !!session,
-      rootsType: typeof session?.roots,
+				hasRoots: !!session?.roots,
-      isRootsArray: Array.isArray(session?.roots),
+				rootsType: typeof session?.roots,
-      rootsLength: session?.roots?.length,
+				isRootsArray: Array.isArray(session?.roots),
-      firstRoot: session?.roots?.[0],
+				rootsLength: session?.roots?.length,
-      hasRootsRoots: !!session?.roots?.roots,
+				firstRoot: session?.roots?.[0],
-      rootsRootsType: typeof session?.roots?.roots,
+				hasRootsRoots: !!session?.roots?.roots,
-      isRootsRootsArray: Array.isArray(session?.roots?.roots),
+				rootsRootsType: typeof session?.roots?.roots,
-      rootsRootsLength: session?.roots?.roots?.length,
+				isRootsRootsArray: Array.isArray(session?.roots?.roots),
-      firstRootsRoot: session?.roots?.roots?.[0]
+				rootsRootsLength: session?.roots?.roots?.length,
-    })}`);
+				firstRootsRoot: session?.roots?.roots?.[0]
+			})}`
+		);
 
-    // ALWAYS ensure we return a valid path for project root
+		// ALWAYS ensure we return a valid path for project root
-    const cwd = process.cwd();
+		const cwd = process.cwd();
 
-    // If we have a session with roots array
+		// If we have a session with roots array
-    if (session?.roots?.[0]?.uri) {
+		if (session?.roots?.[0]?.uri) {
-      const rootUri = session.roots[0].uri;
+			const rootUri = session.roots[0].uri;
-      log.info(`Found rootUri in session.roots[0].uri: ${rootUri}`);
+			log.info(`Found rootUri in session.roots[0].uri: ${rootUri}`);
-      const rootPath = rootUri.startsWith('file://')
+			const rootPath = rootUri.startsWith('file://')
-        ? decodeURIComponent(rootUri.slice(7))
+				? decodeURIComponent(rootUri.slice(7))
-        : rootUri;
+				: rootUri;
-      log.info(`Decoded rootPath: ${rootPath}`);
+			log.info(`Decoded rootPath: ${rootPath}`);
-      return rootPath;
+			return rootPath;
-    }
+		}
 
-    // If we have a session with roots.roots array (different structure)
+		// If we have a session with roots.roots array (different structure)
-    if (session?.roots?.roots?.[0]?.uri) {
+		if (session?.roots?.roots?.[0]?.uri) {
-      const rootUri = session.roots.roots[0].uri;
+			const rootUri = session.roots.roots[0].uri;
-      log.info(`Found rootUri in session.roots.roots[0].uri: ${rootUri}`);
+			log.info(`Found rootUri in session.roots.roots[0].uri: ${rootUri}`);
-      const rootPath = rootUri.startsWith('file://')
+			const rootPath = rootUri.startsWith('file://')
-        ? decodeURIComponent(rootUri.slice(7))
+				? decodeURIComponent(rootUri.slice(7))
-        : rootUri;
+				: rootUri;
-      log.info(`Decoded rootPath: ${rootPath}`);
+			log.info(`Decoded rootPath: ${rootPath}`);
-      return rootPath;
+			return rootPath;
-    }
+		}
 
-    // Get the server's location and try to find project root -- this is a fallback necessary in Cursor IDE
+		// Get the server's location and try to find project root -- this is a fallback necessary in Cursor IDE
-    const serverPath = process.argv[1];  // This should be the path to server.js, which is in mcp-server/
+		const serverPath = process.argv[1]; // This should be the path to server.js, which is in mcp-server/
-    if (serverPath && serverPath.includes('mcp-server')) {
+		if (serverPath && serverPath.includes('mcp-server')) {
-      // Find the mcp-server directory first
+			// Find the mcp-server directory first
-      const mcpServerIndex = serverPath.indexOf('mcp-server');
+			const mcpServerIndex = serverPath.indexOf('mcp-server');
-      if (mcpServerIndex !== -1) {
+			if (mcpServerIndex !== -1) {
-        // Get the path up to mcp-server, which should be the project root
+				// Get the path up to mcp-server, which should be the project root
-        const projectRoot = serverPath.substring(0, mcpServerIndex - 1); // -1 to remove trailing slash
+				const projectRoot = serverPath.substring(0, mcpServerIndex - 1); // -1 to remove trailing slash
 
-        // Verify this looks like our project root by checking for key files/directories
+				// Verify this looks like our project root by checking for key files/directories
-        if (fs.existsSync(path.join(projectRoot, '.cursor')) || 
+				if (
-            fs.existsSync(path.join(projectRoot, 'mcp-server')) ||
+					fs.existsSync(path.join(projectRoot, '.cursor')) ||
-            fs.existsSync(path.join(projectRoot, 'package.json'))) {
+					fs.existsSync(path.join(projectRoot, 'mcp-server')) ||
-          log.info(`Found project root from server path: ${projectRoot}`);
+					fs.existsSync(path.join(projectRoot, 'package.json'))
-          return projectRoot;
+				) {
-        }
+					log.info(`Found project root from server path: ${projectRoot}`);
-      }
+					return projectRoot;
-    }
+				}
+			}
+		}
 
-    // ALWAYS ensure we return a valid path as a last resort
+		// ALWAYS ensure we return a valid path as a last resort
-    log.info(`Using current working directory as ultimate fallback: ${cwd}`);
+		log.info(`Using current working directory as ultimate fallback: ${cwd}`);
-    return cwd;
+		return cwd;
-  } catch (e) {
+	} catch (e) {
-    // If we have a server path, use it as a basis for project root
+		// If we have a server path, use it as a basis for project root
-    const serverPath = process.argv[1];
+		const serverPath = process.argv[1];
-    if (serverPath && serverPath.includes('mcp-server')) {
+		if (serverPath && serverPath.includes('mcp-server')) {
-      const mcpServerIndex = serverPath.indexOf('mcp-server');
+			const mcpServerIndex = serverPath.indexOf('mcp-server');
-      return mcpServerIndex !== -1 ? serverPath.substring(0, mcpServerIndex - 1) : process.cwd();
+			return mcpServerIndex !== -1
-    }
+				? serverPath.substring(0, mcpServerIndex - 1)
+				: process.cwd();
+		}
 
-    // Only use cwd if it's not "/"
+		// Only use cwd if it's not "/"
-    const cwd = process.cwd();
+		const cwd = process.cwd();
-    return cwd !== '/' ? cwd : '/';
+		return cwd !== '/' ? cwd : '/';
-  }
+	}
 }
 
 /**
@@ -159,28 +177,35 @@ function getProjectRootFromSession(session, log) {
  * @param {Function} processFunction - Optional function to process successful result data
  * @returns {Object} - Standardized MCP response object
  */
-function handleApiResult(result, log, errorPrefix = 'API error', processFunction = processMCPResponseData) {
+function handleApiResult(
-  if (!result.success) {
+	result,
-    const errorMsg = result.error?.message || `Unknown ${errorPrefix}`;
+	log,
-    // Include cache status in error logs
+	errorPrefix = 'API error',
-    log.error(`${errorPrefix}: ${errorMsg}. From cache: ${result.fromCache}`); // Keep logging cache status on error
+	processFunction = processMCPResponseData
-    return createErrorResponse(errorMsg);
+) {
-  }
+	if (!result.success) {
+		const errorMsg = result.error?.message || `Unknown ${errorPrefix}`;
+		// Include cache status in error logs
+		log.error(`${errorPrefix}: ${errorMsg}. From cache: ${result.fromCache}`); // Keep logging cache status on error
+		return createErrorResponse(errorMsg);
+	}
 
-  // Process the result data if needed
+	// Process the result data if needed
-  const processedData = processFunction ? processFunction(result.data) : result.data;
+	const processedData = processFunction
+		? processFunction(result.data)
+		: result.data;
 
-  // Log success including cache status
+	// Log success including cache status
-  log.info(`Successfully completed operation. From cache: ${result.fromCache}`); // Add success log with cache status
+	log.info(`Successfully completed operation. From cache: ${result.fromCache}`); // Add success log with cache status
 
-  // Create the response payload including the fromCache flag
+	// Create the response payload including the fromCache flag
-  const responsePayload = {
+	const responsePayload = {
-    fromCache: result.fromCache, // Get the flag from the original 'result'
+		fromCache: result.fromCache, // Get the flag from the original 'result'
-    data: processedData         // Nest the processed data under a 'data' key
+		data: processedData // Nest the processed data under a 'data' key
-  };
+	};
 
-  // Pass this combined payload to createContentResponse
+	// Pass this combined payload to createContentResponse
-  return createContentResponse(responsePayload);
+	return createContentResponse(responsePayload);
 }
 
 /**
@@ -193,75 +218,75 @@ function handleApiResult(result, log, errorPrefix = 'API error', processFunction
  * @returns {Object} - The result of the command execution
  */
 function executeTaskMasterCommand(
-  command,
+	command,
-  log,
+	log,
-  args = [],
+	args = [],
-  projectRootRaw = null,
+	projectRootRaw = null,
-  customEnv = null // Changed from session to customEnv
+	customEnv = null // Changed from session to customEnv
 ) {
-  try {
+	try {
-    // Normalize project root internally using the getProjectRoot utility
+		// Normalize project root internally using the getProjectRoot utility
-    const cwd = getProjectRoot(projectRootRaw, log);
+		const cwd = getProjectRoot(projectRootRaw, log);
 
-    log.info(
+		log.info(
-      `Executing task-master ${command} with args: ${JSON.stringify(
+			`Executing task-master ${command} with args: ${JSON.stringify(
-        args
+				args
-      )} in directory: ${cwd}`
+			)} in directory: ${cwd}`
-    );
+		);
 
-    // Prepare full arguments array
+		// Prepare full arguments array
-    const fullArgs = [command, ...args];
+		const fullArgs = [command, ...args];
 
-    // Common options for spawn
+		// Common options for spawn
-    const spawnOptions = {
+		const spawnOptions = {
-      encoding: "utf8",
+			encoding: 'utf8',
-      cwd: cwd,
+			cwd: cwd,
-      // Merge process.env with customEnv, giving precedence to customEnv
+			// Merge process.env with customEnv, giving precedence to customEnv
-      env: { ...process.env, ...(customEnv || {}) }
+			env: { ...process.env, ...(customEnv || {}) }
-    };
+		};
 
-    // Log the environment being passed (optional, for debugging)
+		// Log the environment being passed (optional, for debugging)
-    // log.info(`Spawn options env: ${JSON.stringify(spawnOptions.env)}`);
+		// log.info(`Spawn options env: ${JSON.stringify(spawnOptions.env)}`);
 
-    // Execute the command using the global task-master CLI or local script
+		// Execute the command using the global task-master CLI or local script
-    // Try the global CLI first
+		// Try the global CLI first
-    let result = spawnSync("task-master", fullArgs, spawnOptions);
+		let result = spawnSync('task-master', fullArgs, spawnOptions);
 
-    // If global CLI is not available, try fallback to the local script
+		// If global CLI is not available, try fallback to the local script
-    if (result.error && result.error.code === "ENOENT") {
+		if (result.error && result.error.code === 'ENOENT') {
-      log.info("Global task-master not found, falling back to local script");
+			log.info('Global task-master not found, falling back to local script');
-      // Pass the same spawnOptions (including env) to the fallback
+			// Pass the same spawnOptions (including env) to the fallback
-      result = spawnSync("node", ["scripts/dev.js", ...fullArgs], spawnOptions);
+			result = spawnSync('node', ['scripts/dev.js', ...fullArgs], spawnOptions);
-    }
+		}
 
-    if (result.error) {
+		if (result.error) {
-      throw new Error(`Command execution error: ${result.error.message}`);
+			throw new Error(`Command execution error: ${result.error.message}`);
-    }
+		}
 
-    if (result.status !== 0) {
+		if (result.status !== 0) {
-      // Improve error handling by combining stderr and stdout if stderr is empty
+			// Improve error handling by combining stderr and stdout if stderr is empty
-      const errorOutput = result.stderr
+			const errorOutput = result.stderr
-        ? result.stderr.trim()
+				? result.stderr.trim()
-        : result.stdout
+				: result.stdout
-        ? result.stdout.trim()
+					? result.stdout.trim()
-        : "Unknown error";
+					: 'Unknown error';
-      throw new Error(
+			throw new Error(
-        `Command failed with exit code ${result.status}: ${errorOutput}`
+				`Command failed with exit code ${result.status}: ${errorOutput}`
-      );
+			);
-    }
+		}
 
-    return {
+		return {
-      success: true,
+			success: true,
-      stdout: result.stdout,
+			stdout: result.stdout,
-      stderr: result.stderr,
+			stderr: result.stderr
-    };
+		};
-  } catch (error) {
+	} catch (error) {
-    log.error(`Error executing task-master command: ${error.message}`);
+		log.error(`Error executing task-master command: ${error.message}`);
-    return {
+		return {
-      success: false,
+			success: false,
-      error: error.message,
+			error: error.message
-    };
+		};
-  }
+	}
 }
 
 /**
@@ -277,40 +302,44 @@ function executeTaskMasterCommand(
  *                              Format: { success: boolean, data?: any, error?: { code: string, message: string }, fromCache: boolean }
  */
 async function getCachedOrExecute({ cacheKey, actionFn, log }) {
-  // Check cache first
+	// Check cache first
-  const cachedResult = contextManager.getCachedData(cacheKey);
+	const cachedResult = contextManager.getCachedData(cacheKey);
 
-  if (cachedResult !== undefined) {
+	if (cachedResult !== undefined) {
-    log.info(`Cache hit for key: ${cacheKey}`);
+		log.info(`Cache hit for key: ${cacheKey}`);
-    // Return the cached data in the same structure as a fresh result
+		// Return the cached data in the same structure as a fresh result
-    return {
+		return {
-      ...cachedResult,  // Spread the cached result to maintain its structure
+			...cachedResult, // Spread the cached result to maintain its structure
-      fromCache: true   // Just add the fromCache flag
+			fromCache: true // Just add the fromCache flag
-    };
+		};
-  }
+	}
 
-  log.info(`Cache miss for key: ${cacheKey}. Executing action function.`);
+	log.info(`Cache miss for key: ${cacheKey}. Executing action function.`);
 
-  // Execute the action function if cache missed
+	// Execute the action function if cache missed
-  const result = await actionFn();
+	const result = await actionFn();
 
-  // If the action was successful, cache the result (but without fromCache flag)
+	// If the action was successful, cache the result (but without fromCache flag)
-  if (result.success && result.data !== undefined) {
+	if (result.success && result.data !== undefined) {
-    log.info(`Action successful. Caching result for key: ${cacheKey}`);
+		log.info(`Action successful. Caching result for key: ${cacheKey}`);
-    // Cache the entire result structure (minus the fromCache flag)
+		// Cache the entire result structure (minus the fromCache flag)
-    const { fromCache, ...resultToCache } = result;
+		const { fromCache, ...resultToCache } = result;
-    contextManager.setCachedData(cacheKey, resultToCache);
+		contextManager.setCachedData(cacheKey, resultToCache);
-  } else if (!result.success) {
+	} else if (!result.success) {
-    log.warn(`Action failed for cache key ${cacheKey}. Result not cached. Error: ${result.error?.message}`);
+		log.warn(
-  } else {
+			`Action failed for cache key ${cacheKey}. Result not cached. Error: ${result.error?.message}`
-    log.warn(`Action for cache key ${cacheKey} succeeded but returned no data. Result not cached.`);
+		);
-  }
+	} else {
+		log.warn(
+			`Action for cache key ${cacheKey} succeeded but returned no data. Result not cached.`
+		);
+	}
 
-  // Return the fresh result, indicating it wasn't from cache
+	// Return the fresh result, indicating it wasn't from cache
-  return {
+	return {
-    ...result,
+		...result,
-    fromCache: false
+		fromCache: false
-  };
+	};
 }
 
 /**
@@ -320,56 +349,68 @@ async function getCachedOrExecute({ cacheKey, actionFn, log }) {
  * @param {string[]} fieldsToRemove - An array of field names to remove.
  * @returns {Object|Array} - The processed data with specified fields removed.
  */
-function processMCPResponseData(taskOrData, fieldsToRemove = ['details', 'testStrategy']) {
+function processMCPResponseData(
-  if (!taskOrData) {
+	taskOrData,
-    return taskOrData;
+	fieldsToRemove = ['details', 'testStrategy']
-  }
+) {
+	if (!taskOrData) {
+		return taskOrData;
+	}
 
-  // Helper function to process a single task object
+	// Helper function to process a single task object
-  const processSingleTask = (task) => {
+	const processSingleTask = (task) => {
-    if (typeof task !== 'object' || task === null) {
+		if (typeof task !== 'object' || task === null) {
-        return task;
+			return task;
-    }
+		}
 
-    const processedTask = { ...task };
+		const processedTask = { ...task };
 
-    // Remove specified fields from the task
+		// Remove specified fields from the task
-    fieldsToRemove.forEach(field => {
+		fieldsToRemove.forEach((field) => {
-      delete processedTask[field];
+			delete processedTask[field];
-    });
+		});
 
-    // Recursively process subtasks if they exist and are an array
+		// Recursively process subtasks if they exist and are an array
-    if (processedTask.subtasks && Array.isArray(processedTask.subtasks)) {
+		if (processedTask.subtasks && Array.isArray(processedTask.subtasks)) {
-      // Use processArrayOfTasks to handle the subtasks array
+			// Use processArrayOfTasks to handle the subtasks array
-      processedTask.subtasks = processArrayOfTasks(processedTask.subtasks); 
+			processedTask.subtasks = processArrayOfTasks(processedTask.subtasks);
-    }
+		}
 
-    return processedTask;
+		return processedTask;
-  };
+	};
 
-  // Helper function to process an array of tasks
+	// Helper function to process an array of tasks
-  const processArrayOfTasks = (tasks) => {
+	const processArrayOfTasks = (tasks) => {
-      return tasks.map(processSingleTask);
+		return tasks.map(processSingleTask);
-  };
+	};
 
-  // Check if the input is a data structure containing a 'tasks' array (like from listTasks)
+	// Check if the input is a data structure containing a 'tasks' array (like from listTasks)
-  if (typeof taskOrData === 'object' && taskOrData !== null && Array.isArray(taskOrData.tasks)) {
+	if (
-    return {
+		typeof taskOrData === 'object' &&
-      ...taskOrData, // Keep other potential fields like 'stats', 'filter'
+		taskOrData !== null &&
-      tasks: processArrayOfTasks(taskOrData.tasks),
+		Array.isArray(taskOrData.tasks)
-    };
+	) {
-  } 
+		return {
-  // Check if the input is likely a single task object (add more checks if needed)
+			...taskOrData, // Keep other potential fields like 'stats', 'filter'
-  else if (typeof taskOrData === 'object' && taskOrData !== null && 'id' in taskOrData && 'title' in taskOrData) {
+			tasks: processArrayOfTasks(taskOrData.tasks)
-    return processSingleTask(taskOrData);
+		};
-  }
+	}
-  // Check if the input is an array of tasks directly (less common but possible)
+	// Check if the input is likely a single task object (add more checks if needed)
-  else if (Array.isArray(taskOrData)) {
+	else if (
-      return processArrayOfTasks(taskOrData);
+		typeof taskOrData === 'object' &&
-  }
+		taskOrData !== null &&
+		'id' in taskOrData &&
+		'title' in taskOrData
+	) {
+		return processSingleTask(taskOrData);
+	}
+	// Check if the input is an array of tasks directly (less common but possible)
+	else if (Array.isArray(taskOrData)) {
+		return processArrayOfTasks(taskOrData);
+	}
 
-  // If it doesn't match known task structures, return it as is
+	// If it doesn't match known task structures, return it as is
-  return taskOrData; 
+	return taskOrData;
 }
 
 /**
@@ -378,19 +419,20 @@ function processMCPResponseData(taskOrData, fieldsToRemove = ['details', 'testSt
  * @returns {Object} - Content response object in FastMCP format
  */
 function createContentResponse(content) {
-  // FastMCP requires text type, so we format objects as JSON strings
+	// FastMCP requires text type, so we format objects as JSON strings
-  return {
+	return {
-    content: [
+		content: [
-      {
+			{
-        type: "text", 
+				type: 'text',
-        text: typeof content === 'object' ? 
+				text:
-          // Format JSON nicely with indentation
+					typeof content === 'object'
-          JSON.stringify(content, null, 2) : 
+						? // Format JSON nicely with indentation
-          // Keep other content types as-is
+							JSON.stringify(content, null, 2)
-          String(content)
+						: // Keep other content types as-is
-      }
+							String(content)
-    ]
+			}
-  };
+		]
+	};
 }
 
 /**
@@ -399,24 +441,24 @@ function createContentResponse(content) {
  * @returns {Object} - Error content response object in FastMCP format
  */
 export function createErrorResponse(errorMessage) {
-  return {
+	return {
-    content: [
+		content: [
-      {
+			{
-        type: "text",
+				type: 'text',
-        text: `Error: ${errorMessage}`
+				text: `Error: ${errorMessage}`
-      }
+			}
-    ],
+		],
-    isError: true
+		isError: true
-  };
+	};
 }
 
 // Ensure all functions are exported
 export {
-  getProjectRoot,
+	getProjectRoot,
-  getProjectRootFromSession,
+	getProjectRootFromSession,
-  handleApiResult,
+	handleApiResult,
-  executeTaskMasterCommand,
+	executeTaskMasterCommand,
-  getCachedOrExecute,
+	getCachedOrExecute,
-  processMCPResponseData,
+	processMCPResponseData,
-  createContentResponse,
+	createContentResponse
 };

mcp-server/src/tools/validate-dependencies.js

@@ -3,56 +3,68 @@
  * Tool for validating task dependencies
  */
 
-import { z } from "zod";
+import { z } from 'zod';
 import {
-  handleApiResult,
+	handleApiResult,
-  createErrorResponse,
+	createErrorResponse,
-  getProjectRootFromSession
+	getProjectRootFromSession
-} from "./utils.js";
+} from './utils.js';
-import { validateDependenciesDirect } from "../core/task-master-core.js";
+import { validateDependenciesDirect } from '../core/task-master-core.js';
 
 /**
  * Register the validateDependencies tool with the MCP server
  * @param {Object} server - FastMCP server instance
  */
 export function registerValidateDependenciesTool(server) {
-  server.addTool({
+	server.addTool({
-    name: "validate_dependencies",
+		name: 'validate_dependencies',
-    description: "Check tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.",
+		description:
-    parameters: z.object({
+			'Check tasks for dependency issues (like circular references or links to non-existent tasks) without making changes.',
-      file: z.string().optional().describe("Path to the tasks file"),
+		parameters: z.object({
-      projectRoot: z.string().optional().describe("Root directory of the project (default: current working directory)")
+			file: z.string().optional().describe('Absolute path to the tasks file'),
-    }),
+			projectRoot: z
-    execute: async (args, { log, session, reportProgress }) => {
+				.string()
-      try {
+				.optional()
-        log.info(`Validating dependencies with args: ${JSON.stringify(args)}`);
+				.describe(
-        await reportProgress({ progress: 0 });
+					'Root directory of the project (default: current working directory)'
+				)
+		}),
+		execute: async (args, { log, session, reportProgress }) => {
+			try {
+				log.info(`Validating dependencies with args: ${JSON.stringify(args)}`);
+				await reportProgress({ progress: 0 });
 
-        let rootFolder = getProjectRootFromSession(session, log);
+				let rootFolder = getProjectRootFromSession(session, log);
 
-        if (!rootFolder && args.projectRoot) {
+				if (!rootFolder && args.projectRoot) {
-          rootFolder = args.projectRoot;
+					rootFolder = args.projectRoot;
-          log.info(`Using project root from args as fallback: ${rootFolder}`);
+					log.info(`Using project root from args as fallback: ${rootFolder}`);
-        }
+				}
 
-        const result = await validateDependenciesDirect({
+				const result = await validateDependenciesDirect(
-          projectRoot: rootFolder,
+					{
-          ...args
+						projectRoot: rootFolder,
-        }, log, { reportProgress, mcpLog: log, session});
+						...args
+					},
+					log,
+					{ reportProgress, mcpLog: log, session }
+				);
 
-        await reportProgress({ progress: 100 });
+				await reportProgress({ progress: 100 });
 
-        if (result.success) {
+				if (result.success) {
-          log.info(`Successfully validated dependencies: ${result.data.message}`);
+					log.info(
-        } else {
+						`Successfully validated dependencies: ${result.data.message}`
-          log.error(`Failed to validate dependencies: ${result.error.message}`);
+					);
-        }
+				} else {
+					log.error(`Failed to validate dependencies: ${result.error.message}`);
+				}
 
-        return handleApiResult(result, log, 'Error validating dependencies');
+				return handleApiResult(result, log, 'Error validating dependencies');
-      } catch (error) {
+			} catch (error) {
-        log.error(`Error in validateDependencies tool: ${error.message}`);
+				log.error(`Error in validateDependencies tool: ${error.message}`);
-        return createErrorResponse(error.message);
+				return createErrorResponse(error.message);
-      }
+			}
-    },
+		}
-  });
+	});
 }

mcp-test.js

@@ -8,64 +8,68 @@ import fs from 'fs';
 console.error(`Current working directory: ${process.cwd()}`);
 
 try {
-  console.error('Attempting to load FastMCP Config...');
+	console.error('Attempting to load FastMCP Config...');
 
-  // Check if .cursor/mcp.json exists
+	// Check if .cursor/mcp.json exists
-  const mcpPath = path.join(process.cwd(), '.cursor', 'mcp.json');
+	const mcpPath = path.join(process.cwd(), '.cursor', 'mcp.json');
-  console.error(`Checking if mcp.json exists at: ${mcpPath}`);
+	console.error(`Checking if mcp.json exists at: ${mcpPath}`);
 
-  if (fs.existsSync(mcpPath)) {
+	if (fs.existsSync(mcpPath)) {
-    console.error('mcp.json file found');
+		console.error('mcp.json file found');
-    console.error(`File content: ${JSON.stringify(JSON.parse(fs.readFileSync(mcpPath, 'utf8')), null, 2)}`);
+		console.error(
-  } else {
+			`File content: ${JSON.stringify(JSON.parse(fs.readFileSync(mcpPath, 'utf8')), null, 2)}`
-    console.error('mcp.json file not found');
+		);
-  }
+	} else {
+		console.error('mcp.json file not found');
+	}
 
-  // Try to create Config
+	// Try to create Config
-  const config = new Config();
+	const config = new Config();
-  console.error('Config created successfully');
+	console.error('Config created successfully');
 
-  // Check if env property exists
+	// Check if env property exists
-  if (config.env) {
+	if (config.env) {
-    console.error(`Config.env exists with keys: ${Object.keys(config.env).join(', ')}`);
+		console.error(
+			`Config.env exists with keys: ${Object.keys(config.env).join(', ')}`
+		);
 
-    // Print each env var value (careful with sensitive values)
+		// Print each env var value (careful with sensitive values)
-    for (const [key, value] of Object.entries(config.env)) {
+		for (const [key, value] of Object.entries(config.env)) {
-      if (key.includes('KEY')) {
+			if (key.includes('KEY')) {
-        console.error(`${key}: [value hidden]`);
+				console.error(`${key}: [value hidden]`);
-      } else {
+			} else {
-        console.error(`${key}: ${value}`);
+				console.error(`${key}: ${value}`);
-      }
+			}
-    }
+		}
-  } else {
+	} else {
-    console.error('Config.env does not exist');
+		console.error('Config.env does not exist');
-  }
+	}
 } catch (error) {
-  console.error(`Error loading Config: ${error.message}`);
+	console.error(`Error loading Config: ${error.message}`);
-  console.error(`Stack trace: ${error.stack}`);
+	console.error(`Stack trace: ${error.stack}`);
 }
 
 // Log process.env to see if values from mcp.json were loaded automatically
 console.error('\nChecking if process.env already has values from mcp.json:');
 const envVars = [
-  'ANTHROPIC_API_KEY',
+	'ANTHROPIC_API_KEY',
-  'PERPLEXITY_API_KEY',
+	'PERPLEXITY_API_KEY',
-  'MODEL',
+	'MODEL',
-  'PERPLEXITY_MODEL',
+	'PERPLEXITY_MODEL',
-  'MAX_TOKENS',
+	'MAX_TOKENS',
-  'TEMPERATURE',
+	'TEMPERATURE',
-  'DEFAULT_SUBTASKS',
+	'DEFAULT_SUBTASKS',
-  'DEFAULT_PRIORITY'
+	'DEFAULT_PRIORITY'
 ];
 
 for (const varName of envVars) {
-  if (process.env[varName]) {
+	if (process.env[varName]) {
-    if (varName.includes('KEY')) {
+		if (varName.includes('KEY')) {
-      console.error(`${varName}: [value hidden]`);
+			console.error(`${varName}: [value hidden]`);
-    } else {
+		} else {
-      console.error(`${varName}: ${process.env[varName]}`);
+			console.error(`${varName}: ${process.env[varName]}`);
-    }
+		}
-  } else {
+	} else {
-    console.error(`${varName}: not set`);
+		console.error(`${varName}: not set`);
-  }
+	}
 }

output.json

@@ -1,6 +1,6 @@
 {
-  "key": "value",
+	"key": "value",
-  "nested": {
+	"nested": {
-    "prop": true
+		"prop": true
-  }
+	}
 }

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "task-master-ai",
-  "version": "0.10.0",
+  "version": "0.10.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "task-master-ai",
-      "version": "0.10.0",
+      "version": "0.10.1",
       "license": "MIT WITH Commons-Clause",
       "dependencies": {
         "@anthropic-ai/sdk": "^0.39.0",
@@ -31,9 +31,7 @@
       },
       "bin": {
         "task-master": "bin/task-master.js",
-        "task-master-init": "bin/task-master-init.js",
+        "task-master-mcp": "mcp-server/server.js"
-        "task-master-mcp": "mcp-server/server.js",
-        "task-master-mcp-server": "mcp-server/server.js"
       },
       "devDependencies": {
         "@changesets/changelog-github": "^0.5.1",
@@ -42,6 +40,7 @@
         "jest": "^29.7.0",
         "jest-environment-node": "^29.7.0",
         "mock-fs": "^5.5.0",
+        "prettier": "^3.5.3",
         "supertest": "^7.1.0"
       },
       "engines": {
@@ -608,6 +607,22 @@
         "semver": "^7.5.3"
       }
     },
+    "node_modules/@changesets/apply-release-plan/node_modules/prettier": {
+      "version": "2.8.8",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin-prettier.js"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
     "node_modules/@changesets/apply-release-plan/node_modules/semver": {
       "version": "7.7.1",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.1.tgz",
@@ -930,6 +945,22 @@
         "prettier": "^2.7.1"
       }
     },
+    "node_modules/@changesets/write/node_modules/prettier": {
+      "version": "2.8.8",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin-prettier.js"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
+      }
+    },
     "node_modules/@colors/colors": {
       "version": "1.5.0",
       "resolved": "https://registry.npmjs.org/@colors/colors/-/colors-1.5.0.tgz",
@@ -6622,16 +6653,16 @@
       }
     },
     "node_modules/prettier": {
-      "version": "2.8.8",
+      "version": "3.5.3",
-      "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.5.3.tgz",
-      "integrity": "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==",
+      "integrity": "sha512-QQtaxnoDJeAkDvDKWCLiwIXkTgRhwYDEQCghU9Z6q03iyek/rxRh/2lC3HB7P8sWT2xC/y5JDctPLBIGzHKbhw==",
       "dev": true,
       "license": "MIT",
       "bin": {
-        "prettier": "bin-prettier.js"
+        "prettier": "bin/prettier.cjs"
       },
       "engines": {
-        "node": ">=10.13.0"
+        "node": ">=14"
       },
       "funding": {
         "url": "https://github.com/prettier/prettier?sponsor=1"

package.json

@@ -1,96 +1,97 @@
 {
-  "name": "task-master-ai",
+	"name": "task-master-ai",
-  "version": "0.10.1",
+	"version": "0.10.1",
-  "description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
+	"description": "A task management system for ambitious AI-driven development that doesn't overwhelm and confuse Cursor.",
-  "main": "index.js",
+	"main": "index.js",
-  "type": "module",
+	"type": "module",
-  "bin": {
+	"bin": {
-    "task-master": "bin/task-master.js",
+		"task-master": "bin/task-master.js",
-    "task-master-init": "bin/task-master-init.js",
+		"task-master-mcp": "mcp-server/server.js"
-    "task-master-mcp": "mcp-server/server.js",
+	},
-    "task-master-mcp-server": "mcp-server/server.js"
+	"scripts": {
-  },
+		"test": "node --experimental-vm-modules node_modules/.bin/jest",
-  "scripts": {
+		"test:fails": "node --experimental-vm-modules node_modules/.bin/jest --onlyFailures",
-    "test": "node --experimental-vm-modules node_modules/.bin/jest",
+		"test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
-    "test:fails": "node --experimental-vm-modules node_modules/.bin/jest --onlyFailures",
+		"test:coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
-    "test:watch": "node --experimental-vm-modules node_modules/.bin/jest --watch",
+		"prepare-package": "node scripts/prepare-package.js",
-    "test:coverage": "node --experimental-vm-modules node_modules/.bin/jest --coverage",
+		"prepublishOnly": "npm run prepare-package",
-    "prepare-package": "node scripts/prepare-package.js",
+		"prepare": "chmod +x bin/task-master.js mcp-server/server.js",
-    "prepublishOnly": "npm run prepare-package",
+		"changeset": "changeset",
-    "prepare": "chmod +x bin/task-master.js bin/task-master-init.js mcp-server/server.js",
+		"release": "changeset publish",
-    "changeset": "changeset",
+		"inspector": "npx @modelcontextprotocol/inspector node mcp-server/server.js",
-    "release": "changeset publish",
+		"mcp-server": "node mcp-server/server.js",
-    "inspector": "CLIENT_PORT=8888 SERVER_PORT=9000 npx @modelcontextprotocol/inspector node mcp-server/server.js",
+		"format-check": "prettier --check .",
-    "mcp-server": "node mcp-server/server.js"
+		"format": "prettier --write ."
-  },
+	},
-  "keywords": [
+	"keywords": [
-    "claude",
+		"claude",
-    "task",
+		"task",
-    "management",
+		"management",
-    "ai",
+		"ai",
-    "development",
+		"development",
-    "cursor",
+		"cursor",
-    "anthropic",
+		"anthropic",
-    "llm",
+		"llm",
-    "mcp",
+		"mcp",
-    "context"
+		"context"
-  ],
+	],
-  "author": "Eyal Toledano",
+	"author": "Eyal Toledano",
-  "license": "MIT WITH Commons-Clause",
+	"license": "MIT WITH Commons-Clause",
-  "dependencies": {
+	"dependencies": {
-    "@anthropic-ai/sdk": "^0.39.0",
+		"@anthropic-ai/sdk": "^0.39.0",
-    "boxen": "^8.0.1",
+		"boxen": "^8.0.1",
-    "chalk": "^4.1.2",
+		"chalk": "^4.1.2",
-    "cli-table3": "^0.6.5",
+		"cli-table3": "^0.6.5",
-    "commander": "^11.1.0",
+		"commander": "^11.1.0",
-    "cors": "^2.8.5",
+		"cors": "^2.8.5",
-    "dotenv": "^16.3.1",
+		"dotenv": "^16.3.1",
-    "express": "^4.21.2",
+		"express": "^4.21.2",
-    "fastmcp": "^1.20.5",
+		"fastmcp": "^1.20.5",
-    "figlet": "^1.8.0",
+		"figlet": "^1.8.0",
-    "fuse.js": "^7.0.0",
+		"fuse.js": "^7.0.0",
-    "gradient-string": "^3.0.0",
+		"gradient-string": "^3.0.0",
-    "helmet": "^8.1.0",
+		"helmet": "^8.1.0",
-    "inquirer": "^12.5.0",
+		"inquirer": "^12.5.0",
-    "jsonwebtoken": "^9.0.2",
+		"jsonwebtoken": "^9.0.2",
-    "lru-cache": "^10.2.0",
+		"lru-cache": "^10.2.0",
-    "openai": "^4.89.0",
+		"openai": "^4.89.0",
-    "ora": "^8.2.0",
+		"ora": "^8.2.0",
-    "uuid": "^11.1.0"
+		"uuid": "^11.1.0"
-  },
+	},
-  "engines": {
+	"engines": {
-    "node": ">=14.0.0"
+		"node": ">=14.0.0"
-  },
+	},
-  "repository": {
+	"repository": {
-    "type": "git",
+		"type": "git",
-    "url": "git+https://github.com/eyaltoledano/claude-task-master.git"
+		"url": "git+https://github.com/eyaltoledano/claude-task-master.git"
-  },
+	},
-  "homepage": "https://github.com/eyaltoledano/claude-task-master#readme",
+	"homepage": "https://github.com/eyaltoledano/claude-task-master#readme",
-  "bugs": {
+	"bugs": {
-    "url": "https://github.com/eyaltoledano/claude-task-master/issues"
+		"url": "https://github.com/eyaltoledano/claude-task-master/issues"
-  },
+	},
-  "files": [
+	"files": [
-    "scripts/init.js",
+		"scripts/init.js",
-    "scripts/dev.js",
+		"scripts/dev.js",
-    "scripts/modules/**",
+		"scripts/modules/**",
-    "assets/**",
+		"assets/**",
-    ".cursor/**",
+		".cursor/**",
-    "README-task-master.md",
+		"README-task-master.md",
-    "index.js",
+		"index.js",
-    "bin/**",
+		"bin/**",
-    "mcp-server/**"
+		"mcp-server/**"
-  ],
+	],
-  "overrides": {
+	"overrides": {
-    "node-fetch": "^3.3.2",
+		"node-fetch": "^3.3.2",
-    "whatwg-url": "^11.0.0"
+		"whatwg-url": "^11.0.0"
-  },
+	},
-  "devDependencies": {
+	"devDependencies": {
-    "@changesets/changelog-github": "^0.5.1",
+		"@changesets/changelog-github": "^0.5.1",
-    "@changesets/cli": "^2.28.1",
+		"@changesets/cli": "^2.28.1",
-    "@types/jest": "^29.5.14",
+		"@types/jest": "^29.5.14",
-    "jest": "^29.7.0",
+		"jest": "^29.7.0",
-    "jest-environment-node": "^29.7.0",
+		"jest-environment-node": "^29.7.0",
-    "mock-fs": "^5.5.0",
+		"mock-fs": "^5.5.0",
-    "supertest": "^7.1.0"
+		"prettier": "^3.5.3",
-  }
+		"supertest": "^7.1.0"
+	}
 }

scripts/README.md

@@ -21,9 +21,11 @@ In an AI-driven development process—particularly with tools like [Cursor](http
 The script can be configured through environment variables in a `.env` file at the root of the project:
 
 ### Required Configuration
+
 - `ANTHROPIC_API_KEY`: Your Anthropic API key for Claude
 
 ### Optional Configuration
+
 - `MODEL`: Specify which Claude model to use (default: "claude-3-7-sonnet-20250219")
 - `MAX_TOKENS`: Maximum tokens for model responses (default: 4000)
 - `TEMPERATURE`: Temperature for model responses (default: 0.7)
@@ -39,6 +41,7 @@ The script can be configured through environment variables in a `.env` file at t
 ## How It Works
 
 1. **`tasks.json`**:
+
    - A JSON file at the project root containing an array of tasks (each with `id`, `title`, `description`, `status`, etc.).
    - The `meta` field can store additional info like the project's name, version, or reference to the PRD.
    - Tasks can have `subtasks` for more detailed implementation steps.
@@ -102,6 +105,7 @@ node scripts/dev.js update --file=custom-tasks.json --from=5 --prompt="Change da
 ```
 
 Notes:
+
 - The `--prompt` parameter is required and should explain the changes or new context
 - Only tasks that aren't marked as 'done' will be updated
 - Tasks with ID >= the specified --from value will be updated
@@ -120,6 +124,7 @@ node scripts/dev.js update-task --id=4 --prompt="Use JWT for authentication" --r
 ```
 
 This command:
+
 - Updates only the specified task rather than a range of tasks
 - Provides detailed validation with helpful error messages
 - Checks for required API keys when using research mode
@@ -146,6 +151,7 @@ node scripts/dev.js set-status --id=1,2,3 --status=done
 ```
 
 Notes:
+
 - When marking a parent task as "done", all of its subtasks will automatically be marked as "done" as well
 - Common status values are 'done', 'pending', and 'deferred', but any string is accepted
 - You can specify multiple task IDs by separating them with commas
@@ -195,6 +201,7 @@ node scripts/dev.js clear-subtasks --all
 ```
 
 Notes:
+
 - After clearing subtasks, task files are automatically regenerated
 - This is useful when you want to regenerate subtasks with a different approach
 - Can be combined with the `expand` command to immediately generate new subtasks
@@ -210,6 +217,7 @@ The script integrates with two AI services:
 The Perplexity integration uses the OpenAI client to connect to Perplexity's API, which provides enhanced research capabilities for generating more informed subtasks. If the Perplexity API is unavailable or encounters an error, the script will automatically fall back to using Anthropic's Claude.
 
 To use the Perplexity integration:
+
 1. Obtain a Perplexity API key
 2. Add `PERPLEXITY_API_KEY` to your `.env` file
 3. Optionally specify `PERPLEXITY_MODEL` in your `.env` file (default: "sonar-medium-online")
@@ -218,6 +226,7 @@ To use the Perplexity integration:
 ## Logging
 
 The script supports different logging levels controlled by the `LOG_LEVEL` environment variable:
+
 - `debug`: Detailed information, typically useful for troubleshooting
 - `info`: Confirmation that things are working as expected (default)
 - `warn`: Warning messages that don't prevent execution
@@ -240,17 +249,20 @@ node scripts/dev.js remove-dependency --id=<id> --depends-on=<id>
 These commands:
 
 1. **Allow precise dependency management**:
+
    - Add dependencies between tasks with automatic validation
    - Remove dependencies when they're no longer needed
    - Update task files automatically after changes
 
 2. **Include validation checks**:
+
    - Prevent circular dependencies (a task depending on itself)
    - Prevent duplicate dependencies
    - Verify that both tasks exist before adding/removing dependencies
    - Check if dependencies exist before attempting to remove them
 
 3. **Provide clear feedback**:
+
    - Success messages confirm when dependencies are added/removed
    - Error messages explain why operations failed (if applicable)
 
@@ -275,6 +287,7 @@ node scripts/dev.js validate-dependencies --file=custom-tasks.json
 ```
 
 This command:
+
 - Scans all tasks and subtasks for non-existent dependencies
 - Identifies potential self-dependencies (tasks referencing themselves)
 - Reports all found issues without modifying files
@@ -296,6 +309,7 @@ node scripts/dev.js fix-dependencies --file=custom-tasks.json
 ```
 
 This command:
+
 1. **Validates all dependencies** across tasks and subtasks
 2. **Automatically removes**:
    - References to non-existent tasks and subtasks
@@ -333,6 +347,7 @@ node scripts/dev.js analyze-complexity --research
 ```
 
 Notes:
+
 - The command uses Claude to analyze each task's complexity (or Perplexity with --research flag)
 - Tasks are scored on a scale of 1-10
 - Each task receives a recommended number of subtasks based on DEFAULT_SUBTASKS configuration
@@ -357,33 +372,35 @@ node scripts/dev.js expand --id=8 --num=5 --prompt="Custom prompt"
 ```
 
 When a complexity report exists:
+
 - The `expand` command will use the recommended subtask count from the report (unless overridden)
 - It will use the tailored expansion prompt from the report (unless a custom prompt is provided)
 - When using `--all`, tasks are sorted by complexity score (highest first)
 - The `--research` flag is preserved from the complexity analysis to expansion
 
 The output report structure is:
+
 ```json
 {
-  "meta": {
+	"meta": {
-    "generatedAt": "2023-06-15T12:34:56.789Z",
+		"generatedAt": "2023-06-15T12:34:56.789Z",
-    "tasksAnalyzed": 20,
+		"tasksAnalyzed": 20,
-    "thresholdScore": 5,
+		"thresholdScore": 5,
-    "projectName": "Your Project Name",
+		"projectName": "Your Project Name",
-    "usedResearch": true
+		"usedResearch": true
-  },
+	},
-  "complexityAnalysis": [
+	"complexityAnalysis": [
-    {
+		{
-      "taskId": 8,
+			"taskId": 8,
-      "taskTitle": "Develop Implementation Drift Handling",
+			"taskTitle": "Develop Implementation Drift Handling",
-      "complexityScore": 9.5,
+			"complexityScore": 9.5,
-      "recommendedSubtasks": 6,
+			"recommendedSubtasks": 6,
-      "expansionPrompt": "Create subtasks that handle detecting...",
+			"expansionPrompt": "Create subtasks that handle detecting...",
-      "reasoning": "This task requires sophisticated logic...",
+			"reasoning": "This task requires sophisticated logic...",
-      "expansionCommand": "node scripts/dev.js expand --id=8 --num=6 --prompt=\"Create subtasks...\" --research"
+			"expansionCommand": "node scripts/dev.js expand --id=8 --num=6 --prompt=\"Create subtasks...\" --research"
-    },
+		}
-    // More tasks sorted by complexity score (highest first)
+		// More tasks sorted by complexity score (highest first)
-  ]
+	]
 }
 ```
 
@@ -457,16 +474,19 @@ This command is particularly useful when you need to examine a specific task in
 The script now includes improved error handling throughout all commands:
 
 1. **Detailed Validation**:
+
    - Required parameters (like task IDs and prompts) are validated early
    - File existence is checked with customized errors for common scenarios
    - Parameter type conversion is handled with clear error messages
 
 2. **Contextual Error Messages**:
+
    - Task not found errors include suggestions to run the list command
    - API key errors include reminders to check environment variables
    - Invalid ID format errors show the expected format
 
 3. **Command-Specific Help Displays**:
+
    - When validation fails, detailed help for the specific command is shown
    - Help displays include usage examples and parameter descriptions
    - Formatted in clear, color-coded boxes with examples
@@ -481,11 +501,13 @@ The script now includes improved error handling throughout all commands:
 The script now automatically checks for updates without slowing down execution:
 
 1. **Background Version Checking**:
+
    - Non-blocking version checks run in the background while commands execute
    - Actual command execution isn't delayed by version checking
    - Update notifications appear after command completion
 
 2. **Update Notifications**:
+
    - When a newer version is available, a notification is displayed
    - Notifications include current version, latest version, and update command
    - Formatted in an attention-grabbing box with clear instructions
@@ -516,6 +538,7 @@ node scripts/dev.js add-subtask --parent=5 --title="Login API route" --skip-gene
 ```
 
 Key features:
+
 - Create new subtasks with detailed properties or convert existing tasks
 - Define dependencies between subtasks
 - Set custom status for new subtasks
@@ -538,6 +561,7 @@ node scripts/dev.js remove-subtask --id=5.2 --skip-generate
 ```
 
 Key features:
+
 - Remove subtasks individually or in batches
 - Optionally convert subtasks to standalone tasks
 - Control whether task files are regenerated

scripts/dev.js

@@ -10,7 +10,7 @@
 
 // Add at the very beginning of the file
 if (process.env.DEBUG === '1') {
-  console.error('DEBUG - dev.js received args:', process.argv.slice(2));
+	console.error('DEBUG - dev.js received args:', process.argv.slice(2));
 }
 
 import { runCLI } from './modules/commands.js';