Move file reading out of client and into TaskManager

Author: chriscarrollsmith

README.md

@@ -30,7 +30,7 @@ Usually you will set the tool configuration in Claude Desktop, Cursor, or anothe
 To use the CLI utility, you can use the following command:
 
 ```bash
-npx task-manager-cli --help
+npx taskqueue --help
 ```
 
 This will show the available commands and options.
@@ -134,7 +134,7 @@ A typical workflow for an LLM using this task manager would be:
 Task approval is controlled exclusively by the human user through the CLI command:
 
 ```bash
-npx task-manager-cli approve-task -- <projectId> <taskId>
+npx taskqueue approve-task -- <projectId> <taskId>
 ```
 
 Options:
@@ -147,13 +147,13 @@ Note: Tasks must be marked as "done" with completed details before they can be a
 The CLI provides a command to list all projects and tasks:
 
 ```bash
-npx task-manager-cli list-tasks
+npx taskqueue list-tasks
 ```
 
 To view details of a specific project:
 
 ```bash
-npx task-manager-cli list-tasks -- -p <projectId>
+npx taskqueue list-tasks -- -p <projectId>
 ```
 
 This command displays information about all projects in the system or a specific project, including:

package-lock.json

@@ -7,7 +7,7 @@
 	"type": "module",
 	"bin": {
 		"taskqueue-mcp": "dist/index.js",
-		"task-manager-cli": "dist/src/client/index.js"
+		"taskqueue": "dist/src/client/index.js"
 	},
 	"files": [
 		"dist/index.js",

package.json

@@ -14,7 +14,7 @@ import fs from "fs/promises";
 const program = new Command();
 
 program
-  .name("task-manager-cli")
+  .name("taskqueue")
   .description("CLI for the Task Manager MCP Server")
   .version("1.2.0")
   .option(
@@ -151,7 +151,7 @@ program
 
       if (completedTasks === totalTasks && approvedTasks === totalTasks) {
         console.log(chalk.green('\n🎉 All tasks are completed and approved!'));
-        console.log(chalk.blue(`The project can now be finalized using: task-manager-cli finalize ${projectId}`));
+        console.log(chalk.blue(`The project can now be finalized using: taskqueue finalize ${projectId}`));
       } else {
         if (totalTasks - completedTasks > 0) {
           console.log(chalk.yellow(`\n${totalTasks - completedTasks} tasks remaining to be completed.`));
@@ -281,7 +281,7 @@ program
 
       console.log(chalk.green('\n🎉 Project successfully completed and approved!'));
       console.log(chalk.gray('You can view the project details anytime using:'));
-      console.log(chalk.blue(`  task-manager-cli list -p ${projectId}`));
+      console.log(chalk.blue(`  taskqueue list -p ${projectId}`));
 
     } catch (error) {
       const normalized = normalizeError(error);
@@ -490,27 +490,12 @@ program
     try {
       console.log(chalk.blue(`Generating project plan from prompt...`));
 
-      // Read attachment files if provided
-      const attachments: string[] = [];
-      for (const file of options.attachment) {
-        try {
-          const content = await fs.readFile(file, 'utf-8');
-          attachments.push(content);
-        } catch (error: unknown) {
-          if (error instanceof Error) {
-            console.error(chalk.yellow(`Warning: Could not read attachment file ${chalk.bold(file)}: ${error.message}`));
-          } else {
-            console.error(chalk.yellow(`Warning: Could not read attachment file ${chalk.bold(file)}: Unknown error`));
-          }
-        }
-      }
-
-      // Call the generateProjectPlan method
+      // Pass attachment filenames directly to the server
       const response = await taskManager.generateProjectPlan({
         prompt: options.prompt,
         provider: options.provider,
         model: options.model,
-        attachments,
+        attachments: options.attachment  // Pass the filenames directly
       });
 
       if ('error' in response) {

src/client/cli.ts

@@ -1,5 +1,5 @@
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { TaskManagerFile, ErrorCode } from "../types/index.js";
 import { createError } from "../utils/errors.js";
@@ -176,4 +176,30 @@ export class FileSystemService {
       }
     });
   }
+
+  /**
+   * Reads an attachment file from the current working directory
+   * @param filename The name of the file to read (relative to cwd)
+   * @returns The contents of the file as a string
+   * @throws {StandardError} If the file cannot be read
+   */
+  public async readAttachmentFile(filename: string): Promise<string> {
+    try {
+      const filePath = resolve(process.cwd(), filename);
+      return await readFile(filePath, 'utf-8');
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('ENOENT')) {
+        throw createError(
+          ErrorCode.FileReadError,
+          `Attachment file not found: ${filename}`,
+          { originalError: error }
+        );
+      }
+      throw createError(
+        ErrorCode.FileReadError,
+        `Failed to read attachment file: ${filename}`,
+        { originalError: error }
+      );
+    }
+  }
 } 

src/server/FileSystemService.ts

@@ -132,10 +132,22 @@ export class TaskManager {
   }): Promise<StandardResponse<ProjectCreationSuccessData>> {
     await this.ensureInitialized();
 
+    // Read all attachment files
+    const attachmentContents: string[] = [];
+    for (const filename of attachments) {
+      try {
+        const content = await this.fileSystemService.readAttachmentFile(filename);
+        attachmentContents.push(content);
+      } catch (error) {
+        // Propagate file read errors
+        throw error;
+      }
+    }
+
     // Wrap prompt and attachments in XML tags
     let llmPrompt = `<prompt>${prompt}</prompt>`;
-    for (const att of attachments) {
-      llmPrompt += `\n<attachment>${att}</attachment>`;
+    for (const content of attachmentContents) {
+      llmPrompt += `\n<attachment>${content}</attachment>`;
     }
 
     // Import and configure the appropriate provider

src/server/TaskManager.ts

@@ -12,7 +12,7 @@ describe("CLI Integration Tests", () => {
   let tasksFilePath: string;
 
   beforeEach(async () => {
-    tempDir = path.join(os.tmpdir(), `task-manager-cli-test-${Date.now()}`);
+    tempDir = path.join(os.tmpdir(), `taskqueue-test-${Date.now()}`);
     await fs.mkdir(tempDir, { recursive: true });
     tasksFilePath = path.join(tempDir, "test-tasks.json");
     process.env.TASK_MANAGER_FILE_PATH = tasksFilePath;
@@ -196,7 +196,7 @@ describe("CLI Integration Tests", () => {
       const { stderr } = await execAsync(
         `TASK_MANAGER_FILE_PATH=${tasksFilePath} tsx ${CLI_PATH} generate-plan --prompt "Create app" --attachment nonexistent.txt`
       ).catch(error => error);
-      
+
       // Just verify we get a warning about the attachment
       expect(stderr).toContain("Warning:");
       expect(stderr).toContain("nonexistent.txt");

tests/integration/cli.integration.test.ts

@@ -5,6 +5,10 @@ import * as path from 'node:path';
 import * as os from 'node:os';
 import * as fs from 'node:fs/promises';
 import process from 'node:process';
+import dotenv from 'dotenv';
+
+// Load environment variables from .env file
+dotenv.config();
 
 interface ToolResponse {
   isError: boolean;
@@ -285,4 +289,60 @@ describe('MCP Client Integration', () => {
     expect(finalizeResult.isError).toBeFalsy();
     console.log('Project was successfully finalized after explicit task approval');
   });
+
+  // Skip by default as it requires OpenAI API key
+  it.skip('should generate a project plan using OpenAI', async () => {
+    console.log('Testing project plan generation...');
+    
+    // Skip if no OpenAI API key is set
+    const openaiApiKey = process.env.OPENAI_API_KEY;
+    if (!openaiApiKey) {
+      console.log('Skipping test: OPENAI_API_KEY not set');
+      return;
+    }
+
+    // Create a temporary requirements file
+    const requirementsPath = path.join(tempDir, 'requirements.md');
+    const requirements = `# TODO App Requirements
+
+- Use React for the frontend
+- Include add, delete, and mark complete functionality
+- Store todos in local storage
+- Add basic styling`;
+
+    await fs.writeFile(requirementsPath, requirements, 'utf-8');
+    console.log('Created temporary requirements file:', requirementsPath);
+
+    // Test prompt and context
+    const testPrompt = "Create a step-by-step project plan to build a simple TODO app with React";
+
+    // Generate project plan
+    const generateResult = await client.callTool({
+      name: "generate_project_plan",
+      arguments: {
+        prompt: testPrompt,
+        provider: "openai",
+        model: "gpt-4-turbo",
+        attachments: [requirementsPath]
+      }
+    }) as ToolResponse;
+
+    expect(generateResult.isError).toBeFalsy();
+    const planData = JSON.parse((generateResult.content[0] as { text: string }).text);
+    
+    // Verify the generated plan structure
+    expect(planData).toHaveProperty('data');
+    expect(planData.data).toHaveProperty('projectPlan');
+    expect(planData.data).toHaveProperty('tasks');
+    expect(Array.isArray(planData.data.tasks)).toBe(true);
+    expect(planData.data.tasks.length).toBeGreaterThan(0);
+
+    // Verify task structure
+    const firstTask = planData.data.tasks[0];
+    expect(firstTask).toHaveProperty('title');
+    expect(firstTask).toHaveProperty('description');
+    
+    // The temporary file will be cleaned up by the afterAll hook that removes tempDir
+    console.log('Successfully generated project plan with tasks');
+  });
 });