gnosys 4.0.0

package/dist/sandbox/server.js

@@ -0,0 +1,661 @@
+/**
+ * Gnosys Sandbox Server
+ *
+ * Lightweight background Node process that holds a GnosysDB connection
+ * and processes requests over a Unix domain socket (or named pipe on Windows).
+ *
+ * Phase 9b: Integrates Dream Mode (idle-triggered), preferences, and sync.
+ *
+ * No Docker. No external deps. Just Node + better-sqlite3.
+ */
+import net from "net";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { GnosysDB } from "../lib/db.js";
+import { federatedSearch } from "../lib/federated.js";
+import { setPreference, getPreference, getAllPreferences, deletePreference, searchPreferences } from "../lib/preferences.js";
+import { GnosysDreamEngine, DreamScheduler, DEFAULT_DREAM_CONFIG } from "../lib/dream.js";
+import { DEFAULT_CONFIG } from "../lib/config.js";
+import { generateRulesBlock } from "../lib/rulesGen.js";
+// ─── Socket + PID paths ─────────────────────────────────────────────────
+export function getSandboxDir() {
+    const dir = path.join(os.homedir(), ".gnosys", "sandbox");
+    fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function getSocketPath() {
+    if (process.platform === "win32") {
+        return "\\\\.\\pipe\\gnosys-sandbox";
+    }
+    return path.join(getSandboxDir(), "gnosys.sock");
+}
+export function getPidPath() {
+    return path.join(getSandboxDir(), "gnosys.pid");
+}
+let dreamState = {
+    enabled: false,
+    idleMinutes: DEFAULT_DREAM_CONFIG.idleMinutes,
+    lastDreamReport: null,
+    dreamsCompleted: 0,
+    isDreaming: false,
+};
+let dreamScheduler = null;
+/**
+ * Initialize Dream Mode in the sandbox.
+ * Called once during server startup.
+ */
+export function initDreamMode(db, config, dreamConfig) {
+    const mergedConfig = {
+        ...DEFAULT_DREAM_CONFIG,
+        ...config.dream,
+        ...dreamConfig,
+        enabled: true, // Always enable in sandbox if caller invokes this
+    };
+    dreamState.enabled = true;
+    dreamState.idleMinutes = mergedConfig.idleMinutes;
+    const engine = new GnosysDreamEngine(db, config, mergedConfig);
+    // Create a scheduler that wraps progress tracking
+    const scheduler = new DreamScheduler(engine, mergedConfig);
+    // Monkey-patch the scheduler's private checkIdle to track dream state
+    const originalStart = scheduler.start.bind(scheduler);
+    scheduler.start = function () {
+        originalStart();
+        // Override the internal check interval to track state
+        const CHECK_INTERVAL = 60_000;
+        const origCheckIdle = scheduler.checkIdle;
+        if (origCheckIdle) {
+            scheduler.checkIdle = async function () {
+                dreamState.isDreaming = scheduler.isDreaming();
+                await origCheckIdle.call(scheduler);
+                dreamState.isDreaming = scheduler.isDreaming();
+                if (!scheduler.isDreaming() && dreamState.isDreaming) {
+                    dreamState.dreamsCompleted++;
+                }
+            };
+        }
+    };
+    return scheduler;
+}
+// ─── Request Handler ─────────────────────────────────────────────────────
+export function handleRequest(db, req) {
+    // Record activity for idle detection (Dream Mode)
+    if (dreamScheduler) {
+        dreamScheduler.recordActivity();
+    }
+    try {
+        switch (req.method) {
+            case "ping":
+                return { id: req.id, ok: true, result: { status: "ok", pid: process.pid } };
+            case "add": {
+                const { content, title, category = "decisions", project_id, scope = "project", tags = "[]", relevance = "", author = "ai", authority = "declared", confidence = 0.9 } = req.params;
+                if (!content)
+                    return { id: req.id, ok: false, error: "content is required" };
+                const now = new Date().toISOString();
+                const memTitle = title || content.slice(0, 80);
+                const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                db.insertMemory({
+                    id,
+                    title: memTitle,
+                    category,
+                    content,
+                    summary: null,
+                    tags: typeof tags === "string" ? tags : JSON.stringify(tags),
+                    relevance: relevance || content.slice(0, 200),
+                    author,
+                    authority,
+                    confidence: Number(confidence),
+                    reinforcement_count: 0,
+                    content_hash: "",
+                    status: "active",
+                    tier: "active",
+                    supersedes: null,
+                    superseded_by: null,
+                    last_reinforced: null,
+                    created: now,
+                    modified: now,
+                    embedding: null,
+                    source_path: null,
+                    project_id: project_id || null,
+                    scope: scope,
+                });
+                return { id: req.id, ok: true, result: { id, title: memTitle } };
+            }
+            case "recall": {
+                const { query, limit = 10, project_id } = req.params;
+                if (!query)
+                    return { id: req.id, ok: false, error: "query is required" };
+                // Use federated search if available, fall back to FTS
+                try {
+                    const results = federatedSearch(db, query, {
+                        limit: Number(limit),
+                        projectId: project_id,
+                    });
+                    return {
+                        id: req.id,
+                        ok: true,
+                        result: results.map((r) => {
+                            // Enrich with full memory data when available
+                            const mem = db.getMemory(r.id);
+                            return {
+                                id: r.id,
+                                title: r.title,
+                                content: mem?.content || r.snippet,
+                                category: r.category,
+                                confidence: mem?.confidence ?? 0,
+                                score: r.score,
+                            };
+                        }),
+                    };
+                }
+                catch {
+                    // Fall back to basic FTS
+                    const results = db.searchFts(query, Number(limit));
+                    return {
+                        id: req.id,
+                        ok: true,
+                        result: results.map((r) => ({
+                            id: r.id,
+                            title: r.title,
+                            snippet: r.snippet,
+                            rank: r.rank,
+                        })),
+                    };
+                }
+            }
+            case "reinforce": {
+                const { id: memId, query } = req.params;
+                let targetId = memId;
+                // If query provided instead of ID, find best match
+                if (!targetId && query) {
+                    const results = db.searchFts(query, 1);
+                    if (results.length === 0) {
+                        return { id: req.id, ok: false, error: `No memory found matching "${query}"` };
+                    }
+                    targetId = results[0].id;
+                }
+                if (!targetId)
+                    return { id: req.id, ok: false, error: "id or query is required" };
+                const mem = db.getMemory(targetId);
+                if (!mem)
+                    return { id: req.id, ok: false, error: `Memory not found: ${targetId}` };
+                db.updateMemory(targetId, {
+                    reinforcement_count: mem.reinforcement_count + 1,
+                    confidence: Math.min(1.0, mem.confidence + 0.05),
+                    last_reinforced: new Date().toISOString(),
+                    modified: new Date().toISOString(),
+                });
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: {
+                        id: targetId,
+                        reinforcement_count: mem.reinforcement_count + 1,
+                        confidence: Math.min(1.0, mem.confidence + 0.05),
+                    },
+                };
+            }
+            case "get": {
+                const { id: memId } = req.params;
+                if (!memId)
+                    return { id: req.id, ok: false, error: "id is required" };
+                const mem = db.getMemory(memId);
+                if (!mem)
+                    return { id: req.id, ok: false, error: `Memory not found: ${memId}` };
+                return { id: req.id, ok: true, result: mem };
+            }
+            case "list": {
+                const { category, project_id, limit = 50 } = req.params;
+                let memories;
+                if (project_id) {
+                    memories = db.getMemoriesByProject(project_id);
+                }
+                else if (category) {
+                    memories = db.getMemoriesByCategory(category);
+                }
+                else {
+                    memories = db.getActiveMemories();
+                }
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: memories.slice(0, Number(limit)).map((m) => ({
+                        id: m.id,
+                        title: m.title,
+                        category: m.category,
+                        confidence: m.confidence,
+                        project_id: m.project_id,
+                        scope: m.scope,
+                    })),
+                };
+            }
+            case "stats": {
+                const counts = db.getMemoryCount();
+                const categories = db.getCategories();
+                const projects = db.getAllProjects();
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: {
+                        ...counts,
+                        categories,
+                        projects: projects.length,
+                    },
+                };
+            }
+            // ─── Phase 9b: Preference methods ───────────────────────────────
+            case "pref_set": {
+                const { key, value, title: prefTitle, tags: prefTags, confidence: prefConf } = req.params;
+                if (!key || !value)
+                    return { id: req.id, ok: false, error: "key and value are required" };
+                const pref = setPreference(db, key, value, {
+                    title: prefTitle,
+                    tags: prefTags ? (Array.isArray(prefTags) ? prefTags : JSON.parse(prefTags)) : undefined,
+                    confidence: prefConf ? Number(prefConf) : undefined,
+                });
+                return { id: req.id, ok: true, result: pref };
+            }
+            case "pref_get": {
+                const { key } = req.params;
+                if (!key)
+                    return { id: req.id, ok: false, error: "key is required" };
+                const pref = getPreference(db, key);
+                if (!pref)
+                    return { id: req.id, ok: false, error: `Preference not found: ${key}` };
+                return { id: req.id, ok: true, result: pref };
+            }
+            case "pref_list": {
+                const prefs = getAllPreferences(db);
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: prefs.map((p) => ({ key: p.key, value: p.value, title: p.title })),
+                };
+            }
+            case "pref_delete": {
+                const { key } = req.params;
+                if (!key)
+                    return { id: req.id, ok: false, error: "key is required" };
+                const deleted = deletePreference(db, key);
+                return { id: req.id, ok: true, result: { deleted } };
+            }
+            case "pref_search": {
+                const { query } = req.params;
+                if (!query)
+                    return { id: req.id, ok: false, error: "query is required" };
+                const results = searchPreferences(db, query);
+                return { id: req.id, ok: true, result: results };
+            }
+            // ─── Phase 9b: Dream Mode status ────────────────────────────────
+            case "dream_status": {
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: {
+                        ...dreamState,
+                        isDreaming: dreamScheduler?.isDreaming() ?? false,
+                    },
+                };
+            }
+            // ─── Phase 9b: Sync rules ───────────────────────────────────────
+            case "sync": {
+                const { project_dir, agent_rules_target, project_id } = req.params;
+                if (!project_dir)
+                    return { id: req.id, ok: false, error: "project_dir is required" };
+                if (!agent_rules_target)
+                    return { id: req.id, ok: false, error: "agent_rules_target is required" };
+                // syncRules is async — but we handle it synchronously via blocking
+                // Actually, we need to return a promise-based result. Since the handler is sync,
+                // we'll use a simpler approach: generate the block and inject directly.
+                const preferences = getAllPreferences(db);
+                let projectConventions = [];
+                if (project_id) {
+                    const projectMems = db.getMemoriesByProject(project_id);
+                    projectConventions = projectMems.filter((m) => (m.category === "decisions" || m.category === "conventions") && m.status === "active");
+                }
+                const block = generateRulesBlock(preferences, projectConventions);
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: {
+                        block,
+                        prefCount: preferences.length,
+                        conventionCount: projectConventions.length,
+                    },
+                };
+            }
+            // ─── Phase 10: Reflection API ─────────────────────────────────────
+            case "reflect": {
+                const { outcome, memory_ids, success, notes, confidence_delta, } = req.params;
+                if (!outcome)
+                    return { id: req.id, ok: false, error: "outcome is required" };
+                const now = new Date().toISOString();
+                const memoryIdList = memory_ids
+                    ? (Array.isArray(memory_ids) ? memory_ids : JSON.parse(memory_ids))
+                    : [];
+                const isSuccess = success !== false; // default true
+                const delta = confidence_delta != null
+                    ? Number(confidence_delta)
+                    : (isSuccess ? 0.05 : -0.1);
+                // Track which memories were updated
+                const updated = [];
+                const relationships = [];
+                // If no explicit memory_ids, search for related memories
+                let targetIds = memoryIdList;
+                if (targetIds.length === 0) {
+                    const results = db.searchFts(outcome, 5);
+                    targetIds = results.map((r) => r.id);
+                }
+                // Update confidence on each related memory
+                for (const memId of targetIds) {
+                    const mem = db.getMemory(memId);
+                    if (!mem)
+                        continue;
+                    const newConf = Math.max(0.05, Math.min(1.0, mem.confidence + delta));
+                    const updates = {
+                        confidence: newConf,
+                        modified: now,
+                    };
+                    if (isSuccess) {
+                        updates.reinforcement_count = mem.reinforcement_count + 1;
+                        updates.last_reinforced = now;
+                    }
+                    db.updateMemory(memId, updates);
+                    updated.push({
+                        id: memId,
+                        confidence: newConf,
+                        reinforcement_count: (updates.reinforcement_count ?? mem.reinforcement_count),
+                    });
+                }
+                // Create a reflection memory that records the outcome
+                const reflectionId = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+                const reflectionContent = [
+                    `## Reflection: ${isSuccess ? "Success" : "Failure"}`,
+                    "",
+                    `**Outcome:** ${outcome}`,
+                    notes ? `\n**Notes:** ${notes}` : "",
+                    "",
+                    `**Related memories:** ${targetIds.join(", ")}`,
+                    `**Confidence adjustment:** ${delta > 0 ? "+" : ""}${delta.toFixed(2)}`,
+                ].filter(Boolean).join("\n");
+                db.insertMemory({
+                    id: reflectionId,
+                    title: `Reflection: ${outcome.slice(0, 60)}`,
+                    category: "reflections",
+                    content: reflectionContent,
+                    summary: null,
+                    tags: JSON.stringify(["reflection", isSuccess ? "success" : "failure"]),
+                    relevance: `reflection outcome ${outcome}`,
+                    author: "ai",
+                    authority: "observed",
+                    confidence: 0.8,
+                    reinforcement_count: 0,
+                    content_hash: "",
+                    status: "active",
+                    tier: "active",
+                    supersedes: null,
+                    superseded_by: null,
+                    last_reinforced: null,
+                    created: now,
+                    modified: now,
+                    embedding: null,
+                    source_path: null,
+                    project_id: null,
+                    scope: "user",
+                });
+                // Add relationships: reflection → each related memory
+                for (const memId of targetIds) {
+                    db.insertRelationship({
+                        source_id: reflectionId,
+                        target_id: memId,
+                        rel_type: isSuccess ? "validates" : "contradicts",
+                        label: `Reflection ${isSuccess ? "validated" : "contradicted"} this memory`,
+                        confidence: 0.9,
+                        created: now,
+                    });
+                    relationships.push({
+                        source_id: reflectionId,
+                        target_id: memId,
+                        rel_type: isSuccess ? "validates" : "contradicts",
+                    });
+                }
+                // Consolidation: if success, link related memories to each other
+                if (isSuccess && targetIds.length > 1) {
+                    for (let i = 0; i < targetIds.length - 1; i++) {
+                        db.insertRelationship({
+                            source_id: targetIds[i],
+                            target_id: targetIds[i + 1],
+                            rel_type: "corroborates",
+                            label: `Linked by successful reflection on: ${outcome.slice(0, 60)}`,
+                            confidence: 0.7,
+                            created: now,
+                        });
+                    }
+                }
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: {
+                        reflection_id: reflectionId,
+                        outcome: isSuccess ? "success" : "failure",
+                        memories_updated: updated,
+                        relationships_created: relationships.length,
+                        confidence_delta: delta,
+                    },
+                };
+            }
+            // ─── Phase 10: Traverse relationship chains ────────────────────────
+            case "traverse": {
+                const { id: startId, depth = 3, rel_types, } = req.params;
+                if (!startId)
+                    return { id: req.id, ok: false, error: "id is required" };
+                const maxDepth = Math.min(Number(depth), 10); // safety cap
+                const allowedTypes = rel_types
+                    ? (Array.isArray(rel_types) ? rel_types : JSON.parse(rel_types))
+                    : null;
+                const visited = new Set();
+                const nodes = [];
+                const queue = [];
+                // Start node
+                const startMem = db.getMemory(startId);
+                if (!startMem)
+                    return { id: req.id, ok: false, error: `Memory not found: ${startId}` };
+                visited.add(startId);
+                nodes.push({
+                    id: startMem.id,
+                    title: startMem.title,
+                    category: startMem.category,
+                    confidence: startMem.confidence,
+                    depth: 0,
+                    via_rel: null,
+                    via_from: null,
+                });
+                queue.push({ id: startId, depth: 0, via_rel: null, via_from: null });
+                while (queue.length > 0) {
+                    const current = queue.shift();
+                    if (current.depth >= maxDepth)
+                        continue;
+                    // Get outgoing relationships
+                    const outgoing = db.getRelationshipsFrom(current.id);
+                    const incoming = db.getRelationshipsTo(current.id);
+                    const allRels = [
+                        ...outgoing.map((r) => ({ targetId: r.target_id, rel_type: r.rel_type })),
+                        ...incoming.map((r) => ({ targetId: r.source_id, rel_type: r.rel_type })),
+                    ];
+                    for (const rel of allRels) {
+                        if (visited.has(rel.targetId))
+                            continue;
+                        if (allowedTypes && !allowedTypes.includes(rel.rel_type))
+                            continue;
+                        visited.add(rel.targetId);
+                        const mem = db.getMemory(rel.targetId);
+                        if (!mem)
+                            continue;
+                        const node = {
+                            id: mem.id,
+                            title: mem.title,
+                            category: mem.category,
+                            confidence: mem.confidence,
+                            depth: current.depth + 1,
+                            via_rel: rel.rel_type,
+                            via_from: current.id,
+                        };
+                        nodes.push(node);
+                        queue.push({
+                            id: mem.id,
+                            depth: current.depth + 1,
+                            via_rel: rel.rel_type,
+                            via_from: current.id,
+                        });
+                    }
+                }
+                return {
+                    id: req.id,
+                    ok: true,
+                    result: {
+                        root: startId,
+                        depth: maxDepth,
+                        nodes,
+                        total: nodes.length,
+                    },
+                };
+            }
+            case "shutdown":
+                // Stop dream scheduler before shutting down
+                if (dreamScheduler) {
+                    dreamScheduler.stop();
+                }
+                setTimeout(() => {
+                    db.close();
+                    process.exit(0);
+                }, 100);
+                return { id: req.id, ok: true, result: { message: "Shutting down" } };
+            default:
+                return { id: req.id, ok: false, error: `Unknown method: ${req.method}` };
+        }
+    }
+    catch (err) {
+        return {
+            id: req.id,
+            ok: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+// ─── Server ──────────────────────────────────────────────────────────────
+export function startServer(dbPath) {
+    const socketPath = getSocketPath();
+    // Clean up stale socket
+    if (process.platform !== "win32" && fs.existsSync(socketPath)) {
+        fs.unlinkSync(socketPath);
+    }
+    // Open database (with retry for network shares — Dropbox, iCloud, NAS)
+    const dbDir = dbPath || GnosysDB.getCentralDbDir();
+    const isNetworkPath = dbPath ? true : false;
+    const db = new GnosysDB(dbDir, isNetworkPath ? { retries: 5, retryDelayMs: 1000 } : undefined);
+    if (!db.isAvailable()) {
+        console.error("Failed to open GnosysDB. Is better-sqlite3 installed?");
+        if (isNetworkPath) {
+            console.error(`Network path "${dbDir}" may be unavailable. Check the path is mounted and accessible.`);
+        }
+        process.exit(1);
+    }
+    if (isNetworkPath) {
+        console.log(`Using network DB path: ${dbDir}`);
+    }
+    // ─── Phase 9b: Initialize Dream Mode ─────────────────────────────
+    // loadConfig is async and needs a store path — in sandbox mode we use defaults
+    // and allow env-based overrides.
+    const config = {
+        ...DEFAULT_CONFIG,
+        dream: {
+            ...DEFAULT_CONFIG.dream,
+            enabled: process.env.GNOSYS_DREAM_ENABLED !== "false",
+            idleMinutes: parseInt(process.env.GNOSYS_DREAM_IDLE_MINUTES || "10", 10),
+        },
+    };
+    if (config.dream?.enabled !== false) {
+        try {
+            dreamScheduler = initDreamMode(db, config);
+            if (dreamScheduler) {
+                dreamScheduler.start();
+                console.log(`Dream Mode enabled (idle threshold: ${dreamState.idleMinutes}min)`);
+            }
+        }
+        catch (err) {
+            console.error(`Dream Mode init failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    const server = net.createServer((socket) => {
+        let buffer = "";
+        socket.on("data", (data) => {
+            buffer += data.toString();
+            // Process complete JSON messages (newline-delimited)
+            let newlineIdx;
+            while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+                const line = buffer.slice(0, newlineIdx).trim();
+                buffer = buffer.slice(newlineIdx + 1);
+                if (!line)
+                    continue;
+                try {
+                    const raw = JSON.parse(line);
+                    // Validate required fields before casting
+                    if (typeof raw !== "object" || raw === null ||
+                        typeof raw.id !== "string" ||
+                        typeof raw.method !== "string" ||
+                        (raw.params !== undefined && (typeof raw.params !== "object" || raw.params === null))) {
+                        throw new Error("Missing required fields: id (string), method (string)");
+                    }
+                    const req = {
+                        id: raw.id,
+                        method: raw.method,
+                        params: raw.params || {},
+                    };
+                    const res = handleRequest(db, req);
+                    socket.write(JSON.stringify(res) + "\n");
+                }
+                catch (err) {
+                    socket.write(JSON.stringify({
+                        id: "error",
+                        ok: false,
+                        error: `Invalid request: ${err instanceof Error ? err.message : String(err)}`,
+                    }) + "\n");
+                }
+            }
+        });
+        socket.on("error", () => {
+            // Client disconnected — that's fine
+        });
+    });
+    server.listen(socketPath, () => {
+        // Write PID file
+        fs.writeFileSync(getPidPath(), String(process.pid));
+        console.log(`Gnosys sandbox running (pid: ${process.pid}, socket: ${socketPath})`);
+    });
+    // Cleanup on exit
+    const cleanup = () => {
+        try {
+            if (dreamScheduler)
+                dreamScheduler.stop();
+            db.close();
+            if (fs.existsSync(socketPath))
+                fs.unlinkSync(socketPath);
+            if (fs.existsSync(getPidPath()))
+                fs.unlinkSync(getPidPath());
+        }
+        catch {
+            // Best effort
+        }
+    };
+    process.on("SIGTERM", () => { cleanup(); process.exit(0); });
+    process.on("SIGINT", () => { cleanup(); process.exit(0); });
+    process.on("exit", cleanup);
+    return server;
+}
+// ─── Entry point (when run directly) ─────────────────────────────────────
+if (process.argv[1] && (process.argv[1].endsWith("sandbox/server.js") ||
+    process.argv[1].endsWith("sandbox/server.ts"))) {
+    const dbPath = process.argv.find((a) => a.startsWith("--db-path="))?.split("=")[1];
+    startServer(dbPath);
+}
+//# sourceMappingURL=server.js.map