@splicr/mcp-server 0.13.1 → 0.14.0

package/dist/cli.js

@@ -10,7 +10,7 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { execSync } from 'child_process';
 import { homedir } from 'os';
-import { join } from 'path';
+import { join, basename } from 'path';
 const command = process.argv[2];
 const subCommand = process.argv[3];
 // Parse --join flag from any position
@@ -195,6 +195,9 @@ async function main() {
         case 'stop':
             await runStop();
             break;
+        case 'index':
+            await runIndex();
+            break;
         case 'dashboard':
         case 'open': {
             const url = 'https://splicr.dev/dashboard';
@@ -1142,6 +1145,190 @@ function printManualConfig() {
     console.error('    }');
     console.error('  }\n');
 }
+// ─── splicr index ───
+async function runIndex() {
+    const target = process.argv[3];
+    if (!target) {
+        console.error('Usage: splicr index <path-or-url>');
+        console.error('  splicr index ./docs/             Index all supported files in directory');
+        console.error('  splicr index ./api.yaml           Index a single file');
+        console.error('  splicr index https://example.com  Index a URL');
+        process.exit(1);
+    }
+    const { hasAuth } = await import('./auth.js');
+    if (!hasAuth()) {
+        console.error('Not authenticated. Run: splicr setup');
+        process.exit(1);
+    }
+    // Detect project for routing
+    const { detectProject } = await import('./lib/project-detector.js');
+    const project = await detectProject(process.cwd()).catch(() => null);
+    const projectName = project?.name;
+    if (projectName) {
+        console.error(`Project: ${projectName}`);
+    }
+    // URL?
+    if (target.startsWith('http://') || target.startsWith('https://')) {
+        await indexUrl(target, projectName);
+        return;
+    }
+    // File or directory
+    const { resolve } = await import('path');
+    const { statSync } = await import('fs');
+    const resolved = resolve(process.cwd(), target);
+    let stat;
+    try {
+        stat = statSync(resolved);
+    }
+    catch {
+        console.error(`Not found: ${resolved}`);
+        process.exit(1);
+    }
+    if (stat.isDirectory()) {
+        await indexDirectory(resolved, projectName);
+    }
+    else {
+        const result = await indexSingleFile(resolved, projectName);
+        if (result) {
+            console.error(`\nDone: 1 ${result}`);
+        }
+    }
+}
+function findGitRoot(startPath) {
+    try {
+        return execSync('git rev-parse --show-toplevel', {
+            cwd: startPath,
+            encoding: 'utf-8',
+            timeout: 2000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+async function indexSingleFile(filePath, projectName) {
+    const { parseFile } = await import('./lib/file-parser.js');
+    const { indexFile } = await import('./lib/api-client.js');
+    const { normalizePath } = await import('./lib/project-detector.js');
+    const { relative, dirname } = await import('path');
+    let parsed;
+    try {
+        parsed = parseFile(filePath);
+    }
+    catch (err) {
+        const short = basename(filePath);
+        console.error(`  x ${short} - ${err.message}`);
+        return null;
+    }
+    // Build source_url as file:// relative to git root
+    const gitRoot = findGitRoot(dirname(filePath)) || process.cwd();
+    const relPath = normalizePath(relative(gitRoot, filePath));
+    const sourceUrl = `file://${relPath}`;
+    const shortPath = relPath.length > 60 ? '...' + relPath.slice(-57) : relPath;
+    try {
+        const result = await indexFile({
+            content: parsed.content,
+            title: parsed.title,
+            source_url: sourceUrl,
+            file_type: parsed.file_type,
+            project_name: projectName,
+            tags: [...parsed.tags, 'indexed'],
+            content_category: parsed.content_category,
+            metadata: { word_count: parsed.word_count, file_type: parsed.file_type },
+        });
+        const status = result.status === 'updated' ? 'updated' : 'created';
+        console.error(`  ${status === 'updated' ? '~' : '+'} ${shortPath}`);
+        return status;
+    }
+    catch (err) {
+        console.error(`  x ${shortPath} - ${err.message}`);
+        return null;
+    }
+}
+async function indexDirectory(dirPath, projectName) {
+    const { readdirSync, statSync: fsStat } = await import('fs');
+    const { join: pathJoin } = await import('path');
+    const { isSupported, getExtension } = await import('./lib/file-parser.js');
+    const SKIP_DIRS = new Set([
+        'node_modules', '.git', 'dist', 'build', 'coverage',
+        '.next', '__pycache__', '.turbo', '.cache', '.expo',
+        'vendor', '.venv', 'venv', 'target', '.output',
+    ]);
+    const MAX_FILES = 50;
+    const files = [];
+    function walk(dir) {
+        if (files.length >= MAX_FILES)
+            return;
+        try {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (files.length >= MAX_FILES)
+                    return;
+                if (entry.name.startsWith('.'))
+                    continue;
+                const full = pathJoin(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (!SKIP_DIRS.has(entry.name))
+                        walk(full);
+                }
+                else if (isSupported(getExtension(entry.name))) {
+                    files.push(full);
+                }
+            }
+        }
+        catch { /* skip unreadable dirs */ }
+    }
+    walk(dirPath);
+    if (files.length === 0) {
+        console.error('No supported files found.');
+        return;
+    }
+    console.error(`Indexing ${files.length} file(s)${files.length >= MAX_FILES ? ` (capped at ${MAX_FILES})` : ''}...\n`);
+    let created = 0;
+    let updated = 0;
+    let failed = 0;
+    // Process with concurrency limit of 5
+    const CONCURRENCY = 5;
+    for (let i = 0; i < files.length; i += CONCURRENCY) {
+        const batch = files.slice(i, i + CONCURRENCY);
+        const results = await Promise.allSettled(batch.map(f => indexSingleFile(f, projectName)));
+        for (const r of results) {
+            if (r.status === 'fulfilled' && r.value) {
+                if (r.value === 'updated')
+                    updated++;
+                else
+                    created++;
+            }
+            else {
+                failed++;
+            }
+        }
+    }
+    console.error(`\nDone: ${created} indexed, ${updated} updated, ${failed} failed`);
+}
+async function indexUrl(url, projectName) {
+    const { saveFromAgent } = await import('./lib/api-client.js');
+    console.error(`Indexing URL: ${url}`);
+    try {
+        const result = await saveFromAgent({
+            content: url,
+            title: url,
+            project_name: projectName,
+            tags: ['indexed', 'url'],
+        });
+        if (result.duplicate) {
+            console.error('  ~ Already indexed');
+        }
+        else {
+            console.error(`  + Saved`);
+        }
+    }
+    catch (err) {
+        console.error(`  x Failed: ${err.message}`);
+        process.exit(1);
+    }
+}
 function printHelp() {
     console.error(`
   Splicr — route what you read to what you're building
@@ -1157,6 +1344,8 @@ function printHelp() {
     team list          List your teams
     team invite        Show invite link for your team
     team join <code>   Join a team by invite code
+    index <path>       Index local files into your knowledge base
+    index <dir>        Index all supported files in a directory
     dashboard          Open knowledge dashboard in browser
     uninstall          Remove Splicr from all coding agents
 

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

@@ -36,6 +36,20 @@ export declare function saveFromAgent(params: {
     project_name?: string;
     duplicate: boolean;
 }>;
+export declare function indexFile(params: {
+    content: string;
+    title: string;
+    source_url: string;
+    file_type?: string;
+    project_name?: string;
+    tags?: string[];
+    content_category?: string;
+    metadata?: Record<string, unknown>;
+}): Promise<{
+    id: string;
+    title: string;
+    status: 'created' | 'updated';
+}>;
 export declare function resolveProject(params: {
     local_path?: string;
     git_remote_url?: string;

package/dist/lib/api-client.js

@@ -58,6 +58,9 @@ export async function getRecentInsights(params) {
 export async function saveFromAgent(params) {
     return await apiRequest('POST', '/mcp/save', params);
 }
+export async function indexFile(params) {
+    return await apiRequest('POST', '/mcp/index', params);
+}
 export async function resolveProject(params) {
     return await apiRequest('POST', '/mcp/resolve-project', params);
 }

package/dist/lib/file-parser.d.ts

@@ -0,0 +1,11 @@
+export interface ParsedFile {
+    title: string;
+    content: string;
+    file_type: string;
+    content_category: string;
+    tags: string[];
+    word_count: number;
+}
+export declare function getExtension(filename: string): string;
+export declare function isSupported(ext: string): boolean;
+export declare function parseFile(filePath: string): ParsedFile;

package/dist/lib/file-parser.js

@@ -0,0 +1,329 @@
+import { readFileSync, statSync } from 'fs';
+import { basename, extname } from 'path';
+import yaml from 'js-yaml';
+const MAX_RAW_SIZE = 1024 * 1024; // 1MB
+const MAX_CONTENT_CHARS = 50_000;
+const MAX_OPENAPI_CHARS = 20_000;
+const MAX_CODE_CHARS = 10_000;
+const SUPPORTED_EXTENSIONS = new Set([
+    '.md', '.txt', '.rst', '.adoc',
+    '.yaml', '.yml', '.json',
+    '.ts', '.tsx', '.js', '.jsx',
+    '.py', '.go', '.rs', '.java',
+    '.css', '.scss',
+]);
+export function getExtension(filename) {
+    return extname(filename).toLowerCase();
+}
+export function isSupported(ext) {
+    return SUPPORTED_EXTENSIONS.has(ext);
+}
+export function parseFile(filePath) {
+    const stat = statSync(filePath);
+    if (stat.size > MAX_RAW_SIZE) {
+        throw new Error(`File too large (${(stat.size / 1024).toFixed(0)}KB > 1MB limit)`);
+    }
+    const raw = readFileSync(filePath, 'utf-8');
+    const filename = basename(filePath);
+    const ext = getExtension(filename);
+    switch (ext) {
+        case '.md':
+        case '.rst':
+        case '.adoc':
+            return parseMarkdown(raw, filename);
+        case '.txt':
+            return parseText(raw, filename);
+        case '.yaml':
+        case '.yml':
+            return parseYamlOrOpenApi(raw, filename);
+        case '.json':
+            return parseJson(raw, filename);
+        case '.ts':
+        case '.tsx':
+        case '.js':
+        case '.jsx':
+            return parseCodeSurface(raw, filename, 'typescript');
+        case '.py':
+            return parseCodeSurface(raw, filename, 'python');
+        case '.go':
+            return parseCodeSurface(raw, filename, 'go');
+        case '.rs':
+            return parseCodeSurface(raw, filename, 'rust');
+        case '.java':
+            return parseCodeSurface(raw, filename, 'java');
+        case '.css':
+        case '.scss':
+            return parseText(raw, filename);
+        default:
+            return parseText(raw, filename);
+    }
+}
+// --- Parsers ---
+function parseMarkdown(raw, filename) {
+    const tags = ['markdown'];
+    // Extract frontmatter tags if present
+    const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
+    if (fmMatch) {
+        const fmContent = fmMatch[1];
+        const tagMatch = fmContent.match(/tags:\s*\[([^\]]+)\]/);
+        if (tagMatch) {
+            tags.push(...tagMatch[1].split(',').map(t => t.trim().replace(/['"]/g, '')));
+        }
+    }
+    // Extract title from first heading
+    const titleMatch = raw.match(/^#\s+(.+)$/m);
+    const title = titleMatch ? titleMatch[1].trim() : filename;
+    const content = raw.substring(0, MAX_CONTENT_CHARS);
+    return {
+        title,
+        content,
+        file_type: 'markdown',
+        content_category: 'other',
+        tags,
+        word_count: content.split(/\s+/).length,
+    };
+}
+function parseText(raw, filename) {
+    const content = raw.substring(0, MAX_CONTENT_CHARS);
+    return {
+        title: filename,
+        content,
+        file_type: 'text',
+        content_category: 'other',
+        tags: ['text'],
+        word_count: content.split(/\s+/).length,
+    };
+}
+function parseJson(raw, filename) {
+    // For package.json, extract useful summary
+    if (filename === 'package.json') {
+        try {
+            const pkg = JSON.parse(raw);
+            const lines = [];
+            if (pkg.name)
+                lines.push(`Package: ${pkg.name}`);
+            if (pkg.description)
+                lines.push(`Description: ${pkg.description}`);
+            if (pkg.scripts)
+                lines.push(`\nScripts:\n${Object.entries(pkg.scripts).map(([k, v]) => `  ${k}: ${v}`).join('\n')}`);
+            if (pkg.dependencies)
+                lines.push(`\nDependencies:\n${Object.keys(pkg.dependencies).map(d => `  - ${d}`).join('\n')}`);
+            if (pkg.devDependencies)
+                lines.push(`\nDev Dependencies:\n${Object.keys(pkg.devDependencies).map(d => `  - ${d}`).join('\n')}`);
+            return {
+                title: pkg.name || filename,
+                content: lines.join('\n'),
+                file_type: 'json',
+                content_category: 'tool',
+                tags: ['json', 'package'],
+                word_count: lines.join('\n').split(/\s+/).length,
+            };
+        }
+        catch { /* fall through to raw */ }
+    }
+    const content = raw.substring(0, MAX_CONTENT_CHARS);
+    return {
+        title: filename,
+        content,
+        file_type: 'json',
+        content_category: 'other',
+        tags: ['json'],
+        word_count: content.split(/\s+/).length,
+    };
+}
+function parseYamlOrOpenApi(raw, filename) {
+    let parsed;
+    try {
+        parsed = yaml.load(raw);
+    }
+    catch {
+        // Invalid YAML - treat as text
+        return parseText(raw, filename);
+    }
+    if (!parsed || typeof parsed !== 'object') {
+        return parseText(raw, filename);
+    }
+    // Detect OpenAPI
+    if (parsed.openapi || parsed.swagger) {
+        return parseOpenApi(parsed, filename);
+    }
+    // Regular YAML - return as-is
+    const content = raw.substring(0, MAX_CONTENT_CHARS);
+    return {
+        title: filename,
+        content,
+        file_type: 'yaml',
+        content_category: 'other',
+        tags: ['yaml'],
+        word_count: content.split(/\s+/).length,
+    };
+}
+function parseOpenApi(spec, filename) {
+    const lines = [];
+    // Header
+    const title = spec.info?.title || filename;
+    const version = spec.info?.version || '';
+    lines.push(`OpenAPI: ${title}${version ? ` v${version}` : ''}`);
+    if (spec.info?.description) {
+        lines.push(`Description: ${spec.info.description.substring(0, 200)}`);
+    }
+    // Servers
+    if (spec.servers?.length) {
+        lines.push(`Base URL: ${spec.servers[0].url}`);
+    }
+    // Auth
+    const securitySchemes = spec.components?.securitySchemes;
+    if (securitySchemes) {
+        const schemes = Object.entries(securitySchemes).map(([name, s]) => {
+            if (s.type === 'http')
+                return `${name}: ${s.scheme} ${s.type}`;
+            if (s.type === 'apiKey')
+                return `${name}: API key in ${s.in}`;
+            if (s.type === 'oauth2')
+                return `${name}: OAuth2`;
+            return `${name}: ${s.type}`;
+        });
+        lines.push(`Auth: ${schemes.join(', ')}`);
+    }
+    // Endpoints
+    if (spec.paths) {
+        lines.push('');
+        lines.push('Endpoints:');
+        for (const [path, methods] of Object.entries(spec.paths)) {
+            for (const [method, op] of Object.entries(methods)) {
+                if (['get', 'post', 'put', 'patch', 'delete'].includes(method)) {
+                    const operation = op;
+                    const summary = operation.summary || operation.operationId || '';
+                    lines.push(`  ${method.toUpperCase()} ${path}${summary ? ` - ${summary}` : ''}`);
+                }
+            }
+        }
+    }
+    // Schemas
+    const schemas = spec.components?.schemas || spec.definitions;
+    if (schemas) {
+        lines.push('');
+        lines.push('Schemas:');
+        for (const [name, schema] of Object.entries(schemas)) {
+            const s = schema;
+            const props = s.properties ? Object.entries(s.properties).map(([k, v]) => `${k} (${v.type || 'object'})`).join(', ') : '';
+            lines.push(`  ${name}${props ? `: ${props}` : ''}`);
+        }
+    }
+    const content = lines.join('\n').substring(0, MAX_OPENAPI_CHARS);
+    return {
+        title: `API: ${title}`,
+        content,
+        file_type: 'openapi',
+        content_category: 'architecture',
+        tags: ['openapi', 'api'],
+        word_count: content.split(/\s+/).length,
+    };
+}
+function parseCodeSurface(raw, filename, lang) {
+    const lines = raw.split('\n');
+    const surface = [];
+    surface.push(`// File: ${filename}`);
+    surface.push(`// Language: ${lang}`);
+    surface.push('');
+    let insideBlock = false;
+    let braceDepth = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('/*') || trimmed.startsWith('*'))
+            continue;
+        // Track if we're capturing a multi-line interface/type body
+        if (insideBlock) {
+            surface.push(line);
+            braceDepth += (line.match(/\{/g) || []).length;
+            braceDepth -= (line.match(/\}/g) || []).length;
+            if (braceDepth <= 0) {
+                insideBlock = false;
+                braceDepth = 0;
+            }
+            continue;
+        }
+        if (lang === 'typescript') {
+            // Imports
+            if (trimmed.startsWith('import ')) {
+                surface.push(trimmed);
+                continue;
+            }
+            // Export statements, interfaces, types, classes, functions, enums
+            if (/^export\s/.test(trimmed) || /^(interface|type|class|enum|abstract)\s/.test(trimmed)) {
+                surface.push(trimmed);
+                // If line opens a block, capture the full body (for interfaces/types)
+                if (trimmed.includes('{') && !trimmed.includes('}')) {
+                    insideBlock = true;
+                    braceDepth = (trimmed.match(/\{/g) || []).length - (trimmed.match(/\}/g) || []).length;
+                }
+                continue;
+            }
+        }
+        else if (lang === 'python') {
+            if (/^(from |import )/.test(trimmed)) {
+                surface.push(trimmed);
+                continue;
+            }
+            if (/^(def |class |async def )/.test(trimmed)) {
+                surface.push(trimmed);
+                continue;
+            }
+            // Decorators
+            if (trimmed.startsWith('@')) {
+                surface.push(trimmed);
+                continue;
+            }
+        }
+        else if (lang === 'go') {
+            if (/^package\s/.test(trimmed)) {
+                surface.push(trimmed);
+                continue;
+            }
+            if (/^import\s/.test(trimmed) || trimmed === 'import (') {
+                surface.push(trimmed);
+                if (trimmed.includes('(') && !trimmed.includes(')')) {
+                    insideBlock = true;
+                    braceDepth = 1;
+                }
+                continue;
+            }
+            if (/^(func |type |var |const )/.test(trimmed)) {
+                surface.push(trimmed);
+                if (trimmed.includes('{') && !trimmed.includes('}')) {
+                    // For func, just capture the signature, not the body
+                    if (trimmed.startsWith('func '))
+                        continue;
+                    insideBlock = true;
+                    braceDepth = (trimmed.match(/\{/g) || []).length - (trimmed.match(/\}/g) || []).length;
+                }
+                continue;
+            }
+        }
+        else if (lang === 'rust') {
+            if (/^(pub |use |mod |fn |struct |enum |trait |impl |type |const )/.test(trimmed)) {
+                surface.push(trimmed);
+                continue;
+            }
+        }
+        else if (lang === 'java') {
+            if (/^(import |package )/.test(trimmed)) {
+                surface.push(trimmed);
+                continue;
+            }
+            if (/^(public |private |protected |static |abstract |interface |class |enum |@)/.test(trimmed)) {
+                surface.push(trimmed);
+                continue;
+            }
+        }
+    }
+    const content = surface.join('\n').substring(0, MAX_CODE_CHARS);
+    return {
+        title: filename,
+        content: content || `// File: ${filename}\n// No public surface detected`,
+        file_type: lang,
+        content_category: 'code_snippet',
+        tags: [lang, 'code'],
+        word_count: content.split(/\s+/).length,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splicr/mcp-server",
-  "version": "0.13.1",
+  "version": "0.14.0",
   "description": "Splicr MCP server — route what you read to what you're building",
   "type": "module",
   "bin": "./dist/cli.js",
@@ -30,9 +30,11 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
+    "js-yaml": "^4.1.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.14.0",
     "tsx": "^4.16.0",
     "typescript": "^5.5.0"