@projitive/mcp 1.1.2 → 1.2.0

package/README.md

@@ -84,7 +84,7 @@ MCP client config example (`mcp.json`):
       "command": "npx",
       "args": ["-y", "@projitive/mcp"],
       "env": {
-        "PROJITIVE_SCAN_ROOT_PATH": "/absolute/path/to/your/workspace",
+        "PROJITIVE_SCAN_ROOT_PATHS": "/workspace/a:/workspace/b",
         "PROJITIVE_SCAN_MAX_DEPTH": "3"
       }
     }
@@ -94,7 +94,9 @@ MCP client config example (`mcp.json`):
 
 Environment variables (required):
 
-- `PROJITIVE_SCAN_ROOT_PATH`: required scan root for discovery methods.
+- `PROJITIVE_SCAN_ROOT_PATHS`: required scan roots for discovery methods.
+  - Use platform-delimiter string (`:` on Linux/macOS, `;` on Windows), e.g. `/workspace/a:/workspace/b`.
+  - Fallback: if not set, legacy `PROJITIVE_SCAN_ROOT_PATH` is used.
 - `PROJITIVE_SCAN_MAX_DEPTH`: required scan depth for discovery methods (integer `0-8`).
 
 Local path startup is not the recommended usage mode in this README.

package/output/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@projitive/mcp",
-    "version": "1.1.2",
+    "version": "1.2.0",
     "description": "Projitive MCP Server for project and task discovery/update",
     "license": "ISC",
     "author": "",

package/output/source/tools/project.js

@@ -46,9 +46,43 @@ function requireEnvVar(name) {
     }
     return value.trim();
 }
+function normalizeScanRoots(rootPaths) {
+    const normalized = rootPaths
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0)
+        .map((entry) => normalizePath(entry));
+    return Array.from(new Set(normalized));
+}
+function parseScanRoots(rawValue) {
+    const trimmed = rawValue.trim();
+    if (trimmed.length === 0) {
+        return [];
+    }
+    return trimmed.split(path.delimiter);
+}
+export function resolveScanRoots(inputPaths) {
+    const normalizedInputPaths = normalizeScanRoots(inputPaths ?? []);
+    if (normalizedInputPaths.length > 0) {
+        return normalizedInputPaths;
+    }
+    const configuredRoots = process.env.PROJITIVE_SCAN_ROOT_PATHS;
+    const rootsFromMultiEnv = typeof configuredRoots === "string"
+        ? normalizeScanRoots(parseScanRoots(configuredRoots))
+        : [];
+    if (rootsFromMultiEnv.length > 0) {
+        return rootsFromMultiEnv;
+    }
+    const legacyRoot = process.env.PROJITIVE_SCAN_ROOT_PATH;
+    const rootsFromLegacyEnv = typeof legacyRoot === "string"
+        ? normalizeScanRoots([legacyRoot])
+        : [];
+    if (rootsFromLegacyEnv.length > 0) {
+        return rootsFromLegacyEnv;
+    }
+    throw new Error("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATHS (or legacy PROJITIVE_SCAN_ROOT_PATH)");
+}
 export function resolveScanRoot(inputPath) {
-    const configuredRoot = requireEnvVar("PROJITIVE_SCAN_ROOT_PATH");
-    return normalizePath(inputPath ?? configuredRoot);
+    return resolveScanRoots(inputPath ? [inputPath] : undefined)[0];
 }
 export function resolveScanDepth(inputDepth) {
     const configuredDepthRaw = requireEnvVar("PROJITIVE_SCAN_MAX_DEPTH");
@@ -210,6 +244,10 @@ export async function discoverProjects(rootPath, maxDepth) {
     await walk(rootPath, 0);
     return Array.from(new Set(results)).sort();
 }
+export async function discoverProjectsAcrossRoots(rootPaths, maxDepth) {
+    const perRootResults = await Promise.all(rootPaths.map((rootPath) => discoverProjects(rootPath, maxDepth)));
+    return Array.from(new Set(perRootResults.flat())).sort();
+}
 async function pathExists(targetPath) {
     const accessResult = await catchIt(fs.access(targetPath));
     return !accessResult.isError();
@@ -362,14 +400,15 @@ export function registerProjectTools(server) {
         description: "Start here when project path is unknown; discover all governance roots",
         inputSchema: {},
     }, async () => {
-        const root = resolveScanRoot();
+        const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjects(root, depth);
+        const projects = await discoverProjectsAcrossRoots(roots, depth);
         const markdown = renderToolResponseMarkdown({
             toolName: "projectScan",
             sections: [
                 summarySection([
-                    `- rootPath: ${root}`,
+                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- discoveredCount: ${projects.length}`,
                 ]),
@@ -398,9 +437,9 @@ export function registerProjectTools(server) {
             limit: z.number().int().min(1).max(50).optional(),
         },
     }, async ({ limit }) => {
-        const root = resolveScanRoot();
+        const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjects(root, depth);
+        const projects = await discoverProjectsAcrossRoots(roots, depth);
         const snapshots = await Promise.all(projects.map(async (governanceDir) => {
             const snapshot = await readTasksSnapshot(governanceDir);
             const inProgress = snapshot.tasks.filter((task) => task.status === "IN_PROGRESS").length;
@@ -435,7 +474,8 @@ export function registerProjectTools(server) {
             toolName: "projectNext",
             sections: [
                 summarySection([
-                    `- rootPath: ${root}`,
+                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- matchedProjects: ${projects.length}`,
                     `- actionableProjects: ${ranked.length}`,

package/output/source/tools/project.test.js

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { discoverProjects, hasProjectMarker, initializeProjectStructure, resolveGovernanceDir, resolveScanRoot, resolveScanDepth, toProjectPath, registerProjectTools } from "./project.js";
+import { discoverProjects, discoverProjectsAcrossRoots, hasProjectMarker, initializeProjectStructure, resolveGovernanceDir, resolveScanRoots, resolveScanDepth, toProjectPath, registerProjectTools } from "./project.js";
 const tempPaths = [];
 async function createTempDir() {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "projitive-mcp-test-"));
@@ -186,6 +186,15 @@ describe("projitive module", () => {
             const projects = await discoverProjects(root, 3);
             expect(projects).toEqual([]);
         });
+        it("ignores non-existent roots when scanning across multiple roots", async () => {
+            const validRoot = await createTempDir();
+            const validProject = path.join(validRoot, "project-a");
+            const missingRoot = path.join(validRoot, "__missing_root__");
+            await fs.mkdir(validProject, { recursive: true });
+            await fs.writeFile(path.join(validProject, ".projitive"), "", "utf-8");
+            const projects = await discoverProjectsAcrossRoots([missingRoot, validRoot], 3);
+            expect(projects).toContain(validProject);
+        });
     });
     describe("initializeProjectStructure", () => {
         it("initializes governance structure under default .projitive directory", async () => {
@@ -267,20 +276,30 @@ describe("projitive module", () => {
                 expect(toProjectPath("/a/b/c")).toBe("/a/b");
             });
         });
-        describe("resolveScanRoot", () => {
-            it("uses environment variable when no input path", () => {
+        describe("resolveScanRoots", () => {
+            it("uses legacy environment variable when no multi-root env is provided", () => {
                 vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
-                expect(resolveScanRoot()).toBe("/test/root");
+                expect(resolveScanRoots()).toEqual(["/test/root"]);
                 vi.unstubAllEnvs();
             });
-            it("uses input path when provided", () => {
+            it("uses input paths when provided", () => {
                 vi.stubEnv("PROJITIVE_SCAN_ROOT_PATH", "/test/root");
-                expect(resolveScanRoot("/custom/path")).toBe("/custom/path");
+                expect(resolveScanRoots(["/custom/path", " /custom/path ", "/second/path"])).toEqual(["/custom/path", "/second/path"]);
+                vi.unstubAllEnvs();
+            });
+            it("uses PROJITIVE_SCAN_ROOT_PATHS with platform delimiter", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATHS", ["/root/a", "/root/b", "", " /root/c "].join(path.delimiter));
+                expect(resolveScanRoots()).toEqual(["/root/a", "/root/b", "/root/c"]);
+                vi.unstubAllEnvs();
+            });
+            it("treats JSON-like string as plain delimiter input", () => {
+                vi.stubEnv("PROJITIVE_SCAN_ROOT_PATHS", JSON.stringify(["/json/a", "/json/b"]));
+                expect(resolveScanRoots()).toHaveLength(1);
                 vi.unstubAllEnvs();
             });
-            it("throws error when required environment variable missing", () => {
+            it("throws error when no root environment variables are configured", () => {
                 vi.unstubAllEnvs();
-                expect(() => resolveScanRoot()).toThrow("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATH");
+                expect(() => resolveScanRoots()).toThrow("Missing required environment variable: PROJITIVE_SCAN_ROOT_PATHS");
             });
         });
         describe("resolveScanDepth", () => {

package/output/source/tools/task.js

@@ -4,7 +4,7 @@ import { z } from "zod";
 import { candidateFilesFromArtifacts, discoverGovernanceArtifacts, findTextReferences } from "../common/index.js";
 import { asText, evidenceSection, guidanceSection, lintSection, nextCallSection, renderErrorMarkdown, renderToolResponseMarkdown, summarySection, } from "../common/index.js";
 import { catchIt, TASK_LINT_CODES, renderLintSuggestions } from "../common/index.js";
-import { resolveGovernanceDir, resolveScanDepth, resolveScanRoot, discoverProjects, toProjectPath } from "./project.js";
+import { resolveGovernanceDir, resolveScanDepth, resolveScanRoots, discoverProjectsAcrossRoots, toProjectPath } from "./project.js";
 import { isValidRoadmapId } from "./roadmap.js";
 import { SUB_STATE_PHASES, BLOCKER_TYPES } from "../types.js";
 export const TASKS_START = "<!-- PROJITIVE:TASKS:START -->";
@@ -820,9 +820,9 @@ export function registerTaskTools(server) {
             limit: z.number().int().min(1).max(20).optional(),
         },
     }, async ({ limit }) => {
-        const root = resolveScanRoot();
+        const roots = resolveScanRoots();
         const depth = resolveScanDepth();
-        const projects = await discoverProjects(root, depth);
+        const projects = await discoverProjectsAcrossRoots(roots, depth);
         const rankedCandidates = rankActionableTaskCandidates(await readActionableTaskCandidates(projects));
         if (rankedCandidates.length === 0) {
             const projectSnapshots = await Promise.all(projects.map(async (governanceDir) => {
@@ -850,7 +850,8 @@ export function registerTaskTools(server) {
                 toolName: "taskNext",
                 sections: [
                     summarySection([
-                        `- rootPath: ${root}`,
+                        `- rootPaths: ${roots.join(", ")}`,
+                        `- rootCount: ${roots.length}`,
                         `- maxDepth: ${depth}`,
                         `- matchedProjects: ${projects.length}`,
                         "- actionableTasks: 0",
@@ -900,7 +901,8 @@ export function registerTaskTools(server) {
             toolName: "taskNext",
             sections: [
                 summarySection([
-                    `- rootPath: ${root}`,
+                    `- rootPaths: ${roots.join(", ")}`,
+                    `- rootCount: ${roots.length}`,
                     `- maxDepth: ${depth}`,
                     `- matchedProjects: ${projects.length}`,
                     `- actionableTasks: ${rankedCandidates.length}`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@projitive/mcp",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "description": "Projitive MCP Server for project and task discovery/update",
   "license": "ISC",
   "author": "",