supipowers 1.5.3 → 2.0.1

package/src/release/prompt.ts

@@ -1,4 +1,6 @@
 import { formatTag } from "./version.js";
+import { renderSchemaText } from "../ai/schema-text.js";
+import { ReleaseNotePolishOutputSchema } from "./contracts.js";
 
 export interface BuildPolishPromptOpts {
   changelog: string;
@@ -10,7 +12,9 @@ export interface BuildPolishPromptOpts {
  * Build a prompt for a headless agent session that polishes raw changelog
  * text into clear, user-facing release notes.
  *
- * The agent returns only the polished markdown — no commands, no confirmation.
+ * The agent returns a structured JSON artifact matching
+ * ReleaseNotePolishOutputSchema. The release command renders the polished
+ * changelog from that artifact — no free-form text, no regex extraction.
  */
 export function buildPolishPrompt(opts: BuildPolishPromptOpts): string {
   const { changelog, version } = opts;
@@ -66,6 +70,18 @@ export function buildPolishPrompt(opts: BuildPolishPromptOpts): string {
     "",
     "## Output",
     "",
-    "Return **only** the polished markdown changelog. No preamble, no explanation, no code fences wrapping the whole output.",
+    "Respond with a JSON object that matches this TypeScript shape exactly:",
+    "",
+    "```ts",
+    renderSchemaText(ReleaseNotePolishOutputSchema),
+    "```",
+    "",
+    "Field guide:",
+    "- `title`: short one-line heading for the release (no leading `#`).",
+    "- `body`: the grouped markdown sections (Breaking Changes, Features, Fixes, ...). Omit empty sections.",
+    "- `highlights`: 0–5 short bullet strings summarising the most user-visible changes. Each string is a plain sentence, no leading `-`.",
+    "- `status`: `\"ok\"` when the release has notable changes; `\"empty\"` when the raw changelog had nothing worth polishing (highlights may be empty and body may be a short placeholder).",
+    "",
+    "Respond with only the JSON object. You may wrap it in a ```json fence.",
   ].join("\n");
 }

package/src/release/targets.ts

@@ -0,0 +1,86 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { PackageManagerId, ReleaseTarget, WorkspaceTarget } from "../types.js";
+import { discoverWorkspaceTargets } from "../workspace/targets.js";
+
+interface ReleaseManifest {
+  name?: string;
+  version?: string;
+  private?: boolean;
+  files?: unknown;
+}
+
+const ROOT_TAG_FORMAT = "v${version}";
+
+function normalizeReleasePath(value: string): string {
+  return value
+    .replace(/\\/g, "/")
+    .replace(/^\.\//, "")
+    .replace(/^\//, "")
+    .replace(/\/package\.json$/, "")
+    .replace(/\/+$/, "");
+}
+
+function readReleaseManifest(manifestPath: string): ReleaseManifest | null {
+  try {
+    return JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as ReleaseManifest;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeFilesWhitelist(files: unknown): string[] {
+  if (!Array.isArray(files)) {
+    return [];
+  }
+
+  return files
+    .filter((entry): entry is string => typeof entry === "string")
+    .map((entry) => normalizeReleasePath(entry))
+    .filter(Boolean);
+}
+
+function joinTargetPath(relativeDir: string, entry: string): string {
+  if (relativeDir === ".") {
+    return entry;
+  }
+  return `${relativeDir}/${entry}`;
+}
+
+function buildPublishScopePaths(target: WorkspaceTarget, manifest: ReleaseManifest | null): string[] {
+  const manifestPath = joinTargetPath(target.relativeDir, "package.json");
+  const filesWhitelist = normalizeFilesWhitelist(manifest?.files);
+  if (filesWhitelist.length > 0) {
+    return [...new Set([manifestPath, ...filesWhitelist.map((entry) => joinTargetPath(target.relativeDir, entry))])];
+  }
+
+  const packageDirScope = target.relativeDir === "." ? "." : target.relativeDir;
+  return [...new Set([manifestPath, packageDirScope])];
+}
+
+function getDefaultTagFormat(target: WorkspaceTarget): string {
+  return target.kind === "root" ? ROOT_TAG_FORMAT : `${target.name}@${ROOT_TAG_FORMAT.replace("v", "")}`;
+}
+
+function hasReleaseVersion(manifest: ReleaseManifest | null): manifest is ReleaseManifest & { version: string } {
+  return typeof manifest?.version === "string" && manifest.version.trim().length > 0;
+}
+
+function toReleaseTarget(target: WorkspaceTarget, manifest = readReleaseManifest(target.manifestPath)): ReleaseTarget {
+  return {
+    ...target,
+    publishScopePaths: buildPublishScopePaths(target, manifest),
+    defaultTagFormat: getDefaultTagFormat(target),
+  };
+}
+
+export function discoverReleaseTargets(repoRoot: string, packageManager: PackageManagerId): ReleaseTarget[] {
+  return discoverWorkspaceTargets(repoRoot, packageManager).flatMap((target) => {
+    const manifest = readReleaseManifest(target.manifestPath);
+    return hasReleaseVersion(manifest) ? [toReleaseTarget(target, manifest)] : [];
+  });
+}
+
+export function getPublishableReleaseTargets(targets: ReleaseTarget[]): ReleaseTarget[] {
+  return targets.filter((target) => !target.private);
+}

package/src/release/version.ts

@@ -1,6 +1,5 @@
 import fs from "fs";
-import path from "path";
-import type { BumpType, CategorizedCommits } from "../types.js";
+import type { BumpType, CategorizedCommits, ReleaseTarget } from "../types.js";
 
 type ExecFn = (
   cmd: string,
@@ -8,6 +7,18 @@ type ExecFn = (
   opts?: { cwd?: string },
 ) => Promise<{ stdout: string; stderr: string; code: number }>;
 
+interface PackageManifest {
+  version?: string;
+}
+
+interface ParsedReleaseTag {
+  tag: string;
+  version: string;
+}
+
+const LEGACY_RELEASE_TAG_FORMAT = "v${version}";
+const SEMVER_CAPTURE = "([0-9]+\\.[0-9]+\\.[0-9]+(?:-[0-9A-Za-z.-]+)?)";
+
 /**
  * Replace `${version}` in a tag format template with the actual version string.
  * If the template contains no placeholder, it is returned as-is.
@@ -32,7 +43,6 @@ export function suggestBump(commits: CategorizedCommits): BumpType {
  * Returns a plain "X.Y.Z" string — never prefixed with "v".
  */
 export function bumpVersion(current: string, bump: BumpType): string {
-  // Strip pre-release / build metadata before parsing
   const core = current.split("-")[0].split("+")[0];
   const parts = core.split(".").map(Number);
 
@@ -40,8 +50,7 @@ export function bumpVersion(current: string, bump: BumpType): string {
     throw new Error(`Invalid semver string: "${current}"`);
   }
 
-  let [major, minor, patch] = parts;
-
+  const [major, minor, patch] = parts;
   switch (bump) {
     case "major":
       return `${major + 1}.0.0`;
@@ -52,56 +61,38 @@ export function bumpVersion(current: string, bump: BumpType): string {
   }
 }
 
-/**
- * Read the parsed package.json object from `<cwd>/package.json`. Returns null
- * when the file is absent or invalid.
- */
-function readPackageJson(cwd: string): { version?: string; files?: unknown } | null {
-  const pkgPath = path.join(cwd, "package.json");
+function readPackageJson(manifestPath: string): PackageManifest | null {
   try {
-    const raw = fs.readFileSync(pkgPath, "utf-8");
-    return JSON.parse(raw) as { version?: string; files?: unknown };
+    return JSON.parse(fs.readFileSync(manifestPath, "utf-8")) as PackageManifest;
   } catch {
     return null;
   }
 }
 
 /**
- * Read the `version` field from `<cwd>/package.json`.
- * Returns `"0.0.0"` when the file is absent or carries no version field.
+ * Read the current version from the selected release target's manifest.
+ * Returns "0.0.0" when the manifest is absent or carries no version field.
  */
-export function getCurrentVersion(cwd: string): string {
-  return readPackageJson(cwd)?.version ?? "0.0.0";
+export function getCurrentVersion(target: ReleaseTarget): string {
+  return readPackageJson(target.manifestPath)?.version ?? "0.0.0";
 }
 
-/**
- * Return the publishable package paths used to scope release-note commits.
- * Returns null when the package manifest does not declare a `files` whitelist.
- */
-export function getPublishedPackagePaths(cwd: string): string[] | null {
-  const files = readPackageJson(cwd)?.files;
-  if (!Array.isArray(files)) {
-    return null;
-  }
-
-  const normalized = files
-    .filter((entry): entry is string => typeof entry === "string")
-    .map((entry) => entry.replace(/^\.\//, "").replace(/\/+$/, ""))
-    .filter(Boolean);
-
-  if (normalized.length === 0) {
-    return null;
-  }
-
-  return [...new Set(["package.json", ...normalized])];
+/** Return the target-specific publish scope already computed during discovery. */
+export function getPublishedPackagePaths(target: ReleaseTarget): string[] {
+  return [...target.publishScopePaths];
 }
 
-interface ParsedReleaseTag {
-  tag: string;
-  version: string;
+/** Resolve the effective tag format for a selected target. */
+export function getReleaseTagFormat(target: ReleaseTarget, rootTagFormat: string): string {
+  return target.kind === "root" ? rootTagFormat : target.defaultTagFormat;
 }
 
-const SEMVER_CAPTURE = "([0-9]+\\.[0-9]+\\.[0-9]+(?:-[0-9A-Za-z.-]+)?)";
+function getTagFormatsForTarget(target: ReleaseTarget, rootTagFormat: string): string[] {
+  const effectiveTagFormat = getReleaseTagFormat(target, rootTagFormat);
+  return target.kind === "root"
+    ? [...new Set([effectiveTagFormat, LEGACY_RELEASE_TAG_FORMAT])]
+    : [effectiveTagFormat];
+}
 
 function escapeRegExp(value: string): string {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -117,9 +108,15 @@ function extractVersionFromTag(tag: string, tagFormat: string): string | null {
   return match?.[1] ?? null;
 }
 
-function parseReleaseTag(tag: string, tagFormat: string): ParsedReleaseTag | null {
-  const version = extractVersionFromTag(tag, tagFormat) ?? extractVersionFromTag(tag, LEGACY_RELEASE_TAG_FORMAT);
-  return version ? { tag, version } : null;
+function parseReleaseTag(tag: string, target: ReleaseTarget, rootTagFormat: string): ParsedReleaseTag | null {
+  for (const tagFormat of getTagFormatsForTarget(target, rootTagFormat)) {
+    const version = extractVersionFromTag(tag, tagFormat);
+    if (version) {
+      return { tag, version };
+    }
+  }
+
+  return null;
 }
 
 function compareSemver(left: string, right: string): number {
@@ -142,10 +139,10 @@ function compareSemver(left: string, right: string): number {
   return left.includes("-") ? -1 : 1;
 }
 
-async function isTagAtHead(exec: ExecFn, cwd: string, tag: string): Promise<boolean> {
+async function isTagAtHead(exec: ExecFn, repoRoot: string, tag: string): Promise<boolean> {
   const [tagCommit, headCommit] = await Promise.all([
-    exec("git", ["rev-list", "-n", "1", tag], { cwd }),
-    exec("git", ["rev-parse", "HEAD"], { cwd }),
+    exec("git", ["rev-list", "-n", "1", tag], { cwd: repoRoot }),
+    exec("git", ["rev-parse", "HEAD"], { cwd: repoRoot }),
   ]);
 
   return tagCommit.code === 0
@@ -154,14 +151,39 @@ async function isTagAtHead(exec: ExecFn, cwd: string, tag: string): Promise<bool
     && tagCommit.stdout.trim() === headCommit.stdout.trim();
 }
 
+export async function getLatestReleaseTag(
+  exec: ExecFn,
+  target: ReleaseTarget,
+  rootTagFormat: string,
+): Promise<string | null> {
+  try {
+    const localTags = await exec("git", ["tag", "--merged", "HEAD"], { cwd: target.repoRoot });
+    if (localTags.code !== 0) {
+      return null;
+    }
+
+    const latest = localTags.stdout
+      .split(/\r?\n/)
+      .map((tag) => tag.trim())
+      .filter(Boolean)
+      .map((tag) => parseReleaseTag(tag, target, rootTagFormat))
+      .filter((candidate): candidate is ParsedReleaseTag => Boolean(candidate))
+      .sort((left, right) => compareSemver(right.version, left.version))[0];
+
+    return latest?.tag ?? null;
+  } catch {
+    return null;
+  }
+}
+
 export async function findResumableLocalRelease(
   exec: ExecFn,
-  cwd: string,
+  target: ReleaseTarget,
   currentVersion: string,
-  tagFormat: string,
+  rootTagFormat: string,
 ): Promise<{ version: string; tag: string } | null> {
   try {
-    const localTags = await exec("git", ["tag", "--merged", "HEAD"], { cwd });
+    const localTags = await exec("git", ["tag", "--merged", "HEAD"], { cwd: target.repoRoot });
     if (localTags.code !== 0) {
       return null;
     }
@@ -170,18 +192,18 @@ export async function findResumableLocalRelease(
       .split(/\r?\n/)
       .map((tag) => tag.trim())
       .filter(Boolean)
-      .map((tag) => parseReleaseTag(tag, tagFormat))
+      .map((tag) => parseReleaseTag(tag, target, rootTagFormat))
       .filter((candidate): candidate is ParsedReleaseTag => Boolean(candidate))
       .filter((candidate) => compareSemver(candidate.version, currentVersion) > 0)
       .sort((left, right) => compareSemver(right.version, left.version));
 
     for (const candidate of candidates) {
-      const remoteTag = await exec("git", ["ls-remote", "--tags", "origin", candidate.tag], { cwd });
+      const remoteTag = await exec("git", ["ls-remote", "--tags", "origin", candidate.tag], { cwd: target.repoRoot });
       if (remoteTag.code !== 0 || remoteTag.stdout.trim() !== "") {
         continue;
       }
 
-      if (await isTagAtHead(exec, cwd, candidate.tag)) {
+      if (await isTagAtHead(exec, target.repoRoot, candidate.tag)) {
         return { version: candidate.version, tag: candidate.tag };
       }
     }
@@ -192,37 +214,41 @@ export async function findResumableLocalRelease(
   }
 }
 
-
-const LEGACY_RELEASE_TAG_FORMAT = "v${version}";
-
-function getReleaseTagCandidates(version: string, tagFormat: string): string[] {
-  return [...new Set([formatTag(version, tagFormat), formatTag(version, LEGACY_RELEASE_TAG_FORMAT)])];
+function getReleaseTagCandidates(
+  target: ReleaseTarget,
+  version: string,
+  rootTagFormat: string,
+): string[] {
+  return [...new Set(getTagFormatsForTarget(target, rootTagFormat).map((tagFormat) => formatTag(version, tagFormat)))];
 }
 
 async function hasMatchingReleaseTag(
   exec: ExecFn,
-  cwd: string,
+  target: ReleaseTarget,
   args: string[],
   version: string,
-  tagFormat: string,
+  rootTagFormat: string,
 ): Promise<boolean> {
-  const result = await exec("git", [...args, ...getReleaseTagCandidates(version, tagFormat)], { cwd });
+  const result = await exec(
+    "git",
+    [...args, ...getReleaseTagCandidates(target, version, rootTagFormat)],
+    { cwd: target.repoRoot },
+  );
   return result.code === 0 && result.stdout.trim().length > 0;
 }
 
 /**
  * Check whether a tag for the given version already exists locally.
- * Returns `true` when either the current-format tag or the legacy `v{version}`
- * tag is already known locally, which means this version was already released.
+ * Root targets keep the legacy `v${version}` fallback; workspace targets do not.
  */
 export async function isVersionReleased(
   exec: ExecFn,
-  cwd: string,
+  target: ReleaseTarget,
   version: string,
-  tagFormat: string,
+  rootTagFormat: string,
 ): Promise<boolean> {
   try {
-    return await hasMatchingReleaseTag(exec, cwd, ["tag", "-l"], version, tagFormat);
+    return await hasMatchingReleaseTag(exec, target, ["tag", "-l"], version, rootTagFormat);
   } catch {
     return false;
   }
@@ -230,17 +256,16 @@ export async function isVersionReleased(
 
 /**
  * Check whether a tag for the given version exists on the remote (origin).
- * Returns true when either the current-format tag or the legacy `v{version}`
- * tag is found via `git ls-remote --tags origin`.
+ * Root targets keep the legacy `v${version}` fallback; workspace targets do not.
  */
 export async function isTagOnRemote(
   exec: ExecFn,
-  cwd: string,
+  target: ReleaseTarget,
   version: string,
-  tagFormat: string,
+  rootTagFormat: string,
 ): Promise<boolean> {
   try {
-    return await hasMatchingReleaseTag(exec, cwd, ["ls-remote", "--tags", "origin"], version, tagFormat);
+    return await hasMatchingReleaseTag(exec, target, ["ls-remote", "--tags", "origin"], version, rootTagFormat);
   } catch {
     return false;
   }