@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/scripts/turn.ts

@@ -0,0 +1,157 @@
+/**
+ * `repo turn [--staged] [<path>]`: gates a change set (the working tree, the index, or one package) with fmt, disable
+ * comments, lint and its baseline, typecheck, reject files, related tests, and sync and check when their inputs
+ * changed, then prints one summary line. Only `--staged` restages, and only what turn itself rewrote.
+ */
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { CONFIG_FILE, findRoot, loadConfig } from "../config.ts";
+import { readWorkspace } from "../sync/workspace.ts";
+import { changeSet, type Scope } from "./change-set.ts";
+import { commentsStep } from "./comments-step.ts";
+import { captureBun } from "./lint.ts";
+import { rejectionsStep } from "./rejections-step.ts";
+import {
+  checkStep,
+  fmtStep,
+  lintStep,
+  syncStep,
+  testsStep,
+  type Bins,
+  type Step,
+  type StepResult,
+  type Turn,
+} from "./turn-steps.ts";
+import { typecheckStep } from "./typecheck-step.ts";
+import { childEnv } from "../env.ts";
+import { NESTED_VITEST_FLAGS } from "../nested-vitest-flags.ts";
+
+export type TurnDeps = { cwd?: string; stdout?: (s: string) => void; stderr?: (s: string) => void; bins?: Bins };
+type Parsed = { ok: true; scope: Scope } | { ok: false; errors: string[] };
+
+const STEPS: readonly Step[] = [
+  fmtStep,
+  commentsStep,
+  lintStep,
+  typecheckStep,
+  rejectionsStep,
+  testsStep,
+  syncStep,
+  checkStep,
+];
+const USE = "use repo turn [--staged] [<path>]";
+
+/** The bin of `name` in the package.json `manifest` resolves to. */
+function binOf(manifest: string, name: string): string {
+  const { bin } = JSON.parse(fs.readFileSync(manifest, "utf8")) as { bin: Record<string, string> };
+  return path.join(path.dirname(manifest), bin[name] as string);
+}
+
+/** typescript from this package's install; vitest from the package being tested, as its own tests would run. */
+export const BINS: Bins = {
+  tsc: (args, cwd) =>
+    captureBun([binOf(Bun.resolveSync("typescript/package.json", import.meta.dirname), "tsc"), ...args], cwd),
+  vitest: (args, cwd) => {
+    let manifest: string;
+    try {
+      manifest = Bun.resolveSync("vitest/package.json", cwd);
+    } catch {
+      return null;
+    }
+    return captureBun(
+      ["--bun", binOf(manifest, "vitest"), ...NESTED_VITEST_FLAGS, ...args],
+      cwd,
+      childEnv({ NO_COLOR: "1" }),
+    );
+  },
+};
+
+function parseArgs(argv: readonly string[], cwd: string, root: string): Parsed {
+  const flags = argv.filter((arg) => arg.startsWith("-"));
+  const paths = argv.filter((arg) => !arg.startsWith("-"));
+  const unknown = flags.find((flag) => flag !== "--staged");
+  if (unknown !== undefined) return { ok: false, errors: [`unknown flag ${unknown}; ${USE}`] };
+  if (paths.length > 1) return { ok: false, errors: [`one path at most; ${USE}`] };
+  if (flags.length > 0 && paths.length > 0)
+    return { ok: false, errors: ["--staged gates the index, a path gates a package; pass one"] };
+  if (flags.length > 0) return { ok: true, scope: { kind: "staged" } };
+  if (paths[0] === undefined) return { ok: true, scope: { kind: "tree" } };
+  const rel = path.relative(root, path.resolve(cwd, paths[0])).split(path.sep).join("/");
+  if (rel.startsWith("..") || path.isAbsolute(rel)) return { ok: false, errors: [`${paths[0]} is outside ${root}`] };
+  return { ok: true, scope: { kind: "package", rel } };
+}
+
+/** The root, its packages and the change set, or why turn cannot start. */
+async function prepare(
+  argv: readonly string[],
+  cwd: string,
+  bins: Bins,
+): Promise<{ ok: true; turn: Turn; staged: boolean } | { ok: false; errors: string[] }> {
+  const root = findRoot(cwd);
+  if (root === null) return { ok: false, errors: [`no ${CONFIG_FILE} in ${cwd} or any parent; run \`bun repo init\``] };
+  const parsed = parseArgs(argv, cwd, root);
+  if (!parsed.ok) return parsed;
+  const loaded = await loadConfig(root);
+  if (!loaded.ok) return loaded;
+  if (!loaded.config.packs.includes("standards"))
+    return { ok: false, errors: [`the standards pack is off; add "standards" to packs in ${CONFIG_FILE}`] };
+  const workspace = readWorkspace(root);
+  if (!workspace.ok) return workspace;
+  const packages = workspace.workspace.packages.map((pkg) => pkg.dir);
+  const changes = changeSet(root, parsed.scope, packages);
+  if (!changes.ok) return changes;
+  const turn = { root, changes: changes.changes, packages, bins, skips: loaded.config.lint.skip };
+  return { ok: true, turn, staged: parsed.scope.kind === "staged" };
+}
+
+/**
+ * Stages the files turn rewrote, so the commit carries them as turn left them; when git refuses (a held index
+ * lock), says so, since the index would otherwise go out with the content turn fixed only on disk.
+ */
+function restage(root: string, touched: readonly string[], stderr: (s: string) => void): boolean {
+  if (touched.length === 0) return true;
+  if (spawnSync("git", ["add", "-A", "--", ...touched], { cwd: root }).status === 0) return true;
+  stderr(`repo turn: git add failed for ${touched.join(" ")}; stage it yourself and commit again\n`);
+  return false;
+}
+
+/** Runs every step whose inputs changed, printing a failed step's output as it ends. */
+function runSteps(turn: Turn, stderr: (s: string) => void): StepResult[] {
+  return STEPS.flatMap((step) => {
+    const result = step(turn);
+    if (result === null) return [];
+    for (const chunk of result.output) stderr(chunk);
+    return [result];
+  });
+}
+
+/** The deps with the process's own for each one left out. */
+function withDefaults(deps: TurnDeps): Required<TurnDeps> {
+  return {
+    cwd: deps.cwd ?? process.cwd(),
+    stdout: deps.stdout ?? ((s: string) => process.stdout.write(s)),
+    stderr: deps.stderr ?? ((s: string) => process.stderr.write(s)),
+    bins: deps.bins ?? BINS,
+  };
+}
+
+export async function main(argv: string[], deps: TurnDeps = {}): Promise<number> {
+  const { cwd, stdout, stderr, bins } = withDefaults(deps);
+  const prepared = await prepare(argv, cwd, bins);
+  if (!prepared.ok) {
+    for (const line of prepared.errors) stderr(`repo turn: ${line}\n`);
+    return 1;
+  }
+  const { turn, staged } = prepared;
+  if (turn.changes.length === 0) {
+    stdout("turn: no changes\n");
+    return 0;
+  }
+  const results = runSteps(turn, stderr);
+  const touched = [...new Set(results.flatMap((result) => result.touched))];
+  const restaged = !staged || restage(turn.root, touched, stderr);
+  const files = `${turn.changes.length} file${turn.changes.length === 1 ? "" : "s"}`;
+  stdout(`turn: ${files} · ${results.map((result) => result.label).join(" · ")}\n`);
+  return restaged && results.every((result) => result.ok) ? 0 : 1;
+}

package/cli/scripts/typecheck-step.ts

@@ -0,0 +1,43 @@
+/** The typecheck step of `repo turn`: each owner's tsconfig.json, then its strict tsconfig.src.json. */
+import fs from "node:fs";
+import path from "node:path";
+import { missingSrcConfig } from "../check-tsconfig.ts";
+import { RUNTIME_CONFIG, SRC_CONFIG } from "../tsconfig.constants.ts";
+import type { Captured } from "./lint.ts";
+import { dirName, failed, owners, passed, type Step, type Turn } from "./turn-steps.ts";
+
+/** A config typecheck ran or found missing: its root-relative path as the label names it, and what to print. */
+type ConfigRun = { name: string; ok: boolean; output: string };
+
+const configRun = (name: string, run: Captured): ConfigRun => ({
+  name,
+  ok: run.code === 0,
+  output: `${run.stdout}${run.stderr}`,
+});
+
+/** The owner's tsconfig.json, then its tsconfig.src.json, which is a failure with check's message when missing. */
+function typecheckOwner(turn: Turn, owner: string): ConfigRun[] {
+  const tsc = (project: string) => turn.bins.tsc(["--noEmit", "-p", project], turn.root);
+  const runtime = configRun(path.posix.join(owner, RUNTIME_CONFIG), tsc(dirName(owner)));
+  const src = path.posix.join(owner, SRC_CONFIG);
+  if (!fs.existsSync(path.join(turn.root, src))) {
+    return [runtime, { name: `${src} missing`, ok: false, output: `repo turn: ${missingSrcConfig(dirName(owner))}\n` }];
+  }
+  return [runtime, configRun(src, tsc(src))];
+}
+
+/**
+ * `tsc --noEmit -p` on the tsconfig.json and the strict tsconfig.src.json of each owning package with a
+ * tsconfig.json, the root for files outside packages. A failure names each failing config by path.
+ */
+export const typecheckStep: Step = (turn) => {
+  const checked = owners(turn).filter((owner) => fs.existsSync(path.join(turn.root, owner, RUNTIME_CONFIG)));
+  if (checked.length === 0) return passed("typecheck skipped (no tsconfig.json)");
+  const bad = checked.flatMap((owner) => typecheckOwner(turn, owner)).filter((run) => !run.ok);
+  if (bad.length === 0) return passed(`typecheck ${checked.map(dirName).join(", ")}`);
+  const names = bad.map(({ name }) => name).sort();
+  return failed(
+    `typecheck failed (${names.join(", ")})`,
+    bad.map(({ output }) => output),
+  );
+};

package/cli/scripts/vscode-tasks.ts

@@ -0,0 +1,175 @@
+#!/usr/bin/env bun
+/**
+ * Write .vscode/tasks.json from package scripts (VS Code and Cursor: Tasks: Run Task).
+ *
+ * One `bun run <script>` shell task per root script, and one per script of every workspace package (root
+ * `package.json` `workspaces` globs), labelled `<scope>:<name>:<script>` with a `${workspaceFolder}` cwd.
+ * A task `isGenerated` rejects (hand-written, extra args, `dependsOn`) is kept, in order, after the generated block.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { isRecord } from "./hook-input.ts";
+import { stripJsonc } from "./jsonc.ts";
+import { resolveRoots } from "./workspace-root.ts";
+
+const TASKS_REL = ".vscode/tasks.json";
+const PRESENTATION = { panel: "new", reveal: "always" };
+
+/** A tasks.json entry; hand-written ones may carry any other field. */
+export interface VsTask {
+  label?: string;
+  type?: string;
+  command?: string;
+  dependsOn?: unknown;
+  options?: { cwd?: string };
+  problemMatcher?: unknown[];
+  presentation?: { panel: string; reveal: string };
+  [key: string]: unknown;
+}
+
+export interface TasksFile {
+  tasks: VsTask[];
+  version: string;
+}
+
+type PackageJson = Record<string, unknown>;
+const RUN_RE = /^bun run \S+$/;
+
+/** True for a task this script writes: a plain `bun run <script>` shell task with no `dependsOn`. */
+export function isGenerated(task: VsTask | null | undefined): boolean {
+  return task != null && task.type === "shell" && !task.dependsOn && RUN_RE.test(String(task.command));
+}
+
+const slash = (p: string): string => p.split(path.sep).join("/");
+
+function readPackage(file: string): PackageJson | null {
+  try {
+    const pkg: unknown = JSON.parse(fs.readFileSync(file, "utf8"));
+    return isRecord(pkg) ? pkg : null;
+  } catch {
+    return null;
+  }
+}
+
+function globDirs(root: string, pattern: string): string[] {
+  const hits = fs.globSync(pattern, {
+    cwd: root,
+    exclude: (entry: string) => path.basename(entry) === "node_modules",
+  });
+  return hits.filter((hit) => !slash(hit).split("/").includes("node_modules")).map((hit) => path.join(root, hit));
+}
+
+function workspaceDirs(root: string, pkg: PackageJson): string[] {
+  const ws: unknown = Array.isArray(pkg.workspaces)
+    ? pkg.workspaces
+    : isRecord(pkg.workspaces)
+      ? pkg.workspaces.packages
+      : undefined;
+  const patterns = (Array.isArray(ws) ? ws : []).filter((p): p is string => typeof p === "string");
+  const dropped = new Set(patterns.filter((p) => p.startsWith("!")).flatMap((p) => globDirs(root, p.slice(1))));
+  const dirs = new Set(patterns.filter((p) => !p.startsWith("!")).flatMap((p) => globDirs(root, p)));
+  return [...dirs]
+    .filter((dir) => !dropped.has(dir) && path.relative(root, dir) !== "")
+    .filter((dir) => fs.existsSync(path.join(dir, "package.json")))
+    .sort();
+}
+
+/** `@acme/api` -> `acme:api`; `api` -> `api`. */
+function labelPrefix(name: string): string {
+  return name.replace(/^@/, "").replace(/\//g, ":");
+}
+
+function shellTask(label: string, script: string, cwd?: string): VsTask {
+  return {
+    label,
+    type: "shell",
+    command: `bun run ${script}`,
+    ...(cwd ? { options: { cwd } } : {}),
+    problemMatcher: [],
+    presentation: { ...PRESENTATION },
+  };
+}
+
+function scriptsOf(pkg: PackageJson): string[] {
+  return isRecord(pkg.scripts) ? Object.keys(pkg.scripts) : [];
+}
+
+/**
+ * @param root checkout root holding the package.json
+ * @param existing the tasks array of the current tasks.json
+ * @returns generated tasks sorted by label, then the kept ones in their order
+ */
+export function buildTasks(root: string, existing: VsTask[]): TasksFile {
+  const pkg = readPackage(path.join(root, "package.json")) ?? {};
+  const kept = existing.filter((task) => !isGenerated(task));
+  const taken = new Set(kept.map((task) => task.label));
+  const generated = new Map<string, VsTask>();
+  const add = (label: string, task: VsTask): void => {
+    if (taken.has(label)) return;
+    taken.add(label);
+    generated.set(label, task);
+  };
+  for (const script of scriptsOf(pkg)) add(script, shellTask(script, script));
+  for (const dir of workspaceDirs(root, pkg)) {
+    const workspace = readPackage(path.join(dir, "package.json"));
+    if (!workspace || typeof workspace.name !== "string" || !workspace.name) continue;
+    const cwd = `\${workspaceFolder}/${slash(path.relative(root, dir))}`;
+    for (const script of scriptsOf(workspace)) {
+      const label = `${labelPrefix(workspace.name)}:${script}`;
+      add(label, shellTask(label, script, cwd));
+    }
+  }
+  // Labels are unique in `generated`, so two never compare equal.
+  const sorted = [...generated].sort(([a], [b]) => (a < b ? -1 : 1)).map(([, task]) => task);
+  return { tasks: [...sorted, ...kept], version: "2.0.0" };
+}
+
+export type RenderedTasks = { ok: true; text: string; generated: number; kept: number } | { ok: false; error: string };
+
+/**
+ * The text of `.vscode/tasks.json` for `root`: the generated tasks, then the ones kept from `existing` (the
+ * current file's text, null when there is none).
+ */
+export function renderTasks(root: string, existing: string | null): RenderedTasks {
+  let tasks: VsTask[] = [];
+  if (existing !== null) {
+    try {
+      const parsed: unknown = JSON.parse(stripJsonc(existing));
+      if (isRecord(parsed) && Array.isArray(parsed.tasks)) tasks = parsed.tasks.filter(isRecord);
+    } catch (err) {
+      return {
+        ok: false,
+        error: `cannot parse ${TASKS_REL}: ${(err /* JSON.parse and stripJsonc throw only Error */ as Error).message}`,
+      };
+    }
+  }
+  const result = buildTasks(root, tasks);
+  const kept = result.tasks.filter((task) => !isGenerated(task)).length;
+  return { ok: true, text: `${JSON.stringify(result, null, 2)}\n`, generated: result.tasks.length - kept, kept };
+}
+
+/** Writes `.vscode/tasks.json` under `root`; prints the count line; returns the exit code. */
+export function run(root: string): number {
+  const file = path.join(root, TASKS_REL);
+  const pkgFile = path.join(root, "package.json");
+  const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : null;
+  const rendered = renderTasks(root, current);
+  if (!rendered.ok) {
+    console.error(`tasks: ${rendered.error.replace(TASKS_REL, file)}`);
+    return 1;
+  }
+  if (!readPackage(pkgFile)) {
+    console.error(`tasks: cannot read ${pkgFile}`);
+    return 1;
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, rendered.text);
+  console.log(
+    `Wrote ${rendered.generated + rendered.kept} tasks to ${TASKS_REL} (${rendered.generated} generated, ${rendered.kept} kept)`,
+  );
+  return 0;
+}
+
+export function main(): number {
+  return run(resolveRoots().checkout);
+}

package/cli/scripts/workspace-root.ts

@@ -0,0 +1,160 @@
+/**
+ * Where repo state lives for a hook or script call (roadmap D1, D2).
+ *
+ *   root      `.tmp/repo` scratch: the main checkout, so subdirs and worktrees share one
+ *   checkout  tracked files (lessons, `cli/scripts`): the checkout the agent works in
+ *   cwd       paths the agent typed and child-process cwds: the hook's cwd, else the sent workspace
+ *
+ * A repo install is the nearest dir holding INSTALL_MARKER, up to the git top level, so a
+ * repo install in a subpackage keeps its own root. All three share the `realpath.native` spelling, so a
+ * symlink, a junction or a Windows 8.3 short name compares equal to the path git prints. Node builtins only.
+ */
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { HookInput } from "./hook-input.ts";
+import { readEnv } from "../env.ts";
+import type { Env } from "../env.ts";
+
+/** The file that marks a repo install: the consumer's `workerstack.config.ts`, which also exists with no `agents/` dir. */
+export const INSTALL_MARKER = "workerstack.config.ts";
+
+export interface GitFacts {
+  top: string;
+  gitDir: string;
+  commonDir: string;
+}
+
+/** Root, checkout and cwd spellings for one hook or script call. */
+export interface Roots {
+  root: string;
+  checkout: string;
+  cwd: string;
+}
+
+interface RootsContext {
+  git: (dir: string) => GitFacts | null;
+  p: typeof path;
+  exists: (abs: string) => boolean;
+  realpath: (abs: string, p?: typeof path) => string;
+}
+
+const revParseMemo = new Map<string, GitFacts | null>();
+
+/** `{ top, gitDir, commonDir }` for `dir`, or null outside git. Memoized for this process only. */
+export function gitRevParse(dir: string, run: typeof execFileSync = execFileSync): GitFacts | null {
+  if (revParseMemo.has(dir)) return revParseMemo.get(dir) ?? null;
+  let facts: GitFacts | null = null;
+  try {
+    const out = run(
+      "git",
+      ["-C", dir, "rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir"],
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] },
+    );
+    const [top, gitDir, commonDir] = out.split(/\r?\n/);
+    if (top && gitDir && commonDir) facts = { top, gitDir, commonDir };
+  } catch {
+    facts = null;
+  }
+  revParseMemo.set(dir, facts);
+  return facts;
+}
+
+/** The filesystem calls `canonicalPath` makes, replaceable by a test. */
+interface CanonicalEdges {
+  exists: (abs: string) => boolean;
+  real: (abs: string) => string;
+}
+
+const NATIVE_EDGES: CanonicalEdges = { exists: fs.existsSync, real: fs.realpathSync.native };
+
+/**
+ * `abs` with its nearest existing ancestor in the `realpath.native` spelling. A relative path, a non-string, or a
+ * path for a foreign `p` (a `path.win32` test on Linux) comes back unchanged.
+ */
+export function canonicalPath(abs: string, p: typeof path = path, edges: CanonicalEdges = NATIVE_EDGES): string {
+  const { exists, real } = edges;
+  if (p !== path || typeof abs !== "string" || !path.isAbsolute(abs)) return abs;
+  let dir = abs;
+  while (!exists(dir)) {
+    const up = path.dirname(dir);
+    if (up === dir) return abs;
+    dir = up;
+  }
+  try {
+    return path.join(real(dir), path.relative(dir, abs));
+  } catch {
+    return abs;
+  }
+}
+
+/** A path an agent typed, resolved against the roots' cwd, in the roots' spelling. */
+export function resolveTyped(roots: { cwd: string }, raw: string, p: typeof path = path): string {
+  return canonicalPath(p.resolve(roots.cwd, raw), p);
+}
+
+function firstString(...values: unknown[]): string {
+  for (const v of values) if (typeof v === "string" && v.trim()) return v.trim();
+  return "";
+}
+
+function asDir(value: string): string {
+  return value.startsWith("file:") ? fileURLToPath(value) : value;
+}
+
+function within(p: typeof path, top: string, dir: string): boolean {
+  const rel = p.relative(top, dir);
+  return !rel.startsWith("..") && !p.isAbsolute(rel);
+}
+
+/** Nearest dir from `dir` up to the git top level that holds the repo marker, else that top level. */
+function checkoutIn(dir: string, facts: GitFacts | null, { p, exists, realpath }: RootsContext): string {
+  if (!facts) return dir;
+  const top = realpath(p.resolve(facts.top));
+  if (!within(p, top, dir)) return top;
+  for (let d = dir; ; d = p.dirname(d)) {
+    if (exists(p.join(d, INSTALL_MARKER))) return d;
+    if (d === top) return top;
+  }
+}
+
+function rootsFor(start: string, ctx: RootsContext): { checkout: string; root: string } {
+  const facts = ctx.git(start);
+  const checkout = checkoutIn(start, facts, ctx);
+  if (!facts) return { checkout, root: checkout };
+  const { p } = ctx;
+  const gitDir = ctx.realpath(p.resolve(facts.gitDir));
+  const commonDir = ctx.realpath(p.resolve(facts.commonDir));
+  if (gitDir === commonDir || p.basename(commonDir) !== ".git") return { checkout, root: checkout };
+  const main = p.dirname(commonDir);
+  return { checkout, root: p.join(main, p.relative(ctx.realpath(p.resolve(facts.top)), checkout)) };
+}
+
+/** Resolves roots from a hook input; reads workspaceRoot, workspace_root, workspacePaths, cwd and toolCall.args.Cwd. */
+export function resolveRoots(
+  input: HookInput | null = {},
+  {
+    env = readEnv(),
+    cwd = process.cwd(),
+    git = gitRevParse,
+    p = path,
+    exists = fs.existsSync,
+    realpath = canonicalPath,
+  }: Partial<RootsContext> & { env?: Env; cwd?: string } = {},
+): Roots {
+  const data: HookInput = input && typeof input === "object" ? input : {};
+  const args = data.toolCall?.args ?? {};
+  const ctx: RootsContext = { git, p, exists, realpath };
+  const paths = Array.isArray(data.workspacePaths) ? data.workspacePaths : [];
+  const given = firstString(data.workspaceRoot, data.workspace_root, paths[0]);
+  // A workspace the harness sent beats the hook process cwd as where the agent works.
+  const hookCwd = realpath(p.resolve(cwd, asDir(firstString(data.cwd, args.Cwd, given) || ".")));
+  const candidate = firstString(given, env.GROK_WORKSPACE_ROOT, env.CLAUDE_PROJECT_DIR);
+  const start = candidate ? realpath(p.resolve(cwd, asDir(candidate))) : hookCwd;
+  return {
+    root: rootsFor(start, ctx).root,
+    checkout: rootsFor(hookCwd, ctx).checkout,
+    cwd: hookCwd,
+  };
+}