@we-scrum/cli 1.0.4 → 1.0.6

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

@@ -1,4 +1,4 @@
-import { _sortBy, Command, serialize, TypeHelper } from '@my-devkit/core';
+import { _sortBy, assert, Command, serialize, TypeHelper } from '@my-devkit/core';
 import {
     MarkEnumerationChangeAsDoneCommand,
     MarkObjectChangeAsDoneCommand,
@@ -11,7 +11,7 @@ import {
     TakeRouteChangeCommand,
     TakeTaskCommand,
 } from '@we-scrum/commands';
-import { ProgressStatus } from '@we-scrum/enums';
+import { ContentType, ProgressStatus } from '@we-scrum/enums';
 import {
     DevelopmentPolicyModel,
     ProjectStoryModel,
@@ -22,27 +22,53 @@ import {
     ProjectStorySectionModelRouteChange,
     ProjectStorySectionModelTask,
 } from '@we-scrum/models';
-import { DevelopmentPolicyHelper } from '@we-scrum/utils';
-import { assert } from 'node:console';
+import { AnalysisDsl, DevelopmentPolicyHelper, HtmlToTextHelper, StorySectionHelper, stringifyAnalysisDslChange } from '@we-scrum/utils';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { AuthHelper } from './auth-helper';
 import { FirebaseHelper } from './firebase-helper';
-import { SettingsHelper } from './settings-helper';
+import { ProjectHelper } from './project-helper';
+import { renderTemplate } from './template.helper';
 
 export class WeScrumHelper {
-    private static backendUrl = 'https://europe-west1-we-scrum-prod.cloudfunctions.net';
+    private static readonly backendUrl = 'https://europe-west1-we-scrum-prod.cloudfunctions.net';
     constructor(private userId: string) {}
 
-    public static get projectId(): string {
-        return SettingsHelper.get().selectedProjectId;
+    private static get projectRoot(): string {
+        return ProjectHelper.requireRoot();
     }
 
-    public static assertProjectIsSelected(): void {
-        assert(!!this.projectId, 'No active project selected. Please run "we-scrum use-project" first.');
+    private static get projectConfig() {
+        return ProjectHelper.read(this.projectRoot);
     }
 
-    public static async getNextChange(identificationNumber: string) {
-        this.assertProjectIsSelected();
+    private static get projectId(): string {
+        return this.projectConfig.projectId;
+    }
+
+    public static async getNextTask(identificationNumber: string): Promise<string> {
+        const nextChange = await this.getNextChange(identificationNumber);
+
+        if (!nextChange) {
+            return `## Story ${identificationNumber}\n\nAll tasks are complete.`;
+        }
 
+        const analysisChange = StorySectionHelper.mapSingleChange(nextChange);
+        const isTodo = nextChange.progress.status === ProgressStatus.ToDo;
+        const developmentPolicy = await this.getChangeDevelopmentPolicy(nextChange);
+        const { guidelinesPath, unitTestsPath } = this.getDevelopmentPolicyPaths(developmentPolicy);
+
+        return renderTemplate('get-next-task', {
+            taskDetails: stringifyAnalysisDslChange(analysisChange),
+            guidelinesPath,
+            unitTestsPath: developmentPolicy?.areUnitTestsMandatory ? unitTestsPath : null,
+            isTodo,
+            identificationNumber,
+            taskId: analysisChange.id,
+        });
+    }
+
+    public static async getNextChange(identificationNumber: string) {
         const story = await this.findStoryByIterationNumber(identificationNumber);
 
         assert(!!story, `Story "${identificationNumber}" not found in the active project.`);
@@ -56,11 +82,31 @@ export class WeScrumHelper {
         return task;
     }
 
-    public static async startTask(identificationNumber: string): Promise<void> {
-        const change = await this.getNextChange(identificationNumber);
+    public static async getChangeById(identificationNumber: string, changeId: string) {
+        const story = await this.findStoryByIterationNumber(identificationNumber);
+        assert(!!story, `Story "${identificationNumber}" not found in the active project.`);
+
+        const sections = await this.getStorySections(story.storyId);
 
-        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}).`);
+        const change = _sortBy(sections, (s) => s.name)
+            .flatMap((s) => [...s.enumerationChanges, ...s.objectChanges, ...s.routeChanges, ...s.relationChanges, ...s.tasks])
+            .find((t) => {
+                if (t instanceof ProjectStorySectionModelEnumerationChange) return t.enumerationChangeId === changeId;
+                if (t instanceof ProjectStorySectionModelObjectChange) return t.objectChangeId === changeId;
+                if (t instanceof ProjectStorySectionModelRouteChange) return t.routeChangeId === changeId;
+                if (t instanceof ProjectStorySectionModelRelationChange) return t.relationChangeId === changeId;
+                if (t instanceof ProjectStorySectionModelTask) return t.taskId === changeId;
+                return false;
+            });
+
+        assert(!!change, `Change "${changeId}" not found in story "${identificationNumber}".`);
+        return change;
+    }
+
+    public static async startTask(identificationNumber: string, taskId: string): Promise<void> {
+        const change = await this.getChangeById(identificationNumber, taskId);
+
+        assert(change.progress.status === ProgressStatus.ToDo, `Task is not in ToDo status (current status: ${change.progress.status}).`);
 
         if (change instanceof ProjectStorySectionModelEnumerationChange) {
             await this.post(
@@ -87,10 +133,9 @@ export class WeScrumHelper {
         }
     }
 
-    public static async completeTask(identificationNumber: string): Promise<void> {
-        const change = await this.getNextChange(identificationNumber);
+    public static async completeTask(identificationNumber: string, taskId: string): Promise<void> {
+        const change = await this.getChangeById(identificationNumber, taskId);
 
-        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) {
@@ -124,6 +169,39 @@ export class WeScrumHelper {
         return DevelopmentPolicyHelper.getMatchingDevelopmentPolicy(change, developmentPolicies);
     }
 
+    public static getDevelopmentPolicyPaths(policy: DevelopmentPolicyModel | null): {
+        guidelinesPath: string | null;
+        unitTestsPath: string | null;
+    } {
+        const { developmentPoliciesPath } = this.projectConfig;
+        const policiesDir = join(this.projectRoot, developmentPoliciesPath);
+        return {
+            guidelinesPath: policy?.slug ? join(policiesDir, `develop-${policy.slug}.md`) : null,
+            unitTestsPath: policy?.slug ? join(policiesDir, `test-${policy.slug}.md`) : null,
+        };
+    }
+
+    public static async getStoryDescription(identificationNumber: string): Promise<string> {
+        const story = await this.findStoryByIterationNumber(identificationNumber);
+        assert(!!story, `Story "${identificationNumber}" not found in the active project.`);
+
+        const description = story.description ?? '';
+        if (story.descriptionContentType === ContentType.Html) {
+            return HtmlToTextHelper.convert(description);
+        }
+        return description;
+    }
+
+    public static async getStoryAnalysis(identificationNumber: string): Promise<string> {
+        const story = await this.findStoryByIterationNumber(identificationNumber);
+        assert(!!story, `Story "${identificationNumber}" not found in the active project.`);
+
+        const sections = await this.getStorySections(story.storyId);
+        const ast = StorySectionHelper.mapSectionsToAnalysisAst(sections);
+
+        return AnalysisDsl.stringify(ast);
+    }
+
     private static async findStoryByIterationNumber(identificationNumber: string) {
         return FirebaseHelper.findDocument<ProjectStoryModel>(`/projects/${this.projectId}/stories`, [
             ['identificationNumber', '==', identificationNumber],
@@ -134,92 +212,31 @@ export class WeScrumHelper {
         return FirebaseHelper.getCollection<ProjectStorySectionModel>(`projects/${this.projectId}/stories/${storyId}/sections`);
     }
 
-    private static async getDevelopmentPolicies() {
+    public 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);
-    // }
+    public static async synchronizeDevelopmentPolicies(): Promise<number> {
+        const { developmentPoliciesPath } = this.projectConfig;
+        const policiesDir = join(this.projectRoot, developmentPoliciesPath);
+
+        rmSync(policiesDir, { recursive: true, force: true });
+        mkdirSync(policiesDir, { recursive: true });
+
+        const policies = await this.getDevelopmentPolicies();
+
+        for (const policy of policies) {
+            const { guidelinesPath, unitTestsPath } = this.getDevelopmentPolicyPaths(policy);
+            if (policy.codeGuidelines && guidelinesPath) {
+                writeFileSync(guidelinesPath, policy.codeGuidelines);
+            }
+            if (policy.unitTestsGuidelines && unitTestsPath) {
+                writeFileSync(unitTestsPath, policy.unitTestsGuidelines);
+            }
+        }
+
+        return policies.length;
+    }
 
     private static async post<C extends Command, R>(route: string, command: C): Promise<R> {
         const userIdToken = await AuthHelper.getUserIdToken();

package/templates/develop-story-skill.hbs

@@ -0,0 +1,46 @@
+---
+name: develop-story
+description: >
+  Develop a we-scrum user story by iterating through its tasks one by one.
+  Use this skill whenever the user says "develop story XXXXX", "/develop-story XXXXX",
+  or asks to implement or work on a specific story number. The skill synchronizes
+  development policies, then fetches and implements each task in sequence using
+  the we-scrum CLI.
+compatibility: "Requires: we-scrum CLI (we-scrum)"
+---
+
+# Develop Story Skill
+
+Iterates through a we-scrum story's tasks, implementing each one in sequence until
+all tasks are complete.
+
+---
+
+## Step 0 — Resolve the story identification number
+
+If the user provided a story identification number (e.g. `/develop-story 00240`), use it.
+Otherwise, ask: _"Which story would you like to develop? Please provide the identification number."_
+Do not proceed until a number is provided.
+
+---
+
+## Step 1 — Synchronize development policies
+
+Pull the latest development guidelines into the project before starting any work:
+
+```bash
+we-scrum synchronize-development-policies
+```
+
+---
+
+## Step 2 — Fetch and implement tasks
+
+Run the following command to get the next pending task and follow the instructions it returns.
+Replace `<identificationNumber>` with the story identification number.
+
+```bash
+we-scrum get-next-task --identificationNumber <identificationNumber>
+```
+
+Repeat until all tasks are complete.

package/templates/get-next-task.hbs

@@ -0,0 +1,21 @@
+{{{taskDetails}}}
+
+## Development guidelines
+{{#if guidelinesPath}}Refer to `{{{guidelinesPath}}}` for coding conventions and project-specific instructions.{{else}}_No development guidelines file configured for this task._{{/if}}
+
+## Unit tests
+{{#if unitTestsPath}}Unit tests are required. Refer to `{{{unitTestsPath}}}` for test writing guidelines.{{else}}No unit tests required.{{/if}}
+
+## Next steps
+{{#if isTodo}}
+1. Run `we-scrum start-task --identificationNumber "{{identificationNumber}}" --taskId "{{taskId}}"` before making any changes.
+2. Implement the task described above.
+3. Commit your changes.
+4. Run `we-scrum complete-task --identificationNumber "{{identificationNumber}}" --taskId "{{taskId}}"` when done.
+5. Call `get_next_task` to continue with the next task.
+{{else}}
+1. Implement the task described above.
+2. Commit your changes.
+3. Run `we-scrum complete-task --identificationNumber "{{identificationNumber}}" --taskId "{{taskId}}"` when done.
+4. Call `get_next_task` to continue with the next task.
+{{/if}}

package/templates/review-analysis-skill.hbs

@@ -0,0 +1,61 @@
+---
+name: review-analysis
+description: >
+  Review the analysis of a we-scrum user story. Use this skill whenever the user says
+  "review analysis XXXXX", "/review-analysis XXXXX", or asks to review or check the
+  analysis of a specific story number. The skill retrieves the story description and
+  analysis DSL, then reviews them and returns comments.
+compatibility: "Requires: we-scrum CLI (we-scrum)"
+---
+
+# Review Analysis Skill
+
+Reviews the analysis of a we-scrum user story and returns comments.
+
+---
+
+## Step 0 — Resolve the story identification number
+
+If the user provided a story identification number (e.g. `/review-analysis 00240`), use it.
+Otherwise, ask: _"Which story would you like to review? Please provide the identification number."_
+Do not proceed until a number is provided.
+
+---
+
+## Step 1 — Retrieve story data
+
+Run the following commands to fetch the story description and analysis DSL.
+Replace `<identificationNumber>` with the story identification number.
+
+```bash
+we-scrum get-story-description --identificationNumber <identificationNumber>
+we-scrum get-story-analysis --identificationNumber <identificationNumber>
+```
+
+---
+
+## Step 2 — Review and return comments
+
+Review the story description and analysis DSL together. Check for:
+
+**Completeness & correctness**
+- Consistency between the description and the analysis changes
+- Missing or incomplete changes relative to the described requirements
+- Incorrect operations (create/update/delete used inappropriately)
+- Unclear or ambiguous task descriptions
+
+**Naming clarity**
+- Object names and property names must be clear, precise, and self-explanatory
+- Challenge any name that is vague, abbreviated, or could be misread — propose a better alternative
+- Names should reflect the domain concept they represent, not the implementation detail
+
+**Naming continuity**
+- A name introduced in the analysis (object, property, route, enumeration) must flow consistently through the entire vertical slice: command → aggregate → event → denormalizer → model → DTO → API response
+- Flag any analysis change where the proposed name would likely create a discontinuity or force a translation at any layer
+- Renames or aliases between layers are a sign of a poorly chosen name — the right name should need no translation
+
+**Migrations**
+- Any change that adds, removes, or renames a field on an Aggregate or a Model must be accompanied by a migration script task in the analysis
+- If such a structural change is present but no corresponding migration task exists, raise it as a blocking issue — shipping without a migration will corrupt existing data or break reads
+
+Return your comments to the user.

package/tsconfig.json

@@ -14,6 +14,7 @@
         "resolveJsonModule": true,
         "paths": {
             "@helpers": ["helpers"]
-        }
+        },
+        "forceConsistentCasingInFileNames": true
     }
 }

package/src/mcp-server/index.ts

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

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

@@ -1,82 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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`.',
-        'After completing a task, immediately run `get_next_task` again and continue until all tasks are complete.',
-    ]).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,
-        };
-    }
-}