@brainervirus/workit-cursor 7.0.0 → 7.1.0

package/.cursor-plugin/plugin.json

@@ -2,7 +2,7 @@
   "name": "workit",
   "displayName": "Workit",
   "description": "Adaptive Workit workflow with shared MCP tools and native Cursor hooks",
-  "version": "7.0.0",
+  "version": "7.1.0",
   "author": {
     "name": "Cristhofer Pincetti"
   },

package/dist/cursor-session-start.js

@@ -10081,14 +10081,14 @@ var diagnosticLogger, PRESETS, mergePreset = (preset, input = {}, current = {
   if (result.status === "malformed")
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
-}, resolveBranchPolicy = (config, workspace) => {
+}, branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"), resolveBranchPolicy = (config, workspace) => {
   const wp = workspace?.branchPolicy ?? {};
   const preset = Object.hasOwn(PRESETS, wp.preset) ? wp.preset : config.branchPolicy?.preset ?? "gitflow";
   const merged = mergePreset(preset, {
     allowed: wp.allowed,
     protectedNames: wp.protected
   }, config);
-  const allowed = merged.allowed.map((p) => new RegExp(`^${p.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i"));
+  const allowed = merged.allowed.map(branchGlobPattern);
   return {
     preset,
     allowed,
@@ -10334,7 +10334,7 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
     profiles: record(nonBlank, profileSchema).optional()
   }).passthrough();
   return entrySchema;
-}, runtimeWorkspaceIndexSchema, resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
+}, runtimeWorkspaceIndexSchema, matchRuntimeWorkspace = (cwd) => {
   const file = path6.join(configDir(), "workspaces.json");
   let raw;
   try {
@@ -10369,8 +10369,15 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
   });
   const workspaceName = process.env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined;
   const selected = selectWorkspaceMatch(matches, cwd, workspaceName);
-  if (!selected)
+  return selected ? { file, selected } : null;
+}, resolveRuntimeReleaseTracks = (cwd) => {
+  const matched = matchRuntimeWorkspace(cwd);
+  return matched ? { workspace: matched.selected.name, releaseTracks: matched.selected.releaseTracks } : null;
+}, resolveRuntimeWorkspaceCandidate = (cwd, kind) => {
+  const matched = matchRuntimeWorkspace(cwd);
+  if (!matched)
     return null;
+  const { file, selected } = matched;
   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("; ");
@@ -10431,26 +10438,31 @@ var init_workspaces = __esm(() => {
     object({ kind: literal("manual") }).strict()
   ]);
   releaseTrackSchema = object({
-    strategy: branchPreset,
+    strategy: branchPreset.optional(),
     productionBranch: nonBlank,
     integrationBranch: nonBlank,
-    naming: object({ feature: nonBlank, release: nonBlank, hotfix: nonBlank }).strict(),
-    baseBranch: nonBlank,
-    mergeBackBranches: array(nonBlank),
-    pullRequestTarget: nonBlank,
-    tagNamespace: string2(),
-    versionSource: versionSourceSchema,
-    requiredChecks: array(nonBlank)
-  }).strict().superRefine((track, context) => {
+    naming: object({
+      feature: nonBlank.optional(),
+      release: nonBlank.optional(),
+      hotfix: nonBlank.optional()
+    }).passthrough().optional(),
+    baseBranch: nonBlank.optional(),
+    mergeBackBranches: array(nonBlank).optional(),
+    pullRequestTarget: nonBlank.optional(),
+    tagNamespace: string2().optional(),
+    versionSource: versionSourceSchema.optional(),
+    requiredChecks: array(nonBlank).optional(),
+    critical: array(nonBlank).optional()
+  }).passthrough().superRefine((track, context) => {
     for (const [field, values] of [
-      ["mergeBackBranches", track.mergeBackBranches],
-      ["requiredChecks", track.requiredChecks]
+      ["mergeBackBranches", track.mergeBackBranches ?? []],
+      ["requiredChecks", track.requiredChecks ?? []]
     ]) {
       if (new Set(values).size !== values.length) {
         context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
       }
     }
-    if (track.versionSource.kind === "package-json" && (path6.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+    if (track.versionSource?.kind === "package-json" && (path6.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
       context.addIssue({
         code: "custom",
         path: ["versionSource", "path"],
@@ -16225,11 +16237,150 @@ var init_commit_flavors = () => {};
 // packages/workit-core/src/core/git.ts
 var init_git = () => {};
 
+// packages/workit-core/src/core/release-tracks.ts
+function readReleaseTracks(raw) {
+  const out = { tracks: [], issues: [], error: null, protectedBranches: [] };
+  if (raw === undefined || raw === null)
+    return out;
+  if (!isRecord3(raw)) {
+    out.issues.push("releaseTracks is not an object; ignored");
+    return out;
+  }
+  const fatal = [];
+  const protectedNames = new Set;
+  for (const [name, entry] of Object.entries(raw).toSorted(([a], [b]) => a < b ? -1 : 1)) {
+    const label = `release track ${JSON.stringify(name)}`;
+    if (!isRecord3(entry)) {
+      out.issues.push(`${label} is not an object; ignored`);
+      continue;
+    }
+    for (const branch of namedBranches(entry))
+      protectedNames.add(branch);
+    if (!name.trim()) {
+      out.issues.push("a release track with a blank name was ignored");
+      continue;
+    }
+    let critical = [];
+    if (Array.isArray(entry.critical))
+      critical = entry.critical.filter((item) => typeof item === "string");
+    else if (entry.critical !== undefined)
+      out.issues.push(`${label} critical: must be a list of field names; ignored`);
+    const isCritical = (field) => critical.some((item) => field === item || field.startsWith(`${item}.`));
+    const problem = (field, message) => {
+      if (isCritical(field))
+        fatal.push(`${label} ${field}: ${message}`);
+      else
+        out.issues.push(`${label} ${field}: ${message}`);
+    };
+    for (const key of Object.keys(entry))
+      if (!KNOWN_FIELDS.has(key))
+        problem(key, "unknown field, ignored");
+    const productionBranch = branchName(entry.productionBranch);
+    const integrationBranch = branchName(entry.integrationBranch);
+    if (!productionBranch)
+      problem("productionBranch", "missing or not a branch name");
+    if (!integrationBranch)
+      problem("integrationBranch", "missing or not a branch name");
+    const optionalBranch = (field) => {
+      if (entry[field] === undefined)
+        return null;
+      const value = branchName(entry[field]);
+      if (!value)
+        problem(field, "not a branch name; using the integration branch");
+      return value;
+    };
+    const baseBranch = optionalBranch("baseBranch");
+    const pullRequestTarget = optionalBranch("pullRequestTarget");
+    let mergeBackBranches = [];
+    if (entry.mergeBackBranches !== undefined) {
+      const list = Array.isArray(entry.mergeBackBranches) ? entry.mergeBackBranches.map(branchName) : [null];
+      if (list.some((item) => item === null))
+        problem("mergeBackBranches", "must be a list of branch names; ignored");
+      else
+        mergeBackBranches = [...new Set(list)];
+    }
+    const naming = {};
+    if (entry.naming !== undefined) {
+      if (!isRecord3(entry.naming))
+        problem("naming", "not an object; ignored");
+      else
+        for (const kind of ["feature", "release", "hotfix"]) {
+          const template = entry.naming[kind];
+          if (template === undefined)
+            continue;
+          if (typeof template !== "string" || !template.trim())
+            problem(`naming.${kind}`, "not a template string; ignored");
+          else if (!literalOf(template))
+            problem(`naming.${kind}`, "needs literal text besides placeholders; ignored");
+          else
+            naming[kind] = template.trim();
+        }
+    }
+    if (!productionBranch || !integrationBranch) {
+      out.issues.push(`${label} was skipped: it needs a productionBranch and integrationBranch`);
+      continue;
+    }
+    out.tracks.push({
+      name,
+      productionBranch,
+      integrationBranch,
+      baseBranch: baseBranch ?? integrationBranch,
+      pullRequestTarget: pullRequestTarget ?? integrationBranch,
+      mergeBackBranches,
+      naming
+    });
+  }
+  out.protectedBranches = [...protectedNames];
+  if (fatal.length)
+    out.error = `workspace releaseTracks cannot be read by this Workit (${fatal.join("; ")}); upgrade Workit or fix the track`;
+  return out;
+}
+function workspaceReleaseTracks(cwd) {
+  const raw = resolveRuntimeReleaseTracks(cwd);
+  return { workspace: raw?.workspace ?? null, ...readReleaseTracks(raw?.releaseTracks) };
+}
+var ReleaseTrackError, KNOWN_FIELDS, BRANCH_FIELDS, PLACEHOLDER, HAS_PLACEHOLDER, isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), branchName = (value) => typeof value === "string" && value.trim() && !value.trim().startsWith("-") ? value.trim() : null, namedBranches = (entry) => [
+  ...BRANCH_FIELDS.map((field) => branchName(entry[field])),
+  ...Array.isArray(entry.mergeBackBranches) ? entry.mergeBackBranches.map(branchName) : []
+].filter((name) => name !== null), literalOf = (template) => template.replace(PLACEHOLDER, "").replace(/[*/]/gu, "").trim(), trackBranches = (tracks) => [
+  ...new Set(tracks.flatMap((track) => [
+    track.productionBranch,
+    track.integrationBranch,
+    track.baseBranch,
+    track.pullRequestTarget,
+    ...track.mergeBackBranches
+  ]))
+], namingGlob = (template) => HAS_PLACEHOLDER.test(template) ? template.replace(PLACEHOLDER, "*") : `${template.replace(/\/?\*?$/u, "")}/*`, memo3;
+var init_release_tracks = __esm(() => {
+  init_rev();
+  init_config();
+  init_workspaces();
+  ReleaseTrackError = class ReleaseTrackError extends Error {
+  };
+  KNOWN_FIELDS = new Set([
+    "strategy",
+    "productionBranch",
+    "integrationBranch",
+    "naming",
+    "baseBranch",
+    "mergeBackBranches",
+    "pullRequestTarget",
+    "tagNamespace",
+    "versionSource",
+    "requiredChecks",
+    "critical"
+  ]);
+  BRANCH_FIELDS = ["productionBranch", "integrationBranch", "baseBranch", "pullRequestTarget"];
+  PLACEHOLDER = /\{[^}]*\}/gu;
+  HAS_PLACEHOLDER = /\{[^}]*\}/u;
+  memo3 = new Map;
+});
+
 // packages/workit-core/src/core/vcs-config.ts
 var init_vcs_config = __esm(() => {
   init_config();
   init_workspaces();
-  init_branch();
+  init_release_tracks();
 });
 
 // packages/workit-core/src/core/branch.ts
@@ -16238,14 +16389,37 @@ function effectiveWorkspacePolicy(workspaceRoot, kind, profileName) {
   const selected = resolveRuntimeWorkspacePolicy(workspaceRoot, kind, profileName?.trim() || process.env.WORKFLOW_PROFILE?.trim() || undefined);
   const config = readConfig();
   return kind === "branch" ? {
-    branchPolicy: resolveBranchPolicy(config, selected.policy ? { branchPolicy: selected.policy } : null),
+    branchPolicy: withReleaseTracks(workspaceRoot, resolveBranchPolicy(config, selected.policy ? { branchPolicy: selected.policy } : null)),
     provenance: { branchPolicy: selected.source }
   } : {
     commitPolicy: resolveCommitPolicy(config, selected.policy ? { commitPolicy: selected.policy } : null),
     provenance: { commitPolicy: selected.source }
   };
 }
-var validateBranchNamePolicy = (name, policy, source) => {
+var withReleaseTracks = (workspaceRoot, policy) => {
+  const read = workspaceReleaseTracks(workspaceRoot);
+  if (read.error)
+    throw new ReleaseTrackError(read.error);
+  if (read.tracks.length === 0 && read.protectedBranches.length === 0)
+    return policy;
+  const known = new Set(policy.allowed.map((pattern) => pattern.source));
+  const allowed = [...policy.allowed];
+  for (const glob of read.tracks.flatMap((track) => Object.values(track.naming).map(namingGlob))) {
+    const pattern = branchGlobPattern(glob);
+    if (!known.has(pattern.source)) {
+      known.add(pattern.source);
+      allowed.push(pattern);
+    }
+  }
+  return {
+    ...policy,
+    allowed,
+    protected: new Set([
+      ...policy.protected,
+      ...[...trackBranches(read.tracks), ...read.protectedBranches].map((name) => name.toLowerCase())
+    ])
+  };
+}, validateBranchNamePolicy = (name, policy, source) => {
   const allowed = policy.allowed.map((pattern) => `/${pattern.source}/${pattern.flags}`);
   if (policy.protected.has(name.toLowerCase())) {
     const correction = `choose a non-protected branch matching one of: ${allowed.join(", ")}`;
@@ -16305,6 +16479,7 @@ var init_branch = __esm(() => {
   init_config();
   init_workspaces();
   init_vcs_config();
+  init_release_tracks();
 });
 
 // packages/workit-core/src/core/route-intent.ts
@@ -16598,7 +16773,7 @@ var init_write_gate = __esm(() => {
 // packages/workit-core/src/hooks/hosts/fields.ts
 import { existsSync as existsSync6, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
 import path17 from "node:path";
-var isRecord3 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "", optionalText = (value) => typeof value === "string" ? value : null, existingDirectory = (value) => {
+var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "", optionalText = (value) => typeof value === "string" ? value : null, existingDirectory = (value) => {
   if (!nonEmpty2(value) || !path17.isAbsolute(value) || !existsSync6(value))
     return null;
   try {
@@ -16625,7 +16800,7 @@ var isRecord3 = (value) => value !== null && typeof value === "object" && !Array
   const joined = argv.map(quoteArg).join(" ");
   return nonEmpty2(joined) ? joined : null;
 }, WRITE_TOOLS, isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toLowerCase().replace(/[_-]/g, "")), PATH_KEYS, writePaths = (input) => {
-  if (!isRecord3(input))
+  if (!isRecord4(input))
     return [];
   const paths = PATH_KEYS.map((key) => input[key]).filter(nonEmpty2);
   for (const value of Object.values(input))
@@ -16757,7 +16932,7 @@ var init_handle = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hosts/claude-code.ts
-var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, toolCommand = (value) => isRecord3(value.tool_input) ? commandText(value.tool_input.command) : null, eventOf = (name, value) => {
+var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, toolCommand = (value) => isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null, eventOf = (name, value) => {
   const toolUseId = optionalText(value.tool_use_id);
   switch (name) {
     case "SessionStart":
@@ -16786,7 +16961,7 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, toolCommand = (value)
       const command = toolCommand(value);
       if (!SHELL_TOOLS.has(String(value.tool_name)) || !command)
         return { ok: false, error: "only shell PostToolUse is mapped" };
-      const response = isRecord3(value.tool_response) ? value.tool_response : {};
+      const response = isRecord4(value.tool_response) ? value.tool_response : {};
       return {
         ok: true,
         event: {
@@ -16961,14 +17136,14 @@ var init_claude_code = __esm(() => {
   claudeCodeAdapter = {
     descriptor: CLAUDE_CODE_DESCRIPTOR,
     parse(raw) {
-      const native = isRecord3(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+      const native = isRecord4(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
       const fail = (error) => ({
         ok: false,
         error,
         native,
         event: native ? EVENTS[native] : null
       });
-      if (!isRecord3(raw) || !native)
+      if (!isRecord4(raw) || !native)
         return fail("hook_event_name is required");
       if (!nonEmpty2(raw.session_id))
         return fail("session_id is required");
@@ -17005,7 +17180,7 @@ function detectCodexSurface(env) {
   return env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || Boolean(env.CODEX_ELECTRON_RESOURCES_PATH) ? "codex_desktop" : "codex_cli";
 }
 var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase()), SOURCES2, parseCodexHookInput = (value) => {
-  if (!isRecord3(value) || !Object.hasOwn(EVENTS2, String(value.hook_event_name)))
+  if (!isRecord4(value) || !Object.hasOwn(EVENTS2, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const event = value.hook_event_name;
   const cwd = existingDirectory(value.cwd);
@@ -17013,7 +17188,7 @@ var undocumented, CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name)
     return { ok: false, error: "cwd must be an existing absolute directory" };
   if (event === "PreToolUse" && !nonEmpty2(value.tool_name))
     return { ok: false, error: "tool_name is required" };
-  const command = isRecord3(value.tool_input) ? commandText(value.tool_input.command) : null;
+  const command = isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null;
   if (event === "PreToolUse" && isShellTool(value.tool_name) && !command)
     return { ok: false, error: "tool_input.command is required for shell tools" };
   if (event === "SubagentStart" && !nonEmpty2(value.agent_id))
@@ -17200,7 +17375,7 @@ var init_codex = __esm(() => {
       const host = detectCodexSurface(env);
       const parsed = parseCodexHookInput(raw);
       if (!parsed.ok) {
-        const native = isRecord3(raw) && Object.hasOwn(EVENTS2, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+        const native = isRecord4(raw) && Object.hasOwn(EVENTS2, String(raw.hook_event_name)) ? raw.hook_event_name : null;
         return { ok: false, error: parsed.error, native, event: native ? EVENTS2[native] : null };
       }
       const input = parsed.data;
@@ -17230,7 +17405,7 @@ var init_codex = __esm(() => {
 // packages/workit-core/src/hooks/hosts/cursor.ts
 import path18 from "node:path";
 var undocumented2, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
-  if (!isRecord3(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
+  if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const roots = value.workspace_roots;
   if (!Array.isArray(roots) || roots.length === 0 || !roots.every(nonEmpty2))
@@ -17442,7 +17617,7 @@ var init_cursor = __esm(() => {
     parse(raw) {
       const parsed = parseCursorHookInput(raw);
       if (!parsed.ok) {
-        const native = isRecord3(raw) && Object.hasOwn(EVENTS3, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+        const native = isRecord4(raw) && Object.hasOwn(EVENTS3, String(raw.hook_event_name)) ? raw.hook_event_name : null;
         return { ok: false, error: parsed.error, native, event: native ? EVENTS3[native] : null };
       }
       const input = parsed.data;