ai-control-center 1.15.2

package/lib/utils/model-ab-test.js

@@ -0,0 +1,164 @@
+/**
+ * A/B Testing System for comparing AI model outputs.
+ *
+ * Scores and compares pre-computed responses from two models,
+ * persists results, and provides aggregated statistics.
+ */
+
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { resolve } from 'path';
+import { getWorkflowDir } from './pipeline.js';
+
+const AB_DIR = 'ab-tests';
+
+function getABDir() {
+  const dir = resolve(getWorkflowDir(), AB_DIR);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+/**
+ * Score an AI response (0–100) based on heuristic quality signals.
+ *
+ * Breakdown:
+ *   Length adequacy   10–30 pts
+ *   Structure         10–30 pts  (headings, code blocks)
+ *   Keyword relevance 10–20 pts
+ *   Completeness      10–20 pts  (distinct sections)
+ */
+export function scoreResponse(response, stage) {
+  if (!response || typeof response !== 'string') return 0;
+
+  let score = 0;
+
+  // Length adequacy (10–30 pts)
+  const words = response.split(/\s+/).filter(Boolean).length;
+  if (words < 50) score += 10;
+  else if (words < 200) score += 20;
+  else score += 30;
+
+  // Structure / formatting (10–30 pts)
+  const headings = (response.match(/^#{1,6}\s/gm) || []).length;
+  const codeBlocks = (response.match(/```/g) || []).length / 2;
+  const structureScore = Math.min(30, 10 + headings * 4 + Math.floor(codeBlocks) * 5);
+  score += structureScore;
+
+  // Keyword relevance (10–20 pts)
+  const stageKeywords = {
+    plan:     ['goal', 'step', 'requirement', 'scope', 'milestone'],
+    blueprint:['architecture', 'component', 'interface', 'design', 'module'],
+    implement:['function', 'class', 'import', 'export', 'return'],
+    review:   ['issue', 'fix', 'improve', 'suggestion', 'change'],
+  };
+  const keywords = stageKeywords[stage] || [];
+  const lower = response.toLowerCase();
+  const hits = keywords.filter(kw => lower.includes(kw)).length;
+  score += Math.min(20, 10 + hits * 2);
+
+  // Completeness (10–20 pts)
+  const sections = new Set(
+    (response.match(/^#{1,3}\s.+/gm) || []).map(h => h.trim())
+  ).size;
+  score += Math.min(20, 10 + sections * 2);
+
+  return Math.min(100, score);
+}
+
+/**
+ * Run an A/B comparison between two pre-computed model responses.
+ *
+ * @param {string} prompt   – the original prompt
+ * @param {{ model: string, response: string }} modelA
+ * @param {{ model: string, response: string }} modelB
+ * @param {string} stage    – pipeline stage (plan, blueprint, …)
+ * @returns {{ winner: string, modelA: object, modelB: object, reason: string }}
+ */
+export function runABTest(prompt, modelA, modelB, stage) {
+  const scoreA = scoreResponse(modelA.response, stage);
+  const scoreB = scoreResponse(modelB.response, stage);
+
+  const winner = scoreA >= scoreB ? modelA.model : modelB.model;
+  const diff   = Math.abs(scoreA - scoreB);
+  const reason  = diff < 5
+    ? 'Near tie — scores within 5 points'
+    : `${winner} scored ${diff} points higher on ${stage} heuristics`;
+
+  const result = {
+    winner,
+    modelA: { model: modelA.model, score: scoreA },
+    modelB: { model: modelB.model, score: scoreB },
+    reason,
+    stage,
+    prompt: prompt.slice(0, 200),
+    timestamp: new Date().toISOString(),
+  };
+
+  saveABResult(result);
+  return result;
+}
+
+/**
+ * Persist an A/B test result to disk.
+ */
+export function saveABResult(result) {
+  const dir  = getABDir();
+  const file = resolve(dir, `ab-${Date.now()}.json`);
+  writeFileSync(file, JSON.stringify(result, null, 2));
+}
+
+/**
+ * Return the last N A/B test results (most recent first).
+ */
+export function getABHistory(limit = 20) {
+  const dir = getABDir();
+  const files = readdirSync(dir)
+    .filter(f => f.startsWith('ab-') && f.endsWith('.json'))
+    .sort()
+    .reverse()
+    .slice(0, limit);
+
+  return files.map(f => {
+    try {
+      return JSON.parse(readFileSync(resolve(dir, f), 'utf-8'));
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+/**
+ * Aggregate win/loss statistics per model across all recorded tests.
+ */
+export function getABSummary() {
+  const history = getABHistory(1000);
+  const stats   = {};
+
+  for (const result of history) {
+    const { winner, modelA, modelB } = result;
+
+    for (const entry of [modelA, modelB]) {
+      if (!stats[entry.model]) {
+        stats[entry.model] = { wins: 0, losses: 0, ties: 0, totalScore: 0, tests: 0 };
+      }
+      stats[entry.model].tests  += 1;
+      stats[entry.model].totalScore += entry.score;
+
+      if (result.reason.startsWith('Near tie')) {
+        stats[entry.model].ties += 1;
+      } else if (entry.model === winner) {
+        stats[entry.model].wins += 1;
+      } else {
+        stats[entry.model].losses += 1;
+      }
+    }
+  }
+
+  // Compute average scores
+  for (const model of Object.keys(stats)) {
+    stats[model].avgScore = stats[model].tests
+      ? Math.round(stats[model].totalScore / stats[model].tests)
+      : 0;
+  }
+
+  return stats;
+}

package/lib/utils/notify.js

@@ -0,0 +1,122 @@
+/**
+ * Terminal notifications: sounds + celebration animations.
+ *
+ * Sounds use macOS `afplay` (fire-and-forget, non-blocking).
+ * Animations use a progress-bar sweep → final message reveal (pure chalk, no deps).
+ *
+ * Usage:
+ *   import { celebrate } from '../utils/notify.js';
+ *   await celebrate('deploy_success');   // plays sound + shows banner
+ *   await celebrate('review_rejected');  // plays sound only (red banner)
+ */
+import { spawn } from 'child_process';
+import chalk from 'chalk';
+
+// ─── macOS system sounds ───────────────────────────────────────────────────────
+const SOUNDS_DIR = '/System/Library/Sounds';
+const SOUND_MAP  = {
+  deploy_success:  `${SOUNDS_DIR}/Hero.aiff`,
+  review_approved: `${SOUNDS_DIR}/Glass.aiff`,
+  approved:        `${SOUNDS_DIR}/Glass.aiff`,
+  review_rejected: `${SOUNDS_DIR}/Blow.aiff`,
+  deploy_failed:   `${SOUNDS_DIR}/Basso.aiff`,
+  task_done:       `${SOUNDS_DIR}/Ping.aiff`,
+};
+
+/**
+ * Play a macOS system sound for the given event.
+ * Fire-and-forget — returns immediately, sound plays in background.
+ * Silent no-op on non-macOS systems.
+ */
+export function playSound(event) {
+  const file = SOUND_MAP[event];
+  if (!file || process.platform !== 'darwin') return;
+  try {
+    const proc = spawn('afplay', [file], { detached: true, stdio: 'ignore' });
+    proc.unref(); // don't block the Node.js process
+  } catch { /* non-fatal — sound is a nice-to-have */ }
+}
+
+// ─── Animation helpers ─────────────────────────────────────────────────────────
+
+const sleep = ms => new Promise(r => setTimeout(r, ms));
+
+/**
+ * Animate a progress bar sweep (░→█), then reveal the final message.
+ *
+ * @param {string} color   chalk color name ('green', 'cyan', 'red', 'yellow')
+ * @param {string} icon    emoji or symbol shown before the message
+ * @param {string} message text after the icon
+ */
+async function sweepBanner(color, icon, message) {
+  const WIDTH  = 42;
+  const FRAMES = 10;
+  const DELAY  = 35; // ms per frame (~350ms total sweep)
+
+  // Phase 1: fill the bar left → right
+  for (let i = 0; i <= FRAMES; i++) {
+    const filled = Math.round((i / FRAMES) * WIDTH);
+    const bar    = chalk[color]('█'.repeat(filled)) + chalk.dim('░'.repeat(WIDTH - filled));
+    process.stdout.write(`\r  ${bar}  `);
+    await sleep(DELAY);
+  }
+
+  // Phase 2: pause on full bar for a beat
+  await sleep(120);
+
+  // Phase 3: clear bar, show final message
+  process.stdout.write('\r\x1b[K');
+  process.stdout.write(chalk[color].bold(`  ${icon}  ${message}\n`));
+}
+
+// ─── Event definitions ─────────────────────────────────────────────────────────
+
+const CELEBRATIONS = {
+  deploy_success: {
+    color:   'green',
+    icon:    '🚀',
+    message: 'DEPLOYED SUCCESSFULLY',
+  },
+  review_approved: {
+    color:   'cyan',
+    icon:    '✓',
+    message: 'REVIEW APPROVED  ·  Ready to approve and ship!',
+  },
+  approved: {
+    color:   'green',
+    icon:    '✓',
+    message: 'FEATURE APPROVED  ·  Deploy when ready',
+  },
+  review_rejected: {
+    color:   'red',
+    icon:    '✗',
+    message: 'REVIEW REJECTED  ·  Blockers found — Copilot will fix',
+  },
+  deploy_failed: {
+    color:   'red',
+    icon:    '✗',
+    message: 'DEPLOY FAILED  ·  Sending errors to Copilot',
+  },
+  task_done: {
+    color:   'blue',
+    icon:    '◆',
+    message: 'PIPELINE STEP COMPLETE',
+  },
+};
+
+/**
+ * Play the sound for `event` and show the celebration animation.
+ * Always resolves — sound/animation failures are silently swallowed.
+ *
+ * @param {string} event  key from CELEBRATIONS / SOUND_MAP
+ */
+export async function celebrate(event) {
+  playSound(event);
+
+  const cfg = CELEBRATIONS[event];
+  if (!cfg) return;
+
+  try {
+    await sweepBanner(cfg.color, cfg.icon, cfg.message);
+  } catch { /* non-fatal */ }
+}

package/lib/utils/persona-loader.js

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { getWorkflowDir } from './pipeline.js';
+
+const PERSONA_FILES = {
+  pm: 'pm.md',
+  architect: 'architect.md',
+  coder: 'coder.md',
+  reviewer: 'reviewer.md',
+};
+
+const DEFAULT_PERSONAS = {
+  pm: {
+    name: 'Product Manager',
+    content: 'You are a Product Manager. You write clear, structured feature specs with user stories, acceptance criteria, and technical risks.',
+  },
+  architect: {
+    name: 'System Architect',
+    content: 'You are a System Architect. You design scalable architectures with data flow diagrams, component breakdowns, and implementation task lists.',
+  },
+  coder: {
+    name: 'Senior Developer',
+    content: 'You are a Senior Developer. You write clean, tested, production-ready code following project conventions.',
+  },
+  reviewer: {
+    name: 'Code Reviewer',
+    content: 'You are a Code Reviewer. You review code for bugs, security issues, performance problems, and adherence to best practices.',
+  },
+};
+
+/**
+ * Return the persona directory path.
+ * @returns {string}
+ */
+export function getPersonaDir() {
+  return join(getWorkflowDir(), 'personas');
+}
+
+/**
+ * Load a persona for a given role.
+ * Falls back to default persona if no custom file exists.
+ * @param {string} role - One of: pm, architect, coder, reviewer
+ * @returns {{name: string, role: string, content: string, custom: boolean}}
+ */
+export function loadPersona(role) {
+  const def = DEFAULT_PERSONAS[role];
+  if (!def) throw new Error(`Unknown persona role: ${role}`);
+
+  const file = join(getPersonaDir(), PERSONA_FILES[role]);
+  if (existsSync(file)) {
+    const content = readFileSync(file, 'utf-8').trim();
+    const nameMatch = content.match(/^#\s+(.+)$/m);
+    const name = nameMatch ? nameMatch[1] : def.name;
+    return { name, role, content, custom: true };
+  }
+
+  return { name: def.name, role, content: def.content, custom: false };
+}
+
+/**
+ * List all available personas with role, name, and custom/default status.
+ * @returns {Array<{role: string, name: string, custom: boolean}>}
+ */
+export function listPersonas() {
+  return Object.keys(PERSONA_FILES).map(role => {
+    const persona = loadPersona(role);
+    return { role: persona.role, name: persona.name, custom: persona.custom };
+  });
+}
+
+/**
+ * Prepend persona identity to a prompt string.
+ * @param {string} prompt - The base prompt
+ * @param {string} role - Persona role to inject
+ * @returns {string} Prompt with persona prepended
+ */
+export function injectPersona(prompt, role) {
+  const persona = loadPersona(role);
+  return `${persona.content}\n\n${prompt}`;
+}

package/lib/utils/pipeline-lock.js

@@ -0,0 +1,73 @@
+/**
+ * Pipeline Lock — prevents concurrent pipeline actions.
+ *
+ * Uses file-based locking since AICC is single-process but may have
+ * multiple triggers (web API, Telegram, cron) firing simultaneously.
+ *
+ * File: .ai-workflow/.pipeline-lock
+ * Format: { holder: 'string', acquiredAt: ISO, expiresAt: ISO }
+ */
+
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { getWorkflowDir } from './pipeline.js';
+
+const LOCK_FILE = () => resolve(getWorkflowDir(), '.pipeline-lock');
+
+export function acquireLock(holder, ttlMs = 120_000) {
+  const lockPath = LOCK_FILE();
+
+  // Check existing lock
+  if (existsSync(lockPath)) {
+    try {
+      const existing = JSON.parse(readFileSync(lockPath, 'utf8'));
+      const expiresAt = new Date(existing.expiresAt).getTime();
+
+      if (Date.now() < expiresAt) {
+        // Lock is valid and held by someone else
+        return false;
+      }
+      // Lock expired — steal it
+    } catch {
+      // Corrupt lock file — remove and proceed
+    }
+  }
+
+  // Acquire lock
+  writeFileSync(lockPath, JSON.stringify({
+    holder,
+    acquiredAt: new Date().toISOString(),
+    expiresAt: new Date(Date.now() + ttlMs).toISOString(),
+  }));
+
+  return true;
+}
+
+export function releaseLock(holder) {
+  const lockPath = LOCK_FILE();
+  if (!existsSync(lockPath)) return;
+
+  try {
+    const existing = JSON.parse(readFileSync(lockPath, 'utf8'));
+    if (existing.holder === holder) {
+      unlinkSync(lockPath);
+    }
+  } catch {
+    // If we can't read it, try to remove anyway
+    try { unlinkSync(lockPath); } catch { /* ignore */ }
+  }
+}
+
+export function isLocked() {
+  const lockPath = LOCK_FILE();
+  if (!existsSync(lockPath)) return { locked: false };
+
+  try {
+    const existing = JSON.parse(readFileSync(lockPath, 'utf8'));
+    const expiresAt = new Date(existing.expiresAt).getTime();
+    if (Date.now() >= expiresAt) return { locked: false, expired: true };
+    return { locked: true, holder: existing.holder, expiresAt: existing.expiresAt };
+  } catch {
+    return { locked: false };
+  }
+}

package/lib/utils/pipeline.js

@@ -0,0 +1,214 @@
+import { createHash } from 'crypto';
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync, writeSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { ErrorCodes } from './errors.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Find the project root by walking up from cwd to find aicc.config.js.
+ * Falls back to __dirname/../../.. for backwards compatibility.
+ */
+function findRoot() {
+  let dir = process.cwd();
+  while (true) {
+    if (existsSync(resolve(dir, 'aicc.config.js'))) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  // Fallback: relative to package location (works when package IS the project)
+  return resolve(__dirname, '../../..');
+}
+
+const ROOT = findRoot();
+const STATUS_FILE = resolve(ROOT, '.ai-workflow/status.json');
+const WORKFLOW_DIR = resolve(ROOT, '.ai-workflow');
+
+// ─── Atomic Write ─────────────────────────────────────────────────────────────
+
+/**
+ * Write data to a file atomically: write to .tmp, fsync, rename.
+ * Prevents corruption from concurrent readers or crashes mid-write.
+ */
+export function atomicWriteSync(filePath, data) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  try {
+    const fd = openSync(tmpPath, 'w');
+    writeSync(fd, typeof data === 'string' ? data : JSON.stringify(data, null, 2));
+    fsyncSync(fd);
+    closeSync(fd);
+    renameSync(tmpPath, filePath);
+  } catch (err) {
+    try { if (existsSync(tmpPath)) unlinkSync(tmpPath); } catch { /* cleanup best-effort */ }
+    const wrapped = new Error(`[${ErrorCodes.STATE_WRITE_FAIL}] Failed to write ${filePath}: ${err.message}`);
+    wrapped.code = ErrorCodes.STATE_WRITE_FAIL;
+    throw wrapped;
+  }
+}
+
+export function getStatus() {
+  if (!existsSync(STATUS_FILE)) return { stage: 'idle', current_feature: null };
+  return JSON.parse(readFileSync(STATUS_FILE, 'utf8'));
+}
+
+export function updateStatus(updates) {
+  const current = getStatus();
+  const next = { ...current, ...updates };
+  atomicWriteSync(STATUS_FILE, JSON.stringify(next, null, 2));
+  return next;
+}
+
+// ─── Checkpoint System ────────────────────────────────────────────────────────
+
+const CHECKPOINT_DIR = resolve(WORKFLOW_DIR, 'checkpoints');
+
+/**
+ * Save a checkpoint after a successful sub-step within a pipeline stage.
+ */
+export function saveCheckpoint(featureId, stage, substep, data) {
+  if (!existsSync(CHECKPOINT_DIR)) mkdirSync(CHECKPOINT_DIR, { recursive: true });
+  const payload = {
+    featureId,
+    stage,
+    substep,
+    completedAt: new Date().toISOString(),
+    outputs: data,
+  };
+  const content = JSON.stringify(payload, null, 2);
+  payload.checksum = createHash('sha256').update(content).digest('hex');
+  const finalContent = JSON.stringify(payload, null, 2);
+  const filePath = resolve(CHECKPOINT_DIR, `${featureId}-${substep}.json`);
+  atomicWriteSync(filePath, finalContent);
+}
+
+/**
+ * Load a checkpoint. Validates SHA256 checksum; deletes corrupt files.
+ * Returns the checkpoint data or null if not found/invalid.
+ */
+export function loadCheckpoint(featureId, substep) {
+  const filePath = resolve(CHECKPOINT_DIR, `${featureId}-${substep}.json`);
+  if (!existsSync(filePath)) return null;
+  try {
+    const raw = readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    const { checksum, ...rest } = parsed;
+    const verify = createHash('sha256').update(JSON.stringify(rest, null, 2)).digest('hex');
+    if (verify !== checksum) {
+      console.error(`[${ErrorCodes.CHECKPOINT_CORRUPT}] Checkpoint corrupt: ${filePath} — deleting`);
+      try { unlinkSync(filePath); } catch { /* */ }
+      return null;
+    }
+    return parsed;
+  } catch {
+    console.error(`[${ErrorCodes.CHECKPOINT_CORRUPT}] Checkpoint unreadable: ${filePath} — deleting`);
+    try { unlinkSync(filePath); } catch { /* */ }
+    return null;
+  }
+}
+
+/**
+ * Clear all checkpoints for a feature (e.g. on new pipeline run).
+ */
+export function clearCheckpoints(featureId) {
+  if (!existsSync(CHECKPOINT_DIR)) return;
+  try {
+    const files = readdirSync(CHECKPOINT_DIR).filter(f => f.startsWith(featureId));
+    for (const f of files) {
+      try { unlinkSync(resolve(CHECKPOINT_DIR, f)); } catch { /* */ }
+    }
+  } catch { /* non-fatal */ }
+}
+
+export function getLatestFilePath(subdir) {
+  const dir = resolve(WORKFLOW_DIR, subdir);
+  if (!existsSync(dir)) return null;
+  const files = readdirSync(dir).filter(f => f.endsWith('.md')).sort().reverse();
+  return files.length ? resolve(dir, files[0]) : null;
+}
+
+export function readLatestFile(subdir) {
+  const filePath = getLatestFilePath(subdir);
+  if (!filePath) return null;
+  return readFileSync(filePath, 'utf8');
+}
+
+export function getWorkflowDir() { return WORKFLOW_DIR; }
+export function getRootDir() { return ROOT; }
+
+// ─── Predictive Pipeline Duration ─────────────────────────────────────────────
+
+export function calculateAverageStageDurations(costEntries) {
+  const stageDurations = {};
+  const stageCounts = {};
+
+  for (const entry of costEntries) {
+    const stage = entry.stage;
+    if (!stage || !entry.durationMs) continue;
+    if (!stageDurations[stage]) {
+      stageDurations[stage] = 0;
+      stageCounts[stage] = 0;
+    }
+    stageDurations[stage] += entry.durationMs;
+    stageCounts[stage]++;
+  }
+
+  const averages = {};
+  for (const stage of Object.keys(stageDurations)) {
+    averages[stage] = Math.round(stageDurations[stage] / stageCounts[stage]);
+  }
+  return averages;
+}
+
+export function getStagesAfter(currentStage) {
+  const stageOrder = ['spec', 'plan', 'pm', 'arch', 'architect', 'impl', 'implement', 'review', 'deploy'];
+  const idx = stageOrder.indexOf(currentStage);
+  if (idx === -1) return stageOrder;
+  return stageOrder.slice(idx + 1);
+}
+
+export function predictCompletion(currentStage, costEntries) {
+  const avgDurations = calculateAverageStageDurations(costEntries);
+  const remainingStages = getStagesAfter(currentStage);
+
+  const defaultDurations = {
+    spec: 60000, plan: 60000, pm: 60000,
+    arch: 120000, architect: 120000,
+    impl: 180000, implement: 180000,
+    review: 90000,
+    deploy: 60000,
+  };
+
+  let remainingMs = 0;
+
+  for (const stage of remainingStages) {
+    if (avgDurations[stage]) {
+      remainingMs += avgDurations[stage];
+    } else {
+      remainingMs += defaultDurations[stage] || 120000;
+    }
+  }
+
+  const dataPoints = costEntries.length;
+
+  return {
+    estimatedMs: remainingMs,
+    estimatedMinutes: Math.ceil(remainingMs / 60000),
+    estimatedCompletion: new Date(Date.now() + remainingMs).toISOString(),
+    confidence: dataPoints > 10 ? 'high' : dataPoints > 5 ? 'medium' : 'low',
+    dataPoints,
+    remainingStages: remainingStages.length,
+    avgDurations,
+  };
+}
+
+export function formatPrediction(prediction) {
+  if (!prediction) return '';
+  const confEmoji = { high: '🟢', medium: '🟡', low: '🔴' };
+  return `⏱️ ETA: ~${prediction.estimatedMinutes} min ` +
+    `${confEmoji[prediction.confidence] || '⚪'} ` +
+    `(${prediction.confidence} confidence, based on ${prediction.dataPoints} data points)`;
+}