n2n-nexus 0.4.2 → 0.6.0

package/build/storage/logs.js

@@ -1,60 +0,0 @@
-import { promises as fs } from "node:fs";
-import { NexusPaths } from "./paths.js";
-export class LogStorage {
-    static async ensureLogFile() {
-        try {
-            await fs.access(NexusPaths.globalDiscussion);
-        }
-        catch {
-            await fs.writeFile(NexusPaths.globalDiscussion, "[]", "utf-8");
-        }
-    }
-    static async addLog(from, text, category) {
-        await this.ensureLogFile();
-        const logs = await this.getLogs();
-        const payload = {
-            timestamp: new Date().toISOString(),
-            from,
-            text,
-            category: this.normalizeCategory(category)
-        };
-        logs.push(payload);
-        await fs.writeFile(NexusPaths.globalDiscussion, JSON.stringify(logs, null, 2), "utf-8");
-    }
-    static normalizeCategory(category) {
-        if (!category)
-            return undefined;
-        const allowed = ["MEETING_START", "PROPOSAL", "DECISION", "UPDATE", "CHAT", "message", "SYSTEM"];
-        return allowed.includes(category) ? category : "UPDATE";
-    }
-    static async getLogs(limit = 10) {
-        await this.ensureLogFile();
-        const rows = await this.readRawLogs();
-        if (limit <= 0)
-            return rows;
-        return rows.slice(-limit);
-    }
-    static async pruneLogs(count) {
-        const current = await this.readRawLogs();
-        if (count <= 0)
-            return;
-        if (current.length <= count)
-            return;
-        const remaining = current.slice(count);
-        await fs.writeFile(NexusPaths.globalDiscussion, JSON.stringify(remaining, null, 2), "utf-8");
-    }
-    static async clearLogs() {
-        await fs.writeFile(NexusPaths.globalDiscussion, "[]", "utf-8");
-    }
-    static async readRawLogs() {
-        await this.ensureLogFile();
-        try {
-            const raw = await fs.readFile(NexusPaths.globalDiscussion, "utf-8");
-            const parsed = JSON.parse(raw);
-            return Array.isArray(parsed) ? parsed : [];
-        }
-        catch {
-            return [];
-        }
-    }
-}

package/build/storage/meetings.js

@@ -1,276 +0,0 @@
-import { promises as fs } from "fs";
-import path from "path";
-import { NexusPaths } from "./paths.js";
-import { AsyncMutex } from "../utils/async-mutex.js";
-import { FILE_ENCODING } from "../constants.js";
-/**
- * MeetingStore - Handles all meeting-related storage operations
- */
-export class MeetingStore {
-    static meetingLock = new AsyncMutex();
-    static stateLock = new AsyncMutex();
-    // --- Path Definitions ---
-    static get meetingsDir() { return path.join(NexusPaths.root, "meetings"); }
-    static get stateFile() { return path.join(NexusPaths.root, "global", "meeting_state.json"); }
-    /**
-     * Initialize meeting storage directories
-     */
-    static async init() {
-        await fs.mkdir(this.meetingsDir, { recursive: true });
-        await this.loadStateSafe();
-    }
-    /**
-     * Check if a path exists
-     */
-    static async exists(p) {
-        try {
-            await fs.access(p);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * Load meeting state with self-healing
-     */
-    static async loadStateSafe() {
-        const defaultState = { activeMeetings: [], defaultMeetingId: null };
-        try {
-            if (!await this.exists(this.stateFile)) {
-                await fs.writeFile(this.stateFile, JSON.stringify(defaultState, null, 2), FILE_ENCODING);
-                return defaultState;
-            }
-            const content = await fs.readFile(this.stateFile, FILE_ENCODING);
-            const cleanContent = content.replace(/^\uFEFF/, '').trim();
-            if (!cleanContent)
-                throw new Error("Empty file");
-            return JSON.parse(cleanContent);
-        }
-        catch (e) {
-            console.warn(`[MeetingStore] Repairing corrupted state file. Error: ${e.message}`);
-            await fs.writeFile(this.stateFile, JSON.stringify(defaultState, null, 2), FILE_ENCODING);
-            return defaultState;
-        }
-    }
-    /**
-     * Get current meeting state
-     */
-    static async getState() {
-        return this.loadStateSafe();
-    }
-    /**
-     * Save meeting state
-     */
-    static async saveState(state) {
-        await fs.writeFile(this.stateFile, JSON.stringify(state, null, 2), FILE_ENCODING);
-    }
-    /**
-     * 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}`;
-    }
-    /**
-     * Get the file path for a meeting
-     */
-    static getMeetingPath(id) {
-        return path.join(this.meetingsDir, `${id}.json`);
-    }
-    /**
-     * Start a new meeting
-     */
-    static async startMeeting(topic, initiator) {
-        await this.init();
-        return this.stateLock.withLock(async () => {
-            const id = this.generateMeetingId(topic);
-            const meeting = {
-                id,
-                topic,
-                status: "active",
-                startTime: new Date().toISOString(),
-                initiator,
-                participants: [initiator],
-                messages: [],
-                decisions: []
-            };
-            // Save meeting file
-            await fs.writeFile(this.getMeetingPath(id), JSON.stringify(meeting, null, 2), FILE_ENCODING);
-            // Update state
-            const state = await this.loadStateSafe();
-            state.activeMeetings.push(id);
-            state.defaultMeetingId = id;
-            await this.saveState(state);
-            return meeting;
-        });
-    }
-    /**
-     * Get a meeting by ID
-     */
-    static async getMeeting(id) {
-        const meetingPath = this.getMeetingPath(id);
-        if (!await this.exists(meetingPath))
-            return null;
-        const content = await fs.readFile(meetingPath, FILE_ENCODING);
-        return JSON.parse(content);
-    }
-    /**
-     * Add a message to a meeting
-     */
-    static async addMessage(meetingId, message) {
-        await this.meetingLock.withLock(async () => {
-            const meeting = await this.getMeeting(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.`);
-            // Add message
-            meeting.messages.push(message);
-            // Track participant
-            if (!meeting.participants.includes(message.from)) {
-                meeting.participants.push(message.from);
-            }
-            // Extract decisions
-            if (message.category === "DECISION") {
-                meeting.decisions.push(message.text);
-            }
-            await fs.writeFile(this.getMeetingPath(meetingId), JSON.stringify(meeting, null, 2), FILE_ENCODING);
-        });
-    }
-    /**
-     * End a meeting (close it)
-     */
-    static async endMeeting(meetingId, summary, callerId) {
-        return this.stateLock.withLock(async () => {
-            const meeting = await 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}.`);
-            // Permission check: Only initiator can end
-            if (callerId && meeting.initiator && meeting.initiator !== callerId) {
-                throw new Error(`Permission denied: Only initiator (${meeting.initiator}) can end this meeting.`);
-            }
-            // Close the meeting
-            meeting.status = "closed";
-            meeting.endTime = new Date().toISOString();
-            if (summary)
-                meeting.summary = summary;
-            await fs.writeFile(this.getMeetingPath(meetingId), JSON.stringify(meeting, null, 2), FILE_ENCODING);
-            // Update state - remove from active meetings
-            const state = await this.loadStateSafe();
-            state.activeMeetings = state.activeMeetings.filter(id => id !== meetingId);
-            state.defaultMeetingId = state.activeMeetings.length > 0
-                ? state.activeMeetings[state.activeMeetings.length - 1]
-                : null;
-            await this.saveState(state);
-            // Suggest sync targets based on participants (extract project IDs)
-            const suggestedSyncTargets = meeting.participants
-                .map(p => p.split('@')[1])
-                .filter((v, i, a) => v && v !== "Global" && a.indexOf(v) === i);
-            return { meeting, suggestedSyncTargets };
-        });
-    }
-    /**
-     * Archive a closed meeting
-     */
-    static async archiveMeeting(meetingId, callerId) {
-        const meeting = await 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.`);
-        // Permission check: Only initiator can archive
-        if (callerId && meeting.initiator && meeting.initiator !== callerId) {
-            throw new Error(`Permission denied: Only initiator (${meeting.initiator}) can archive this meeting.`);
-        }
-        meeting.status = "archived";
-        await fs.writeFile(this.getMeetingPath(meetingId), JSON.stringify(meeting, null, 2), FILE_ENCODING);
-    }
-    /**
-     * Reopen a closed or archived meeting
-     */
-    static async reopenMeeting(meetingId, _callerId) {
-        return this.stateLock.withLock(async () => {
-            const meeting = await this.getMeeting(meetingId);
-            if (!meeting)
-                throw new Error(`Meeting '${meetingId}' not found.`);
-            if (meeting.status === "active")
-                throw new Error(`Meeting '${meetingId}' is already active.`);
-            // Update status to active
-            meeting.status = "active";
-            meeting.endTime = undefined;
-            await fs.writeFile(this.getMeetingPath(meetingId), JSON.stringify(meeting, null, 2), FILE_ENCODING);
-            // Update state
-            const state = await this.loadStateSafe();
-            if (!state.activeMeetings.includes(meetingId)) {
-                state.activeMeetings.push(meetingId);
-            }
-            state.defaultMeetingId = meetingId;
-            await this.saveState(state);
-            return meeting;
-        });
-    }
-    /**
-     * List all meetings with optional status filter
-     */
-    static async listMeetings(status) {
-        await this.init();
-        const files = await fs.readdir(this.meetingsDir);
-        const meetings = [];
-        for (const file of files) {
-            if (!file.endsWith('.json'))
-                continue;
-            const id = file.replace('.json', '');
-            const meeting = await this.getMeeting(id);
-            if (!meeting)
-                continue;
-            if (status && meeting.status !== status)
-                continue;
-            meetings.push({
-                id: meeting.id,
-                topic: meeting.topic,
-                status: meeting.status,
-                startTime: meeting.startTime,
-                participantCount: meeting.participants.length
-            });
-        }
-        // Sort by startTime descending
-        return meetings.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
-    }
-    /**
-     * Get the current active meeting (for auto-routing)
-     */
-    static async getActiveMeeting() {
-        const state = await this.getState();
-        if (!state.defaultMeetingId)
-            return null;
-        return this.getMeeting(state.defaultMeetingId);
-    }
-    /**
-     * Get recent messages from the active meeting
-     */
-    static async getRecentMessages(count = 10, meetingId) {
-        const targetId = meetingId || (await this.getState()).defaultMeetingId;
-        if (!targetId)
-            return [];
-        const meeting = await this.getMeeting(targetId);
-        if (!meeting)
-            return [];
-        return meeting.messages.slice(-count);
-    }
-}

package/build/storage/store.js

@@ -1,153 +0,0 @@
-/**
- * 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
-        };
-    }
-};