@accelerationguy/accel 1.0.0

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

@@ -0,0 +1,361 @@
+/**
+ * Vector Domains — Domain CRUD tools
+ * Migrated from DRL-engine MCP, renamed drl_* → vector_* for Accelerate
+ */
+
+import { readFileSync, existsSync, readdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+
+const VECTOR_FOLDER = '.vector';
+
+function debugLog(...args) {
+    console.error('[Vector:domains]', new Date().toISOString(), ...args);
+}
+
+// ============================================================
+// FILE PARSING
+// ============================================================
+
+function findVectorFiles(workspacePath) {
+    const files = {};
+    const vectorPath = join(workspacePath, VECTOR_FOLDER);
+
+    try {
+        if (!existsSync(vectorPath)) {
+            debugLog('Vector folder not found:', vectorPath);
+            return files;
+        }
+
+        const entries = readdirSync(vectorPath);
+        for (const entry of entries) {
+            if (!entry.startsWith('.') && !entry.startsWith('sessions') && !entry.startsWith('skool')) {
+                files[entry] = join(vectorPath, entry);
+            }
+        }
+    } catch (error) {
+        debugLog('Error reading Vector folder:', error.message);
+    }
+
+    return files;
+}
+
+function applyManifestEntry(domains, key, value) {
+    const suffixes = [
+        { suffix: '_STATE', len: 6, handler: (d, v) => { d.state = ['active', 'true', 'yes', '1'].includes(v.toLowerCase()); } },
+        { suffix: '_ALWAYS_ON', len: 10, handler: (d, v) => { d.always_on = ['true', 'yes', '1'].includes(v.toLowerCase()); } },
+        { suffix: '_RECALL', len: 7, handler: (d, v) => { d.recall = v; } }
+    ];
+
+    for (const { suffix, len, handler } of suffixes) {
+        if (key.endsWith(suffix)) {
+            const domain = key.slice(0, -len);
+            if (!domains[domain]) domains[domain] = {};
+            handler(domains[domain], value);
+            return;
+        }
+    }
+}
+
+function parseManifest(filepath) {
+    const domains = {};
+    if (!existsSync(filepath)) return domains;
+
+    const content = readFileSync(filepath, 'utf-8');
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) continue;
+        const [key, value] = trimmed.split('=', 2);
+        applyManifestEntry(domains, key.trim(), value.trim());
+    }
+
+    return domains;
+}
+
+function parseDomainRules(filepath, domainName) {
+    const rules = [];
+    if (!existsSync(filepath)) return rules;
+
+    const content = readFileSync(filepath, 'utf-8');
+    const prefix = `${domainName}_RULE_`;
+
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#') || !trimmed.includes('=')) continue;
+        const [key, value] = trimmed.split('=', 2);
+        const k = key.trim();
+        const v = value.trim();
+
+        if (k.startsWith(prefix) && v) {
+            const num = Number.parseInt(k.replace(prefix, ''), 10);
+            rules.push({ num, text: v });
+        }
+    }
+
+    rules.sort((a, b) => a.num - b.num);
+    return rules;
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "vector_list_domains",
+        description: "List all available Vector domains with state from manifest.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "vector_get_domain_rules",
+        description: "Load rules for a specific Vector domain. Use when user intent matches domain recall keywords.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: { type: "string", description: "Domain name (e.g., 'PROJECTS', 'CONTENT'). Case-insensitive." }
+            },
+            required: ["domain"]
+        }
+    },
+    {
+        name: "vector_create_domain",
+        description: "Create a new Vector domain with file and manifest entry.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: { type: "string", description: "Domain name in UPPERCASE (e.g., 'TESTING')" },
+                description: { type: "string", description: "Brief description of when this domain applies" },
+                recall: { type: "string", description: "Comma-separated recall keywords that trigger this domain" },
+                rules: { type: "array", items: { type: "string" }, description: "Array of rule strings (Rule 0 auto-generated from description)" }
+            },
+            required: ["domain", "description", "recall", "rules"]
+        }
+    },
+    {
+        name: "vector_toggle_domain",
+        description: "Enable or disable a Vector domain by updating the manifest.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: { type: "string", description: "Domain name to toggle (e.g., 'PROJECTS')" },
+                state: { type: "string", enum: ["active", "inactive"], description: "New state" }
+            },
+            required: ["domain", "state"]
+        }
+    },
+    {
+        name: "vector_get_manifest",
+        description: "Get current Vector manifest showing all domains, states, and recall keywords.",
+        inputSchema: { type: "object", properties: {} }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+export async function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case "vector_list_domains": return listDomains(workspacePath);
+        case "vector_get_domain_rules": return getDomainRules(args, workspacePath);
+        case "vector_create_domain": return createDomain(args, workspacePath);
+        case "vector_toggle_domain": return toggleDomain(args, workspacePath);
+        case "vector_get_manifest": return getManifest(workspacePath);
+        default: return null;
+    }
+}
+
+async function listDomains(workspacePath) {
+    const files = findVectorFiles(workspacePath);
+    debugLog('Listing domains');
+
+    const domainFiles = Object.entries(files)
+        .filter(([type]) => type !== 'manifest' && type !== 'context')
+        .map(([type, filepath]) => ({
+            domain: type.toUpperCase(),
+            file: `.vector/${type}`,
+            path: filepath
+        }));
+
+    return {
+        success: true,
+        workspace: workspacePath,
+        domain_count: domainFiles.length,
+        domains: domainFiles,
+        special_files: {
+            manifest: files.manifest || null,
+            context: files.context || null
+        }
+    };
+}
+
+async function getDomainRules(args, workspacePath) {
+    const domain = args.domain.toUpperCase();
+    const files = findVectorFiles(workspacePath);
+    debugLog('Getting rules for domain:', domain);
+
+    let domainFile = files[domain.toLowerCase()];
+    let isCommandExtraction = false;
+
+    if (!domainFile && files.commands) {
+        debugLog('No dedicated file, checking commands file for:', domain);
+        domainFile = files.commands;
+        isCommandExtraction = true;
+    }
+
+    if (!domainFile) {
+        return {
+            success: false,
+            error: `Domain file not found: .vector/${domain.toLowerCase()}`,
+            available_domains: Object.keys(files).filter(k => k !== 'manifest' && k !== 'context')
+        };
+    }
+
+    const rules = parseDomainRules(domainFile, domain);
+
+    if (rules.length === 0) {
+        return {
+            success: false,
+            error: `No ${domain}_RULE_* entries found`,
+            domain
+        };
+    }
+
+    const formatted = rules.map(r => `[${domain}] Rule ${r.num}: ${r.text}`);
+
+    return {
+        success: true,
+        domain,
+        rule_count: rules.length,
+        rules: formatted,
+        source: isCommandExtraction ? 'commands' : 'dedicated',
+        instruction: `${domain} rules loaded. Apply these rules to the current context.`
+    };
+}
+
+async function createDomain(args, workspacePath) {
+    const domain = args.domain.toUpperCase();
+    const domainLower = domain.toLowerCase();
+    const { description, recall, rules = [] } = args;
+    const files = findVectorFiles(workspacePath);
+
+    debugLog('Creating domain:', domain);
+
+    if (files[domainLower]) {
+        return { success: false, error: `Domain already exists: ${domain}`, existing_file: files[domainLower] };
+    }
+
+    if (!files.manifest) {
+        return { success: false, error: 'Manifest not found' };
+    }
+
+    const domainFilePath = join(workspacePath, VECTOR_FOLDER, domainLower);
+
+    let domainContent = `# Dynamic Rules Loader V2 - ${domain} Domain
+# ${'='.repeat(40)}
+# ${description}
+#
+# Domain Configuration (synced with .vector/manifest)
+${domain}_STATE=active
+${domain}_ALWAYS_ON=false
+
+# Rule 0: Self-referencing relevance instruction
+${domain}_RULE_0=${domain} rules apply when ${description.toLowerCase()}. If these rules are loaded but the request doesn't involve this domain, note that ${domain} rules are active but may not be needed.
+
+# ============================================================================
+# ${domain} Rules
+# ============================================================================
+`;
+
+    for (let i = 0; i < rules.length; i++) {
+        domainContent += `${domain}_RULE_${i + 1}=${rules[i]}\n`;
+    }
+
+    writeFileSync(domainFilePath, domainContent, 'utf-8');
+
+    const manifestContent = readFileSync(files.manifest, 'utf-8');
+    const manifestEntry = `
+# ============================================================================
+# ${domain} - ${description}
+# ============================================================================
+${domain}_STATE=active
+${domain}_ALWAYS_ON=false
+${domain}_RECALL=${recall}
+# ${domain}_EXCLUDE=
+`;
+
+    writeFileSync(files.manifest, manifestContent + manifestEntry, 'utf-8');
+
+    return {
+        success: true,
+        domain,
+        domain_file: domainFilePath,
+        rule_count: rules.length + 1,
+        recall_keywords: recall,
+        message: `Domain ${domain} created. File: .vector/${domainLower}, Manifest updated.`
+    };
+}
+
+async function toggleDomain(args, workspacePath) {
+    const domain = args.domain.toUpperCase();
+    const newState = args.state.toLowerCase();
+    const files = findVectorFiles(workspacePath);
+
+    debugLog('Toggling domain:', domain, 'to', newState);
+
+    if (!files.manifest) {
+        return { success: false, error: 'Manifest not found' };
+    }
+
+    const content = readFileSync(files.manifest, 'utf-8');
+    const lines = content.split('\n');
+    const stateKey = `${domain}_STATE`;
+    let found = false;
+
+    const newLines = lines.map(line => {
+        if (line.trim().startsWith(stateKey + '=')) {
+            found = true;
+            return `${stateKey}=${newState}`;
+        }
+        return line;
+    });
+
+    if (!found) {
+        return { success: false, error: `Domain not found in manifest: ${domain}` };
+    }
+
+    writeFileSync(files.manifest, newLines.join('\n'), 'utf-8');
+
+    return {
+        success: true,
+        domain,
+        new_state: newState,
+        message: `${domain} is now ${newState}. Change persisted to manifest.`
+    };
+}
+
+async function getManifest(workspacePath) {
+    const files = findVectorFiles(workspacePath);
+    debugLog('Getting manifest');
+
+    if (!files.manifest) {
+        return { success: false, error: 'Manifest not found' };
+    }
+
+    const domains = parseManifest(files.manifest);
+
+    const formatted = {};
+    for (const [name, config] of Object.entries(domains)) {
+        formatted[name] = {
+            state: config.state ? 'active' : 'inactive',
+            always_on: config.always_on || false,
+            recall: config.recall || ''
+        };
+    }
+
+    return {
+        success: true,
+        manifest_path: files.manifest,
+        domain_count: Object.keys(domains).length,
+        domains: formatted
+    };
+}

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

@@ -0,0 +1,252 @@
+/**
+ * Vector Staging — Rule proposal staging pipeline (legacy v1 file-based)
+ * Stage, review, approve/kill rule proposals before they become Vector rules
+ *
+ * Note: v2 users should use vector_v2_stage_proposal / vector_v2_approve_proposal
+ * from vector-json.js, which stages directly in vector.json.
+ * This file provides backward compatibility for v1 flat-file setups.
+ */
+
+import { readFileSync, writeFileSync, existsSync, appendFileSync, mkdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+const VALID_SOURCES = ['psmm', 'decisions', 'manual'];
+
+function debugLog(...args) {
+    console.error('[Vector:staging]', new Date().toISOString(), ...args);
+}
+
+function getStagingPath(workspacePath) {
+    return join(workspacePath, '.vector', 'staging.json');
+}
+
+function readStaging(workspacePath) {
+    const filepath = getStagingPath(workspacePath);
+    if (!existsSync(filepath)) {
+        return { proposals: [] };
+    }
+    try {
+        return JSON.parse(readFileSync(filepath, 'utf-8'));
+    } catch (error) {
+        debugLog('Error reading staging.json:', error.message);
+        return { proposals: [] };
+    }
+}
+
+function writeStaging(workspacePath, data) {
+    const filepath = getStagingPath(workspacePath);
+    const dir = dirname(filepath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(filepath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+function nextProposalId(proposals) {
+    if (proposals.length === 0) return 'prop-001';
+    const nums = proposals.map(p => parseInt(p.id.replace('prop-', ''), 10)).filter(n => !isNaN(n));
+    const max = nums.length > 0 ? Math.max(...nums) : 0;
+    return `prop-${String(max + 1).padStart(3, '0')}`;
+}
+
+// ============================================================
+// TOOL DEFINITIONS
+// ============================================================
+
+export const TOOLS = [
+    {
+        name: "vector_stage_proposal",
+        description: "Stage a new Vector rule proposal for review. Sources: psmm, decisions, manual.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: { type: "string", description: "Target domain (e.g., 'GLOBAL', 'DEVELOPMENT')" },
+                rule_text: { type: "string", description: "The proposed rule text" },
+                rationale: { type: "string", description: "Why this rule should exist" },
+                source: { type: "string", enum: VALID_SOURCES, description: "Where this proposal came from" }
+            },
+            required: ["domain", "rule_text", "rationale", "source"]
+        }
+    },
+    {
+        name: "vector_get_staged",
+        description: "List all pending rule proposals in the staging pipeline.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "vector_approve_proposal",
+        description: "Approve a staged proposal — writes the rule to the target domain file and removes from staging.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Proposal ID (e.g., 'prop-001')" }
+            },
+            required: ["id"]
+        }
+    },
+    {
+        name: "vector_kill_proposal",
+        description: "Delete a staged proposal permanently.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Proposal ID to delete" }
+            },
+            required: ["id"]
+        }
+    },
+    {
+        name: "vector_archive_proposal",
+        description: "Archive a proposal — keeps it for reference but doesn't activate as a rule.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                id: { type: "string", description: "Proposal ID to archive" }
+            },
+            required: ["id"]
+        }
+    }
+];
+
+// ============================================================
+// TOOL HANDLERS
+// ============================================================
+
+export async function handleTool(name, args, workspacePath) {
+    switch (name) {
+        case "vector_stage_proposal": return stageProposal(args, workspacePath);
+        case "vector_get_staged": return getStaged(workspacePath);
+        case "vector_approve_proposal": return approveProposal(args, workspacePath);
+        case "vector_kill_proposal": return killProposal(args, workspacePath);
+        case "vector_archive_proposal": return archiveProposal(args, workspacePath);
+        default: return null;
+    }
+}
+
+async function stageProposal(args, workspacePath) {
+    const { domain, rule_text, rationale, source } = args;
+
+    if (!VALID_SOURCES.includes(source)) {
+        return { success: false, error: `Invalid source: ${source}. Valid: ${VALID_SOURCES.join(', ')}` };
+    }
+
+    debugLog('Staging proposal for domain:', domain);
+
+    const data = readStaging(workspacePath);
+    const id = nextProposalId(data.proposals);
+    const date = new Date().toISOString().split('T')[0];
+
+    const proposal = {
+        id,
+        proposed: date,
+        source,
+        domain: domain.toUpperCase(),
+        rule_text,
+        rationale,
+        status: 'pending'
+    };
+
+    data.proposals.push(proposal);
+    writeStaging(workspacePath, data);
+
+    return {
+        success: true,
+        id,
+        domain: proposal.domain,
+        message: `Staged ${id} for ${proposal.domain}: "${rule_text.slice(0, 60)}..."`
+    };
+}
+
+async function getStaged(workspacePath) {
+    debugLog('Getting staged proposals');
+    const data = readStaging(workspacePath);
+
+    const pending = data.proposals.filter(p => p.status === 'pending');
+    const archived = data.proposals.filter(p => p.status === 'archived');
+
+    return {
+        success: true,
+        pending_count: pending.length,
+        archived_count: archived.length,
+        pending,
+        archived
+    };
+}
+
+async function approveProposal(args, workspacePath) {
+    const { id } = args;
+    debugLog('Approving proposal:', id);
+
+    const data = readStaging(workspacePath);
+    const idx = data.proposals.findIndex(p => p.id === id && p.status === 'pending');
+
+    if (idx === -1) {
+        return { success: false, error: `Pending proposal not found: ${id}` };
+    }
+
+    const proposal = data.proposals[idx];
+    const domain = proposal.domain;
+    const domainLower = domain.toLowerCase();
+
+    // Find the domain file
+    const domainFilePath = join(workspacePath, '.vector', domainLower);
+
+    if (!existsSync(domainFilePath)) {
+        return { success: false, error: `Domain file not found: .vector/${domainLower}` };
+    }
+
+    // Read domain file and find next rule number
+    const content = readFileSync(domainFilePath, 'utf-8');
+    const ruleRegex = new RegExp(`${domain}_RULE_(\\d+)`, 'g');
+    const ruleNums = [...content.matchAll(ruleRegex)].map(m => parseInt(m[1], 10));
+    const nextNum = ruleNums.length > 0 ? Math.max(...ruleNums) + 1 : 1;
+
+    // Append the new rule
+    const ruleLine = `${domain}_RULE_${nextNum}=${proposal.rule_text}\n`;
+    appendFileSync(domainFilePath, ruleLine, 'utf-8');
+
+    // Remove from staging
+    data.proposals.splice(idx, 1);
+    writeStaging(workspacePath, data);
+
+    return {
+        success: true,
+        id,
+        domain,
+        rule_number: nextNum,
+        message: `Approved ${id} → ${domain}_RULE_${nextNum} written to .vector/${domainLower}`
+    };
+}
+
+async function killProposal(args, workspacePath) {
+    const { id } = args;
+    debugLog('Killing proposal:', id);
+
+    const data = readStaging(workspacePath);
+    const idx = data.proposals.findIndex(p => p.id === id);
+
+    if (idx === -1) {
+        return { success: false, error: `Proposal not found: ${id}` };
+    }
+
+    data.proposals.splice(idx, 1);
+    writeStaging(workspacePath, data);
+
+    return { success: true, message: `Deleted proposal ${id}` };
+}
+
+async function archiveProposal(args, workspacePath) {
+    const { id } = args;
+    debugLog('Archiving proposal:', id);
+
+    const data = readStaging(workspacePath);
+    const proposal = data.proposals.find(p => p.id === id && p.status === 'pending');
+
+    if (!proposal) {
+        return { success: false, error: `Pending proposal not found: ${id}` };
+    }
+
+    proposal.status = 'archived';
+    proposal.archived_date = new Date().toISOString().split('T')[0];
+    writeStaging(workspacePath, data);
+
+    return { success: true, message: `Archived proposal ${id}` };
+}