@brainervirus/workit-core 0.4.0

package/src/core/sdd.ts

@@ -0,0 +1,188 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { parseTasksFromPlan } from "./docs-validate";
+import { docsValidate } from "./docs-validate";
+import { readFlowState } from "./flow-state";
+
+const posix = (p: string) => p.split(path.sep).join("/");
+
+export const slugFromPlan = (planPath: string) => {
+  const dirName = path.basename(path.dirname(planPath));
+  return dirName === "." || dirName === "/" || dirName === "" ? "" : dirName;
+};
+
+/** OpenCode todowrite payload. SDD ledger is persistence, not a UI substitute. */
+export function todosFromTasks(
+  tasks: { id: number | string; title: string }[],
+  completedTaskIds: (number | string)[] = [],
+) {
+  const done = new Set((completedTaskIds ?? []).map((id) => Number(id)));
+  const todos = (tasks ?? []).map((t) => {
+    const id = Number(t.id);
+    return {
+      id: `task-${id}`,
+      content: `Task ${id}: ${t.title ?? ""}`.trim(),
+      status: done.has(id) ? "completed" : "pending",
+    };
+  });
+  const firstPending = todos.find((t) => t.status === "pending");
+  if (firstPending) firstPending.status = "in_progress";
+  return todos;
+}
+
+export function sddContext({
+  slug,
+  plan_path,
+  workspace_root,
+}: {
+  slug?: string;
+  plan_path?: string;
+  workspace_root: string;
+}) {
+  const cwd = path.resolve(workspace_root);
+  let resolvedSlug = slug;
+  let resolvedPlanPath = plan_path;
+  if (!resolvedSlug && plan_path) {
+    resolvedPlanPath = path.isAbsolute(plan_path) ? plan_path : path.join(cwd, plan_path);
+    resolvedSlug = slugFromPlan(resolvedPlanPath);
+  }
+  if (!resolvedSlug) return { error: "slug or plan_path required" };
+
+  const sdd_dir = path.posix.join("docs", resolvedSlug, "sdd");
+  const progress_path = path.posix.join(sdd_dir, "progress.md");
+  const manifest_path = path.posix.join(sdd_dir, "manifest.json");
+
+  let progress_lines: string[] = [];
+  let completed_task_ids: number[] = [];
+  const absProgress = path.join(cwd, progress_path);
+  if (existsSync(absProgress)) {
+    progress_lines = readFileSync(absProgress, "utf8").split("\n").map((ln) => ln.trim()).filter(Boolean);
+    const pat = /^Task\s+(\d+):\s+complete\b/i;
+    completed_task_ids = progress_lines
+      .map((ln) => pat.exec(ln)?.[1])
+      .filter(Boolean)
+      .map(Number);
+  }
+
+  let manifest: Record<string, unknown> = {};
+  const absManifest = path.join(cwd, manifest_path);
+  if (existsSync(absManifest)) {
+    try { manifest = JSON.parse(readFileSync(absManifest, "utf8")); } catch { manifest = {}; }
+  }
+
+  const legacy_path = path.join(cwd, ".superpowers/sdd");
+  const legacy_exists = existsSync(legacy_path);
+
+  let todos: { id: string; content: string; status: string }[] = [];
+  let task_count = 0;
+  if (plan_path) {
+    const absPlan = path.isAbsolute(plan_path) ? plan_path : path.join(cwd, plan_path);
+    const planText = readFileSync(absPlan, "utf8");
+    const specMatch = planText.match(/^\*\*Spec:\*\*\s*(?:`([^`]+)`|(\S+))/m);
+    const spec_path = specMatch?.[1] ?? specMatch?.[2] ?? "";
+    if (spec_path) {
+      const validated = docsValidate({ spec_path, plan_path, workspace_root: cwd });
+      if (validated.ok === false) return { ok: false, errors: validated.errors, error: validated.error };
+    }
+    const tasks = parseTasksFromPlan(planText);
+    if (tasks.length > 0) {
+      task_count = tasks.length;
+      todos = todosFromTasks(tasks, completed_task_ids);
+    }
+  }
+
+  const flow = readFlowState(cwd, resolvedSlug);
+
+  return {
+    slug: resolvedSlug,
+    sdd_dir,
+    progress_path,
+    manifest_path,
+    progress_lines,
+    completed_task_ids,
+    manifest,
+    created: existsSync(path.join(cwd, sdd_dir)),
+    forbidden_legacy_path: ".superpowers/sdd",
+    legacy_sdd_exists: legacy_exists,
+    warning: legacy_exists
+      ? "Ignore .superpowers/sdd — use sdd_dir from this tool only"
+      : undefined,
+    todos,
+    task_count,
+    flow: { spec: flow.spec, plan: flow.plan, menu: flow.menu },
+    todowrite_required: true,
+    todowrite_hint:
+      "REQUIRED: Call OpenCode todowrite with todos from this result so the native task list shows progress. Before each task set status in_progress; after workflow_sdd_append_progress set it completed.",
+  };
+}
+
+export function sddTaskBrief({
+  sdd_dir,
+  task_id,
+  section_text,
+  workspace_root,
+}: {
+  sdd_dir: string;
+  task_id: number;
+  section_text: string;
+  workspace_root: string;
+}) {
+  const cwd = path.resolve(workspace_root);
+  const dir = path.isAbsolute(sdd_dir) ? sdd_dir : path.join(cwd, sdd_dir);
+  mkdirSync(dir, { recursive: true });
+  const out = path.join(dir, `task-${task_id}-brief.md`);
+  writeFileSync(out, `# Task ${task_id} brief\n\n${section_text}\n`, "utf8");
+  const rel = posix(path.relative(cwd, out));
+  return { brief_path: rel, task_id };
+}
+
+export function sddReviewPackage({
+  sdd_dir,
+  base_sha,
+  head_sha,
+  workspace_root,
+}: {
+  sdd_dir: string;
+  base_sha: string;
+  head_sha: string;
+  workspace_root: string;
+}) {
+  const cwd = path.resolve(workspace_root);
+  const dir = path.isAbsolute(sdd_dir) ? sdd_dir : path.join(cwd, sdd_dir);
+  mkdirSync(dir, { recursive: true });
+  const base7 = base_sha.slice(0, 7);
+  const head7 = head_sha.slice(0, 7);
+  const diffPath = path.join(dir, `review-${base7}..${head7}.diff`);
+  try {
+    const diff = execFileSync("git", ["diff", base_sha, head_sha], { cwd, encoding: "utf8" });
+    writeFileSync(diffPath, diff, "utf8");
+    const rel = posix(path.relative(cwd, diffPath));
+    return { diff_path: rel, base_sha, head_sha, base7, head7 };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : "git diff failed" };
+  }
+}
+
+const PROGRESS_RE = /^Task\s+\d+:\s+complete\s+\(commits\s+[0-9a-f]{7,40}\.\.[0-9a-f]{7,40},/i;
+
+export function sddAppendProgress({
+  progress_path,
+  line,
+  workspace_root,
+}: {
+  progress_path: string;
+  line: string;
+  workspace_root: string;
+}) {
+  const cwd = path.resolve(workspace_root);
+  const path_ = path.isAbsolute(progress_path) ? progress_path : path.join(cwd, progress_path);
+  const trimmed = line.trim();
+  if (!PROGRESS_RE.test(trimmed)) {
+    return { error: "invalid progress line format" };
+  }
+  mkdirSync(path.dirname(path_), { recursive: true });
+  appendFileSync(path_, trimmed + "\n", "utf8");
+  const rel = posix(path.relative(cwd, path_));
+  return { ok: true, line: trimmed, progress_path: rel };
+}

package/src/core/templates.ts

@@ -0,0 +1,37 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { configDir } from "./config";
+
+export type TemplateName = "issue-update" | "greeting" | "headers";
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+
+export const templatePath = (name: TemplateName): string => path.join(configDir(), "templates", `${name}.md`);
+
+export const readTemplate = (name: TemplateName): { source: "config" | "repo"; content: string } => {
+  const cfg = templatePath(name);
+  if (existsSync(cfg)) return { source: "config", content: readFileSync(cfg, "utf8") };
+  return { source: "repo", content: readFileSync(path.join(repoRoot, "templates", `${name}.md`), "utf8") };
+};
+
+export const writeTemplate = (
+  name: TemplateName,
+  content: string,
+  confirmed: boolean,
+): { ok: true; path: string } | { ok: false; error: string } => {
+  if (!confirmed) return { ok: false, error: "confirmed: true required" };
+  const file = templatePath(name);
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, content, "utf8");
+  return { ok: true, path: file };
+};
+
+export const listTemplates = (): { name: TemplateName; source: "config" | "repo" | "missing"; path: string }[] =>
+  (["issue-update", "greeting", "headers"] as TemplateName[]).map((name) => {
+    const cfg = templatePath(name);
+    const repoFile = path.join(repoRoot, "templates", `${name}.md`);
+    if (existsSync(cfg)) return { name, source: "config", path: cfg };
+    if (existsSync(repoFile)) return { name, source: "repo", path: repoFile };
+    return { name, source: "missing", path: cfg };
+  });

package/src/core/vcs-config.ts

@@ -0,0 +1,252 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { configDir } from "./config";
+import { resolveWorkspace } from "./workspaces";
+
+// Ports of scripts/vcs/config.sh + verify-token.sh + token-create-urls.sh + merged-style.sh.
+// Token never printed.
+
+const TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
+
+export const vcsConfigPath = (): string =>
+  process.env.WORKFLOW_VCS_CONFIG ?? path.join(configDir(), "vcs.json");
+
+const workspacesPath = (): string => path.join(configDir(), "workspaces.json");
+
+const vcsCwd = (cwd?: string): string => process.env.WORKFLOW_WORKSPACE_ROOT ?? cwd ?? process.cwd();
+
+function readVcsJson(): { config: Record<string, any>; path: string; ok: boolean } {
+  const cfgPath = vcsConfigPath();
+  let config: Record<string, any> = {};
+  let ok = false;
+  if (fs.existsSync(cfgPath)) {
+    try {
+      const parsed = JSON.parse(fs.readFileSync(cfgPath, "utf8")) as unknown;
+      if (parsed && typeof parsed === "object") {
+        config = parsed as Record<string, any>;
+        ok = true;
+      }
+    } catch { /* missing or invalid */ }
+  }
+  return { config, path: cfgPath, ok };
+}
+
+/** Port of scripts/vcs/config.sh — mode: load | summary | resolve. */
+export function vcsConfig(mode: "load" | "summary" | "resolve", cwd?: string): Record<string, any> {
+  const ws = resolveWorkspace(vcsCwd(cwd));
+  const wsVcs = (ws?.vcs ?? {}) as Record<string, any>;
+  const wsYt = (ws?.youtrack ?? {}) as Record<string, any>;
+  const wsIssues = (ws?.issues ?? {}) as Record<string, any>;
+  const { config: cfg, path: cfgPath, ok: cfgOk } = readVcsJson();
+
+  const provider = String(wsVcs.provider ?? cfg.provider ?? "gitlab").toLowerCase();
+  const defaultTarget = String(wsVcs.defaultTargetBranch ?? cfg.defaultTargetBranch ?? "develop");
+  const linkIssues = typeof wsYt.link_issues === "boolean" ? wsYt.link_issues : null;
+  const youtrackBaseUrl = typeof wsYt.baseUrl === "string" ? wsYt.baseUrl : null;
+  // github issues path only when BOTH providers are github (mirrors WorkspaceConfig.issues).
+  let issuesProvider: string | null = null;
+  let linkOnPr: boolean | null = null;
+  if (provider === "github" && typeof wsIssues.provider === "string" && wsIssues.provider.toLowerCase() === "github") {
+    issuesProvider = "github";
+    linkOnPr = typeof wsIssues.link_on_pr === "boolean" ? wsIssues.link_on_pr : null;
+  }
+
+  if (mode === "resolve") {
+    return {
+      ok: true,
+      workspace_name: ws?.name ?? null,
+      provider,
+      defaultTargetBranch: defaultTarget,
+      link_issues: linkIssues,
+      youtrack_base_url: youtrackBaseUrl,
+      issues_provider: issuesProvider,
+      link_on_pr: linkOnPr,
+    };
+  }
+
+  if (!cfgOk) return { ok: false, error: "missing or invalid vcs.json" };
+
+  const prov = (cfg[provider] ?? {}) as Record<string, any>;
+  const tokenFile = String(prov.tokenFile ?? path.join(os.homedir(), ".config", "workflow-toolkit", `${provider}.token`));
+  const tokenPath = path.resolve(tokenFile);
+  let tokenOk = false;
+  if (fs.existsSync(tokenPath)) {
+    const token = fs.readFileSync(tokenPath, "utf8").trim();
+    const placeholder = !token || token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER);
+    tokenOk = !placeholder;
+  }
+
+  const out: Record<string, any> = {
+    ok: true,
+    configPath: path.resolve(cfgPath),
+    provider,
+    defaultTargetBranch: defaultTarget,
+    pr: cfg.pr ?? {},
+    tokenPath,
+    tokenPresent: fs.existsSync(tokenPath),
+    tokenReady: tokenOk,
+    workspace_name: ws?.name ?? null,
+    link_issues: linkIssues,
+    youtrack_base_url: youtrackBaseUrl,
+    issues_provider: issuesProvider,
+    link_on_pr: linkOnPr,
+  };
+  if (provider === "gitlab") {
+    out.gitlab = { host: prov.host ?? "gitlab.com", apiUrl: prov.apiUrl ?? "https://gitlab.com/api/v4" };
+  } else if (provider === "github") {
+    out.github = { host: prov.host ?? "github.com" };
+  }
+  if (mode === "summary") delete out.tokenPath;
+  return out;
+}
+
+/** Port of scripts/vcs/verify-token.sh — soft-fail JSON out, always exit 0. */
+export function vcsVerifyToken(): Record<string, any> {
+  const cfg = vcsConfig("load");
+  if (!cfg.ok) return { ok: false, error: cfg.error ?? "vcs config not ready" };
+  const provider = cfg.provider as string;
+  if (!cfg.tokenReady) {
+    return {
+      ok: false,
+      provider,
+      error: "token file still placeholder YOUR_TOKEN_HERE — edit locally, then /wk-status",
+      path: cfg.tokenPath,
+    };
+  }
+  const token = fs.readFileSync(cfg.tokenPath as string, "utf8").trim();
+
+  if (provider === "gitlab") {
+    const host = (cfg.gitlab as Record<string, any>)?.host ?? "gitlab.com";
+    const api = ((cfg.gitlab as Record<string, any>)?.apiUrl ?? `https://${host}/api/v4`).replace(/\/+$/, "");
+    const result = spawnSync("curl", ["-fsS", "-H", `PRIVATE-TOKEN: ${token}`, `${api}/user`], { encoding: "utf8" });
+    if (result.status !== 0) {
+      return { ok: false, provider, error: "GitLab API rejected token", detail: (result.stderr ?? result.stdout ?? "").slice(0, 200) };
+    }
+    try {
+      const user = JSON.parse(result.stdout ?? "") as Record<string, any>;
+      return { ok: true, provider, username: user.username ?? user.login, name: user.name };
+    } catch {
+      return { ok: false, provider, error: "invalid JSON from GitLab /user" };
+    }
+  }
+  if (provider === "github") {
+    const result = spawnSync("gh", ["api", "user"], { encoding: "utf8", env: { ...process.env, GH_TOKEN: token } });
+    if (result.status !== 0) {
+      return { ok: false, provider, error: "GitHub API rejected token", detail: (result.stderr ?? result.stdout ?? "").slice(0, 200) };
+    }
+    try {
+      const user = JSON.parse(result.stdout ?? "") as Record<string, any>;
+      return { ok: true, provider, username: user.login, name: user.name };
+    } catch {
+      return { ok: false, provider, error: "invalid JSON from gh api user" };
+    }
+  }
+  return { ok: false, error: `unsupported provider: ${provider}` };
+}
+
+/** Port of scripts/vcs/token-create-urls.sh — provider token-creation deep links. */
+export function vcsTokenCreateUrls(): Record<string, any> {
+  const tokenName = process.env.WORKFLOW_VCS_TOKEN_NAME ?? "workit";
+  const { config: cfg } = readVcsJson();
+  const defaults = (cfg.tokenDefaults ?? {}) as Record<string, any>;
+  const name = String(defaults.name ?? tokenName);
+  const desc = String(defaults.description ?? "OpenCode workit — /wk-pr and glab/gh");
+
+  const gitlab = (cfg.gitlab ?? {}) as Record<string, any>;
+  const host = String(gitlab.host ?? "gitlab.com");
+  const gitlabScopes = Array.isArray(defaults.gitlabScopes) ? defaults.gitlabScopes : ["api"];
+  const gitlabParams = new URLSearchParams({ name, description: desc, scopes: gitlabScopes.join(",") });
+  const gitlabUrl = `https://${host}/-/user_settings/personal_access_tokens?${gitlabParams}`;
+
+  const githubPerms = defaults.githubPermissions ?? { pull_requests: "write", contents: "write", metadata: "read" };
+  const ghParams = new URLSearchParams({ name, description: desc, ...githubPerms });
+  const githubFineUrl = `https://github.com/settings/personal-access-tokens/new?${ghParams}`;
+
+  const classicScopes = Array.isArray(defaults.githubClassicScopes) ? defaults.githubClassicScopes : ["repo"];
+  const githubClassicUrl = `https://github.com/settings/tokens/new?${new URLSearchParams({ description: name, scopes: classicScopes.join(",") })}`;
+
+  const provider = String(cfg.provider ?? "gitlab").toLowerCase();
+  const active = {
+    gitlab: {
+      tokenFile: gitlab.tokenFile ?? path.join(os.homedir(), ".config", "workflow-toolkit", "gitlab.token"),
+      createUrl: gitlabUrl,
+      scopes: gitlabScopes,
+      name,
+    },
+    github: {
+      tokenFile: (cfg.github as Record<string, any>)?.tokenFile ?? path.join(os.homedir(), ".config", "workflow-toolkit", "github.token"),
+      createUrl: githubFineUrl,
+      createUrlClassic: githubClassicUrl,
+      permissions: githubPerms,
+      name,
+    },
+  }[provider] ?? {};
+
+  return {
+    tokenName: name,
+    tokenDescription: desc,
+    activeProvider: provider,
+    active,
+    gitlab: { host, createUrl: gitlabUrl, scopes: gitlabScopes, tokenFile: gitlab.tokenFile },
+    github: { createUrl: githubFineUrl, createUrlClassic: githubClassicUrl, permissions: githubPerms, tokenFile: (cfg.github as Record<string, any>)?.tokenFile },
+  };
+}
+
+/** Port of scripts/vcs/merged-style.sh — recent merged MR/PR bodies for style reference. */
+export function mergedPrStyle(limit = 6): Record<string, any> {
+  const cfg = vcsConfig("load");
+  if (!cfg.ok || !cfg.tokenReady) return { ok: false, error: "vcs not configured" };
+  const provider = cfg.provider as string;
+  const token = fs.readFileSync(cfg.tokenPath as string, "utf8").trim();
+  const examples: Array<Record<string, any>> = [];
+
+  const descInfo = (desc: string, caseInsensitiveNotes = false): Record<string, any> => ({
+    hasNotesSection: caseInsensitiveNotes ? /##\s*notes/i.test(desc) : /##\s*Notes/.test(desc),
+    sections: desc.split("\n").filter((l) => l.startsWith("## ")).map((l) => l.trim()),
+    descriptionPreview: desc.slice(0, 600),
+  });
+
+  if (provider === "gitlab") {
+    const remote = spawnSync("git", ["remote", "get-url", "origin"], { encoding: "utf8" });
+    if (remote.status !== 0) return { ok: false, error: "no origin remote" };
+    const url = (remote.stdout ?? "").trim();
+    const m = /gitlab\.com[:/](.+?)(?:\.git)?$/.exec(url);
+    if (!m) return { ok: false, error: "not a gitlab.com origin" };
+    const project = m[1];
+    const env = { ...process.env, GITLAB_TOKEN: token };
+    const run = (args: string[]) => spawnSync("glab", ["api", ...args], { encoding: "utf8", env });
+    let r = run([`projects/${project.replaceAll("/", "%2F")}/merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`]);
+    if (r.status !== 0) {
+      r = run([`merge_requests?state=merged&per_page=${limit}&order_by=updated_at&sort=desc`]);
+    }
+    if (r.status !== 0) return { ok: false, error: "could not list merge requests" };
+    for (const mr of JSON.parse(r.stdout ?? "[]") as Array<Record<string, any>>) {
+      const desc = String(mr.description ?? "").trim();
+      examples.push({ title: mr.title, url: mr.web_url, squash: mr.squash, ...descInfo(desc, true) });
+    }
+  } else if (provider === "github") {
+    const r = spawnSync("gh", ["pr", "list", "--state", "merged", "--limit", String(limit), "--json", "title,url,body"],
+      { encoding: "utf8", env: { ...process.env, GH_TOKEN: token } });
+    if (r.status !== 0) return { ok: false, error: "could not list pull requests" };
+    for (const pr of JSON.parse(r.stdout ?? "[]") as Array<Record<string, any>>) {
+      const desc = String(pr.body ?? "").trim();
+      examples.push({ title: pr.title, url: pr.url, ...descInfo(desc) });
+    }
+  }
+
+  return {
+    ok: true,
+    provider,
+    count: examples.length,
+    styleHints: [
+      "Prefer ## Summary bullets + ## Validation or ## Test plan only",
+      "Do not add ## Notes with branch names, commit counts, or diff stats",
+      "Do not paste commit log or diff stat into the body",
+    ],
+    examples,
+  };
+}
+
+export const vcsWorkspacesPath = workspacesPath;

package/src/core/verify-parse.ts

@@ -0,0 +1,27 @@
+/** Parse verify-project.sh stdout (# Summary + ## check sections). */
+export function parseVerifyOutput(stdout: string): Record<string, any> {
+  const commands = [];
+  const parts = stdout.split(/\n## /);
+  for (const part of parts.slice(1)) {
+    const nl = part.indexOf('\n');
+    const label = part.slice(0, nl).trim();
+    const body = part.slice(nl + 1);
+    const cmdMatch = body.match(/^command: (.+)$/m);
+    const statusMatch = body.match(/^status: (pass|fail|skipped)(?: \((.+)\))?/m);
+    if (cmdMatch && statusMatch) {
+      commands.push({
+        label,
+        command: cmdMatch[1].trim(),
+        status: statusMatch[1],
+        reason: statusMatch[2]?.trim(),
+      });
+    }
+  }
+
+  const summaryMatch = stdout.match(/# Summary[\s\S]*?passed: (\d+)[\s\S]*?failed: (\d+)[\s\S]*?skipped: (\d+)/);
+  const passed = summaryMatch ? Number(summaryMatch[1]) : 0;
+  const failed = summaryMatch ? Number(summaryMatch[2]) : 0;
+  const skipped = summaryMatch ? Number(summaryMatch[3]) : 0;
+
+  return { passed, failed, skipped, commands };
+}

package/src/core/workspaces.ts

@@ -0,0 +1,81 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { configDir } from "./config";
+
+export type VcsProvider = "gitlab" | "github";
+
+export type WorkspaceConfig = {
+  name: string;
+  glob: string;
+  vcs?: { provider: VcsProvider; defaultTargetBranch?: string };
+  youtrack?: { baseUrl?: string; link_issues?: boolean };
+  issues?: { provider?: "github"; link_on_pr?: boolean };
+};
+
+export const workspacesPath = (): string => path.join(configDir(), "workspaces.json");
+
+// ponytail: only globstar (`**`) is supported; if more minimatch parity is needed
+// (char classes, braces, `?`), swap this matcher for the minimatch dependency.
+const globToRegExp = (glob: string): RegExp => {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          // **/ matches zero or more segments; a leading **/ also consumes the leading slash
+          if (out === "") out += "/?";
+          out += "(?:[^/]+/)*";
+          i += 2;
+        } else {
+          // trailing ** also matches the bare parent: /x/y/** -> /x/y and /x/y/deep.
+          // (?:/.*)? only when the prefix ends with / (POSIX absolute); otherwise
+          // the trailing ** must match any remainder, e.g. a bare ** against a
+          // drive-letter cwd like D:/a/x.
+          if (i + 2 >= glob.length) {
+            if (out.endsWith("/")) {
+              out = out.slice(0, -1);
+              out += "(?:/.*)?";
+            } else {
+              out += ".*";
+            }
+          } else {
+            out += ".*";
+          }
+          i++;
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else {
+      out += c.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${out}$`);
+};
+
+export const resolveWorkspace = (cwd: string): WorkspaceConfig | null => {
+  let raw: string;
+  try {
+    raw = readFileSync(workspacesPath(), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object") return null;
+  const list = (parsed as { workspaces?: unknown }).workspaces;
+  if (!Array.isArray(list)) return null;
+  const cwdPosix = cwd.split(path.sep).join("/");
+  for (const entry of list) {
+    if (!entry || typeof entry !== "object") continue;
+    const ws = entry as WorkspaceConfig;
+    if (typeof ws.glob !== "string" || !ws.glob) continue;
+    if (globToRegExp(ws.glob).test(cwdPosix)) return ws;
+  }
+  return null;
+};