@telvok/librarian-mcp 1.5.3 → 2.0.0

package/dist/library 2/parsers/markdown.js

@@ -0,0 +1,77 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { glob } from 'glob';
+import matter from 'gray-matter';
+/**
+ * Parse a folder of markdown files (Basic Memory MCP / Obsidian / any .md).
+ *
+ * Input format:
+ * ---
+ * title: API Rate Limits
+ * tags: [api, performance]
+ * ---
+ *
+ * # API Rate Limits
+ *
+ * Always implement exponential backoff...
+ */
+export async function parseMarkdown(dirPath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    try {
+        // Handle both single file and directory
+        const stats = await fs.stat(dirPath);
+        const files = stats.isDirectory()
+            ? await glob(path.join(dirPath, '**/*.md'), { nodir: true })
+            : [dirPath];
+        for (const filePath of files) {
+            try {
+                const content = await fs.readFile(filePath, 'utf-8');
+                const { data, content: body } = matter(content);
+                const frontmatter = data;
+                // Skip empty files
+                const trimmedBody = body.trim();
+                if (!trimmedBody) {
+                    skipped++;
+                    continue;
+                }
+                // Extract title from frontmatter, H1, or filename
+                let title = frontmatter.title;
+                if (!title) {
+                    const headingMatch = trimmedBody.match(/^#\s+(.+)$/m);
+                    if (headingMatch) {
+                        title = headingMatch[1].trim();
+                    }
+                    else {
+                        title = path.basename(filePath, '.md').replace(/-/g, ' ');
+                    }
+                }
+                // Extract context from tags or context field
+                let context;
+                if (frontmatter.context) {
+                    context = frontmatter.context;
+                }
+                else if (frontmatter.tags && Array.isArray(frontmatter.tags)) {
+                    context = frontmatter.tags.join(', ');
+                }
+                entries.push({
+                    title,
+                    content: trimmedBody,
+                    context,
+                    intent: frontmatter.intent,
+                    source: 'markdown',
+                    originalPath: filePath,
+                });
+            }
+            catch (fileError) {
+                errors.push(`${filePath}: ${fileError instanceof Error ? fileError.message : String(fileError)}`);
+                skipped++;
+            }
+        }
+    }
+    catch (dirError) {
+        errors.push(`Failed to access path: ${dirError instanceof Error ? dirError.message : String(dirError)}`);
+    }
+    return { entries, skipped, errors };
+}

package/dist/library 2/parsers/sqlite.d.ts

@@ -0,0 +1,8 @@
+import type { ParseResult } from './types.js';
+/**
+ * Parse a SQLite database file for memory entries.
+ *
+ * Auto-detects table and column names from common patterns.
+ * Supports mcp-memory-service, SQLite-vec, and custom schemas.
+ */
+export declare function parseSQLite(filePath: string): Promise<ParseResult>;

package/dist/library 2/parsers/sqlite.js

@@ -0,0 +1,123 @@
+import Database from 'better-sqlite3';
+// ============================================================================
+// SQLite Parser - mcp-memory-service, SQLite-vec, custom databases
+// ============================================================================
+// Common table names for memory storage
+const TABLE_CANDIDATES = ['memories', 'entries', 'knowledge', 'notes', 'items', 'documents'];
+// Common column names for different fields
+const TITLE_CANDIDATES = ['title', 'name', 'key', 'id', 'subject', 'heading'];
+const CONTENT_CANDIDATES = ['content', 'text', 'value', 'memory', 'observation', 'body', 'description', 'note'];
+const CONTEXT_CANDIDATES = ['context', 'category', 'type', 'tags', 'topic', 'area'];
+/**
+ * Parse a SQLite database file for memory entries.
+ *
+ * Auto-detects table and column names from common patterns.
+ * Supports mcp-memory-service, SQLite-vec, and custom schemas.
+ */
+export async function parseSQLite(filePath) {
+    const entries = [];
+    const errors = [];
+    let skipped = 0;
+    let db = null;
+    try {
+        db = new Database(filePath, { readonly: true });
+        // Find a suitable table
+        const tables = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table'")
+            .all();
+        const tableNames = tables.map((t) => t.name.toLowerCase());
+        const targetTable = TABLE_CANDIDATES.find((candidate) => tableNames.includes(candidate));
+        if (!targetTable) {
+            errors.push(`No memory table found. Available tables: ${tableNames.join(', ')}. ` +
+                `Expected one of: ${TABLE_CANDIDATES.join(', ')}`);
+            return { entries, skipped, errors };
+        }
+        // Get column info for the target table
+        const columns = db.prepare(`PRAGMA table_info(${targetTable})`).all();
+        const columnNames = columns.map((c) => c.name.toLowerCase());
+        // Find content column (required)
+        const contentColumn = CONTENT_CANDIDATES.find((candidate) => columnNames.includes(candidate));
+        if (!contentColumn) {
+            errors.push(`No content column found in table "${targetTable}". ` +
+                `Available columns: ${columnNames.join(', ')}. ` +
+                `Expected one of: ${CONTENT_CANDIDATES.join(', ')}`);
+            return { entries, skipped, errors };
+        }
+        // Find optional columns
+        const titleColumn = TITLE_CANDIDATES.find((candidate) => columnNames.includes(candidate));
+        const contextColumn = CONTEXT_CANDIDATES.find((candidate) => columnNames.includes(candidate));
+        // Build and execute query
+        const selectColumns = [
+            contentColumn,
+            titleColumn,
+            contextColumn,
+        ].filter(Boolean);
+        const query = `SELECT ${selectColumns.join(', ')} FROM ${targetTable}`;
+        const rows = db.prepare(query).all();
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            // Extract content
+            const content = row[contentColumn];
+            if (!content || typeof content !== 'string' || !content.trim()) {
+                skipped++;
+                continue;
+            }
+            // Extract title
+            let title;
+            if (titleColumn && row[titleColumn]) {
+                title = String(row[titleColumn]);
+            }
+            else {
+                // Generate title from content
+                title = content.slice(0, 60).replace(/\s+/g, ' ').trim();
+                if (content.length > 60)
+                    title += '...';
+            }
+            // Extract context
+            let context;
+            if (contextColumn && row[contextColumn]) {
+                const contextValue = row[contextColumn];
+                if (typeof contextValue === 'string') {
+                    context = contextValue;
+                }
+                else if (Array.isArray(contextValue)) {
+                    context = contextValue.join(', ');
+                }
+            }
+            entries.push({
+                title,
+                content: content.trim(),
+                context,
+                source: 'sqlite',
+                originalPath: `${filePath}:${targetTable}`,
+            });
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            if (error.message.includes('SQLITE_CANTOPEN')) {
+                errors.push(`Cannot open database file: ${filePath}`);
+            }
+            else if (error.message.includes('file is not a database')) {
+                errors.push(`File is not a valid SQLite database: ${filePath}`);
+            }
+            else {
+                errors.push(`SQLite error: ${error.message}`);
+            }
+        }
+        else {
+            errors.push(`Unknown error: ${String(error)}`);
+        }
+    }
+    finally {
+        if (db) {
+            try {
+                db.close();
+            }
+            catch {
+                // Ignore close errors
+            }
+        }
+    }
+    return { entries, skipped, errors };
+}

package/dist/library 2/parsers/types.d.ts

@@ -0,0 +1,21 @@
+/**
+ * A parsed memory entry ready to be converted to Librarian format.
+ */
+export interface ParsedEntry {
+    title: string;
+    content: string;
+    context?: string;
+    intent?: string;
+    reasoning?: string;
+    example?: string;
+    source: 'jsonl' | 'markdown' | 'cursor' | 'json' | 'sqlite';
+    originalPath?: string;
+}
+/**
+ * Result of a parse operation.
+ */
+export interface ParseResult {
+    entries: ParsedEntry[];
+    skipped: number;
+    errors: string[];
+}

package/dist/library 2/parsers/types.js

@@ -0,0 +1,4 @@
+// ============================================================================
+// Shared Types for Memory Parsers
+// ============================================================================
+export {};

package/dist/library 2/query.d.ts

@@ -0,0 +1,26 @@
+import type { LibraryEntry } from './schemas.js';
+/**
+ * Score how well an entry matches a search term.
+ */
+export declare function scoreMatch(entry: LibraryEntry, searchTerm: string): number;
+/**
+ * Detect potential conflicts between entries.
+ * Returns true if entries on the same topic give contradictory advice.
+ */
+export declare function detectConflict(entries: LibraryEntry[]): boolean;
+/**
+ * Generate a conflict summary.
+ */
+export declare function generateConflictSummary(entries: LibraryEntry[]): string;
+/**
+ * Filter entries by topic.
+ */
+export declare function filterByTopic(entries: LibraryEntry[], topic: string): LibraryEntry[];
+/**
+ * Sort entries by relevance to search term.
+ */
+export declare function sortByRelevance(entries: LibraryEntry[], searchTerm: string): LibraryEntry[];
+/**
+ * Group entries by source.
+ */
+export declare function groupBySource(entries: LibraryEntry[]): Record<string, LibraryEntry[]>;

package/dist/library 2/query.js

@@ -0,0 +1,104 @@
+// ============================================================================
+// Query Utilities
+// ============================================================================
+/**
+ * Score how well an entry matches a search term.
+ */
+export function scoreMatch(entry, searchTerm) {
+    const term = searchTerm.toLowerCase();
+    let score = 0;
+    // Topic matches (highest weight)
+    for (const topic of entry.topics) {
+        if (topic.toLowerCase() === term) {
+            score += 10; // Exact match
+        }
+        else if (topic.toLowerCase().includes(term)) {
+            score += 5; // Partial match
+        }
+    }
+    // Content matches
+    const contentLower = entry.content.toLowerCase();
+    if (contentLower.includes(term)) {
+        // Count occurrences
+        const matches = contentLower.split(term).length - 1;
+        score += Math.min(matches * 2, 8); // Cap at 8
+    }
+    return score;
+}
+/**
+ * Detect potential conflicts between entries.
+ * Returns true if entries on the same topic give contradictory advice.
+ */
+export function detectConflict(entries) {
+    if (entries.length < 2)
+        return false;
+    // Simple heuristic: look for negation patterns
+    const negationPatterns = [
+        /don't|dont|never|avoid|stop/i,
+        /always|must|should/i,
+    ];
+    let hasNegation = false;
+    let hasAffirmation = false;
+    for (const entry of entries) {
+        if (negationPatterns[0].test(entry.content)) {
+            hasNegation = true;
+        }
+        if (negationPatterns[1].test(entry.content)) {
+            hasAffirmation = true;
+        }
+    }
+    // This is a very simple heuristic - could be improved with semantic analysis
+    return hasNegation && hasAffirmation;
+}
+/**
+ * Generate a conflict summary.
+ */
+export function generateConflictSummary(entries) {
+    if (entries.length < 2)
+        return '';
+    const sources = entries.map(e => {
+        if (e.imported_from) {
+            return `imported/${e.imported_from}`;
+        }
+        return e.source;
+    });
+    const uniqueSources = [...new Set(sources)];
+    return `Found ${entries.length} entries that may conflict. Sources: ${uniqueSources.join(', ')}. Review and decide which to keep.`;
+}
+/**
+ * Filter entries by topic.
+ */
+export function filterByTopic(entries, topic) {
+    const term = topic.toLowerCase();
+    return entries.filter(entry => entry.topics.some(t => t.toLowerCase().includes(term)));
+}
+/**
+ * Sort entries by relevance to search term.
+ */
+export function sortByRelevance(entries, searchTerm) {
+    return [...entries].sort((a, b) => {
+        const scoreA = scoreMatch(a, searchTerm);
+        const scoreB = scoreMatch(b, searchTerm);
+        return scoreB - scoreA;
+    });
+}
+/**
+ * Group entries by source.
+ */
+export function groupBySource(entries) {
+    const groups = {
+        local: [],
+        imported: [],
+        archived: [],
+    };
+    for (const entry of entries) {
+        const key = entry.source;
+        if (groups[key]) {
+            groups[key].push(entry);
+        }
+        else {
+            groups.local.push(entry); // Default to local
+        }
+    }
+    return groups;
+}

package/dist/library 2/schemas.d.ts

@@ -0,0 +1,324 @@
+import { z } from 'zod';
+export declare const SourceTypeSchema: z.ZodEnum<["local", "imported", "archived"]>;
+export type SourceType = z.infer<typeof SourceTypeSchema>;
+export declare const EntrySourceSchema: z.ZodEnum<["manual", "precompact", "imported"]>;
+export type EntrySource = z.infer<typeof EntrySourceSchema>;
+export declare const LibraryEntrySchema: z.ZodObject<{
+    id: z.ZodString;
+    topics: z.ZodArray<z.ZodString, "many">;
+    content: z.ZodString;
+    created: z.ZodString;
+    source: z.ZodEnum<["local", "imported", "archived"]>;
+    origin: z.ZodOptional<z.ZodEnum<["manual", "precompact", "imported"]>>;
+    imported_from: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    created: string;
+    source: "local" | "imported" | "archived";
+    id: string;
+    topics: string[];
+    origin?: "imported" | "manual" | "precompact" | undefined;
+    imported_from?: string | undefined;
+}, {
+    content: string;
+    created: string;
+    source: "local" | "imported" | "archived";
+    id: string;
+    topics: string[];
+    origin?: "imported" | "manual" | "precompact" | undefined;
+    imported_from?: string | undefined;
+}>;
+export type LibraryEntry = z.infer<typeof LibraryEntrySchema>;
+export declare const FrontmatterSchema: z.ZodObject<{
+    id: z.ZodString;
+    topics: z.ZodArray<z.ZodString, "many">;
+    created: z.ZodString;
+    source: z.ZodOptional<z.ZodEnum<["manual", "precompact", "imported"]>>;
+    imported_from: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    created: string;
+    id: string;
+    topics: string[];
+    source?: "imported" | "manual" | "precompact" | undefined;
+    imported_from?: string | undefined;
+}, {
+    created: string;
+    id: string;
+    topics: string[];
+    source?: "imported" | "manual" | "precompact" | undefined;
+    imported_from?: string | undefined;
+}>;
+export type Frontmatter = z.infer<typeof FrontmatterSchema>;
+export declare const BriefParamsSchema: z.ZodObject<{
+    topic: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    topic: string;
+    context?: string | undefined;
+}, {
+    topic: string;
+    context?: string | undefined;
+}>;
+export type BriefParams = z.infer<typeof BriefParamsSchema>;
+export declare const RecordParamsSchema: z.ZodObject<{
+    topics: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    topics: string | string[];
+}, {
+    content: string;
+    topics: string | string[];
+}>;
+export type RecordParams = z.infer<typeof RecordParamsSchema>;
+export declare const AdoptParamsSchema: z.ZodObject<{
+    entry_id: z.ZodString;
+    library_name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    entry_id: string;
+    library_name?: string | undefined;
+}, {
+    entry_id: string;
+    library_name?: string | undefined;
+}>;
+export type AdoptParams = z.infer<typeof AdoptParamsSchema>;
+export declare const BriefResultSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        topics: z.ZodArray<z.ZodString, "many">;
+        content: z.ZodString;
+        created: z.ZodString;
+        source: z.ZodEnum<["local", "imported", "archived"]>;
+        origin: z.ZodOptional<z.ZodEnum<["manual", "precompact", "imported"]>>;
+        imported_from: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }, {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }>, "many">;
+    conflict: z.ZodOptional<z.ZodBoolean>;
+    conflict_summary: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }[];
+    conflict?: boolean | undefined;
+    conflict_summary?: string | undefined;
+}, {
+    entries: {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }[];
+    conflict?: boolean | undefined;
+    conflict_summary?: string | undefined;
+}>;
+export type BriefResult = z.infer<typeof BriefResultSchema>;
+export declare const ImportedLibrarySchema: z.ZodObject<{
+    name: z.ZodString;
+    entry_count: z.ZodNumber;
+    purchased_at: z.ZodString;
+    sync_preference: z.ZodOptional<z.ZodEnum<["auto", "manual", "pinned"]>>;
+    last_synced: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    entry_count: number;
+    purchased_at: string;
+    last_synced?: string | undefined;
+    sync_preference?: "pinned" | "manual" | "auto" | undefined;
+}, {
+    name: string;
+    entry_count: number;
+    purchased_at: string;
+    last_synced?: string | undefined;
+    sync_preference?: "pinned" | "manual" | "auto" | undefined;
+}>;
+export type ImportedLibrary = z.infer<typeof ImportedLibrarySchema>;
+export declare const StateResultSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        topics: z.ZodArray<z.ZodString, "many">;
+        content: z.ZodString;
+        created: z.ZodString;
+        source: z.ZodEnum<["local", "imported", "archived"]>;
+        origin: z.ZodOptional<z.ZodEnum<["manual", "precompact", "imported"]>>;
+        imported_from: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }, {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }>, "many">;
+    imported_libraries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        entry_count: z.ZodNumber;
+        purchased_at: z.ZodString;
+        sync_preference: z.ZodOptional<z.ZodEnum<["auto", "manual", "pinned"]>>;
+        last_synced: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        entry_count: number;
+        purchased_at: string;
+        last_synced?: string | undefined;
+        sync_preference?: "pinned" | "manual" | "auto" | undefined;
+    }, {
+        name: string;
+        entry_count: number;
+        purchased_at: string;
+        last_synced?: string | undefined;
+        sync_preference?: "pinned" | "manual" | "auto" | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }[];
+    imported_libraries: {
+        name: string;
+        entry_count: number;
+        purchased_at: string;
+        last_synced?: string | undefined;
+        sync_preference?: "pinned" | "manual" | "auto" | undefined;
+    }[];
+}, {
+    entries: {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }[];
+    imported_libraries: {
+        name: string;
+        entry_count: number;
+        purchased_at: string;
+        last_synced?: string | undefined;
+        sync_preference?: "pinned" | "manual" | "auto" | undefined;
+    }[];
+}>;
+export type StateResult = z.infer<typeof StateResultSchema>;
+export declare const RecordResultSchema: z.ZodObject<{
+    entry: z.ZodObject<{
+        id: z.ZodString;
+        topics: z.ZodArray<z.ZodString, "many">;
+        content: z.ZodString;
+        created: z.ZodString;
+        source: z.ZodEnum<["local", "imported", "archived"]>;
+        origin: z.ZodOptional<z.ZodEnum<["manual", "precompact", "imported"]>>;
+        imported_from: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }, {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    }>;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    entry: {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    };
+}, {
+    path: string;
+    entry: {
+        content: string;
+        created: string;
+        source: "local" | "imported" | "archived";
+        id: string;
+        topics: string[];
+        origin?: "imported" | "manual" | "precompact" | undefined;
+        imported_from?: string | undefined;
+    };
+}>;
+export type RecordResult = z.infer<typeof RecordResultSchema>;
+export declare const ExtractedEntrySchema: z.ZodObject<{
+    topics: z.ZodArray<z.ZodString, "many">;
+    content: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    content: string;
+    topics: string[];
+}, {
+    content: string;
+    topics: string[];
+}>;
+export type ExtractedEntry = z.infer<typeof ExtractedEntrySchema>;
+export declare const ExtractionResultSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        topics: z.ZodArray<z.ZodString, "many">;
+        content: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        content: string;
+        topics: string[];
+    }, {
+        content: string;
+        topics: string[];
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    entries: {
+        content: string;
+        topics: string[];
+    }[];
+}, {
+    entries: {
+        content: string;
+        topics: string[];
+    }[];
+}>;
+export type ExtractionResult = z.infer<typeof ExtractionResultSchema>;