@accelerationguy/accel 1.0.0

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

@@ -0,0 +1,106 @@
+/**
+ * Operator CRUD tools for .accel/momentum/operator.json
+ * Read, update sections, toggle hook activation
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+function debugLog(...args) {
+    console.error('[Momentum:operator]', new Date().toISOString(), ...args);
+}
+
+function getOperatorPath(workspacePath) {
+    return path.join(workspacePath, '.accel/momentum', 'operator.json');
+}
+
+function readOperator(workspacePath) {
+    const filepath = getOperatorPath(workspacePath);
+    try {
+        return JSON.parse(fs.readFileSync(filepath, 'utf8'));
+    } catch (error) {
+        return null;
+    }
+}
+
+function writeOperator(workspacePath, data) {
+    const filepath = getOperatorPath(workspacePath);
+    data.last_updated = new Date().toISOString();
+    fs.writeFileSync(filepath, JSON.stringify(data, null, 2) + '\n');
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "momentum_get_operator",
+        description: "Read the full operator profile from .accel/momentum/operator.json. Returns identity, deep why, north star, values, pitch, vision.",
+        inputSchema: { type: "object", properties: {}, required: [] }
+    },
+    {
+        name: "momentum_update_operator",
+        description: "Update a specific section of the operator profile. Sections: deep_why, north_star, key_values, elevator_pitch, surface_vision, extensions, hook_active. Pass the full section object to replace it.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "Section to update (deep_why, north_star, key_values, elevator_pitch, surface_vision, extensions, hook_active)" },
+                data: { description: "New section data (object for sections, boolean for hook_active)" }
+            },
+            required: ["section", "data"]
+        }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+async function handleGetOperator(_args, workspacePath) {
+    const data = readOperator(workspacePath);
+    if (!data) {
+        return { error: "No operator.json found. Run /momentum:orientation to create one." };
+    }
+    return data;
+}
+
+async function handleUpdateOperator(args, workspacePath) {
+    const { section, data: sectionData } = args;
+    if (!section) throw new Error('Missing required parameter: section');
+    if (sectionData === undefined) throw new Error('Missing required parameter: data');
+
+    const validSections = ['deep_why', 'north_star', 'key_values', 'elevator_pitch', 'surface_vision', 'extensions', 'hook_active'];
+    if (!validSections.includes(section)) {
+        throw new Error(`Invalid section "${section}". Valid: ${validSections.join(', ')}`);
+    }
+
+    const operator = readOperator(workspacePath);
+    if (!operator) {
+        throw new Error('No operator.json found. Run /momentum:orientation to create one.');
+    }
+
+    debugLog('Updating operator section:', section);
+
+    if (section === 'hook_active') {
+        operator.hook_active = !!sectionData;
+    } else {
+        operator[section] = sectionData;
+    }
+
+    writeOperator(workspacePath, operator);
+
+    return {
+        section,
+        updated: true,
+        hook_active: operator.hook_active
+    };
+}
+
+export async function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case 'momentum_get_operator': return handleGetOperator(args, workspacePath);
+        case 'momentum_update_operator': return handleUpdateOperator(args, workspacePath);
+        default: return null;
+    }
+}

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

@@ -0,0 +1,322 @@
+/**
+ * Mission Control Projects — Hierarchy-aware CRUD for projects.json
+ * Supports Initiative > Project > Task with auto-ID by type
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+function debugLog(...args) {
+    console.error('[Momentum:projects]', new Date().toISOString(), ...args);
+}
+
+// ============================================================
+// HELPERS
+// ============================================================
+
+const TYPE_PREFIX = { initiative: 'INI', project: 'PRJ', task: 'TSK' };
+
+function getProjectsPath(workspacePath) {
+    return join(workspacePath, '.accel/momentum', 'data', 'projects.json');
+}
+
+function readProjects(workspacePath) {
+    const filepath = getProjectsPath(workspacePath);
+    if (!existsSync(filepath)) {
+        return { version: 1, workspace: '', last_modified: null, categories: [], items: [], archived: [] };
+    }
+    try {
+        return JSON.parse(readFileSync(filepath, 'utf-8'));
+    } catch (error) {
+        debugLog('Error reading projects.json:', error.message);
+        return { version: 1, workspace: '', last_modified: null, categories: [], items: [], archived: [] };
+    }
+}
+
+function writeProjects(workspacePath, data) {
+    const filepath = getProjectsPath(workspacePath);
+    data.last_modified = new Date().toISOString();
+    writeFileSync(filepath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function generateProjectId(type, items) {
+    const prefix = TYPE_PREFIX[type];
+    if (!prefix) throw new Error(`Invalid type: ${type}. Valid: initiative, project, task`);
+
+    let max = 0;
+    for (const item of items) {
+        const match = (item.id || '').match(new RegExp(`^${prefix}-(\\d+)$`));
+        if (match) {
+            const num = parseInt(match[1], 10);
+            if (num > max) max = num;
+        }
+    }
+    return `${prefix}-${String(max + 1).padStart(3, '0')}`;
+}
+
+function formatTimestamp() {
+    return new Date().toISOString();
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "momentum_list_projects",
+        description: "List/filter project items. Supports filtering by type (initiative/project/task), status, priority, parent_id, and category.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: ["initiative", "project", "task"], description: "Filter by hierarchy level" },
+                status: { type: "string", description: "Filter by status (backlog, todo, in_progress, blocked, in_review, completed, deferred, archived)" },
+                priority: { type: "string", description: "Filter by priority (urgent, high, medium, low, ongoing)" },
+                parent_id: { type: "string", description: "Filter by parent item ID" },
+                category: { type: "string", description: "Filter by category" }
+            },
+            required: []
+        }
+    },
+    {
+        name: "momentum_get_project",
+        description: "Get a single project item by ID. Returns the full item object.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Item ID (e.g., 'PRJ-001', 'INI-002', 'TSK-005')" }
+            },
+            required: ["id"]
+        }
+    },
+    {
+        name: "momentum_add_project",
+        description: "Add a new initiative, project, or task. Auto-generates ID by type (INI-NNN, PRJ-NNN, TSK-NNN). Sets created_at and updated_at.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                type: { type: "string", enum: ["initiative", "project", "task"], description: "Hierarchy level" },
+                title: { type: "string", description: "Item title" },
+                parent_id: { type: "string", description: "Parent item ID (null for top-level initiatives)" },
+                status: { type: "string", enum: ["backlog", "todo", "in_progress", "blocked", "in_review", "completed", "deferred"], description: "Initial status (default: todo)" },
+                priority: { type: "string", enum: ["urgent", "high", "medium", "low", "ongoing"], description: "Priority level (default: medium)" },
+                category: { type: "string", description: "Category from workspace categories list" },
+                assignees: { type: "array", items: { type: "string" }, description: "Entity IDs to assign" },
+                description: { type: "string", description: "Extended description" },
+                location: { type: "string", description: "Workspace-relative path" },
+                due_date: { type: "string", description: "ISO date deadline" },
+                tags: { type: "array", items: { type: "string" }, description: "Free-form tags" }
+            },
+            required: ["type", "title"]
+        }
+    },
+    {
+        name: "momentum_update_project",
+        description: "Update an existing item's fields by ID. Shallow merge — only specified fields updated, others preserved.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Item ID to update" },
+                data: { type: "object", description: "Fields to update (shallow merge)" }
+            },
+            required: ["id", "data"]
+        }
+    },
+    {
+        name: "momentum_archive_project",
+        description: "Archive an item by ID — moves from items[] to archived[] with outcome and timestamp.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Item ID to archive" },
+                outcome: { type: "string", description: "What happened (shipped, killed, absorbed, etc.)" }
+            },
+            required: ["id", "outcome"]
+        }
+    },
+    {
+        name: "momentum_search_projects",
+        description: "Search project items by keyword. Case-insensitive substring match across title, description, notes, and tags.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                query: { type: "string", description: "Search query (case-insensitive)" }
+            },
+            required: ["query"]
+        }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+function handleListProjects(args, workspacePath) {
+    const data = readProjects(workspacePath);
+    let items = data.items;
+
+    if (args.type) items = items.filter(i => i.type === args.type);
+    if (args.status) items = items.filter(i => i.status === args.status);
+    if (args.priority) items = items.filter(i => i.priority === args.priority);
+    if (args.parent_id) items = items.filter(i => i.parent_id === args.parent_id);
+    if (args.category) items = items.filter(i => i.category === args.category);
+
+    return { items, count: items.length, total: data.items.length };
+}
+
+function handleGetProject(args, workspacePath) {
+    const { id } = args;
+    if (!id) throw new Error('Missing required parameter: id');
+
+    const data = readProjects(workspacePath);
+    const item = data.items.find(i => i.id === id);
+    if (!item) {
+        throw new Error(`Item "${id}" not found. Available IDs: ${data.items.map(i => i.id).slice(0, 20).join(', ')}${data.items.length > 20 ? '...' : ''}`);
+    }
+    return item;
+}
+
+function handleAddProject(args, workspacePath) {
+    const { type, title } = args;
+    if (!type) throw new Error('Missing required parameter: type');
+    if (!title) throw new Error('Missing required parameter: title');
+
+    const data = readProjects(workspacePath);
+    const now = formatTimestamp();
+    const id = generateProjectId(type, data.items);
+
+    const newItem = {
+        id,
+        title,
+        type,
+        parent_id: args.parent_id || null,
+        status: args.status || 'todo',
+        priority: args.priority || 'medium',
+        category: args.category || null,
+        assignees: args.assignees || [],
+        start_date: null,
+        due_date: args.due_date || null,
+        created_at: now,
+        updated_at: now,
+        location: args.location || null,
+        blocked_by: null,
+        next: null,
+        notes: [],
+        tags: args.tags || [],
+        drive: null,
+        relations: [],
+        description: args.description || null
+    };
+
+    data.items.push(newItem);
+    writeProjects(workspacePath, data);
+
+    debugLog(`Added ${type} ${id}: ${title}`);
+    return newItem;
+}
+
+function handleUpdateProject(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 = readProjects(workspacePath);
+    const index = data.items.findIndex(i => i.id === id);
+    if (index === -1) {
+        throw new Error(`Item "${id}" not found`);
+    }
+
+    data.items[index] = {
+        ...data.items[index],
+        ...updateData,
+        id, // Prevent ID overwrite
+        updated_at: formatTimestamp()
+    };
+
+    writeProjects(workspacePath, data);
+
+    debugLog(`Updated ${id}`);
+    return data.items[index];
+}
+
+function handleArchiveProject(args, workspacePath) {
+    const { id, outcome } = args;
+    if (!id) throw new Error('Missing required parameter: id');
+    if (!outcome) throw new Error('Missing required parameter: outcome');
+
+    const data = readProjects(workspacePath);
+    const index = data.items.findIndex(i => i.id === id);
+    if (index === -1) {
+        throw new Error(`Item "${id}" not found`);
+    }
+
+    const [item] = data.items.splice(index, 1);
+    const now = formatTimestamp();
+
+    if (!data.archived) data.archived = [];
+    data.archived.push({
+        id: item.id,
+        title: item.title,
+        outcome,
+        date: now.split('T')[0],
+        archived_at: now
+    });
+
+    writeProjects(workspacePath, data);
+
+    debugLog(`Archived ${id}: ${outcome}`);
+    return { id, title: item.title, outcome, archived_at: now };
+}
+
+function handleSearchProjects(args, workspacePath) {
+    const { query } = args;
+    if (!query) throw new Error('Missing required parameter: query');
+
+    const data = readProjects(workspacePath);
+    const queryLower = query.toLowerCase();
+    const results = [];
+
+    for (const item of data.items) {
+        const searchFields = [
+            item.title,
+            item.description,
+            ...(item.tags || []),
+            ...(item.notes || []).map(n => n.text)
+        ].filter(Boolean).join(' ').toLowerCase();
+
+        if (searchFields.includes(queryLower)) {
+            results.push({
+                id: item.id,
+                title: item.title,
+                type: item.type,
+                status: item.status,
+                priority: item.priority
+            });
+        }
+    }
+
+    return { results, count: results.length, query };
+}
+
+// ============================================================
+// HANDLER DISPATCH
+// ============================================================
+
+export function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case 'momentum_list_projects':
+            return handleListProjects(args, workspacePath);
+        case 'momentum_get_project':
+            return handleGetProject(args, workspacePath);
+        case 'momentum_add_project':
+            return handleAddProject(args, workspacePath);
+        case 'momentum_update_project':
+            return handleUpdateProject(args, workspacePath);
+        case 'momentum_archive_project':
+            return handleArchiveProject(args, workspacePath);
+        case 'momentum_search_projects':
+            return handleSearchProjects(args, workspacePath);
+        default:
+            return null;
+    }
+}

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

@@ -0,0 +1,206 @@
+/**
+ * Momentum PSMM — Per-Session Meta Memory tools
+ * Tracks significant meta moments across sessions.
+ * The injection hook (psmm-injector.py) re-injects entries into context every prompt.
+ * Vector connects only for graduation: PSMM entries can be staged as Vector rule proposals.
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const VALID_TYPES = ['DECISION', 'CORRECTION', 'SHIFT', 'INSIGHT', 'COMMITMENT'];
+
+function debugLog(...args) {
+    console.error('[Momentum:psmm]', new Date().toISOString(), ...args);
+}
+
+function getPsmmPath(workspacePath) {
+    return join(workspacePath, '.accel/momentum', 'data', 'psmm.json');
+}
+
+function readPsmm(workspacePath) {
+    const filepath = getPsmmPath(workspacePath);
+    if (!existsSync(filepath)) {
+        return { sessions: {} };
+    }
+    try {
+        return JSON.parse(readFileSync(filepath, 'utf-8'));
+    } catch (error) {
+        debugLog('Error reading psmm.json:', error.message);
+        return { sessions: {} };
+    }
+}
+
+function writePsmm(workspacePath, data) {
+    const filepath = getPsmmPath(workspacePath);
+    writeFileSync(filepath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function formatTimestamp() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())} ${pad(now.getHours())}:${pad(now.getMinutes())}`;
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "momentum_psmm_log",
+        description: "Log a per-session meta memory entry. Types: DECISION, CORRECTION, SHIFT, INSIGHT, COMMITMENT. Auto-creates session if new.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                session_id: { type: "string", description: "Session UUID" },
+                type: { type: "string", enum: VALID_TYPES, description: "Entry type" },
+                text: { type: "string", description: "Description of the meta moment" }
+            },
+            required: ["session_id", "type", "text"]
+        }
+    },
+    {
+        name: "momentum_psmm_get",
+        description: "Get all PSMM entries for a specific session by UUID.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                session_id: { type: "string", description: "Session UUID" }
+            },
+            required: ["session_id"]
+        }
+    },
+    {
+        name: "momentum_psmm_list",
+        description: "List all PSMM sessions with entry counts and created timestamps.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "momentum_psmm_clean",
+        description: "Remove a stale session's entries from PSMM.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                session_id: { type: "string", description: "Session UUID to remove" }
+            },
+            required: ["session_id"]
+        }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+export async function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case "momentum_psmm_log": return psmmLog(args, workspacePath);
+        case "momentum_psmm_get": return psmmGet(args, workspacePath);
+        case "momentum_psmm_list": return psmmList(workspacePath);
+        case "momentum_psmm_clean": return psmmClean(args, workspacePath);
+        default: return null;
+    }
+}
+
+async function psmmLog(args, workspacePath) {
+    const { session_id, type, text } = args;
+
+    if (!VALID_TYPES.includes(type)) {
+        return { success: false, error: `Invalid type: ${type}. Valid: ${VALID_TYPES.join(', ')}` };
+    }
+
+    debugLog('Logging PSMM entry:', session_id, type);
+
+    const data = readPsmm(workspacePath);
+
+    if (!data.sessions[session_id]) {
+        data.sessions[session_id] = {
+            created: formatTimestamp(),
+            entries: []
+        };
+    }
+
+    const entry = {
+        timestamp: formatTimestamp(),
+        type,
+        text
+    };
+
+    data.sessions[session_id].entries.push(entry);
+    writePsmm(workspacePath, data);
+
+    return {
+        success: true,
+        session_id,
+        entry_count: data.sessions[session_id].entries.length,
+        message: `Logged ${type} entry to session ${session_id.slice(0, 8)}...`
+    };
+}
+
+async function psmmGet(args, workspacePath) {
+    const { session_id } = args;
+    debugLog('Getting PSMM for session:', session_id);
+
+    const data = readPsmm(workspacePath);
+    const session = data.sessions[session_id];
+
+    if (!session) {
+        return { entries: [], exists: false };
+    }
+
+    return {
+        exists: true,
+        session_id,
+        created: session.created,
+        entry_count: session.entries.length,
+        entries: session.entries
+    };
+}
+
+async function psmmList(workspacePath) {
+    debugLog('Listing PSMM sessions');
+
+    const data = readPsmm(workspacePath);
+    const sessions = [];
+
+    for (const [id, session] of Object.entries(data.sessions)) {
+        sessions.push({
+            session_id: id,
+            created: session.created,
+            entry_count: session.entries.length,
+            types: [...new Set(session.entries.map(e => e.type))]
+        });
+    }
+
+    sessions.sort((a, b) => b.created.localeCompare(a.created));
+
+    return {
+        success: true,
+        session_count: sessions.length,
+        total_entries: sessions.reduce((sum, s) => sum + s.entry_count, 0),
+        sessions
+    };
+}
+
+async function psmmClean(args, workspacePath) {
+    const { session_id } = args;
+    debugLog('Cleaning PSMM session:', session_id);
+
+    const data = readPsmm(workspacePath);
+
+    if (!data.sessions[session_id]) {
+        return { success: false, error: `Session not found: ${session_id}` };
+    }
+
+    const entryCount = data.sessions[session_id].entries.length;
+    delete data.sessions[session_id];
+    writePsmm(workspacePath, data);
+
+    return {
+        success: true,
+        session_id,
+        entries_removed: entryCount,
+        message: `Cleaned session ${session_id.slice(0, 8)}... (${entryCount} entries removed)`
+    };
+}