opencode-codeops 2.4.0 → 2.6.0

package/bin/lib/test-selection-changes.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+/**
+ * Git change detection and baseline resolution for the selector.
+ *
+ * The selector never guesses where a change began. This module resolves one
+ * base from an explicit value, an environment hint, the last successful full-run
+ * marker, or the branch policy, and then collects every changed path — committed,
+ * staged, unstaged, renamed, deleted, and untracked.
+ *
+ * All shell work goes through `spawnSync` with an argv array. No path is ever
+ * interpolated into a shell string, and the Git calls are read-only.
+ *
+ * @module lib/test-selection-changes
+ */
+
+import { spawnSync } from "node:child_process"
+
+/**
+ * Error raised when a baseline cannot be resolved or Git cannot answer.
+ *
+ * The `reason` value is stable and becomes the selection result's fallback
+ * reason (`marker-missing`, `unresolved-base`, `git-error`).
+ */
+export class SelectionError extends Error {
+  /**
+   * @param {string} reason Stable reason code.
+   * @param {string} message Human-readable explanation.
+   */
+  constructor(reason, message) {
+    super(message)
+    this.name = "SelectionError"
+    this.reason = reason
+  }
+}
+
+/**
+ * Run one read-only Git command.
+ *
+ * @param {string[]} args Git arguments after the program name.
+ * @param {object} [options] Execution options.
+ * @param {string} [options.cwd] Repository root.
+ * @returns {{status: number, stdout: string, stderr: string}} Process result.
+ */
+export function defaultRunGit(args, { cwd } = {}) {
+  const result = spawnSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: 32 * 1024 * 1024,
+  })
+  return {
+    status: result.status ?? 1,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+  }
+}
+
+/**
+ * Parse `git diff --name-status -z` output.
+ *
+ * A rename or copy entry carries two paths after its status token; every other
+ * entry carries one. Both sides of a rename count as changed so a source move
+ * never hides its old or new owner.
+ *
+ * @param {string} output NUL-separated Git output.
+ * @returns {{changed: string[], renames: Array<{from: string, to: string, score: string}>, deleted: string[]}}
+ * @example
+ * parseNameStatusZ("R100\0a.ts\0b.ts\0D\0old.ts\0")
+ */
+export function parseNameStatusZ(output) {
+  const parts = String(output ?? "").split("\0")
+  const changed = []
+  const renames = []
+  const deleted = []
+  const seen = new Set()
+
+  const push = (path) => {
+    if (!path || seen.has(path)) return
+    seen.add(path)
+    changed.push(path)
+  }
+
+  for (let index = 0; index < parts.length; index += 1) {
+    const status = parts[index]
+    if (!status) continue
+    const letter = status[0]
+    if (letter === "R" || letter === "C") {
+      const from = parts[index + 1]
+      const to = parts[index + 2]
+      index += 2
+      if (from && to) {
+        push(from)
+        push(to)
+        renames.push({ from, to, score: status.slice(1) })
+      }
+      continue
+    }
+    const path = parts[index + 1]
+    index += 1
+    if (!path) continue
+    push(path)
+    if (letter === "D") deleted.push(path)
+  }
+  return { changed, renames, deleted }
+}
+
+/**
+ * Parse NUL-separated `git ls-files -z` output into paths.
+ *
+ * @param {string} output NUL-separated output.
+ * @returns {string[]} Non-empty paths.
+ */
+export function parseNullList(output) {
+  return String(output ?? "")
+    .split("\0")
+    .filter((value) => value.length > 0)
+}
+
+/**
+ * Check whether a value looks like a Git object hash.
+ *
+ * @param {string} value Candidate value.
+ * @returns {boolean} `true` for a 40- or 64-character hexadecimal string.
+ */
+function isObjectHash(value) {
+  return /^[0-9a-f]{40}$|^[0-9a-f]{64}$/i.test(value)
+}
+
+/**
+ * Normalize a branch name for classification.
+ *
+ * @param {string} branch Raw branch or ref.
+ * @returns {string} Branch name without `refs/heads/` or `refs/remotes/`.
+ */
+function branchName(branch) {
+  return String(branch ?? "")
+    .replace(/^refs\/heads\//, "")
+    .replace(/^refs\/remotes\/[^/]+\//, "")
+}
+
+/**
+ * Resolve the base for change detection.
+ *
+ * Priority is explicit `--baseline`/`--since`, `CODEOPS_TEST_BASE`, the
+ * last-full marker, then the branch policy. An integration branch with no valid
+ * marker fails closed; it never falls back to `HEAD`, because an empty diff
+ * would silently skip every test.
+ *
+ * @param {object} input Resolution input.
+ * @param {string} [input.baseline] Explicit tree or ref.
+ * @param {string} [input.lastFullSha] Last successful full-run SHA.
+ * @param {string} [input.branch] Current branch or ref.
+ * @param {boolean} [input.isTag=false] Whether the ref is a release tag.
+ * @param {Record<string, string>} [input.env] Environment values.
+ * @param {(args: string[], options?: object) => {status: number, stdout: string}} [input.runGit] Git runner.
+ * @returns {{kind: "tree"|"ref", value: string}} Resolved base.
+ * @throws {SelectionError} When no safe base exists.
+ * @example
+ * resolveBaseline({ branch: "feature/x", runGit: defaultRunGit })
+ */
+export function resolveBaseline({
+  baseline,
+  lastFullSha,
+  branch,
+  isTag = false,
+  env = {},
+  runGit = defaultRunGit,
+} = {}) {
+  const explicit = baseline ?? env.CODEOPS_TEST_BASE
+  if (explicit) {
+    const check = runGit(["rev-parse", "--verify", `${explicit}^{object}`])
+    if (check.status !== 0) throw new SelectionError("unresolved-base", `cannot resolve base ${explicit}`)
+    return { kind: isObjectHash(explicit) ? "tree" : "ref", value: explicit }
+  }
+
+  const name = branchName(branch)
+  const marker = lastFullSha ?? env.CODEOPS_LAST_FULL_SHA ?? null
+
+  if (name === "main" || name === "master") {
+    if (!marker) throw new SelectionError("marker-missing", `${name} needs a last successful full-run marker`)
+    const ancestor = runGit(["merge-base", "--is-ancestor", marker, "HEAD"])
+    if (ancestor.status !== 0) {
+      throw new SelectionError("marker-missing", `marker ${marker} is not an ancestor of HEAD`)
+    }
+    return { kind: "ref", value: marker }
+  }
+
+  if (isTag || /^v\d/.test(name)) {
+    const previous = runGit(["describe", "--tags", "--abbrev=0", "--match", "v*", `${name}^`])
+    if (previous.status === 0 && previous.stdout.trim()) {
+      return { kind: "ref", value: previous.stdout.trim() }
+    }
+    throw new SelectionError("unresolved-base", `no previous release tag before ${name}`)
+  }
+
+  if (name.startsWith("release/") || name.startsWith("release-") || name.startsWith("hotfix/") || name.startsWith("hotfix-")) {
+    const previous = runGit(["describe", "--tags", "--abbrev=0", "--match", "v*", "HEAD^"])
+    if (previous.status === 0 && previous.stdout.trim()) {
+      return { kind: "ref", value: previous.stdout.trim() }
+    }
+    return mergeBaseWithIntegration({ runGit, branch: name })
+  }
+
+  return mergeBaseWithIntegration({ runGit, branch: name })
+}
+
+/**
+ * Find the merge base with the first available integration branch.
+ *
+ * @param {object} input Resolution input.
+ * @param {(args: string[], options?: object) => {status: number, stdout: string}} input.runGit Git runner.
+ * @param {string} input.branch Branch being resolved (for the error message).
+ * @returns {{kind: "ref", value: string}} Merge-base commit.
+ * @throws {SelectionError} When neither integration branch exists.
+ */
+function mergeBaseWithIntegration({ runGit, branch }) {
+  for (const integration of ["main", "master"]) {
+    const result = runGit(["merge-base", "HEAD", integration])
+    const value = result.stdout.trim()
+    if (result.status === 0 && value) return { kind: "ref", value }
+  }
+  throw new SelectionError("unresolved-base", `cannot find an integration base for ${branch}`)
+}
+
+/**
+ * Collect every changed path for a selection run.
+ *
+ * @param {object} input Collection input.
+ * @param {string} input.root Repository root.
+ * @param {string} [input.baseline] Explicit base.
+ * @param {string} [input.lastFullSha] Last successful full-run SHA.
+ * @param {string} [input.branch] Current branch.
+ * @param {boolean} [input.isTag=false] Whether the ref is a tag.
+ * @param {string[]} [input.include=[]] Extra paths that must be considered changed.
+ * @param {Record<string, string>} [input.env] Environment values.
+ * @param {(args: string[], options?: object) => {status: number, stdout: string, stderr: string}} [input.runGit] Git runner.
+ * @returns {{base: {kind: string, value: string}, changed: string[], renames: Array<object>, deleted: string[], warnings: object[]}}
+ * @throws {SelectionError} When Git cannot answer.
+ * @example
+ * const changes = collectChanges({ root: process.cwd(), baseline: treeSha, include: ["spec.test.ts"] })
+ */
+export function collectChanges({
+  root,
+  baseline,
+  lastFullSha,
+  branch,
+  isTag = false,
+  include = [],
+  env = {},
+  runGit = defaultRunGit,
+} = {}) {
+  const base = resolveBaseline({ baseline, lastFullSha, branch, isTag, env, runGit })
+
+  const diff = runGit(["diff", "--name-status", "-z", base.value], { cwd: root })
+  if (diff.status !== 0) {
+    throw new SelectionError("git-error", `git diff against ${base.value} failed`)
+  }
+  const parsed = parseNameStatusZ(diff.stdout)
+
+  const untracked = runGit(["ls-files", "--others", "--exclude-standard", "-z"], { cwd: root })
+  if (untracked.status !== 0) {
+    throw new SelectionError("git-error", "git ls-files failed")
+  }
+
+  const changed = [...new Set([...parsed.changed, ...parseNullList(untracked.stdout), ...include])].sort()
+  return {
+    base,
+    changed,
+    renames: parsed.renames,
+    deleted: parsed.deleted,
+    warnings: [],
+  }
+}

package/bin/lib/test-selection-explain.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Human-readable rendering of a selection result.
+ *
+ * JSON is the machine contract; people need a compact summary they can scan in
+ * a terminal. This module keeps formatting out of the selector so both outputs
+ * describe exactly the same result object.
+ *
+ * @module lib/test-selection-explain
+ */
+
+/**
+ * Render the base evidence as one short label.
+ *
+ * @param {{kind?: string, value?: string}|null} base Resolved base.
+ * @returns {string} Human-readable base.
+ */
+function formatBase(base) {
+  if (!base?.value) return "unresolved"
+  return `${base.kind ?? "ref"} ${base.value}`
+}
+
+/**
+ * Render a selection result as a compact multi-line summary.
+ *
+ * @param {object} result Selection result from `selectTests`.
+ * @returns {string} Human-readable summary.
+ * @example
+ * console.log(formatSelection(result))
+ */
+export function formatSelection(result) {
+  const lines = [`mode: ${result.mode}`, `gate: ${result.gate}`, `base: ${formatBase(result.base)}`]
+
+  if (result.mode === "full") {
+    lines.push(`reason: ${result.reason ?? "unknown"}`)
+    if (result.unknownPaths?.length) lines.push(`unknown: ${result.unknownPaths.join(", ")}`)
+    if (result.fullCommand) {
+      const command = Array.isArray(result.fullCommand[0])
+        ? result.fullCommand.map((argv) => argv.join(" ")).join(" && ")
+        : result.fullCommand.join(" ")
+      lines.push(`command: ${command}`)
+    } else {
+      lines.push("command: none configured")
+    }
+    return lines.join("\n")
+  }
+
+  if (result.mode === "none") {
+    lines.push(`reason: ${result.reason ?? "docs-only"}`)
+    return lines.join("\n")
+  }
+
+  lines.push(`selected: ${result.selected.length}/${result.selected.length + result.skipped.length + result.deferred.length} groups`)
+  for (const entry of result.selected) {
+    lines.push(`  ${entry.id}  ${entry.reasons.join(", ")}`)
+  }
+  if (result.deferred.length > 0) {
+    lines.push("deferred:")
+    for (const entry of result.deferred) lines.push(`  ${entry.id}  ${entry.reason}`)
+  }
+  if (result.skipped.length > 0) lines.push(`skipped: ${result.skipped.join(", ")}`)
+  lines.push(`budget: ${result.budget.estimatedSec}s (${result.budget.status})`)
+  for (const warning of result.warnings ?? []) lines.push(`warning: ${warning.code} ${warning.message}`)
+  return lines.join("\n")
+}
+
+/**
+ * Render a result as stable JSON.
+ *
+ * @param {object} result Selection result.
+ * @returns {string} Pretty-printed JSON with a trailing newline.
+ */
+export function formatSelectionJson(result) {
+  return `${JSON.stringify(result, null, 2)}\n`
+}

package/bin/lib/test-selection-glob.d.mts

@@ -0,0 +1,32 @@
+/**
+ * Type declarations for the repository glob matcher.
+ */
+
+/** Validation result for one glob pattern. */
+export type GlobValidation = { ok: true } | { ok: false; message: string }
+
+/** Validate syntax without compiling. */
+export declare function validateGlobPattern(pattern: unknown): GlobValidation
+
+/** Compile a glob to an anchored regular expression. */
+export declare function globToRegExp(
+  pattern: string,
+  options?: { caseSensitive?: boolean }
+): RegExp
+
+/** Match one normalized repository path. */
+export declare function matchesGlob(
+  path: string,
+  pattern: string,
+  options?: { caseSensitive?: boolean }
+): boolean
+
+/** Match one path against a pattern list. */
+export declare function matchesAnyGlob(
+  path: string,
+  patterns: string[],
+  options?: { caseSensitive?: boolean }
+): boolean
+
+/** Check whether two globs can share a path. */
+export declare function globsIntersect(left: string, right: string): boolean

package/bin/lib/test-selection-glob.mjs

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+/**
+ * Small, dependency-free glob matcher for repository paths.
+ *
+ * The selector must not pull a general-purpose glob library into the plugin:
+ * the supported syntax is intentionally narrow, and every pattern comes from a
+ * committed map that a reviewer can read. This module documents that syntax and
+ * rejects constructs it does not implement instead of silently treating them as
+ * literals.
+ *
+ * Supported: `*` (within one segment), `**` (across segments), `?` (one
+ * character), character classes such as `[abc]`, `[a-z]`, `[!abc]`, and `\`
+ * escapes. Not supported: braces, extglobs, and leading negation groups.
+ *
+ * @module lib/test-selection-glob
+ */
+
+const REGEXP_SPECIAL = /[\\^$.*+?()[\]{}|]/
+
+/**
+ * Validate one glob pattern against the supported syntax.
+ *
+ * @param {unknown} pattern Candidate pattern.
+ * @returns {{ok: true} | {ok: false, message: string}} Validation result.
+ * @example
+ * validateGlobPattern("src/**\/*.ts") // { ok: true }
+ */
+export function validateGlobPattern(pattern) {
+  if (typeof pattern !== "string" || pattern.length === 0) {
+    return { ok: false, message: "glob must be a non-empty string" }
+  }
+  if (pattern.startsWith("!")) {
+    return { ok: false, message: "negation groups are not supported" }
+  }
+  for (let index = 0; index < pattern.length; index += 1) {
+    const character = pattern[index]
+    if (character === "\\") {
+      index += 1
+      continue
+    }
+    if (character === "{" || character === "}") {
+      return { ok: false, message: "brace expansion is not supported" }
+    }
+    if (character === "(" && index > 0 && "?*+@!".includes(pattern[index - 1])) {
+      return { ok: false, message: "extglobs are not supported" }
+    }
+    if (character === "[") {
+      const end = findClassEnd(pattern, index + 1)
+      if (end === -1) return { ok: false, message: "unterminated character class" }
+      index = end
+    }
+  }
+  return { ok: true }
+}
+
+/**
+ * Find the closing bracket of a character class.
+ *
+ * @param {string} pattern Glob pattern.
+ * @param {number} start Index just after `[`.
+ * @returns {number} Index of `]`, or -1 when the class is unterminated.
+ */
+function findClassEnd(pattern, start) {
+  for (let index = start; index < pattern.length; index += 1) {
+    if (pattern[index] === "\\") {
+      index += 1
+      continue
+    }
+    if (pattern[index] === "]") return index
+  }
+  return -1
+}
+
+/**
+ * Convert one glob pattern to an anchored regular expression.
+ *
+ * @param {string} pattern Glob pattern.
+ * @param {object} [options] Matching options.
+ * @param {boolean} [options.caseSensitive=true] Whether case matters.
+ * @returns {RegExp} Anchored expression matching a normalized repo path.
+ */
+export function globToRegExp(pattern, { caseSensitive = true } = {}) {
+  const validation = validateGlobPattern(pattern)
+  if (!validation.ok) {
+    throw new Error(`invalid glob ${JSON.stringify(pattern)}: ${validation.message}`)
+  }
+
+  let source = "^"
+  for (let index = 0; index < pattern.length; index += 1) {
+    const character = pattern[index]
+
+    if (character === "\\") {
+      const next = pattern[index + 1]
+      if (next === undefined) {
+        source += "\\\\"
+      } else {
+        source += REGEXP_SPECIAL.test(next) ? `\\${next}` : next
+        index += 1
+      }
+      continue
+    }
+
+    if (character === "*" && pattern[index + 1] === "*") {
+      index += 1
+      if (pattern[index + 1] === "/") {
+        index += 1
+        source += "(?:.*/)?"
+      } else {
+        source += ".*"
+      }
+      continue
+    }
+
+    if (character === "*") {
+      source += "[^/]*"
+      continue
+    }
+
+    if (character === "?") {
+      source += "[^/]"
+      continue
+    }
+
+    if (character === "[") {
+      const end = findClassEnd(pattern, index + 1)
+      let body = pattern.slice(index + 1, end)
+      if (body.startsWith("!")) body = `^${body.slice(1)}`
+      source += `[${body.replace(/\\/g, "\\\\")}]`
+      index = end
+      continue
+    }
+
+    source += REGEXP_SPECIAL.test(character) ? `\\${character}` : character
+  }
+  source += "$"
+  return new RegExp(source, caseSensitive ? "" : "i")
+}
+
+/**
+ * Match one normalized repository path against one glob.
+ *
+ * @param {string} path Repo-relative path with forward slashes.
+ * @param {string} pattern Glob pattern.
+ * @param {object} [options] Matching options.
+ * @param {boolean} [options.caseSensitive=true] Whether case matters.
+ * @returns {boolean} `true` when the pattern matches the whole path.
+ */
+export function matchesGlob(path, pattern, options = {}) {
+  return globToRegExp(pattern, options).test(path)
+}
+
+/**
+ * Match one path against any pattern in a list.
+ *
+ * @param {string} path Repo-relative path.
+ * @param {string[]} patterns Glob patterns.
+ * @param {object} [options] Matching options.
+ * @returns {boolean} `true` when at least one pattern matches.
+ */
+export function matchesAnyGlob(path, patterns, options = {}) {
+  return patterns.some((pattern) => matchesGlob(path, pattern, options))
+}
+
+/**
+ * Extract the literal directory prefix of a glob, before the first wildcard.
+ *
+ * @param {string} pattern Glob pattern.
+ * @returns {string} Prefix ending at the last literal `/`, or an empty string.
+ */
+function globPrefix(pattern) {
+  let literal = ""
+  for (let index = 0; index < pattern.length; index += 1) {
+    const character = pattern[index]
+    if ("*?[".includes(character)) break
+    if (character === "\\") {
+      literal += pattern[index + 1] ?? ""
+      index += 1
+      continue
+    }
+    literal += character
+  }
+  const slash = literal.lastIndexOf("/")
+  return slash === -1 ? "" : literal.slice(0, slash + 1)
+}
+
+/**
+ * Decide whether two globs can match a common path.
+ *
+ * This is a conservative prefix check, not a set-intersection proof. It is used
+ * to stop a documented ignore rule from swallowing an owned source or a
+ * full-on path, so a false positive is a safe error the author can resolve by
+ * narrowing the pattern.
+ *
+ * @param {string} left First glob.
+ * @param {string} right Second glob.
+ * @returns {boolean} `true` when the patterns overlap or one contains the other.
+ * @example
+ * globsIntersect("web/**", "web/billing/**") // true
+ */
+export function globsIntersect(left, right) {
+  if (left === right) return true
+  const leftPrefix = globPrefix(left)
+  const rightPrefix = globPrefix(right)
+  if (leftPrefix === "" || rightPrefix === "") return false
+  return leftPrefix.startsWith(rightPrefix) || rightPrefix.startsWith(leftPrefix)
+}

package/bin/lib/test-selection.d.mts

@@ -0,0 +1,80 @@
+/**
+ * Type declarations for the pure selector.
+ */
+
+import type { TestMap, TestMapGroup, TestMapPolicy } from "./test-map.mjs"
+import type { SelectionBase } from "./test-selection-changes.mjs"
+
+/** Gates accepted by the selector. */
+export type SelectionGate = "task" | "phase" | "pr" | "release" | "acceptance" | "nightly"
+
+/** Partial gates that may narrow the run. */
+export declare const PARTIAL_GATES: readonly SelectionGate[]
+
+/** Every accepted gate. */
+export declare const ALL_GATES: readonly SelectionGate[]
+
+/** One selected group. */
+export interface SelectedGroup {
+  id: string
+  slice: string
+  reasons: string[]
+}
+
+/** One deferred group. */
+export interface DeferredGroup {
+  id: string
+  reason: string
+}
+
+/** One expanded command. */
+export interface SelectionCommand {
+  id: string
+  argv: string[]
+  cwd: string
+}
+
+/** Budget summary. */
+export interface SelectionBudget {
+  estimatedSec: number
+  status: "within-target" | "acceptable" | "over-budget" | "not-applicable"
+  breakdown?: Array<{ id: string; durationSec: number }>
+}
+
+/** Selection result shared by every mode. */
+export interface SelectionResult {
+  schema: number
+  mode: "groups" | "full" | "none"
+  gate: SelectionGate
+  base: SelectionBase | null
+  mapHash: string | null
+  changed: string[]
+  selected: SelectedGroup[]
+  deferred: DeferredGroup[]
+  skipped: string[]
+  commands: SelectionCommand[]
+  budget: SelectionBudget
+  warnings: Array<{ code: string; message: string; breakdown?: object[] }>
+  reason: string | null
+  fullCommand: string[] | string[][] | null
+  unknownPaths: string[]
+}
+
+/** Select groups for one gate. */
+export declare function selectTests(input: {
+  map: TestMap | null
+  mapHash?: string | null
+  changed?: string[]
+  files?: string[] | null
+  gate?: SelectionGate
+  include?: string[]
+  explicitFull?: boolean
+  env?: Record<string, string>
+  base?: SelectionBase | null
+}): SelectionResult
+
+/** Check whether a group relies on target discovery. */
+export declare function groupUsesTargetDiscovery(group: TestMapGroup): boolean
+
+/** Policy type re-export for consumers. */
+export type { TestMapPolicy }