@dobbyai/mcp-external 1.0.3 → 1.1.0

package/dist/tools/workflow.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Workflow Automation MCP Tools
+ *
+ * Phase 2: Intelligent task routing and auto-assignment.
+ * Provides tools for task classification, agent workload monitoring,
+ * and automated/manual assignment through the Dobby platform.
+ */
+import { DobbyClient } from '../lib/dobby-client.js';
+export declare const workflowTools: {
+    workflow_classify_task: {
+        name: string;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                title: {
+                    type: string;
+                    description: string;
+                };
+                description: {
+                    type: string;
+                    description: string;
+                };
+                priority: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    workflow_auto_assign: {
+        name: string;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                task_id: {
+                    type: string;
+                    description: string;
+                    pattern: string;
+                };
+                title: {
+                    type: string;
+                    description: string;
+                };
+                description: {
+                    type: string;
+                    description: string;
+                };
+                priority: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    workflow_agent_workload: {
+        name: string;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                agent_layer: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+        };
+    };
+    workflow_assignment_rules: {
+        name: string;
+        annotations: {
+            title: string;
+            readOnlyHint: boolean;
+            destructiveHint: boolean;
+            openWorldHint: boolean;
+        };
+        description: string;
+        inputSchema: {
+            type: "object";
+            properties: {
+                active_only: {
+                    type: string;
+                    description: string;
+                };
+            };
+        };
+    };
+};
+export declare function handleWorkflowClassifyTask(client: DobbyClient, args: {
+    title: string;
+    description?: string;
+    priority?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function handleWorkflowAutoAssign(client: DobbyClient, args: {
+    task_id: string;
+    title: string;
+    description?: string;
+    priority?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;
+export declare function handleWorkflowAgentWorkload(client: DobbyClient, args: {
+    agent_layer?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;
+export declare function handleWorkflowAssignmentRules(client: DobbyClient, args: {
+    active_only?: boolean;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;
+//# sourceMappingURL=workflow.d.ts.map

package/dist/tools/workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/tools/workflow.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAkJrD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0GzB,CAAC;AAuFF,wBAAsB,0BAA0B,CAC9C,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;GA2BjE;AAqBD,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;GA6FlF;AAmCD,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE;IAAE,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;GA2C/B;AAED,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE;IAAE,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;;;;;;;GA6ChC"}

package/dist/tools/workflow.js

@@ -0,0 +1,518 @@
+/**
+ * Workflow Automation MCP Tools
+ *
+ * Phase 2: Intelligent task routing and auto-assignment.
+ * Provides tools for task classification, agent workload monitoring,
+ * and automated/manual assignment through the Dobby platform.
+ */
+// ============================================
+// Task Category Definitions (mirrors Python)
+// ============================================
+const CATEGORY_KEYWORDS = {
+    backend: [
+        'api', 'endpoint', 'route', 'fastapi', 'server', 'backend',
+        'middleware', 'handler', 'service', 'controller', 'python',
+        'async', 'uvicorn', 'pydantic',
+    ],
+    frontend: [
+        'ui', 'frontend', 'react', 'component', 'page', 'layout',
+        'css', 'tailwind', 'next.js', 'nextjs', 'html', 'form',
+        'modal', 'dialog', 'button', 'sidebar', 'dashboard',
+    ],
+    api: [
+        'rest', 'graphql', 'webhook', 'cors', 'openapi', 'swagger',
+        'rate limit', 'throttle', 'api route', 'api key',
+    ],
+    database: [
+        'bigquery', 'sql', 'query', 'migration', 'schema', 'table',
+        'column', 'index', 'partition', 'cluster', 'database',
+    ],
+    security: [
+        'auth', 'authentication', 'authorization', 'sso', 'saml',
+        'oidc', 'oauth', 'token', 'permission', 'rbac', 'encrypt',
+        'vulnerability', 'security', 'xss', 'csrf', 'injection',
+    ],
+    testing: [
+        'test', 'vitest', 'pytest', 'e2e', 'playwright', 'coverage',
+        'mock', 'fixture', 'assertion', 'spec', 'unit test',
+    ],
+    devops: [
+        'deploy', 'ci/cd', 'docker', 'kubernetes', 'helm', 'github actions',
+        'pipeline', 'build', 'release', 'monitoring', 'logging',
+    ],
+    docs: [
+        'documentation', 'readme', 'docs', 'comment', 'jsdoc',
+        'docstring', 'guide', 'tutorial', 'changelog',
+    ],
+    planning: [
+        'plan', 'design', 'architecture', 'roadmap', 'requirement',
+        'spec', 'rfc', 'adr', 'decision',
+    ],
+    refactor: [
+        'refactor', 'cleanup', 'technical debt', 'optimize',
+        'performance', 'simplify', 'restructure', 'modernize',
+    ],
+};
+let categoryAgentMapCache = null;
+let categoryAgentMapCacheTime = 0;
+const CATEGORY_MAP_CACHE_TTL = 5 * 60 * 1000; // 5 minutes
+function getDefaultCategoryAgentMap() {
+    return {
+        backend: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-backend-agent' },
+        frontend: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-frontend-agent' },
+        api: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-api-agent' },
+        database: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-database-agent' },
+        security: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-security-agent' },
+        testing: { coordinator: 'dobby-qa-lead-agent', worker: 'dobby-test-writer-agent' },
+        devops: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-devops-agent' },
+        docs: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-docs-agent' },
+        planning: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-planning-agent' },
+        refactor: { coordinator: 'dobby-dev-coordinator-agent', worker: 'dobby-refactor-agent' },
+    };
+}
+const AGENT_NAME_TO_CATEGORY = {
+    'backend': ['backend'],
+    'frontend': ['frontend'],
+    'api': ['api'],
+    'database': ['database'],
+    'security': ['security'],
+    'test-writer': ['testing'],
+    'devops': ['devops'],
+    'docs': ['docs'],
+    'planning': ['planning'],
+    'refactor': ['refactor'],
+};
+async function getCategoryAgentMap(client) {
+    const now = Date.now();
+    if (categoryAgentMapCache && (now - categoryAgentMapCacheTime) < CATEGORY_MAP_CACHE_TTL) {
+        return categoryAgentMapCache;
+    }
+    try {
+        const data = await client.request(`/api/v1/tenants/${client.tenantId}/unified-agents`);
+        const agents = data?.data?.agents || data?.agents || [];
+        const map = { ...getDefaultCategoryAgentMap() };
+        for (const agent of agents) {
+            const agentId = agent.agent_id || agent.unified_id || '';
+            const layer = agent.agent_layer || '';
+            const group = agent.group || '';
+            // Map coordinators by group
+            if (layer === 'coordinator') {
+                for (const [category, agentMap] of Object.entries(map)) {
+                    if (group === 'qa' && category === 'testing') {
+                        agentMap.coordinator = agentId;
+                    }
+                    else if (group === 'dev' && category !== 'testing') {
+                        agentMap.coordinator = agentId;
+                    }
+                }
+            }
+            // Map workers by name matching
+            if (layer === 'worker') {
+                for (const [nameFragment, categories] of Object.entries(AGENT_NAME_TO_CATEGORY)) {
+                    if (agentId.includes(nameFragment)) {
+                        for (const cat of categories) {
+                            if (map[cat]) {
+                                map[cat].worker = agentId;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        categoryAgentMapCache = map;
+        categoryAgentMapCacheTime = now;
+        return map;
+    }
+    catch {
+        return getDefaultCategoryAgentMap();
+    }
+}
+// ============================================
+// Tool Definitions
+// ============================================
+export const workflowTools = {
+    workflow_classify_task: {
+        name: 'workflow_classify_task',
+        annotations: {
+            title: 'Classify Task',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'Classify a task and get an auto-assignment suggestion. Analyzes task title and description to determine the best agent. Does NOT execute the assignment — use workflow_auto_assign to apply.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Task title to classify',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional: Task description for better classification',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high'],
+                    description: 'Task priority (default: medium)',
+                },
+            },
+            required: ['title'],
+        },
+    },
+    workflow_auto_assign: {
+        name: 'workflow_auto_assign',
+        annotations: {
+            title: 'Auto-Assign Task',
+            readOnlyHint: false,
+            destructiveHint: true,
+            openWorldHint: false,
+        },
+        description: 'Auto-assign a task to the best agent based on classification and workload. Calls the Dobby API to execute the assignment.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                task_id: {
+                    type: 'string',
+                    description: 'Task ID to assign (format: task_xxxxx)',
+                    pattern: '^task_[a-zA-Z0-9_-]+$',
+                },
+                title: {
+                    type: 'string',
+                    description: 'Task title (used for classification if not already classified)',
+                },
+                description: {
+                    type: 'string',
+                    description: 'Optional: Task description',
+                },
+                priority: {
+                    type: 'string',
+                    enum: ['low', 'medium', 'high'],
+                    description: 'Task priority (default: medium)',
+                },
+            },
+            required: ['task_id', 'title'],
+        },
+    },
+    workflow_agent_workload: {
+        name: 'workflow_agent_workload',
+        annotations: {
+            title: 'Agent Workload',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'View current agent workload across the team. Shows active tasks, availability, and success rates.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                agent_layer: {
+                    type: 'string',
+                    enum: ['coordinator', 'worker', 'all'],
+                    description: 'Filter by agent layer (default: all)',
+                },
+            },
+        },
+    },
+    workflow_assignment_rules: {
+        name: 'workflow_assignment_rules',
+        annotations: {
+            title: 'Assignment Rules',
+            readOnlyHint: true,
+            destructiveHint: false,
+            openWorldHint: false,
+        },
+        description: 'List configured assignment rules for the current tenant. Rules override default keyword-based routing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                active_only: {
+                    type: 'boolean',
+                    description: 'Only show active rules (default: true)',
+                },
+            },
+        },
+    },
+};
+async function classifyTask(client, title, description = '', _priority = 'medium') {
+    const text = `${title} ${description}`.toLowerCase();
+    const agentMap = await getCategoryAgentMap(client);
+    const scores = {};
+    for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+        const matched = [];
+        for (const kw of keywords) {
+            const pattern = new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+            if (pattern.test(text)) {
+                matched.push(kw);
+            }
+        }
+        if (matched.length > 0) {
+            let score = matched.length / keywords.length;
+            // Boost for title matches
+            const titleLower = title.toLowerCase();
+            const titleMatches = matched.filter(kw => {
+                const pat = new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+                return pat.test(titleLower);
+            }).length;
+            if (titleMatches > 0) {
+                score += titleMatches * 0.15;
+            }
+            scores[category] = { score: Math.min(score, 1.0), matched };
+        }
+    }
+    const defaultMap = agentMap['backend'] || getDefaultCategoryAgentMap()['backend'];
+    if (Object.keys(scores).length === 0) {
+        return {
+            category: 'backend',
+            subcategory: null,
+            confidence: 0.3,
+            matched_keywords: [],
+            suggested_coordinator: defaultMap.coordinator,
+            suggested_worker: defaultMap.worker,
+            reasoning: 'No keywords matched — defaulting to backend development agent.',
+        };
+    }
+    const bestCategory = Object.entries(scores).reduce((best, [cat, data]) => data.score > best[1].score ? [cat, data] : best)[0];
+    const { score: confidence, matched } = scores[bestCategory];
+    const categoryMapping = agentMap[bestCategory] || defaultMap;
+    return {
+        category: bestCategory,
+        subcategory: matched[0] || null,
+        confidence,
+        matched_keywords: matched.slice(0, 10),
+        suggested_coordinator: categoryMapping.coordinator,
+        suggested_worker: categoryMapping.worker,
+        reasoning: `Task classified as '${bestCategory}' (confidence: ${(confidence * 100).toFixed(0)}%). Matched keywords: ${matched.slice(0, 5).join(', ')}. Suggested: ${categoryMapping.worker} under ${categoryMapping.coordinator}.`,
+    };
+}
+// ============================================
+// Tool Handlers
+// ============================================
+export async function handleWorkflowClassifyTask(client, args) {
+    const classification = await classifyTask(client, args.title, args.description || '', args.priority || 'medium');
+    let text = '## Task Classification\n\n';
+    text += `**Category:** ${classification.category}\n`;
+    text += `**Confidence:** ${(classification.confidence * 100).toFixed(0)}%\n`;
+    text += `**Coordinator:** ${classification.suggested_coordinator}\n`;
+    text += `**Worker:** ${classification.suggested_worker}\n`;
+    if (classification.matched_keywords.length > 0) {
+        text += `\n### Matched Keywords\n- ${classification.matched_keywords.join(', ')}\n`;
+    }
+    text += `\n### Next Steps\n1. Use \`workflow_auto_assign\` to execute this assignment\n`;
+    return {
+        content: [{
+                type: 'text',
+                text,
+            }],
+    };
+}
+/**
+ * Helper to call Dobby API using the client's config.
+ * Uses global fetch (not client.fetch which is private).
+ */
+async function dobbyApiFetch(client, endpoint, options = {}) {
+    return fetch(`${client.apiUrl}${endpoint}`, {
+        ...options,
+        headers: {
+            'Content-Type': 'application/json',
+            'X-API-Key': client.apiKey,
+            ...options.headers,
+        },
+    });
+}
+export async function handleWorkflowAutoAssign(client, args) {
+    // First classify with dynamic agent map
+    const classification = await classifyTask(client, args.title, args.description || '', args.priority || 'medium');
+    // Check agent health before assignment (Task 3.5)
+    let healthWarning = null;
+    try {
+        const healthResponse = await dobbyApiFetch(client, `/api/v1/tenants/${client.tenantId}/unified-agents/${classification.suggested_worker}/health`);
+        if (healthResponse.ok) {
+            const health = await healthResponse.json();
+            const agentStatus = health.agent_status || health.status;
+            if (agentStatus === 'paused' || agentStatus === 'blocked') {
+                healthWarning = `${classification.suggested_worker} is ${agentStatus}.`;
+                // Try to find a healthy alternative in same category
+                const agentMap = await getCategoryAgentMap(client);
+                for (const [, mapping] of Object.entries(agentMap)) {
+                    if (mapping.worker !== classification.suggested_worker) {
+                        classification.suggested_worker = mapping.worker;
+                        healthWarning += ` Routing to ${mapping.worker} instead.`;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Health check failed — proceed with suggestion anyway
+    }
+    // Call Dobby API to execute assignment
+    try {
+        const response = await dobbyApiFetch(client, `/api/v1/tasks/${args.task_id}/auto-assign`, {
+            method: 'POST',
+            body: JSON.stringify({
+                title: args.title,
+                description: args.description || '',
+                priority: args.priority || 'medium',
+                suggested_coordinator: classification.suggested_coordinator,
+                suggested_worker: classification.suggested_worker,
+                classification,
+            }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                content: [{
+                        type: 'text',
+                        text: formatAutoAssignResult({
+                            status: 'error',
+                            error: `API error (${response.status}): ${errorText.slice(0, 200)}`,
+                            classification,
+                            health_warning: healthWarning,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        const result = await response.json();
+        return {
+            content: [{
+                    type: 'text',
+                    text: formatAutoAssignResult({
+                        status: 'assigned',
+                        ...result,
+                        classification,
+                        health_warning: healthWarning,
+                    }),
+                }],
+        };
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        return {
+            content: [{
+                    type: 'text',
+                    text: formatAutoAssignResult({
+                        status: 'suggestion_only',
+                        note: `Could not reach Dobby API (${errMsg}). Returning local classification.`,
+                        classification,
+                        health_warning: healthWarning,
+                    }),
+                }],
+        };
+    }
+}
+function formatAutoAssignResult(data) {
+    const classification = data.classification;
+    const status = data.status;
+    const healthWarning = data.health_warning;
+    let text = '## Auto-Assignment Result\n\n';
+    text += `**Status:** ${status}\n`;
+    if (healthWarning) {
+        text += `**Health Warning:** ${healthWarning}\n`;
+    }
+    if (classification) {
+        text += `**Category:** ${classification.category}\n`;
+        text += `**Coordinator:** ${classification.suggested_coordinator}\n`;
+        text += `**Worker:** ${classification.suggested_worker}\n`;
+        text += `**Confidence:** ${(classification.confidence * 100).toFixed(0)}%\n`;
+    }
+    if (data.error) {
+        text += `\n### Error\n${data.error}\n`;
+    }
+    if (data.note) {
+        text += `\n### Note\n${data.note}\n`;
+    }
+    if (classification?.matched_keywords && classification.matched_keywords.length > 0) {
+        text += `\n### Matched Keywords\n- ${classification.matched_keywords.join(', ')}\n`;
+    }
+    return text;
+}
+export async function handleWorkflowAgentWorkload(client, args) {
+    try {
+        const layer = args.agent_layer || 'all';
+        const response = await dobbyApiFetch(client, `/api/v1/agents/workload?layer=${layer}`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `API error (${response.status}): ${errorText.slice(0, 200)}`,
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+        const data = await response.json();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(data, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        const agentMap = await getCategoryAgentMap(client);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        note: `Could not reach Dobby API (${errMsg}). Showing agent hierarchy.`,
+                        agents: Object.entries(agentMap).map(([category, agents]) => ({
+                            category,
+                            coordinator: agents.coordinator,
+                            worker: agents.worker,
+                        })),
+                    }, null, 2),
+                }],
+        };
+    }
+}
+export async function handleWorkflowAssignmentRules(client, args) {
+    try {
+        const activeOnly = args.active_only !== false;
+        const response = await dobbyApiFetch(client, `/api/v1/workflow/assignment-rules?active_only=${activeOnly}`);
+        if (!response.ok) {
+            const errorText = await response.text();
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            error: `API error (${response.status}): ${errorText.slice(0, 200)}`,
+                        }, null, 2),
+                    }],
+                isError: true,
+            };
+        }
+        const data = await response.json();
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify(data, null, 2),
+                }],
+        };
+    }
+    catch (error) {
+        const errMsg = error instanceof Error ? error.message : 'Unknown error';
+        const agentMap = await getCategoryAgentMap(client);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        note: `Could not reach Dobby API (${errMsg}). No rules available offline.`,
+                        rules: [],
+                        default_routing: Object.entries(agentMap).map(([category, agents]) => ({
+                            category,
+                            coordinator: agents.coordinator,
+                            worker: agents.worker,
+                            type: 'default',
+                        })),
+                    }, null, 2),
+                }],
+        };
+    }
+}
+//# sourceMappingURL=workflow.js.map