@accelerationguy/accel 1.0.0

package/modules/momentum/src/hooks/satellite-detection.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python3
+"""
+Hook: satellite-detection.py
+Purpose: Scans the workspace recursively for .drive/drive.json files,
+         auto-registers new satellites, and syncs drive.json state to
+         workspace.json and projects.json.
+Triggers: SessionStart — runs once when Claude Code starts a session.
+Output: <momentum-satellites> block if new satellites registered, silent otherwise.
+
+Sync flow (drive.json → workspace.json → projects.json):
+  1. Discover drive.json files across workspace
+  2. Register new satellites (existing behavior)
+  3. Sync drive.json state to workspace.json satellite entries
+  4. Cross-check projects.json: update drive field on matching projects
+  Respects satellite.sync: false as opt-out for steps 3-4.
+"""
+
+import sys
+import json
+from datetime import datetime
+from pathlib import Path
+
+# Workspace root — find .accel/momentum/ relative to this hook's location
+HOOK_DIR = Path(__file__).resolve().parent
+WORKSPACE_ROOT = HOOK_DIR.parent.parent  # hooks/ -> .accel/momentum/ -> workspace
+BASE_DIR = WORKSPACE_ROOT / ".accel/momentum"
+MANIFEST_FILE = BASE_DIR / "workspace.json"
+PROJECTS_FILE = BASE_DIR / "data" / "projects.json"
+
+
+def has_hidden_component(path: Path, workspace_root: Path) -> bool:
+    """
+    Return True if any component of path (relative to workspace_root) starts with '.',
+    excluding '.drive' itself (which is the expected target directory).
+    """
+    try:
+        rel = path.relative_to(workspace_root)
+    except ValueError:
+        return True  # Can't relativize — skip it
+    return any(part.startswith(".") and part != ".drive" for part in rel.parts)
+
+
+def find_drive_json_files(workspace_root: Path) -> list[Path]:
+    """
+    Recursively scan workspace_root for .drive/drive.json files.
+    Skips any path that has a hidden directory component (starts with '.').
+    """
+    results = []
+    try:
+        for drive_json in workspace_root.rglob(".drive/drive.json"):
+            if not has_hidden_component(drive_json, workspace_root):
+                results.append(drive_json)
+    except (OSError, PermissionError):
+        pass
+    return results
+
+
+def should_sync(drive_data: dict) -> bool:
+    """Check if this satellite opts into sync. Default: True."""
+    satellite = drive_data.get("satellite", {})
+    return satellite.get("sync", True)
+
+
+def sync_to_workspace(satellites: dict, drive_data: dict, name: str) -> bool:
+    """Sync drive.json state to workspace.json satellite entry. Returns True if changed."""
+    if name not in satellites:
+        return False
+
+    sat = satellites[name]
+    changed = False
+
+    phase = drive_data.get("phase", {})
+    loop = drive_data.get("loop", {})
+    handoff = drive_data.get("handoff", {})
+
+    updates = {
+        "phase_name": phase.get("name"),
+        "phase_number": phase.get("number"),
+        "phase_status": phase.get("status"),
+        "loop_position": loop.get("position"),
+        "handoff": handoff.get("present", False),
+        "last_plan_completed_at": drive_data.get("last_plan_completed_at"),
+        "next_action": drive_data.get("next_action"),
+    }
+
+    for key, value in updates.items():
+        if sat.get(key) != value:
+            sat[key] = value
+            changed = True
+
+    return changed
+
+
+def sync_to_projects(drive_data: dict, name: str, projects_data: dict) -> bool:
+    """Sync drive.json state to matching project in projects.json. Returns True if changed."""
+    for item in projects_data.get("items", []):
+        drive_field = item.get("drive")
+        if not drive_field or drive_field.get("satellite_name") != name:
+            continue
+
+        # Found matching project — update drive field
+        phase = drive_data.get("phase", {})
+        loop = drive_data.get("loop", {})
+        handoff = drive_data.get("handoff", {})
+        timestamps = drive_data.get("timestamps", {})
+
+        drive_field["phase"] = phase.get("name")
+        drive_field["loop_position"] = loop.get("position")
+        drive_field["last_update"] = timestamps.get("updated_at")
+
+        # Calculate completed phases
+        if phase.get("status") == "complete":
+            drive_field["completed_phases"] = phase.get("number")
+        else:
+            drive_field["completed_phases"] = max(0, (phase.get("number", 1) or 1) - 1)
+
+        # Copy enriched fields
+        drive_field["last_plan_completed_at"] = drive_data.get("last_plan_completed_at")
+        drive_field["handoff"] = handoff.get("present", False)
+
+        item["updated_at"] = datetime.now().isoformat()
+        return True
+
+    return False
+
+
+def main():
+    # Skip if Momentum is not installed
+    if not BASE_DIR.exists() or not MANIFEST_FILE.exists():
+        sys.exit(0)
+
+    try:
+        with open(MANIFEST_FILE, "r") as f:
+            manifest = json.load(f)
+    except (json.JSONDecodeError, OSError):
+        sys.exit(0)
+
+    satellites = manifest.get("satellites", {})
+    new_registrations = []
+    workspace_changed = False
+    projects_changed = False
+
+    # Load projects.json for cross-check (if it exists)
+    projects_data = None
+    if PROJECTS_FILE.exists():
+        try:
+            with open(PROJECTS_FILE, "r") as f:
+                projects_data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            projects_data = None
+
+    drive_files = find_drive_json_files(WORKSPACE_ROOT)
+
+    # Collect drive data for sync pass
+    drive_registry = {}  # name → drive_data
+
+    for drive_json_path in drive_files:
+        try:
+            with open(drive_json_path, "r") as f:
+                drive_data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            continue  # Malformed or unreadable — skip silently
+
+        name = drive_data.get("name")
+        if not name:
+            continue  # No name field — skip
+
+        drive_registry[name] = drive_data
+
+        # Read last_activity from drive.json timestamps (if present)
+        last_activity = drive_data.get("timestamps", {}).get("updated_at")
+
+        if name in satellites:
+            # Already registered — refresh last_activity if available
+            if last_activity and satellites[name].get("last_activity") != last_activity:
+                satellites[name]["last_activity"] = last_activity
+                workspace_changed = True
+            continue
+
+        # New satellite — derive relative path
+        project_dir = drive_json_path.parent.parent
+        try:
+            rel_path = str(project_dir.relative_to(WORKSPACE_ROOT))
+        except ValueError:
+            continue  # Can't relativize — skip
+
+        # Build registration entry
+        entry = {
+            "path": rel_path,
+            "engine": "drive",
+            "state": f"{rel_path}/.drive/STATE.md",
+            "registered": datetime.now().strftime("%Y-%m-%d"),
+            "groom_check": True,
+        }
+        if last_activity:
+            entry["last_activity"] = last_activity
+
+        satellites[name] = entry
+        new_registrations.append(name)
+        workspace_changed = True
+
+    # --- Sync pass: drive.json → workspace.json + projects.json ---
+    for name, drive_data in drive_registry.items():
+        if not should_sync(drive_data):
+            continue  # Opt-out — skip sync
+
+        # Sync to workspace.json
+        if sync_to_workspace(satellites, drive_data, name):
+            workspace_changed = True
+
+        # Sync to projects.json
+        if projects_data and sync_to_projects(drive_data, name, projects_data):
+            projects_changed = True
+
+    # Write workspace.json if changed
+    if workspace_changed:
+        try:
+            manifest["satellites"] = satellites
+            with open(MANIFEST_FILE, "w") as f:
+                json.dump(manifest, f, indent=2)
+                f.write("\n")
+        except OSError:
+            pass  # Write failed — silent
+
+    # Write projects.json if changed
+    if projects_changed and projects_data:
+        try:
+            projects_data["last_modified"] = datetime.now().isoformat()
+            with open(PROJECTS_FILE, "w") as f:
+                json.dump(projects_data, f, indent=2)
+                f.write("\n")
+        except OSError:
+            pass  # Write failed — silent
+
+    # Output only for new registrations
+    if new_registrations:
+        names_str = ", ".join(new_registrations)
+        n = len(new_registrations)
+        print(f"<momentum-satellites>\nAuto-registered {n} new satellite(s): {names_str}\n</momentum-satellites>")
+
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        sys.exit(0)

package/modules/momentum/src/packages/momentum-mcp/index.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+/**
+ * Momentum MCP — Surface CRUD Server
+ * Builder's Automated State Engine
+ *
+ * Generic CRUD operations for any registered data surface.
+ * Surfaces are registered in workspace.json and stored as JSON in .accel/momentum/data/.
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Tool group imports
+import { TOOLS as surfaceTools, handleTool as handleSurface } from './tools/surfaces.js';
+import { TOOLS as projectTools, handleTool as handleProject } from './tools/projects.js';
+import { TOOLS as stateTools, handleTool as handleState } from './tools/state.js';
+import { TOOLS as entityTools, handleTool as handleEntity } from './tools/entities.js';
+import { TOOLS as operatorTools, handleTool as handleOperator } from './tools/operator.js';
+import { TOOLS as psmmTools, handleTool as handlePsmm } from './tools/psmm.js';
+
+// ============================================================
+// CONFIGURATION
+// ============================================================
+
+// Resolve workspace from this file's location: momentum-mcp/ → .accel/momentum/ → workspace root
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKSPACE_PATH = path.resolve(__dirname, '../..');
+
+function debugLog(...args) {
+    console.error('[Momentum]', new Date().toISOString(), ...args);
+}
+
+// ============================================================
+// TOOL REGISTRY
+// ============================================================
+
+const ALL_TOOLS = [...surfaceTools, ...projectTools, ...stateTools, ...entityTools, ...operatorTools, ...psmmTools];
+
+// Build handler lookup: tool name → handler function
+const TOOL_HANDLERS = {};
+for (const tool of surfaceTools) TOOL_HANDLERS[tool.name] = handleSurface;
+for (const tool of projectTools) TOOL_HANDLERS[tool.name] = handleProject;
+for (const tool of stateTools) TOOL_HANDLERS[tool.name] = handleState;
+for (const tool of entityTools) TOOL_HANDLERS[tool.name] = handleEntity;
+for (const tool of operatorTools) TOOL_HANDLERS[tool.name] = handleOperator;
+for (const tool of psmmTools) TOOL_HANDLERS[tool.name] = handlePsmm;
+
+// ============================================================
+// MCP SERVER
+// ============================================================
+
+const server = new Server({
+    name: "momentum-mcp",
+    version: "1.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+
+debugLog('Momentum MCP Server initialized');
+debugLog('Workspace:', WORKSPACE_PATH);
+debugLog('Tool groups: surfaces (%d), projects (%d), state (%d), entities (%d), psmm (%d)',
+    surfaceTools.length, projectTools.length, stateTools.length, entityTools.length, psmmTools.length);
+debugLog('Total tools:', ALL_TOOLS.length);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    debugLog('List tools request');
+    return { tools: ALL_TOOLS };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    debugLog('Call tool:', name);
+
+    try {
+        const handler = TOOL_HANDLERS[name];
+        if (!handler) {
+            throw new Error(`Unknown tool: ${name}`);
+        }
+
+        const result = await handler(name, args || {}, WORKSPACE_PATH);
+
+        if (result === null) {
+            throw new Error(`Tool ${name} returned null — handler mismatch`);
+        }
+
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            isError: false,
+        };
+    } catch (error) {
+        debugLog('Error:', error.message);
+        return {
+            content: [{ type: "text", text: `Error: ${error.message}` }],
+            isError: true,
+        };
+    }
+});
+
+// ============================================================
+// RUN
+// ============================================================
+
+async function runServer() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Momentum MCP Server running on stdio");
+}
+
+try {
+    await runServer();
+} catch (error) {
+    console.error("Fatal error:", error);
+    process.exit(1);
+}

package/modules/momentum/src/packages/momentum-mcp/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "momentum-mcp",
+  "version": "1.0.0",
+  "description": "Momentum Surface CRUD Server - Generic operations for registered data surfaces",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}

package/modules/momentum/src/packages/momentum-mcp/tools/entities.js

@@ -0,0 +1,226 @@
+/**
+ * Mission Control Entities — CRUD for entities.json
+ * People and organizations with relational links to projects
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+function debugLog(...args) {
+    console.error('[Momentum:entities]', new Date().toISOString(), ...args);
+}
+
+// ============================================================
+// HELPERS
+// ============================================================
+
+function getEntitiesPath(workspacePath) {
+    return join(workspacePath, '.accel/momentum', 'data', 'entities.json');
+}
+
+function readEntities(workspacePath) {
+    const filepath = getEntitiesPath(workspacePath);
+    if (!existsSync(filepath)) {
+        return { version: 1, last_modified: null, entities: [] };
+    }
+    try {
+        return JSON.parse(readFileSync(filepath, 'utf-8'));
+    } catch (error) {
+        debugLog('Error reading entities.json:', error.message);
+        return { version: 1, last_modified: null, entities: [] };
+    }
+}
+
+function writeEntities(workspacePath, data) {
+    const filepath = getEntitiesPath(workspacePath);
+    data.last_modified = new Date().toISOString();
+    writeFileSync(filepath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function generateEntityId(entities) {
+    let max = 0;
+    for (const entity of entities) {
+        const match = (entity.id || '').match(/^ENT-(\d+)$/);
+        if (match) {
+            const num = parseInt(match[1], 10);
+            if (num > max) max = num;
+        }
+    }
+    return `ENT-${String(max + 1).padStart(3, '0')}`;
+}
+
+function formatTimestamp() {
+    return new Date().toISOString();
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "momentum_list_entities",
+        description: "List all entities with optional type filter (person/organization).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: ["person", "organization"], description: "Filter by entity type" }
+            },
+            required: []
+        }
+    },
+    {
+        name: "momentum_add_entity",
+        description: "Add a new person or organization entity. Auto-generates ENT-NNN ID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Display name" },
+                type: { type: "string", enum: ["person", "organization"], description: "Entity type" },
+                role: { type: "string", description: "Primary role (owner, client, partner, contractor, team member, employer)" }
+            },
+            required: ["name", "type"]
+        }
+    },
+    {
+        name: "momentum_update_entity",
+        description: "Update an entity's fields by ID. Shallow merge — only specified fields updated.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Entity ID (e.g., 'ENT-001')" },
+                data: { type: "object", description: "Fields to update" }
+            },
+            required: ["id", "data"]
+        }
+    },
+    {
+        name: "momentum_link_entity",
+        description: "Add a relation between an entity and a project item. Avoids duplicate relations.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Entity ID (e.g., 'ENT-001')" },
+                project_id: { type: "string", description: "Project item ID (e.g., 'PRJ-003')" },
+                relationship: { type: "string", description: "Relationship type (stakeholder, client, owner, partner, contractor, assignee)" }
+            },
+            required: ["id", "project_id", "relationship"]
+        }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+function handleListEntities(args, workspacePath) {
+    debugLog('Listing entities');
+    const data = readEntities(workspacePath);
+    let entities = data.entities;
+
+    if (args.type) {
+        entities = entities.filter(e => e.type === args.type);
+    }
+
+    return { entities, count: entities.length, total: data.entities.length };
+}
+
+function handleAddEntity(args, workspacePath) {
+    const { name, type } = args;
+    if (!name) throw new Error('Missing required parameter: name');
+    if (!type) throw new Error('Missing required parameter: type');
+
+    const data = readEntities(workspacePath);
+    const now = formatTimestamp();
+    const id = generateEntityId(data.entities);
+
+    const entity = {
+        id,
+        name,
+        type,
+        role: args.role || null,
+        relations: [],
+        notes: [],
+        created_at: now,
+        updated_at: now
+    };
+
+    data.entities.push(entity);
+    writeEntities(workspacePath, data);
+
+    debugLog(`Added ${type} ${id}: ${name}`);
+    return entity;
+}
+
+function handleUpdateEntity(args, workspacePath) {
+    const { id, data: updateData } = args;
+    if (!id) throw new Error('Missing required parameter: id');
+    if (!updateData) throw new Error('Missing required parameter: data');
+
+    const data = readEntities(workspacePath);
+    const index = data.entities.findIndex(e => e.id === id);
+    if (index === -1) {
+        throw new Error(`Entity "${id}" not found. Available: ${data.entities.map(e => e.id).join(', ') || 'none'}`);
+    }
+
+    data.entities[index] = {
+        ...data.entities[index],
+        ...updateData,
+        id, // Prevent ID overwrite
+        updated_at: formatTimestamp()
+    };
+
+    writeEntities(workspacePath, data);
+
+    debugLog(`Updated ${id}`);
+    return data.entities[index];
+}
+
+function handleLinkEntity(args, workspacePath) {
+    const { id, project_id, relationship } = args;
+    if (!id) throw new Error('Missing required parameter: id');
+    if (!project_id) throw new Error('Missing required parameter: project_id');
+    if (!relationship) throw new Error('Missing required parameter: relationship');
+
+    const data = readEntities(workspacePath);
+    const index = data.entities.findIndex(e => e.id === id);
+    if (index === -1) {
+        throw new Error(`Entity "${id}" not found`);
+    }
+
+    const entity = data.entities[index];
+    if (!entity.relations) entity.relations = [];
+
+    // Check for duplicate
+    const exists = entity.relations.some(r => r.project_id === project_id && r.relationship === relationship);
+    if (exists) {
+        return { already_linked: true, id, project_id, relationship, message: 'Relation already exists' };
+    }
+
+    entity.relations.push({ project_id, relationship });
+    entity.updated_at = formatTimestamp();
+
+    writeEntities(workspacePath, data);
+
+    debugLog(`Linked ${id} → ${project_id} (${relationship})`);
+    return { id, project_id, relationship, relations_count: entity.relations.length };
+}
+
+// ============================================================
+// HANDLER DISPATCH
+// ============================================================
+
+export function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case 'momentum_list_entities':
+            return handleListEntities(args, workspacePath);
+        case 'momentum_add_entity':
+            return handleAddEntity(args, workspacePath);
+        case 'momentum_update_entity':
+            return handleUpdateEntity(args, workspacePath);
+        case 'momentum_link_entity':
+            return handleLinkEntity(args, workspacePath);
+        default:
+            return null;
+    }
+}