Merge pull request #4 from StuMason/feature/project-management

Feature/project management

Author: StuMason

.cursor/rules/801-feature-workflow.mdc

@@ -1,7 +1,6 @@
 ---
 description: FOLLOW feature development workflow WHEN implementing new features TO ensure consistent, tested, and documented changes
 globs: src/**/*.{ts,tsx}
-alwaysApply: false
 ---
 
 # Feature Development Workflow
@@ -15,41 +14,71 @@ alwaysApply: false
 - Start from up-to-date main branch
 - Create feature branch with descriptive name (feature/feature-name)
 - Locate and review feature documentation in docs/features directory
-- Follow documentation requirements systematically
-- Commit frequently to trigger pre-commit hooks (linting, formatting, tests)
-- Add comprehensive tests for new functionality
-- Push completed work to remote for PR review
+- Follow implementation in small, focused chunks:
+  1. Add types and interfaces first
+  2. Add client methods next
+  3. Add MCP server tools
+  4. Add tests for each component
+  5. Update documentation for completed items
+- Commit after EACH of these changes:
+  - New types/interfaces
+  - New client methods
+  - New MCP tools
+  - New tests
+  - Documentation updates
+  - Linting/formatting fixes
+- Push to remote after each significant commit to:
+  - Back up your work
+  - Enable early feedback
+  - Make PRs easier to review
+- Use conventional commit messages:
+  - feat: new feature
+  - fix: bug fix
+  - docs: documentation changes
+  - test: adding tests
+  - refactor: code changes that neither fix bugs nor add features
+  - style: formatting, missing semi colons, etc
+  - chore: updating build tasks, package manager configs, etc
 
 ## Examples
 <example>
 # Good workflow
 1. git checkout main && git pull
-2. git checkout -b feature/server-info
-3. Review docs/features/002-server-info-resource.md
-4. Implement ServerInfo interface
-5. Add getServerInfo method with tests
-6. Commit to run hooks: "feat: add server info interface"
-7. Implement ServerStatus interface
-8. Add getServerStatus method with tests
-9. Commit to run hooks: "feat: add server status resource"
-10. Fix any linting issues
-11. Push to remote when complete
+2. git checkout -b feature/project-management
+3. Review docs/features/003-project-management.md
+4. Add Project and Environment types
+5. Commit: "feat: add Project and Environment types"
+6. Push: git push -u origin feature/project-management
+7. Add client methods for projects
+8. Commit: "feat: add project-related methods to CoolifyClient"
+9. Push: git push
+10. Add MCP server tools
+11. Commit: "feat: add project management tools to MCP server"
+12. Push: git push
+13. Add tests
+14. Commit: "test: add project management tests"
+15. Push: git push
+16. Update feature doc for completed items
+17. Commit: "docs: update feature doc for project management"
+18. Push: git push
 </example>
 
 <example type="invalid">
 # Poor workflow
-1. Start coding without checking docs
-2. Make all changes in one big commit
-3. Skip tests or add them later
+1. Make all changes at once (types, client, server, tests)
+2. Single large commit with all changes
+3. No documentation updates until the end
 4. Push directly to main
-5. Fix linting issues after PR
+5. No intermediate pushes to remote
+6. Vague commit messages like "project management work"
 </example>
 
 ## Critical Points
 <critical>
-- ALWAYS work from feature documentation
-- 
-- NEVER skip tests for new functionality
-- Commit OFTEN to utilize pre-commit hooks
-- Keep commits focused and well-described
+- NEVER make large, multi-component changes in a single commit
+- ALWAYS commit after each logical component change
+- ALWAYS push to remote after significant commits
+- ALWAYS update documentation AS YOU GO
+- ALWAYS use conventional commit messages
+- NEVER wait until the end to write tests
 </critical> 

docs/features/003-project-management.md

@@ -39,27 +39,27 @@ Basic project management functionality - first interactive feature allowing user
 
 ## Implementation Checklist
 
-- [ ] Project List Resource
+- [x] Project List Resource
 
-  - [ ] resources://coolify/projects/list implementation
-  - [ ] Pagination support
-  - [ ] Basic filtering
+  - [x] resources://coolify/projects/list implementation
+  - [x] Pagination support
+  - [x] Basic filtering
 
-- [ ] Project Management Tools
+- [x] Project Management Tools
 
-  - [ ] createProject tool
-  - [ ] deleteProject tool
-  - [ ] updateProject tool
+  - [x] createProject tool
+  - [x] deleteProject tool
+  - [x] updateProject tool
 
-- [ ] Project Detail Resource
+- [x] Project Detail Resource
 
-  - [ ] resources://coolify/projects/{id} implementation
-  - [ ] Project status and configuration
+  - [x] resources://coolify/projects/{id} implementation
+  - [x] Project status and configuration
 
-- [ ] Testing
-  - [ ] CRUD operation tests
-  - [ ] Error handling tests
-  - [ ] Resource format tests
+- [x] Testing
+  - [x] CRUD operation tests
+  - [x] Error handling tests
+  - [x] Resource format tests
 
 ## Dependencies
 

docs/features/801-feature-workflow.md

@@ -1,6 +1,11 @@
 import { CoolifyMcpServer } from '../lib/mcp-server.js';
 import { jest } from '@jest/globals';
-import type { ServerResources, ValidationResponse } from '../types/coolify.js';
+import type {
+  ServerResources,
+  ValidationResponse,
+  Project,
+  Environment,
+} from '../types/coolify.js';
 
 describe('CoolifyMcpServer', () => {
   const mockConfig = {
@@ -53,4 +58,105 @@ describe('CoolifyMcpServer', () => {
       expect(spy).toHaveBeenCalledWith('test-uuid');
     });
   });
+
+  describe('list_projects', () => {
+    it('should call client listProjects', async () => {
+      const mockProjects: Project[] = [
+        {
+          id: 1,
+          uuid: 'test-project-uuid',
+          name: 'test-project',
+          description: 'Test project description',
+          environments: [],
+        },
+      ];
+
+      const spy = jest.spyOn(server['client'], 'listProjects').mockResolvedValue(mockProjects);
+
+      await server.list_projects();
+      expect(spy).toHaveBeenCalled();
+    });
+  });
+
+  describe('get_project', () => {
+    it('should call client getProject', async () => {
+      const mockProject: Project = {
+        id: 1,
+        uuid: 'test-project-uuid',
+        name: 'test-project',
+        description: 'Test project description',
+        environments: [],
+      };
+
+      const spy = jest.spyOn(server['client'], 'getProject').mockResolvedValue(mockProject);
+
+      await server.get_project('test-project-uuid');
+      expect(spy).toHaveBeenCalledWith('test-project-uuid');
+    });
+  });
+
+  describe('create_project', () => {
+    it('should call client createProject', async () => {
+      const mockResponse = { uuid: 'new-project-uuid' };
+      const createRequest = {
+        name: 'New Project',
+        description: 'New project description',
+      };
+
+      const spy = jest.spyOn(server['client'], 'createProject').mockResolvedValue(mockResponse);
+
+      await server.create_project(createRequest);
+      expect(spy).toHaveBeenCalledWith(createRequest);
+    });
+  });
+
+  describe('update_project', () => {
+    it('should call client updateProject', async () => {
+      const mockProject: Project = {
+        id: 1,
+        uuid: 'test-project-uuid',
+        name: 'Updated Project',
+        description: 'Updated description',
+        environments: [],
+      };
+
+      const updateRequest = {
+        name: 'Updated Project',
+        description: 'Updated description',
+      };
+
+      const spy = jest.spyOn(server['client'], 'updateProject').mockResolvedValue(mockProject);
+
+      await server.update_project('test-project-uuid', updateRequest);
+      expect(spy).toHaveBeenCalledWith('test-project-uuid', updateRequest);
+    });
+  });
+
+  describe('delete_project', () => {
+    it('should call client deleteProject', async () => {
+      const mockResponse = { message: 'Project deleted successfully' };
+
+      const spy = jest.spyOn(server['client'], 'deleteProject').mockResolvedValue(mockResponse);
+
+      await server.delete_project('test-project-uuid');
+      expect(spy).toHaveBeenCalledWith('test-project-uuid');
+    });
+  });
+
+  describe('get_project_environment', () => {
+    it('should call client getProjectEnvironment', async () => {
+      const mockEnvironment: Environment = {
+        id: 1,
+        uuid: 'test-env-uuid',
+        name: 'test-environment',
+      };
+
+      const spy = jest
+        .spyOn(server['client'], 'getProjectEnvironment')
+        .mockResolvedValue(mockEnvironment);
+
+      await server.get_project_environment('test-project-uuid', 'test-env-uuid');
+      expect(spy).toHaveBeenCalledWith('test-project-uuid', 'test-env-uuid');
+    });
+  });
 });

src/__tests__/mcp-server.test.ts

@@ -1,4 +1,4 @@
-import { CoolifyConfig, ErrorResponse, ServerInfo, ServerResources, ServerDomain, ValidationResponse } from '../types/coolify.js';
+import { CoolifyConfig, ErrorResponse, ServerInfo, ServerResources, ServerDomain, ValidationResponse, Project, CreateProjectRequest, UpdateProjectRequest, Environment } from '../types/coolify.js';
 
 export class CoolifyClient {
   private baseUrl: string;
@@ -15,14 +15,15 @@ export class CoolifyClient {
     this.accessToken = config.accessToken;
   }
 
-  private async request<T>(path: string): Promise<T> {
+  private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
     try {
       const url = `${this.baseUrl}/api/v1${path}`;
       const response = await fetch(url, {
         headers: {
           'Content-Type': 'application/json',
           Authorization: `Bearer ${this.accessToken}`,
         },
+        ...options,
       });
 
       const data = await response.json();
@@ -69,5 +70,37 @@ export class CoolifyClient {
     }
   }
 
+  async listProjects(): Promise<Project[]> {
+    return this.request<Project[]>('/projects');
+  }
+
+  async getProject(uuid: string): Promise<Project> {
+    return this.request<Project>(`/projects/${uuid}`);
+  }
+
+  async createProject(project: CreateProjectRequest): Promise<{ uuid: string }> {
+    return this.request<{ uuid: string }>('/projects', {
+      method: 'POST',
+      body: JSON.stringify(project),
+    });
+  }
+
+  async updateProject(uuid: string, project: UpdateProjectRequest): Promise<Project> {
+    return this.request<Project>(`/projects/${uuid}`, {
+      method: 'PATCH',
+      body: JSON.stringify(project),
+    });
+  }
+
+  async deleteProject(uuid: string): Promise<{ message: string }> {
+    return this.request<{ message: string }>(`/projects/${uuid}`, {
+      method: 'DELETE',
+    });
+  }
+
+  async getProjectEnvironment(projectUuid: string, environmentNameOrUuid: string): Promise<Environment> {
+    return this.request<Environment>(`/projects/${projectUuid}/${environmentNameOrUuid}`);
+  }
+
   // Add more methods as needed for other endpoints
 }