n2n-nexus 0.4.2

package/build/index.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { pkg } from "./config/index.js";
+const command = process.argv[2] || "mcp";
+if (command === "--version" || command === "-v") {
+    process.stdout.write(pkg.version + "\n");
+    process.exit(0);
+}
+if (command === "--help" || command === "-h") {
+    process.stdout.write(`
+n2n-nexus v${pkg.version} — Multi-AI assistant coordination hub
+
+USAGE:
+  n2n-nexus daemon   Start the Nexus server (run once, stays alive)
+  n2n-nexus mcp      Start the MCP proxy (launched by IDE automatically)
+
+OPTIONS:
+  --root <path>      Storage directory for daemon (default: ~/.n2n-nexus)
+  --port <port>      HTTP port for daemon (default: 5688)
+  --host <host>      Host address for daemon (default: 127.0.0.1)
+  --id <id>          Instance ID for MCP proxy
+  --version, -v      Show version
+  --help, -h         Show this help
+
+ENVIRONMENT:
+  NEXUS_ROOT         Override --root
+  NEXUS_DAEMON_PORT  Override --port
+  NEXUS_HOST         Override --host
+  NEXUS_ENDPOINT     Daemon URL for MCP proxy (default: http://127.0.0.1:5688)
+  NEXUS_INSTANCE_ID  Override --id for MCP proxy
+`);
+    process.exit(0);
+}
+async function main() {
+    if (command === "daemon") {
+        const { runDaemon } = await import("./daemon/index.js");
+        await runDaemon();
+        return;
+    }
+    // Default: mcp
+    const { NexusServer } = await import("./server/nexus.js");
+    const server = new NexusServer();
+    await server.run();
+}
+main().catch(err => {
+    console.error("[n2n-nexus] Fatal error:", err);
+    process.exit(1);
+});

package/build/server/nexus.js

@@ -0,0 +1,98 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { NexusClient } from "../client/nexus-client.js";
+import { pkg } from "../config/index.js";
+const RETRY_INTERVAL_MS = 3000;
+const SERVICE_NAME = "n2n-nexus";
+export class NexusServer {
+    server;
+    client;
+    instanceId;
+    cachedTools = [];
+    retryTimer = null;
+    connected = false;
+    constructor() {
+        const endpoint = process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
+        const instanceId = process.env.NEXUS_INSTANCE_ID ||
+            process.argv.find((_, i) => process.argv[i - 1] === "--id") ||
+            `mcp-${Math.random().toString(36).slice(2, 6)}`;
+        this.instanceId = instanceId;
+        this.client = new NexusClient({ endpoint, timeoutMs: 5000 });
+        this.server = new Server({ name: SERVICE_NAME, version: pkg.version }, { capabilities: { tools: { listChanged: true } } });
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: this.cachedTools
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            if (!this.connected) {
+                return {
+                    content: [{ type: "text", text: "Daemon is not ready yet. Please wait a moment and retry." }],
+                    isError: true
+                };
+            }
+            try {
+                const result = await this.client.callTool(request.params.name, request.params.arguments, this.instanceId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: typeof result === "string" ? result : JSON.stringify(result, null, 2)
+                        }]
+                };
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                // Daemon went away — start retry loop
+                if (this.connected) {
+                    this.connected = false;
+                    this.cachedTools = [];
+                    await this.server.sendToolListChanged();
+                    this.scheduleRetry();
+                }
+                return {
+                    content: [{ type: "text", text: `Daemon unavailable: ${message}. Reconnecting...` }],
+                    isError: true
+                };
+            }
+        });
+    }
+    async tryConnect() {
+        try {
+            const tools = await this.client.fetchTools();
+            this.cachedTools = tools;
+            this.connected = true;
+            console.error(`[n2n-nexus] Connected to daemon. ${tools.length} tools loaded.`);
+            await this.server.sendToolListChanged();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    scheduleRetry() {
+        if (this.retryTimer)
+            return;
+        const endpoint = process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
+        this.retryTimer = setInterval(async () => {
+            console.error(`[n2n-nexus] Waiting for daemon at ${endpoint}...`);
+            const ok = await this.tryConnect();
+            if (ok && this.retryTimer) {
+                clearInterval(this.retryTimer);
+                this.retryTimer = null;
+            }
+        }, RETRY_INTERVAL_MS);
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        // Try to connect immediately; if not ready, start retry loop
+        const ok = await this.tryConnect();
+        if (!ok) {
+            const endpoint = process.env.NEXUS_ENDPOINT || "http://127.0.0.1:5688";
+            console.error(`[n2n-nexus] Daemon not available at ${endpoint}. Will retry every ${RETRY_INTERVAL_MS / 1000}s...`);
+            this.scheduleRetry();
+        }
+    }
+}

package/build/storage/docs.js

@@ -0,0 +1,74 @@
+import { promises as fs } from "node:fs";
+import { NexusPaths } from "./paths.js";
+import { FILE_ENCODING } from "../constants.js";
+export class DocStorage {
+    static async ensureDirectory() {
+        await fs.mkdir(NexusPaths.docsDir(), { recursive: true });
+        try {
+            await fs.access(NexusPaths.docsIndexFile);
+        }
+        catch {
+            await fs.writeFile(NexusPaths.docsIndexFile, JSON.stringify({}, null, 2), FILE_ENCODING);
+        }
+    }
+    static async readIndex() {
+        await this.ensureDirectory();
+        try {
+            const raw = await fs.readFile(NexusPaths.docsIndexFile, FILE_ENCODING);
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object")
+                return parsed;
+        }
+        catch {
+            // fall through
+        }
+        return {};
+    }
+    static async writeIndex(index) {
+        await this.ensureDirectory();
+        await fs.writeFile(NexusPaths.docsIndexFile, JSON.stringify(index, null, 2), FILE_ENCODING);
+    }
+    static async init() {
+        await this.ensureDirectory();
+        try {
+            await fs.access(NexusPaths.globalBlueprint);
+        }
+        catch {
+            await fs.writeFile(NexusPaths.globalBlueprint, "# Global Collaboration Blueprint\n\nShared meeting space.", FILE_ENCODING);
+        }
+    }
+    static async listDocs() {
+        await this.ensureDirectory();
+        return this.readIndex();
+    }
+    static async getDoc(docId) {
+        await this.ensureDirectory();
+        const filePath = NexusPaths.docFile(docId);
+        try {
+            return await fs.readFile(filePath, FILE_ENCODING);
+        }
+        catch {
+            return "";
+        }
+    }
+    static async saveDoc(docId, title, content, updatedBy) {
+        await this.ensureDirectory();
+        const index = await this.readIndex();
+        const filePath = NexusPaths.docFile(docId);
+        await fs.writeFile(filePath, content, FILE_ENCODING);
+        index[docId] = {
+            title,
+            lastUpdated: new Date().toISOString(),
+            updatedBy
+        };
+        await this.writeIndex(index);
+    }
+    static async deleteDoc(docId) {
+        await this.ensureDirectory();
+        const index = await this.readIndex();
+        const filePath = NexusPaths.docFile(docId);
+        delete index[docId];
+        await this.writeIndex(index);
+        await fs.rm(filePath, { force: true });
+    }
+}

package/build/storage/index.js

@@ -0,0 +1,105 @@
+import { promises as fs } from "fs";
+import { FILE_ENCODING } from "../constants.js";
+import { NexusPaths } from "./paths.js";
+import { RegistryStorage } from "./registry.js";
+import { ProjectStorage } from "./projects.js";
+import { LogStorage } from "./logs.js";
+import { DocStorage } from "./docs.js";
+export class StorageManager {
+    static initialized = false;
+    // --- Path Proxies (Backward Compatibility) ---
+    static get globalDir() { return NexusPaths.globalDir; }
+    static get globalBlueprint() { return NexusPaths.globalBlueprint; }
+    static get globalDiscussion() { return NexusPaths.globalDiscussion; }
+    static get projectsRoot() { return NexusPaths.projectsRoot; }
+    static get registryFile() { return NexusPaths.registryFile; }
+    static get archivesDir() { return NexusPaths.archivesDir; }
+    static async init() {
+        if (this.initialized)
+            return;
+        await fs.mkdir(NexusPaths.root, { recursive: true });
+        await fs.mkdir(this.globalDir, { recursive: true });
+        await fs.mkdir(this.projectsRoot, { recursive: true });
+        await fs.mkdir(this.archivesDir, { recursive: true });
+        // Self-healing initialization for critical files
+        await this.loadJsonSafe(this.registryFile, { projects: {} });
+        await this.loadJsonSafe(this.globalDiscussion, []);
+        if (!await this.exists(this.globalBlueprint)) {
+            await fs.writeFile(this.globalBlueprint, "# Global Coordination Blueprint\n\nShared meeting space.");
+        }
+        await DocStorage.init();
+        try {
+            const { initTasksTable } = await import("./tasks.js");
+            initTasksTable();
+        }
+        catch {
+            /* tasks module is optional */
+        }
+        this.initialized = true;
+    }
+    static resetInit() {
+        this.initialized = false;
+    }
+    static async loadJsonSafe(filePath, defaultValue) {
+        try {
+            if (!await this.exists(filePath)) {
+                await fs.writeFile(filePath, JSON.stringify(defaultValue, null, 2), FILE_ENCODING);
+                return defaultValue;
+            }
+            const content = await fs.readFile(filePath, FILE_ENCODING);
+            return JSON.parse(content.replace(/^\uFEFF/, '').trim());
+        }
+        catch {
+            console.warn(`[Nexus Storage] Repairing corrupted file: ${filePath}`);
+            await fs.writeFile(filePath, JSON.stringify(defaultValue, null, 2), FILE_ENCODING);
+            return defaultValue;
+        }
+    }
+    static async exists(p) {
+        try {
+            await fs.access(p);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // --- Registry Methods ---
+    static listRegistry() { return RegistryStorage.listRegistry(); }
+    static getProjectManifest(id) { return RegistryStorage.getProjectManifest(id); }
+    static saveProjectManifest(manifest) { return RegistryStorage.saveProjectManifest(manifest); }
+    static patchProjectManifest(id, patch) { return RegistryStorage.patchProjectManifest(id, patch); }
+    static calculateTopology(projectId) { return RegistryStorage.calculateTopology(projectId); }
+    // --- Project Methods ---
+    static getProjectDocs(id) { return ProjectStorage.getProjectDocs(id); }
+    static saveProjectDocs(id, content) { return ProjectStorage.saveProjectDocs(id, content); }
+    static saveAsset(id, fileName, content) { return ProjectStorage.saveAsset(id, fileName, content); }
+    static async deleteProject(id) {
+        await ProjectStorage.deleteProject(id);
+        await RegistryStorage.deleteProject(id);
+    }
+    static async renameProject(oldId, newId) {
+        await RegistryStorage.renameProject(oldId, newId);
+        try {
+            const result = await ProjectStorage.renameProject(oldId, newId);
+            if (result === 0) {
+                await RegistryStorage.renameProject(newId, oldId);
+            }
+            return result;
+        }
+        catch (error) {
+            await RegistryStorage.renameProject(newId, oldId).catch(() => { });
+            throw error;
+        }
+    }
+    // --- Log Methods ---
+    static addGlobalLog(from, text, category) { return LogStorage.addLog(from, text, category); }
+    static getRecentLogs(count = 10) { return LogStorage.getLogs(count); }
+    static pruneGlobalLogs(count) { return LogStorage.pruneLogs(count); }
+    static clearGlobalLogs() { return LogStorage.clearLogs(); }
+    // --- Doc Methods ---
+    static listGlobalDocs() { return DocStorage.listDocs(); }
+    static getGlobalDoc(docId) { return DocStorage.getDoc(docId); }
+    static saveGlobalDoc(docId, title, content, updatedBy) { return DocStorage.saveDoc(docId, title, content, updatedBy); }
+    static deleteGlobalDoc(docId) { return DocStorage.deleteDoc(docId); }
+}

package/build/storage/logs.js

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,276 @@
+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/paths.js

@@ -0,0 +1,26 @@
+import path from "node:path";
+import { getRootPath } from "../config/paths.js";
+export class NexusPaths {
+    static get root() { return getRootPath(); }
+    static get globalDir() { return path.join(this.root, "global"); }
+    static get globalBlueprint() { return path.join(this.globalDir, "blueprint.md"); }
+    static get globalDiscussion() { return path.join(this.globalDir, "discussion.json"); }
+    static get projectsRoot() { return path.join(this.root, "projects"); }
+    static get registryFile() { return path.join(this.root, "registry.json"); }
+    static get archivesDir() { return path.join(this.root, "archives"); }
+    static assertSafeSegment(value, label) {
+        if (!/^[a-zA-Z0-9._-]+$/.test(value) || value === "." || value === "..") {
+            throw new Error(`Invalid ${label}: '${value}'. Use only letters, numbers, dots, underscores, and hyphens.`);
+        }
+        return value;
+    }
+    static projectDir(id) { return path.join(this.projectsRoot, this.assertSafeSegment(id, "project id")); }
+    static projectDocPath(id) { return path.join(this.projectDir(id), "internal_blueprint.md"); }
+    static projectManifestPath(id) { return path.join(this.projectDir(id), "manifest.json"); }
+    static projectAssetsDir(id) { return path.join(this.projectDir(id), "assets"); }
+    static get dbFile() { return path.join(this.root, "nexus.db"); }
+    static taskFile() { return path.join(this.root, "tasks.json"); }
+    static docsDir() { return path.join(this.globalDir, "docs"); }
+    static get docsIndexFile() { return path.join(this.globalDir, "docs_index.json"); }
+    static docFile(docId) { return path.join(this.docsDir(), `${this.assertSafeSegment(docId, "document id")}.md`); }
+}