n2n-nexus 0.4.2

package/build/storage/sqlite.js

@@ -0,0 +1,141 @@
+import Database from "better-sqlite3";
+import { createRequire } from "module";
+import { NexusPaths } from "./paths.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',
+    initiator TEXT,
+    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);
+
+-- Read cursors table (tracks each IDE's last read message per context)
+CREATE TABLE IF NOT EXISTS read_cursors (
+    instance_id TEXT NOT NULL,
+    context_type TEXT NOT NULL CHECK(context_type IN ('meeting', 'global')),
+    context_id TEXT,
+    last_read_id INTEGER DEFAULT 0,
+    updated_at TEXT,
+    PRIMARY KEY (instance_id, context_type, context_id)
+);
+`;
+/**
+ * Get the database file path
+ */
+export function getDbPath() {
+    return NexusPaths.dbFile;
+}
+/**
+ * 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);
+    // Migration: Add initiator column if it doesn't exist (Upgrade from v0.1.7)
+    try {
+        const columns = db.prepare("PRAGMA table_info(meetings)").all();
+        const hasInitiator = columns.some(c => c.name === "initiator");
+        if (!hasInitiator) {
+            console.error("[Nexus] Migrating database: Adding 'initiator' column to 'meetings' table.");
+            db.exec("ALTER TABLE meetings ADD COLUMN initiator TEXT");
+        }
+    }
+    catch (e) {
+        console.error("[Nexus] Migration check failed:", e);
+    }
+    // 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");
+    }
+}
+export function isSqliteAvailable() {
+    const require = createRequire(import.meta.url);
+    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,153 @@
+/**
+ * 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, callerId) {
+        const { store } = await getStore();
+        return store.endMeeting(meetingId, summary, callerId);
+    },
+    /**
+     * Archive a meeting
+     */
+    async archiveMeeting(meetingId, callerId) {
+        const { store } = await getStore();
+        return store.archiveMeeting(meetingId, callerId);
+    },
+    /**
+     * Reopen a meeting
+     */
+    async reopenMeeting(meetingId, callerId) {
+        const { store } = await getStore();
+        return store.reopenMeeting(meetingId, callerId);
+    },
+    /**
+     * 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 (incremental for SQLite with instanceId)
+     */
+    async getRecentMessages(count, meetingId, instanceId) {
+        const { type, store } = await getStore();
+        if (type === "sqlite") {
+            // SQLite supports incremental reads with cursor tracking
+            return store.getRecentMessages(count || 10, meetingId, instanceId);
+        }
+        else {
+            // JSON fallback - no incremental support
+            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/storage/tasks.js

@@ -0,0 +1,212 @@
+/**
+ * TaskService - Phase 2: Async Task Management
+ *
+ * Manages long-running operations with progress tracking,
+ * meeting traceability, and MCP-compatible status reporting.
+ */
+import { getDatabase } from "./sqlite.js";
+import { TASK_CLEANUP_MAX_AGE_MS } from "../constants.js";
+// Generate unique task ID
+function generateTaskId() {
+    const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+    const random = Math.random().toString(36).substring(2, 6);
+    return `task_${timestamp}_${random}`;
+}
+let initialized = false;
+/**
+ * Initialize the tasks table (run migrations)
+ */
+export function initTasksTable() {
+    if (initialized)
+        return;
+    const db = getDatabase();
+    const TASKS_SCHEMA = `
+    CREATE TABLE IF NOT EXISTS tasks (
+        id TEXT PRIMARY KEY,
+        status TEXT NOT NULL CHECK(status IN ('pending', 'running', 'completed', 'failed', 'cancelled')) DEFAULT 'pending',
+        progress REAL DEFAULT 0.0 CHECK(progress >= 0.0 AND progress <= 1.0),
+        source_meeting_id TEXT,
+        metadata TEXT,
+        result_uri TEXT,
+        error_message TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now')),
+        updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+        ttl INTEGER,
+        FOREIGN KEY (source_meeting_id) REFERENCES meetings(id) ON DELETE SET NULL
+    );
+    
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_tasks_meeting ON tasks(source_meeting_id);
+    `;
+    db.exec(TASKS_SCHEMA);
+    // Add trigger for auto-updating updated_at (separate exec to handle IF NOT EXISTS)
+    try {
+        db.exec(`
+            CREATE TRIGGER IF NOT EXISTS tasks_updated_at
+            AFTER UPDATE ON tasks
+            FOR EACH ROW
+            BEGIN
+                UPDATE tasks SET updated_at = datetime('now') WHERE id = OLD.id;
+            END;
+        `);
+    }
+    catch {
+        // Trigger may already exist in older SQLite versions without IF NOT EXISTS support
+    }
+    console.error("[Nexus] Tasks table initialized");
+    initialized = true;
+}
+export function resetTasksInit() {
+    initialized = false;
+}
+/**
+ * Create a new task
+ */
+export function createTask(input = {}) {
+    const db = getDatabase();
+    const id = input.id || generateTaskId();
+    const now = new Date().toISOString();
+    const stmt = db.prepare(`
+        INSERT INTO tasks (id, status, progress, source_meeting_id, metadata, created_at, updated_at, ttl)
+        VALUES (?, 'pending', 0.0, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(id, input.source_meeting_id || null, input.metadata ? JSON.stringify(input.metadata) : null, now, now, input.ttl || null);
+    return getTask(id);
+}
+/**
+ * Get a task by ID
+ */
+export function getTask(id) {
+    const db = getDatabase();
+    const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        status: row.status,
+        progress: row.progress,
+        source_meeting_id: row.source_meeting_id || null,
+        metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        result_uri: row.result_uri || null,
+        error_message: row.error_message || null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ttl: row.ttl || null
+    };
+}
+/**
+ * Update task status and progress
+ */
+export function updateTask(id, update) {
+    const db = getDatabase();
+    const now = new Date().toISOString();
+    const sets = ["updated_at = ?"];
+    const values = [now];
+    if (update.status !== undefined) {
+        sets.push("status = ?");
+        values.push(update.status);
+    }
+    if (update.progress !== undefined) {
+        sets.push("progress = ?");
+        values.push(Math.max(0, Math.min(1, update.progress)));
+    }
+    if (update.result_uri !== undefined) {
+        sets.push("result_uri = ?");
+        values.push(update.result_uri);
+    }
+    if (update.error_message !== undefined) {
+        sets.push("error_message = ?");
+        values.push(update.error_message);
+    }
+    if (update.metadata !== undefined) {
+        sets.push("metadata = ?");
+        values.push(JSON.stringify(update.metadata));
+    }
+    values.push(id);
+    const sql = `UPDATE tasks SET ${sets.join(", ")} WHERE id = ?`;
+    db.prepare(sql).run(...values);
+    return getTask(id);
+}
+/**
+ * List tasks with optional status filter
+ */
+export function listTasks(status, limit = 50) {
+    const db = getDatabase();
+    let sql = "SELECT * FROM tasks";
+    const params = [];
+    if (status) {
+        sql += " WHERE status = ?";
+        params.push(status);
+    }
+    sql += " ORDER BY created_at DESC LIMIT ?";
+    params.push(limit);
+    const rows = db.prepare(sql).all(...params);
+    return rows.map(row => ({
+        id: row.id,
+        status: row.status,
+        progress: row.progress,
+        source_meeting_id: row.source_meeting_id || null,
+        metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        result_uri: row.result_uri || null,
+        error_message: row.error_message || null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ttl: row.ttl || null
+    }));
+}
+/**
+ * Get tasks by meeting ID
+ */
+export function getTasksByMeeting(meetingId) {
+    const db = getDatabase();
+    const rows = db.prepare(`
+        SELECT * FROM tasks WHERE source_meeting_id = ? ORDER BY created_at DESC
+    `).all(meetingId);
+    return rows.map(row => ({
+        id: row.id,
+        status: row.status,
+        progress: row.progress,
+        source_meeting_id: row.source_meeting_id || null,
+        metadata: row.metadata ? JSON.parse(row.metadata) : {},
+        result_uri: row.result_uri || null,
+        error_message: row.error_message || null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+        ttl: row.ttl || null
+    }));
+}
+/**
+ * Cancel a pending or running task
+ */
+export function cancelTask(id) {
+    const task = getTask(id);
+    if (!task)
+        return false;
+    if (task.status !== "pending" && task.status !== "running")
+        return false;
+    updateTask(id, { status: "cancelled" });
+    return true;
+}
+/**
+ * Delete completed/failed/cancelled tasks older than specified age
+ */
+export function cleanupTasks(maxAgeMs = TASK_CLEANUP_MAX_AGE_MS) {
+    const db = getDatabase();
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const result = db.prepare(`
+        DELETE FROM tasks 
+        WHERE status IN ('completed', 'failed', 'cancelled') 
+        AND updated_at < ?
+    `).run(cutoff);
+    return result.changes;
+}
+/**
+ * Get active (pending/running) task count
+ */
+export function getActiveTaskCount() {
+    const db = getDatabase();
+    const row = db.prepare(`
+        SELECT COUNT(*) as count FROM tasks WHERE status IN ('pending', 'running')
+    `).get();
+    return row.count;
+}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/build/utils/async-mutex.js

@@ -0,0 +1,36 @@
+/**
+ * Simple mutex lock for preventing concurrent file writes.
+ * Ensures that only one write operation can happen at a time.
+ */
+export class AsyncMutex {
+    locked = false;
+    queue = [];
+    async acquire() {
+        if (!this.locked) {
+            this.locked = true;
+            return;
+        }
+        return new Promise((resolve) => {
+            this.queue.push(resolve);
+        });
+    }
+    release() {
+        if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            if (next)
+                next();
+        }
+        else {
+            this.locked = false;
+        }
+    }
+    async withLock(fn) {
+        await this.acquire();
+        try {
+            return await fn();
+        }
+        finally {
+            this.release();
+        }
+    }
+}