n2n-nexus 0.4.2

package/build/storage/projects.js

@@ -0,0 +1,75 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { NexusPaths } from "./paths.js";
+import { FILE_ENCODING } from "../constants.js";
+export class ProjectStorage {
+    static projectFilePath(projectId) {
+        return {
+            docsPath: NexusPaths.projectDocPath(projectId),
+            assetsDir: NexusPaths.projectAssetsDir(projectId),
+            manifestPath: NexusPaths.projectManifestPath(projectId),
+            projectDir: NexusPaths.projectDir(projectId)
+        };
+    }
+    static async getProjectDocs(projectId) {
+        const paths = this.projectFilePath(projectId);
+        try {
+            return await fs.readFile(paths.docsPath, FILE_ENCODING);
+        }
+        catch {
+            return "";
+        }
+    }
+    static async saveProjectDocs(projectId, content) {
+        const paths = this.projectFilePath(projectId);
+        await fs.mkdir(paths.projectDir, { recursive: true });
+        await fs.writeFile(paths.docsPath, content, FILE_ENCODING);
+    }
+    static async saveAsset(projectId, fileName, content) {
+        const safeName = this.sanitizeFileName(fileName);
+        const paths = this.projectFilePath(projectId);
+        await fs.mkdir(paths.assetsDir, { recursive: true });
+        const assetPath = path.join(paths.assetsDir, safeName);
+        await fs.writeFile(assetPath, content, FILE_ENCODING);
+        return path.relative(NexusPaths.root, assetPath);
+    }
+    static async deleteProject(projectId) {
+        const paths = this.projectFilePath(projectId);
+        try {
+            await fs.rm(paths.projectDir, { recursive: true, force: true });
+            return 1;
+        }
+        catch {
+            return 0;
+        }
+    }
+    static async renameProject(oldId, newId) {
+        if (!oldId || !newId || oldId === newId)
+            return 0;
+        const oldPath = this.projectFilePath(oldId);
+        const newPath = this.projectFilePath(newId);
+        try {
+            await fs.access(oldPath.projectDir);
+        }
+        catch {
+            return 0;
+        }
+        await fs.mkdir(path.dirname(newPath.projectDir), { recursive: true });
+        await fs.rename(oldPath.projectDir, newPath.projectDir);
+        try {
+            const manifestRaw = await fs.readFile(newPath.manifestPath, FILE_ENCODING);
+            const manifest = JSON.parse(manifestRaw);
+            manifest.id = newId;
+            await fs.writeFile(newPath.manifestPath, JSON.stringify(manifest, null, 2), FILE_ENCODING);
+        }
+        catch {
+            // Manifest is optional for some flows.
+        }
+        return 1;
+    }
+    static sanitizeFileName(fileName) {
+        return fileName
+            .replace(/[\\/:*?"<>|]/g, "_")
+            .replace(/\.\./g, "_");
+    }
+}

package/build/storage/registry.js

@@ -0,0 +1,230 @@
+import { promises as fs } from "node:fs";
+import { NexusPaths } from "./paths.js";
+const emptyRegistry = { projects: {} };
+async function readRegistry() {
+    try {
+        const raw = await fs.readFile(NexusPaths.registryFile, "utf-8");
+        const parsed = JSON.parse(raw);
+        return sanitizeRegistry(parsed);
+    }
+    catch {
+        return { ...emptyRegistry };
+    }
+}
+function sanitizeRegistry(data) {
+    if (!data || typeof data !== "object")
+        return { ...emptyRegistry };
+    const root = data;
+    if (!root.projects || typeof root.projects !== "object")
+        return { ...emptyRegistry };
+    return {
+        projects: Object.fromEntries(Object.entries(root.projects).map(([id, item]) => {
+            if (!item || typeof item !== "object") {
+                return [id, {
+                        summary: "",
+                        lastActive: new Date().toISOString()
+                    }];
+            }
+            const entry = item;
+            return [id, {
+                    name: typeof entry.name === "string" ? entry.name : undefined,
+                    summary: typeof entry.summary === "string" ? entry.summary : "",
+                    lastActive: typeof entry.lastActive === "string" ? entry.lastActive : new Date().toISOString()
+                }];
+        }))
+    };
+}
+async function writeRegistry(data) {
+    await fs.mkdir(NexusPaths.root, { recursive: true });
+    await fs.writeFile(NexusPaths.registryFile, JSON.stringify(data, null, 2), "utf-8");
+}
+async function readProjectManifest(id) {
+    try {
+        const raw = await fs.readFile(NexusPaths.projectManifestPath(id), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export class RegistryStorage {
+    static async listRegistry() {
+        return readRegistry();
+    }
+    static async saveProjectManifest(manifest) {
+        const projectDir = NexusPaths.projectDir(manifest.id);
+        const manifestPath = NexusPaths.projectManifestPath(manifest.id);
+        const registry = await readRegistry();
+        registry.projects[manifest.id] = {
+            name: manifest.name,
+            summary: manifest.description || "",
+            lastActive: new Date().toISOString()
+        };
+        await writeRegistry(registry);
+        await fs.mkdir(projectDir, { recursive: true });
+        await fs.writeFile(manifestPath, JSON.stringify({ ...manifest, lastUpdated: manifest.lastUpdated || new Date().toISOString() }, null, 2), "utf-8");
+    }
+    static async getProjectManifest(id) {
+        const registry = await readRegistry();
+        const entry = registry.projects[id];
+        if (!entry)
+            return null;
+        const rawManifest = await readProjectManifest(id);
+        return {
+            id,
+            name: entry.name || rawManifest?.name || id,
+            description: entry.summary || rawManifest?.description || "",
+            techStack: rawManifest?.techStack || [],
+            relations: rawManifest?.relations || [],
+            lastUpdated: rawManifest?.lastUpdated || entry.lastActive,
+            repositoryUrl: rawManifest?.repositoryUrl || "",
+            localPath: rawManifest?.localPath || NexusPaths.projectDir(id),
+            endpoints: rawManifest?.endpoints || [],
+            apiSpec: rawManifest?.apiSpec || [],
+            apiDependencies: rawManifest?.apiDependencies,
+            gatewayCompatibility: rawManifest?.gatewayCompatibility,
+            api_versions: rawManifest?.api_versions,
+            feature_tier: rawManifest?.feature_tier
+        };
+    }
+    static async patchProjectManifest(id, patch) {
+        const registry = await readRegistry();
+        const existing = registry.projects[id];
+        if (!existing)
+            throw new Error(`Project '${id}' not found.`);
+        registry.projects[id] = {
+            ...existing,
+            summary: patch.description ?? existing.summary,
+            name: patch.name ?? existing.name,
+            lastActive: new Date().toISOString()
+        };
+        await writeRegistry(registry);
+        const manifest = await readProjectManifest(id) || {};
+        const patchedManifest = {
+            id,
+            name: patch.name ?? manifest.name ?? existing.name ?? "",
+            description: patch.description ?? manifest.description ?? "",
+            techStack: patch.techStack ?? manifest.techStack ?? [],
+            relations: patch.relations ?? manifest.relations ?? [],
+            lastUpdated: new Date().toISOString(),
+            repositoryUrl: patch.repositoryUrl ?? manifest.repositoryUrl ?? "",
+            localPath: patch.localPath ?? manifest.localPath ?? NexusPaths.projectDir(id),
+            endpoints: patch.endpoints ?? manifest.endpoints ?? [],
+            apiSpec: patch.apiSpec ?? manifest.apiSpec ?? [],
+            apiDependencies: patch.apiDependencies ?? manifest.apiDependencies,
+            gatewayCompatibility: patch.gatewayCompatibility ?? manifest.gatewayCompatibility,
+            api_versions: patch.api_versions ?? manifest.api_versions,
+            feature_tier: patch.feature_tier ?? manifest.feature_tier
+        };
+        await fs.writeFile(NexusPaths.projectManifestPath(id), JSON.stringify(patchedManifest, null, 2), "utf-8");
+    }
+    static async calculateTopology(projectId) {
+        const registry = await readRegistry();
+        const projectRecords = await Promise.all(Object.entries(registry.projects).map(async ([id, project]) => {
+            const manifest = await readProjectManifest(id);
+            return {
+                id,
+                name: manifest?.name || project.name || id,
+                summary: project.summary,
+                lastActive: project.lastActive,
+                relations: manifest?.relations || []
+            };
+        }));
+        const nodeMap = new Map(projectRecords.map((record) => [record.id, record]));
+        const edges = projectRecords.flatMap((project) => {
+            return project.relations
+                .filter(relation => nodeMap.has(relation.targetId))
+                .map((relation) => ({
+                from: project.id,
+                to: relation.targetId,
+                type: relation.type
+            }));
+        });
+        const allProjects = projectRecords.map((project) => ({
+            id: project.id,
+            name: project.name,
+            summary: project.summary,
+            lastActive: project.lastActive
+        }));
+        if (!projectId) {
+            return {
+                mode: "list",
+                summary: {
+                    totalProjects: allProjects.length,
+                    totalEdges: edges.length
+                },
+                projects: Object.fromEntries(allProjects.map((project) => [project.id, project]))
+            };
+        }
+        if (!nodeMap.has(projectId)) {
+            return {
+                mode: "focused",
+                nodes: [],
+                edges: []
+            };
+        }
+        const visited = new Set();
+        const queue = [projectId];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || visited.has(current)) {
+                continue;
+            }
+            visited.add(current);
+            for (const edge of edges) {
+                if (edge.from === current && !visited.has(edge.to)) {
+                    queue.push(edge.to);
+                }
+            }
+        }
+        return {
+            mode: "focused",
+            nodes: allProjects.filter((project) => visited.has(project.id)),
+            edges: edges.filter((edge) => visited.has(edge.from) && visited.has(edge.to))
+        };
+    }
+    static async deleteProject(projectId) {
+        const registry = await readRegistry();
+        if (!registry.projects[projectId])
+            return 0;
+        delete registry.projects[projectId];
+        await writeRegistry(registry);
+        return 1;
+    }
+    static async renameProject(oldId, newId) {
+        const registry = await readRegistry();
+        if (!registry.projects[oldId])
+            return 0;
+        if (registry.projects[newId]) {
+            throw new Error(`Project '${newId}' already exists.`);
+        }
+        const entry = registry.projects[oldId];
+        delete registry.projects[oldId];
+        registry.projects[newId] = entry;
+        await writeRegistry(registry);
+        for (const projectId of Object.keys(registry.projects)) {
+            const manifestId = projectId === newId ? oldId : projectId;
+            const manifest = await readProjectManifest(manifestId);
+            if (!manifest)
+                continue;
+            let changed = false;
+            if (projectId === newId && manifest.id !== newId) {
+                manifest.id = newId;
+                changed = true;
+            }
+            if (Array.isArray(manifest.relations)) {
+                const relations = manifest.relations.map((relation) => {
+                    if (relation.targetId !== oldId)
+                        return relation;
+                    changed = true;
+                    return { ...relation, targetId: newId };
+                });
+                manifest.relations = relations;
+            }
+            if (changed) {
+                await fs.writeFile(NexusPaths.projectManifestPath(manifestId), JSON.stringify(manifest, null, 2), "utf-8");
+            }
+        }
+        return 1;
+    }
+}

package/build/storage/sqlite-meeting.js

@@ -0,0 +1,311 @@
+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, initiator, participants, created_at)
+            VALUES (?, ?, 'active', ?, ?, ?)
+        `);
+        stmt.run(id, topic, initiator, 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,
+            initiator,
+            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,
+            initiator: meeting.initiator || "Unknown",
+            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, callerId) {
+        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}.`);
+        // 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.`);
+        }
+        // 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, callerId) {
+        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.`);
+        // 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.`);
+        }
+        const stmt = db.prepare("UPDATE meetings SET status = 'archived' WHERE id = ?");
+        stmt.run(meetingId);
+    }
+    /**
+     * Reopen a closed or archived meeting
+     */
+    static reopenMeeting(meetingId, _callerId) {
+        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 already active.`);
+        // Update status to active
+        const stmt = db.prepare("UPDATE meetings SET status = 'active', closed_at = NULL WHERE id = ?");
+        stmt.run(meetingId);
+        // Update state
+        const activeMeetings = this.getActiveMeetingIds();
+        if (!activeMeetings.includes(meetingId)) {
+            activeMeetings.push(meetingId);
+            this.updateState("active_meetings", JSON.stringify(activeMeetings));
+        }
+        this.updateState("default_meeting", meetingId);
+        return this.getMeeting(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 (incremental read based on instance cursor)
+     * Automatically returns only unread messages for the current instance.
+     */
+    static getRecentMessages(count = 10, meetingId, instanceId) {
+        const db = getDatabase();
+        const targetId = meetingId || this.getState("default_meeting");
+        if (!targetId)
+            return [];
+        // If no instanceId provided, fall back to returning all recent messages
+        if (!instanceId) {
+            const stmt = db.prepare(`
+                SELECT id, sender as "from", text, category, timestamp
+                FROM messages WHERE meeting_id = ?
+                ORDER BY id DESC LIMIT ?
+            `);
+            const messages = stmt.all(targetId, count);
+            return messages.reverse();
+        }
+        // Get cursor for this instance + meeting
+        const cursorStmt = db.prepare(`
+            SELECT last_read_id FROM read_cursors 
+            WHERE instance_id = ? AND context_type = 'meeting' AND context_id = ?
+        `);
+        const cursorRow = cursorStmt.get(instanceId, targetId);
+        const lastReadId = cursorRow?.last_read_id || 0;
+        // Fetch unread messages (id > lastReadId)
+        const stmt = db.prepare(`
+            SELECT id, sender as "from", text, category, timestamp
+            FROM messages 
+            WHERE meeting_id = ? AND id > ?
+            ORDER BY id ASC
+            LIMIT ?
+        `);
+        const messages = stmt.all(targetId, lastReadId, count);
+        // Update cursor if we got messages
+        if (messages.length > 0) {
+            const maxId = messages[messages.length - 1].id;
+            const now = new Date().toISOString();
+            const updateStmt = db.prepare(`
+                INSERT OR REPLACE INTO read_cursors (instance_id, context_type, context_id, last_read_id, updated_at)
+                VALUES (?, 'meeting', ?, ?, ?)
+            `);
+            updateStmt.run(instanceId, targetId, maxId, now);
+        }
+        return messages;
+    }
+    /**
+     * 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 [];
+        }
+    }
+}