@memoire-ai/mcp-runtime 0.1.0

package/dist/index.js

@@ -0,0 +1,1137 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { MemoireClient } from '@memoire-ai/sdk';
+export function createMemoireMcpServer(config, deps) {
+    const client = deps?.client ?? new MemoireClient({
+        apiUrl: config.apiUrl,
+        apiKey: config.apiKey,
+        clientId: config.clientId,
+    });
+    const server = new McpServer({
+        name: 'memoire',
+        version: '0.2.0',
+    });
+    // ── Search Context ─────────────────────────────────────────────────
+    server.tool('search_context', 'Search shared project context — decisions, observations, attempts, and teammate work. Uses hybrid search (vector + fulltext + metadata). Use the detail parameter to control how much context is returned: summary (L0, cheapest), overview (L1, balanced), or full (L2, richest).', {
+        query: z.string().describe('Search query'),
+        event_types: z.array(z.string()).optional().describe('Filter by event types'),
+        limit: z.number().optional().describe('Max results (default 20)'),
+        strategy: z.enum(['auto', 'vector', 'fulltext', 'metadata', 'hybrid']).optional().describe('Search strategy (default: auto)'),
+        detail: z.enum(['summary', 'overview', 'full']).optional().describe('Detail level: summary (L0, ~200 tokens), overview (L1, ~1000 tokens), full (L2, complete content). Default: summary'),
+    }, async ({ query, event_types, limit, strategy, detail }) => {
+        const res = await client.searchContext({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            query,
+            filters: event_types ? { event_types } : undefined,
+            limit,
+            detail: detail ?? 'summary',
+        });
+        const text = res.results
+            .map((r) => {
+            const header = `[${r.event_type}] (score: ${r.score.toFixed(2)}) ${r.summary}`;
+            const meta = `  by ${r.user_id} via ${r.client} at ${r.created_at}`;
+            const feedbackLine = r.feedback_score ? `  feedback: ${r.feedback_score > 0 ? '+' : ''}${r.feedback_score}${r.feedback_labels?.length ? ` [${r.feedback_labels.join(', ')}]` : ''}` : '';
+            const body = detail === 'full' && r.content
+                ? `\n  ${r.content}`
+                : detail === 'overview' && r.overview
+                    ? `\n  ${r.overview}`
+                    : '';
+            return `${header}\n${meta}${feedbackLine}${body}`;
+        })
+            .join('\n\n');
+        return { content: [{ type: 'text', text: text || 'No results found.' }] };
+    });
+    // ── Timeline Context ───────────────────────────────────────────────
+    server.tool('timeline_context', 'Get chronological project context — recent activity, branch work, session history.', {
+        branch_name: z.string().optional().describe('Filter by branch'),
+        limit: z.number().optional().describe('Max entries (default 50)'),
+    }, async ({ branch_name, limit }) => {
+        const res = await client.timelineContext({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            branch_name,
+            limit,
+        });
+        const text = res.entries
+            .map((e) => `[${e.created_at}] ${e.event_type}: ${e.content.slice(0, 300)}`)
+            .join('\n\n');
+        return { content: [{ type: 'text', text: text || 'No timeline entries.' }] };
+    });
+    // ── Project Profile ────────────────────────────────────────────────
+    server.tool('project_profile', 'Get the stable shared project profile — architecture, conventions, current focus, and open threads.', {}, async () => {
+        const res = await client.projectProfile({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+        });
+        const sections = [];
+        sections.push(`# Project Profile`);
+        sections.push(res.project_profile.summary);
+        appendProfileSection(sections, 'Architecture', res.project_profile.architecture);
+        appendProfileSection(sections, 'Conventions', res.project_profile.conventions);
+        appendProfileSection(sections, 'Current Focus', res.project_profile.current_focus);
+        appendProfileSection(sections, 'Recent Decisions', res.project_profile.recent_decisions);
+        appendProfileSection(sections, 'Open Threads', res.project_profile.open_threads);
+        appendProfileSection(sections, 'Key Files', res.project_profile.key_files);
+        sections.push(`Source coverage: ${res.source_event_count} events across ${res.source_event_types.join(', ') || 'no event types yet'}`);
+        return { content: [{ type: 'text', text: sections.join('\n\n') }] };
+    });
+    // ── Project Facts ──────────────────────────────────────────────────
+    server.tool('project_facts', 'Get derived static and dynamic project facts distilled from shared memory.', {}, async () => {
+        const res = await client.projectFacts({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+        });
+        const sections = ['# Project Facts'];
+        appendFactSection(sections, 'Static Facts', res.facts.static.map((fact) => `${fact.text} (${fact.category})`));
+        appendFactSection(sections, 'Dynamic Facts', res.facts.dynamic.map((fact) => `${fact.text} (${fact.category})`));
+        sections.push(`Source coverage: ${res.source_event_count} events across ${res.source_event_types.join(', ') || 'no event types yet'}`);
+        return { content: [{ type: 'text', text: sections.join('\n\n') }] };
+    });
+    // ── Assemble Context ───────────────────────────────────────────────
+    server.tool('assemble_context', 'Get a prompt-ready context block with decisions, failed attempts, active work, and teammate activity.', {
+        query: z.string().optional().describe('Optional focus query'),
+        token_budget: z.number().optional().describe('Max tokens for context block (default 4000)'),
+    }, async ({ query, token_budget }) => {
+        const res = await client.assembleContext({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            query,
+            token_budget,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: res.context_block || 'No context available for this project yet.',
+                }],
+        };
+    });
+    // ── Saved Handoffs ────────────────────────────────────────────────
+    server.tool('save_handoff', 'Assemble a prompt-ready context block and save it as a reusable handoff for teammates or other agents.', {
+        query: z.string().optional().describe('Optional focus query for the handoff'),
+        title: z.string().optional().describe('Optional custom handoff title'),
+        token_budget: z.number().optional().describe('Max tokens for the generated handoff block (default 2400)'),
+    }, async ({ query, title, token_budget }) => {
+        const trimmedQuery = query?.trim() || undefined;
+        const assembled = await client.assembleContext({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            query: trimmedQuery,
+            token_budget: token_budget ?? 2400,
+        });
+        const saved = await client.createHandoff({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            title: title?.trim() || undefined,
+            query: trimmedQuery,
+            context_block: assembled.context_block,
+            source_event_ids: assembled.event_ids,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `Saved handoff ${saved.handoff.id}`,
+                        `Title: ${saved.handoff.title}`,
+                        `Summary: ${saved.handoff.summary}`,
+                        '',
+                        saved.handoff.context_block,
+                    ].join('\n'),
+                }],
+        };
+    });
+    server.tool('list_handoffs', 'List recent saved handoffs for this project so another agent can pick up the right context thread quickly.', {
+        limit: z.number().optional().describe('Max handoffs to return (default 10)'),
+    }, async ({ limit }) => {
+        const res = await client.listHandoffs({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            limit,
+        });
+        const text = res.handoffs
+            .map((handoff) => `[${handoff.id}] ${handoff.title}\n  ${handoff.summary}\n  created ${handoff.created_at}`)
+            .join('\n\n');
+        return { content: [{ type: 'text', text: text || 'No saved handoffs yet.' }] };
+    });
+    server.tool('get_handoff', 'Fetch a saved handoff by ID and return the full prompt-ready context block.', {
+        handoff_id: z.string().describe('Saved handoff ID'),
+    }, async ({ handoff_id }) => {
+        const res = await client.getHandoff({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            handoff_id,
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: [
+                        `# ${res.handoff.title}`,
+                        `ID: ${res.handoff.id}`,
+                        `Summary: ${res.handoff.summary}`,
+                        '',
+                        res.handoff.context_block,
+                    ].join('\n'),
+                }],
+        };
+    });
+    // ── Auto-subscribe Dependencies ──────────────────────────────────
+    server.tool('auto_subscribe_dependencies', 'Parse a package manifest (package.json, requirements.txt, Cargo.toml) and auto-index documentation for all dependencies. Provide the file path and content.', {
+        manifest_path: z.string().describe('File path of the manifest (e.g. "package.json")'),
+        manifest_content: z.string().describe('Full content of the manifest file'),
+    }, async ({ manifest_path, manifest_content }) => {
+        const res = await client.autoSubscribeDocs({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            manifest_path,
+            manifest_content,
+        });
+        const parts = [];
+        parts.push(`# Auto-Subscribe Results`);
+        parts.push(`Dependencies found: ${res.dependencies_found}`);
+        parts.push(`Indexed: ${res.dependencies_indexed}`);
+        parts.push(`Skipped: ${res.dependencies_skipped}`);
+        parts.push(`Failed: ${res.dependencies_failed}`);
+        if (res.results.length > 0) {
+            parts.push('');
+            for (const r of res.results.slice(0, 20)) {
+                parts.push(`- ${r.dependency_name}@${r.dependency_version}: ${r.status} (${r.chunks_indexed} chunks)${r.reason ? ` — ${r.reason}` : ''}`);
+            }
+        }
+        return { content: [{ type: 'text', text: parts.join('\n') }] };
+    });
+    // ── Index Docs ─────────────────────────────────────────────────────
+    server.tool('index_docs', 'Index documentation for specific packages by name. Fetches from npm/PyPI/crates registries and indexes for search. Use the language parameter to index language-specific variants (e.g., Python vs JavaScript docs for the same library).', {
+        packages: z.array(z.object({
+            name: z.string().describe('Package name'),
+            version: z.string().optional().describe('Package version (default: latest)'),
+            ecosystem: z.enum(['npm', 'pip', 'cargo', 'go', 'internal']).describe('Package ecosystem'),
+            language: z.string().optional().describe('Language variant (e.g. "python", "javascript", "typescript")'),
+        })).min(1).max(50).describe('Packages to index'),
+    }, async ({ packages }) => {
+        const dependencies = packages.map((pkg) => ({
+            name: pkg.name,
+            version: pkg.version ?? 'latest',
+            ecosystem: pkg.ecosystem,
+            language: pkg.language,
+        }));
+        const res = await client.indexDocs({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            dependencies,
+        });
+        const parts = [`# Index Results (${res.results.length} packages)`];
+        for (const r of res.results) {
+            parts.push(`- ${r.dependency_name}@${r.dependency_version}: ${r.status} (${r.chunks_indexed} chunks)${r.reason ? ` — ${r.reason}` : ''}`);
+        }
+        return { content: [{ type: 'text', text: parts.join('\n') }] };
+    });
+    // ── Index URL Docs ─────────────────────────────────────────────────
+    server.tool('index_url_docs', 'Index documentation from any URL. Fetches the page content and indexes it for search. Works with any website, documentation page, or llms.txt endpoint.', {
+        url: z.string().describe('URL to fetch and index'),
+        name: z.string().optional().describe('Name for the documentation source (default: hostname)'),
+    }, async ({ url, name }) => {
+        const res = await client.indexUrlDocs({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            url,
+            name,
+        });
+        if (res.status === 'indexed') {
+            return { content: [{ type: 'text', text: `Indexed "${res.name}" from ${res.url} — ${res.chunks_indexed} chunks stored. Use search_docs to query.` }] };
+        }
+        return { content: [{ type: 'text', text: `Failed to index ${res.url}: ${res.reason}` }] };
+    });
+    // ── Scratchpad (short-lived notes) ─────────────────────────────────
+    server.tool('write_scratchpad', 'Write a short-lived working note that auto-expires in 24 hours. Visible to all agents. Use for temporary context like "auth uses JWT" or "currently debugging the payment flow".', {
+        content: z.string().describe('The scratchpad note content'),
+        concepts: z.array(z.string()).optional().describe('Related concepts for search'),
+    }, async ({ content, concepts }) => {
+        await client.ingestEvent({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            user_id: config.userId,
+            session_id: config.sessionId ?? `mcp-${Date.now()}`,
+            client: 'cloud',
+            event_type: 'observation',
+            content: `[scratchpad] ${content}`,
+            concepts,
+            created_at: new Date().toISOString(),
+        });
+        return { content: [{ type: 'text', text: `Scratchpad note saved (expires in 24h). Searchable via search_context.` }] };
+    });
+    server.tool('get_scratchpad', 'Retrieve recent scratchpad notes (short-lived working memory).', {
+        limit: z.number().optional().describe('Max notes to retrieve (default 10)'),
+    }, async ({ limit }) => {
+        const res = await client.searchContext({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            query: '[scratchpad]',
+            limit: limit ?? 10,
+        });
+        const notes = res.results
+            .filter((r) => r.content?.includes('[scratchpad]') || r.summary?.includes('[scratchpad]'))
+            .map((r) => {
+            const text = (r.content ?? r.summary ?? '').replace('[scratchpad] ', '');
+            return `- ${text} (by ${r.user_id}, ${r.created_at})`;
+        });
+        if (notes.length === 0) {
+            return { content: [{ type: 'text', text: 'No scratchpad notes found.' }] };
+        }
+        return { content: [{ type: 'text', text: `# Scratchpad Notes\n${notes.join('\n')}` }] };
+    });
+    // ── Search Docs ────────────────────────────────────────────────────
+    server.tool('search_docs', 'Search indexed dependency and internal package documentation for the current project. Use the language parameter to filter results by language variant.', {
+        query: z.string().describe('Documentation search query'),
+        dependency_names: z.array(z.string()).optional().describe('Optional dependency filter'),
+        language: z.string().optional().describe('Filter by language variant (e.g. "python", "javascript")'),
+        limit: z.number().optional().describe('Max results (default 10)'),
+    }, async ({ query, dependency_names, language, limit }) => {
+        const res = await client.searchDocs({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+            query,
+            dependency_names,
+            language,
+            limit,
+        });
+        const text = res.results
+            .map((r) => {
+            const langTag = r.language ? ` (${r.language})` : '';
+            const notes = Array.isArray(r.attached_annotations) && r.attached_annotations.length > 0
+                ? `\nNotes:\n${r.attached_annotations
+                    .map((annotation) => `- ${annotation.annotation_type}${annotation.anchor_text ? ` (${annotation.anchor_text})` : ''}: ${annotation.content}`)
+                    .join('\n')}`
+                : '';
+            return `[${r.dependency_name}@${r.dependency_version}${langTag}] ${r.content}${notes}`;
+        })
+            .join('\n\n');
+        return { content: [{ type: 'text', text: text || 'No documentation results found.' }] };
+    });
+    // ── Build Docs Registry ────────────────────────────────────────────
+    server.tool('build_docs_registry', 'Build a registry of all indexed documentation for the project. Returns a structured JSON manifest of all indexed packages, versions, languages, and chunk counts — similar to a package registry index.', {}, async () => {
+        const res = await client.docsRegistry({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            viewer_user_id: config.userId,
+        });
+        const lines = [
+            `# Documentation Registry`,
+            `Generated: ${res.generated}`,
+            `Total entries: ${res.total_entries}`,
+            '',
+        ];
+        for (const entry of (res.entries ?? [])) {
+            const langTag = entry.language ? ` (${entry.language})` : '';
+            lines.push(`- ${entry.name}@${entry.version}${langTag} [${entry.ecosystem}] — ${entry.chunk_count} chunks (${entry.source_type})`);
+        }
+        return { content: [{ type: 'text', text: lines.join('\n') }] };
+    });
+    // ── Write Memory Event ─────────────────────────────────────────────
+    const writeEventSchema = {
+        event_type: z.enum(['decision', 'observation', 'attempt', 'branch_event', 'convention']).describe('Type of event'),
+        content: z.string().describe('Event content'),
+        files_modified: z.array(z.string()).optional().describe('Files that were modified'),
+        concepts: z.array(z.string()).optional().describe('Related concepts'),
+        branch_name: z.string().optional().describe('Branch name'),
+    };
+    async function writeEventTool({ event_type, content, files_modified, concepts, branch_name, }) {
+        await client.ingestEvent({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            user_id: config.userId,
+            session_id: config.sessionId ?? `mcp-${Date.now()}`,
+            client: 'cloud',
+            event_type,
+            content,
+            files_modified,
+            concepts,
+            branch_name,
+            created_at: new Date().toISOString(),
+        });
+        return { content: [{ type: 'text', text: `✓ ${event_type} recorded.` }] };
+    }
+    server.tool('write_memory_event', 'Write a memory event — record a decision, observation, or failed attempt for the team.', writeEventSchema, writeEventTool);
+    server.tool('write_event', 'Alias for write_memory_event.', writeEventSchema, writeEventTool);
+    // ── Oracle Research (NEW) ──────────────────────────────────────────
+    server.tool('oracle_research', 'Deep research agent — combines fact store, vector search, full-text search, and multi-hop tracing to answer complex questions about the project. Use for "why did we...", "what happened with...", "how does...work" questions.', {
+        question: z.string().describe('Research question about the project'),
+        depth: z.enum(['shallow', 'standard', 'deep']).optional().describe('Search depth (default: standard)'),
+    }, async ({ question, depth }) => {
+        // Oracle is server-side only — call the API endpoint
+        try {
+            const res = await fetch(`${config.apiUrl}/v1/context/oracle`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                    question,
+                    depth,
+                }),
+            });
+            if (!res.ok) {
+                return { content: [{ type: 'text', text: `Oracle research failed: ${res.status}` }] };
+            }
+            const data = await res.json();
+            const parts = [];
+            parts.push(`# Oracle Research: ${question}`);
+            parts.push(`Confidence: ${(data.confidence * 100).toFixed(0)}%`);
+            parts.push(`Strategies: ${data.search_stats?.strategies_used?.join(', ') ?? 'unknown'}`);
+            parts.push(`Events examined: ${data.search_stats?.events_examined ?? 0}`);
+            parts.push('');
+            parts.push(data.answer);
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Oracle research error: ${error}` }] };
+        }
+    });
+    // ── Tracer Search (NEW) ────────────────────────────────────────────
+    server.tool('tracer_search', 'Multi-hop search that follows reference chains through project memory. Useful for tracing the history of a decision, file, or concept across related events.', {
+        query: z.string().describe('Starting query to trace'),
+        max_hops: z.number().optional().describe('Max trace hops (default: 3)'),
+    }, async ({ query, max_hops }) => {
+        try {
+            const res = await fetch(`${config.apiUrl}/v1/context/trace`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                    query,
+                    max_hops,
+                }),
+            });
+            if (!res.ok) {
+                return { content: [{ type: 'text', text: `Tracer search failed: ${res.status}` }] };
+            }
+            const data = await res.json();
+            const parts = [];
+            parts.push(`# Trace: ${query}`);
+            parts.push(`Total events examined: ${data.total_events_examined}`);
+            parts.push('');
+            for (const hop of data.hops ?? []) {
+                parts.push(`## Hop ${hop.depth} (pivot: ${hop.pivot_query})`);
+                for (const event of hop.events ?? []) {
+                    parts.push(`- [${event.event_type}] ${event.summary} (relevance: ${event.relevance_score?.toFixed(2)})`);
+                }
+            }
+            if (data.chain_summary) {
+                parts.push('');
+                parts.push('## Chain Summary');
+                parts.push(data.chain_summary);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Tracer search error: ${error}` }] };
+        }
+    });
+    // ── Web Search (NEW) ───────────────────────────────────────────────
+    server.tool('web_search', 'Search the web for real-time information (documentation, Stack Overflow, blog posts). Requires TAVILY_API_KEY or BRAVE_SEARCH_API_KEY to be configured.', {
+        query: z.string().describe('Web search query'),
+        limit: z.number().optional().describe('Max results (default 5)'),
+    }, async ({ query, limit }) => {
+        try {
+            const res = await fetch(`${config.apiUrl}/v1/context/web-search`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify({ query, limit }),
+            });
+            if (!res.ok) {
+                return { content: [{ type: 'text', text: `Web search failed: ${res.status}. Make sure TAVILY_API_KEY or BRAVE_SEARCH_API_KEY is configured.` }] };
+            }
+            const data = await res.json();
+            const text = (data.results ?? [])
+                .map((r) => `[${r.source}] **${r.title}**\n${r.url}\n${r.snippet}`)
+                .join('\n\n');
+            return { content: [{ type: 'text', text: text || 'No web search results found.' }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Web search error: ${error}` }] };
+        }
+    });
+    // ── Fact Store (NEW) ───────────────────────────────────────────────
+    server.tool('get_project_knowledge', 'Get structured knowledge (facts) about the project — architecture decisions, conventions, configurations, dependencies. These are extracted from events and maintained with contradiction detection.', {
+        category: z.string().optional().describe('Filter by category: architecture, convention, dependency, behavior, config, workflow'),
+    }, async ({ category }) => {
+        try {
+            const url = category
+                ? `${config.apiUrl}/v1/context/facts/structured?category=${category}`
+                : `${config.apiUrl}/v1/context/facts/structured`;
+            const res = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.apiKey}`,
+                },
+                body: JSON.stringify({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                    category,
+                }),
+            });
+            if (!res.ok) {
+                // Fall back to existing project_facts endpoint
+                const fallbackRes = await client.projectFacts({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                });
+                const sections = ['# Project Knowledge'];
+                appendFactSection(sections, 'Static Facts', fallbackRes.facts.static.map((f) => `${f.text} (${f.category})`));
+                appendFactSection(sections, 'Dynamic Facts', fallbackRes.facts.dynamic.map((f) => `${f.text} (${f.category})`));
+                return { content: [{ type: 'text', text: sections.join('\n\n') }] };
+            }
+            const data = await res.json();
+            const parts = ['# Project Knowledge'];
+            for (const fact of data.facts ?? []) {
+                const conf = `${(fact.confidence * 100).toFixed(0)}%`;
+                parts.push(`- [${fact.category}] ${fact.subject} ${fact.predicate} ${fact.object} (confidence: ${conf})`);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') || 'No structured knowledge available yet.' }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Knowledge query error: ${error}` }] };
+        }
+    });
+    // ── Fetch Dependency Docs (NEW) ─────────────────────────────────────
+    server.tool('fetch_dependency_docs', 'Fetch documentation for project dependencies from npm/PyPI/crates registries. Provide a package name and registry.', {
+        packages: z.array(z.object({
+            name: z.string().describe('Package name'),
+            registry: z.enum(['npm', 'pypi', 'crates']).describe('Package registry'),
+        })).describe('List of packages to look up'),
+    }, async ({ packages }) => {
+        const TIMEOUT = 8000;
+        const results = [`# Dependency Documentation (${packages.length} packages)`];
+        for (const pkg of packages.slice(0, 20)) {
+            try {
+                let url;
+                switch (pkg.registry) {
+                    case 'npm':
+                        url = `https://registry.npmjs.org/${encodeURIComponent(pkg.name)}/latest`;
+                        break;
+                    case 'pypi':
+                        url = `https://pypi.org/pypi/${encodeURIComponent(pkg.name)}/json`;
+                        break;
+                    case 'crates':
+                        url = `https://crates.io/api/v1/crates/${encodeURIComponent(pkg.name)}`;
+                        break;
+                }
+                const controller = new AbortController();
+                const timer = setTimeout(() => controller.abort(), TIMEOUT);
+                const res = await fetch(url, { signal: controller.signal });
+                clearTimeout(timer);
+                if (!res.ok) {
+                    results.push(`## ${pkg.name} (${pkg.registry})\nNot found (${res.status})\n`);
+                    continue;
+                }
+                const data = await res.json();
+                results.push(`## ${pkg.name} (${pkg.registry})`);
+                if (pkg.registry === 'npm') {
+                    if (data.version)
+                        results.push(`Version: ${data.version}`);
+                    if (data.description)
+                        results.push(data.description);
+                    if (data.readme)
+                        results.push(String(data.readme).slice(0, 1500));
+                }
+                else if (pkg.registry === 'pypi') {
+                    const info = data.info ?? {};
+                    if (info.version)
+                        results.push(`Version: ${info.version}`);
+                    if (info.summary)
+                        results.push(info.summary);
+                    if (info.description)
+                        results.push(String(info.description).slice(0, 1500));
+                }
+                else if (pkg.registry === 'crates') {
+                    const crate = data.crate ?? {};
+                    if (crate.max_version)
+                        results.push(`Version: ${crate.max_version}`);
+                    if (crate.description)
+                        results.push(crate.description);
+                }
+                results.push('');
+            }
+            catch {
+                results.push(`## ${pkg.name} (${pkg.registry})\nFetch failed\n`);
+            }
+        }
+        return { content: [{ type: 'text', text: results.join('\n') }] };
+    });
+    // ── Memory Health (NEW) ────────────────────────────────────────────
+    server.tool('memory_health', 'Check the health of project memory — total events, breakdown by type, stale memories, recent activity.', {}, async () => {
+        try {
+            const [profile, facts] = await Promise.allSettled([
+                client.projectProfile({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                }),
+                client.projectFacts({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                }),
+            ]);
+            const parts = ['# Memory Health Report'];
+            if (profile.status === 'fulfilled') {
+                const p = profile.value;
+                parts.push(`## Profile`);
+                parts.push(`Source events: ${p.source_event_count}`);
+                parts.push(`Event types: ${(p.source_event_types ?? []).join(', ')}`);
+            }
+            if (facts.status === 'fulfilled') {
+                const f = facts.value;
+                parts.push(`## Knowledge`);
+                parts.push(`Static facts: ${f.facts?.static?.length ?? 0}`);
+                parts.push(`Dynamic facts: ${f.facts?.dynamic?.length ?? 0}`);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Health check error: ${error}` }] };
+        }
+    });
+    // ── Code Advisor (NEW) ─────────────────────────────────────────────
+    server.tool('memoire_advisor', 'Analyze code against project memory (conventions, past attempts, facts) and get grounded recommendations with citations.', {
+        code: z.string().describe('The code snippet to analyze'),
+        question: z.string().optional().describe('Specific question about the code'),
+        language: z.string().optional().describe('Programming language (auto-detected if omitted)'),
+        focus: z.enum(['bugs', 'performance', 'patterns', 'security', 'general']).optional().describe('Analysis focus area'),
+    }, async ({ code, question, language, focus }) => {
+        try {
+            const response = await fetch(`${config.apiUrl}/v1/admin/advisor`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    org_id: config.orgId,
+                    project_id: config.projectId,
+                    viewer_user_id: config.userId,
+                    code,
+                    question,
+                    language,
+                    focus: focus ?? 'general',
+                }),
+            });
+            const data = await response.json();
+            const parts = ['# Code Advisor Report'];
+            if (data.recommendations) {
+                for (const rec of data.recommendations) {
+                    parts.push(`\n## [${rec.severity.toUpperCase()}] ${rec.title}`);
+                    parts.push(rec.description);
+                    if (rec.suggestion)
+                        parts.push(`**Suggestion:** ${rec.suggestion}`);
+                }
+            }
+            parts.push(`\n_Consulted ${data.context_used ?? 0} context items, ${data.citations?.length ?? 0} citations._`);
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Advisor error: ${error}` }] };
+        }
+    });
+    // ── Package Source Search (NEW) ─────────────────────────────────────
+    server.tool('package_source_search', 'Search the source code of an npm/PyPI package on-the-fly. Downloads, extracts, and searches package tarballs.', {
+        name: z.string().describe('Package name (e.g. "express", "fastapi")'),
+        version: z.string().describe('Package version (e.g. "4.18.2")'),
+        ecosystem: z.enum(['npm', 'pypi', 'crates']).describe('Package ecosystem'),
+        pattern: z.string().describe('Regex pattern to search for'),
+        max_results: z.number().optional().describe('Max results (default 50)'),
+    }, async ({ name, version, ecosystem, pattern, max_results }) => {
+        try {
+            const response = await fetch(`${config.apiUrl}/v1/admin/package/search`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name, version, ecosystem, pattern, max_results: max_results ?? 50 }),
+            });
+            const data = await response.json();
+            const parts = [`# Package Search: ${name}@${version}`];
+            parts.push(`Found ${data.results?.length ?? 0} matches in ${data.file_count ?? 0} files\n`);
+            for (const result of (data.results ?? []).slice(0, 20)) {
+                parts.push(`**${result.file}:${result.line}** — \`${result.match}\``);
+                parts.push(`  ${result.content}`);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Package search error: ${error}` }] };
+        }
+    });
+    // ── Package Source Browse (NEW) ─────────────────────────────────────
+    server.tool('package_source_browse', 'Browse the file tree of an npm/PyPI package.', {
+        name: z.string().describe('Package name'),
+        version: z.string().describe('Package version'),
+        ecosystem: z.enum(['npm', 'pypi', 'crates']).describe('Package ecosystem'),
+        path: z.string().optional().describe('Subdirectory to browse'),
+    }, async ({ name, version, ecosystem, path }) => {
+        try {
+            const response = await fetch(`${config.apiUrl}/v1/admin/package/browse`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name, version, ecosystem, path }),
+            });
+            const data = await response.json();
+            const parts = [`# ${name}@${version} — File Tree`];
+            for (const f of (data.files ?? [])) {
+                const icon = f.type === 'directory' ? '📁' : '📄';
+                parts.push(`${icon} ${f.path}${f.size ? ` (${f.size} bytes)` : ''}`);
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Browse error: ${error}` }] };
+        }
+    });
+    // ── Package Source Read (NEW) ──────────────────────────────────────
+    server.tool('package_source_read', 'Read a specific file from an npm/PyPI package source.', {
+        name: z.string().describe('Package name'),
+        version: z.string().describe('Package version'),
+        ecosystem: z.enum(['npm', 'pypi', 'crates']).describe('Package ecosystem'),
+        file_path: z.string().describe('File path within the package'),
+    }, async ({ name, version, ecosystem, file_path }) => {
+        try {
+            const response = await fetch(`${config.apiUrl}/v1/admin/package/read`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ name, version, ecosystem, file_path }),
+            });
+            const data = await response.json();
+            if (data.error) {
+                return { content: [{ type: 'text', text: `File not found: ${file_path}` }] };
+            }
+            return { content: [{ type: 'text', text: `# ${name}@${version} — ${file_path}\n\n\`\`\`\n${data.content}\n\`\`\`` }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Read error: ${error}` }] };
+        }
+    });
+    // ── Export Project (NEW) ──────────────────────────────────────────
+    server.tool('export_project', 'Export all project memory (events, facts) as a portable JSON bundle for backup or migration.', {}, async () => {
+        try {
+            const response = await fetch(`${config.apiUrl}/v1/admin/export`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ org_id: config.orgId, project_id: config.projectId }),
+            });
+            const data = await response.json();
+            return { content: [{ type: 'text', text: `# Export Complete\nEvents: ${data.metadata?.event_count ?? 0}\nFacts: ${data.metadata?.fact_count ?? 0}\nDate range: ${data.metadata?.date_range?.earliest ?? 'N/A'} to ${data.metadata?.date_range?.latest ?? 'N/A'}\n\nFull bundle returned as JSON (${JSON.stringify(data).length} bytes).` }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Export error: ${error}` }] };
+        }
+    });
+    // ── Usage Stats (NEW) ──────────────────────────────────────────────
+    server.tool('usage_stats', 'View current month API usage statistics for the organization.', {}, async () => {
+        try {
+            const response = await fetch(`${config.apiUrl}/v1/admin/usage`, {
+                method: 'POST',
+                headers: { 'Authorization': `Bearer ${config.apiKey}`, 'Content-Type': 'application/json' },
+                body: JSON.stringify({ org_id: config.orgId }),
+            });
+            const data = await response.json();
+            const parts = ['# Usage Statistics'];
+            parts.push(`Period: ${data.period ?? 'current'}\n`);
+            for (const item of (data.usage ?? [])) {
+                parts.push(`- **${item.operation}**: ${item.count}`);
+            }
+            if (!data.usage?.length)
+                parts.push('No usage recorded this period.');
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Usage error: ${error}` }] };
+        }
+    });
+    // ── Sync Cursor Rules ───────────────────────────────────────────────
+    server.tool('sync_cursor_rules', 'Write project context to .cursor/rules/ for auto-injection into every Cursor conversation. Requires workspace_path.', {
+        workspace_path: z.string().describe('Absolute path to the workspace root directory'),
+        project_name: z.string().optional().describe('Human-readable project name'),
+    }, async ({ workspace_path, project_name }) => {
+        try {
+            // Fetch profile from API
+            const profileResp = await client.projectProfile({
+                org_id: config.orgId,
+                project_id: config.projectId,
+                viewer_user_id: config.userId,
+            });
+            const pp = profileResp?.project_profile;
+            // Build .cursor/rules/memoire-context.mdc content
+            const sections = [];
+            sections.push(`---\nalwaysApply: true\ndescription: "Memoire shared memory context for ${project_name ?? 'Project'} (auto-updated)"\n---`);
+            sections.push(`# Memoire Context: ${project_name ?? 'Project'}`);
+            sections.push('> Auto-generated by Memoire. Use MCP tools for deeper queries.\n');
+            if (pp) {
+                sections.push('## Project Profile');
+                if (pp.architecture?.length)
+                    sections.push(`**Architecture:** ${pp.architecture.join(', ')}`);
+                if (pp.conventions?.length) {
+                    sections.push('**Conventions:**');
+                    for (const c of pp.conventions.slice(0, 10))
+                        sections.push(`- ${c}`);
+                }
+                if (pp.current_focus?.length)
+                    sections.push(`**Current Focus:** ${pp.current_focus.join(', ')}`);
+                if (pp.key_files?.length)
+                    sections.push(`**Key Files:** ${pp.key_files.slice(0, 5).join(', ')}`);
+                if (pp.summary) {
+                    sections.push('\n## Summary');
+                    sections.push(pp.summary);
+                }
+                sections.push('');
+            }
+            sections.push('---');
+            sections.push(`*Use Memoire MCP tools (search_context, project_profile, oracle_research) for detailed queries.*`);
+            sections.push(`*API: ${config.apiUrl}*`);
+            const content = sections.join('\n');
+            // Atomic write to .cursor/rules/
+            const fs = await import('node:fs');
+            const path = await import('node:path');
+            const rulesDir = path.join(workspace_path, '.cursor', 'rules');
+            const rulesFile = path.join(rulesDir, 'memoire-context.mdc');
+            const tempFile = `${rulesFile}.tmp`;
+            if (!fs.existsSync(rulesDir))
+                fs.mkdirSync(rulesDir, { recursive: true });
+            fs.writeFileSync(tempFile, content, 'utf-8');
+            fs.renameSync(tempFile, rulesFile);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `✅ Cursor rules written to ${workspace_path}/.cursor/rules/memoire-context.mdc\n` +
+                            `Includes project profile with ${pp?.conventions?.length ?? 0} conventions.\n` +
+                            `Context will be auto-injected into every Cursor conversation.`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to sync cursor rules: ${error}` }] };
+        }
+    });
+    // ─── AST Code Analysis Tools ────────────────────────────────────────────
+    // ── Run Tests (Sandbox) ──────────────────────────────────────────────
+    server.tool('run_tests', 'Run your project\'s test suite locally. Auto-detects framework (Vitest, Jest, Pytest, Go, Cargo) and returns structured results with failure details.', {
+        working_dir: z.string().describe('Absolute path to the project root'),
+        test_command: z.string().optional().describe('Override test command (e.g. "npm test", "pytest -x")'),
+        scope: z.enum(['all', 'affected']).optional().describe('Run all tests or only affected'),
+        timeout_ms: z.number().optional().describe('Timeout in milliseconds (default 300000)'),
+        env_vars: z.record(z.string()).optional().describe('Extra environment variables'),
+    }, async ({ working_dir, test_command, scope, timeout_ms, env_vars }) => {
+        try {
+            const res = await client.runTests({
+                org_id: config.orgId,
+                project_id: config.projectId,
+                working_dir,
+                test_command,
+                scope,
+                timeout_ms,
+                env_vars,
+            });
+            const r = res.result;
+            const statusIcon = r.status === 'pass' ? '✅' : r.status === 'fail' ? '❌' : r.status === 'timeout' ? '⏱️' : '⚠️';
+            const parts = [
+                `${statusIcon} **${r.status.toUpperCase()}** — ${r.summary}`,
+                `Total: ${r.total} | Passed: ${r.passed} | Failed: ${r.failed} | Skipped: ${r.skipped}`,
+                `Duration: ${(r.duration_ms / 1000).toFixed(1)}s`,
+            ];
+            if (r.failures.length > 0) {
+                parts.push('\n## Failures\n');
+                for (const f of r.failures.slice(0, 10)) {
+                    parts.push(`### ${f.test_name}${f.file ? ` (${f.file}${f.line ? `:${f.line}` : ''})` : ''}`);
+                    parts.push('```');
+                    parts.push(f.error.slice(0, 500));
+                    parts.push('```\n');
+                }
+            }
+            if (r.log && r.failures.length === 0 && r.status !== 'pass') {
+                parts.push('\n## Log Output\n```\n' + r.log.slice(0, 2000) + '\n```');
+            }
+            return { content: [{ type: 'text', text: parts.join('\n') }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Test run failed: ${error}` }] };
+        }
+    });
+    // ── Record Demo (Sandbox) ──────────────────────────────────────────
+    server.tool('record_demo', 'Record a video demo of your web app running locally. Starts your dev server, navigates pages, and captures a video recording. Runs async — returns a job ID to check later.', {
+        working_dir: z.string().optional().describe('Project root to run the start command from'),
+        start_command: z.string().describe('Command to start the dev server (e.g. "npm run dev")'),
+        url: z.string().describe('URL of the running app (e.g. "http://localhost:3000")'),
+        flows: z.array(z.object({
+            action: z.enum(['navigate', 'click', 'fill', 'wait', 'screenshot', 'scroll']),
+            url: z.string().optional(),
+            selector: z.string().optional(),
+            value: z.string().optional(),
+            ms: z.number().optional(),
+            name: z.string().optional(),
+            direction: z.enum(['up', 'down']).optional(),
+            amount: z.number().optional(),
+        })).optional().describe('Actions to perform during recording'),
+        auto_explore: z.boolean().optional().describe('Auto-discover and visit internal links'),
+        duration_ms: z.number().optional().describe('Max recording duration (default 120000)'),
+        viewport: z.object({ width: z.number(), height: z.number() }).optional().describe('Browser viewport size'),
+    }, async ({ working_dir, start_command, url, flows, auto_explore, duration_ms, viewport }) => {
+        try {
+            const res = await client.recordDemo({
+                org_id: config.orgId,
+                project_id: config.projectId,
+                working_dir,
+                start_command,
+                url,
+                flows: flows,
+                auto_explore,
+                duration_ms,
+                viewport,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: `🎬 Demo recording started!\n\nJob ID: \`${res.job_id}\`\nStatus: ${res.status}\n\nUse \`demo_status\` tool with this job ID to check when the recording is ready.`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Demo recording failed to start: ${error}` }] };
+        }
+    });
+    // ── Demo Status ────────────────────────────────────────────────────
+    server.tool('demo_status', 'Check the status of an async demo recording job.', {
+        job_id: z.string().describe('Job ID returned by record_demo'),
+    }, async ({ job_id }) => {
+        try {
+            const res = await client.demoStatus(job_id);
+            if (res.status === 'complete') {
+                const parts = [
+                    `✅ Demo recording complete!`,
+                    `Duration: ${((res.duration_ms ?? 0) / 1000).toFixed(1)}s`,
+                ];
+                if (res.recording_path)
+                    parts.push(`Video: ${res.recording_path}`);
+                if (res.pages_visited?.length)
+                    parts.push(`Pages visited: ${res.pages_visited.join(', ')}`);
+                if (res.screenshots?.length)
+                    parts.push(`Screenshots: ${res.screenshots.length} captured`);
+                if (res.expires_at && !res.retained)
+                    parts.push(`Auto-deletes at: ${res.expires_at}`);
+                if (res.retained)
+                    parts.push('Demo files are marked to keep.');
+                return { content: [{ type: 'text', text: parts.join('\n') }] };
+            }
+            if (res.status === 'failed') {
+                return { content: [{ type: 'text', text: `❌ Demo recording failed: ${res.error ?? 'Unknown error'}` }] };
+            }
+            if (res.status === 'expired') {
+                return { content: [{ type: 'text', text: `🧹 Demo expired: ${res.error ?? 'Result has been deleted after 24 hours.'}` }] };
+            }
+            return { content: [{ type: 'text', text: `⏳ Demo recording still in progress (job: ${job_id})` }] };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to check demo status: ${error}` }] };
+        }
+    });
+    server.tool('keep_demo', 'Prevent a completed demo recording from auto-deleting after 24 hours.', {
+        job_id: z.string().describe('Job ID returned by record_demo'),
+    }, async ({ job_id }) => {
+        try {
+            const res = await client.keepDemo(job_id);
+            if (res.status === 'expired') {
+                return { content: [{ type: 'text', text: `Demo not found: ${res.error ?? 'It may already be deleted.'}` }] };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `📌 Demo ${job_id} will be kept.${res.recording_path ? `\nVideo: ${res.recording_path}` : ''}`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to keep demo: ${error}` }] };
+        }
+    });
+    // ── GitHub Code Search ───────────────────────────────────────────────
+    server.tool('search_github', 'Search GitHub repos for code. No pre-indexing required — give it a question and repo names, it searches live. Great for referencing external codebases, libraries, or open-source projects.', {
+        repos: z.array(z.string()).min(1).max(10).describe('GitHub repos to search (e.g. ["vercel/next.js", "facebook/react"])'),
+        query: z.string().describe('What to search for — can be a question or code pattern'),
+        language: z.string().optional().describe('Filter by language (e.g. "typescript", "python")'),
+        path_filter: z.string().optional().describe('Filter by path prefix (e.g. "src/", "lib/")'),
+        max_results: z.number().optional().describe('Max results (default 10)'),
+    }, async ({ repos, query, language, path_filter, max_results }) => {
+        try {
+            const res = await client.searchGitHub({
+                org_id: config.orgId,
+                repos,
+                query,
+                language,
+                path_filter,
+                max_results: max_results ?? 10,
+            });
+            if (res.error) {
+                return { content: [{ type: 'text', text: res.error }] };
+            }
+            if (!res.results || res.results.length === 0) {
+                return { content: [{ type: 'text', text: `No results found for "${query}" in ${repos.join(', ')}` }] };
+            }
+            const text = res.results
+                .map((r, i) => `### ${i + 1}. ${r.repo}/${r.path}${r.language ? ` (${r.language})` : ''}\n` +
+                `${r.url}\n\`\`\`\n${r.content.slice(0, 1500)}\n\`\`\``)
+                .join('\n\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Found ${res.total} results for "${query}" across ${repos.join(', ')}:\n\n${text}`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `GitHub search failed: ${error}` }] };
+        }
+    });
+    server.tool('smart_outline', 'Get structural outline of a file (functions, classes, types). 6-10x cheaper than reading the full file.', { file_path: z.string().describe('Absolute path to the file to outline') }, async ({ file_path }) => {
+        try {
+            const { parseFile, formatOutline } = await import('./ast-parser-inline.js');
+            const fs = await import('node:fs');
+            const content = fs.readFileSync(file_path, 'utf-8');
+            const outline = parseFile(content, file_path);
+            const text = formatOutline(file_path, outline.language, outline.totalLines, outline.imports, outline.symbols);
+            return {
+                content: [{
+                        type: 'text',
+                        text: `${text}\n\n📊 ${outline.symbols.length} symbols, ~${outline.foldedTokenEstimate} tokens (vs ~${Math.ceil(content.length / 4)} for full file)`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Failed to outline: ${error}` }] };
+        }
+    });
+    server.tool('smart_search', 'Search for code symbols (functions, classes, types) across a codebase by name. Returns ranked results with context.', {
+        query: z.string().describe('Symbol name or pattern to search for'),
+        root_dir: z.string().describe('Root directory to search in'),
+        max_results: z.number().optional().default(15).describe('Max results to return'),
+        kind: z.string().optional().describe('Filter by kind: function, class, method, interface, type, enum'),
+    }, async ({ query, root_dir, max_results, kind }) => {
+        try {
+            const { smartSearch } = await import('./ast-parser-inline.js');
+            const results = smartSearch({
+                query,
+                rootDir: root_dir,
+                maxResults: max_results,
+                kind: kind,
+            });
+            if (results.length === 0) {
+                return { content: [{ type: 'text', text: `No symbols found matching "${query}"` }] };
+            }
+            const text = results.map((r, i) => `${i + 1}. ${r.symbol.kind} **${r.symbol.name}** (score: ${r.score.toFixed(1)})\n` +
+                `   📁 ${r.filePath} L${r.symbol.lineStart}-${r.symbol.lineEnd}\n` +
+                `   ${r.context ?? r.symbol.signature}`).join('\n\n');
+            return {
+                content: [{
+                        type: 'text',
+                        text: `Found ${results.length} symbols matching "${query}":\n\n${text}`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Search failed: ${error}` }] };
+        }
+    });
+    server.tool('smart_unfold', 'Expand a specific symbol to see its full source code with context. 4-8x cheaper than reading the full file.', {
+        file_path: z.string().describe('Absolute path to the file'),
+        symbol_name: z.string().describe('Name of the symbol to unfold'),
+    }, async ({ file_path, symbol_name }) => {
+        try {
+            const { smartUnfold } = await import('./ast-parser-inline.js');
+            const result = smartUnfold(file_path, symbol_name);
+            if (!result) {
+                return { content: [{ type: 'text', text: `Symbol "${symbol_name}" not found in ${file_path}` }] };
+            }
+            return {
+                content: [{
+                        type: 'text',
+                        text: `${result.source}\n\n📊 ${result.kind} "${result.symbolName}" (${result.tokenEstimate} tokens)`,
+                    }],
+            };
+        }
+        catch (error) {
+            return { content: [{ type: 'text', text: `Unfold failed: ${error}` }] };
+        }
+    });
+    // ── Rate Memory (Feedback) ─────────────────────────────────────────
+    server.tool('rate_memory', 'Rate a retrieved memory as helpful or unhelpful. Feedback improves search ranking and memory lifecycle — downvoted memories decay faster, upvoted memories get boosted. Team-shared: one agent\'s rating benefits all agents.', {
+        event_id: z.string().describe('ID of the memory event to rate'),
+        rating: z.union([z.literal(1), z.literal(-1)]).describe('+1 (helpful) or -1 (unhelpful)'),
+        label: z.enum([
+            'helpful', 'accurate', 'well-structured', 'good-examples',
+            'outdated', 'inaccurate', 'incomplete', 'superseded',
+            'poorly-structured', 'wrong-examples', 'wrong-version',
+        ]).optional().describe('Structured feedback label'),
+        note: z.string().optional().describe('Optional annotation explaining the rating'),
+    }, async ({ event_id, rating, label, note }) => {
+        const res = await client.rateFeedback({
+            org_id: config.orgId,
+            project_id: config.projectId,
+            event_id,
+            user_id: config.userId,
+            rating,
+            label,
+            note,
+        });
+        const emoji = rating > 0 ? '+1' : '-1';
+        const labelStr = label ? ` [${label}]` : '';
+        const noteStr = note ? ` — "${note}"` : '';
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Rated memory ${event_id}: ${emoji}${labelStr}${noteStr}\nAggregate score: ${res.feedback_score}`,
+                }],
+        };
+    });
+    return server;
+}
+export async function runMemoireStdioServer(config, deps) {
+    const server = createMemoireMcpServer(config, deps);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Memoire MCP server running on stdio');
+    return server;
+}
+function appendProfileSection(target, title, items) {
+    if (items.length === 0) {
+        return;
+    }
+    target.push(`## ${title}\n${items.map((item) => `- ${item}`).join('\n')}`);
+}
+function appendFactSection(target, title, items) {
+    if (items.length === 0) {
+        return;
+    }
+    target.push(`## ${title}\n${items.map((item) => `- ${item}`).join('\n')}`);
+}
+//# sourceMappingURL=index.js.map