cognitive-workflow-mcp 1.1.0

package/src/index.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+  ErrorCode,
+  McpError
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { analyzeCommits } from './analyzer.js';
+import { generateDashboard } from './generator.js';
+import { configureTerminals } from './configurator.js';
+import { getInsights } from './insights.js';
+
+/**
+ * Cognitive Workflow MCP Server
+ *
+ * Provides tools for analyzing git commits and generating
+ * identity-based cognitive workflow dashboards.
+ */
+class CognitiveWorkflowServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'cognitive-workflow-mcp',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupToolHandlers();
+
+    this.server.onerror = (error) => console.error('[MCP Error]', error);
+    process.on('SIGINT', async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: 'cognitive-analyze',
+          description: 'Analyze git commit history and categorize into 6 cognitive identities (Builder, Discoverer, Operator, Teacher, Strategist, Experimenter)',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              daysBack: {
+                type: 'number',
+                description: 'Number of days of commit history to analyze',
+                default: 60
+              },
+              outputPath: {
+                type: 'string',
+                description: 'Optional path to save analysis results'
+              }
+            }
+          }
+        },
+        {
+          name: 'cognitive-generate-dashboard',
+          description: 'Generate HTML dashboard and individual room pages for each cognitive identity',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              outputDir: {
+                type: 'string',
+                description: 'Output directory for generated files',
+                default: '.workflow'
+              },
+              openAfter: {
+                type: 'boolean',
+                description: 'Open dashboard in browser after generation',
+                default: true
+              }
+            }
+          }
+        },
+        {
+          name: 'cognitive-configure-terminals',
+          description: 'Configure terminal application mappings for each cognitive identity',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              mappings: {
+                type: 'object',
+                description: 'Map of identity names to terminal applications',
+                properties: {
+                  builder: { type: 'string' },
+                  discoverer: { type: 'string' },
+                  operator: { type: 'string' },
+                  teacher: { type: 'string' },
+                  strategist: { type: 'string' },
+                  experimenter: { type: 'string' }
+                }
+              }
+            },
+            required: ['mappings']
+          }
+        },
+        {
+          name: 'cognitive-get-insights',
+          description: 'Get insights about your cognitive work patterns and recommendations for better balance',
+          inputSchema: {
+            type: 'object',
+            properties: {
+              includeRecommendations: {
+                type: 'boolean',
+                description: 'Include actionable recommendations',
+                default: true
+              }
+            }
+          }
+        }
+      ]
+    }));
+
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        switch (request.params.name) {
+          case 'cognitive-analyze':
+            return await this.handleAnalyze(request.params.arguments);
+
+          case 'cognitive-generate-dashboard':
+            return await this.handleGenerateDashboard(request.params.arguments);
+
+          case 'cognitive-configure-terminals':
+            return await this.handleConfigureTerminals(request.params.arguments);
+
+          case 'cognitive-get-insights':
+            return await this.handleGetInsights(request.params.arguments);
+
+          default:
+            throw new McpError(
+              ErrorCode.MethodNotFound,
+              `Unknown tool: ${request.params.name}`
+            );
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `Error: ${error.message}\n\nStack: ${error.stack}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+  }
+
+  async handleAnalyze(args) {
+    const { daysBack = 60, outputPath } = args || {};
+
+    const analysis = await analyzeCommits(daysBack);
+
+    if (outputPath) {
+      const fs = await import('fs/promises');
+      await fs.writeFile(outputPath, JSON.stringify(analysis, null, 2));
+    }
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(analysis, null, 2)
+        }
+      ]
+    };
+  }
+
+  async handleGenerateDashboard(args) {
+    const { outputDir = '.workflow', openAfter = true } = args || {};
+
+    const result = await generateDashboard(outputDir, openAfter);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  }
+
+  async handleConfigureTerminals(args) {
+    const { mappings } = args;
+
+    const result = await configureTerminals(mappings);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  }
+
+  async handleGetInsights(args) {
+    const { includeRecommendations = true } = args || {};
+
+    const insights = await getInsights(includeRecommendations);
+
+    return {
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(insights, null, 2)
+        }
+      ]
+    };
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('Cognitive Workflow MCP server running on stdio');
+  }
+}
+
+const server = new CognitiveWorkflowServer();
+server.run().catch(console.error);

package/src/insights.js

@@ -0,0 +1,127 @@
+import { analyzeCommits } from './analyzer.js';
+
+/**
+ * Generates insights about cognitive work patterns
+ *
+ * @param {boolean} includeRecommendations - Whether to include recommendations
+ * @returns {Promise<Object>} Insights and recommendations
+ */
+export async function getInsights(includeRecommendations = true) {
+  const analysis = await analyzeCommits(60);
+
+  const identitiesArray = Object.entries(analysis.identities);
+  const dominantIdentity = identitiesArray[0][0];
+
+  // Calculate balance score
+  const percentages = identitiesArray.map(([_, data]) => data.percentage);
+  const idealPercentage = 100 / 6;
+  const balanceScore = 1 - (percentages.reduce((sum, p) => sum + Math.abs(p - idealPercentage), 0) / 100);
+
+  const insights = {
+    dominantIdentity,
+    balanceScore,
+    identityDistribution: identitiesArray.map(([id, data]) => ({
+      identity: id,
+      commits: data.commits,
+      percentage: data.percentage,
+      commitsPerDay: data.commitsPerDay
+    })),
+    trends: analyzeTrends(identitiesArray)
+  };
+
+  if (includeRecommendations) {
+    insights.recommendations = generateRecommendations(identitiesArray, balanceScore);
+  }
+
+  return insights;
+}
+
+/**
+ * Analyzes trends in identity usage
+ */
+function analyzeTrends(identitiesArray) {
+  const trends = {};
+
+  // Identify increasing/decreasing patterns
+  // (Would require historical data to properly implement)
+
+  // For now, just flag extremes
+  for (const [identity, data] of identitiesArray) {
+    if (data.percentage > 40) {
+      trends[`${identity}High`] = true;
+    }
+    if (data.percentage < 5) {
+      trends[`${identity}Low`] = true;
+    }
+  }
+
+  return trends;
+}
+
+/**
+ * Generates actionable recommendations
+ */
+function generateRecommendations(identitiesArray, balanceScore) {
+  const recommendations = [];
+
+  // Low balance score
+  if (balanceScore < 0.6) {
+    recommendations.push(
+      `Work is concentrated in ${identitiesArray[0][0]} (${identitiesArray[0][1].percentage}%). Consider distributing effort across more identities.`
+    );
+  }
+
+  // Underutilized identities
+  const underutilized = identitiesArray.filter(([_, data]) => data.percentage < 5);
+  if (underutilized.length > 0) {
+    for (const [identity] of underutilized) {
+      recommendations.push(
+        `${capitalize(identity)} is underutilized (${identitiesArray.find(([id]) => id === identity)[1].percentage}%). ${getIdentityRecommendation(identity)}`
+      );
+    }
+  }
+
+  // Dominant identity warnings
+  const [dominantId, dominantData] = identitiesArray[0];
+  if (dominantData.percentage > 50) {
+    recommendations.push(
+      `${capitalize(dominantId)} dominance may indicate tunnel vision. Schedule dedicated time for other identities.`
+    );
+  }
+
+  // Specific identity recommendations
+  const strategistData = identitiesArray.find(([id]) => id === 'strategist');
+  if (strategistData && strategistData[1].percentage < 10) {
+    recommendations.push(
+      'Low strategic thinking detected. Block time for market analysis and competitive positioning.'
+    );
+  }
+
+  const experimenterData = identitiesArray.find(([id]) => id === 'experimenter');
+  if (experimenterData && experimenterData[1].percentage < 5) {
+    recommendations.push(
+      'Low experimentation rate. Consider rapid prototyping sessions before committing to implementations.'
+    );
+  }
+
+  return recommendations;
+}
+
+/**
+ * Gets specific recommendation for an identity
+ */
+function getIdentityRecommendation(identity) {
+  const recommendations = {
+    builder: 'Schedule focused implementation sessions with iTerm2.',
+    discoverer: 'Block time for deep research with WezTerm.',
+    operator: 'Review operations dashboard and handle administrative tasks with Kitty.',
+    teacher: 'Write documentation or blog content with Terminal.',
+    strategist: 'Analyze market trends and competitive landscape with VS Code.',
+    experimenter: 'Run quick prototyping sessions with Cursor.'
+  };
+  return recommendations[identity] || 'Consider dedicating time to this mode.';
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}