ai-control-center 1.15.2

package/lib/hub/project-poller.js

@@ -0,0 +1,75 @@
+/**
+ * Project Poller — periodically fetches /api/status and /api/health
+ * from each registered project instance.
+ */
+
+export class ProjectPoller {
+  /**
+   * @param {Array<{name:string, url:string, color?:string}>} projects
+   * @param {import('./state-aggregator.js').StateAggregator} aggregator
+   * @param {number} intervalMs — polling interval (default 3000ms)
+   */
+  constructor(projects, aggregator, intervalMs = 3000) {
+    this._projects = projects;
+    this._aggregator = aggregator;
+    this._intervalMs = intervalMs;
+    this._timer = null;
+  }
+
+  /** Start polling all projects */
+  start() {
+    this._poll(); // immediate first poll
+    this._timer = setInterval(() => this._poll(), this._intervalMs);
+    console.log(`  [Hub] Polling ${this._projects.length} project(s) every ${this._intervalMs / 1000}s`);
+  }
+
+  /** Stop polling */
+  stop() {
+    if (this._timer) { clearInterval(this._timer); this._timer = null; }
+  }
+
+  /** Immediately re-poll a single project by name (called on push-event) */
+  pollProject(name) {
+    const project = this._projects.find(p => p.name === name);
+    if (project) this._pollOne(project).catch(() => {});
+  }
+
+  /** Poll all projects in parallel */
+  async _poll() {
+    await Promise.allSettled(
+      this._projects.map(p => this._pollOne(p))
+    );
+  }
+
+  /** Poll a single project */
+  async _pollOne(project) {
+    const { name, url } = project;
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 5000);
+
+      const [statusRes, healthRes] = await Promise.allSettled([
+        fetch(`${url}/api/status`, { signal: controller.signal }),
+        fetch(`${url}/api/health`, { signal: controller.signal }),
+      ]);
+
+      clearTimeout(timeout);
+
+      const status = statusRes.status === 'fulfilled' && statusRes.value.ok
+        ? await statusRes.value.json()
+        : null;
+
+      const health = healthRes.status === 'fulfilled' && healthRes.value.ok
+        ? await healthRes.value.json()
+        : null;
+
+      if (status || health) {
+        this._aggregator.update(name, status, health);
+      } else {
+        this._aggregator.markOffline(name);
+      }
+    } catch {
+      this._aggregator.markOffline(name);
+    }
+  }
+}

package/lib/hub/skill-registry.js

@@ -0,0 +1,89 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { getWorkflowDir } from '../utils/pipeline.js';
+
+const REGISTRY_FILENAME = 'skills_index.json';
+
+const DEFAULT_REGISTRY = [
+  { name: 'security-review', stage: 'review', description: 'Security-focused code review with OWASP checklist', tags: ['security', 'review', 'owasp'], source: 'built-in' },
+  { name: 'api-design', stage: 'arch', description: 'REST API design best practices and validation', tags: ['api', 'rest', 'architecture'], source: 'built-in' },
+  { name: 'unit-testing', stage: 'test', description: 'Unit test generation and coverage analysis', tags: ['testing', 'unit-tests', 'coverage'], source: 'built-in' },
+  { name: 'integration-testing', stage: 'test', description: 'Integration and end-to-end test patterns', tags: ['testing', 'integration', 'e2e'], source: 'built-in' },
+  { name: 'performance-audit', stage: 'review', description: 'Performance profiling and optimization recommendations', tags: ['performance', 'profiling', 'optimization'], source: 'built-in' },
+  { name: 'accessibility-check', stage: 'review', description: 'WCAG compliance and accessibility audit', tags: ['accessibility', 'a11y', 'wcag'], source: 'built-in' },
+  { name: 'doc-generator', stage: 'docs', description: 'Auto-generate API and module documentation', tags: ['documentation', 'jsdoc', 'markdown'], source: 'built-in' },
+  { name: 'db-schema-review', stage: 'arch', description: 'Database schema design and migration review', tags: ['database', 'schema', 'migrations'], source: 'built-in' },
+  { name: 'error-handling', stage: 'review', description: 'Error handling patterns and resilience checks', tags: ['error-handling', 'resilience', 'exceptions'], source: 'built-in' },
+  { name: 'logging-standards', stage: 'review', description: 'Structured logging and observability best practices', tags: ['logging', 'observability', 'monitoring'], source: 'built-in' },
+  { name: 'ci-cd-pipeline', stage: 'deploy', description: 'CI/CD pipeline configuration and optimization', tags: ['ci-cd', 'github-actions', 'deployment'], source: 'built-in' },
+  { name: 'containerization', stage: 'deploy', description: 'Dockerfile and container best practices', tags: ['docker', 'containerization', 'kubernetes'], source: 'built-in' },
+  { name: 'frontend-patterns', stage: 'arch', description: 'Frontend architecture patterns and component design', tags: ['frontend', 'components', 'state-management'], source: 'built-in' },
+  { name: 'mobile-dev', stage: 'arch', description: 'Mobile development patterns and platform guidelines', tags: ['mobile', 'ios', 'android'], source: 'built-in' },
+  { name: 'code-quality', stage: 'review', description: 'Code quality metrics, linting, and style enforcement', tags: ['code-quality', 'linting', 'style'], source: 'built-in' },
+  { name: 'refactoring', stage: 'review', description: 'Refactoring patterns and code smell detection', tags: ['refactoring', 'code-smells', 'clean-code'], source: 'built-in' },
+  { name: 'dependency-audit', stage: 'review', description: 'Dependency vulnerability scanning and license checks', tags: ['security', 'dependencies', 'vulnerabilities'], source: 'built-in' },
+  { name: 'api-testing', stage: 'test', description: 'API contract testing and response validation', tags: ['testing', 'api', 'contract-testing'], source: 'built-in' },
+];
+
+export function getRegistryPath() {
+  return resolve(getWorkflowDir(), REGISTRY_FILENAME);
+}
+
+export function getDefaultRegistry() {
+  return structuredClone(DEFAULT_REGISTRY);
+}
+
+export function getRegistry() {
+  const registryPath = getRegistryPath();
+  if (!existsSync(registryPath)) {
+    return getDefaultRegistry();
+  }
+  try {
+    const raw = readFileSync(registryPath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return getDefaultRegistry();
+  }
+}
+
+export function searchSkills(query) {
+  const registry = getRegistry();
+  const q = query.toLowerCase();
+  return registry.filter((skill) => {
+    const haystack = [
+      skill.name,
+      skill.description,
+      ...(skill.tags || []),
+    ].join(' ').toLowerCase();
+    return haystack.includes(q);
+  });
+}
+
+export function filterByStage(stage) {
+  const registry = getRegistry();
+  const s = stage.toLowerCase();
+  return registry.filter((skill) => (skill.stage || '').toLowerCase() === s);
+}
+
+export function addToRegistry(skillMeta) {
+  const registry = getRegistry();
+  const existing = registry.findIndex((s) => s.name === skillMeta.name);
+  if (existing !== -1) {
+    registry[existing] = { ...registry[existing], ...skillMeta };
+  } else {
+    registry.push(skillMeta);
+  }
+  const registryPath = getRegistryPath();
+  mkdirSync(dirname(registryPath), { recursive: true });
+  writeFileSync(registryPath, JSON.stringify(registry, null, 2), 'utf-8');
+  return registry;
+}
+
+export function removeFromRegistry(skillName) {
+  const registry = getRegistry();
+  const filtered = registry.filter((s) => s.name !== skillName);
+  const registryPath = getRegistryPath();
+  mkdirSync(dirname(registryPath), { recursive: true });
+  writeFileSync(registryPath, JSON.stringify(filtered, null, 2), 'utf-8');
+  return filtered;
+}

package/lib/hub/state-aggregator.js

@@ -0,0 +1,204 @@
+/**
+ * State Aggregator — merges status from multiple AICC project instances.
+ *
+ * Provides functions to aggregate, diff, and format multi-project state.
+ * Also exports the StateAggregator class for internal hub use.
+ */
+
+// ─── StateAggregator class (used by project-poller.js) ─────────────────────────
+
+/**
+ * Maintains an in-memory Map of project states, updated by the poller.
+ * Broadcasts changes via a callback.
+ */
+export class StateAggregator {
+  constructor() {
+    /** @type {Map<string, object>} */
+    this._states = new Map();
+    this._listeners = [];
+  }
+
+  /** Register a listener called on any state change */
+  onChange(fn) { this._listeners.push(fn); }
+
+  /** Update a single project's state */
+  update(projectName, status, health) {
+    const prev = this._states.get(projectName);
+    const next = {
+      name: projectName,
+      status: status || {},
+      health: health || {},
+      online: !!status,
+      lastPoll: Date.now(),
+    };
+
+    const changed = !prev
+      || prev.status?.stage !== next.status?.stage
+      || prev.status?.current_feature !== next.status?.current_feature
+      || prev.online !== next.online
+      || JSON.stringify(prev.status?._bannedModels) !== JSON.stringify(next.status?._bannedModels);
+
+    this._states.set(projectName, next);
+
+    if (changed) {
+      for (const fn of this._listeners) {
+        try { fn(projectName, next); } catch (e) { console.error('[Hub] listener error:', e.message); }
+      }
+    }
+  }
+
+  /** Mark a project as offline */
+  markOffline(projectName) {
+    const prev = this._states.get(projectName);
+    if (prev && prev.online) {
+      prev.online = false;
+      prev.lastPoll = Date.now();
+      for (const fn of this._listeners) {
+        try { fn(projectName, prev); } catch (e) { console.error('[Hub] listener error:', e.message); }
+      }
+    }
+  }
+
+  /** Get all project states as array */
+  getAll() {
+    return Array.from(this._states.values());
+  }
+
+  /** Get single project state */
+  get(name) {
+    return this._states.get(name) || null;
+  }
+}
+
+// ─── Functional API ────────────────────────────────────────────────────────────
+
+/**
+ * Merge state from multiple projects into a single aggregated object.
+ *
+ * @param {Array<{name:string, url:string, color?:string, icon?:string}>} projectConfigs
+ * @param {Array<{name:string, status:object|null, health:object|null, online:boolean}>} responses
+ * @returns {object} Aggregated state
+ */
+export function aggregateStates(projectConfigs, responses) {
+  const projects = {};
+  let active = 0;
+  let idle = 0;
+  let offline = 0;
+
+  for (const cfg of projectConfigs) {
+    const resp = responses.find(r => r.name === cfg.name) || { status: null, health: null, online: false };
+    const isOnline = resp.online;
+
+    projects[cfg.name] = {
+      name: cfg.name,
+      url: cfg.url,
+      color: cfg.color || '#888888',
+      icon: cfg.icon || '📦',
+      status: resp.status || {},
+      health: resp.health || {},
+      online: isOnline,
+    };
+
+    if (!isOnline) {
+      offline++;
+    } else {
+      const stage = resp.status?.stage || '';
+      const activeStages = ['reviewing', 'implementing', 'deploying', 'testing', 'fixing'];
+      if (activeStages.some(s => stage.toLowerCase().includes(s))) {
+        active++;
+      } else {
+        idle++;
+      }
+    }
+  }
+
+  return {
+    timestamp: Date.now(),
+    projects,
+    summary: {
+      total: projectConfigs.length,
+      active,
+      idle,
+      offline,
+    },
+  };
+}
+
+/**
+ * Compare two aggregated states and return an array of change events.
+ *
+ * @param {object} oldState — previous aggregated state
+ * @param {object} newState — current aggregated state
+ * @returns {Array<{project:string, type:string, from:*, to:*}>}
+ */
+export function detectChanges(oldState, newState) {
+  const changes = [];
+  if (!oldState || !newState) return changes;
+
+  for (const [name, newProject] of Object.entries(newState.projects)) {
+    const oldProject = oldState.projects?.[name];
+
+    if (!oldProject) {
+      changes.push({ project: name, type: 'added', from: null, to: newProject });
+      continue;
+    }
+
+    // Online/offline transitions
+    if (oldProject.online !== newProject.online) {
+      changes.push({
+        project: name,
+        type: 'connectivity',
+        from: oldProject.online ? 'online' : 'offline',
+        to: newProject.online ? 'online' : 'offline',
+      });
+    }
+
+    // Stage transitions
+    const oldStage = oldProject.status?.stage;
+    const newStage = newProject.status?.stage;
+    if (oldStage !== newStage) {
+      changes.push({ project: name, type: 'stage', from: oldStage, to: newStage });
+    }
+
+    // Feature changes
+    const oldFeature = oldProject.status?.current_feature;
+    const newFeature = newProject.status?.current_feature;
+    if (oldFeature !== newFeature) {
+      changes.push({ project: name, type: 'feature', from: oldFeature, to: newFeature });
+    }
+  }
+
+  // Detect removals
+  for (const name of Object.keys(oldState.projects || {})) {
+    if (!newState.projects[name]) {
+      changes.push({ project: name, type: 'removed', from: oldState.projects[name], to: null });
+    }
+  }
+
+  return changes;
+}
+
+/**
+ * Format aggregated state as a human-readable string.
+ *
+ * @param {object} aggregated — output of aggregateStates()
+ * @returns {string}
+ */
+export function formatHubStatus(aggregated) {
+  if (!aggregated) return 'Hub: no data';
+
+  const { summary, projects } = aggregated;
+  const lines = [
+    `🏢 Hub Status — ${summary.total} project(s): ${summary.active} active, ${summary.idle} idle, ${summary.offline} offline`,
+    '─'.repeat(50),
+  ];
+
+  for (const p of Object.values(projects)) {
+    const statusIcon = p.online ? '🟢' : '🔴';
+    const stage = p.status?.stage || 'unknown';
+    const feature = p.status?.current_feature || '—';
+    lines.push(`  ${statusIcon} ${p.icon} ${p.name}  │  ${stage}  │  ${feature}`);
+  }
+
+  return lines.join('\n');
+}