cognitive-workflow-mcp 1.1.0

package/bin/cli.js

@@ -0,0 +1,286 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { analyzeCommits } from '../src/analyzer.js';
+import { generateDashboard } from '../src/generator.js';
+import { configureTerminals } from '../src/configurator.js';
+import { getInsights } from '../src/insights.js';
+import { readFile, access, copyFile, mkdir } from 'fs/promises';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(
+  await readFile(join(__dirname, '../package.json'), 'utf-8')
+);
+
+// ============================================================================
+// POSTINSTALL: Show welcome + open dashboard
+// ============================================================================
+if (process.argv.includes('--postinstall')) {
+  const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    blue: '\x1b[34m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    purple: '\x1b[35m',
+    cyan: '\x1b[36m',
+  };
+
+  console.log(`
+${colors.purple}${colors.bold}
+  ╔════════════════════════════════════════════════════════════╗
+  ║                                                            ║
+  ║   ████████╗██╗  ██╗███████╗████████╗ █████╗  ██████╗ ██████╗  ║
+  ║   ╚══██╔══╝██║  ██║██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔═══██╗ ║
+  ║      ██║   ███████║█████╗     ██║   ███████║██║     ██║   ██║ ║
+  ║      ██║   ██╔══██║██╔══╝     ██║   ██╔══██║██║     ██║   ██║ ║
+  ║      ██║   ██║  ██║███████╗   ██║   ██║  ██║╚██████╗╚██████╔╝ ║
+  ║      ╚═╝   ╚═╝  ╚═╝╚══════╝   ╚═╝   ╚═╝  ╚═╝ ╚═════╝ ╚═════╝  ║
+  ║                                                            ║
+  ║          Transform Your Terminal Into a Mental Palace      ║
+  ╚════════════════════════════════════════════════════════════╝
+${colors.reset}
+${colors.green}✓ Cognitive Workflow MCP installed successfully!${colors.reset}
+
+${colors.bold}The 6 Cognitive Identities:${colors.reset}
+
+  ${colors.blue}🔨 Builder${colors.reset}      feat, fix, refactor  → iTerm2
+  ${colors.yellow}🔍 Discoverer${colors.reset}   docs, research       → WezTerm
+  ${colors.green}⚙️  Operator${colors.reset}     chore, deploy, ops   → Kitty
+  ${colors.cyan}📚 Teacher${colors.reset}      blog, content        → Terminal
+  ${colors.purple}🎯 Strategist${colors.reset}   strategy, planning   → VS Code
+  ${colors.purple}🧪 Experimenter${colors.reset} experiment, poc      → Cursor
+
+${colors.bold}Quick Start:${colors.reset}
+
+  ${colors.cyan}cognitive-workflow analyze${colors.reset}    Analyze your git commits
+  ${colors.cyan}cognitive-workflow generate${colors.reset}   Generate dashboard HTML
+  ${colors.cyan}cognitive-workflow dashboard${colors.reset}  Open included dashboard
+
+${colors.bold}The Principle:${colors.reset} Tool = Identity = Mindset
+
+${colors.bold}Learn more:${colors.reset} ${colors.cyan}https://thetacoach.biz/thetacog${colors.reset}
+`);
+
+  // Copy bundled dashboard to .workflow if it doesn't exist
+  const bundledDashboard = join(__dirname, '../.workflow/cognitive-dashboard-enhanced.html');
+  const localWorkflow = join(process.cwd(), '.workflow');
+  const localDashboard = join(localWorkflow, 'cognitive-dashboard.html');
+
+  if (existsSync(bundledDashboard) && !existsSync(localDashboard)) {
+    try {
+      await mkdir(localWorkflow, { recursive: true });
+      await copyFile(bundledDashboard, localDashboard);
+      console.log(`${colors.green}✓ Dashboard copied to .workflow/cognitive-dashboard.html${colors.reset}\n`);
+    } catch (e) {
+      // Silent fail - user can run generate command
+    }
+  }
+
+  process.exit(0);
+}
+
+const program = new Command();
+
+program
+  .name('cognitive-workflow')
+  .description('Manage identity-based cognitive workflows with terminal integration')
+  .version(packageJson.version);
+
+program
+  .command('analyze')
+  .description('Analyze git commit history and categorize by cognitive identity')
+  .option('-d, --days <number>', 'Days of history to analyze', '60')
+  .option('-o, --output <path>', 'Save results to file')
+  .action(async (options) => {
+    console.log('🔍 Analyzing commit history...\n');
+
+    const analysis = await analyzeCommits(parseInt(options.days));
+
+    console.log(`📊 Total commits: ${analysis.totalCommits}`);
+    console.log(`📅 Period: ${analysis.daysAnalyzed} days\n`);
+
+    console.log('🎯 Cognitive Identity Distribution:\n');
+    for (const [identity, data] of Object.entries(analysis.identities)) {
+      const emoji = getIdentityEmoji(identity);
+      console.log(`${emoji} ${capitalize(identity).padEnd(15)} ${data.commits} commits (${data.percentage}%)`);
+    }
+
+    console.log('\n💡 Insights:\n');
+    for (const insight of analysis.insights) {
+      console.log(`  • ${insight.message}`);
+    }
+
+    if (options.output) {
+      const { writeFile } = await import('fs/promises');
+      await writeFile(options.output, JSON.stringify(analysis, null, 2));
+      console.log(`\n✅ Results saved to ${options.output}`);
+    }
+  });
+
+program
+  .command('generate')
+  .description('Generate HTML dashboard and room pages')
+  .option('-o, --output <directory>', 'Output directory', '.workflow')
+  .option('--no-open', 'Do not open dashboard after generation')
+  .action(async (options) => {
+    console.log('🎨 Generating cognitive workflow dashboard...\n');
+
+    const result = await generateDashboard(options.output, options.open);
+
+    console.log('✅ Generated files:');
+    for (const file of result.filesCreated) {
+      console.log(`  • ${file}`);
+    }
+
+    if (options.open) {
+      console.log(`\n🌐 Opening dashboard: ${result.dashboardUrl}`);
+    }
+  });
+
+program
+  .command('configure')
+  .description('Configure terminal application mappings')
+  .action(async () => {
+    console.log('⚙️  Configuring terminal mappings...\n');
+
+    // Interactive configuration (would use inquirer or prompts)
+    console.log('This would open an interactive configurator.');
+    console.log('For now, edit .cognitive-workflow.json manually.');
+  });
+
+program
+  .command('insights')
+  .description('Get insights about your cognitive work patterns')
+  .action(async () => {
+    console.log('💡 Analyzing work patterns...\n');
+
+    const insights = await getInsights(true);
+
+    console.log(`🎯 Dominant Identity: ${capitalize(insights.dominantIdentity)}`);
+    console.log(`⚖️  Balance Score: ${(insights.balanceScore * 100).toFixed(0)}%\n`);
+
+    if (insights.recommendations.length > 0) {
+      console.log('📋 Recommendations:\n');
+      for (const rec of insights.recommendations) {
+        console.log(`  • ${rec}`);
+      }
+    }
+  });
+
+program
+  .command('open')
+  .description('Open the cognitive workflow dashboard (local .workflow folder)')
+  .action(async () => {
+    const dashboardPath = join(process.cwd(), '.workflow', 'cognitive-dashboard.html');
+    openFile(dashboardPath);
+  });
+
+program
+  .command('dashboard')
+  .description('Open the bundled cognitive dashboard (included with package)')
+  .option('-r, --room <name>', 'Open specific room (builder, discoverer, operator, teacher, strategist, experimenter)')
+  .action(async (options) => {
+    const workflowDir = join(__dirname, '../.workflow');
+
+    let file = 'cognitive-dashboard-enhanced.html';
+    if (options.room) {
+      const room = options.room.toLowerCase();
+      const validRooms = ['builder', 'discoverer', 'operator', 'teacher', 'strategist', 'experimenter'];
+      if (validRooms.includes(room)) {
+        file = `bucket-${room}.html`;
+      } else {
+        console.error(`❌ Unknown room: ${room}`);
+        console.log(`   Valid rooms: ${validRooms.join(', ')}`);
+        process.exit(1);
+      }
+    }
+
+    const dashboardPath = join(workflowDir, file);
+
+    if (!existsSync(dashboardPath)) {
+      console.error(`❌ Dashboard not found: ${dashboardPath}`);
+      console.log('   Opening web version instead...');
+      openFile('https://thetacoach.biz/thetacog');
+      return;
+    }
+
+    console.log(`🌐 Opening ${options.room ? `${options.room} room` : 'dashboard'}...`);
+    openFile(dashboardPath);
+  });
+
+program
+  .command('rooms')
+  .description('List all cognitive rooms/identities')
+  .action(() => {
+    console.log(`
+🏗️  The 6 Cognitive Identities (Rooms)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  🔨 Builder       "I am building. I am shipping. I am solving."
+                   Triggers: feat, fix, refactor, perf
+                   Terminal: iTerm2
+
+  🔍 Discoverer    "I am exploring. I am researching. I am learning."
+                   Triggers: docs, research, analysis
+                   Terminal: WezTerm
+
+  ⚙️  Operator      "I am executing. I am deploying. I am maintaining."
+                   Triggers: chore, deploy, ops
+                   Terminal: Kitty
+
+  📚 Teacher       "I am explaining. I am teaching. I am sharing."
+                   Triggers: blog, content, tutorial
+                   Terminal: Terminal.app
+
+  🎯 Strategist    "I am positioning. I am planning. I am deciding."
+                   Triggers: strategy, planning
+                   Terminal: VS Code
+
+  🧪 Experimenter  "I am testing. I am prototyping. I am breaking."
+                   Triggers: experiment, prototype, poc
+                   Terminal: Cursor
+
+Open a specific room:
+  cognitive-workflow dashboard --room builder
+  cognitive-workflow dashboard --room discoverer
+`);
+  });
+
+program.parse();
+
+function openFile(path) {
+  try {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+      execSync(`open "${path}"`);
+    } else if (platform === 'win32') {
+      execSync(`start "" "${path}"`);
+    } else {
+      execSync(`xdg-open "${path}" || sensible-browser "${path}"`);
+    }
+  } catch (error) {
+    console.log(`Open this URL in your browser:\n  ${path}`);
+  }
+}
+
+function getIdentityEmoji(identity) {
+  const emojis = {
+    builder: '🏗️',
+    discoverer: '🔬',
+    operator: '🎩',
+    teacher: '📣',
+    strategist: '🗺️',
+    experimenter: '🧪'
+  };
+  return emojis[identity] || '📌';
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "cognitive-workflow-mcp",
+  "version": "1.1.0",
+  "description": "Transform your terminal into a mental palace. Cognitive workspaces that ground your workflow through git commit analysis. Tool = Identity = Mindset.",
+  "main": "src/index.js",
+  "bin": {
+    "cognitive-workflow": "bin/cli.js",
+    "thetacog": "bin/cli.js"
+  },
+  "type": "module",
+  "files": [
+    "src/",
+    "bin/",
+    ".workflow/",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node src/index.js",
+    "cli": "node bin/cli.js",
+    "dashboard": "node bin/cli.js dashboard",
+    "postinstall": "node bin/cli.js --postinstall",
+    "test": "node --test src/**/*.test.js"
+  },
+  "keywords": [
+    "mcp",
+    "cognitive-workflow",
+    "terminal",
+    "identity",
+    "mental-palace",
+    "productivity",
+    "git-analysis",
+    "commit-categorization",
+    "thetacog",
+    "thetacoach",
+    "fim",
+    "claude"
+  ],
+  "author": "ThetaDriven <elias@thetadriven.com>",
+  "license": "MIT",
+  "homepage": "https://thetacoach.biz/thetacog",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.5.0",
+    "simple-git": "^3.25.0",
+    "commander": "^12.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wiber/thetadrivencoach.git",
+    "directory": "packages/cognitive-workflow-mcp"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/analyzer.js

@@ -0,0 +1,194 @@
+import simpleGit from 'simple-git';
+
+/**
+ * Identity patterns for commit categorization
+ */
+const IDENTITY_PATTERNS = {
+  builder: {
+    keywords: ['feat', 'fix', 'refactor', 'perf', 'build', 'style', 'ui', 'component'],
+    paths: ['src/', 'lib/', 'components/', 'pages/', 'app/'],
+    description: 'Hands-on implementation and feature building'
+  },
+  discoverer: {
+    keywords: ['docs', 'research', 'analysis', 'study', 'investigate', 'explore', 'book'],
+    paths: ['docs/', 'research/', 'notes/', 'books/', 'papers/'],
+    description: 'Deep research and first principles thinking'
+  },
+  operator: {
+    keywords: ['chore', 'deploy', 'ops', 'ci', 'cd', 'release', 'config', 'env'],
+    paths: ['config/', '.github/', 'scripts/', 'deploy/'],
+    description: 'Operations, deployment, and business management'
+  },
+  teacher: {
+    keywords: ['blog', 'content', 'tutorial', 'guide', 'example', 'demo', 'explain'],
+    paths: ['blog/', 'content/', 'examples/', 'tutorials/'],
+    description: 'Teaching, content creation, and public communication'
+  },
+  strategist: {
+    keywords: ['strategy', 'planning', 'positioning', 'marketing', 'competitor', 'market'],
+    paths: ['strategy/', 'planning/', 'marketing/'],
+    description: 'Strategic planning and competitive analysis'
+  },
+  experimenter: {
+    keywords: ['experiment', 'prototype', 'poc', 'test', 'try', 'spike', 'wip'],
+    paths: ['experiments/', 'prototypes/', 'playground/'],
+    description: 'Rapid prototyping and hypothesis testing'
+  }
+};
+
+/**
+ * Analyzes git commit history and categorizes commits by cognitive identity
+ *
+ * @param {number} daysBack - Number of days of history to analyze
+ * @returns {Promise<Object>} Analysis results with commit categorization
+ */
+export async function analyzeCommits(daysBack = 60) {
+  const git = simpleGit();
+
+  // Get commit history
+  const since = new Date(Date.now() - daysBack * 24 * 60 * 60 * 1000).toISOString();
+  const log = await git.log(['--since', since, '--all']);
+
+  const commits = log.all;
+  const totalCommits = commits.length;
+
+  // Categorize commits
+  const categorized = {
+    builder: [],
+    discoverer: [],
+    operator: [],
+    teacher: [],
+    strategist: [],
+    experimenter: []
+  };
+
+  for (const commit of commits) {
+    const message = commit.message.toLowerCase();
+    const identity = categorizeCommit(commit, message);
+    categorized[identity].push(commit);
+  }
+
+  // Calculate statistics
+  const identities = {};
+  for (const [identity, commits] of Object.entries(categorized)) {
+    const count = commits.length;
+    const percentage = Math.round((count / totalCommits) * 100);
+    const commitsPerDay = (count / daysBack).toFixed(2);
+
+    identities[identity] = {
+      commits: count,
+      percentage,
+      commitsPerDay: parseFloat(commitsPerDay),
+      description: IDENTITY_PATTERNS[identity].description,
+      recentCommits: commits.slice(0, 10).map(c => ({
+        hash: c.hash.substring(0, 8),
+        message: c.message,
+        date: c.date,
+        author: c.author_name
+      }))
+    };
+  }
+
+  // Sort identities by commit count
+  const sortedIdentities = Object.entries(identities)
+    .sort((a, b) => b[1].commits - a[1].commits)
+    .reduce((acc, [key, value]) => {
+      acc[key] = value;
+      return acc;
+    }, {});
+
+  // Generate insights
+  const insights = generateInsights(sortedIdentities, totalCommits);
+
+  return {
+    totalCommits,
+    daysAnalyzed: daysBack,
+    identities: sortedIdentities,
+    insights,
+    generatedAt: new Date().toISOString()
+  };
+}
+
+/**
+ * Categorizes a single commit into a cognitive identity
+ */
+function categorizeCommit(commit, messageLower) {
+  // Check each identity's patterns
+  for (const [identity, patterns] of Object.entries(IDENTITY_PATTERNS)) {
+    // Check keywords in message
+    const keywordMatch = patterns.keywords.some(kw => messageLower.includes(kw));
+
+    // Get changed files for this commit (if available)
+    const files = commit.diff?.files || [];
+    const pathMatch = files.some(file =>
+      patterns.paths.some(path => file.file.includes(path))
+    );
+
+    if (keywordMatch || pathMatch) {
+      return identity;
+    }
+  }
+
+  // Default to builder if no clear match
+  return 'builder';
+}
+
+/**
+ * Generates insights about work patterns
+ */
+function generateInsights(identities, totalCommits) {
+  const insights = [];
+
+  // Dominant identity
+  const dominant = Object.entries(identities)[0];
+  if (dominant) {
+    insights.push({
+      type: 'dominant',
+      message: `${capitalize(dominant[0])} is your dominant mode (${dominant[1].percentage}%)`,
+      identity: dominant[0]
+    });
+  }
+
+  // Balance score (how evenly distributed)
+  const percentages = Object.values(identities).map(i => i.percentage);
+  const idealPercentage = 100 / 6; // 16.67% if perfectly balanced
+  const balanceScore = 1 - (percentages.reduce((sum, p) => sum + Math.abs(p - idealPercentage), 0) / 100);
+
+  insights.push({
+    type: 'balance',
+    message: `Work balance score: ${(balanceScore * 100).toFixed(0)}%`,
+    score: balanceScore
+  });
+
+  // Underutilized identities
+  const underutilized = Object.entries(identities)
+    .filter(([_, data]) => data.percentage < 5)
+    .map(([identity]) => identity);
+
+  if (underutilized.length > 0) {
+    insights.push({
+      type: 'underutilized',
+      message: `Consider more ${underutilized.map(capitalize).join(', ')} time`,
+      identities: underutilized
+    });
+  }
+
+  // Productivity patterns
+  const highActivity = Object.entries(identities)
+    .filter(([_, data]) => data.commitsPerDay > 1)
+    .map(([identity]) => identity);
+
+  if (highActivity.length > 0) {
+    insights.push({
+      type: 'high-activity',
+      message: `High activity in ${highActivity.map(capitalize).join(', ')}`,
+      identities: highActivity
+    });
+  }
+
+  return insights;
+}
+
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/configurator.js

@@ -0,0 +1,63 @@
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+
+const CONFIG_FILE = '.cognitive-workflow.json';
+
+/**
+ * Configures terminal application mappings
+ *
+ * @param {Object} mappings - Terminal assignments per identity
+ * @returns {Promise<Object>} Configuration result
+ */
+export async function configureTerminals(mappings) {
+  const configPath = join(process.cwd(), CONFIG_FILE);
+
+  let config = {};
+
+  // Load existing config if it exists
+  try {
+    const existing = await readFile(configPath, 'utf-8');
+    config = JSON.parse(existing);
+  } catch (error) {
+    // File doesn't exist, start fresh
+  }
+
+  // Update terminal mappings
+  config.terminals = {
+    ...config.terminals,
+    ...mappings
+  };
+
+  // Save config
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+
+  return {
+    configured: true,
+    terminals: config.terminals,
+    configPath
+  };
+}
+
+/**
+ * Gets current terminal configuration
+ */
+export async function getTerminalConfig() {
+  const configPath = join(process.cwd(), CONFIG_FILE);
+
+  try {
+    const config = await readFile(configPath, 'utf-8');
+    return JSON.parse(config);
+  } catch (error) {
+    // Return defaults
+    return {
+      terminals: {
+        builder: 'iTerm2',
+        discoverer: 'WezTerm',
+        operator: 'Kitty',
+        teacher: 'Terminal',
+        strategist: 'VSCode',
+        experimenter: 'Cursor'
+      }
+    };
+  }
+}

package/src/generator.js

@@ -0,0 +1,65 @@
+import { mkdir, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { analyzeCommits } from './analyzer.js';
+import { getDashboardTemplate, getRoomTemplate } from './templates.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * Generates HTML dashboard and room pages
+ *
+ * @param {string} outputDir - Output directory path
+ * @param {boolean} openAfter - Whether to open dashboard after generation
+ * @returns {Promise<Object>} Generation results
+ */
+export async function generateDashboard(outputDir = '.workflow', openAfter = true) {
+  // Ensure output directory exists
+  await mkdir(outputDir, { recursive: true });
+
+  // Analyze commits
+  const analysis = await analyzeCommits(60);
+
+  // Generate central dashboard
+  const dashboardHtml = getDashboardTemplate(analysis);
+  const dashboardPath = join(outputDir, 'cognitive-dashboard.html');
+  await writeFile(dashboardPath, dashboardHtml);
+
+  const filesCreated = [dashboardPath];
+
+  // Generate room pages for each identity
+  const identities = ['builder', 'discoverer', 'operator', 'teacher', 'strategist', 'experimenter'];
+
+  for (const identity of identities) {
+    const identityData = analysis.identities[identity];
+    const roomHtml = getRoomTemplate(identity, identityData, analysis.totalCommits);
+    const roomPath = join(outputDir, `bucket-${identity}.html`);
+    await writeFile(roomPath, roomHtml);
+    filesCreated.push(roomPath);
+  }
+
+  const result = {
+    filesCreated,
+    dashboardUrl: `file://${join(process.cwd(), dashboardPath)}`,
+    analysis: {
+      totalCommits: analysis.totalCommits,
+      identities: Object.keys(analysis.identities).map(id => ({
+        name: id,
+        commits: analysis.identities[id].commits,
+        percentage: analysis.identities[id].percentage
+      }))
+    }
+  };
+
+  // Open dashboard if requested
+  if (openAfter) {
+    try {
+      await execAsync(`open "${join(process.cwd(), dashboardPath)}"`);
+    } catch (error) {
+      console.error('Could not open dashboard automatically:', error.message);
+    }
+  }
+
+  return result;
+}