@brainervirus/workit-mcp 8.1.0 → 8.1.1

package/dist/index.js

@@ -16574,7 +16574,7 @@ class StdioServerTransport {
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // packages/workit-core/src/core.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
+import { spawnSync as spawnSync14 } from "node:child_process";
 import { existsSync as existsSync7, realpathSync as realpathSync5 } from "node:fs";
 import path19 from "node:path";
 
@@ -23032,6 +23032,7 @@ var gitContext = (workspaceRoot, paths = []) => {
 };
 
 // packages/workit-core/src/core/workspaces.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { createHash as createHash8 } from "node:crypto";
 import { readFileSync as readFileSync4, realpathSync as realpathSync3 } from "node:fs";
 import path13 from "node:path";
@@ -23276,6 +23277,53 @@ var validateWorkspaceGlob = (glob) => {
   }
   return { ok: true };
 };
+
+class WorkspaceConfigError extends Error {
+  name = "WorkspaceConfigError";
+}
+var mainCheckouts = new Map;
+var mainCheckoutOf = (cwd) => {
+  const cached = mainCheckouts.get(cwd);
+  if (cached !== undefined)
+    return cached;
+  const env = { ...process.env };
+  for (const name of ["GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_INDEX_FILE"])
+    delete env[name];
+  const git = (args) => {
+    const run = spawnSync8("git", args, {
+      cwd,
+      env,
+      encoding: "utf8",
+      timeout: 5000,
+      windowsHide: true
+    });
+    return run.status === 0 ? run.stdout : null;
+  };
+  let main = null;
+  const dirs = git(["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
+  const [gitDir, common] = (dirs ?? "").trim().split(/\r?\n/u);
+  if (gitDir && common && path13.resolve(gitDir) !== path13.resolve(common)) {
+    const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
+    main = listed?.trim() || (path13.basename(common) === ".git" ? path13.dirname(common) : common);
+  }
+  mainCheckouts.set(cwd, main);
+  return main;
+};
+var matchingEntries = (cwd, entries) => {
+  const match = (where) => {
+    const targets = [where, realpathOf(where)].map((value) => value.replaceAll("\\", "/"));
+    return entries.filter((entry) => {
+      const glob = entry.glob.replaceAll("\\", "/");
+      const canonical = canonicalGlob(glob);
+      return targets.some((target) => matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target));
+    });
+  };
+  const direct = match(cwd);
+  if (direct.length)
+    return direct;
+  const main = mainCheckoutOf(cwd);
+  return main ? match(main) : direct;
+};
 var realpathOf = (p) => {
   const real = realpathSync3.native ?? realpathSync3;
   try {
@@ -23300,43 +23348,29 @@ var selectWorkspaceMatch = (matches, cwd, workspaceName) => {
     if (named.length === 1)
       return named[0];
     if (named.length > 1)
-      throw new Error(`ambiguous workspace ${JSON.stringify(workspaceName)} for ${cwd}`);
+      throw new WorkspaceConfigError(`ambiguous workspace ${JSON.stringify(workspaceName)} for ${cwd}`);
     if (matches.length > 0) {
-      throw new Error(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}; matching choices: ${matches.map((entry) => entry.name).join(", ")}`);
+      throw new WorkspaceConfigError(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}; matching choices: ${matches.map((entry) => entry.name).join(", ")}`);
     }
-    throw new Error(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}`);
+    throw new WorkspaceConfigError(`workspace ${JSON.stringify(workspaceName)} does not match ${cwd}`);
   }
   if (matches.length < 2)
     return matches[0];
   const highestSpecificity = Math.max(...matches.map((entry) => globSpecificity(entry.glob)));
   const mostSpecific = matches.filter((entry) => globSpecificity(entry.glob) === highestSpecificity);
   if (mostSpecific.length > 1) {
-    throw new Error(`ambiguous workspace for ${cwd}; choose one of: ${mostSpecific.map((entry) => entry.name).join(", ")}`);
+    throw new WorkspaceConfigError(`ambiguous workspace for ${cwd}; choose one of: ${mostSpecific.map((entry) => entry.name).join(", ")}`);
   }
   return mostSpecific[0];
 };
 var resolveWorkspaceFromEntries = (cwd, entries, workspaceName) => {
-  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
-  const matches = [];
-  for (const ws of entries) {
-    const glob = ws.glob.replaceAll("\\", "/");
-    const canonical = canonicalGlob(glob);
-    let matched = false;
-    for (const target of targets) {
-      if (matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target)) {
-        matched = true;
-        break;
-      }
-    }
-    if (matched)
-      matches.push(ws);
-  }
+  const matches = matchingEntries(cwd, entries);
   return selectWorkspaceMatch(matches, cwd, workspaceName) ?? null;
 };
 var resolveWorkspaceFrom = (cwd, dir, workspaceName) => {
   const result = readWorkspacesResult(dir);
   if (result.status === "malformed" || result.status === "invalid")
-    throw new Error(result.error);
+    throw new WorkspaceConfigError(result.error);
   return resolveWorkspaceFromEntries(cwd, result.entries, workspaceName);
 };
 var runtimeWorkspacePolicySchema = (kind) => {
@@ -23368,31 +23402,26 @@ var matchRuntimeWorkspace = (cwd) => {
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
-    throw new Error(`${file} could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    throw new WorkspaceConfigError(`${file} could not be read: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
   }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw new Error(`${file} is not valid JSON`);
+    throw new WorkspaceConfigError(`${file} is not valid JSON`);
   }
   const validated = runtimeWorkspaceIndexSchema.safeParse(parsed);
   if (!validated.success) {
     const detail = validated.error.issues.map((issue) => `${issue.path.map(String).join(".") || "workspaces"}: ${issue.message}`).join("; ");
-    throw new Error(`${file} has invalid workspace matching data: ${detail}`);
+    throw new WorkspaceConfigError(`${file} has invalid workspace matching data: ${detail}`);
   }
   const entries = validated.data.workspaces;
   for (const entry of entries ?? []) {
     const glob = validateWorkspaceGlob(entry.glob);
     if (!glob.ok)
-      throw new Error(`${file} workspace ${entry.name}: ${glob.error}`);
+      throw new WorkspaceConfigError(`${file} workspace ${entry.name}: ${glob.error}`);
   }
-  const targets = [cwd, realpathOf(cwd)].map((value) => value.replaceAll("\\", "/"));
-  const matches = (entries ?? []).filter((entry) => {
-    const glob = entry.glob.replaceAll("\\", "/");
-    const canonical = canonicalGlob(glob);
-    return targets.some((target) => matchWorkspace(glob, target) || canonical !== glob && matchWorkspace(canonical, target));
-  });
+  const matches = matchingEntries(cwd, entries ?? []);
   const workspaceName = process.env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined;
   const selected = selectWorkspaceMatch(matches, cwd, workspaceName);
   return selected ? { file, selected } : null;
@@ -23409,7 +23438,7 @@ var resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
   const policy = runtimeWorkspacePolicySchema(kind).safeParse(selected);
   if (!policy.success) {
     const detail = policy.error.issues.map((issue) => `${issue.path.map(String).join(".") || "workspace"}: ${issue.message}`).join("; ");
-    throw new Error(`${file} has invalid ${kind} policy configuration: ${detail}`);
+    throw new WorkspaceConfigError(`${file} has invalid ${kind} policy configuration: ${detail}`);
   }
   return policy.data;
 };
@@ -23420,10 +23449,10 @@ var resolveRuntimeWorkspacePolicy = (cwd, kind, requestedProfile) => {
   const key = kind === "branch" ? "branchPolicy" : "commitPolicy";
   const profileName = requestedProfile?.trim() || candidate.defaultProfile;
   if (candidate.defaultProfile && !Object.hasOwn(candidate.profiles ?? {}, candidate.defaultProfile))
-    throw new Error(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(candidate.defaultProfile)}`);
+    throw new WorkspaceConfigError(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(candidate.defaultProfile)}`);
   const profile = profileName ? candidate.profiles?.[profileName] : undefined;
   if (profileName && !profile)
-    throw new Error(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(profileName)}`);
+    throw new WorkspaceConfigError(`workspace ${JSON.stringify(candidate.name)} has no profile ${JSON.stringify(profileName)}`);
   const profilePolicy = profile?.[key];
   const workspacePolicy = candidate[key];
   return {
@@ -23443,11 +23472,11 @@ function workspaceDefaultTarget(cwd, globalDefault) {
 // packages/workit-core/src/core/vcs-config.ts
 import fs12 from "node:fs";
 import path14 from "node:path";
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 
 // packages/workit-core/src/core/release-tracks.ts
 import { createHash as createHash9 } from "node:crypto";
-import { spawnSync as spawnSync8 } from "node:child_process";
+import { spawnSync as spawnSync9 } from "node:child_process";
 var KNOWN_FIELDS = new Set([
   "strategy",
   "productionBranch",
@@ -23719,7 +23748,7 @@ function resolveReleaseTrack(input) {
   return fallback(`${branch} has the same or unrelated fork points with ${[...new Set(newest.map((fork) => `${fork.ref} (${fork.track.name === IMPLICIT ? "workspace default" : fork.track.name})`))].join(" and ")}`);
 }
 var git4 = (cwd, args) => {
-  const run = spawnSync8("git", args, {
+  const run = spawnSync9("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 20000,
@@ -23834,7 +23863,7 @@ function resolveTrackFor(cwd, options) {
 var workspacesPath = () => path14.join(configDir(), "workspaces.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync9("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync10("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -23871,7 +23900,7 @@ var remoteEndpoint = (remote) => {
 var configuredSshEndpoint = (host) => {
   if (host.startsWith("-"))
     return null;
-  const resolved = spawnSync9("ssh", ["-G", host], {
+  const resolved = spawnSync10("ssh", ["-G", host], {
     encoding: "utf8",
     timeout: 5000,
     maxBuffer: 1024 * 1024,
@@ -24044,7 +24073,7 @@ function mergedPrStyle(limit = 6, cwd) {
 `).filter((l) => l.startsWith("## ")).map((l) => l.trim()),
     descriptionPreview: desc.slice(0, 600)
   });
-  const remoteResult = spawnSync9("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const remoteResult = spawnSync10("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -24060,7 +24089,7 @@ function mergedPrStyle(limit = 6, cwd) {
   if (!hostingApiHostMatches(remote, host))
     return { ok: false, error: "PR style target does not match the provider host" };
   if (provider === "gitlab") {
-    const run = (args) => spawnSync9("glab", ["api", ...args], {
+    const run = (args) => spawnSync10("glab", ["api", ...args], {
       cwd,
       encoding: "utf8",
       env
@@ -24080,7 +24109,7 @@ function mergedPrStyle(limit = 6, cwd) {
       });
     }
   } else if (provider === "github") {
-    const r = spawnSync9("gh", [
+    const r = spawnSync10("gh", [
       "pr",
       "list",
       "--repo",
@@ -26017,7 +26046,7 @@ class WorkitCore {
   }
 }
 // packages/workit-core/src/core/repo-context.ts
-import { spawnSync as spawnSync10 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync6, readFileSync as readFileSync5, readdirSync as readdirSync4 } from "node:fs";
 import path16 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
@@ -26046,7 +26075,7 @@ var invalidRange = (cwd) => ({
   cwd
 });
 var runGit = (cwd, args) => {
-  const result = spawnSync10("git", args, { cwd, encoding: "utf8" });
+  const result = spawnSync11("git", args, { cwd, encoding: "utf8" });
   return {
     stdout: (result.stdout ?? "").trimEnd(),
     stderr: (result.stderr ?? "").trimEnd(),
@@ -26487,12 +26516,12 @@ function releaseNotesContext(root, rangeOrTag) {
 }
 
 // packages/workit-core/src/core/tracker-issues.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync13 } from "node:child_process";
 
 // packages/workit-core/src/core/pr-create.ts
 import fs13 from "node:fs";
 import path17 from "node:path";
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
   const m = /issues\/(\d+)/.exec(value);
@@ -26517,7 +26546,7 @@ function whichOnPath(tool) {
 }
 var hostingCliAvailable = (provider) => whichOnPath(provider === "gitlab" ? "glab" : "gh") !== null;
 var pushRemote = (cwd) => {
-  const result = spawnSync11("git", ["remote", "get-url", "--push", "--all", "origin"], {
+  const result = spawnSync12("git", ["remote", "get-url", "--push", "--all", "origin"], {
     cwd,
     encoding: "utf8"
   });
@@ -26548,7 +26577,7 @@ var defaultCli = (bin, available) => {
   if (!available)
     return null;
   return (args, root) => {
-    const out = spawnSync12(bin, args, {
+    const out = spawnSync13(bin, args, {
       cwd: root,
       encoding: "utf8",
       env: { ...process.env, PATH: process.env.PATH ?? "" }
@@ -27066,7 +27095,7 @@ function resolveInside(root, candidate) {
 }
 function run2(root, executable, args, env = {}) {
   const cwd = realpathSync5(root);
-  const result = spawnSync13(executable, args, {
+  const result = spawnSync14(executable, args, {
     cwd,
     encoding: "utf8",
     env: { ...process.env, ...env }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-mcp",
-  "version": "8.1.0",
+  "version": "8.1.1",
   "private": false,
   "description": "Workit shared MCP transport for the eight task and policy operation families",
   "keywords": [
@@ -42,7 +42,7 @@
     "build": "bun scripts/build.ts"
   },
   "dependencies": {
-    "@brainervirus/workit-core": "^8.1.0",
+    "@brainervirus/workit-core": "^8.1.1",
     "@modelcontextprotocol/sdk": "1.32.0",
     "zod": "4.6.5"
   },