@we-scrum/cli 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@we-scrum/cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Cli tool for we-scrum application",
   "main": "dist/cli.js",
   "bin": {
@@ -23,30 +23,32 @@
     ]
   },
   "dependencies": {
-    "@inquirer/prompts": "^8.3.0",
-    "@modelcontextprotocol/sdk": "^1.26.0",
-    "commander": "^11.1.0",
+    "@inquirer/prompts": "8.3.0",
+    "zod": "4.3.6",
+    "@modelcontextprotocol/sdk": "1.27.1",
+    "commander": "14.0.3",
     "firebase": "12.10.0",
     "google-auth-library": "^10.6.1",
     "open": "^11.0.0"
   },
   "devDependencies": {
     "@types/node": "22.18.6",
+    "@modelcontextprotocol/inspector": "0.21.1",
     "tsup": "8.5.1",
     "typescript": "5.9.3",
     "@my-devkit/cli": "2.1.0",
+    "@we-scrum/commands": "1.0.0",
     "@my-devkit/core": "1.0.0",
     "@we-scrum/enums": "1.0.0",
     "@we-scrum/models": "1.0.0",
-    "@we-scrum/commands": "1.0.0"
+    "@we-scrum/utils": "1.0.0"
   },
   "scripts": {
-    "build": "mdk build",
-    "watch": "mdk watch",
-    "build:prod": "tsup",
-    "publish:public": "pnpm publish --access public",
-    "preinstall": "npx only-allow pnpm",
-    "global:link": "pnpm link --global",
-    "global:unlink": "pnpm remove --global @we-scrum/cli"
+    "start": "node dist/cli.js",
+    "inspect": "mcp-inspector node dist/cli.js mcp",
+    "build": "tsup",
+    "watch": "tsup --watch",
+    "deploy": "pnpm build && pnpm publish --access public",
+    "preinstall": "npx only-allow pnpm"
   }
 }

package/src/cli.ts

@@ -4,16 +4,14 @@ import { Logger } from '@my-devkit/core';
 import { UserProjectModel } from '@we-scrum/models';
 import { Command } from 'commander';
 
-import { AuthHelper } from './auth-helper';
-import { FirebaseHelper } from './firebase-helper';
+import { AuthHelper, FirebaseHelper, SettingsHelper } from './helpers';
 import { startMcpServer } from './mcp-server';
-import { SettingsHelper } from './settings-helper';
 
 Logger.registerLogger(new Logger.ConsoleImplementation());
 
 const program = new Command();
 
-program.name('we-scrum').description('CLI for we-scrum application').version('1.0.0');
+program.name('we-scrum').description('CLI for we-scrum application').version('1.0.2');
 
 program
     .command('login')

package/src/{auth-helper.ts → helpers/auth-helper.ts}

@@ -18,6 +18,35 @@ export class AuthHelper {
         return FirebaseHelper.auth.currentUser?.uid;
     }
 
+    public static async getUserIdToken(): Promise<string> {
+        return FirebaseHelper.auth.currentUser.getIdToken();
+    }
+
+    public static async initializeFromStoredCredentials(): Promise<boolean> {
+        const credentials = SettingsHelper.get().credentials ?? null;
+        if (!credentials?.id_token) {
+            return false;
+        }
+        try {
+            const auth = FirebaseHelper.auth;
+            let idToken = credentials.id_token;
+
+            if (credentials.refresh_token) {
+                const oAuth2Client = new OAuth2Client(this.cid, this.csec, this.REDIRECT_URI);
+                oAuth2Client.setCredentials(credentials);
+                const { credentials: refreshed } = await oAuth2Client.refreshAccessToken();
+                SettingsHelper.set({ credentials: refreshed });
+                idToken = refreshed.id_token;
+            }
+
+            const credential = GoogleAuthProvider.credential(idToken);
+            await signInWithCredential(auth, credential);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
     public static async loginWithGoogle(): Promise<User> {
         const auth = FirebaseHelper.auth;
 
@@ -77,31 +106,13 @@ export class AuthHelper {
         });
     }
 
-    /**
-     * Generates PKCE Verifier and Challenge
-     */
-    private static generatePKCE() {
-        const verifier = randomBytes(32).toString('base64url');
-        const challenge = createHash('sha256').update(verifier).digest('base64url');
-        return { verifier, challenge };
-    }
-
     public static logout() {
         SettingsHelper.set({ credentials: undefined });
     }
 
-    public static async initializeFromStoredCredentials(): Promise<boolean> {
-        const credentials = SettingsHelper.get().credentials ?? null;
-        if (!credentials?.id_token) {
-            return false;
-        }
-        try {
-            const auth = FirebaseHelper.auth;
-            const credential = GoogleAuthProvider.credential(credentials.id_token);
-            await signInWithCredential(auth, credential);
-            return true;
-        } catch {
-            return false;
-        }
+    private static generatePKCE() {
+        const verifier = randomBytes(32).toString('base64url');
+        const challenge = createHash('sha256').update(verifier).digest('base64url');
+        return { verifier, challenge };
     }
 }

package/src/{firebase-helper.ts → helpers/firebase-helper.ts}

@@ -77,7 +77,7 @@ export class FirebaseHelper {
         if (!this._app) {
             // Should depend on targeted environment
             const firebaseConfig = {
-                apiKey: 'AIzaSyCodItNw1wtWfx1GAU_x0Pj96mCAUyrWvU',
+                apiKey: 'AIzaSyBUY5qDPQY2035MvP6-pZFuhBRmF5JyddI',
                 authDomain: 'we-scrum-prod.firebaseapp.com',
                 projectId: 'we-scrum-prod',
             };

package/src/helpers/index.ts

@@ -0,0 +1,4 @@
+export * from './auth-helper';
+export * from './firebase-helper';
+export * from './settings-helper';
+export * from './we-scrum.helper';

package/src/helpers/we-scrum.helper.ts

@@ -0,0 +1,240 @@
+import { _sortBy, Command, serialize, TypeHelper } from '@my-devkit/core';
+import {
+    MarkEnumerationChangeAsDoneCommand,
+    MarkObjectChangeAsDoneCommand,
+    MarkRelationChangeAsDoneCommand,
+    MarkRouteChangeAsDoneCommand,
+    MarkTaskAsDoneCommand,
+    TakeEnumerationChangeCommand,
+    TakeObjectChangeCommand,
+    TakeRelationChangeCommand,
+    TakeRouteChangeCommand,
+    TakeTaskCommand,
+} from '@we-scrum/commands';
+import { ProgressStatus } from '@we-scrum/enums';
+import {
+    DevelopmentPolicyModel,
+    ProjectStoryModel,
+    ProjectStorySectionModel,
+    ProjectStorySectionModelEnumerationChange,
+    ProjectStorySectionModelObjectChange,
+    ProjectStorySectionModelRelationChange,
+    ProjectStorySectionModelRouteChange,
+    ProjectStorySectionModelTask,
+} from '@we-scrum/models';
+import { DevelopmentPolicyHelper } from '@we-scrum/utils';
+import { assert } from 'node:console';
+import { AuthHelper } from './auth-helper';
+import { FirebaseHelper } from './firebase-helper';
+import { SettingsHelper } from './settings-helper';
+
+export class WeScrumHelper {
+    private static backendUrl = 'https://europe-west1-we-scrum-prod.cloudfunctions.net';
+    constructor(private userId: string) {}
+
+    public static get projectId(): string {
+        return SettingsHelper.get().selectedProjectId;
+    }
+
+    public static assertProjectIsSelected(): void {
+        assert(!!this.projectId, 'No active project selected. Please run "we-scrum use-project" first.');
+    }
+
+    public static async getNextChange(identificationNumber: string) {
+        this.assertProjectIsSelected();
+
+        const story = await this.findStoryByIterationNumber(identificationNumber);
+
+        assert(!!story, `Story "${identificationNumber}" not found in the active project.`);
+
+        const sections = await this.getStorySections(story.storyId);
+
+        const task = _sortBy(sections, (s) => s.name)
+            .flatMap((s) => [...s.enumerationChanges, ...s.objectChanges, ...s.routeChanges, ...s.relationChanges, ...s.tasks])
+            .find((t) => t.progress?.status !== ProgressStatus.Done);
+
+        return task;
+    }
+
+    public static async startTask(identificationNumber: string): Promise<void> {
+        const change = await this.getNextChange(identificationNumber);
+
+        assert(!!change, `All tasks for story "${identificationNumber}" are complete.`);
+        assert(change.progress.status === ProgressStatus.ToDo, `Task is already in progress (current status: ${change.progress.status}).`);
+
+        if (change instanceof ProjectStorySectionModelEnumerationChange) {
+            await this.post(
+                'enumeration-management/take-enumeration-change',
+                TypeHelper.transform(TakeEnumerationChangeCommand, { enumerationChangeId: change.enumerationChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelObjectChange) {
+            await this.post(
+                'object-management/take-object-change',
+                TypeHelper.transform(TakeObjectChangeCommand, { objectChangeId: change.objectChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelRouteChange) {
+            await this.post(
+                'route-management/take-route-change',
+                TypeHelper.transform(TakeRouteChangeCommand, { routeChangeId: change.routeChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelRelationChange) {
+            await this.post(
+                'relation-management/take-relation-change',
+                TypeHelper.transform(TakeRelationChangeCommand, { relationChangeId: change.relationChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelTask) {
+            await this.post('task-management/take-task', TypeHelper.transform(TakeTaskCommand, { taskId: change.taskId }));
+        }
+    }
+
+    public static async completeTask(identificationNumber: string): Promise<void> {
+        const change = await this.getNextChange(identificationNumber);
+
+        assert(!!change, `All tasks for story "${identificationNumber}" are complete.`);
+        assert(change.progress.status === ProgressStatus.Doing, `Task is not in progress (current status: ${change.progress.status}).`);
+
+        if (change instanceof ProjectStorySectionModelEnumerationChange) {
+            await this.post(
+                'enumeration-management/mark-enumeration-change-as-done',
+                TypeHelper.transform(MarkEnumerationChangeAsDoneCommand, { enumerationChangeId: change.enumerationChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelObjectChange) {
+            await this.post(
+                'object-management/mark-object-change-as-done',
+                TypeHelper.transform(MarkObjectChangeAsDoneCommand, { objectChangeId: change.objectChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelRouteChange) {
+            await this.post(
+                'route-management/mark-route-change-as-done',
+                TypeHelper.transform(MarkRouteChangeAsDoneCommand, { routeChangeId: change.routeChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelRelationChange) {
+            await this.post(
+                'relation-management/mark-relation-change-as-done',
+                TypeHelper.transform(MarkRelationChangeAsDoneCommand, { relationChangeId: change.relationChangeId }),
+            );
+        } else if (change instanceof ProjectStorySectionModelTask) {
+            await this.post('task-management/mark-task-as-done', TypeHelper.transform(MarkTaskAsDoneCommand, { taskId: change.taskId }));
+        }
+    }
+
+    public static async getChangeDevelopmentPolicy(change: DevelopmentPolicyHelper.Change) {
+        const developmentPolicies = await this.getDevelopmentPolicies();
+
+        return DevelopmentPolicyHelper.getMatchingDevelopmentPolicy(change, developmentPolicies);
+    }
+
+    private static async findStoryByIterationNumber(identificationNumber: string) {
+        return FirebaseHelper.findDocument<ProjectStoryModel>(`/projects/${this.projectId}/stories`, [
+            ['identificationNumber', '==', identificationNumber],
+        ]);
+    }
+
+    private static async getStorySections(storyId: string) {
+        return FirebaseHelper.getCollection<ProjectStorySectionModel>(`projects/${this.projectId}/stories/${storyId}/sections`);
+    }
+
+    private static async getDevelopmentPolicies() {
+        return FirebaseHelper.getCollection<DevelopmentPolicyModel>(`/projects/${this.projectId}/development-policies`);
+    }
+
+    // public async createEnumeration(enumeration: Enumeration): Promise<string> {
+    //     Logger.info(`Creating enumeration ${enumeration.name}`);
+
+    //     const createCommand = TypeHelper.transform(CreateEnumerationCommand, {
+    //         projectId: this.projectId,
+    //         name: enumeration.name,
+    //     });
+
+    //     const enumerationId = await this.post<CreateEnumerationCommand, string>('enumeration-management/create-enumeration', createCommand);
+    //     for (const property of enumeration.properties) {
+    //         const propertyCommand = TypeHelper.transform(CreateEnumerationPropertyCommand, {
+    //             enumerationId,
+    //             enumerationPropertyId: guid(),
+    //             name: property.label,
+    //             value: property.value,
+    //         });
+    //         await this.post<CreateEnumerationPropertyCommand, string>(
+    //             'enumeration-management/create-enumeration-property',
+    //             propertyCommand,
+    //         );
+    //     }
+
+    //     return enumerationId;
+    // }
+
+    // public async createObject(object: Object, getEnumerationId: (name: string) => string): Promise<string> {
+    //     Logger.info(`Creating object ${object.name}`);
+
+    //     const createCommand = TypeHelper.transform(CreateObjectCommand, {
+    //         projectId: this.projectId,
+    //         name: object.name,
+    //     });
+    //     const objectId = await this.post<CreateObjectCommand, string>('object-management/create-object', createCommand);
+
+    //     const propertyMap = new Map<string, string>();
+    //     for (const property of object.properties) {
+    //         const objectPropertyId = guid();
+    //         const propertyCommand = TypeHelper.transform(CreateObjectPropertyCommand, {
+    //             objectId,
+    //             objectPropertyId,
+    //             objectPropertyParentId: propertyMap.get(property.parent) || null,
+    //             name: property.name,
+    //             objectPropertyType: property.type,
+    //             isArray: property.isArray,
+    //             enumerationId: property.enumerationName ? getEnumerationId(property.enumerationName) : null,
+    //         });
+    //         await this.post<CreateObjectPropertyCommand, string>('object-management/create-object-property', propertyCommand);
+
+    //         propertyMap.set(property.path, objectPropertyId);
+    //     }
+
+    //     return objectId;
+    // }
+
+    // public async createHandler(handler: Handler, getObjectId: (name: string) => string): Promise<void> {
+    //     Logger.info(`Creating handler ${handler.name}`);
+
+    //     for (const relation of handler.relations) {
+    //         const createCommand = TypeHelper.transform(CreateRelationCommand, {
+    //             projectId: this.projectId,
+    //             boundedContext: handler.boundedContext,
+    //             handlerName: handler.name,
+    //             objectIds: relation.map((o) => getObjectId(o)),
+    //             subscriptionName: null,
+    //         });
+    //         await this.post<CreateRelationCommand, string>('relation-management/create-relation', createCommand);
+    //     }
+    // }
+
+    // public async createRoute(route: Route, getObjectId: (name: string) => string): Promise<string> {
+    //     Logger.info(`Creating route ${route.method} ${route.path}`);
+
+    //     const createCommand = TypeHelper.transform(CreateRouteCommand, {
+    //         projectId: this.projectId,
+    //         method: route.method,
+    //         path: route.path,
+    //         objectId: getObjectId(route.object),
+    //         permission: null,
+    //     });
+
+    //     return this.post<CreateRouteCommand, string>('route-management/create-route', createCommand);
+    // }
+
+    private static async post<C extends Command, R>(route: string, command: C): Promise<R> {
+        const userIdToken = await AuthHelper.getUserIdToken();
+
+        const response = await fetch(`${this.backendUrl}/command/${route}`, {
+            method: 'POST',
+            body: JSON.stringify(serialize(command)),
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${userIdToken}`,
+            },
+            signal: AbortSignal.timeout(60 * 1000),
+        });
+
+        const body = (await response.json()) as { result: R };
+        return body.result;
+    }
+}

package/src/mcp-server/index.ts

@@ -0,0 +1 @@
+export * from './mcp-server';

package/src/mcp-server/mcp-server.ts

@@ -0,0 +1,82 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+
+import { AuthHelper } from '@helpers';
+import { completeTask, getNextTask, getUnitTestGuidelines, startTask } from './tools';
+
+const identificationNumberSchema = z.object({
+    identificationNumber: z.string().describe('The story identification number, e.g. "144154"'),
+});
+
+function createToolCallback<T extends Record<string, string>>(fn: (identificationNumber: string) => Promise<T>) {
+    return async ({ identificationNumber }: { identificationNumber: string }) => {
+        try {
+            const result = await fn(identificationNumber);
+            return { content: [{ type: 'text' as const, text: JSON.stringify(result, null, 2) }] };
+        } catch (error) {
+            return {
+                content: [{ type: 'text' as const, text: JSON.stringify({ error: error.message }) }],
+                isError: true,
+            };
+        }
+    };
+}
+
+export async function startMcpServer(): Promise<void> {
+    const initialized = await AuthHelper.initializeFromStoredCredentials();
+    if (!initialized) {
+        process.stderr.write('Error: Not authenticated. Please run "we-scrum login" first.\n');
+        process.exit(1);
+    }
+
+    const server = new McpServer({ name: 'we-scrum-mcp-server', version: '1.0.0' });
+
+    server.registerTool(
+        'get_next_task',
+        {
+            description: `Get the next pending task (status: ToDo) for a story.
+Returns the task description, the task type template (development guidelines),
+and the full section analysis specifying what must be implemented
+(route changes, object/DTO changes, enumeration changes, relation/handler changes).
+Also returns storyId, sectionId and taskId needed to call start_task and complete_task.`,
+            inputSchema: identificationNumberSchema,
+        },
+        createToolCallback(getNextTask),
+    );
+
+    server.registerTool(
+        'start_task',
+        {
+            description: `Mark the next pending task of a story as in progress.
+Call this before making any changes to the codebase, as instructed by get_next_task.`,
+            inputSchema: identificationNumberSchema,
+        },
+        createToolCallback(startTask),
+    );
+
+    server.registerTool(
+        'get_unit_test_guidelines',
+        {
+            description: `Get unit test writing guidelines for the current pending task of a story.
+Call this tool when get_next_task returns unitTests instructions to run it.`,
+            inputSchema: identificationNumberSchema,
+        },
+        createToolCallback(getUnitTestGuidelines),
+    );
+
+    server.registerTool(
+        'complete_task',
+        {
+            description: `Mark the current in-progress task of a story as done.
+Call this after committing all changes, as instructed by get_next_task.`,
+            inputSchema: identificationNumberSchema,
+        },
+        createToolCallback(completeTask),
+    );
+
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+
+    process.stderr.write('we-scrum MCP server running.\n');
+}

package/src/mcp-server/tools/complete-task.ts

@@ -0,0 +1,6 @@
+import { WeScrumHelper } from '@helpers';
+
+export async function completeTask(identificationNumber: string): Promise<Record<string, string>> {
+    await WeScrumHelper.completeTask(identificationNumber);
+    return { message: 'Task completed successfully.' };
+}

package/src/mcp-server/tools/get-next-task.ts

@@ -0,0 +1,149 @@
+import { WeScrumHelper } from '@helpers';
+import { _compact } from '@my-devkit/core';
+import { Operation, ProgressStatus } from '@we-scrum/enums';
+import {
+    ProjectStorySectionModelEnumerationChange,
+    ProjectStorySectionModelObjectChange,
+    ProjectStorySectionModelRelationChange,
+    ProjectStorySectionModelRouteChange,
+    ProjectStorySectionModelTask,
+} from '@we-scrum/models';
+
+export async function getNextTask(identificationNumber: string): Promise<Record<string, string>> {
+    const nextTask = await WeScrumHelper.getNextChange(identificationNumber);
+
+    if (!nextTask) {
+        return { message: `All tasks for story "${identificationNumber}" are complete.` };
+    }
+
+    const isTodo = nextTask.progress.status === ProgressStatus.ToDo;
+    const generalInstructions = _compact([
+        'Implement the task described in the fields below.',
+        'Refer to `implementationGuidelines` for coding conventions and project-specific instructions.',
+        isTodo ? 'Before making any changes, run `start_task` to mark the task as in progress.' : null,
+        'If anything is unclear, stop and ask before making any changes.',
+        'Once all changes are done, commit your code and run `complete_task`.',
+    ]).join('\n');
+
+    const developmentPolicy = await WeScrumHelper.getChangeDevelopmentPolicy(nextTask);
+    const implementationGuidelines = developmentPolicy?.codeGuidelines ?? 'No guidelines found for this task... :-(';
+
+    const unitTestInstructions = 'Run get_unit_test_guidelines to get instructions to generate unit tests for this task';
+    const unitTests = developmentPolicy?.areUnitTestsMandatory ? unitTestInstructions : 'No unit test needed.';
+
+    if (nextTask instanceof ProjectStorySectionModelEnumerationChange) {
+        const propertyChanges = nextTask.propertyChanges
+            .filter((pc) => !!pc.operation)
+            .map((pc) => `${pc.operation} property ${pc.propertyName} (= '${pc.propertyValue}')`)
+            .sort()
+            .join('\n');
+
+        return {
+            generalInstructions,
+            taskType: `${nextTask.operation} enumeration`,
+            enumerationName: nextTask.enumerationName,
+            propertyChanges: propertyChanges || 'No change on properties',
+            taskDescription: nextTask.description ?? undefined,
+            implementationGuidelines,
+            unitTests,
+        };
+    }
+    if (nextTask instanceof ProjectStorySectionModelObjectChange) {
+        const propertyMap = new Map(nextTask.propertyChanges.map((pc) => [pc.objectPropertyId, pc]));
+
+        const buildPath = (pc: (typeof nextTask.propertyChanges)[0]): string => {
+            const name = pc.isArray ? `${pc.propertyName}[]` : pc.propertyName;
+            if (!pc.objectPropertyParentId) return name;
+            const parent = propertyMap.get(pc.objectPropertyParentId);
+            return parent ? `${buildPath(parent)}.${name}` : name;
+        };
+
+        const changedProperties = nextTask.propertyChanges.filter((pc) => !!pc.operation);
+        const parentIdsWithChangedChildren = new Set(changedProperties.map((pc) => pc.objectPropertyParentId).filter(Boolean));
+
+        const propertyChanges = changedProperties
+            .filter((pc) => !(pc.operation === Operation.Create && parentIdsWithChangedChildren.has(pc.objectPropertyId)))
+            .map((pc) => {
+                const enumInfo = pc.enumerationName ? ` (enum: ${pc.enumerationName})` : '';
+                return `${pc.operation} property ${buildPath(pc)}: ${pc.propertyType}${enumInfo}`;
+            })
+            .sort()
+            .join('\n');
+
+        return {
+            generalInstructions,
+            taskType: `${nextTask.operation} object`,
+            objectName: nextTask.objectName,
+            renamedFrom: nextTask.initialObjectName
+                ? `Object renamed from "${nextTask.initialObjectName}" to "${nextTask.objectName}"`
+                : undefined,
+            propertyChanges: propertyChanges || 'No change on properties',
+            taskDescription: nextTask.description ?? undefined,
+            implementationGuidelines,
+            unitTests,
+        };
+    }
+    if (nextTask instanceof ProjectStorySectionModelRouteChange) {
+        const queryParamChanges = nextTask.queryParamChanges
+            .filter((qp) => !!qp.operation)
+            .map((qp) => {
+                const enumInfo = qp.enumerationName ? ` (enum: ${qp.enumerationName})` : '';
+                return `${qp.operation} query param ${qp.routeQueryParamName}: ${qp.routeQueryParamType}${enumInfo}`;
+            })
+            .sort()
+            .join('\n');
+
+        return {
+            generalInstructions,
+            taskType: `${nextTask.operation} route`,
+            route: `${nextTask.routeMethod} ${nextTask.routePath}`,
+            routeObject: nextTask.routeObjectName ?? undefined,
+            pathChangedFrom:
+                nextTask.initialRoutePath && nextTask.initialRoutePath !== nextTask.routePath ? nextTask.initialRoutePath : undefined,
+            methodChangedFrom:
+                nextTask.initialRouteMethod && nextTask.initialRouteMethod !== nextTask.routeMethod
+                    ? nextTask.initialRouteMethod
+                    : undefined,
+            objectChangedFrom:
+                nextTask.initialRouteObjectName && nextTask.initialRouteObjectName !== nextTask.routeObjectName
+                    ? nextTask.initialRouteObjectName
+                    : undefined,
+            permissionChangedFrom:
+                nextTask.initialRoutePermission && nextTask.initialRoutePermission !== nextTask.routePermission
+                    ? nextTask.initialRoutePermission
+                    : undefined,
+            queryParamChanges: queryParamChanges || 'No change on query params',
+            taskDescription: nextTask.description ?? undefined,
+            implementationGuidelines,
+            unitTests,
+        };
+    }
+    if (nextTask instanceof ProjectStorySectionModelRelationChange) {
+        const relations = nextTask.relations
+            .filter((r) => !!r.operation)
+            .map((r) => `${r.operation} [${r.objects.map((o) => o.objectName).join(' ⇒ ')}]`)
+            .sort()
+            .join('\n');
+
+        return {
+            generalInstructions,
+            taskType: 'relation change',
+            handlerName: nextTask.handlerName,
+            boundedContext: nextTask.boundedContext,
+            subscriptionName: nextTask.subscriptionName ?? undefined,
+            relations: relations || 'No relation changes',
+            taskDescription: nextTask.description ?? undefined,
+            implementationGuidelines,
+            unitTests,
+        };
+    }
+    if (nextTask instanceof ProjectStorySectionModelTask) {
+        return {
+            generalInstructions,
+            taskType: nextTask.taskTypeName,
+            taskDescription: nextTask.description ?? undefined,
+            implementationGuidelines,
+            unitTests,
+        };
+    }
+}

package/src/mcp-server/tools/get-unit-test-guidelines.ts

@@ -0,0 +1,15 @@
+import { WeScrumHelper } from '@helpers';
+
+export async function getUnitTestGuidelines(identificationNumber: string): Promise<Record<string, string>> {
+    const nextTask = await WeScrumHelper.getNextChange(identificationNumber);
+
+    if (!nextTask) {
+        return { message: `All tasks for story "${identificationNumber}" are complete.` };
+    }
+
+    const developmentPolicy = await WeScrumHelper.getChangeDevelopmentPolicy(nextTask);
+
+    return {
+        unitTestGuidelines: developmentPolicy?.unitTestsGuidelines ?? 'No unit test guidelines found for this task.',
+    };
+}

package/src/mcp-server/tools/index.ts

@@ -0,0 +1,4 @@
+export * from './complete-task';
+export * from './get-next-task';
+export * from './get-unit-test-guidelines';
+export * from './start-task';

package/src/mcp-server/tools/start-task.ts

@@ -0,0 +1,6 @@
+import { WeScrumHelper } from '@helpers';
+
+export async function startTask(identificationNumber: string): Promise<Record<string, string>> {
+    await WeScrumHelper.startTask(identificationNumber);
+    return { message: 'Task started successfully. You can now make changes to the codebase.' };
+}