Support project-level approval from the CLI

Author: chriscarrollsmith

README.md

@@ -213,16 +213,18 @@ The TaskManager now uses a direct tools interface with specific, purpose-built t
 Tasks have a status field that can be one of:
 - `not started`: Task has not been started yet
 - `in progress`: Task is currently being worked on
-- `done`: Task has been completed
+- `done`: Task has been completed (requires `completedDetails`)
 
 #### Status Transition Rules
+
 The system enforces the following rules for task status transitions:
 - Tasks follow a specific workflow with defined valid transitions:
   - From `not started`: Can only move to `in progress`
   - From `in progress`: Can move to either `done` or back to `not started`
   - From `done`: Can move back to `in progress` if additional work is needed
-- When a task is marked as "done", the `completedDetails` field should be provided to document what was completed
+- When a task is marked as "done", the `completedDetails` field must be provided to document what was completed
 - Approved tasks cannot be modified
+- A project can only be approved when all tasks are both done and approved
 
 These rules help maintain the integrity of task progress and ensure proper documentation of completed work.
 
@@ -243,7 +245,7 @@ A typical workflow for an LLM using this task manager would be:
 
 #### Task Approval
 
-Task approval is controlled exclusively by the human user through a CLI command:
+Task approval is controlled exclusively by the human user through the CLI command:
 
 ```bash
 npm run approve-task -- <projectId> <taskId>
@@ -252,7 +254,7 @@ npm run approve-task -- <projectId> <taskId>
 Options:
 - `-f, --force`: Force approval even if the task is not marked as done
 
-This command sets the `approved` field of a task to `true` after verifying that the task is marked as `done`. Only the human user can approve tasks, ensuring quality control.
+Note: Tasks must be marked as "done" with completed details before they can be approved (unless using --force).
 
 #### Listing Tasks and Projects
 
@@ -342,7 +344,7 @@ const nextTaskResult = await toolManager.callFunction('get_next_task', {
 const markDoneResult = await toolManager.callFunction('mark_task_done', {
   projectId: "proj-1234",
   taskId: "task-1",
-  completedDetails: "Created repository at github.com/example/business-site and initialized with HTML5 boilerplate, CSS reset, and basic JS structure."
+  completedDetails: "Created repository at github.com/example/business-site and initialized with HTML5 boilerplate, CSS reset, and basic JS structure."  // Required when marking as done
 });
 
 // Response will include:

src/cli.ts

@@ -150,6 +150,92 @@ program
     }
   });
 
+program
+  .command("approve-project")
+  .description("Approve project completion")
+  .argument("<projectId>", "ID of the project to approve")
+  .action(async (projectId) => {
+    try {
+      console.log(chalk.blue(`Approving project ${chalk.bold(projectId)}...`));
+
+      const data = await readData();
+
+      // Check if we have any projects
+      if (data.projects.length === 0) {
+        console.error(chalk.red(`No projects found. The task file is empty or just initialized.`));
+        process.exit(1);
+      }
+
+      const project = data.projects.find(p => p.projectId === projectId);
+
+      if (!project) {
+        console.error(chalk.red(`Project ${chalk.bold(projectId)} not found.`));
+        console.log(chalk.yellow('Available projects:'));
+        data.projects.forEach(p => {
+          console.log(`  - ${p.projectId}: ${p.initialPrompt.substring(0, 50)}${p.initialPrompt.length > 50 ? '...' : ''}`);
+        });
+        process.exit(1);
+      }
+
+      // Check if all tasks are done & approved
+      const allDone = project.tasks.every(t => t.status === "done");
+      if (!allDone) {
+        console.error(chalk.red(`Not all tasks in project ${chalk.bold(projectId)} are marked as done.`));
+        console.log(chalk.yellow('\nPending tasks:'));
+        project.tasks.filter(t => t.status !== "done").forEach(t => {
+          console.log(`  - ${chalk.bold(t.id)}: ${t.title} (Status: ${t.status})`);
+        });
+        process.exit(1);
+      }
+
+      const allApproved = project.tasks.every(t => t.approved);
+      if (!allApproved) {
+        console.error(chalk.red(`Not all tasks in project ${chalk.bold(projectId)} are approved yet.`));
+        console.log(chalk.yellow('\nUnapproved tasks:'));
+        project.tasks.filter(t => !t.approved).forEach(t => {
+          console.log(`  - ${chalk.bold(t.id)}: ${t.title}`);
+        });
+        process.exit(1);
+      }
+
+      if (project.completed) {
+        console.log(chalk.yellow(`Project ${chalk.bold(projectId)} is already approved and completed.`));
+        process.exit(0);
+      }
+
+      project.completed = true;
+      await writeData(data);
+      console.log(chalk.green(`✅ Project ${chalk.bold(projectId)} has been approved and marked as complete.`));
+
+      // Show project info
+      console.log(chalk.cyan('\n📋 Project details:'));
+      console.log(`  - ${chalk.bold('Initial Prompt:')} ${project.initialPrompt}`);
+      if (project.projectPlan && project.projectPlan !== project.initialPrompt) {
+        console.log(`  - ${chalk.bold('Project Plan:')} ${project.projectPlan}`);
+      }
+      console.log(`  - ${chalk.bold('Status:')} ${chalk.green('Completed ✓')}`);
+
+      // Show progress info
+      const totalTasks = project.tasks.length;
+      const completedTasks = project.tasks.filter(t => t.status === "done").length;
+      const approvedTasks = project.tasks.filter(t => t.approved).length;
+      
+      console.log(chalk.cyan(`\n📊 Final Progress: ${chalk.bold(`${approvedTasks}/${completedTasks}/${totalTasks}`)} (approved/completed/total)`));
+      
+      // Create a progress bar
+      const bar = '▓'.repeat(approvedTasks) + '▒'.repeat(completedTasks - approvedTasks) + '░'.repeat(totalTasks - completedTasks);
+      console.log(`  ${bar}`);
+
+      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}`));
+
+    } catch (error) {
+      console.error(chalk.red(`An error occurred: ${error instanceof Error ? error.message : String(error)}`));
+      process.exit(1);
+    }
+  });
+
 program
   .command("list")
   .description("List all projects and their tasks")

src/server/TaskManagerServer.ts

@@ -267,6 +267,11 @@ export class TaskManagerServer {
     const proj = this.data.projects.find((p) => p.projectId === projectId);
     if (!proj) return { status: "error", message: "Project not found" };
 
+    // Check if project is already completed
+    if (proj.completed) {
+      return { status: "error", message: "Project is already completed." };
+    }
+
     // Check if all tasks are done and approved
     const allDone = proj.tasks.every((t) => t.status === "done");
     if (!allDone) {

src/types/tools.ts

@@ -32,7 +32,7 @@ const readProjectTool: Tool = {
 // Create Project
 const createProjectTool: Tool = {
   name: "create_project",
-  description: "Create a new project with an initial prompt and a list of tasks.",
+  description: "Create a new project with an initial prompt and a list of tasks. This is typically the first step in any workflow.",
   inputSchema: {
     type: "object",
     properties: {
@@ -120,7 +120,7 @@ const addTasksToProjectTool: Tool = {
 // Finalize Project (Mark as Complete)
 const finalizeProjectTool: Tool = {
   name: "finalize_project",
-  description: "Mark a project as complete after all tasks are done and approved.",
+  description: "Mark a project as complete. Can only be called when all tasks are both done and approved. This is typically the last step in a project workflow.",
   inputSchema: {
     type: "object",
     properties: {
@@ -199,7 +199,7 @@ const createTaskTool: Tool = {
 // Update Task
 const updateTaskTool: Tool = {
   name: "update_task",
-  description: "Modify a task's title, description, or status. Note: completedDetails are required when setting status to 'done'.",
+  description: "Modify a task's properties. Note: (1) completedDetails are required when setting status to 'done', (2) approved tasks cannot be modified, (3) status must follow valid transitions: not started → in progress → done.",
   inputSchema: {
     type: "object",
     properties: {
@@ -256,7 +256,7 @@ const deleteTaskTool: Tool = {
 // Approve Task
 const approveTaskTool: Tool = {
   name: "approve_task",
-  description: "Approve a completed task.",
+  description: "Approve a completed task. Tasks must be marked as 'done' with completedDetails before approval. Note: This is a CLI-only operation that requires human intervention.",
   inputSchema: {
     type: "object",
     properties: {
@@ -276,7 +276,7 @@ const approveTaskTool: Tool = {
 // Get Next Task
 const getNextTaskTool: Tool = {
   name: "get_next_task",
-  description: "Get the next task to be done in a project.",
+  description: "Get the next task to be done in a project. Returns the first non-approved task in sequence, regardless of status. Use this to determine which task to work on next.",
   inputSchema: {
     type: "object",
     properties: {

tests/integration/server.test.ts

@@ -302,4 +302,70 @@ describe('TaskManagerServer Integration', () => {
     const project = server["data"].projects.find(p => p.projectId === projectId);
     expect(project?.completed).toBe(true);
   });
+
+  it('should handle project approval workflow', async () => {
+    // 1. Create a project with multiple tasks
+    const createResult = await server.createProject(
+      'Project for approval workflow',
+      [
+        {
+          title: 'Task 1',
+          description: 'Description of task 1'
+        },
+        {
+          title: 'Task 2',
+          description: 'Description of task 2'
+        }
+      ]
+    ) as { 
+      projectId: string; 
+      tasks: { id: string }[];
+    };
+
+    const projectId = createResult.projectId;
+    const taskId1 = createResult.tasks[0].id;
+    const taskId2 = createResult.tasks[1].id;
+
+    // 2. Try to approve project before tasks are done (should fail)
+    const earlyApprovalResult = await server.approveProjectCompletion(projectId);
+    expect(earlyApprovalResult.status).toBe('error');
+    expect(earlyApprovalResult.message).toContain('Not all tasks are done');
+
+    // 3. Mark tasks as done
+    await server.markTaskDone(projectId, taskId1, 'Task 1 completed details');
+    await server.markTaskDone(projectId, taskId2, 'Task 2 completed details');
+
+    // 4. Try to approve project before tasks are approved (should fail)
+    const preApprovalResult = await server.approveProjectCompletion(projectId);
+    expect(preApprovalResult.status).toBe('error');
+    expect(preApprovalResult.message).toContain('Not all done tasks are approved');
+
+    // 5. Approve tasks
+    await server.approveTaskCompletion(projectId, taskId1);
+    await server.approveTaskCompletion(projectId, taskId2);
+
+    // 6. Now approve the project (should succeed)
+    const approvalResult = await server.approveProjectCompletion(projectId);
+    expect(approvalResult.status).toBe('project_approved_complete');
+
+    // 7. Verify project state
+    const project = server["data"].projects.find(p => p.projectId === projectId);
+    expect(project?.completed).toBe(true);
+    expect(project?.tasks.every(t => t.status === 'done')).toBe(true);
+    expect(project?.tasks.every(t => t.approved)).toBe(true);
+
+    // 8. Try to approve again (should fail)
+    const reapprovalResult = await server.approveProjectCompletion(projectId);
+    expect(reapprovalResult.status).toBe('error');
+    expect(reapprovalResult.message).toContain('Project is already completed');
+
+    // 9. Verify project is still listed
+    const listResult = await server.listProjects();
+    const listedProject = listResult.projects?.find(p => p.projectId === projectId);
+    expect(listedProject).toBeDefined();
+    expect(listedProject?.initialPrompt).toBe('Project for approval workflow');
+    expect(listedProject?.totalTasks).toBe(2);
+    expect(listedProject?.completedTasks).toBe(2);
+    expect(listedProject?.approvedTasks).toBe(2);
+  });
 }); 

tests/unit/TaskManagerServer.test.ts

@@ -327,4 +327,95 @@ describe('TaskManagerServer', () => {
       expect(task?.status).toBe('done');
     });
   });
+
+  describe('Project Approval', () => {
+    let projectId: string;
+    let taskId1: string;
+    let taskId2: string;
+    
+    beforeEach(async () => {
+      // Create a project with two tasks for each test in this group
+      const createResult = await server.createProject(
+        'Test project for approval',
+        [
+          {
+            title: 'Task 1',
+            description: 'Description for task 1'
+          },
+          {
+            title: 'Task 2',
+            description: 'Description for task 2'
+          }
+        ]
+      ) as { 
+        projectId: string; 
+        tasks: { id: string }[];
+      };
+      
+      projectId = createResult.projectId;
+      taskId1 = createResult.tasks[0].id;
+      taskId2 = createResult.tasks[1].id;
+    });
+    
+    it('should not approve project if tasks are not done', async () => {
+      const result = await server.approveProjectCompletion(projectId);
+      expect(result.status).toBe('error');
+      expect(result.message).toContain('Not all tasks are done');
+    });
+    
+    it('should not approve project if tasks are done but not approved', async () => {
+      // Mark both tasks as done
+      const task1 = server["data"].projects.find(p => p.projectId === projectId)?.tasks.find(t => t.id === taskId1);
+      const task2 = server["data"].projects.find(p => p.projectId === projectId)?.tasks.find(t => t.id === taskId2);
+      if (task1 && task2) {
+        task1.status = 'done';
+        task2.status = 'done';
+        await server["saveTasks"]();
+      }
+      
+      const result = await server.approveProjectCompletion(projectId);
+      expect(result.status).toBe('error');
+      expect(result.message).toContain('Not all done tasks are approved');
+    });
+    
+    it('should approve project when all tasks are done and approved', async () => {
+      // Mark both tasks as done and approved
+      const task1 = server["data"].projects.find(p => p.projectId === projectId)?.tasks.find(t => t.id === taskId1);
+      const task2 = server["data"].projects.find(p => p.projectId === projectId)?.tasks.find(t => t.id === taskId2);
+      if (task1 && task2) {
+        task1.status = 'done';
+        task2.status = 'done';
+        task1.approved = true;
+        task2.approved = true;
+        await server["saveTasks"]();
+      }
+      
+      const result = await server.approveProjectCompletion(projectId);
+      expect(result.status).toBe('project_approved_complete');
+      
+      // Verify project is marked as completed
+      const project = server["data"].projects.find(p => p.projectId === projectId);
+      expect(project?.completed).toBe(true);
+    });
+    
+    it('should not allow approving an already completed project', async () => {
+      // First approve the project
+      const task1 = server["data"].projects.find(p => p.projectId === projectId)?.tasks.find(t => t.id === taskId1);
+      const task2 = server["data"].projects.find(p => p.projectId === projectId)?.tasks.find(t => t.id === taskId2);
+      if (task1 && task2) {
+        task1.status = 'done';
+        task2.status = 'done';
+        task1.approved = true;
+        task2.approved = true;
+        await server["saveTasks"]();
+      }
+      
+      await server.approveProjectCompletion(projectId);
+      
+      // Try to approve again
+      const result = await server.approveProjectCompletion(projectId);
+      expect(result.status).toBe('error');
+      expect(result.message).toContain('Project is already completed');
+    });
+  });
 });