@brainervirus/workit-core 0.6.0 → 0.7.0

package/src/core/workspaces.ts

@@ -1,19 +1,70 @@
-import { readFileSync } from "node:fs";
+import { readFileSync, realpathSync } from "node:fs";
 import path from "node:path";
-import { configDir } from "./config";
+import { configDir, isConfigObject, type BranchPreset } from "./config";
 
 export type VcsProvider = "gitlab" | "github";
 
+export type IntegrationMode = "pr" | "merge";
+
+export type WorkspaceBranchPolicy = {
+  preset: BranchPreset;
+  developBranch?: string;
+  prefixes?: { feature: string; bugfix: string; release: string; hotfix: string };
+  allowed?: string[];
+  protected?: string[];
+  integration: IntegrationMode;
+};
+
 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 };
+  branchPolicy?: WorkspaceBranchPolicy;
 };
 
 export const workspacesPath = (): string => path.join(configDir(), "workspaces.json");
 
+// RL-01: typed workspaces reader. Missing is a legitimate unconfigured state
+// (empty list); malformed JSON is reported with the exact path so risky
+// consumers (wizard/installer/doctor) can block instead of silently resetting.
+export type WorkspacesResult = {
+  status: "missing" | "valid" | "malformed";
+  path: string;
+  entries: WorkspaceConfig[];
+  error?: string;
+};
+
+export const readWorkspacesResult = (dir: string = configDir()): WorkspacesResult => {
+  const file = path.join(dir, "workspaces.json");
+  let raw: string;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch {
+    return { status: "missing", path: file, entries: [] };
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return { status: "malformed", path: file, entries: [], error: `${file} is not valid JSON` };
+  }
+  if (!isConfigObject(parsed)) {
+    return { status: "malformed", path: file, entries: [], error: `${file} is not a JSON object` };
+  }
+  const list = (parsed as { workspaces?: unknown }).workspaces;
+  return {
+    status: "valid",
+    path: file,
+    entries: Array.isArray(list) ? (list as WorkspaceConfig[]) : [],
+  };
+};
+
+/** Parse the workspaces.json list under an explicit config dir; [] when missing/malformed. */
+export const loadWorkspacesFrom = (dir: string): WorkspaceConfig[] =>
+  readWorkspacesResult(dir).entries;
+
 // 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 => {
@@ -54,28 +105,96 @@ const globToRegExp = (glob: string): RegExp => {
   return new RegExp(`^${out}$`);
 };
 
-export const resolveWorkspace = (cwd: string): WorkspaceConfig | null => {
-  let raw: string;
-  try {
-    raw = readFileSync(workspacesPath(), "utf8");
-  } catch {
-    return null;
+/** Shared authoritative workspace matcher (WZ-12): the wizard's pattern
+ *  preview and resolveWorkspaceFrom both route through it. */
+export const matchWorkspace = (glob: string, target: string): boolean =>
+  globToRegExp(glob.replaceAll("\\", "/")).test(target.replaceAll("\\", "/"));
+
+// RL-08: the matcher above implements `*` and `**` only. Classic glob
+// metacharacters it would otherwise store as literals (char classes, `?`,
+// brace expansion) are rejected at write time so a saved pattern never
+// silently matches nothing (Task 15 advisory: unsupported patterns were
+// accepted and shown as "no match").
+const UNSUPPORTED_GLOB = /[?[\]{}]/;
+
+// B3: `!`-negation and extglob prefixes (@(...), +(...), *(...)) are the same
+// no-match trap — the matcher stores them as literals, so `!**` or `@(a|b)`
+// silently matches nothing. Reject them at write time too; the Task 15 match
+// preview still routes through matchWorkspace (literals -> no match) and is
+// unchanged.
+const UNSUPPORTED_EXTGLOB = /[@+*]\(|!/;
+
+export type GlobValidation = { ok: true } | { ok: false; error: string };
+
+export const validateWorkspaceGlob = (glob: string): GlobValidation => {
+  const trimmed = glob.trim();
+  if (!trimmed) return { ok: false, error: "workspace pattern is required" };
+  const m = UNSUPPORTED_GLOB.exec(trimmed);
+  if (m) {
+    return {
+      ok: false,
+      error: `unsupported glob character ${JSON.stringify(m[0])} in workspace pattern ${JSON.stringify(glob)} — the matcher supports * and ** only (e.g. /work/**)`,
+    };
   }
-  let parsed: unknown;
+  const ext = UNSUPPORTED_EXTGLOB.exec(trimmed);
+  if (ext) {
+    const token = ext[0];
+    const kind = token === "!" ? "negation (!)" : `extglob (${token})`;
+    return {
+      ok: false,
+      error: `unsupported glob ${kind} in workspace pattern ${JSON.stringify(glob)} — the matcher supports * and ** only (e.g. /work/**)`,
+    };
+  }
+  return { ok: true };
+};
+
+const realpathOf = (p: string): string => {
+  // realpathSync.native goes through libuv, which expands Windows 8.3 short
+  // names (C:\Users\RUNNER~1 -> C:\Users\runneradmin); the plain realpathSync
+  // keeps them, so a git-derived long path would miss a glob written with the
+  // short form (GitHub runner TMP uses the short name).
+  const real = realpathSync.native ?? realpathSync;
   try {
-    parsed = JSON.parse(raw);
+    return real(p);
   } catch {
-    return null;
+    return p;
   }
-  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) {
+};
+
+// Rebuild a glob with the realpath of its static prefix, so a config glob
+// written with the logical path also matches a canonical target (and vice
+// versa). The glob metacharacters themselves are left untouched.
+const canonicalGlob = (glob: string): string => {
+  const m = /[*?[\]{]/.exec(glob);
+  const prefix = m ? glob.slice(0, m.index) : glob;
+  const rest = m ? glob.slice(m.index) : "";
+  if (!prefix) return glob;
+  const real = realpathOf(prefix.replace(/\/+$/, "") || "/");
+  return real + (prefix.endsWith("/") ? "/" : "") + rest;
+};
+
+/** Match a cwd against the workspaces.json under an explicit config dir. */
+export const resolveWorkspaceFrom = (cwd: string, dir: string): WorkspaceConfig | null => {
+  // macOS/Windows tmpdir symlinks (/var -> /private/var): git's
+  // --show-toplevel returns the realpath while config globs are usually
+  // written with the logical path, so a workspace would silently stop
+  // matching on macOS. Match both forms on each side — same class as the
+  // docs-migration escape-guard realpath comparison; on Linux both forms
+  // are identical so behavior is unchanged.
+  const targets = [cwd, realpathOf(cwd)].map((p) => p.replaceAll("\\", "/"));
+  for (const entry of loadWorkspacesFrom(dir)) {
     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;
+    const glob = ws.glob.replaceAll("\\", "/");
+    const canonical = canonicalGlob(glob);
+    for (const target of targets) {
+      if (matchWorkspace(glob, target)) return ws;
+      if (canonical !== glob && matchWorkspace(canonical, target)) return ws;
+    }
   }
   return null;
 };
+
+export const resolveWorkspace = (cwd: string): WorkspaceConfig | null =>
+  resolveWorkspaceFrom(cwd, configDir());

package/src/core/youtrack-tools.ts

@@ -0,0 +1,228 @@
+import { readFileSync, statSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fail, ok, type Result } from "../core";
+import { configDir, isConfigObject } from "./config";
+import {
+  context as legacyContext,
+  logTime as legacyLogTime,
+  parseDuration as legacyParseDuration,
+  postUpdate as legacyPostUpdate,
+  verifyYouTrackToken,
+} from "./youtrack";
+
+export const ISSUE_RE = /^[A-Z]+-\d+$/;
+export const message = (error: unknown) => (error instanceof Error ? error.message : String(error));
+
+// Both override names point at the config dir itself, same precedence as
+// src/core/config.ts and scripts/init/status.sh: WORKFLOW_TOOLKIT_CONFIG → WORKFLOW_TOOLKIT_CONFIG_DIR → XDG.
+// Default env (no args) routes through configDir() so the legacy migration runs.
+export const configPath = (env: NodeJS.ProcessEnv = process.env, home = os.homedir()) =>
+  path.join(
+    env === process.env
+      ? configDir()
+      : (env.WORKFLOW_TOOLKIT_CONFIG ??
+          env.WORKFLOW_TOOLKIT_CONFIG_DIR ??
+          path.join(env.XDG_CONFIG_HOME || path.join(home, ".config"), "workit")),
+    "youtrack.json",
+  );
+
+export function readCredentials(env: NodeJS.ProcessEnv = process.env, home = os.homedir()) {
+  const resolvedConfig = configPath(env, home);
+  // AR-07/CA-37: a parseable non-object youtrack.json is malformed — exact-path
+  // error, never a raw TypeError or a silent tokenFile default.
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(resolvedConfig, "utf8"));
+  } catch {
+    throw new Error(`${resolvedConfig} is not valid JSON`);
+  }
+  if (!isConfigObject(parsed)) {
+    throw new Error(`${resolvedConfig} is not a JSON object`);
+  }
+  const config = parsed as { tokenFile?: string };
+  const tokenFile = config.tokenFile ?? "youtrack.token";
+  const tokenPath = path.resolve(path.dirname(resolvedConfig), tokenFile.replace(/^~(?=\/)/, home));
+  if (process.platform !== "win32" && (statSync(tokenPath).mode & 0o777) !== 0o600)
+    throw new Error("youtrack.token mode must be 0600");
+  const token = readFileSync(tokenPath, "utf8").trim();
+  if (!token) throw new Error("youtrack.token is empty");
+  return { configPath: resolvedConfig, token };
+}
+
+export const redact = (text: string, token: string) =>
+  token ? text.split(token).join("[REDACTED]") : text;
+
+type MaybePromise<T> = T | Promise<T>;
+export type LegacyValue = Record<string, unknown> | void;
+export type NotApplied = { ok: false; error: string; outcome: "not_applied" };
+
+export type YouTrackOperations = {
+  verifyToken(): MaybePromise<LegacyValue>;
+  context(input: Record<string, unknown>): MaybePromise<LegacyValue>;
+  parseDuration(text: string, workspaceRoot: string): MaybePromise<LegacyValue>;
+  postComment(issueId: string, markdown: string, workspaceRoot?: string): MaybePromise<LegacyValue>;
+  logTime(input: Record<string, unknown>): MaybePromise<LegacyValue>;
+};
+
+export const unwrap = (value: LegacyValue) => {
+  if (!value) return {};
+  if (value.error) throw new Error(String(value.error));
+  if (value.ok === false) throw new Error(String(value.error ?? "YouTrack operation failed"));
+  return (value.data as Record<string, unknown> | undefined) ?? value;
+};
+
+export const defaultOperations: YouTrackOperations = {
+  verifyToken: () => unwrap(verifyYouTrackToken()),
+  context: (input) => legacyContext(input as never),
+  parseDuration: (text, workspaceRoot) => legacyParseDuration(text, workspaceRoot),
+  postComment: async (issueId, markdown, workspaceRoot) =>
+    unwrap(
+      await legacyPostUpdate({
+        confirmed: true,
+        issueId,
+        markdown,
+        workspace_root: workspaceRoot,
+      } as never),
+    ),
+  logTime: async (input) => unwrap(await legacyLogTime(input as never)),
+};
+
+type PostInput = {
+  confirmed: boolean;
+  issueId: string;
+  markdown: string;
+  minutes?: number;
+  workspace_root?: string;
+};
+
+type PostData = {
+  issueId: string;
+  postedComment: boolean;
+  loggedMinutes: number;
+  outcome?: "unknown" | "not_applied";
+  instructions?: string;
+  retry?: "workflow_youtrack_post" | "workflow_youtrack_log_time";
+};
+
+const notApplied = (value: LegacyValue): value is NotApplied =>
+  value?.ok === false && value.outcome === "not_applied";
+
+export async function postUpdate(
+  input: PostInput,
+  operations: Pick<YouTrackOperations, "postComment" | "logTime"> = defaultOperations,
+): Promise<Result<PostData>> {
+  if (input.confirmed !== true) return fail("confirmed: true required");
+  if (!ISSUE_RE.test(input.issueId)) return fail("invalid issueId");
+  if (!input.markdown?.trim()) return fail("markdown required");
+  if (input.minutes != null && input.minutes <= 0) return fail("minutes must be positive");
+
+  try {
+    const comment = await operations.postComment(
+      input.issueId,
+      input.markdown,
+      input.workspace_root,
+    );
+    if (notApplied(comment))
+      return fail(comment.error, {
+        issueId: input.issueId,
+        postedComment: false,
+        loggedMinutes: 0,
+        outcome: "not_applied",
+        retry: "workflow_youtrack_post",
+      });
+    unwrap(comment);
+  } catch (error) {
+    return fail(message(error), {
+      issueId: input.issueId,
+      postedComment: false,
+      loggedMinutes: 0,
+      outcome: "unknown",
+      instructions: "Check YouTrack comments manually; do not retry while the outcome is unknown.",
+    });
+  }
+
+  if (input.minutes != null) {
+    try {
+      const time = await operations.logTime({
+        issueId: input.issueId,
+        minutes: input.minutes,
+        text: "workit update",
+        workspace_root: input.workspace_root,
+      });
+      if (notApplied(time))
+        return fail(time.error, {
+          issueId: input.issueId,
+          postedComment: true,
+          loggedMinutes: 0,
+          outcome: "not_applied",
+          retry: "workflow_youtrack_log_time",
+        });
+      unwrap(time);
+    } catch (error) {
+      return fail(message(error), {
+        issueId: input.issueId,
+        postedComment: true,
+        loggedMinutes: 0,
+        outcome: "unknown",
+        instructions:
+          "Check YouTrack time entries manually; do not retry while the outcome is unknown.",
+      });
+    }
+  }
+
+  return ok({
+    issueId: input.issueId,
+    postedComment: true,
+    loggedMinutes: input.minutes ?? 0,
+  });
+}
+
+export async function logTimeUpdate(
+  input: Record<string, unknown>,
+  operation: Pick<YouTrackOperations, "logTime"> = defaultOperations,
+): Promise<Result<Record<string, unknown>>> {
+  try {
+    const value = await operation.logTime(input);
+    if (notApplied(value))
+      return fail(value.error, {
+        issueId: input.issueId,
+        loggedMinutes: 0,
+        outcome: "not_applied",
+        retry: "workflow_youtrack_log_time",
+      });
+    return ok(unwrap(value));
+  } catch (error) {
+    return fail(message(error), {
+      issueId: input.issueId,
+      loggedMinutes: 0,
+      outcome: "unknown",
+      instructions:
+        "Check YouTrack time entries manually; do not retry while the outcome is unknown.",
+    });
+  }
+}
+
+export function normalizeContext(value: LegacyValue, mode?: string): LegacyValue {
+  if (!value || mode !== "meetings") return value;
+  const config = value.config as Record<string, unknown> | undefined;
+  const issue = String(config?.meetingIssue || "IRPT-12");
+  const { meetingIssues: _meetingIssues, ...singleMeetingConfig } = config ?? {};
+  const options = Array.isArray(value.meetingOptions)
+    ? (value.meetingOptions as Array<Record<string, unknown>>)
+    : [];
+  const selected = options.find((option) => option.issue === issue) ?? {
+    key: "general",
+    issue,
+    label: issue,
+    workItemText: "Reuniones",
+  };
+  return {
+    ...value,
+    config: singleMeetingConfig,
+    meetingOptions: [selected],
+    requiresMeetingChoice: false,
+    issueId: issue,
+    workItemText: selected.workItemText ?? "Reuniones",
+  };
+}