@accelerationguy/accel 1.0.0

package/shared/events/event-bus.js

@@ -0,0 +1,134 @@
+/**
+ * Accelerate Event Bus — File-based cross-module communication
+ *
+ * Modules write JSON event files to ~/.accel/events/
+ * Consuming modules read events on their next invocation
+ * Processed events move to ~/.accel/events/archive/
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const EVENTS_DIR = path.join(os.homedir(), '.accel', 'events');
+const ARCHIVE_DIR = path.join(EVENTS_DIR, 'archive');
+const ERRORS_DIR = path.join(EVENTS_DIR, 'errors');
+const SCHEMAS_DIR = path.join(EVENTS_DIR, 'schemas');
+const MANIFEST_PATH = path.join(os.homedir(), '.accel', 'manifest.json');
+
+let sequenceCounter = 0;
+
+function ensureDirs() {
+  for (const dir of [EVENTS_DIR, ARCHIVE_DIR, ERRORS_DIR, SCHEMAS_DIR]) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function getRegisteredModules() {
+  try {
+    const manifest = JSON.parse(fs.readFileSync(MANIFEST_PATH, 'utf8'));
+    return Object.keys(manifest.modules || {});
+  } catch {
+    return [];
+  }
+}
+
+function validateProducer(event) {
+  const registered = getRegisteredModules();
+  if (!event._producer || !registered.includes(event._producer)) {
+    return `Unknown producer: ${event._producer}. Registered: ${registered.join(', ')}`;
+  }
+  return null;
+}
+
+function emit(source, type, payload) {
+  ensureDirs();
+
+  const event = {
+    _producer: source,
+    source,
+    type,
+    payload,
+    timestamp: new Date().toISOString(),
+  };
+
+  const producerError = validateProducer(event);
+  if (producerError) {
+    const errorFile = path.join(ERRORS_DIR, `${Date.now()}-invalid-producer.json`);
+    fs.writeFileSync(errorFile, JSON.stringify({ error: producerError, event }, null, 2));
+    throw new Error(producerError);
+  }
+
+  const seq = String(sequenceCounter++).padStart(4, '0');
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const filename = `${ts}-${seq}-${source}-${type}.json`;
+
+  fs.writeFileSync(path.join(EVENTS_DIR, filename), JSON.stringify(event, null, 2));
+  return filename;
+}
+
+function consume(consumerModule, eventTypes) {
+  ensureDirs();
+
+  const events = [];
+  const files = fs.readdirSync(EVENTS_DIR).filter((f) => f.endsWith('.json'));
+
+  for (const file of files) {
+    try {
+      const filePath = path.join(EVENTS_DIR, file);
+      const event = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+
+      if (eventTypes && !eventTypes.includes(event.type)) continue;
+
+      const producerError = validateProducer(event);
+      if (producerError) {
+        fs.renameSync(filePath, path.join(ERRORS_DIR, file));
+        continue;
+      }
+
+      events.push({ file, event });
+
+      // Move to archive
+      fs.renameSync(filePath, path.join(ARCHIVE_DIR, file));
+    } catch (e) {
+      // Malformed event — move to errors
+      const filePath = path.join(EVENTS_DIR, file);
+      const errorData = JSON.stringify({ error: e.message, file }, null, 2);
+      fs.writeFileSync(path.join(ERRORS_DIR, `${file}.error.json`), errorData);
+      try { fs.renameSync(filePath, path.join(ERRORS_DIR, file)); } catch {}
+    }
+  }
+
+  return events;
+}
+
+function cleanup(maxAgeDays = 7) {
+  ensureDirs();
+
+  const now = Date.now();
+  const maxAge = maxAgeDays * 24 * 60 * 60 * 1000;
+  const registered = getRegisteredModules();
+  const maxArchive = registered.length * 100;
+
+  // Clean old events from main dir
+  for (const file of fs.readdirSync(EVENTS_DIR).filter((f) => f.endsWith('.json'))) {
+    const filePath = path.join(EVENTS_DIR, file);
+    const stat = fs.statSync(filePath);
+    if (now - stat.mtimeMs > maxAge) {
+      fs.unlinkSync(filePath);
+    }
+  }
+
+  // Cap archive
+  const archiveFiles = fs.readdirSync(ARCHIVE_DIR)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => ({ name: f, time: fs.statSync(path.join(ARCHIVE_DIR, f)).mtimeMs }))
+    .sort((a, b) => a.time - b.time);
+
+  while (archiveFiles.length > maxArchive) {
+    const oldest = archiveFiles.shift();
+    fs.unlinkSync(path.join(ARCHIVE_DIR, oldest.name));
+  }
+}
+
+module.exports = { emit, consume, cleanup, EVENTS_DIR, ARCHIVE_DIR };

package/shared/events/event_bus.py

@@ -0,0 +1,255 @@
+#!/usr/bin/env python3
+"""
+Accelerate Event Bus — Python implementation
+
+File-based cross-module communication matching the Node.js event-bus.js format.
+Modules write JSON event files to ~/.accel/events/
+Consuming modules read events on their next invocation.
+Processed events move to ~/.accel/events/archive/
+
+Event file format (identical to Node.js version):
+{
+    "_producer": "ignition",
+    "source": "ignition",
+    "type": "plan-created",
+    "payload": { ... },
+    "timestamp": "2026-03-26T12:00:00.000Z"
+}
+"""
+
+import json
+import os
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+
+ACCEL_HOME = Path.home() / ".accel"
+EVENTS_DIR = ACCEL_HOME / "events"
+ARCHIVE_DIR = EVENTS_DIR / "archive"
+ERRORS_DIR = EVENTS_DIR / "errors"
+SCHEMAS_DIR = EVENTS_DIR / "schemas"
+MANIFEST_PATH = ACCEL_HOME / "manifest.json"
+
+_sequence_counter = 0
+
+
+def _ensure_dirs():
+    """Create event directories if they don't exist."""
+    for d in [EVENTS_DIR, ARCHIVE_DIR, ERRORS_DIR, SCHEMAS_DIR]:
+        d.mkdir(parents=True, exist_ok=True)
+
+
+def _get_registered_modules():
+    """Read registered module IDs from the Accelerate manifest."""
+    try:
+        manifest = json.loads(MANIFEST_PATH.read_text())
+        return list(manifest.get("modules", {}).keys())
+    except (json.JSONDecodeError, OSError, FileNotFoundError):
+        return []
+
+
+def validate_producer(event):
+    """
+    Check that event._producer is a registered module.
+
+    Returns None if valid, or an error string if invalid.
+    """
+    registered = _get_registered_modules()
+    producer = event.get("_producer")
+    if not producer or producer not in registered:
+        return f"Unknown producer: {producer}. Registered: {', '.join(registered)}"
+    return None
+
+
+def emit(source, event_type, payload):
+    """
+    Write an event JSON file to ~/.accel/events/.
+
+    Args:
+        source: Module ID emitting the event (e.g. 'ignition', 'radar')
+        event_type: Event type string (e.g. 'plan-created', 'audit-complete')
+        payload: Dict of event-specific data
+
+    Returns:
+        The filename of the written event file.
+
+    Raises:
+        ValueError: If the source module is not registered in the manifest.
+    """
+    global _sequence_counter
+    _ensure_dirs()
+
+    event = {
+        "_producer": source,
+        "source": source,
+        "type": event_type,
+        "payload": payload,
+        "timestamp": datetime.utcnow().isoformat(timespec="milliseconds") + "Z",
+    }
+
+    # Validate producer
+    error = validate_producer(event)
+    if error:
+        error_file = ERRORS_DIR / f"{int(time.time() * 1000)}-invalid-producer.json"
+        error_file.write_text(json.dumps({"error": error, "event": event}, indent=2))
+        raise ValueError(error)
+
+    # Build filename matching Node.js format: timestamp-seq-source-type.json
+    seq = str(_sequence_counter).zfill(4)
+    _sequence_counter += 1
+    ts = datetime.utcnow().isoformat(timespec="milliseconds").replace(":", "-").replace(".", "-")
+    filename = f"{ts}Z-{seq}-{source}-{event_type}.json"
+
+    event_path = EVENTS_DIR / filename
+    event_path.write_text(json.dumps(event, indent=2))
+    return filename
+
+
+def consume(event_types=None):
+    """
+    Read and archive matching event files from ~/.accel/events/.
+
+    Args:
+        event_types: Optional list of event type strings to filter by.
+                     If None, consumes all events.
+
+    Returns:
+        List of dicts: [{"file": filename, "event": event_dict}, ...]
+    """
+    _ensure_dirs()
+
+    events = []
+    files = sorted(f for f in EVENTS_DIR.iterdir() if f.is_file() and f.suffix == ".json")
+
+    for filepath in files:
+        try:
+            event = json.loads(filepath.read_text())
+
+            # Filter by event type if specified
+            if event_types and event.get("type") not in event_types:
+                continue
+
+            # Validate producer
+            error = validate_producer(event)
+            if error:
+                filepath.rename(ERRORS_DIR / filepath.name)
+                continue
+
+            events.append({"file": filepath.name, "event": event})
+
+            # Move to archive
+            filepath.rename(ARCHIVE_DIR / filepath.name)
+
+        except (json.JSONDecodeError, OSError) as e:
+            # Malformed event — move to errors
+            error_data = json.dumps({"error": str(e), "file": filepath.name}, indent=2)
+            (ERRORS_DIR / f"{filepath.name}.error.json").write_text(error_data)
+            try:
+                filepath.rename(ERRORS_DIR / filepath.name)
+            except OSError:
+                pass
+
+    return events
+
+
+def cleanup(max_age_days=7):
+    """
+    Remove old events from the events directory and cap the archive.
+
+    Args:
+        max_age_days: Events older than this are removed from the main dir.
+    """
+    _ensure_dirs()
+
+    now = time.time()
+    max_age_seconds = max_age_days * 24 * 60 * 60
+    registered = _get_registered_modules()
+    max_archive = max(len(registered) * 100, 100)
+
+    # Clean old events from main dir
+    for filepath in EVENTS_DIR.iterdir():
+        if filepath.is_file() and filepath.suffix == ".json":
+            try:
+                age = now - filepath.stat().st_mtime
+                if age > max_age_seconds:
+                    filepath.unlink()
+            except OSError:
+                pass
+
+    # Cap archive size
+    archive_files = []
+    for filepath in ARCHIVE_DIR.iterdir():
+        if filepath.is_file() and filepath.suffix == ".json":
+            try:
+                archive_files.append((filepath, filepath.stat().st_mtime))
+            except OSError:
+                pass
+
+    archive_files.sort(key=lambda x: x[1])
+
+    while len(archive_files) > max_archive:
+        oldest_path, _ = archive_files.pop(0)
+        try:
+            oldest_path.unlink()
+        except OSError:
+            pass
+
+
+def peek(event_types=None):
+    """
+    Read matching events WITHOUT archiving them (non-destructive).
+
+    Useful for checking what's pending without consuming.
+
+    Args:
+        event_types: Optional list of event type strings to filter by.
+
+    Returns:
+        List of dicts: [{"file": filename, "event": event_dict}, ...]
+    """
+    _ensure_dirs()
+
+    events = []
+    files = sorted(f for f in EVENTS_DIR.iterdir() if f.is_file() and f.suffix == ".json")
+
+    for filepath in files:
+        try:
+            event = json.loads(filepath.read_text())
+            if event_types and event.get("type") not in event_types:
+                continue
+            events.append({"file": filepath.name, "event": event})
+        except (json.JSONDecodeError, OSError):
+            pass
+
+    return events
+
+
+# ─── Convenience emitters matching integrations.js ─────────────
+
+def emit_plan_created(plan_path, project_type, title):
+    """Emit a plan-created event (Ignition -> Drive/Momentum)."""
+    return emit("ignition", "plan-created", {
+        "path": str(plan_path),
+        "projectType": project_type,
+        "title": title,
+    })
+
+
+def emit_phase_progress(phase, status, plan_path="", completed_tasks=0, total_tasks=0):
+    """Emit a phase-progress event (Drive -> Momentum)."""
+    return emit("drive", "phase-progress", {
+        "phase": phase,
+        "status": status,
+        "planPath": str(plan_path),
+        "completedTasks": completed_tasks,
+        "totalTasks": total_tasks,
+    })
+
+
+def emit_audit_complete(findings, critical, report_path):
+    """Emit an audit-complete event (Radar -> Momentum)."""
+    return emit("radar", "audit-complete", {
+        "findings": findings,
+        "critical": critical,
+        "report": str(report_path),
+    })

package/shared/events/integrations.js

@@ -0,0 +1,161 @@
+/**
+ * Accelerate Cross-Module Integration Points
+ *
+ * These functions are called by module hooks to emit/consume events
+ * that wire modules together.
+ *
+ * Integration map:
+ *   Ignition -> Drive:    plan-created -> Drive picks up as next plan
+ *   Drive -> Momentum:    phase-progress -> Momentum tracks in workspace state
+ *   Radar -> Momentum:    audit-complete -> Momentum adds findings to backlog
+ *   Vector -> All:        Rules are injected via hook, no event bus needed
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const eventBus = require('./event-bus');
+
+const ACCEL_HOME = path.join(os.homedir(), '.accel');
+
+function moduleInstalled(moduleId) {
+  const manifestPath = path.join(ACCEL_HOME, 'manifest.json');
+  try {
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    return !!manifest.modules[moduleId];
+  } catch {
+    return false;
+  }
+}
+
+// ─── Ignition -> Drive ──────────────────────────────────────
+// Called when Ignition produces a PLANNING.md
+function onPlanCreated(planPath, projectType, title) {
+  if (!moduleInstalled('ignition')) return;
+
+  eventBus.emit('ignition', 'plan-created', {
+    path: planPath,
+    projectType,
+    title,
+  });
+
+  // If Drive is installed, also write a breadcrumb so Drive
+  // can find the latest plan on next invocation
+  if (moduleInstalled('drive')) {
+    const driveState = path.join(ACCEL_HOME, 'modules', 'drive', '.latest-plan');
+    fs.mkdirSync(path.dirname(driveState), { recursive: true });
+    fs.writeFileSync(driveState, JSON.stringify({
+      path: planPath,
+      projectType,
+      title,
+      createdAt: new Date().toISOString(),
+    }, null, 2));
+  }
+}
+
+// ─── Drive -> Momentum ──────────────────────────────────────
+// Called when Drive completes a phase or updates progress
+function onPhaseProgress(phase, status, planPath, completedTasks, totalTasks) {
+  if (!moduleInstalled('drive')) return;
+
+  eventBus.emit('drive', 'phase-progress', {
+    phase,
+    status,
+    planPath: planPath || '',
+    completedTasks: completedTasks || 0,
+    totalTasks: totalTasks || 0,
+  });
+
+  // If Momentum is installed, update the workspace state directly
+  if (moduleInstalled('momentum')) {
+    const stateFile = path.join(ACCEL_HOME, 'modules', 'momentum', 'data', 'state.json');
+    try {
+      const state = fs.existsSync(stateFile)
+        ? JSON.parse(fs.readFileSync(stateFile, 'utf8'))
+        : { currentPhase: null, phases: [] };
+
+      state.currentPhase = phase;
+      state.lastUpdated = new Date().toISOString();
+      if (status === 'completed') {
+        if (!state.phases) state.phases = [];
+        state.phases.push({ phase, completedAt: new Date().toISOString() });
+      }
+
+      fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+      fs.writeFileSync(stateFile, JSON.stringify(state, null, 2));
+    } catch {
+      // Non-fatal — event bus is the primary channel
+    }
+  }
+}
+
+// ─── Radar -> Momentum ──────────────────────────────────────
+// Called when Radar completes a security audit
+function onAuditComplete(findings, critical, reportPath) {
+  if (!moduleInstalled('radar')) return;
+
+  eventBus.emit('radar', 'audit-complete', {
+    findings,
+    critical,
+    report: reportPath,
+  });
+
+  // If Momentum is installed, create a backlog item
+  if (moduleInstalled('momentum')) {
+    const backlogDir = path.join(ACCEL_HOME, 'modules', 'momentum', 'data', 'backlog');
+    fs.mkdirSync(backlogDir, { recursive: true });
+
+    const item = {
+      id: `radar-${Date.now()}`,
+      type: 'audit-finding',
+      source: 'radar',
+      title: `Radar found ${findings} issue${findings !== 1 ? 's' : ''} (${critical} critical)`,
+      priority: critical > 0 ? 'high' : 'medium',
+      report: reportPath,
+      createdAt: new Date().toISOString(),
+      status: 'open',
+    };
+
+    const itemPath = path.join(backlogDir, `${item.id}.json`);
+    fs.writeFileSync(itemPath, JSON.stringify(item, null, 2));
+  }
+}
+
+// ─── Event Consumer ─────────────────────────────────────────
+// Called by Momentum's hook to process pending events
+function processPendingEvents() {
+  if (!moduleInstalled('momentum')) return [];
+
+  const processed = [];
+
+  // Consume audit-complete events
+  const auditEvents = eventBus.consume('momentum', ['audit-complete']);
+  for (const { event } of auditEvents) {
+    processed.push(`Radar audit: ${event.payload.findings} findings, ${event.payload.critical} critical`);
+  }
+
+  // Consume phase-progress events
+  const phaseEvents = eventBus.consume('momentum', ['phase-progress']);
+  for (const { event } of phaseEvents) {
+    processed.push(`Drive phase "${event.payload.phase}": ${event.payload.status}`);
+  }
+
+  // Consume plan-created events
+  const planEvents = eventBus.consume('momentum', ['plan-created']);
+  for (const { event } of planEvents) {
+    processed.push(`Ignition plan created: "${event.payload.title}" (${event.payload.projectType})`);
+  }
+
+  // Run cleanup
+  eventBus.cleanup();
+
+  return processed;
+}
+
+module.exports = {
+  onPlanCreated,
+  onPhaseProgress,
+  onAuditComplete,
+  processPendingEvents,
+  moduleInstalled,
+};

package/shared/events/schemas/audit-complete.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Radar Audit Complete Event",
+  "type": "object",
+  "required": ["_producer", "source", "type", "payload", "timestamp"],
+  "properties": {
+    "_producer": { "const": "radar" },
+    "source": { "const": "radar" },
+    "type": { "const": "audit-complete" },
+    "timestamp": { "type": "string", "format": "date-time" },
+    "payload": {
+      "type": "object",
+      "required": ["findings", "critical", "report"],
+      "properties": {
+        "findings": { "type": "integer", "minimum": 0 },
+        "critical": { "type": "integer", "minimum": 0 },
+        "report": { "type": "string" }
+      }
+    }
+  }
+}

package/shared/events/schemas/phase-progress.schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Drive Phase Progress Event",
+  "type": "object",
+  "required": ["_producer", "source", "type", "payload", "timestamp"],
+  "properties": {
+    "_producer": { "const": "drive" },
+    "source": { "const": "drive" },
+    "type": { "const": "phase-progress" },
+    "timestamp": { "type": "string", "format": "date-time" },
+    "payload": {
+      "type": "object",
+      "required": ["phase", "status"],
+      "properties": {
+        "phase": { "type": "string" },
+        "status": { "enum": ["started", "in-progress", "completed", "blocked"] },
+        "planPath": { "type": "string" },
+        "completedTasks": { "type": "integer", "minimum": 0 },
+        "totalTasks": { "type": "integer", "minimum": 0 }
+      }
+    }
+  }
+}

package/shared/events/schemas/plan-created.schema.json

@@ -0,0 +1,21 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "Ignition Plan Created Event",
+  "type": "object",
+  "required": ["_producer", "source", "type", "payload", "timestamp"],
+  "properties": {
+    "_producer": { "const": "ignition" },
+    "source": { "const": "ignition" },
+    "type": { "const": "plan-created" },
+    "timestamp": { "type": "string", "format": "date-time" },
+    "payload": {
+      "type": "object",
+      "required": ["path", "projectType", "title"],
+      "properties": {
+        "path": { "type": "string" },
+        "projectType": { "enum": ["application", "campaign", "client", "utility", "workflow"] },
+        "title": { "type": "string" }
+      }
+    }
+  }
+}