@doquflow/server 1.3.0 → 1.4.0

package/dist/tools/build-graph.js

@@ -0,0 +1,111 @@
+"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/list-wiki.js

@@ -20,34 +20,98 @@ const SINGULAR_TO_PLURAL = {
     synthesis: "syntheses",
 };
 const STALE_DAYS = 30;
+function unquote(s) {
+    const t = s.trim();
+    if (t.length >= 2) {
+        const first = t[0];
+        const last = t[t.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return t.slice(1, -1);
+        }
+    }
+    return t;
+}
 /**
- * Parse frontmatter from markdown
+ * Parse YAML-ish frontmatter from markdown.
+ *
+ * Supports:
+ *   - Inline JSON/flow:  key: ["a", "b"]   or   key: {x: 1}
+ *   - Block-style list:  key:\n  - "a"\n  - "b"
+ *   - Scalar:            key: value (values may contain ':' — split on FIRST ':' only)
  */
 function parseFrontmatter(content) {
     const match = content.match(/^---\n([\s\S]*?)\n---/);
     if (!match)
         return {};
-    const yaml = match[1];
+    const lines = match[1].split("\n");
     const result = {};
-    for (const line of yaml.split("\n")) {
-        if (!line.trim())
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        if (!trimmed) {
+            i++;
+            continue;
+        }
+        // Block-list continuation handled inside the key branch below; top-level
+        // dashes without a preceding key are ignored.
+        if (trimmed.startsWith("- ")) {
+            i++;
+            continue;
+        }
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1) {
+            i++;
             continue;
-        const [key, ...valueParts] = line.split(":");
-        const value = valueParts.join(":").trim();
-        try {
-            if (value.startsWith("[") || value.startsWith("{")) {
-                result[key.trim()] = JSON.parse(value);
+        }
+        const key = line.slice(0, colonIdx).trim();
+        const rawValue = line.slice(colonIdx + 1).trim();
+        if (rawValue === "") {
+            // Possibly a block-style list on subsequent lines: "  - value"
+            const items = [];
+            let j = i + 1;
+            while (j < lines.length) {
+                const next = lines[j];
+                if (!next.trim()) {
+                    j++;
+                    continue;
+                }
+                // A block-list item must be indented and start with "- ".
+                const m = next.match(/^(\s+)-\s+(.*)$/);
+                if (!m)
+                    break;
+                items.push(unquote(m[2]));
+                j++;
+            }
+            if (items.length > 0) {
+                result[key] = items;
             }
             else {
-                result[key.trim()] = value;
+                result[key] = "";
+            }
+            i = j;
+            continue;
+        }
+        if (rawValue.startsWith("[") || rawValue.startsWith("{")) {
+            try {
+                result[key] = JSON.parse(rawValue);
+            }
+            catch {
+                result[key] = rawValue;
             }
         }
-        catch {
-            result[key.trim()] = value;
+        else {
+            result[key] = unquote(rawValue);
         }
+        i++;
     }
     return result;
 }
+function toStringArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === "string");
+}
 /**
  * Extract title from markdown
  */
@@ -89,6 +153,8 @@ async function listWiki(input) {
                     const updatedAt = fm.updated_at ?? new Date().toISOString();
                     const updatedMs = new Date(updatedAt).getTime();
                     const stale = !isNaN(updatedMs) && (now - updatedMs) > STALE_DAYS * 86_400_000;
+                    const outbound_links = toStringArray(fm.outbound_links);
+                    const inbound_links = toStringArray(fm.inbound_links);
                     pages.push({
                         id: pageId,
                         title,
@@ -96,9 +162,12 @@ async function listWiki(input) {
                         path: node_path_1.default.relative(docuDir, filePath),
                         created_at: fm.created_at ?? new Date().toISOString(),
                         updated_at: updatedAt,
-                        sources: fm.sources ?? [],
-                        tags: fm.tags ?? [],
+                        sources: toStringArray(fm.sources),
+                        tags: toStringArray(fm.tags),
                         stale,
+                        outbound_links,
+                        inbound_links,
+                        degree: outbound_links.length + inbound_links.length,
                     });
                     categoryCount++;
                 }

package/package.json

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