@brainervirus/workit-core 0.8.11 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-core",
-  "version": "0.8.11",
+  "version": "0.9.0",
   "private": false,
   "description": "Workit — workflow rails for agentic coding: specs, plans, YouTrack, CI-gated commits (shared core)",
   "keywords": [

package/scripts/analyze-release-scope.ts

@@ -0,0 +1,93 @@
+#!/usr/bin/env bun
+// AR-16: path-gated releases. Replaces message-only commit analysis: a
+// releasable commit counts only when it touches a PRODUCT PATH (any of the
+// four package dirs). Tooling-only merges produce no release at all.
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+
+export const RELEASE_PACKAGES = [
+  "workit-core",
+  "workit-opencode",
+  "workit-cursor",
+  "workit-cli",
+] as const;
+
+const g = (root: string, args: string[]): string =>
+  execFileSync("git", args, { cwd: root, encoding: "utf8" }).trim();
+
+const SEMVER_TAG = /^v\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+
+export function latestTag(root = process.cwd()): string | null {
+  const out = g(root, ["tag", "--list", "v*", "--sort=-v:refname"])
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => SEMVER_TAG.test(l));
+  return out[0] ?? null;
+}
+
+type Level = "major" | "minor" | "patch";
+const LEVEL_RANK: Record<Level, number> = { patch: 1, minor: 2, major: 3 };
+const TYPE_LEVEL: Record<string, Level> = { fix: "patch", perf: "patch", feat: "minor" };
+
+const subjectLevel = (commit: string): Level | null => {
+  const firstLine = commit.split("\n")[0] ?? "";
+  const m = /^(?:fix|perf|feat)(?:\([^)]*\))?!?:/.exec(firstLine);
+  if (!m) return null;
+  if (m[0].includes("!")) return "major";
+  const body = commit.split("\n").slice(1).join("\n");
+  return /BREAKING[- ]CHANGE:/.test(body)
+    ? "major"
+    : TYPE_LEVEL[m[0].split("(")[0].replace("!", "")];
+};
+
+// Two-pass collection (sanctioned by the task brief): the single-pass
+// `%H<NUL>%s%n%b` + `--name-only` interleave is brittle because execFileSync
+// rejects NUL bytes inside arguments. Bounded by commit count; acceptable for
+// this repo's cadence.
+//
+// diff-tree with -m unions files across a merge's parents (a plain `show`
+// combined diff drops files identical to either parent — e.g. hotfix-branch
+// back-merges), and -z returns raw NUL-delimited paths so spaces/non-ASCII
+// are never C-quoted. NUL is fine in captured output, never in argv.
+const commitsSince = (root: string, from: string): { message: string; files: string[] }[] => {
+  const hashes = g(root, ["log", "--reverse", "--format=%H", `${from}..HEAD`])
+    .split("\n")
+    .filter(Boolean);
+  return hashes.map((h) => ({
+    message: g(root, ["show", "-s", "--format=%B", h]),
+    files: g(root, ["diff-tree", "--no-commit-id", "--name-only", "-r", "-m", "--root", "-z", h])
+      .split("\0")
+      .filter(Boolean),
+  }));
+};
+
+export function analyzeReleaseScope(
+  root = process.cwd(),
+): { level: Level | null; productPkgs: string[] } {
+  const from = latestTag(root);
+  if (from === null) {
+    return { level: "minor", productPkgs: [...RELEASE_PACKAGES] };
+  }
+  const commits = commitsSince(root, from);
+  const levels: Level[] = [];
+  const pkgs = new Set<string>();
+  for (const { message, files } of commits) {
+    const touched = files.filter((f) => RELEASE_PACKAGES.some((p) => f.startsWith(`packages/${p}/`)));
+    if (touched.length === 0) continue;
+    const lvl = subjectLevel(message);
+    if (lvl) levels.push(lvl);
+    for (const f of touched) {
+      const pkg = RELEASE_PACKAGES.find((p) => f.startsWith(`packages/${p}/`));
+      if (pkg) pkgs.add(pkg);
+    }
+  }
+  if (levels.length === 0) return { level: null, productPkgs: [...pkgs] };
+  const level = levels.reduce<Level>((best, l) => (LEVEL_RANK[l] > LEVEL_RANK[best] ? l : best), "patch");
+  return { level, productPkgs: [...pkgs] };
+}
+
+if (import.meta.main) {
+  const root = process.argv[2] ? resolve(process.argv[2]) : process.cwd();
+  const { level } = analyzeReleaseScope(root);
+  if (level) process.stdout.write(`${level}\n`);
+}

package/scripts/publish-changed-packages.ts

@@ -0,0 +1,85 @@
+#!/usr/bin/env bun
+// AR-16: selective publishing. Publishes only packages whose directory
+// changed since the previous v* tag; logs an exact skip line per unchanged
+// package so release logs answer "what shipped?" without leaving the terminal.
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+import { latestTag, RELEASE_PACKAGES } from "./analyze-release-scope";
+
+const git = (root: string, args: string[]): string =>
+  execFileSync("git", args, { cwd: root, encoding: "utf8" }).trim();
+
+export function changedPackages(root: string, fromTag: string): string[] {
+  // Committed state only: <tag>..HEAD, never the working tree — unreviewed
+  // local edits must not decide what ships.
+  return RELEASE_PACKAGES.filter((pkg) => {
+    const out = git(root, ["diff", "--name-only", `${fromTag}..HEAD`, "--", `packages/${pkg}`]);
+    return out !== "";
+  });
+}
+
+export function publishChanged(opts: {
+  root: string;
+  dryRun?: boolean;
+  /**
+   * Base tag to diff against. Empty string means first-ever release (ship
+   * all). Default: latestTag(root). semantic-release creates the NEW release
+   * tag before publish plugins run, so production passes the PREVIOUS tag via
+   * `${lastRelease.gitTag}` — diffing against latestTag() there is always
+   * empty and would skip every package.
+   */
+  fromTag?: string;
+  run?: (cmd: string, args: string[], o: { cwd: string }) => unknown;
+}): { published: string[]; skipped: string[]; tag: string | null } {
+  const { root, dryRun = false } = opts;
+  const run =
+    opts.run ??
+    ((cmd: string, args: string[], o: { cwd: string }) =>
+      execFileSync(cmd, args, { cwd: o.cwd, encoding: "utf8", stdio: "inherit" }));
+  const tag =
+    opts.fromTag !== undefined ? (opts.fromTag === "" ? null : opts.fromTag) : latestTag(root);
+  if (tag === null) {
+    // First-ever release: everything ships.
+    const published: string[] = [];
+    for (const pkg of RELEASE_PACKAGES) {
+      const cwd = resolve(root, "packages", pkg);
+      if (!dryRun) run("npm", ["publish", "--access", "public"], { cwd });
+      published.push(pkg);
+      console.log(`published ${pkg} @ ${cwd}`);
+    }
+    return { published, skipped: [], tag: null };
+  }
+  const changed = new Set(changedPackages(root, tag));
+  const published: string[] = [];
+  const skipped: string[] = [];
+  for (const pkg of RELEASE_PACKAGES) {
+    if (!changed.has(pkg)) {
+      skipped.push(pkg);
+      console.log(`skip ${pkg} (no payload change since ${tag})`);
+      continue;
+    }
+    const cwd = resolve(root, "packages", pkg);
+    try {
+      if (!dryRun) run("npm", ["publish", "--access", "public"], { cwd });
+    } catch (e) {
+      console.log(`publish failed ${pkg}: ${e instanceof Error ? e.message : String(e)}`);
+      throw e;
+    }
+    published.push(pkg);
+    console.log(`published ${pkg} @ ${cwd}`);
+  }
+  return { published, skipped, tag };
+}
+
+// @semantic-release/exec spawns this Cmd as a shell string whose ONLY optional
+// positional arg is rendered from ${lastRelease.gitTag}: present when a
+// previous release exists, absent on a first-ever release. The repo root is
+// always the spawn cwd (release.config.cjs paths are repo-root-relative), so
+// the CLI takes no root argument.
+if (import.meta.main) {
+  publishChanged({
+    root: process.cwd(),
+    dryRun: process.env.PUBLISH_DRY_RUN === "1",
+    ...(process.argv[2] !== undefined ? { fromTag: process.argv[2] } : {}),
+  });
+}