@programinglive/dev-workflow-mcp-server 1.1.11 → 1.1.18

package/web/server.js

@@ -1,5 +1,5 @@
 import { createServer } from "http";
-import { readFile } from "fs/promises";
+import { readFile, access } from "fs/promises";
 import { fileURLToPath } from "url";
 import { dirname, join } from "path";
 import getPort from "get-port";
@@ -7,6 +7,12 @@ import { getHistoryForUser, getSummaryForUser, getHistorySummary } from "../db/i
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+const projectRoot = join(__dirname, "..");
+
+const allowedDocs = {
+  "README.md": join(projectRoot, "README.md"),
+  "web-dashboard.md": join(projectRoot, "docs", "web-dashboard.md"),
+};
 
 async function start() {
   const PORT = process.env.DEV_WORKFLOW_WEB_PORT || await getPort({ port: 3111 });
@@ -39,6 +45,33 @@ async function start() {
         const summary = getHistorySummary(userId, { startDate, endDate, frequency });
         res.writeHead(200, { "Content-Type": "application/json" });
         res.end(JSON.stringify({ summary }));
+      } else if (req.method === "GET" && url.pathname === "/api/docs") {
+        const rawDocKey = url.searchParams.get("doc");
+        if (!rawDocKey) {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ docs: Object.keys(allowedDocs) }));
+          return;
+        }
+
+        const docKey = rawDocKey.trim();
+        const resolvedKey = Object.keys(allowedDocs).find((key) => key.toLowerCase() === docKey.toLowerCase());
+        if (!resolvedKey) {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: "Document not found", requested: docKey, available: Object.keys(allowedDocs) }));
+          return;
+        }
+
+        const docPath = allowedDocs[resolvedKey];
+
+        try {
+          await access(docPath);
+          const content = await readFile(docPath, "utf-8");
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ doc: resolvedKey, content }));
+        } catch (error) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: error.message }));
+        }
       } else {
         res.writeHead(404, { "Content-Type": "text/plain" });
         res.end("Not found");

package/workflow-state.js

@@ -107,21 +107,88 @@ function hasProjectMarkers(candidate) {
   );
 }
 
-function selectProjectRoot(candidates) {
+function normalizeAndStoreCandidate(list, candidate) {
+  if (!candidate) {
+    return;
+  }
+
+  const resolved = path.resolve(candidate);
+  if (!list.includes(resolved)) {
+    list.push(resolved);
+  }
+}
+
+function addAncestorCandidates(list, start) {
+  if (!start) {
+    return;
+  }
+
+  let current = path.resolve(start);
+  while (!isRootPath(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    if (!isRootPath(parent)) {
+      normalizeAndStoreCandidate(list, parent);
+    }
+    current = parent;
+  }
+}
+
+function selectProjectRoot(candidates, moduleRoot) {
+  const cwdResolved = path.resolve(process.cwd());
+  const prioritized = [];
+
   for (const candidate of candidates) {
     if (!candidate) {
       continue;
     }
 
     const resolved = path.resolve(candidate);
-    if (isRootPath(resolved) && !hasProjectMarkers(resolved)) {
+    if (prioritized.some((entry) => entry.resolved === resolved)) {
       continue;
     }
 
-    return resolved;
+    prioritized.push({
+      resolved,
+      hasMarkers: hasProjectMarkers(resolved),
+      isRoot: isRootPath(resolved),
+      isCwdAncestor: cwdResolved === resolved || cwdResolved.startsWith(`${resolved}${path.sep}`),
+    });
+  }
+
+  const ancestorWithMarkers = prioritized.find((entry) => entry.isCwdAncestor && entry.hasMarkers);
+  if (ancestorWithMarkers) {
+    return ancestorWithMarkers.resolved;
   }
 
-  return null;
+  const ancestorWithoutMarkers = prioritized
+    .filter((entry) => entry.isCwdAncestor && !entry.hasMarkers && !entry.isRoot)
+    .sort((a, b) => b.resolved.length - a.resolved.length);
+  if (ancestorWithoutMarkers.length > 0) {
+    return ancestorWithoutMarkers[0].resolved;
+  }
+
+  if (moduleRoot) {
+    const moduleResolved = path.resolve(moduleRoot);
+    const moduleEntry = prioritized.find((entry) => entry.resolved === moduleResolved && !entry.isRoot);
+    if (moduleEntry) {
+      return moduleEntry.resolved;
+    }
+  }
+
+  const withMarkers = prioritized.find((entry) => entry.hasMarkers);
+  if (withMarkers) {
+    return withMarkers.resolved;
+  }
+
+  const nonRoot = prioritized.find((entry) => !entry.isRoot);
+  if (nonRoot) {
+    return nonRoot.resolved;
+  }
+
+  return prioritized.length > 0 ? prioritized[0].resolved : null;
 }
 
 function getUserScopedDir(baseDir) {
@@ -339,33 +406,29 @@ export function resolveStateFile() {
   const candidateRoots = [];
 
   const initProjectRoot = findProjectRoot(resolvedInitCwd);
-  if (initProjectRoot) {
-    candidateRoots.push(initProjectRoot);
-  }
-
-  const moduleProjectRoot = findProjectRoot(moduleRoot);
-  if (moduleProjectRoot) {
-    candidateRoots.push(moduleProjectRoot);
-  } else if (!isRootPath(moduleRoot)) {
-    candidateRoots.push(moduleRoot);
-  }
-
   const cwdProjectRoot = findProjectRoot(cwdResolved);
-  if (cwdProjectRoot) {
-    candidateRoots.push(cwdProjectRoot);
-  } else if (!isRootPath(cwdResolved)) {
-    candidateRoots.push(cwdResolved);
-  }
+  const moduleProjectRoot = findProjectRoot(moduleRoot);
 
+  normalizeAndStoreCandidate(candidateRoots, initProjectRoot);
+  normalizeAndStoreCandidate(candidateRoots, cwdProjectRoot);
   if (!isRootPath(resolvedInitCwd)) {
-    candidateRoots.push(resolvedInitCwd);
+    normalizeAndStoreCandidate(candidateRoots, resolvedInitCwd);
+    addAncestorCandidates(candidateRoots, resolvedInitCwd);
+  }
+  if (!isRootPath(cwdResolved)) {
+    normalizeAndStoreCandidate(candidateRoots, cwdResolved);
+    addAncestorCandidates(candidateRoots, cwdResolved);
   }
 
+  normalizeAndStoreCandidate(candidateRoots, moduleProjectRoot);
+  if (!isRootPath(moduleRoot)) {
+    normalizeAndStoreCandidate(candidateRoots, moduleRoot);
+  }
   if (!isRootPath(__dirname)) {
-    candidateRoots.push(__dirname);
+    normalizeAndStoreCandidate(candidateRoots, __dirname);
   }
 
-  let projectRoot = selectProjectRoot(candidateRoots);
+  let projectRoot = selectProjectRoot(candidateRoots, moduleRoot);
 
   if (!projectRoot) {
     projectRoot = path.resolve(__dirname);