@telvok/librarian-mcp 1.0.0

package/dist/library/manager.d.ts

@@ -0,0 +1,42 @@
+import type { LibraryEntry } from './schemas.js';
+export declare class LibraryManager {
+    private libraryPath;
+    constructor();
+    /**
+     * Initialize the library directory structure.
+     */
+    initialize(): Promise<void>;
+    /**
+     * Get all entries from local library.
+     */
+    getLocalEntries(): Promise<LibraryEntry[]>;
+    /**
+     * Get all entries from imported libraries.
+     */
+    getImportedEntries(): Promise<LibraryEntry[]>;
+    /**
+     * Get all archived entries.
+     */
+    getArchivedEntries(): Promise<LibraryEntry[]>;
+    /**
+     * Query entries by topic.
+     */
+    queryByTopic(topic: string): Promise<LibraryEntry[]>;
+    /**
+     * Record a new entry to local library.
+     */
+    record(topics: string[], content: string): Promise<{
+        entry: LibraryEntry;
+        path: string;
+    }>;
+    /**
+     * Archive an entry (move to archived/).
+     */
+    archive(entryId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    private readEntriesFromPath;
+    private findEntryById;
+    private fileExists;
+}

package/dist/library/manager.js

@@ -0,0 +1,218 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { glob } from 'glob';
+import { v4 as uuidv4 } from 'uuid';
+import { getLibraryPath, getLocalPath, getImportedPath, getArchivedPath, } from './storage.js';
+// ============================================================================
+// Library Manager
+// ============================================================================
+export class LibraryManager {
+    libraryPath;
+    constructor() {
+        this.libraryPath = getLibraryPath();
+    }
+    /**
+     * Initialize the library directory structure.
+     */
+    async initialize() {
+        const dirs = [
+            getLocalPath(this.libraryPath),
+            getImportedPath(this.libraryPath),
+            getArchivedPath(this.libraryPath),
+        ];
+        for (const dir of dirs) {
+            await fs.mkdir(dir, { recursive: true });
+        }
+    }
+    /**
+     * Get all entries from local library.
+     */
+    async getLocalEntries() {
+        const localPath = getLocalPath(this.libraryPath);
+        return this.readEntriesFromPath(localPath, 'local');
+    }
+    /**
+     * Get all entries from imported libraries.
+     */
+    async getImportedEntries() {
+        const importedPath = getImportedPath(this.libraryPath);
+        return this.readEntriesFromPath(importedPath, 'imported');
+    }
+    /**
+     * Get all archived entries.
+     */
+    async getArchivedEntries() {
+        const archivedPath = getArchivedPath(this.libraryPath);
+        return this.readEntriesFromPath(archivedPath, 'archived');
+    }
+    /**
+     * Query entries by topic.
+     */
+    async queryByTopic(topic) {
+        const [local, imported] = await Promise.all([
+            this.getLocalEntries(),
+            this.getImportedEntries(),
+        ]);
+        const allEntries = [...local, ...imported];
+        const searchTerm = topic.toLowerCase();
+        return allEntries.filter(entry => entry.topics.some(t => t.toLowerCase().includes(searchTerm)) ||
+            entry.content.toLowerCase().includes(searchTerm));
+    }
+    /**
+     * Record a new entry to local library.
+     */
+    async record(topics, content) {
+        const localPath = getLocalPath(this.libraryPath);
+        await fs.mkdir(localPath, { recursive: true });
+        const id = uuidv4();
+        const created = new Date().toISOString();
+        const entry = {
+            id,
+            topics,
+            content,
+            created,
+            source: 'local',
+            origin: 'manual',
+        };
+        // Generate filename
+        const slug = topics[0]
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '');
+        const timestamp = created.slice(0, 10);
+        let filename = `${slug}-${timestamp}.md`;
+        let filePath = path.join(localPath, filename);
+        // Handle collisions
+        let counter = 1;
+        while (await this.fileExists(filePath)) {
+            filename = `${slug}-${timestamp}-${counter}.md`;
+            filePath = path.join(localPath, filename);
+            counter++;
+        }
+        // Write file
+        const frontmatter = {
+            id,
+            topics,
+            created,
+            source: 'manual',
+        };
+        const fileContent = matter.stringify(content, frontmatter);
+        await fs.writeFile(filePath, fileContent, 'utf-8');
+        return {
+            entry,
+            path: path.relative(this.libraryPath, filePath),
+        };
+    }
+    /**
+     * Archive an entry (move to archived/).
+     */
+    async archive(entryId) {
+        const localPath = getLocalPath(this.libraryPath);
+        const archivedPath = getArchivedPath(this.libraryPath);
+        // Find the entry
+        const found = await this.findEntryById(localPath, entryId);
+        if (!found) {
+            return { success: false, message: `Entry not found: ${entryId}` };
+        }
+        await fs.mkdir(archivedPath, { recursive: true });
+        const filename = path.basename(found.filePath);
+        const newPath = path.join(archivedPath, filename);
+        await fs.rename(found.filePath, newPath);
+        return {
+            success: true,
+            message: `Archived to ${path.relative(this.libraryPath, newPath)}`,
+        };
+    }
+    // ============================================================================
+    // Private Helpers
+    // ============================================================================
+    async readEntriesFromPath(dirPath, source) {
+        const entries = [];
+        try {
+            const files = await glob(path.join(dirPath, '**/*.md'), { nodir: true });
+            for (const filePath of files) {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const { data, content: body } = matter(content);
+                    let topics;
+                    if (Array.isArray(data.topics)) {
+                        topics = data.topics;
+                    }
+                    else if (data.topic) {
+                        topics = [data.topic];
+                    }
+                    else {
+                        topics = ['general'];
+                    }
+                    entries.push({
+                        id: data.id || uuidv4(),
+                        topics,
+                        content: body.trim(),
+                        created: data.created || new Date().toISOString(),
+                        source,
+                        origin: data.source,
+                        imported_from: data.imported_from,
+                    });
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        return entries;
+    }
+    async findEntryById(dirPath, entryId) {
+        try {
+            const files = await glob(path.join(dirPath, '**/*.md'), { nodir: true });
+            for (const filePath of files) {
+                try {
+                    const content = await fs.readFile(filePath, 'utf-8');
+                    const { data, content: body } = matter(content);
+                    if (data.id === entryId) {
+                        let topics;
+                        if (Array.isArray(data.topics)) {
+                            topics = data.topics;
+                        }
+                        else if (data.topic) {
+                            topics = [data.topic];
+                        }
+                        else {
+                            topics = ['general'];
+                        }
+                        return {
+                            entry: {
+                                id: data.id,
+                                topics,
+                                content: body.trim(),
+                                created: data.created || new Date().toISOString(),
+                                source: 'local',
+                                origin: data.source,
+                            },
+                            filePath,
+                        };
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+        return null;
+    }
+    async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/library/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/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;
+}