@doquflow/server 1.6.0 → 2.0.0

package/dist/tools/build-graph.js

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildGraph = buildGraph;
-const list_wiki_1 = require("./list-wiki");
-const SEP = "\u0000";
-async function buildGraph(input) {
-    const generatedAt = new Date().toISOString();
-    try {
-        const wiki = await (0, list_wiki_1.listWiki)({ project_path: input.project_path });
-        if (wiki.error) {
-            return {
-                nodes: [],
-                edges: [],
-                meta: {
-                    total_pages: 0, total_edges: 0, orphans: 0, isolated: 0,
-                    dangling_refs: [], generated_at: generatedAt,
-                },
-                error: wiki.error,
-            };
-        }
-        const pages = wiki.pages;
-        const nodeIds = new Set(pages.map((p) => p.id));
-        const edgeMap = new Map();
-        const dangling = new Set();
-        // Pass 1: outbound
-        for (const page of pages) {
-            const src = page.id;
-            for (const tgt of page.outbound_links ?? []) {
-                if (tgt === src)
-                    continue;
-                if (!nodeIds.has(tgt)) {
-                    dangling.add(tgt);
-                    continue;
-                }
-                const key = `${src}${SEP}${tgt}`;
-                if (!edgeMap.has(key)) {
-                    edgeMap.set(key, { source: src, target: tgt, kind: "outbound" });
-                }
-            }
-        }
-        // Pass 2: inbound — `n.inbound_links` lists pages that point AT n.
-        for (const page of pages) {
-            const tgt = page.id;
-            for (const src of page.inbound_links ?? []) {
-                if (src === tgt)
-                    continue;
-                if (!nodeIds.has(src)) {
-                    dangling.add(src);
-                    continue;
-                }
-                const key = `${src}${SEP}${tgt}`;
-                const existing = edgeMap.get(key);
-                if (existing) {
-                    if (existing.kind === "outbound")
-                        existing.kind = "both";
-                    // already 'inbound' or 'both' → keep
-                }
-                else {
-                    edgeMap.set(key, { source: src, target: tgt, kind: "inbound" });
-                }
-            }
-        }
-        const edges = Array.from(edgeMap.values());
-        // Compute resolved in/out degree from final edge list.
-        const inDeg = new Map();
-        const outDeg = new Map();
-        for (const e of edges) {
-            outDeg.set(e.source, (outDeg.get(e.source) ?? 0) + 1);
-            inDeg.set(e.target, (inDeg.get(e.target) ?? 0) + 1);
-        }
-        const nodes = pages.map((p) => {
-            const out_degree = outDeg.get(p.id) ?? 0;
-            const in_degree = inDeg.get(p.id) ?? 0;
-            return {
-                id: p.id,
-                title: p.title,
-                category: p.category,
-                degree: in_degree + out_degree,
-                in_degree,
-                out_degree,
-                stale: p.stale,
-                updated_at: p.updated_at,
-            };
-        });
-        const orphans = nodes.filter((n) => n.in_degree === 0).length;
-        const isolated = nodes.filter((n) => n.degree === 0).length;
-        return {
-            nodes,
-            edges,
-            meta: {
-                total_pages: nodes.length,
-                total_edges: edges.length,
-                orphans,
-                isolated,
-                dangling_refs: Array.from(dangling).sort(),
-                generated_at: generatedAt,
-            },
-        };
-    }
-    catch (e) {
-        return {
-            nodes: [],
-            edges: [],
-            meta: {
-                total_pages: 0, total_edges: 0, orphans: 0, isolated: 0,
-                dangling_refs: [], generated_at: generatedAt,
-            },
-            error: e?.message ?? String(e),
-        };
-    }
-}

package/dist/tools/generate-dependency-graph.js

@@ -1,162 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateDependencyGraph = generateDependencyGraph;
-const node_path_1 = __importDefault(require("node:path"));
-const list_modules_1 = require("./list-modules");
-async function generateDependencyGraph(input) {
-    try {
-        const projectPath = node_path_1.default.resolve(input.project_path);
-        // Scan all modules
-        const listResult = await (0, list_modules_1.listModules)({
-            path: projectPath,
-            extensions: input.extensions,
-        });
-        const modules = listResult.modules ?? [];
-        if (modules.length === 0) {
-            return {
-                nodes: [],
-                edges: [],
-                shared_tables: {},
-                shared_endpoints: {},
-                most_connected: [],
-                summary: "No source files found in the project.",
-            };
-        }
-        // Build id from relative path (normalised for use as node id)
-        const relPath = (filePath) => node_path_1.default.relative(projectPath, filePath).replace(/\\/g, "/");
-        // Build nodes map
-        const nodeMap = new Map();
-        for (const mod of modules) {
-            const id = relPath(mod.path);
-            nodeMap.set(id, {
-                id,
-                label: node_path_1.default.basename(mod.path),
-                language: mod.language,
-                classes: mod.classes.length,
-                functions: mod.functions.length,
-                db_tables: mod.db_tables,
-                endpoints: mod.endpoints,
-            });
-        }
-        // Build import edges: for each module's dependency list, look for matches in node IDs
-        const edges = [];
-        const edgeSet = new Set(); // avoid duplicates
-        for (const mod of modules) {
-            const fromId = relPath(mod.path);
-            for (const dep of mod.dependencies) {
-                // Try to resolve dep to a known node (relative path match or basename match)
-                for (const [nodeId] of nodeMap) {
-                    // Match if the dependency string is contained in the node path
-                    // (e.g., dep = "./user-service" matches "src/user-service.ts")
-                    const depNorm = dep.replace(/^[./]+/, "").replace(/\\/g, "/").toLowerCase();
-                    const nodeNorm = nodeId.replace(/\\/g, "/").toLowerCase();
-                    if (depNorm.length > 2 &&
-                        (nodeNorm.includes(depNorm) || nodeNorm.replace(/\.\w+$/, "").endsWith(depNorm))) {
-                        const key = `${fromId}->${nodeId}`;
-                        if (fromId !== nodeId && !edgeSet.has(key)) {
-                            edgeSet.add(key);
-                            edges.push({ from: fromId, to: nodeId, type: "imports" });
-                        }
-                    }
-                }
-            }
-        }
-        // Shared DB tables
-        const tableToModules = new Map();
-        for (const mod of modules) {
-            for (const table of mod.db_tables) {
-                const key = table.toLowerCase();
-                if (!tableToModules.has(key))
-                    tableToModules.set(key, []);
-                tableToModules.get(key).push(relPath(mod.path));
-            }
-        }
-        const shared_tables = {};
-        for (const [table, mods] of tableToModules) {
-            if (mods.length > 1) {
-                shared_tables[table] = mods;
-                // Add shared_table edges
-                for (let i = 0; i < mods.length; i++) {
-                    for (let j = i + 1; j < mods.length; j++) {
-                        const key = `${mods[i]}<>${mods[j]}:${table}`;
-                        if (!edgeSet.has(key)) {
-                            edgeSet.add(key);
-                            edges.push({ from: mods[i], to: mods[j], type: "shared_table" });
-                        }
-                    }
-                }
-            }
-        }
-        // Shared endpoints
-        const endpointToModules = new Map();
-        for (const mod of modules) {
-            for (const ep of mod.endpoints) {
-                if (!endpointToModules.has(ep))
-                    endpointToModules.set(ep, []);
-                endpointToModules.get(ep).push(relPath(mod.path));
-            }
-        }
-        const shared_endpoints = {};
-        for (const [ep, mods] of endpointToModules) {
-            if (mods.length > 1)
-                shared_endpoints[ep] = mods;
-        }
-        // Most connected nodes (by total edge count)
-        const connectionCount = new Map();
-        for (const edge of edges) {
-            connectionCount.set(edge.from, (connectionCount.get(edge.from) ?? 0) + 1);
-            connectionCount.set(edge.to, (connectionCount.get(edge.to) ?? 0) + 1);
-        }
-        const most_connected = Array.from(connectionCount.entries())
-            .map(([id, count]) => ({
-            id,
-            label: nodeMap.get(id)?.label ?? id,
-            connection_count: count,
-        }))
-            .sort((a, b) => b.connection_count - a.connection_count)
-            .slice(0, 10);
-        // Apply focus filter: if focus is set, only include nodes/edges reachable from it
-        let nodes = Array.from(nodeMap.values());
-        let filteredEdges = edges;
-        if (input.focus) {
-            const focusNorm = input.focus.toLowerCase();
-            const focusId = nodes.find((n) => n.id.toLowerCase().includes(focusNorm))?.id;
-            if (focusId) {
-                const reachable = new Set([focusId]);
-                // BFS: include direct neighbours
-                for (const e of edges) {
-                    if (e.from === focusId)
-                        reachable.add(e.to);
-                    if (e.to === focusId)
-                        reachable.add(e.from);
-                }
-                nodes = nodes.filter((n) => reachable.has(n.id));
-                filteredEdges = edges.filter((e) => reachable.has(e.from) && reachable.has(e.to));
-            }
-        }
-        const sharedTableCount = Object.keys(shared_tables).length;
-        const summary = [
-            `${nodes.length} modules, ${filteredEdges.length} dependencies`,
-            sharedTableCount > 0 ? `${sharedTableCount} shared DB table(s)` : null,
-            most_connected.length > 0
-                ? `Most connected: ${most_connected[0].label} (${most_connected[0].connection_count} links)`
-                : null,
-        ]
-            .filter(Boolean)
-            .join(" · ");
-        return {
-            nodes,
-            edges: filteredEdges,
-            shared_tables,
-            shared_endpoints,
-            most_connected,
-            summary,
-        };
-    }
-    catch (e) {
-        return { error: e?.message ?? String(e) };
-    }
-}

package/dist/tools/get-schema-guidance.js

@@ -1,213 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSchemataGuidance = getSchemataGuidance;
-const node_path_1 = __importDefault(require("node:path"));
-const promises_1 = __importDefault(require("node:fs/promises"));
-/**
- * get_schema_guidance
- *
- * Analyzes what documents should exist based on the project schema and current wiki state.
- * Helps users understand what to create next.
- *
- * Input:
- * - project_path: string
- * - domain?: string (optional; auto-detected from schema if not provided)
- *
- * Output:
- * - domain: detected domain
- * - recommended_pages: list of pages that should exist with reasons
- * - existing_pages: what's already in the wiki
- * - missing_pages: high-priority missing documents
- * - recommendations: actionable next steps
- */
-async function getSchemataGuidance(input) {
-    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 schemaPath = node_path_1.default.join(docuDir, "schema.md");
-    // Read schema to understand domain
-    let domain = input.domain || "General";
-    try {
-        const schemaContent = await promises_1.default.readFile(schemaPath, "utf-8");
-        if (schemaContent.includes("Research"))
-            domain = "Research";
-        else if (schemaContent.includes("Business"))
-            domain = "Business";
-        else if (schemaContent.includes("Architecture"))
-            domain = "Code/Architecture";
-        else if (schemaContent.includes("Personal"))
-            domain = "Personal";
-    }
-    catch {
-        // Use default if schema not readable
-    }
-    // Scan wiki for existing pages
-    const indexPath = node_path_1.default.join(docuDir, "index.md");
-    const indexContent = await promises_1.default
-        .readFile(indexPath, "utf-8")
-        .catch(() => "");
-    // Count pages by category
-    const existingPages = [];
-    const categories = ["entities", "concepts", "syntheses", "timelines"];
-    for (const cat of categories) {
-        const catDir = node_path_1.default.join(wikiDir, cat);
-        try {
-            const files = await promises_1.default.readdir(catDir);
-            for (const file of files.filter((f) => f.endsWith(".md"))) {
-                existingPages.push({
-                    name: file.replace(".md", ""),
-                    category: cat,
-                });
-            }
-        }
-        catch {
-            // Directory may not exist
-        }
-    }
-    // Define recommended pages by domain
-    const recommendedByDomain = {
-        "Code/Architecture": [
-            {
-                name: "architecture_overview",
-                category: "syntheses",
-                suggested_title: "System Architecture Overview",
-                reason: "High-level view of how all components fit together",
-            },
-            {
-                name: "core_patterns",
-                category: "concepts",
-                suggested_title: "Core Architectural Patterns",
-                reason: "Design patterns used throughout the codebase",
-            },
-            {
-                name: "module_dependencies",
-                category: "concepts",
-                suggested_title: "Module Dependencies",
-                reason: "How modules depend on and integrate with each other",
-            },
-            {
-                name: "data_flow",
-                category: "syntheses",
-                suggested_title: "Data Flow Diagram",
-                reason: "How data moves through the system",
-            },
-        ],
-        Research: [
-            {
-                name: "research_overview",
-                category: "syntheses",
-                suggested_title: "Research Domain Overview",
-                reason: "Big picture of the research area",
-            },
-            {
-                name: "key_findings",
-                category: "syntheses",
-                suggested_title: "Key Findings & Synthesis",
-                reason: "Major discoveries and insights",
-            },
-            {
-                name: "contradictions",
-                category: "syntheses",
-                suggested_title: "Areas of Contradiction",
-                reason: "Where researchers disagree",
-            },
-            {
-                name: "open_questions",
-                category: "concepts",
-                suggested_title: "Open Research Questions",
-                reason: "What's still unknown in this domain",
-            },
-        ],
-        Business: [
-            {
-                name: "market_overview",
-                category: "syntheses",
-                suggested_title: "Market Overview",
-                reason: "Big picture of the market and competitive landscape",
-            },
-            {
-                name: "competitive_analysis",
-                category: "syntheses",
-                suggested_title: "Competitive Analysis",
-                reason: "Comparison of key competitors",
-            },
-            {
-                name: "opportunities",
-                category: "syntheses",
-                suggested_title: "Market Opportunities",
-                reason: "Gaps and growth areas",
-            },
-            {
-                name: "risks",
-                category: "concepts",
-                suggested_title: "Market Risks",
-                reason: "Threats and challenges",
-            },
-        ],
-        Personal: [
-            {
-                name: "learning_goals",
-                category: "concepts",
-                suggested_title: "Learning Goals",
-                reason: "What you want to learn in this domain",
-            },
-            {
-                name: "key_insights",
-                category: "syntheses",
-                suggested_title: "Key Personal Insights",
-                reason: "Major learnings and takeaways",
-            },
-            {
-                name: "action_items",
-                category: "concepts",
-                suggested_title: "Action Items & Next Steps",
-                reason: "What to do with this knowledge",
-            },
-            {
-                name: "resources",
-                category: "concepts",
-                suggested_title: "Key Resources",
-                reason: "Important links, books, people",
-            },
-        ],
-    };
-    const recommended = recommendedByDomain[domain] || recommendedByDomain.General;
-    // Find missing pages
-    const missingPages = [];
-    for (const rec of recommended) {
-        const found = existingPages.find((p) => p.name === rec.name);
-        if (!found) {
-            missingPages.push(rec.suggested_title);
-        }
-    }
-    // Generate recommendations
-    const recommendations = [];
-    if (existingPages.length === 0) {
-        recommendations.push("🌱 Start by ingesting your first source");
-        recommendations.push("📝 Create an overview/synthesis page");
-    }
-    else if (existingPages.length < 10) {
-        recommendations.push("📚 Add more sources to deepen understanding");
-        if (missingPages.length > 0) {
-            recommendations.push(`⚠️ Consider creating: ${missingPages[0]}`);
-        }
-    }
-    else if (existingPages.length > 50) {
-        recommendations.push("✅ You have a solid wiki foundation");
-        recommendations.push("🔍 Run lint_wiki to health-check for gaps");
-        recommendations.push("🔗 Verify cross-references are accurate");
-    }
-    if (missingPages.length > 2) {
-        recommendations.push(`💡 Biggest gap: ${missingPages[0]} could improve wiki significantly`);
-    }
-    return {
-        domain,
-        recommended_pages: recommended,
-        existing_pages: existingPages,
-        missing_pages: missingPages,
-        recommendations,
-    };
-}