@datafrog-io/n2n-nexus 0.1.7 → 0.1.8

package/build/storage/sqlite-meeting.js

@@ -0,0 +1,249 @@
+import { getDatabase, initDatabase } from "./sqlite.js";
+/**
+ * SQLite-backed Meeting Store
+ * Provides ACID-compliant concurrent access to meeting data
+ */
+export class SqliteMeetingStore {
+    /**
+     * Initialize the database
+     */
+    static init() {
+        initDatabase();
+    }
+    /**
+     * Generate a unique meeting ID
+     */
+    static generateMeetingId(topic) {
+        const now = new Date();
+        const timestamp = now.toISOString().replace(/[-:T]/g, "").substring(0, 14);
+        // Create slug from topic, fallback to base64 hash for non-ASCII
+        let slug = topic
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, "-")
+            .replace(/^-|-$/g, "")
+            .substring(0, 30);
+        // If slug is empty (e.g., Chinese topic), use base64 of topic
+        if (!slug) {
+            slug = Buffer.from(topic).toString("base64").replace(/[^a-zA-Z0-9]/g, "").substring(0, 8).toLowerCase();
+        }
+        // Add random suffix for uniqueness (prevents collision in same second)
+        const suffix = Math.random().toString(36).substring(2, 6);
+        return `${timestamp}-${slug || "meeting"}-${suffix}`;
+    }
+    /**
+     * Start a new meeting
+     */
+    static startMeeting(topic, initiator) {
+        const db = getDatabase();
+        const id = this.generateMeetingId(topic);
+        const now = new Date().toISOString();
+        const participants = JSON.stringify([initiator]);
+        const stmt = db.prepare(`
+            INSERT INTO meetings (id, topic, status, participants, created_at)
+            VALUES (?, ?, 'active', ?, ?)
+        `);
+        stmt.run(id, topic, participants, now);
+        // Update state
+        this.updateState("default_meeting", id);
+        const activeMeetings = this.getActiveMeetingIds();
+        activeMeetings.push(id);
+        this.updateState("active_meetings", JSON.stringify(activeMeetings));
+        return {
+            id,
+            topic,
+            status: "active",
+            startTime: now,
+            participants: [initiator],
+            messages: [],
+            decisions: []
+        };
+    }
+    /**
+     * Get a meeting by ID
+     */
+    static getMeeting(id) {
+        const db = getDatabase();
+        const meetingStmt = db.prepare("SELECT * FROM meetings WHERE id = ?");
+        const meeting = meetingStmt.get(id);
+        if (!meeting)
+            return null;
+        // Get messages
+        const messagesStmt = db.prepare(`
+            SELECT sender as "from", text, category, timestamp
+            FROM messages WHERE meeting_id = ?
+            ORDER BY timestamp ASC
+        `);
+        const messages = messagesStmt.all(id);
+        // Get decisions
+        const decisionsStmt = db.prepare(`
+            SELECT content FROM decisions WHERE meeting_id = ?
+            ORDER BY timestamp ASC
+        `);
+        const decisions = decisionsStmt.all(id).map(d => d.content);
+        return {
+            id: meeting.id,
+            topic: meeting.topic,
+            status: meeting.status,
+            startTime: meeting.created_at,
+            endTime: meeting.closed_at || undefined,
+            participants: JSON.parse(meeting.participants),
+            messages,
+            decisions,
+            summary: meeting.summary || undefined
+        };
+    }
+    /**
+     * Add a message to a meeting
+     */
+    static addMessage(meetingId, message) {
+        const db = getDatabase();
+        // Check meeting status
+        const checkStmt = db.prepare("SELECT status, participants FROM meetings WHERE id = ?");
+        const meeting = checkStmt.get(meetingId);
+        if (!meeting)
+            throw new Error(`Meeting '${meetingId}' not found.`);
+        if (meeting.status !== "active")
+            throw new Error(`Meeting '${meetingId}' is ${meeting.status}, cannot add messages.`);
+        // Insert message
+        const insertStmt = db.prepare(`
+            INSERT INTO messages (meeting_id, sender, text, category, timestamp)
+            VALUES (?, ?, ?, ?, ?)
+        `);
+        insertStmt.run(meetingId, message.from, message.text, message.category || null, message.timestamp);
+        // Track participant
+        const participants = JSON.parse(meeting.participants);
+        if (!participants.includes(message.from)) {
+            participants.push(message.from);
+            const updateStmt = db.prepare("UPDATE meetings SET participants = ? WHERE id = ?");
+            updateStmt.run(JSON.stringify(participants), meetingId);
+        }
+        // Extract decision
+        if (message.category === "DECISION") {
+            const decisionStmt = db.prepare(`
+                INSERT INTO decisions (meeting_id, content, timestamp)
+                VALUES (?, ?, ?)
+            `);
+            decisionStmt.run(meetingId, message.text, message.timestamp);
+        }
+    }
+    /**
+     * End a meeting
+     */
+    static endMeeting(meetingId, summary) {
+        const db = getDatabase();
+        const now = new Date().toISOString();
+        // Check meeting exists and is active
+        const meeting = this.getMeeting(meetingId);
+        if (!meeting)
+            throw new Error(`Meeting '${meetingId}' not found.`);
+        if (meeting.status !== "active")
+            throw new Error(`Meeting '${meetingId}' is already ${meeting.status}.`);
+        // Update meeting
+        const stmt = db.prepare(`
+            UPDATE meetings SET status = 'closed', closed_at = ?, summary = ?
+            WHERE id = ?
+        `);
+        stmt.run(now, summary || null, meetingId);
+        // Update state
+        const activeMeetings = this.getActiveMeetingIds().filter(id => id !== meetingId);
+        this.updateState("active_meetings", JSON.stringify(activeMeetings));
+        this.updateState("default_meeting", activeMeetings.length > 0 ? activeMeetings[activeMeetings.length - 1] : "");
+        // Refresh meeting data
+        const updatedMeeting = this.getMeeting(meetingId);
+        // Suggest sync targets based on participants
+        const suggestedSyncTargets = updatedMeeting.participants
+            .map(p => p.split("@")[1])
+            .filter((v, i, a) => v && v !== "Global" && a.indexOf(v) === i);
+        return { meeting: updatedMeeting, suggestedSyncTargets };
+    }
+    /**
+     * Archive a meeting
+     */
+    static archiveMeeting(meetingId) {
+        const db = getDatabase();
+        const meeting = this.getMeeting(meetingId);
+        if (!meeting)
+            throw new Error(`Meeting '${meetingId}' not found.`);
+        if (meeting.status === "active")
+            throw new Error(`Meeting '${meetingId}' is still active. End it first.`);
+        const stmt = db.prepare("UPDATE meetings SET status = 'archived' WHERE id = ?");
+        stmt.run(meetingId);
+    }
+    /**
+     * List meetings with optional status filter
+     */
+    static listMeetings(status) {
+        const db = getDatabase();
+        let query = "SELECT id, topic, status, participants, created_at FROM meetings";
+        const params = [];
+        if (status) {
+            query += " WHERE status = ?";
+            params.push(status);
+        }
+        query += " ORDER BY created_at DESC";
+        const stmt = db.prepare(query);
+        const meetings = (params.length > 0 ? stmt.all(...params) : stmt.all());
+        return meetings.map(m => ({
+            id: m.id,
+            topic: m.topic,
+            status: m.status,
+            startTime: m.created_at,
+            participantCount: JSON.parse(m.participants).length
+        }));
+    }
+    /**
+     * Get the current active meeting
+     */
+    static getActiveMeeting() {
+        const defaultId = this.getState("default_meeting");
+        if (!defaultId)
+            return null;
+        return this.getMeeting(defaultId);
+    }
+    /**
+     * Get recent messages from a meeting
+     */
+    static getRecentMessages(count = 10, meetingId) {
+        const db = getDatabase();
+        const targetId = meetingId || this.getState("default_meeting");
+        if (!targetId)
+            return [];
+        const stmt = db.prepare(`
+            SELECT sender as "from", text, category, timestamp
+            FROM messages WHERE meeting_id = ?
+            ORDER BY timestamp DESC LIMIT ?
+        `);
+        const messages = stmt.all(targetId, count);
+        // Reverse to get chronological order
+        return messages.reverse();
+    }
+    /**
+     * Get meeting state value
+     */
+    static getState(key) {
+        const db = getDatabase();
+        const stmt = db.prepare("SELECT value FROM meeting_state WHERE key = ?");
+        const row = stmt.get(key);
+        return row?.value || "";
+    }
+    /**
+     * Update meeting state value
+     */
+    static updateState(key, value) {
+        const db = getDatabase();
+        const stmt = db.prepare("INSERT OR REPLACE INTO meeting_state (key, value) VALUES (?, ?)");
+        stmt.run(key, value);
+    }
+    /**
+     * Get list of active meeting IDs
+     */
+    static getActiveMeetingIds() {
+        const value = this.getState("active_meetings");
+        try {
+            return JSON.parse(value) || [];
+        }
+        catch {
+            return [];
+        }
+    }
+}

package/build/storage/sqlite.js

@@ -0,0 +1,120 @@
+import Database from "better-sqlite3";
+import path from "path";
+import { CONFIG } from "../config.js";
+let db = null;
+/**
+ * SQLite Database Schema for Nexus Meetings
+ */
+const SCHEMA = `
+-- Meetings table
+CREATE TABLE IF NOT EXISTS meetings (
+    id TEXT PRIMARY KEY,
+    topic TEXT NOT NULL,
+    status TEXT CHECK(status IN ('active', 'closed', 'archived')) DEFAULT 'active',
+    participants TEXT DEFAULT '[]',
+    created_at TEXT NOT NULL,
+    closed_at TEXT,
+    summary TEXT
+);
+
+-- Messages table
+CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    meeting_id TEXT NOT NULL,
+    sender TEXT NOT NULL,
+    text TEXT NOT NULL,
+    category TEXT CHECK(category IN ('MEETING_START', 'PROPOSAL', 'DECISION', 'UPDATE', 'CHAT')),
+    timestamp TEXT NOT NULL,
+    FOREIGN KEY (meeting_id) REFERENCES meetings(id)
+);
+
+-- Decisions table (extracted from DECISION messages)
+CREATE TABLE IF NOT EXISTS decisions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    meeting_id TEXT NOT NULL,
+    content TEXT NOT NULL,
+    timestamp TEXT NOT NULL,
+    FOREIGN KEY (meeting_id) REFERENCES meetings(id)
+);
+
+-- Meeting state (Key-Value store)
+CREATE TABLE IF NOT EXISTS meeting_state (
+    key TEXT PRIMARY KEY,
+    value TEXT NOT NULL
+);
+
+-- Indexes for performance
+CREATE INDEX IF NOT EXISTS idx_messages_meeting ON messages(meeting_id);
+CREATE INDEX IF NOT EXISTS idx_messages_timestamp ON messages(timestamp);
+CREATE INDEX IF NOT EXISTS idx_decisions_meeting ON decisions(meeting_id);
+CREATE INDEX IF NOT EXISTS idx_meetings_status ON meetings(status);
+`;
+/**
+ * Get the database file path
+ */
+export function getDbPath() {
+    return path.join(CONFIG.rootStorage, "nexus.db");
+}
+/**
+ * Initialize the SQLite database with WAL mode
+ */
+export function initDatabase() {
+    if (db)
+        return db;
+    const dbPath = getDbPath();
+    db = new Database(dbPath);
+    // Enable WAL mode for better concurrent access
+    db.pragma("journal_mode = WAL");
+    // Initialize schema
+    db.exec(SCHEMA);
+    // Initialize default state if not exists
+    const stmt = db.prepare("INSERT OR IGNORE INTO meeting_state (key, value) VALUES (?, ?)");
+    stmt.run("active_meetings", "[]");
+    stmt.run("default_meeting", "");
+    console.error("[Nexus] SQLite database initialized at:", dbPath);
+    return db;
+}
+/**
+ * Get the database instance
+ */
+export function getDatabase() {
+    if (!db) {
+        return initDatabase();
+    }
+    return db;
+}
+/**
+ * Close the database connection
+ */
+export function closeDatabase() {
+    if (db) {
+        db.close();
+        db = null;
+        console.error("[Nexus] SQLite database closed");
+    }
+}
+/**
+ * Check if SQLite is available
+ */
+export function isSqliteAvailable() {
+    try {
+        // Try to load better-sqlite3
+        require("better-sqlite3");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// Cleanup on process exit
+process.on("exit", () => {
+    closeDatabase();
+});
+process.on("SIGINT", () => {
+    closeDatabase();
+    process.exit(0);
+});
+process.on("SIGTERM", () => {
+    closeDatabase();
+    process.exit(0);
+});

package/build/storage/store.js

@@ -0,0 +1,139 @@
+/**
+ * Meeting Store Entry Point
+ *
+ * Provides a unified interface that automatically selects between:
+ * - SQLite backend (preferred, for concurrent access safety)
+ * - JSON backend (fallback, for environments without native module support)
+ */
+// Lazy-loaded store implementation
+let storeType = null;
+let SqliteStore = null;
+let JsonStore = null;
+/**
+ * Detect and initialize the appropriate store
+ */
+async function getStore() {
+    if (storeType === "sqlite" && SqliteStore) {
+        return { type: "sqlite", store: SqliteStore };
+    }
+    if (storeType === "json" && JsonStore) {
+        return { type: "json", store: JsonStore };
+    }
+    // Try SQLite first
+    try {
+        // Dynamic import to avoid bundling issues
+        const sqliteModule = await import("./sqlite-meeting.js");
+        SqliteStore = sqliteModule.SqliteMeetingStore;
+        SqliteStore.init();
+        storeType = "sqlite";
+        console.error("[Nexus MeetingStore] Using SQLite backend");
+        return { type: "sqlite", store: SqliteStore };
+    }
+    catch (e) {
+        console.error("[Nexus MeetingStore] SQLite unavailable:", e.message);
+        console.error("[Nexus MeetingStore] Falling back to JSON backend");
+        console.warn("[Nexus MeetingStore] ⚠️ JSON mode is single-process only. For multi-IDE environments, install better-sqlite3.");
+        // Fall back to JSON
+        const jsonModule = await import("./meetings.js");
+        JsonStore = jsonModule.MeetingStore;
+        storeType = "json";
+        return { type: "json", store: JsonStore };
+    }
+}
+/**
+ * Unified Meeting Store Interface
+ */
+export const UnifiedMeetingStore = {
+    /**
+     * Start a new meeting
+     */
+    async startMeeting(topic, initiator) {
+        const { store } = await getStore();
+        return store.startMeeting(topic, initiator);
+    },
+    /**
+     * Get a meeting by ID
+     */
+    async getMeeting(id) {
+        const { store } = await getStore();
+        return store.getMeeting(id);
+    },
+    /**
+     * Add a message to a meeting
+     */
+    async addMessage(meetingId, message) {
+        const { store } = await getStore();
+        return store.addMessage(meetingId, message);
+    },
+    /**
+     * End a meeting
+     */
+    async endMeeting(meetingId, summary) {
+        const { store } = await getStore();
+        return store.endMeeting(meetingId, summary);
+    },
+    /**
+     * Archive a meeting
+     */
+    async archiveMeeting(meetingId) {
+        const { store } = await getStore();
+        return store.archiveMeeting(meetingId);
+    },
+    /**
+     * List meetings
+     */
+    async listMeetings(status) {
+        const { store } = await getStore();
+        return store.listMeetings(status);
+    },
+    /**
+     * Get the current active meeting
+     */
+    async getActiveMeeting() {
+        const { store } = await getStore();
+        return store.getActiveMeeting();
+    },
+    /**
+     * Get recent messages
+     */
+    async getRecentMessages(count, meetingId) {
+        const { store } = await getStore();
+        return store.getRecentMessages(count || 10, meetingId);
+    },
+    /**
+     * Get the current backend type
+     */
+    async getBackendType() {
+        const { type } = await getStore();
+        return type;
+    },
+    /**
+     * Get meeting state (SQLite only, returns empty for JSON)
+     */
+    async getState() {
+        const { type, store } = await getStore();
+        if (type === "sqlite") {
+            const sqliteStore = store;
+            const activeMeetings = JSON.parse(sqliteStore.getState("active_meetings") || "[]");
+            const defaultMeetingId = sqliteStore.getState("default_meeting") || null;
+            return { activeMeetings, defaultMeetingId };
+        }
+        else {
+            // JSON backend
+            const jsonStore = store;
+            const state = await jsonStore.getState();
+            return state;
+        }
+    },
+    /**
+     * Get storage info for status display
+     * @returns storage_mode and is_degraded flag
+     */
+    async getStorageInfo() {
+        const { type } = await getStore();
+        return {
+            storage_mode: type,
+            is_degraded: type === "json" // JSON mode is considered degraded
+        };
+    }
+};

package/build/tools/definitions.js

@@ -78,7 +78,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "upload_project_asset",
-        description: "Upload a file. Both fileName and base64Content are MANDATORY.",
+        description: "Upload a binary file (images, PDFs, etc.) to the current project's asset folder. Requires active session (call register_session_context first). Returns the relative path of the saved file.",
         inputSchema: {
             type: "object",
             properties: {
@@ -90,7 +90,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "get_global_topology",
-        description: "Retrieve complete project relationship graph. Use this to understand current IDs and their connections.",
+        description: "Retrieve complete project relationship graph. Returns { nodes: [{ id, name }], edges: [{ from, to, type }] }. Use this to visualize dependencies.",
         inputSchema: { type: "object", properties: {} }
     },
     {
@@ -116,7 +116,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "post_global_discussion",
-        description: "Join the 'Nexus Meeting Room' to collaborate with other AI agents. Use this for initiating meetings, making cross-project proposals, or announcing key decisions. Every message is shared across all assistants in real-time.",
+        description: "Post a message to the Nexus collaboration space. If an active meeting exists, the message is automatically routed to that meeting. Otherwise, it goes to the global discussion log. Use this for proposals, decisions, or general coordination.",
         inputSchema: {
             type: "object",
             properties: {
@@ -124,7 +124,7 @@ export const TOOL_DEFINITIONS = [
                 category: {
                     type: "string",
                     enum: ["MEETING_START", "PROPOSAL", "DECISION", "UPDATE", "CHAT"],
-                    description: "The nature of this message. Use MEETING_START to call for a synchronous discussion."
+                    description: "The nature of this message. DECISION messages are auto-extracted into meeting decisions[]."
                 }
             },
             required: ["message"]
@@ -132,11 +132,12 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "read_recent_discussion",
-        description: "Quickly 'listen' to the last few messages in the Nexus Room to catch up on the context of the current meeting or collaboration.",
+        description: "Read recent messages. Automatically reads from the active meeting if one exists, otherwise reads from global discussion log.",
         inputSchema: {
             type: "object",
             properties: {
-                count: { type: "number", description: "Number of recent messages to retrieve (defaults to 10).", default: 10 }
+                count: { type: "number", description: "Number of recent messages to retrieve (defaults to 10).", default: 10 },
+                meetingId: { type: "string", description: "Optional: Read from a specific meeting instead of the active one." }
             }
         }
     },
@@ -204,7 +205,7 @@ export const TOOL_DEFINITIONS = [
     },
     {
         name: "moderator_maintenance",
-        description: "[ADMIN ONLY] Prune or clear logs. Both action and count are MANDATORY.",
+        description: "[ADMIN ONLY] Manage global discussion logs. 'prune' removes the oldest N entries (keeps newest). 'clear' wipes all logs (use count=0). Returns summary of removed entries. Irreversible.",
         inputSchema: {
             type: "object",
             properties: {
@@ -215,8 +216,8 @@ export const TOOL_DEFINITIONS = [
         }
     },
     {
-        name: "delete_project",
-        description: "[ADMIN ONLY] Completely remove a project, its manifest, and all its assets from Nexus.",
+        name: "moderator_delete_project",
+        description: "[ADMIN ONLY] Completely remove a project, its manifest, and all its assets from Nexus Hub. Irreversible.",
         inputSchema: {
             type: "object",
             properties: {
@@ -224,5 +225,64 @@ export const TOOL_DEFINITIONS = [
             },
             required: ["projectId"]
         }
+    },
+    // --- Meeting Management Tools (Phase 1) ---
+    {
+        name: "start_meeting",
+        description: "Start a new meeting session. Creates a dedicated file for the meeting. Returns the meeting ID and details.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: { type: "string", description: "The topic/agenda for this meeting (e.g., 'Architecture Review', 'Sprint Planning')." }
+            },
+            required: ["topic"]
+        }
+    },
+    {
+        name: "end_meeting",
+        description: "End an active meeting. Locks the session for further messages. Returns suggested sync targets based on participants.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                meetingId: { type: "string", description: "The ID of the meeting to end. If omitted, ends the current active meeting." },
+                summary: { type: "string", description: "Optional summary of the meeting conclusions." }
+            }
+        }
+    },
+    {
+        name: "list_meetings",
+        description: "List all meetings with optional status filter. Returns meeting metadata without full message history.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                status: {
+                    type: "string",
+                    enum: ["active", "closed", "archived"],
+                    description: "Filter by meeting status. Omit to list all."
+                }
+            }
+        }
+    },
+    {
+        name: "read_meeting",
+        description: "Read the full content of a specific meeting including all messages and decisions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                meetingId: { type: "string", description: "The ID of the meeting to read." }
+            },
+            required: ["meetingId"]
+        }
+    },
+    {
+        name: "archive_meeting",
+        description: "Archive a closed meeting. Archived meetings are read-only and excluded from active queries.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                meetingId: { type: "string", description: "The ID of the closed meeting to archive." }
+            },
+            required: ["meetingId"]
+        }
     }
 ];