@accelerationguy/accel 1.0.0

package/modules/vector/mcp/index.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Vector MCP — Consolidated Tool Server
+ * Context Augmentation & Reinforcement Layer
+ *
+ * Consolidates: DRL-engine + decision-logger + Staging + vector-json (v2)
+ * 4 tool groups, all optional, activated by Vector rules.
+ *
+ * When installed to .vector/vector-mcp/, workspace path resolves to parent of .vector/
+ */
+
+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 domainTools, handleTool as handleDomain } from './tools/domains.js';
+import { TOOLS as decisionTools, handleTool as handleDecision } from './tools/decisions.js';
+import { TOOLS as stagingTools, handleTool as handleStaging } from './tools/staging.js';
+import { TOOLS as vectorJsonTools, handleTool as handleVectorJson } from './tools/vector-json.js';
+
+// ============================================================
+// CONFIGURATION
+// ============================================================
+
+// Resolve workspace from this file's location:
+// Installed at .vector/vector-mcp/index.js → workspace is ../..
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const WORKSPACE_PATH = path.resolve(__dirname, '../..');
+
+function debugLog(...args) {
+    console.error('[Vector]', new Date().toISOString(), ...args);
+}
+
+// ============================================================
+// TOOL REGISTRY
+// ============================================================
+
+const ALL_TOOLS = [...domainTools, ...decisionTools, ...stagingTools, ...vectorJsonTools];
+
+// Build handler lookup: tool name → handler function
+const TOOL_HANDLERS = {};
+for (const tool of domainTools) TOOL_HANDLERS[tool.name] = handleDomain;
+for (const tool of decisionTools) TOOL_HANDLERS[tool.name] = handleDecision;
+for (const tool of stagingTools) TOOL_HANDLERS[tool.name] = handleStaging;
+for (const tool of vectorJsonTools) TOOL_HANDLERS[tool.name] = handleVectorJson;
+
+// ============================================================
+// MCP SERVER
+// ============================================================
+
+const server = new Server({
+    name: "vector-mcp",
+    version: "2.0.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+
+debugLog('Vector MCP Server initialized');
+debugLog('Workspace:', WORKSPACE_PATH);
+debugLog('Tool groups: domains (%d), decisions (%d), staging (%d), vector-json (%d)',
+    domainTools.length, decisionTools.length, stagingTools.length, vectorJsonTools.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("Vector MCP Server running on stdio");
+}
+
+try {
+    await runServer();
+} catch (error) {
+    console.error("Fatal error:", error);
+    process.exit(1);
+}

package/modules/vector/mcp/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "vector-mcp",
+  "version": "2.0.0",
+  "description": "Vector MCP Server - Domains, Decisions, PSMM, Staging, Vector JSON CRUD",
+  "type": "module",
+  "main": "index.js",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  }
+}

package/modules/vector/mcp/tools/decisions.js

@@ -0,0 +1,269 @@
+/**
+ * Vector Decisions — Per-domain decision logging/recall tools
+ * Reads/writes .vector/decisions/{domain}.json files
+ */
+
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+
+function debugLog(...args) {
+    console.error('[Vector:decisions]', new Date().toISOString(), ...args);
+}
+
+function getDecisionsDir(workspacePath) {
+    return join(workspacePath, '.vector', 'decisions');
+}
+
+function getDomainFilePath(workspacePath, domain) {
+    return join(getDecisionsDir(workspacePath), `${domain.toLowerCase()}.json`);
+}
+
+function readDomainDecisions(workspacePath, domain) {
+    const filepath = getDomainFilePath(workspacePath, domain);
+    if (!existsSync(filepath)) {
+        return { domain: domain.toLowerCase(), decisions: [], archived: [] };
+    }
+    try {
+        return JSON.parse(readFileSync(filepath, 'utf-8'));
+    } catch (error) {
+        debugLog('Error reading domain decisions:', error.message);
+        return { domain: domain.toLowerCase(), decisions: [], archived: [] };
+    }
+}
+
+function writeDomainDecisions(workspacePath, domain, data) {
+    const filepath = getDomainFilePath(workspacePath, domain);
+    writeFileSync(filepath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function listAllDomainFiles(workspacePath) {
+    const dir = getDecisionsDir(workspacePath);
+    if (!existsSync(dir)) return [];
+    return readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => f.replace('.json', ''));
+}
+
+function nextDecisionId(domain, decisions) {
+    const prefix = `${domain.toLowerCase()}-`;
+    const nums = decisions
+        .map(d => {
+            const m = d.id.match(new RegExp(`^${prefix}(\\d+)$`));
+            return m ? parseInt(m[1], 10) : 0;
+        })
+        .filter(n => n > 0);
+    const max = nums.length > 0 ? Math.max(...nums) : 0;
+    return `${prefix}${String(max + 1).padStart(3, '0')}`;
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "vector_log_decision",
+        description: "Log a decision to a Vector domain. Auto-creates domain file if new.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: { type: "string", description: "Domain name (e.g., 'casegate', 'development', 'global')" },
+                decision: { type: "string", description: "The decision made" },
+                rationale: { type: "string", description: "Why this decision was made" },
+                recall: { type: "string", description: "Comma-separated keywords for when to recall this decision" }
+            },
+            required: ["domain", "decision", "rationale", "recall"]
+        }
+    },
+    {
+        name: "vector_list_decision_domains",
+        description: "List all decision domain files with counts.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "vector_get_decisions",
+        description: "Get all decisions for a domain.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: { type: "string", description: "Domain name (e.g., 'casegate', 'development')" }
+            },
+            required: ["domain"]
+        }
+    },
+    {
+        name: "vector_search_decisions",
+        description: "Search decisions by keyword across all domain files.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                keyword: { type: "string", description: "Keyword to search for" }
+            },
+            required: ["keyword"]
+        }
+    },
+    {
+        name: "vector_archive_decision",
+        description: "Move a decision to the archived array in its domain file.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Decision ID (e.g., 'casegate-003')" }
+            },
+            required: ["id"]
+        }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+export async function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case "vector_log_decision": return logDecision(args, workspacePath);
+        case "vector_list_decision_domains": return listDecisionDomains(workspacePath);
+        case "vector_get_decisions": return getDecisions(args, workspacePath);
+        case "vector_search_decisions": return searchDecisions(args, workspacePath);
+        case "vector_archive_decision": return archiveDecision(args, workspacePath);
+        default: return null;
+    }
+}
+
+async function logDecision(args, workspacePath) {
+    const { domain, decision, rationale, recall } = args;
+    const domainLower = domain.toLowerCase();
+    debugLog('Logging decision to domain:', domainLower);
+
+    const data = readDomainDecisions(workspacePath, domainLower);
+    const id = nextDecisionId(domainLower, data.decisions);
+    const date = new Date().toISOString().split('T')[0];
+    const recallList = recall.split(',').map(k => k.trim()).filter(Boolean);
+
+    const entry = {
+        id,
+        decision,
+        rationale,
+        date,
+        source: "manual",
+        recall: recallList
+    };
+
+    data.decisions.push(entry);
+    data.domain = domainLower;
+    if (!data.archived) data.archived = [];
+    writeDomainDecisions(workspacePath, domainLower, data);
+
+    return {
+        success: true,
+        id,
+        domain: domainLower,
+        message: `Logged: ${id} to ${domainLower}`
+    };
+}
+
+async function listDecisionDomains(workspacePath) {
+    debugLog('Listing decision domains');
+    const domainNames = listAllDomainFiles(workspacePath);
+    const domains = [];
+
+    for (const name of domainNames) {
+        const data = readDomainDecisions(workspacePath, name);
+        domains.push({
+            domain: name,
+            active_count: data.decisions.length,
+            archived_count: (data.archived || []).length
+        });
+    }
+
+    const totalActive = domains.reduce((sum, d) => sum + d.active_count, 0);
+    const totalArchived = domains.reduce((sum, d) => sum + d.archived_count, 0);
+
+    return {
+        success: true,
+        domain_count: domains.length,
+        total_active: totalActive,
+        total_archived: totalArchived,
+        domains
+    };
+}
+
+async function getDecisions(args, workspacePath) {
+    const { domain } = args;
+    const domainLower = domain.toLowerCase();
+    debugLog('Getting decisions for:', domainLower);
+
+    const filepath = getDomainFilePath(workspacePath, domainLower);
+    if (!existsSync(filepath)) {
+        return { error: `No decisions file for domain: ${domainLower}` };
+    }
+
+    const data = readDomainDecisions(workspacePath, domainLower);
+
+    return {
+        domain: domainLower,
+        count: data.decisions.length,
+        archived_count: (data.archived || []).length,
+        decisions: data.decisions,
+        archived: data.archived || []
+    };
+}
+
+async function searchDecisions(args, workspacePath) {
+    const { keyword } = args;
+    debugLog('Searching for:', keyword);
+
+    const lowerKeyword = keyword.toLowerCase();
+    const domainNames = listAllDomainFiles(workspacePath);
+    const results = [];
+
+    for (const name of domainNames) {
+        const data = readDomainDecisions(workspacePath, name);
+        for (const d of data.decisions) {
+            const searchText = [
+                d.decision,
+                d.rationale,
+                ...(d.recall || [])
+            ].join(' ').toLowerCase();
+
+            if (searchText.includes(lowerKeyword)) {
+                results.push({ ...d, domain: name });
+            }
+        }
+    }
+
+    return { keyword, count: results.length, decisions: results };
+}
+
+async function archiveDecision(args, workspacePath) {
+    const { id } = args;
+    debugLog('Archiving:', id);
+
+    // Extract domain from ID (e.g., 'casegate-003' -> 'casegate')
+    const dashIdx = id.lastIndexOf('-');
+    if (dashIdx === -1) {
+        return { error: `Invalid decision ID format: ${id}. Expected: {domain}-{number}` };
+    }
+    const domainLower = id.slice(0, dashIdx);
+
+    const filepath = getDomainFilePath(workspacePath, domainLower);
+    if (!existsSync(filepath)) {
+        return { error: `No decisions file for domain: ${domainLower}` };
+    }
+
+    const data = readDomainDecisions(workspacePath, domainLower);
+    const idx = data.decisions.findIndex(d => d.id === id);
+
+    if (idx === -1) {
+        return { error: `Decision not found: ${id}` };
+    }
+
+    const decision = data.decisions.splice(idx, 1)[0];
+    decision.archived_date = new Date().toISOString().split('T')[0];
+
+    if (!data.archived) data.archived = [];
+    data.archived.push(decision);
+    writeDomainDecisions(workspacePath, domainLower, data);
+
+    return { success: true, message: `Archived: ${id}` };
+}