@splicr/mcp-server 0.9.5 → 0.10.1

package/dist/cli.js

@@ -273,9 +273,13 @@ async function setup() {
     injectClaudeMd();
     injectClaudeHook();
     if (configured > 0) {
-        console.error(`\n  Done! Splicr is connected to ${configured} agent(s).`);
-        console.error('  Start a new session in any agent to use it.');
-        console.error('  Save articles from your phone or browser — they\'ll show up when you code.\n');
+        console.error(`\n  Done! Splicr is connected to ${configured} agent(s).\n`);
+        console.error('  Start saving knowledge — it\'ll show up when you code:\n');
+        console.error('    Telegram    t.me/SplicrBot — save links and text from your phone');
+        console.error('    Extension   chrome.google.com/webstore (search "Splicr") — save from browser');
+        console.error('    Agent       your coding agent can save with save_from_agent tool');
+        console.error('    Dashboard   splicr.dev/dashboard — view everything you\'ve saved\n');
+        console.error('  Start a new session in any agent to begin.\n');
     }
     else {
         console.error('\n  Could not auto-configure any agents. Add manually:\n');
@@ -1105,8 +1109,12 @@ function printHelp() {
 
   Quick start:
     1. Run: npx @splicr/mcp-server setup
-    2. Start saving articles from your phone or browser
+    2. Save knowledge from anywhere:
+       - Telegram: t.me/SplicrBot (send links from your phone)
+       - Browser: Chrome Web Store (search "Splicr")
+       - Agent: save_from_agent tool (agents save learnings)
     3. Open any coding agent — your saves show up when relevant
+    4. Dashboard: splicr.dev/dashboard
 `);
 }
 main().catch(err => {

package/dist/index.js

@@ -11,6 +11,8 @@ import { getFullContentSchema, handleGetFullContent } from './tools/get-full-con
 import { getRelevantContextSchema, handleGetRelevantContext } from './tools/get-relevant-context.js';
 import { browseProjectSchema, handleBrowseProject } from './tools/browse-project.js';
 import { getCompiledPageSchema, handleGetCompiledPage } from './tools/get-compiled-page.js';
+import { grepKnowledgeSchema, handleGrepKnowledge } from './tools/grep-knowledge.js';
+import { exploreKnowledgeSchema, handleExploreKnowledge } from './tools/explore-knowledge.js';
 import { completeSession } from './lib/api-client.js';
 // Prevent unhandled errors from crashing the MCP server
 process.on('uncaughtException', (err) => {
@@ -57,6 +59,8 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         getRelevantContextSchema,
         browseProjectSchema,
         getCompiledPageSchema,
+        grepKnowledgeSchema,
+        exploreKnowledgeSchema,
     ],
 }));
 // Handle tool calls with per-tool timeout
@@ -73,6 +77,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             get_relevant_context: handleGetRelevantContext,
             browse_project: handleBrowseProject,
             get_compiled_page: handleGetCompiledPage,
+            grep_knowledge: handleGrepKnowledge,
+            explore_knowledge: handleExploreKnowledge,
         }[name];
         if (!handler) {
             return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };

package/dist/lib/api-client.d.ts

@@ -25,6 +25,7 @@ export declare function saveFromAgent(params: {
     title: string;
     project_name?: string;
     tags?: string[];
+    memory_type?: string;
     context?: Record<string, unknown>;
 }): Promise<{
     id: string;
@@ -82,6 +83,30 @@ export declare function getCompiledPage(params: {
     version: number;
     last_compiled_at: string;
 } | null>;
+export declare function grepKnowledge(params: {
+    pattern: string;
+    project_name?: string;
+    limit?: number;
+    case_sensitive?: boolean;
+    fields?: ('title' | 'insight' | 'content')[];
+}): Promise<{
+    results: any[];
+    pattern: string;
+    match_count: number;
+}>;
+export declare function exploreKnowledge(): Promise<{
+    projects: Array<{
+        id: string;
+        name: string;
+        capture_count: number;
+        categories: Record<string, number>;
+        source_types: Record<string, number>;
+        latest_at: string | null;
+    }>;
+    unrouted_count: number;
+    total_count: number;
+    memory_types: Record<string, number>;
+}>;
 export declare function retryFailed(): Promise<{
     retried: number;
     message: string;

package/dist/lib/api-client.js

@@ -81,6 +81,12 @@ export async function getFullContent(params) {
 export async function getCompiledPage(params) {
     return await apiRequest('GET', `/mcp/compiled/${params.id}`);
 }
+export async function grepKnowledge(params) {
+    return await apiRequest('POST', '/mcp/grep', params);
+}
+export async function exploreKnowledge() {
+    return await apiRequest('GET', '/mcp/explore');
+}
 export async function retryFailed() {
     return await apiRequest('POST', '/captures/retry-failed', {});
 }

package/dist/tools/browse-project.js

@@ -21,7 +21,7 @@ Use get_full_content(id) on any item to read the complete content.`,
             },
             source_type: {
                 type: 'string',
-                description: 'Filter by source: tweet, thread, article, youtube, agent, highlight, manual',
+                description: 'Filter by source: tweet, thread, article, youtube, agent, highlight, manual. Tip: use source_type="agent" to see only agent-saved memories.',
             },
             offset: { type: 'number', description: 'Skip first N results for pagination (default: 0)' },
             limit: { type: 'number', description: 'Max results (default: 20, max: 50)' },

package/dist/tools/explore-knowledge.d.ts

@@ -0,0 +1,9 @@
+export declare const exploreKnowledgeSchema: {
+    name: "explore_knowledge";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {};
+    };
+};
+export declare function handleExploreKnowledge(_args: Record<string, unknown>): Promise<string>;

package/dist/tools/explore-knowledge.js

@@ -0,0 +1,72 @@
+import { exploreKnowledge } from '../lib/api-client.js';
+import * as session from '../lib/session-state.js';
+export const exploreKnowledgeSchema = {
+    name: 'explore_knowledge',
+    description: `Browse the user's knowledge base as a tree structure. Returns a hierarchical view: projects with their capture counts, category breakdowns, source type distributions, and memory type stats.
+
+WHEN TO USE:
+- You want an overview of the entire knowledge base before diving in
+- You need to understand what projects exist and how much knowledge each has
+- You want to discover which categories or source types dominate
+- You're deciding which project or area to search/browse next
+
+This is a lightweight overview call - no content is returned, just structure and counts. Follow up with browse_project, search_knowledge, or grep_knowledge to explore specific areas.`,
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+export async function handleExploreKnowledge(_args) {
+    const tree = await exploreKnowledge();
+    session.recordToolCall();
+    if (tree.total_count === 0) {
+        return 'Knowledge base is empty. Save content from the browser extension, Telegram bot, or using save_from_agent.';
+    }
+    // Format project tree
+    const projectLines = tree.projects.map((p) => {
+        const cats = Object.entries(p.categories)
+            .sort((a, b) => b[1] - a[1])
+            .map(([cat, count]) => `${cat} (${count})`)
+            .join(', ');
+        const sources = Object.entries(p.source_types)
+            .sort((a, b) => b[1] - a[1])
+            .map(([src, count]) => `${src} (${count})`)
+            .join(', ');
+        const age = p.latest_at ? formatAge(p.latest_at) : 'never';
+        return `  **${p.name}/** - ${p.capture_count} captures (latest: ${age})\n` +
+            (cats ? `    categories: ${cats}\n` : '') +
+            (sources ? `    sources: ${sources}` : '');
+    }).join('\n\n');
+    // Format memory types if any
+    const memoryLine = Object.keys(tree.memory_types).length > 0
+        ? `\n\n**Memory types:** ${Object.entries(tree.memory_types).map(([t, c]) => `${t} (${c})`).join(', ')}`
+        : '';
+    let output = `*Knowledge Base - ${tree.total_count} total captures*\n\n`;
+    output += `**projects/**\n`;
+    if (projectLines) {
+        output += `${projectLines}\n`;
+    }
+    output += `\n**unrouted/** - ${tree.unrouted_count} captures`;
+    output += memoryLine;
+    output += '\n\n---\n*Use browse_project(project) to list captures, search_knowledge(query) for semantic search, or grep_knowledge(pattern) for exact matches.*';
+    return output;
+}
+function formatAge(dateStr) {
+    const date = new Date(dateStr);
+    if (isNaN(date.getTime()))
+        return 'unknown';
+    const days = Math.floor((Date.now() - date.getTime()) / 86400000);
+    if (days < 0)
+        return 'just now';
+    if (days === 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)}mo ago`;
+    return `${Math.floor(days / 365)}y ago`;
+}

package/dist/tools/grep-knowledge.d.ts

@@ -0,0 +1,31 @@
+export declare const grepKnowledgeSchema: {
+    name: "grep_knowledge";
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pattern: {
+                type: "string";
+                description: string;
+            };
+            project: {
+                type: "string";
+                description: string;
+            };
+            limit: {
+                type: "number";
+                description: string;
+            };
+            fields: {
+                type: "array";
+                items: {
+                    type: "string";
+                    enum: string[];
+                };
+                description: string;
+            };
+        };
+        required: "pattern"[];
+    };
+};
+export declare function handleGrepKnowledge(args: Record<string, unknown>): Promise<string>;

package/dist/tools/grep-knowledge.js

@@ -0,0 +1,93 @@
+import { grepKnowledge } from '../lib/api-client.js';
+import { detectProject } from '../lib/project-detector.js';
+import * as session from '../lib/session-state.js';
+export const grepKnowledgeSchema = {
+    name: 'grep_knowledge',
+    description: `Exact text/pattern search across the user's knowledge base. Unlike search_knowledge (which uses semantic/embedding search), grep finds exact string matches in titles, insights, and full content.
+
+WHEN TO USE (instead of search_knowledge):
+- You need an exact string match ("pgvector", "useEffect", a specific error code)
+- Semantic search returned irrelevant results and you want precision
+- You're looking for a specific code pattern, API name, or technical term
+
+Supports case-insensitive matching by default. Scope to specific fields (title, insight, content) for faster, more targeted results.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pattern: { type: 'string', description: 'Exact text pattern to search for (e.g. "pgvector", "JWT refresh", "ECONNREFUSED")' },
+            project: { type: 'string', description: 'Scope to a specific project name, or "auto" to detect from cwd. Omit to search all.' },
+            limit: { type: 'number', description: 'Max results (default: 10)' },
+            fields: {
+                type: 'array',
+                items: { type: 'string', enum: ['title', 'insight', 'content'] },
+                description: 'Which fields to search (default: all three). Use ["title", "insight"] for faster searches.',
+            },
+        },
+        required: ['pattern'],
+    },
+};
+export async function handleGrepKnowledge(args) {
+    const pattern = String(args.pattern || '').trim();
+    if (!pattern)
+        return 'Please provide a search pattern.';
+    if (pattern.length > 500)
+        return 'Pattern too long (max 500 chars).';
+    const limit = Math.min(Math.max(1, Number(args.limit) || 10), 50);
+    const fields = args.fields;
+    const projectArg = args.project;
+    let projectName;
+    if (projectArg === 'auto') {
+        const detected = await detectProject(process.cwd());
+        projectName = detected?.name;
+    }
+    else if (projectArg) {
+        projectName = projectArg;
+    }
+    const data = await grepKnowledge({
+        pattern,
+        project_name: projectName,
+        limit,
+        fields,
+    });
+    session.recordToolCall();
+    session.recordSearch();
+    if (!data.results || data.results.length === 0) {
+        return `No matches for "${pattern}" in Splicr. Try search_knowledge for semantic/fuzzy search.`;
+    }
+    session.addContextServed(data.results.map((r) => r.id).filter(Boolean));
+    const formatted = data.results.map((r, i) => {
+        const age = formatAge(r.created_at);
+        const projects = r.projects?.length > 0 ? ` -> ${r.projects.join(', ')}` : '';
+        const clusterTag = r.cluster?.name
+            ? `\n   cluster: "${r.cluster.name}" (${r.cluster.member_count - 1} more)`
+            : '';
+        const compiledTag = r.compiled_page
+            ? `\n   compiled: "${r.compiled_page.title}" - call get_compiled_page("${r.compiled_page.id}")`
+            : '';
+        return `${i + 1}. **${r.title || 'Untitled'}**\n` +
+            `   ${r.insight ? r.insight.substring(0, 150) : 'No insight'}\n` +
+            `   ${r.source_type || 'unknown'} | ${age} | tags: ${r.tags?.join(', ') || 'none'}${projects}` +
+            clusterTag + compiledTag +
+            `\n   id: ${r.id}`;
+    }).join('\n\n');
+    return `*Grep "${pattern}" - ${data.match_count} match(es):*\n\n${formatted}\n\n*Call get_full_content(id) to read the complete content.*`;
+}
+function formatAge(dateStr) {
+    const date = new Date(dateStr);
+    if (isNaN(date.getTime()))
+        return 'unknown';
+    const days = Math.floor((Date.now() - date.getTime()) / 86400000);
+    if (days < 0)
+        return 'just now';
+    if (days === 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    if (days < 365)
+        return `${Math.floor(days / 30)}mo ago`;
+    return `${Math.floor(days / 365)}y ago`;
+}

package/dist/tools/save-from-agent.d.ts

@@ -23,6 +23,11 @@ export declare const saveFromAgentSchema: {
                 };
                 description: string;
             };
+            memory_type: {
+                type: "string";
+                enum: string[];
+                description: string;
+            };
             context: {
                 type: "object";
                 description: string;
@@ -56,7 +61,7 @@ export declare const saveFromAgentSchema: {
                 };
             };
         };
-        required: ("content" | "title")[];
+        required: ("title" | "content")[];
     };
 };
 export declare function handleSaveFromAgent(args: Record<string, unknown>): Promise<string>;

package/dist/tools/save-from-agent.js

@@ -10,6 +10,12 @@ export const saveFromAgentSchema = {
 
 For auto-save at session end, include the "context" field with attribution metadata.
 
+**Memory types** (use memory_type to categorize):
+- "fact" — permanent knowledge (API uses X pattern, team decided Y). Default if omitted.
+- "procedural" — reusable how-to (deploy steps, workarounds, setup instructions)
+- "episodic" — session-level context (what happened this session, investigation results)
+- "scratchpad" — short-lived working memory (temp notes, in-progress thinking)
+
 What to save: decisions (chose X over Y because...), discoveries (found undocumented behavior), workarounds (non-obvious fix), synthesis (combined multiple insights).
 What NOT to save: file edits (git has those), routine commands, anything derivable from reading the code.`,
     inputSchema: {
@@ -19,6 +25,11 @@ What NOT to save: file edits (git has those), routine commands, anything derivab
             title: { type: 'string', description: 'Short title' },
             project: { type: 'string', description: 'Project name, "auto", or "all"' },
             tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+            memory_type: {
+                type: 'string',
+                enum: ['fact', 'procedural', 'episodic', 'scratchpad'],
+                description: 'Memory type: fact (permanent), procedural (how-to), episodic (session), scratchpad (temp). Default: fact.',
+            },
             context: {
                 type: 'object',
                 description: 'Attribution context for agent learnings',
@@ -39,6 +50,7 @@ export async function handleSaveFromAgent(args) {
     const title = args.title;
     const projectArg = args.project;
     const tags = args.tags || [];
+    const memoryType = args.memory_type || 'fact';
     const context = args.context;
     // Resolve project name
     let projectName;
@@ -54,6 +66,7 @@ export async function handleSaveFromAgent(args) {
         title,
         project_name: projectName,
         tags,
+        memory_type: memoryType,
         context,
     });
     if (result.duplicate) {
@@ -62,5 +75,6 @@ export async function handleSaveFromAgent(args) {
     session.recordToolCall();
     session.recordSave();
     const typeLabel = context?.decision_type ? ` [${context.decision_type}]` : '';
-    return `*Saved to Splicr:* "${title}"${typeLabel}${result.project_name ? ` → routed to ${result.project_name}` : ''}`;
+    const memLabel = memoryType !== 'fact' ? ` (${memoryType})` : '';
+    return `*Saved to Splicr:* "${title}"${typeLabel}${memLabel}${result.project_name ? ` → routed to ${result.project_name}` : ''}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splicr/mcp-server",
-  "version": "0.9.5",
+  "version": "0.10.1",
   "description": "Splicr MCP server — route what you read to what you're building",
   "type": "module",
   "bin": "./dist/cli.js",