@we-scrum/cli 1.0.0 → 1.0.1

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "module": "commonjs",
-        "moduleResolution": "node",
+        "moduleResolution": "bundler",
         "target": "es2021",
         "outDir": "./dist",
         "baseUrl": "src",
@@ -12,9 +12,7 @@
         "esModuleInterop": true,
         "skipLibCheck": true,
         "paths": {
-            "@modelcontextprotocol/sdk/server": ["../node_modules/@modelcontextprotocol/sdk/dist/esm/server/index"],
-            "@modelcontextprotocol/sdk/server/stdio.js": ["../node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio"],
-            "@modelcontextprotocol/sdk/types.js": ["../node_modules/@modelcontextprotocol/sdk/dist/esm/types"]
+            "@helpers": ["helpers"]
         }
     }
 }

package/src/mcp-server.ts

@@ -1,127 +0,0 @@
-import { Server } from '@modelcontextprotocol/sdk/server';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { ProgressStatus } from '@we-scrum/enums';
-import { ProjectStoryModel, ProjectStorySectionModel } from '@we-scrum/models';
-
-import { AuthHelper } from './auth-helper';
-import { FirebaseHelper } from './firebase-helper';
-import { SettingsHelper } from './settings-helper';
-
-const TOOLS = [
-    {
-        name: '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: {
-            type: 'object',
-            properties: {
-                identificationNumber: {
-                    type: 'string',
-                    description: 'The story identification number, e.g. "144154"',
-                },
-            },
-            required: ['identificationNumber'],
-        },
-    },
-];
-
-async function handleGetNextTask(identificationNumber: string): Promise<string> {
-    const projectId = SettingsHelper.get().selectedProjectId;
-    if (!projectId) {
-        throw new Error('No active project selected. Please run "we-scrum use-project" first.');
-    }
-
-    // 1. Find story by identificationNumber
-    const story = await FirebaseHelper.findDocument<ProjectStoryModel>(`/projects/${projectId}/stories`, [
-        ['identificationNumber', '==', identificationNumber],
-    ]);
-
-    if (!story) {
-        throw new Error(`Story "${identificationNumber}" not found in the active project.`);
-    }
-
-    // 2. Fetch all section documents at once
-    const sections = await FirebaseHelper.getCollection<ProjectStorySectionModel>(
-        `projects/${projectId}/stories/${story.storyId}/sections`,
-    );
-
-    // 3. Order sections using the position stored in story.sections[]
-    const positionBySection = new Map(story.sections.map((s) => [s.sectionId, s.position ?? 0]));
-    const sortedSections = sections.sort((a, b) => (positionBySection.get(a.sectionId) ?? 0) - (positionBySection.get(b.sectionId) ?? 0));
-
-    // 4. Walk sections in order and find the first ToDo task
-    for (const section of sortedSections) {
-        const tasks = [...(section.tasks ?? [])].sort((a, b) => (a.position ?? 0) - (b.position ?? 0));
-        const nextTask = tasks.find((t) => t.progress?.status === ProgressStatus.ToDo);
-
-        if (!nextTask) continue;
-
-        const result = {
-            storyId: story.storyId,
-            storyName: story.name,
-            sectionId: section.sectionId,
-            sectionName: section.name,
-            task: {
-                taskId: nextTask.taskId,
-                description: nextTask.description,
-                taskTypeName: nextTask.taskTypeName,
-                position: nextTask.position,
-                status: nextTask.progress?.status,
-            },
-            sectionAnalysis: {
-                ...(section.routeChanges?.length && { routeChanges: section.routeChanges }),
-                ...(section.objectChanges?.length && { objectChanges: section.objectChanges }),
-                ...(section.enumerationChanges?.length && { enumerationChanges: section.enumerationChanges }),
-                ...(section.relationChanges?.length && { relationChanges: section.relationChanges }),
-            },
-        };
-
-        return JSON.stringify(result, null, 2);
-    }
-
-    return JSON.stringify({ message: `All tasks for story "${identificationNumber}" are complete.` });
-}
-
-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 Server({ name: 'we-scrum-mcp-server', version: '1.0.0' }, { capabilities: { tools: {} } });
-
-    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
-
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-
-        try {
-            let text: string;
-
-            switch (name) {
-                case 'get_next_task':
-                    text = await handleGetNextTask(args.identificationNumber as string);
-                    break;
-                default:
-                    throw new Error(`Unknown tool: ${name}`);
-            }
-
-            return { content: [{ type: 'text', text }] };
-        } catch (error) {
-            return {
-                content: [{ type: 'text', text: JSON.stringify({ error: error.message }) }],
-                isError: true,
-            };
-        }
-    });
-
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-
-    process.stderr.write('we-scrum MCP server running.\n');
-}

package/src/we-scrum.service.ts

@@ -1,107 +0,0 @@
-import { Command, serialize } from '@my-devkit/core';
-
-export class WeScrumService {
-    constructor(
-        private backendUrl: string,
-        private projectId: string,
-        private userId: string,
-    ) {}
-
-    // 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 async post<C extends Command, R>(route: string, command: C): Promise<R> {
-        const response = await fetch(`${this.backendUrl}/command/${route}`, {
-            method: 'POST',
-            body: JSON.stringify(serialize(command)),
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: 'Basic ' + Buffer.from(`${this.userId}:20V0anV4M!we`).toString('base64'),
-            },
-            signal: AbortSignal.timeout(60 * 1000),
-        });
-
-        const body = (await response.json()) as { result: R };
-        return body.result;
-    }
-}