@noesis-brain/mcp-server 2.0.0

package/dist/api/NoesisClient.js

@@ -0,0 +1,654 @@
+/**
+ * NoesisClient - HTTP client for Noesis API
+ *
+ * Replaces direct PostgreSQL access in MCP server.
+ * All operations go through authenticated API calls.
+ */
+import crypto from 'crypto';
+import os from 'os';
+import path from 'path';
+const _envFakePlatform = process.env.NOESIS_FAKE_PLATFORM;
+const _realPlatform = process.platform === 'darwin' ? 'darwin'
+    : process.platform === 'win32' ? 'win32'
+        : 'linux';
+export const CLIENT_OS = (_envFakePlatform === 'win32' || _envFakePlatform === 'darwin' || _envFakePlatform === 'linux')
+    ? _envFakePlatform
+    : _realPlatform;
+/**
+ * Expand a leading `~` or `%USERPROFILE%` (home-directory shortcut) against
+ * this machine's home directory. Cloud-flow root paths are stored as
+ * `~/Noesis/...` in the cloud DB because the cloud cannot know each machine's
+ * $HOME -- the MCP server expands here at sync time. No-op for already-absolute
+ * paths.
+ *
+ * `%USERPROFILE%` is accepted because the frontend renders Windows-row root
+ * paths as `%USERPROFILE%\Noesis` for display (Windows shells don't expand `~`),
+ * and that displayed form ends up on the clipboard via the note's "Copy file
+ * path" button. Recognising it here keeps Copy → Paste → `sync_notes` working
+ * end-to-end on Windows.
+ *
+ * Phase 34 introduced this expansion. Older MCP server versions stored
+ * `cloud://` sentinels and never expanded; that path is gone.
+ */
+export function expandHome(p) {
+    if (!p)
+        return '';
+    if (p === '~')
+        return os.homedir();
+    if (p.startsWith('~/') || p.startsWith('~\\')) {
+        return path.join(os.homedir(), p.slice(2));
+    }
+    // Windows: `%USERPROFILE%` and `%USERPROFILE%\...` (case-insensitive variable name).
+    const envHomeMatch = p.match(/^%USERPROFILE%([\\/].*)?$/i);
+    if (envHomeMatch) {
+        const tail = envHomeMatch[1];
+        if (!tail)
+            return os.homedir();
+        return path.join(os.homedir(), tail.slice(1));
+    }
+    return p;
+}
+/**
+ * Return the OS-active path from a root's local_paths map, or '' if
+ * missing. Tilde-prefixed values are expanded against `os.homedir()` for
+ * direct fs use. Callers that need an error on miss should use
+ * requireActiveRootPath in tools/index.ts instead.
+ */
+export function getActivePathFromMap(localPaths) {
+    if (!localPaths)
+        return '';
+    return expandHome(localPaths[CLIENT_OS] || '');
+}
+/**
+ * HTTP client for Noesis API
+ */
+export class NoesisClient {
+    baseUrl;
+    apiToken;
+    constructor(baseUrl, apiToken) {
+        // Remove trailing slash
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.apiToken = apiToken;
+    }
+    /**
+     * Make an authenticated HTTP request
+     */
+    async request(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const response = await fetch(url, {
+            method,
+            headers: {
+                'Authorization': `Bearer ${this.apiToken}`,
+                'Content-Type': 'application/json',
+                'X-Client-OS': CLIENT_OS,
+            },
+            body: body ? JSON.stringify(body) : undefined,
+        });
+        if (!response.ok) {
+            const errorBody = await response.json().catch(() => ({ error: 'Request failed' }));
+            throw new Error(errorBody.error || `HTTP ${response.status}: ${response.statusText}`);
+        }
+        return response.json();
+    }
+    // ============================================
+    // ROOTS
+    // ============================================
+    async getRoots() {
+        const result = await this.request('GET', '/api/mcp/roots');
+        // Backfill `path` convenience field from local_paths[CLIENT_OS] for any
+        // call site still reading r.path directly.
+        return result.roots.map(r => ({ ...r, path: getActivePathFromMap(r.local_paths) }));
+    }
+    async getRootsForSync() {
+        const result = await this.request('GET', '/api/mcp/roots?forSync=true');
+        return result.roots.map(r => ({
+            id: r.id,
+            name: r.name,
+            local_paths: r.local_paths || {},
+            path: getActivePathFromMap(r.local_paths),
+            lastScannedAt: r.last_scanned_at || null
+        }));
+    }
+    /**
+     * Create a new root.
+     *
+     * Accepts either:
+     *  - `{ name, local_paths: { win32?, darwin?, linux? } }` (preferred; phase32+),
+     *  - `{ name, path }` (legacy single-path — auto-routed into local_paths[CLIENT_OS]).
+     */
+    async createRoot(options) {
+        let local_paths = options.local_paths;
+        if (!local_paths && options.path) {
+            local_paths = { [CLIENT_OS]: options.path };
+        }
+        const body = { name: options.name, local_paths };
+        if (options.type)
+            body.type = options.type;
+        const result = await this.request('POST', '/api/mcp/roots', body);
+        return { ...result.root, path: getActivePathFromMap(result.root.local_paths) };
+    }
+    async getRootByPath(path) {
+        try {
+            const result = await this.request('GET', `/api/mcp/roots/by-path?path=${encodeURIComponent(path)}`);
+            return { ...result.root, path: getActivePathFromMap(result.root.local_paths) };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Look up a note by (root_id, relative_path). Used by the MCP server's
+     * cross-platform `get_note` resolver after it has prefix-matched the input
+     * path against a root.
+     */
+    async getNoteByRelativePath(rootId, relativePath) {
+        try {
+            const params = new URLSearchParams({ root_id: String(rootId), relative_path: relativePath });
+            const result = await this.request('GET', `/api/mcp/notes/by-relative?${params}`);
+            return result.note;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getNoteHashesByRoot(rootId) {
+        const result = await this.request('GET', `/api/mcp/roots/${rootId}/hashes`);
+        return new Map(Object.entries(result.hashes));
+    }
+    /**
+     * Get notes with hash, modified_at, content, and metadata for bidirectional sync comparison
+     */
+    async getNotesForSync(rootId) {
+        const result = await this.request('GET', `/api/mcp/roots/${rootId}/notes-for-sync`);
+        return result.notes;
+    }
+    /**
+     * Mark a cloud note as having an unresolved sync conflict.
+     * The structured BASE/LOCAL/CLOUD payload is stored in notes.conflict_marker (JSONB).
+     * Web UI surfaces a yellow banner when this is set.
+     */
+    async markConflict(noteId, payload) {
+        await this.request('POST', `/api/mcp/notes/${noteId}/mark-conflict`, payload);
+    }
+    /** Clear the conflict marker after a successful merge + push. */
+    async clearConflict(noteId) {
+        await this.request('POST', `/api/mcp/notes/${noteId}/clear-conflict`, {});
+    }
+    /**
+     * List notes with edited_online_at set — pending local sync from web UI edits.
+     * Optionally filter to a specific root by ID.
+     */
+    async getEditedOnlineNotes(rootId) {
+        const params = rootId !== undefined ? `?root_id=${rootId}` : '';
+        const result = await this.request('GET', `/api/mcp/edited-online-notes${params}`);
+        // Phase32: backend returns root_local_paths (JSONB map). Compute the
+        // OS-active root_path convenience field for back-compat with the existing
+        // tool surface.
+        return result.notes.map((n) => ({
+            id: n.id,
+            title: n.title,
+            relative_path: n.relative_path,
+            hash: n.hash,
+            edited_online_at: n.edited_online_at,
+            root_id: n.root_id,
+            root_local_paths: n.root_local_paths || {},
+            root_path: getActivePathFromMap(n.root_local_paths),
+        }));
+    }
+    // ============================================
+    // CATALOGS
+    // ============================================
+    async listCatalogs() {
+        const result = await this.request('GET', '/api/mcp/catalogs');
+        return result.catalogs;
+    }
+    async setNoteCatalogs(noteId, catalogs) {
+        await this.request('PUT', `/api/mcp/notes/${noteId}/catalogs`, { catalogs });
+    }
+    async setNoteRelatedCodes(noteId, codes) {
+        // Numeric ids hit the primary `codebase_ids` channel; raw path strings fall through
+        // the backend's find-or-create shim. Mixed input rides the same `related_codes` key
+        // and the server resolves per-element.
+        const allNumeric = codes.every(c => typeof c === 'number');
+        const body = allNumeric ? { codebase_ids: codes } : { related_codes: codes };
+        await this.request('PUT', `/api/mcp/notes/${noteId}/related-codes`, body);
+    }
+    // ============================================
+    // CODEBASES (managed registry)
+    // ============================================
+    async listCodebases(includeArchived = false) {
+        const params = new URLSearchParams();
+        if (includeArchived)
+            params.set('archived', 'true');
+        const qs = params.toString();
+        const result = await this.request('GET', `/api/mcp/codebases${qs ? `?${qs}` : ''}`);
+        return result.codebases;
+    }
+    async getCodebase(id) {
+        return this.request('GET', `/api/mcp/codebases/${id}`);
+    }
+    async getCodebaseUsage(id) {
+        return this.request('GET', `/api/mcp/codebases/${id}/usage`);
+    }
+    async createCodebase(input) {
+        return this.request('POST', `/api/mcp/codebases`, input);
+    }
+    async findOrCreateCodebase(input) {
+        return this.request('POST', `/api/mcp/codebases/find-or-create`, input);
+    }
+    async updateCodebase(id, patch) {
+        return this.request('PATCH', `/api/mcp/codebases/${id}`, patch);
+    }
+    async deleteCodebase(id) {
+        return this.request('DELETE', `/api/mcp/codebases/${id}`);
+    }
+    async updateRootScanTime(rootId) {
+        await this.request('PUT', `/api/mcp/roots/${rootId}/scan-time`, {});
+    }
+    // ============================================
+    // NOTES - SEARCH & READ
+    // ============================================
+    async searchNotes(query, options = {}) {
+        const { limit = 10, root, catalog } = options;
+        const params = new URLSearchParams({ q: query, limit: String(limit) });
+        if (root)
+            params.append('root', root);
+        if (catalog)
+            params.append('catalog', catalog);
+        const result = await this.request('GET', `/api/mcp/notes/search?${params}`);
+        // Transform results to include relevance percentage and excerpt
+        return result.notes.map(note => {
+            // Convert relevance_score to percentage (BM25 scores vary, normalize to 0-100)
+            const relevanceScore = note.relevance_score || 0;
+            const relevance = Math.min(Math.round(relevanceScore * 100), 100);
+            // Generate excerpt from content
+            let excerpt = note.description || '';
+            if (!excerpt && note.content) {
+                excerpt = note.content.substring(0, 200).replace(/\n/g, ' ').trim();
+                if (note.content.length > 200)
+                    excerpt += '...';
+            }
+            return {
+                ...note,
+                relevance,
+                excerpt
+            };
+        });
+    }
+    async getNote(id) {
+        try {
+            const result = await this.request('GET', `/api/mcp/notes/${id}`);
+            return result.note;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getBookmarkContext(noteId, bookmarkId, contextParagraphs = 2) {
+        try {
+            const params = new URLSearchParams({ paragraphs: String(contextParagraphs) });
+            return await this.request('GET', `/api/mcp/notes/${noteId}/bookmarks/${bookmarkId}/context?${params}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getChatSession(id, opts = {}) {
+        try {
+            const params = new URLSearchParams();
+            if (opts.limit != null)
+                params.set('limit', String(opts.limit));
+            const qs = params.toString();
+            return await this.request('GET', `/api/mcp/chat/sessions/${id}${qs ? `?${qs}` : ''}`);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getNoteByPath(filePath) {
+        try {
+            const result = await this.request('GET', `/api/mcp/notes/by-path?path=${encodeURIComponent(filePath)}`);
+            return result.note;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async searchByRelatedCode(path, limit = 20) {
+        const params = new URLSearchParams({
+            path,
+            limit: String(limit)
+        });
+        const result = await this.request('GET', `/api/mcp/notes/by-related-code?${params}`);
+        return result.notes;
+    }
+    async getRelationGraph(noteId, depth = 2) {
+        const params = new URLSearchParams({
+            id: String(noteId),
+            depth: String(depth)
+        });
+        const result = await this.request('GET', `/api/mcp/notes/relation-graph?${params}`);
+        return result.notes;
+    }
+    async listNotes(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.append('limit', String(options.limit));
+        if (options.offset)
+            params.append('offset', String(options.offset));
+        if (options.root)
+            params.append('root', options.root);
+        if (options.catalog)
+            params.append('catalog', options.catalog);
+        const result = await this.request('GET', `/api/mcp/notes?${params}`);
+        return result.notes;
+    }
+    async getRecentNotes(days = 7, limit = 20) {
+        const params = new URLSearchParams({
+            recent: String(days),
+            limit: String(limit)
+        });
+        const result = await this.request('GET', `/api/mcp/notes?${params}`);
+        return result.notes;
+    }
+    /**
+     * Get notes for pulling to local files
+     */
+    async getNotesForPull(options = {}) {
+        const params = new URLSearchParams();
+        if (options.root)
+            params.append('root', options.root);
+        params.append('for_pull', 'true');
+        const result = await this.request('GET', `/api/mcp/notes?${params}`);
+        return result.notes;
+    }
+    /**
+     * Get note count by root for sync status
+     */
+    async getNoteCountByRoot() {
+        const result = await this.request('GET', '/api/mcp/notes/count-by-root');
+        return new Map(Object.entries(result.counts).map(([k, v]) => [parseInt(k), v]));
+    }
+    // ============================================
+    // NOTES - WRITE (SYNC)
+    // ============================================
+    async upsertNote(file, metadata = {}, options = {}) {
+        const { force = false, regenerateMetadata = false, preserveMetadata = false, lastSyncedHash } = options;
+        const body = { file, metadata, force, regenerateMetadata, preserveMetadata };
+        if (lastSyncedHash !== undefined)
+            body.lastSyncedHash = lastSyncedHash;
+        const result = await this.request('POST', '/api/mcp/notes/upsert', body);
+        return result;
+    }
+    async logSyncOperation(options) {
+        await this.request('POST', '/api/mcp/sync/log', options);
+    }
+    // ============================================
+    // METADATA ENHANCEMENT
+    // ============================================
+    async getNoteForEnhancement(id) {
+        try {
+            const result = await this.request('GET', `/api/mcp/notes/${id}/for-enhancement`);
+            return result.note;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async updateNoteMetadata(id, metadata) {
+        try {
+            await this.request('PUT', `/api/mcp/notes/${id}/metadata`, metadata);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Update file metadata (file_size, hash) after pulling from cloud.
+     * Phase32: prefer (root_id, relative_path); falls back to legacy file_path
+     * if the caller hasn't been updated.
+     */
+    async updateFileMetadata(filePathOrIds, fileSize, hash) {
+        try {
+            const body = { file_size: fileSize, hash };
+            if (typeof filePathOrIds === 'string') {
+                body.file_path = filePathOrIds;
+            }
+            else {
+                body.root_id = filePathOrIds.rootId;
+                body.relative_path = filePathOrIds.relativePath;
+            }
+            await this.request('PUT', '/api/mcp/notes/file-metadata', body);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getNotesNeedingEnhancement(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.append('limit', String(options.limit));
+        if (options.importantOnly)
+            params.append('important_only', 'true');
+        if (options.root)
+            params.append('root', options.root);
+        if (options.catalog)
+            params.append('catalog', options.catalog);
+        const result = await this.request('GET', `/api/mcp/notes/needing-enhancement?${params}`);
+        return result.notes;
+    }
+    // ============================================
+    // SCORES & RELATIONS
+    // ============================================
+    async updateImportanceScore(id, score) {
+        try {
+            await this.request('PUT', `/api/mcp/notes/${id}/importance`, { score });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async updateQualityScore(id, score) {
+        try {
+            await this.request('PUT', `/api/mcp/notes/${id}/quality`, { score });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async updateRelations(id, relations) {
+        const result = await this.request('PUT', `/api/mcp/notes/${id}/relations`, { relations });
+        return { updated: result.updated || relations.length, inversesCreated: 0 };
+    }
+    async moveNote(id, newPath, options = {}) {
+        try {
+            const result = await this.request('PUT', `/api/mcp/notes/${id}/move`, {
+                new_path: newPath,
+                new_relative_path: options.newRelativePath,
+                new_root_name: options.newRootName,
+            });
+            return result.note;
+        }
+        catch {
+            return null;
+        }
+    }
+    async updateNoteSignals(id, signals) {
+        try {
+            await this.request('PUT', `/api/mcp/notes/${id}/signals`, signals);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async trashNote(id) {
+        try {
+            await this.request('PUT', `/api/mcp/notes/${id}/trash`, {});
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async getNoteForScoring(id) {
+        // Same as getNoteForEnhancement for now
+        return this.getNoteForEnhancement(id);
+    }
+    async getNotesForRelationAnalysis(excludeId, options = {}) {
+        const params = new URLSearchParams({ limit: String(options.limit || 50) });
+        if (options.root)
+            params.append('root', options.root);
+        const result = await this.request('GET', `/api/mcp/notes?${params}`);
+        return result.notes.filter(n => n.id !== excludeId);
+    }
+    // ============================================
+    // EMBEDDINGS
+    // ============================================
+    async getNotesWithoutEmbeddings(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.append('limit', String(options.limit));
+        if (options.root)
+            params.append('root', options.root);
+        const result = await this.request('GET', `/api/mcp/notes/without-embeddings?${params}`);
+        return result.notes;
+    }
+    async updateNoteEmbedding(id, embedding) {
+        try {
+            await this.request('PUT', `/api/mcp/notes/${id}/embedding`, { embedding });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async searchByEmbedding(embedding, options = {}) {
+        const result = await this.request('POST', '/api/mcp/notes/search-semantic', { embedding, ...options });
+        return result.notes;
+    }
+    async findSimilarNotes(noteId, options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.append('limit', String(options.limit));
+        const result = await this.request('GET', `/api/mcp/notes/${noteId}/similar?${params}`);
+        return result.notes;
+    }
+    async getNoteEmbedding(id) {
+        // Get note and extract embedding if present
+        const note = await this.getNote(id);
+        if (!note)
+            return undefined;
+        // Embedding is not returned in standard note response for size reasons
+        return undefined;
+    }
+    async getEmbeddingStats() {
+        const result = await this.request('GET', '/api/mcp/stats/embeddings');
+        return result;
+    }
+    // ============================================
+    // STATUS & SETTINGS
+    // ============================================
+    async getLastSyncTime() {
+        const result = await this.request('GET', '/api/mcp/status');
+        return result.lastSyncTime;
+    }
+    async setLastSyncTime(timestamp) {
+        // This is typically handled by logSyncOperation
+        // Not directly exposed via API for now
+    }
+    async getKnowledgeBaseStats(options = {}) {
+        const params = new URLSearchParams();
+        if (options.limit)
+            params.append('limit', String(options.limit));
+        if (options.root)
+            params.append('root', options.root);
+        return this.request('GET', `/api/mcp/analyze?${params}`);
+    }
+    async getSyncLogs(rootId, limit = 10) {
+        const params = new URLSearchParams({ limit: String(limit) });
+        if (rootId)
+            params.append('root_id', String(rootId));
+        // Note: This endpoint is on the main API, not /api/mcp
+        const result = await this.request('GET', `/api/sync-logs?${params}`);
+        return result.logs;
+    }
+    // ============================================
+    // UTILITIES
+    // ============================================
+    /**
+     * Normalize line endings to LF for cross-platform consistency
+     * Matches backend behavior in src/backend/routes/mcp.ts
+     */
+    static normalizeLineEndings(content) {
+        return content.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+    }
+    // ─── Daily News Methods ───
+    async getNewsPreferences() {
+        const [settings, sources, seeds] = await Promise.all([
+            this.request('GET', '/api/news/settings'),
+            this.request('GET', '/api/news/sources'),
+            this.request('GET', '/api/news/seeds'),
+        ]);
+        return {
+            settings: settings.settings,
+            sources: sources.sources,
+            seeds: seeds.seeds,
+        };
+    }
+    async updateNewsPreferences(data) {
+        if (data.settings) {
+            await this.request('PATCH', '/api/news/settings', data.settings);
+        }
+        if (data.preferences) {
+            await this.request('POST', '/api/news/preferences/import', { preferences: data.preferences });
+        }
+    }
+    async addNewsSource(data) {
+        return this.request('POST', '/api/news/sources', data);
+    }
+    /**
+     * Compute SHA-256 hash of content (for sync comparison)
+     * Static method - can be used without API call
+     * Note: Normalizes line endings to match backend hash computation
+     */
+    static computeHash(content) {
+        return crypto.createHash('sha256').update(NoesisClient.normalizeLineEndings(content), 'utf8').digest('hex');
+    }
+    // ============================================
+    // NAVIS
+    // ============================================
+    async listNavis() {
+        return this.request('GET', '/api/navis');
+    }
+    async getNavi(id) {
+        const result = await this.request('GET', `/api/navis/${id}`);
+        return result.navi;
+    }
+    async createNavi(body) {
+        const result = await this.request('POST', '/api/navis', body);
+        return result.navi;
+    }
+    async updateNavi(id, body) {
+        const result = await this.request('PUT', `/api/navis/${id}`, body);
+        return result.navi;
+    }
+    async deleteNavi(id) {
+        await this.request('DELETE', `/api/navis/${id}`);
+    }
+    async duplicateNavi(id, name) {
+        const result = await this.request('POST', `/api/navis/${id}/duplicate`, name ? { name } : {});
+        return result.navi;
+    }
+    /**
+     * Close the client (no-op for HTTP client)
+     */
+    async close() {
+        // No-op - HTTP client doesn't need cleanup
+    }
+}
+//# sourceMappingURL=NoesisClient.js.map