@doquflow/server 0.2.0 → 0.4.0

package/dist/tools/wiki-search.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wikiSearch = wikiSearch;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const filesystem_1 = require("../filesystem");
+/**
+ * Simple BM25-inspired scoring with term frequency and document frequency.
+ * Weights entity pages more heavily than concepts, titles match higher.
+ */
+function scoreMatch(query, content, title, category, totalPages) {
+    const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+    let score = 0;
+    const matched_terms = new Set();
+    for (const term of queryTerms) {
+        // Title match (highest weight)
+        if (title.toLowerCase().includes(term)) {
+            score += 50;
+            matched_terms.add(term);
+        }
+        // Content match with term frequency (TF)
+        const contentLower = content.toLowerCase();
+        const termRegex = new RegExp(`\\b${term}\\b`, "gi");
+        const matches = contentLower.match(termRegex);
+        if (matches) {
+            const tf = matches.length;
+            // Inverse document frequency approximation
+            const idf = Math.log(totalPages / Math.max(1, matches.length));
+            score += tf * idf * 2;
+            matched_terms.add(term);
+        }
+    }
+    // Category boost: entities score higher than concepts
+    if (category === "entity") {
+        score *= 1.3;
+    }
+    else if (category === "synthesis") {
+        score *= 1.1;
+    }
+    return { score, matched_terms: Array.from(matched_terms) };
+}
+/**
+ * Extract a preview snippet from content around matched terms
+ */
+function extractPreview(content, matchedTerms, maxLength = 150) {
+    if (!matchedTerms.length) {
+        // Return first non-empty paragraph
+        const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#") && !l.startsWith("---"));
+        return lines.slice(0, 2).join(" ").substring(0, maxLength);
+    }
+    // Find first occurrence of any matched term
+    const contentLower = content.toLowerCase();
+    const term = matchedTerms[0];
+    const index = contentLower.indexOf(term);
+    if (index === -1) {
+        const lines = content.split("\n").filter((l) => l.trim() && !l.startsWith("#"));
+        return lines.slice(0, 2).join(" ").substring(0, maxLength);
+    }
+    const start = Math.max(0, index - 60);
+    const end = Math.min(content.length, index + 150);
+    let preview = content.substring(start, end);
+    // Trim to word boundary
+    const lastSpace = preview.lastIndexOf(" ");
+    if (lastSpace > 0) {
+        preview = preview.substring(0, lastSpace) + "...";
+    }
+    return preview;
+}
+async function wikiSearch(input) {
+    try {
+        const projectPath = node_path_1.default.resolve(input.project_path);
+        const docuDir = node_path_1.default.join(projectPath, ".docuflow");
+        const wikiDir = node_path_1.default.join(docuDir, "wiki");
+        const limit = input.limit ?? 10;
+        const allResults = [];
+        // Build list of categories to search
+        let categoriesToScan = ["entities", "concepts", "timelines", "syntheses"];
+        if (input.category) {
+            categoriesToScan = [`${input.category}s`];
+        }
+        // First pass: count total pages (for IDF calculation)
+        let totalPages = 0;
+        for (const categoryDir of categoriesToScan) {
+            const fullCategoryPath = node_path_1.default.join(wikiDir, categoryDir);
+            try {
+                const files = await promises_1.default.readdir(fullCategoryPath);
+                totalPages += files.filter((f) => f.endsWith(".md")).length;
+            }
+            catch (e) {
+                // Category may not exist
+            }
+        }
+        const PLURAL_TO_SINGULAR = {
+            entities: "entity",
+            concepts: "concept",
+            timelines: "timeline",
+            syntheses: "synthesis",
+        };
+        // Second pass: search all pages
+        for (const categoryDir of categoriesToScan) {
+            const fullCategoryPath = node_path_1.default.join(wikiDir, categoryDir);
+            const category = PLURAL_TO_SINGULAR[categoryDir] ?? categoryDir.replace(/s$/, "");
+            try {
+                const files = await promises_1.default.readdir(fullCategoryPath);
+                for (const file of files) {
+                    if (!file.endsWith(".md"))
+                        continue;
+                    const filePath = node_path_1.default.join(fullCategoryPath, file);
+                    const read = await (0, filesystem_1.safeReadFile)(filePath);
+                    if (read.error || read.binary || !read.content)
+                        continue;
+                    // Extract title from content (first H1)
+                    const titleMatch = read.content.match(/^#\s+(.+?)$/m);
+                    const title = titleMatch ? titleMatch[1].trim() : file.replace(".md", "");
+                    const pageId = file.replace(".md", "");
+                    // Score the match
+                    const { score, matched_terms } = scoreMatch(input.query, read.content, title, category, totalPages);
+                    // Only include if there's at least one match
+                    if (score > 0 && matched_terms.length > 0) {
+                        const preview = extractPreview(read.content, matched_terms);
+                        allResults.push({
+                            page_id: pageId,
+                            title,
+                            category,
+                            path: node_path_1.default.relative(docuDir, filePath),
+                            relevance_score: Math.round(score * 10) / 10, // Round to 1 decimal
+                            preview,
+                            matched_terms,
+                        });
+                    }
+                }
+            }
+            catch (e) {
+                // Category directory may not exist
+            }
+        }
+        // Sort by relevance score (descending) and return top N
+        allResults.sort((a, b) => b.relevance_score - a.relevance_score);
+        const results = allResults.slice(0, limit);
+        return {
+            query: input.query,
+            results,
+            total_results: allResults.length,
+        };
+    }
+    catch (e) {
+        return {
+            query: input.query,
+            results: [],
+            total_results: 0,
+            error: e?.message ?? String(e),
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doquflow/server",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Docuflow MCP server — lets AI agents read codebases and persist living specs",
   "author": "Docuflow <hello@doquflows.dev>",
   "license": "MIT",