chati-dev 1.0.0

package/src/config/mcp-configs.js

@@ -0,0 +1,136 @@
+/**
+ * MCP Registry and Configuration
+ * Defines available MCPs and their agent dependencies
+ */
+export const MCP_CONFIGS = {
+  browser: {
+    name: 'Browser (Playwright)',
+    description: 'Web automation and testing',
+    defaultSelected: true,
+    requiresEnv: [],
+    claudeConfig: {
+      command: 'npx',
+      args: ['-y', '@playwright/mcp'],
+    },
+  },
+  context7: {
+    name: 'Context7',
+    description: 'Library documentation search',
+    defaultSelected: true,
+    requiresEnv: [],
+    claudeConfig: {
+      command: 'npx',
+      args: ['-y', '@context7/mcp'],
+    },
+  },
+  exa: {
+    name: 'Exa',
+    description: 'Advanced web search',
+    defaultSelected: true,
+    requiresEnv: ['EXA_API_KEY'],
+    claudeConfig: {
+      command: 'npx',
+      args: ['-y', '@exa/mcp'],
+      env: { EXA_API_KEY: '${EXA_API_KEY}' },
+    },
+  },
+  'desktop-commander': {
+    name: 'Desktop Commander',
+    description: 'File system access',
+    defaultSelected: false,
+    requiresEnv: [],
+    claudeConfig: {
+      command: 'npx',
+      args: ['-y', '@anthropic/desktop-commander-mcp'],
+    },
+  },
+  'sequential-thinking': {
+    name: 'Sequential Thinking',
+    description: 'Step-by-step reasoning',
+    defaultSelected: false,
+    requiresEnv: [],
+    claudeConfig: {
+      command: 'npx',
+      args: ['-y', '@anthropic/sequential-thinking-mcp'],
+    },
+  },
+  github: {
+    name: 'GitHub',
+    description: 'GitHub API integration',
+    defaultSelected: false,
+    requiresEnv: ['GITHUB_TOKEN'],
+    claudeConfig: {
+      command: 'npx',
+      args: ['-y', '@anthropic/github-mcp'],
+      env: { GITHUB_TOKEN: '${GITHUB_TOKEN}' },
+    },
+  },
+};
+
+/**
+ * Agent-MCP dependency matrix
+ */
+export const AGENT_MCP_DEPS = {
+  orchestrator:       { required: [],                    optional: ['git'] },
+  'greenfield-wu':    { required: [],                    optional: [] },
+  'brownfield-wu':    { required: ['git'],               optional: ['browser'] },
+  brief:              { required: [],                    optional: [] },
+  detail:             { required: [],                    optional: ['exa'] },
+  architect:          { required: ['context7'],          optional: ['exa', 'git'] },
+  ux:                 { required: [],                    optional: ['browser'] },
+  phases:             { required: [],                    optional: [] },
+  tasks:              { required: [],                    optional: [] },
+  'qa-planning':      { required: [],                    optional: [] },
+  dev:                { required: ['context7', 'git'],   optional: ['browser', 'coderabbit'] },
+  'qa-implementation':{ required: ['git'],               optional: ['browser', 'coderabbit'] },
+  devops:             { required: ['git', 'github'],     optional: [] },
+};
+
+/**
+ * Get list of MCPs for selection prompt
+ */
+export function getMCPChoices() {
+  return Object.entries(MCP_CONFIGS).map(([key, config]) => ({
+    value: key,
+    label: config.name,
+    hint: config.description,
+    initialValue: config.defaultSelected,
+  }));
+}
+
+/**
+ * Check MCP warnings for selected project type and MCPs
+ */
+export function getMCPWarnings(projectType, selectedMCPs) {
+  const warnings = [];
+
+  if (projectType === 'brownfield' && !selectedMCPs.includes('git')) {
+    warnings.push({
+      level: 'critical',
+      message: "You selected Brownfield but did not enable 'git' MCP. The brownfield-wu agent requires git for codebase analysis.",
+    });
+  }
+
+  return warnings;
+}
+
+/**
+ * Generate MCP config for Claude Code (.claude/mcp.json)
+ */
+export function generateClaudeMCPConfig(selectedMCPs) {
+  const mcpServers = {};
+  for (const mcpKey of selectedMCPs) {
+    const config = MCP_CONFIGS[mcpKey];
+    if (config?.claudeConfig) {
+      const entry = {
+        command: config.claudeConfig.command,
+        args: config.claudeConfig.args,
+      };
+      if (config.claudeConfig.env) {
+        entry.env = config.claudeConfig.env;
+      }
+      mcpServers[mcpKey] = entry;
+    }
+  }
+  return { mcpServers };
+}

package/src/dashboard/data-reader.js

@@ -0,0 +1,99 @@
+import { readFileSync, existsSync, readdirSync, statSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+/**
+ * Read all dashboard data from project directory
+ */
+export function readDashboardData(targetDir) {
+  const data = {
+    session: null,
+    config: null,
+    agentScores: {},
+    taskProgress: null,
+    validationResults: null,
+    recentActivity: [],
+    blockers: [],
+    gotchas: [],
+  };
+
+  // Read session.yaml
+  const sessionPath = join(targetDir, '.chati', 'session.yaml');
+  if (existsSync(sessionPath)) {
+    try {
+      data.session = yaml.load(readFileSync(sessionPath, 'utf-8'));
+    } catch {
+      data.session = null;
+    }
+  }
+
+  // Read config.yaml
+  const configPath = join(targetDir, 'chati.dev', 'config.yaml');
+  if (existsSync(configPath)) {
+    try {
+      data.config = yaml.load(readFileSync(configPath, 'utf-8'));
+    } catch {
+      data.config = null;
+    }
+  }
+
+  // Extract agent scores
+  if (data.session?.agents) {
+    for (const [name, info] of Object.entries(data.session.agents)) {
+      data.agentScores[name] = {
+        status: info.status || 'pending',
+        score: info.score || 0,
+        completedAt: info.completed_at || null,
+      };
+    }
+  }
+
+  // Extract blockers from backlog (high priority items)
+  if (data.session?.backlog) {
+    data.blockers = data.session.backlog.filter(
+      item => item.priority === 'high' && item.status !== 'done'
+    );
+  }
+
+  // Read task progress from artifacts
+  const tasksDir = join(targetDir, 'chati.dev', 'artifacts', '6-Tasks');
+  if (existsSync(tasksDir)) {
+    try {
+      const files = readdirSync(tasksDir).filter(f => f.endsWith('.yaml') || f.endsWith('.md'));
+      data.taskProgress = { totalFiles: files.length };
+    } catch {
+      // Ignore
+    }
+  }
+
+  // Read gotchas
+  const gotchasPath = join(targetDir, 'chati.dev', 'intelligence', 'gotchas.yaml');
+  if (existsSync(gotchasPath)) {
+    try {
+      const gotchasData = yaml.load(readFileSync(gotchasPath, 'utf-8'));
+      data.gotchas = gotchasData?.gotchas || [];
+    } catch {
+      // Ignore
+    }
+  }
+
+  // Build recent activity from agent completion timestamps
+  if (data.session?.agents) {
+    for (const [name, info] of Object.entries(data.session.agents)) {
+      if (info.completed_at) {
+        data.recentActivity.push({
+          agent: name,
+          score: info.score,
+          completedAt: info.completed_at,
+        });
+      }
+    }
+    data.recentActivity.sort((a, b) => {
+      if (!a.completedAt) return 1;
+      if (!b.completedAt) return -1;
+      return new Date(b.completedAt) - new Date(a.completedAt);
+    });
+  }
+
+  return data;
+}

package/src/dashboard/layout.js

@@ -0,0 +1,161 @@
+import { brand, dim, success, yellow, green, gray, bold, red } from '../utils/colors.js';
+
+/**
+ * Dashboard layout definition
+ * Formats data into the TUI display
+ */
+
+/**
+ * Format agent score with color
+ */
+function formatScore(score, status) {
+  if (status === 'pending') return gray('--');
+  if (status === 'in_progress') return yellow('...');
+  if (score >= 95) return green(String(score));
+  if (score >= 80) return yellow(String(score));
+  return red(String(score));
+}
+
+/**
+ * Format project state with label
+ */
+function formatState(state) {
+  const stateMap = {
+    clarity: brand('CLARITY'),
+    build: yellow('BUILD'),
+    validate: bold('VALIDATE'),
+    deploy: green('DEPLOY'),
+    completed: success('COMPLETED'),
+  };
+  return stateMap[state] || gray(state || 'unknown');
+}
+
+/**
+ * Format execution mode
+ */
+function formatMode(mode) {
+  if (mode === 'autonomous') return yellow('Ralph Wiggum');
+  return dim('Interactive');
+}
+
+/**
+ * Build the header section
+ */
+export function buildHeader(data) {
+  const version = data.config?.version || '?.?.?';
+  const line = '─'.repeat(59);
+  return [
+    brand(`┌${line}┐`),
+    brand(`│  chati.dev Dashboard`) + ' '.repeat(59 - 21 - version.length - 2) + dim(`v${version}`) + brand('  │'),
+    brand(`├${line}┤`),
+  ];
+}
+
+/**
+ * Build project info section
+ */
+export function buildProjectInfo(data) {
+  const session = data.session || {};
+  const project = session.project || {};
+
+  const name = project.name || 'unknown';
+  const type = project.type === 'brownfield' ? 'Brownfield' : 'Greenfield';
+  const state = formatState(project.state);
+  const mode = formatMode(session.execution_mode);
+  const lang = session.language || 'en';
+  const ide = (session.ides || [])[0] || 'unknown';
+
+  return [
+    brand('│') + `  ${dim('Project:')} ${name}` + ' '.repeat(Math.max(1, 30 - name.length)) + `${dim('Type:')} ${type}` + ' '.repeat(Math.max(1, 18 - type.length)) + brand('│'),
+    brand('│') + `  ${dim('Phase:')}   ${state}` + ' '.repeat(Math.max(1, 28)) + `${dim('Mode:')} ${mode}` + ' '.repeat(Math.max(1, 10)) + brand('│'),
+    brand('│') + `  ${dim('Language:')} ${lang}` + ' '.repeat(Math.max(1, 30 - lang.length)) + `${dim('IDE:')}  ${ide}` + ' '.repeat(Math.max(1, 18 - ide.length)) + brand('│'),
+  ];
+}
+
+/**
+ * Build CLARITY section with agent scores
+ */
+export function buildClaritySection(data) {
+  const scores = data.agentScores || {};
+
+  const clarityAgents = [
+    ['WU', scores['greenfield-wu'] || scores['brownfield-wu'] || { status: 'pending', score: 0 }],
+    ['Brief', scores['brief'] || { status: 'pending', score: 0 }],
+    ['Detail', scores['detail'] || { status: 'pending', score: 0 }],
+    ['Arch', scores['architect'] || { status: 'pending', score: 0 }],
+    ['UX', scores['ux'] || { status: 'pending', score: 0 }],
+    ['Phases', scores['phases'] || { status: 'pending', score: 0 }],
+    ['Tasks', scores['tasks'] || { status: 'pending', score: 0 }],
+    ['QA-P', scores['qa-planning'] || { status: 'pending', score: 0 }],
+  ];
+
+  const row1 = clarityAgents.slice(0, 4)
+    .map(([name, info]) => `${dim(name.padEnd(8))} ${formatScore(info.score, info.status)}`)
+    .join('  ');
+
+  const row2 = clarityAgents.slice(4)
+    .map(([name, info]) => `${dim(name.padEnd(8))} ${formatScore(info.score, info.status)}`)
+    .join('  ');
+
+  return [
+    brand('│') + `  ${brand('── CLARITY')} ${'─'.repeat(46)}` + brand('│'),
+    brand('│') + `  │ ${row1}` + ' '.repeat(5) + brand('│'),
+    brand('│') + `  │ ${row2}` + ' '.repeat(5) + brand('│'),
+    brand('│') + `  ${'─'.repeat(57)}` + brand('│'),
+  ];
+}
+
+/**
+ * Build BUILD section
+ */
+export function buildBuildSection(data) {
+  const devInfo = data.agentScores?.dev || { status: 'pending', score: 0 };
+  const status = devInfo.status === 'pending' ? gray('Waiting') :
+    devInfo.status === 'in_progress' ? yellow('In Progress') :
+    green('Complete');
+
+  return [
+    brand('│') + `  ${brand('── BUILD')} ${'─'.repeat(48)}` + brand('│'),
+    brand('│') + `  │ ${dim('Dev Agent:')} ${status}` + ' '.repeat(38) + brand('│'),
+    brand('│') + `  ${'─'.repeat(57)}` + brand('│'),
+  ];
+}
+
+/**
+ * Build VALIDATE section
+ */
+export function buildValidateSection(data) {
+  const qaInfo = data.agentScores?.['qa-implementation'] || { status: 'pending', score: 0 };
+  const tests = qaInfo.status === 'completed' ? green('Pass') : gray('--');
+
+  return [
+    brand('│') + `  ${brand('── VALIDATE')} ${'─'.repeat(45)}` + brand('│'),
+    brand('│') + `  │ ${dim('Tests:')} ${tests}  ${dim('SAST:')} ${gray('--')}  ${dim('DAST:')} ${gray('--')}  ${dim('DS Audit:')} ${gray('--')}` + ' '.repeat(5) + brand('│'),
+    brand('│') + `  ${'─'.repeat(57)}` + brand('│'),
+  ];
+}
+
+/**
+ * Build footer with recent activity, blockers, gotchas
+ */
+export function buildFooter(data) {
+  const recent = data.recentActivity?.[0];
+  const recentText = recent
+    ? `${recent.agent} completed (score: ${recent.score})`
+    : 'No recent activity';
+
+  const blockerCount = data.blockers?.length || 0;
+  const blockerText = blockerCount > 0 ? red(`${blockerCount} active`) : green('None');
+
+  const gotchaCount = data.gotchas?.length || 0;
+  const gotchaText = gotchaCount > 0 ? `${gotchaCount} patterns learned` : 'None yet';
+
+  const line = '─'.repeat(59);
+
+  return [
+    brand('│') + `  ${dim('Recent:')}   ${recentText}` + ' '.repeat(Math.max(1, 40 - recentText.length)) + brand('│'),
+    brand('│') + `  ${dim('Blockers:')} ${blockerText}` + ' '.repeat(42) + brand('│'),
+    brand('│') + `  ${dim('Gotchas:')}  ${gotchaText}` + ' '.repeat(Math.max(1, 40 - gotchaText.length)) + brand('│'),
+    brand(`└${line}┘`),
+  ];
+}

package/src/dashboard/renderer.js

@@ -0,0 +1,104 @@
+import { readDashboardData } from './data-reader.js';
+import {
+  buildHeader,
+  buildProjectInfo,
+  buildClaritySection,
+  buildBuildSection,
+  buildValidateSection,
+  buildFooter,
+} from './layout.js';
+import { dim } from '../utils/colors.js';
+
+/**
+ * Render dashboard once (static mode)
+ */
+export function renderDashboard(targetDir) {
+  const data = readDashboardData(targetDir);
+
+  if (!data.session) {
+    console.log('No chati.dev session found. Run `npx chati-dev init` first.');
+    return;
+  }
+
+  const lines = [
+    ...buildHeader(data),
+    ...buildProjectInfo(data),
+    '',
+    ...buildClaritySection(data),
+    '',
+    ...buildBuildSection(data),
+    '',
+    ...buildValidateSection(data),
+    '',
+    ...buildFooter(data),
+  ];
+
+  console.log();
+  for (const line of lines) {
+    console.log(line);
+  }
+  console.log();
+}
+
+/**
+ * Render dashboard in watch mode (auto-refresh)
+ */
+export function renderDashboardWatch(targetDir, intervalMs = 5000) {
+  // Initial render
+  console.clear();
+  renderDashboard(targetDir);
+  console.log(dim(`  Auto-refreshing every ${intervalMs / 1000}s. Press Ctrl+C to exit.`));
+
+  // Set up interval
+  const timer = setInterval(() => {
+    console.clear();
+    renderDashboard(targetDir);
+    console.log(dim(`  Auto-refreshing every ${intervalMs / 1000}s. Press Ctrl+C to exit.`));
+    console.log(dim(`  Last update: ${new Date().toLocaleTimeString()}`));
+  }, intervalMs);
+
+  // Handle exit
+  process.on('SIGINT', () => {
+    clearInterval(timer);
+    console.log();
+    process.exit(0);
+  });
+
+  return timer;
+}
+
+/**
+ * Render plain text fallback (for terminals without TUI support)
+ */
+export function renderPlainDashboard(targetDir) {
+  const data = readDashboardData(targetDir);
+
+  if (!data.session) {
+    console.log('No chati.dev session found. Run `npx chati-dev init` first.');
+    return;
+  }
+
+  const session = data.session;
+  const project = session.project || {};
+
+  console.log();
+  console.log('=== chati.dev Dashboard ===');
+  console.log();
+  console.log(`Project:  ${project.name || 'unknown'}`);
+  console.log(`Type:     ${project.type || 'unknown'}`);
+  console.log(`Phase:    ${project.state || 'unknown'}`);
+  console.log(`Mode:     ${session.execution_mode || 'interactive'}`);
+  console.log(`Language: ${session.language || 'en'}`);
+  console.log();
+
+  console.log('--- Agent Scores ---');
+  for (const [name, info] of Object.entries(data.agentScores)) {
+    const status = info.status === 'pending' ? '--' : info.status === 'in_progress' ? '...' : String(info.score);
+    console.log(`  ${name.padEnd(20)} ${status}`);
+  }
+
+  console.log();
+  console.log(`Blockers: ${data.blockers.length || 'None'}`);
+  console.log(`Gotchas:  ${data.gotchas.length} patterns`);
+  console.log();
+}