@yaawn/workflow 0.0.0-stage → 0.3.1

package/agents/skills/yaawn-implement-plan/scripts/agent.ts

@@ -0,0 +1,218 @@
+import { readFileSync } from "node:fs";
+import { succeeds } from "./targets.js";
+
+// The coding agent CLI that runs the sessions. The binary only ever comes
+// from this fixed allow-list — never from the settings file or a flag as
+// free text — and is spawned with an argument array, never through a shell.
+
+const agentNames = ["copilot", "claude", "vibe"] as const;
+
+export type AgentName = (typeof agentNames)[number];
+
+export type AgentChoice =
+  { ok: true; agent: AgentName } | { ok: false; failure: string };
+
+export type SessionKind = "implement" | "review" | "fix";
+
+export interface AgentSession {
+  kind: SessionKind;
+  prompt: string;
+  name: string;
+  transcriptPath: string;
+}
+
+export interface AgentCommand {
+  binary: AgentName;
+  args: string[];
+  // Claude and Vibe have no --share: the caller writes their stdout to the
+  // transcript.
+  transcriptFromStdout: boolean;
+}
+
+export interface AgentArguments {
+  agentOption: string | null;
+  rest: string[];
+}
+
+export const settingsPath = ".yaawn/yaawn-settings.json";
+const defaultAgent: AgentName = "copilot";
+const agentFlag = "--agent";
+const maxShownValueLength = 40;
+const copilotEffort = "medium";
+
+// The reviewer runs on a different model than the implementer.
+const copilotModels: Record<SessionKind, string> = {
+  implement: "claude-opus-5.5",
+  review: "gpt-5.3-codex",
+  fix: "claude-opus-5.5",
+};
+
+const claudeModels: Record<SessionKind, string> = {
+  implement: "opus",
+  review: "sonnet",
+  fix: "opus",
+};
+
+const transcriptExtensions: Record<AgentName, string> = {
+  copilot: ".md",
+  claude: ".jsonl",
+  vibe: ".jsonl",
+};
+
+function isAgentName(value: unknown): value is AgentName {
+  return (agentNames as readonly unknown[]).includes(value);
+}
+
+function shownValue(value: unknown): string {
+  return typeof value === "string"
+    ? JSON.stringify(value.slice(0, maxShownValueLength))
+    : "none";
+}
+
+function agentFrom(value: unknown, source: string): AgentChoice {
+  if (isAgentName(value)) return { ok: true, agent: value };
+  return {
+    ok: false,
+    failure: `${source}: unknown agent ${shownValue(value)} (expected one of: ${agentNames.join(", ")})`,
+  };
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function readSettingsText(): string | null {
+  try {
+    return readFileSync(settingsPath, "utf-8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return null;
+    throw error;
+  }
+}
+
+function settingsAgent(): AgentChoice {
+  let text: string | null;
+  try {
+    text = readSettingsText();
+  } catch (error) {
+    return {
+      ok: false,
+      failure: `could not read ${settingsPath}: ${errorMessage(error)}`,
+    };
+  }
+  if (text === null) return { ok: true, agent: defaultAgent };
+  let settings: unknown;
+  try {
+    settings = JSON.parse(text);
+  } catch {
+    return { ok: false, failure: `${settingsPath} is not valid JSON` };
+  }
+  const agent =
+    typeof settings === "object" &&
+    settings !== null &&
+    Object.hasOwn(settings, "agent")
+      ? (settings as { agent: unknown }).agent
+      : undefined;
+  return agentFrom(agent, settingsPath);
+}
+
+// --agent overrides the settings file; a missing settings file means copilot.
+// Never throws: a bad choice comes back as a failure for the pre-flight.
+export function readAgent(agentOption: string | null): AgentChoice {
+  return agentOption === null
+    ? settingsAgent()
+    : agentFrom(agentOption, agentFlag);
+}
+
+export function agentArguments(args: string[]): AgentArguments {
+  const index = args.indexOf(agentFlag);
+  if (index === -1) return { agentOption: null, rest: args };
+  const value = args[index + 1];
+  if (value === undefined || value.startsWith("-")) {
+    throw new Error(`${agentFlag} needs a value: ${agentNames.join(" or ")}`);
+  }
+  const rest = [...args.slice(0, index), ...args.slice(index + 2)];
+  if (rest.includes(agentFlag))
+    throw new Error(`${agentFlag} given more than once`);
+  return { agentOption: value, rest };
+}
+
+export function agentToolCheck(choice: AgentChoice): [string, boolean] {
+  if (!choice.ok) return [choice.failure, false];
+  return [`${choice.agent} not installed`, succeeds("which", [choice.agent])];
+}
+
+export function transcriptExtension(agent: AgentName): string {
+  return transcriptExtensions[agent];
+}
+
+function copilotArgs(session: AgentSession): string[] {
+  return [
+    "-p",
+    session.prompt,
+    "--model",
+    copilotModels[session.kind],
+    "--effort",
+    copilotEffort,
+    "--yolo",
+    "--no-ask-user",
+    "--experimental",
+    "--name",
+    session.name,
+    "--share",
+    session.transcriptPath,
+  ];
+}
+
+function claudeArgs(session: AgentSession): string[] {
+  return [
+    "-p",
+    session.prompt,
+    "--model",
+    claudeModels[session.kind],
+    "--dangerously-skip-permissions",
+    "--output-format",
+    "stream-json",
+    "--verbose",
+  ];
+}
+
+// No model: Vibe uses the user's active_model (overridable via VIBE_ACTIVE_MODEL).
+// --trust only trusts the session's working directory and is not persisted.
+function vibeArgs(session: AgentSession): string[] {
+  return [
+    "-p",
+    session.prompt,
+    "--trust",
+    "--auto-approve",
+    "--disabled-tools",
+    "ask_user_question",
+    "--output",
+    "streaming",
+  ];
+}
+
+export function agentCli(
+  agent: AgentName,
+  session: AgentSession,
+): AgentCommand {
+  if (agent === "claude") {
+    return {
+      binary: "claude",
+      args: claudeArgs(session),
+      transcriptFromStdout: true,
+    };
+  }
+  if (agent === "vibe") {
+    return {
+      binary: "vibe",
+      args: vibeArgs(session),
+      transcriptFromStdout: true,
+    };
+  }
+  return {
+    binary: "copilot",
+    args: copilotArgs(session),
+    transcriptFromStdout: false,
+  };
+}

package/agents/skills/yaawn-implement-plan/scripts/caffeinate.ts

@@ -0,0 +1,56 @@
+import { spawn } from "node:child_process";
+
+// Shared by the overnight scripts of yaawn-implement-plan and
+// yaawn-verify-executed-plan.
+
+export function keepMacAwakeWhileRunning(): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const caffeinate = spawn(
+      "caffeinate",
+      ["-ims", "-w", String(process.pid)],
+      { stdio: "ignore" },
+    );
+    // caffeinate -w waits for this process to exit; a ref'd handle would make
+    // this process wait for caffeinate in turn, so the run would never exit.
+    caffeinate.unref();
+    caffeinate.once("spawn", resolve).once("error", reject);
+  });
+}
+
+function shouldUseColor(): boolean {
+  const { NO_COLOR, FORCE_COLOR, TERM } = process.env;
+  if (NO_COLOR) return false;
+  if (FORCE_COLOR && FORCE_COLOR !== "0") return true;
+  return Boolean(process.stdout.isTTY) && TERM !== "dumb";
+}
+
+export function printWalkAwayBanner(agent?: string): void {
+  const useColor = shouldUseColor();
+  const ansi = (code: string): string => (useColor ? `\x1b[${code}m` : "");
+  const red = ansi("31");
+  const yellow = ansi("33");
+  const green = ansi("32");
+  const dim = ansi("2");
+  const reset = ansi("0");
+  // Every banner line is 59 chars: " │" + 56 interior chars + "│". The
+  // header's 39-char text field names the running agent; runs without
+  // one (verification) keep the plain overnight label.
+  const header =
+    agent === undefined
+      ? "overnight — staying awake"
+      : `${agent} is working ...`;
+  const headerPadding = " ".repeat(39 - header.length);
+  console.log(String.raw`
+ ╭────────────────────────────────────────────────────────╮
+ │ ${red}●${reset} ${yellow}●${reset} ${green}●${reset}           ${dim}${header}${reset}${headerPadding}│
+ ├────────────────────────────────────────────────────────┤
+ │  You can walk away now.                                │
+ │  The Mac stays awake until the run ends.               │
+ │                                                        │
+ │  Plug it in - you can close the lid.                   │
+ │  Leave this terminal and the editor open.              │
+ │                                                        │
+ │  ${green}~ $${reset} █                                                 │
+ ╰────────────────────────────────────────────────────────╯
+`);
+}

package/agents/skills/yaawn-implement-plan/scripts/groups.ts

@@ -0,0 +1,233 @@
+import path from "node:path";
+import { type Issue, sectionContent } from "./targets.js";
+
+// Lane and conflict planning: which lanes conflict, which can run together,
+// and which Yaawn: implementation-group label each ready lane issue carries. Pure —
+// no gh, file system, or process access — so it is unit tested directly.
+
+export interface Lane {
+  issue: number;
+  targets: Issue[];
+}
+
+export interface FilesToChange {
+  files: string[];
+  invalid: string[];
+}
+
+export interface ImplementationGroup {
+  number: number;
+  issues: number[];
+}
+
+export interface LabelAction {
+  issue: number;
+  label: string;
+  kind: "add" | "remove";
+}
+
+export const filesToChangeHeading = "Files to Change";
+const bulletPattern = /^[-*+]\s+(.*)$/;
+const groupLabelPrefix = "Yaawn: implementation-group-";
+const groupLabelPattern = /^Yaawn: implementation-group-([1-9]\d*)$/;
+
+// --- lanes
+
+export function laneIssueNumbers(lane: Lane): number[] {
+  return [...new Set([lane.issue, ...lane.targets.map((target) => target.number)])];
+}
+
+function normalizedRepoPath(entry: string): string | null {
+  const raw = entry.replaceAll("`", "").trim();
+  if (!raw || path.posix.isAbsolute(raw) || path.win32.isAbsolute(raw)) return null;
+  if (raw.split(/[\\/]/).includes("..")) return null;
+  const normalized = path.posix.normalize(raw).replace(/\/+$/, "");
+  return normalized && normalized !== "." ? normalized : null;
+}
+
+export function filesToChange(issue: Issue): FilesToChange {
+  const result: FilesToChange = { files: [], invalid: [] };
+  sectionContent(issue.body, filesToChangeHeading)
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .forEach((line) => {
+      const entry = bulletPattern.exec(line)?.[1];
+      const file = entry === undefined ? null : normalizedRepoPath(entry);
+      if (file) result.files.push(file);
+      else result.invalid.push(line);
+    });
+  return result;
+}
+
+export function laneFiles(lane: Lane): Set<string> {
+  return new Set(lane.targets.flatMap((target) => filesToChange(target).files));
+}
+
+export function lanePairs(lanes: Lane[]): [Lane, Lane][] {
+  return lanes.flatMap((first, index) =>
+    lanes.slice(index + 1).map((second): [Lane, Lane] => [first, second]),
+  );
+}
+
+// Every issue a lane covers — its own number and its targets — mapped to the
+// lanes that cover it.
+export function laneOwners(lanes: Lane[]): Map<number, number[]> {
+  const owners = new Map<number, number[]>();
+  lanes.forEach((lane) =>
+    laneIssueNumbers(lane).forEach((issue) =>
+      owners.set(issue, [...(owners.get(issue) ?? []), lane.issue]),
+    ),
+  );
+  return owners;
+}
+
+// --- conflicts
+
+// Adjacency map: lane issue → set of lane issues it conflicts with.
+export function conflictGraph(lanes: Lane[]): Map<number, Set<number>> {
+  const graph = new Map<number, Set<number>>();
+  lanes.forEach((lane) => graph.set(lane.issue, new Set()));
+  const addEdge = (a: number, b: number): void => {
+    if (a === b) return;
+    graph.get(a)?.add(b);
+    graph.get(b)?.add(a);
+  };
+
+  const owners = laneOwners(lanes);
+  const files = new Map(lanes.map((lane) => [lane.issue, laneFiles(lane)]));
+
+  lanePairs(lanes).forEach(([first, second]) => {
+    const shared = [...(files.get(first.issue) ?? [])].filter((file) =>
+      files.get(second.issue)?.has(file),
+    );
+    if (shared.length > 0) addEdge(first.issue, second.issue);
+  });
+
+  [...owners].forEach(([, laneIssues]) => {
+    for (let i = 0; i < laneIssues.length; i++) {
+      for (let j = i + 1; j < laneIssues.length; j++) {
+        addEdge(laneIssues[i], laneIssues[j]);
+      }
+    }
+  });
+
+  lanes.forEach((lane) => {
+    lane.targets.forEach((target) => {
+      target.externalDependsOn.forEach((dependency) => {
+        (owners.get(dependency) ?? [])
+          .filter((owner) => owner !== lane.issue)
+          .forEach((owner) => addEdge(lane.issue, owner));
+      });
+    });
+  });
+
+  return graph;
+}
+
+// Every maximal independent set in the conflict graph — each is a group of
+// lanes that can run together (no shared files, targets, or cross-lane deps).
+// Recursive: pick a vertex v; every MIS either contains v (recurse on the
+// rest minus v's neighbours) or excludes v (recurse on the rest, keep only
+// sets that touch a neighbour of v so they stay maximal in the full graph).
+export function allCompatibleGroups(
+  vertices: number[],
+  graph: Map<number, Set<number>>,
+): number[][] {
+  if (vertices.length === 0) return [[]];
+  const [v, ...rest] = vertices;
+  const neighbors = graph.get(v) ?? new Set<number>();
+  const withoutNeighbors = rest.filter((u) => !neighbors.has(u));
+  const withV = allCompatibleGroups(withoutNeighbors, graph).map((s) => [v, ...s]);
+  const withoutV = allCompatibleGroups(rest, graph).filter((s) =>
+    s.some((u) => neighbors.has(u)),
+  );
+  return [...withV, ...withoutV];
+}
+
+// --- group identification
+
+// Larger sets first; equal sizes by their members in ascending order, so the
+// set with the smallest member issue number wins.
+function compareSets(first: number[], second: number[]): number {
+  if (first.length !== second.length) return second.length - first.length;
+  const differing = first.findIndex((issue, index) => issue !== second[index]);
+  return differing === -1 ? 0 : first[differing] - second[differing];
+}
+
+function bestCompatibleSet(issues: number[], graph: Map<number, Set<number>>): number[] {
+  return allCompatibleGroups(issues, graph)
+    .map((set) => [...set].sort((a, b) => a - b))
+    .sort(compareSets)[0];
+}
+
+// Partitions the lane issues: the best-ranked maximal set among the still
+// unassigned issues becomes the next group, until every issue has one. Picking
+// per issue instead would split overlapping sets into needless singletons.
+function partitionIntoSets(lanes: Lane[]): number[][] {
+  const graph = conflictGraph(lanes);
+  const sets: number[][] = [];
+  let unassigned = lanes.map((lane) => lane.issue).sort((a, b) => a - b);
+  while (unassigned.length > 0) {
+    const set = bestCompatibleSet(unassigned, graph);
+    sets.push(set);
+    unassigned = unassigned.filter((issue) => !set.includes(issue));
+  }
+  return sets;
+}
+
+// Groups are numbered 1..k by set size descending, ties by smallest member, so
+// the numbering is deterministic while membership is unchanged.
+export function assignGroups(lanes: Lane[]): Map<number, number> {
+  const sets = partitionIntoSets(lanes).sort(compareSets);
+  return new Map(
+    sets.flatMap((set, index) => set.map((issue): [number, number] => [issue, index + 1])),
+  );
+}
+
+export function groupsOf(assignment: Map<number, number>): ImplementationGroup[] {
+  const members = new Map<number, number[]>();
+  [...assignment]
+    .sort(([a], [b]) => a - b)
+    .forEach(([issue, group]) => members.set(group, [...(members.get(group) ?? []), issue]));
+  return [...members]
+    .sort(([a], [b]) => a - b)
+    .map(([number, issues]) => ({ number, issues }));
+}
+
+// --- labels
+
+export const groupLabel = (group: number): string => `${groupLabelPrefix}${group}`;
+
+export const isGroupLabel = (label: string): boolean => label.startsWith(groupLabelPrefix);
+
+function groupLabelsOf(labels: string[]): string[] {
+  return labels.filter(isGroupLabel);
+}
+
+// Every wrong group label is removed, the correct one added when absent.
+export function labelActions(
+  assignment: Map<number, number>,
+  issueLabels: Map<number, string[]>,
+): LabelAction[] {
+  return [...assignment].flatMap(([issue, group]) => {
+    const wanted = groupLabel(group);
+    const current = groupLabelsOf(issueLabels.get(issue) ?? []);
+    const removals = current
+      .filter((label) => label !== wanted)
+      .map((label): LabelAction => ({ issue, label, kind: "remove" }));
+    const additions: LabelAction[] = current.includes(wanted)
+      ? []
+      : [{ issue, label: wanted, kind: "add" }];
+    return [...removals, ...additions];
+  });
+}
+
+// --- label reset
+
+// Only well-formed group labels count: "Yaawn: implementation-group-01" is not one.
+export function groupLabelRemovals(issue: number, labels: string[]): LabelAction[] {
+  return labels
+    .filter((label) => groupLabelPattern.test(label))
+    .map((label): LabelAction => ({ issue, label, kind: "remove" }));
+}