ai-control-center 1.15.2

package/lib/utils/intent-engine.js

@@ -0,0 +1,464 @@
+/**
+ * Intent Engine — Dynamic, learnable intent pattern matcher.
+ *
+ * Replaces hardcoded regex with a JSON-driven pattern store that learns
+ * from successful interactions. Patterns are loaded from disk, matched
+ * against user messages, and new patterns are learned over time.
+ *
+ * Storage: .ai-workflow/intelligence/intent-patterns.json
+ *          .ai-workflow/intelligence/learned-phrases.json
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+import { getWorkflowDir } from './pipeline.js';
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+const INTEL_DIR_NAME = 'intelligence';
+
+function getIntelDir() {
+  const dir = resolve(getWorkflowDir(), INTEL_DIR_NAME);
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function getPatternsPath() {
+  return resolve(getIntelDir(), 'intent-patterns.json');
+}
+
+function getLearnedPath() {
+  return resolve(getIntelDir(), 'learned-phrases.json');
+}
+
+function getPromptPath() {
+  return resolve(getIntelDir(), 'system-prompt.md');
+}
+
+// ─── Default Patterns (seed) ─────────────────────────────────────────────────
+
+const DEFAULT_PATTERNS = {
+  fix: {
+    description: 'User wants Copilot to fix bugs/blockers from review',
+    primary: [
+      'fix', 'repair', 'address', 'correct', 'apply.*fix',
+      'dispatch.*fix', 'copilot.*fix', 'fix.*blockers', 'fix.*issue'
+    ],
+    context: [
+      'it', 'this', 'that', 'those', 'them',
+      'the (issues?|bugs?|blockers?|errors?|code|review|problems?)'
+    ],
+    requiresContext: true,
+    requiresFeature: true
+  },
+  review: {
+    description: 'User wants a code review',
+    primary: [
+      'review', 're.?view', 'check.*code', 'run.*review', 'gemini.*review'
+    ],
+    context: [
+      'it', 'this', 'that', 'again', 'now',
+      'the (code|changes?|impl|feature)', 'once more'
+    ],
+    requiresContext: true,
+    requiresFeature: true
+  },
+  approve: {
+    description: 'User wants to approve the feature',
+    primary: ['approve', 'approved', 'lgtm', 'looks good', 'good to go', 'ship it', 'merge it'],
+    context: [],
+    requiresContext: false,
+    requiresFeature: true
+  },
+  deploy: {
+    description: 'User wants to deploy',
+    primary: ['deploy', 'push to prod', 'go live', 'release it'],
+    context: [],
+    requiresContext: false,
+    requiresFeature: true
+  },
+  implement: {
+    description: 'User wants to start/resume Copilot implementation',
+    primary: [
+      'implement', 'start copilot', 'run impl', 'run it', 'run the task',
+      'run feature', 'trigger impl'
+    ],
+    combo: [
+      { primary: ['restart', 'resume', 'start', 'run', 'trigger'],
+        context: ['impl', 'implementat', 'copilot', 'pipeline', 'feature', 'it', 'that', 'tasks'] }
+    ],
+    context: [],
+    requiresContext: false,
+    requiresFeature: true,
+    stageGate: ['arch_complete', 'implementation_failed']
+  },
+  fix_and_review: {
+    description: 'User wants fix then review (combo)',
+    primary: [],
+    combo: [
+      { primary: ['fix', 'repair', 'address', 'correct', 'copilot.*fix'],
+        context: ['review', 're.?view', 'check'] }
+    ],
+    context: [],
+    requiresContext: false,
+    requiresFeature: true,
+    priority: 10  // higher priority — match before individual fix/review
+  },
+  reset: {
+    description: 'User wants to reset pipeline to idle / abandon current feature',
+    primary: [
+      'reset', 'idle', 'go idle', 'set idle', 'change.*idle', 'move.*idle',
+      'stop.*pipeline', 'abandon', 'cancel.*feature', 'clear.*pipeline',
+      'start over', 'start fresh', 'clean slate'
+    ],
+    context: [],
+    requiresContext: false,
+    requiresFeature: false,
+    priority: 12
+  },
+  status: {
+    description: 'User wants to check pipeline status',
+    primary: [
+      'status', 'what.*stage', 'where.*pipeline', 'what.*happening',
+      'current.*state', 'pipeline.*state', 'show.*status'
+    ],
+    context: [],
+    requiresContext: false,
+    requiresFeature: false
+  },
+  cleanup: {
+    description: 'User wants to clean up workspace',
+    primary: ['cleanup', 'clean up', 'clean.*workspace', 'tidy up'],
+    context: [],
+    requiresContext: false,
+    requiresFeature: false
+  },
+  rewrite_docs: {
+    description: 'User wants to rework/rewrite spec and/or architecture docs',
+    primary: [
+      'rework', 'rewrite', 'redo', 'redo.*spec', 'redo.*arch',
+      'update.*spec', 'update.*arch', 'revise.*spec', 'revise.*arch',
+      'rewrite.*spec', 'rewrite.*arch', 'rework.*spec', 'rework.*arch',
+      'refresh.*spec', 'refresh.*arch'
+    ],
+    combo: [
+      { primary: ['rework', 'rewrite', 'redo', 'update', 'revise', 'refresh'],
+        context: ['spec', 'arch', 'document', 'docs', 'plan', 'design', 'tasks'] }
+    ],
+    context: [],
+    requiresContext: false,
+    requiresFeature: false,
+    priority: 15  // high priority — catch before generic fix/implement
+  },
+  payment: {
+    description: 'User wants to implement payment functionality',
+    primary: [
+      'payment', 'stripe', 'payos', 'momo', 'vnpay', 'zalopay',
+      'checkout', 'billing', 'subscription', 'invoice', 'transaction',
+      'pay', 'purchase', 'buy', 'cart', 'order'
+    ],
+    context: [],
+    requiresContext: false,
+    skillsToInject: ['skill-payment'],
+  },
+  auth: {
+    description: 'User wants authentication/authorization',
+    primary: [
+      'login', 'logout', 'auth', 'oauth', 'jwt', 'session', 'token',
+      'register', 'signup', 'sign up', 'sign in', 'password', 'forgot password',
+      '2fa', 'mfa', 'sso'
+    ],
+    context: [],
+    requiresContext: false,
+    skillsToInject: [],
+  },
+  notification: {
+    description: 'User wants notification system',
+    primary: [
+      'email', 'push notification', 'sms', 'notify', 'notification',
+      'alert', 'reminder', 'webhook'
+    ],
+    context: [],
+    requiresContext: false,
+    skillsToInject: [],
+  },
+};
+
+// ─── Pattern Loading ─────────────────────────────────────────────────────────
+
+let _cachedPatterns = null;
+let _cacheTime = 0;
+const CACHE_TTL = 30_000; // reload every 30s
+
+/**
+ * Load intent patterns from disk. Seeds default if file doesn't exist.
+ */
+export function loadPatterns() {
+  if (_cachedPatterns && Date.now() - _cacheTime < CACHE_TTL) return _cachedPatterns;
+
+  const path = getPatternsPath();
+  if (!existsSync(path)) {
+    // Seed with defaults
+    savePatterns(DEFAULT_PATTERNS);
+    _cachedPatterns = DEFAULT_PATTERNS;
+    _cacheTime = Date.now();
+    return DEFAULT_PATTERNS;
+  }
+
+  try {
+    const loaded = JSON.parse(readFileSync(path, 'utf8'));
+    // Merge new/updated DEFAULT_PATTERNS into disk file.
+    // New intents are added; existing intents get their primary array refreshed
+    // from defaults (so code-level fixes to patterns take effect).
+    let merged = false;
+    for (const [key, value] of Object.entries(DEFAULT_PATTERNS)) {
+      if (!(key in loaded)) {
+        loaded[key] = value;
+        merged = true;
+      } else if (JSON.stringify(loaded[key].primary) !== JSON.stringify(value.primary)) {
+        loaded[key].primary = value.primary;
+        merged = true;
+      }
+    }
+    if (merged) savePatterns(loaded);
+    _cachedPatterns = loaded;
+    _cacheTime = Date.now();
+    return _cachedPatterns;
+  } catch {
+    _cachedPatterns = DEFAULT_PATTERNS;
+    _cacheTime = Date.now();
+    return DEFAULT_PATTERNS;
+  }
+}
+
+function savePatterns(patterns) {
+  try {
+    writeFileSync(getPatternsPath(), JSON.stringify(patterns, null, 2));
+    _cachedPatterns = patterns;
+    _cacheTime = Date.now();
+  } catch { /* non-fatal */ }
+}
+
+// ─── Learned Phrases ─────────────────────────────────────────────────────────
+
+/**
+ * Load learned phrases — maps raw user text → resolved intent.
+ * Structure: { phrases: [{ text, intent, action, count, lastUsed }], ... }
+ */
+function loadLearned() {
+  const path = getLearnedPath();
+  if (!existsSync(path)) return { phrases: [], stats: { totalLearned: 0, totalMatches: 0 } };
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return { phrases: [], stats: { totalLearned: 0, totalMatches: 0 } };
+  }
+}
+
+function saveLearned(data) {
+  try {
+    writeFileSync(getLearnedPath(), JSON.stringify(data, null, 2));
+  } catch { /* non-fatal */ }
+}
+
+/**
+ * Record a successful intent match for learning.
+ * Next time the user says something similar, we can skip AI entirely.
+ */
+export function learnPhrase(rawText, intent, actionData = {}) {
+  const learned = loadLearned();
+  const normalized = rawText.toLowerCase().trim();
+
+  // Check if we already know this phrase
+  const existing = learned.phrases.find(p => p.text === normalized);
+  if (existing) {
+    existing.count = (existing.count || 1) + 1;
+    existing.lastUsed = Date.now();
+  } else {
+    learned.phrases.push({
+      text: normalized,
+      intent,
+      action: actionData,
+      count: 1,
+      firstSeen: Date.now(),
+      lastUsed: Date.now()
+    });
+    learned.stats.totalLearned = (learned.stats.totalLearned || 0) + 1;
+  }
+
+  // Keep max 500 phrases — prune least-used ones
+  if (learned.phrases.length > 500) {
+    learned.phrases.sort((a, b) => (b.count * (b.lastUsed || 0)) - (a.count * (a.lastUsed || 0)));
+    learned.phrases = learned.phrases.slice(0, 400);
+  }
+
+  saveLearned(learned);
+}
+
+/**
+ * Check if we've seen this exact (or very similar) phrase before.
+ * Returns the intent if found, null otherwise.
+ */
+export function matchLearnedPhrase(rawText) {
+  const learned = loadLearned();
+  const normalized = rawText.toLowerCase().trim();
+
+  // Exact match
+  const exact = learned.phrases.find(p => p.text === normalized);
+  if (exact && exact.count >= 2) {
+    // Only trust phrases we've seen at least twice
+    const data = loadLearned();
+    data.stats.totalMatches = (data.stats.totalMatches || 0) + 1;
+    saveLearned(data);
+    return { intent: exact.intent, action: exact.action, confidence: 'exact' };
+  }
+
+  // Fuzzy match — check if text is 80%+ similar to a known phrase
+  for (const phrase of learned.phrases) {
+    if (phrase.count < 3) continue; // need at least 3 occurrences for fuzzy
+    if (fuzzyMatch(normalized, phrase.text) > 0.8) {
+      return { intent: phrase.intent, action: phrase.action, confidence: 'fuzzy' };
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Simple similarity score (Dice coefficient on bigrams).
+ */
+function fuzzyMatch(a, b) {
+  if (a === b) return 1;
+  if (a.length < 2 || b.length < 2) return 0;
+
+  const bigramsA = new Set();
+  for (let i = 0; i < a.length - 1; i++) bigramsA.add(a.slice(i, i + 2));
+
+  let matches = 0;
+  for (let i = 0; i < b.length - 1; i++) {
+    if (bigramsA.has(b.slice(i, i + 2))) matches++;
+  }
+
+  return (2.0 * matches) / (a.length - 1 + b.length - 1);
+}
+
+// ─── Pattern Matching ────────────────────────────────────────────────────────
+
+/**
+ * Match user text against all intent patterns.
+ * Returns { intent, confidence } or null.
+ */
+export function matchIntent(text, statusData = {}) {
+  const lc = text.toLowerCase();
+  const isQuestion = /^(how|what|why|when|where|who|can you explain|could you|would you|should|is it|are you|do you|does it|did|will|shall)\b/.test(lc) || text.endsWith('?');
+
+  if (isQuestion) return null;
+
+  const patterns = loadPatterns();
+
+  // Sort by priority (higher first), default priority = 0
+  const intents = Object.entries(patterns)
+    .sort(([, a], [, b]) => (b.priority || 0) - (a.priority || 0));
+
+  for (const [name, pattern] of intents) {
+    // Gate: requires active feature?
+    if (pattern.requiresFeature && !statusData.current_feature) continue;
+
+    // Gate: stage restriction?
+    if (pattern.stageGate && !pattern.stageGate.includes(statusData.stage)) continue;
+
+    // Check combo patterns first (they need BOTH sets to match)
+    if (pattern.combo?.length) {
+      for (const combo of pattern.combo) {
+        const primaryMatch = combo.primary.some(p => new RegExp(`\\b${p}\\b`, 'i').test(lc));
+        const contextMatch = combo.context.some(c => new RegExp(`\\b${c}\\b`, 'i').test(lc));
+        if (primaryMatch && contextMatch) {
+          return { intent: name, confidence: 'combo_pattern' };
+        }
+      }
+    }
+
+    // Check primary patterns
+    if (pattern.primary?.length) {
+      const primaryMatch = pattern.primary.some(p => new RegExp(`\\b${p}\\b`, 'i').test(lc));
+      if (!primaryMatch) continue;
+
+      // If context is required, check context patterns too
+      if (pattern.requiresContext && pattern.context?.length) {
+        const contextMatch = pattern.context.some(c => new RegExp(`\\b${c}\\b`, 'i').test(lc));
+        if (!contextMatch) continue;
+      }
+
+      return { intent: name, confidence: 'pattern' };
+    }
+  }
+
+  return null;
+}
+
+// ─── External System Prompt ──────────────────────────────────────────────────
+
+/**
+ * Load the externalized system prompt.
+ * Falls back to null if file doesn't exist (caller uses inline prompt).
+ */
+export function loadExternalPrompt() {
+  const path = getPromptPath();
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, 'utf8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save/update the externalized system prompt.
+ */
+export function saveExternalPrompt(content) {
+  try {
+    getIntelDir(); // ensure dir exists
+    writeFileSync(getPromptPath(), content);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Add a learned pattern to the prompt's "Learned Shortcuts" section.
+ * This enriches the AI's understanding over time.
+ */
+export function appendLearnedContext() {
+  const learned = loadLearned();
+  if (!learned.phrases.length) return '';
+
+  // Get top phrases (most used) to add as examples for the AI
+  const topPhrases = learned.phrases
+    .filter(p => p.count >= 2)
+    .sort((a, b) => b.count - a.count)
+    .slice(0, 20);
+
+  if (!topPhrases.length) return '';
+
+  return '\n\n## Learned User Patterns (from past interactions)\n' +
+    'These phrases have been successfully mapped to actions before:\n' +
+    topPhrases.map(p => `- "${p.text}" → ${p.intent}`).join('\n') + '\n' +
+    'Use these as hints when classifying messages with similar wording.\n';
+}
+
+/**
+ * Get intelligence stats for display.
+ */
+export function getIntelStats() {
+  const learned = loadLearned();
+  const patterns = loadPatterns();
+  return {
+    totalIntents: Object.keys(patterns).length,
+    totalLearnedPhrases: learned.phrases.length,
+    totalMatches: learned.stats?.totalMatches || 0,
+    topIntents: learned.phrases.reduce((acc, p) => {
+      acc[p.intent] = (acc[p.intent] || 0) + p.count;
+      return acc;
+    }, {})
+  };
+}

package/lib/utils/mcp-client.js

@@ -0,0 +1,238 @@
+/**
+ * Model Context Protocol (MCP) — Configuration Reader, Formatter & Client.
+ *
+ * Reads MCP server configuration from aicc.config.js and formats
+ * server metadata as context strings for AI prompts.
+ * Also provides JSON-RPC stdio transport, server lifecycle management,
+ * and tool calling capabilities.
+ */
+
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { spawn } from 'child_process';
+
+/** Example schema showing the expected MCP config structure. */
+export const MCP_SCHEMA = {
+  mcp: {
+    servers: [
+      {
+        name: 'example-server',
+        url: 'http://localhost:3100',
+        transport: 'stdio',
+        capabilities: ['tools', 'resources'],
+        description: 'Example MCP server',
+      },
+    ],
+  },
+};
+
+/**
+ * Read MCP server configuration from aicc.config.js.
+ * Returns an empty array when no config is found.
+ */
+export async function getMCPConfig() {
+  const configPaths = [
+    resolve(process.cwd(), 'aicc.config.js'),
+    resolve(process.cwd(), 'aicc.config.mjs'),
+  ];
+
+  for (const configPath of configPaths) {
+    if (!existsSync(configPath)) continue;
+
+    try {
+      const configUrl = pathToFileURL(configPath).href;
+      const mod = await import(configUrl);
+      const config = mod.default || mod;
+      if (config?.mcp?.servers && Array.isArray(config.mcp.servers)) {
+        return config.mcp.servers;
+      }
+    } catch {
+      // Config exists but failed to load — fall through
+    }
+  }
+
+  return [];
+}
+
+/**
+ * List configured MCP servers with a basic status indicator.
+ */
+export async function listMCPServers() {
+  const servers = await getMCPConfig();
+
+  return servers.map(server => ({
+    name: server.name || 'unnamed',
+    url: server.url || null,
+    transport: server.transport || 'stdio',
+    capabilities: server.capabilities || [],
+    description: server.description || '',
+    command: server.command || null,
+    args: server.args || [],
+    env: server.env || {},
+    status: 'configured',
+  }));
+}
+
+/**
+ * Format MCP server info as a context string suitable for AI prompts.
+ */
+export function formatMCPContext(servers) {
+  if (!servers || servers.length === 0) {
+    return 'No MCP servers configured.';
+  }
+
+  const lines = ['Available MCP Servers:', ''];
+
+  for (const server of servers) {
+    lines.push(`• ${server.name || 'unnamed'}`);
+    if (server.url)          lines.push(`  URL: ${server.url}`);
+    if (server.transport)    lines.push(`  Transport: ${server.transport}`);
+    if (server.description)  lines.push(`  ${server.description}`);
+    if (server.capabilities?.length) {
+      lines.push(`  Capabilities: ${server.capabilities.join(', ')}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+// ─── JSON-RPC Stdio Transport & Server Lifecycle ───────────────────────────────
+
+const _servers = new Map(); // name → { process, pendingRequests, nextId, ... }
+
+export async function startServer(serverConfig) {
+  const { name, command, args = [], env = {} } = serverConfig;
+  if (_servers.has(name)) return _servers.get(name);
+
+  const proc = spawn(command, args, {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    env: { ...process.env, ...env },
+  });
+
+  const server = {
+    name,
+    process: proc,
+    pendingRequests: new Map(),
+    nextId: 1,
+    tools: [],
+    ready: false,
+  };
+
+  let buffer = '';
+  proc.stdout.on('data', (data) => {
+    buffer += data.toString();
+    const lines = buffer.split('\n');
+    buffer = lines.pop(); // keep incomplete line
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const msg = JSON.parse(line);
+        if (msg.id !== undefined && server.pendingRequests.has(msg.id)) {
+          const { resolve, reject, timer } = server.pendingRequests.get(msg.id);
+          clearTimeout(timer);
+          server.pendingRequests.delete(msg.id);
+          if (msg.error) reject(new Error(msg.error.message || 'MCP error'));
+          else resolve(msg.result);
+        }
+      } catch { /* ignore malformed */ }
+    }
+  });
+
+  proc.on('error', (err) => {
+    console.error(`[MCP] Server "${name}" error: ${err.message}`);
+  });
+
+  proc.on('exit', (code) => {
+    _servers.delete(name);
+    for (const [, { reject, timer }] of server.pendingRequests) {
+      clearTimeout(timer);
+      reject(new Error(`MCP server "${name}" exited with code ${code}`));
+    }
+  });
+
+  _servers.set(name, server);
+
+  // Send initialize request
+  try {
+    await _sendRequest(server, 'initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'aicc', version: '1.7.0' },
+    }, 10000);
+    server.ready = true;
+
+    _sendNotification(server, 'notifications/initialized', {});
+
+    try {
+      const toolsResult = await _sendRequest(server, 'tools/list', {}, 5000);
+      server.tools = toolsResult.tools || [];
+    } catch { /* server may not support tools */ }
+  } catch (e) {
+    proc.kill();
+    _servers.delete(name);
+    throw new Error(`MCP server "${name}" initialization failed: ${e.message}`);
+  }
+
+  return server;
+}
+
+export async function callTool(serverName, toolName, args = {}, timeout = 30000) {
+  const server = _servers.get(serverName);
+  if (!server) throw new Error(`MCP server "${serverName}" not started. Call startServer() first.`);
+  if (!server.ready) throw new Error(`MCP server "${serverName}" not ready`);
+
+  return _sendRequest(server, 'tools/call', { name: toolName, arguments: args }, timeout);
+}
+
+export async function listTools(serverName) {
+  const server = _servers.get(serverName);
+  if (!server) throw new Error(`MCP server "${serverName}" not started`);
+  if (server.tools.length > 0) return server.tools;
+  const result = await _sendRequest(server, 'tools/list', {}, 5000);
+  server.tools = result.tools || [];
+  return server.tools;
+}
+
+export function stopServer(serverName) {
+  const server = _servers.get(serverName);
+  if (!server) return;
+  try { server.process.kill(); } catch { /* already dead */ }
+  _servers.delete(serverName);
+}
+
+export function stopAllServers() {
+  for (const [name] of _servers) {
+    stopServer(name);
+  }
+}
+
+export function getRunningServers() {
+  return Array.from(_servers.entries()).map(([name, s]) => ({
+    name, ready: s.ready, tools: s.tools.length, pid: s.process.pid,
+  }));
+}
+
+function _sendRequest(server, method, params, timeout = 30000) {
+  return new Promise((resolvePromise, reject) => {
+    const id = server.nextId++;
+    const timer = setTimeout(() => {
+      server.pendingRequests.delete(id);
+      reject(new Error(`MCP request "${method}" timed out after ${timeout}ms`));
+    }, timeout);
+    server.pendingRequests.set(id, { resolve: resolvePromise, reject, timer });
+    const msg = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+    server.process.stdin.write(msg);
+  });
+}
+
+function _sendNotification(server, method, params) {
+  const msg = JSON.stringify({ jsonrpc: '2.0', method, params }) + '\n';
+  server.process.stdin.write(msg);
+}
+
+// Cleanup on process exit
+process.on('exit', stopAllServers);
+process.on('SIGINT', () => { stopAllServers(); process.exit(0); });
+process.on('SIGTERM', () => { stopAllServers(); process.exit(0); });