@gevezex/gdt 0.2.0 → 0.4.0

package/dist/cli.js

@@ -2,11 +2,12 @@
 import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CONFIG_PATH, DEFAULT_LANGUAGE, DEFAULT_MAX_ACCEPTANCE_CRITERIA, loadConfig, ROLES } from "./config.js";
+import { CONFIG_PATH, DEFAULT_LANGUAGE, DEFAULT_MAX_ACCEPTANCE_CRITERIA, loadConfig, readUserConfig, ROLES } from "./config.js";
 import { validateContract } from "./contract.js";
-import { findRepository, runDoctor } from "./doctor.js";
-import { issueBody } from "./github.js";
-import { loadLocale } from "./locale.js";
+import { findRepository, herdrPreflight, runDoctor } from "./doctor.js";
+import { detectedChecks, issueBody } from "./github.js";
+import { createRoleRulesFiles, parseRoleSpec, proposal, serializeConfig, writeConfig, writeUserConfig } from "./init.js";
+import { loadLocale, shippedLanguages } from "./locale.js";
 import { allowRound, answer, installSkill, pause, resume, setAgent, steer } from "./steering.js";
 import { supervise } from "./supervisor.js";
 import { work } from "./worker.js";
@@ -21,7 +22,8 @@ Usage:
   gdt <command> [options]
 
 Commands:
-  doctor        Check tools, GitHub authentication and .gdt/config.toml
+  init          Write roles to the user config and .gdt/config.toml; install the skill
+  doctor        Check tools, GitHub authentication and the configuration
   check-issue   Validate an issue body against the issue contract
   start         Start the workflow for an issue in the background
   status        Show the workflow status and the next step
@@ -43,9 +45,33 @@ Options:
 `;
 const DOCTOR_HELP = `Usage: gdt doctor [--json]
 
-Checks that git and gh are installed, gh is authenticated, and that
-.gdt/config.toml (merged with .gdt/config.local.toml) is valid.
-Exits with 1 when any finding has level "error".
+Checks that git and gh are installed, gh is authenticated, and that the user
+config (roles), .gdt/config.toml (project settings) and .gdt/config.local.toml
+are valid. Exits with 1 when any finding has level "error".
+`;
+const INIT_HELP = `Usage: gdt init [--json]
+       gdt init --developer <agent>/<model> --tester <agent>/<model> --reviewer <agent>/<model>
+                [--language <lang>] [--terminal <herdr|headless>]
+                [--required-check <name>]... [--allow-no-required-checks] [--force]
+
+Without the three role options, reports the supported agents, whether each is on
+PATH, the usable terminal, the detected CI checks and the language. When the
+user config (see below) defines all three roles it writes .gdt/config.toml; with
+the three role options it writes the roles to the user config and the project
+settings to .gdt/config.toml, then runs "gdt doctor" and installs the operator
+skill. The user config is $XDG_CONFIG_HOME/gdt/config.toml, or
+$HOME/.config/gdt/config.toml when XDG_CONFIG_HOME is not set.
+
+Options:
+  --developer <agent>/<model>    Agent and model for the developer role
+  --tester <agent>/<model>       Agent and model for the tester role
+  --reviewer <agent>/<model>     Agent and model for the reviewer role
+  --language <lang>              Language for human-facing text (default en)
+  --terminal <herdr|headless>    Terminal backend (default: herdr when usable)
+  --required-check <name>        CI check that must pass; repeatable
+  --allow-no-required-checks     Accept an empty required_checks list
+  --force                        Replace an existing .gdt/config.toml
+  --json                         Machine-readable proposal output
 `;
 const CHECK_ISSUE_HELP = `Usage: gdt check-issue <issue> [--json]
        gdt check-issue --body-file <file> [--json]
@@ -150,6 +176,157 @@ function doctor(args, io) {
     io.stdout(json ? `${JSON.stringify(report, null, 2)}\n` : formatFindings(report.findings));
     return report.ok ? EXIT_OK : EXIT_FAILED;
 }
+function formatProposal(facts) {
+    const lines = ["agents:"];
+    for (const choice of facts.agents) {
+        lines.push(`  ${choice.agent}  ${choice.found ? "found" : "not found"}  model: ${choice.model_format}, example: ${choice.example}`);
+    }
+    lines.push(`terminal: ${facts.terminal}`, `required_checks: ${facts.required_checks.length === 0 ? "none" : facts.required_checks.join(", ")}`, `language: ${facts.language}`, "", "Next: gdt init --developer <agent>/<model> --tester <agent>/<model> --reviewer <agent>/<model>");
+    return `${lines.join("\n")}\n`;
+}
+/**
+ * `gdt init`: without role options, reports the proposal (AC-1); with all three, writes
+ * `.gdt/config.toml` (AC-2 to AC-5), then runs doctor and installs the skill (AC-6, AC-7).
+ */
+function initCommand(args, io) {
+    let developer;
+    let tester;
+    let reviewer;
+    let language;
+    let terminal;
+    const requiredChecks = [];
+    let allowNoRequiredChecks = false;
+    let force = false;
+    let json = false;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i] ?? "";
+        if (arg === "--json")
+            json = true;
+        else if (arg === "--force")
+            force = true;
+        else if (arg === "--allow-no-required-checks")
+            allowNoRequiredChecks = true;
+        else if (arg === "--help" || arg === "-h") {
+            io.stdout(INIT_HELP);
+            return EXIT_OK;
+        }
+        else if (arg === "--developer" || arg === "--tester" || arg === "--reviewer" || arg === "--language" || arg === "--terminal" || arg === "--required-check") {
+            const given = args[++i];
+            if (given === undefined)
+                return usageError(io, `Missing value for "${arg}".`, "gdt init --help");
+            if (arg === "--developer")
+                developer = given;
+            else if (arg === "--tester")
+                tester = given;
+            else if (arg === "--reviewer")
+                reviewer = given;
+            else if (arg === "--language")
+                language = given;
+            else if (arg === "--terminal") {
+                if (given !== "herdr" && given !== "headless") {
+                    return usageError(io, `Invalid terminal "${given}"; use herdr or headless.`, "gdt init --help");
+                }
+                terminal = given;
+            }
+            else
+                requiredChecks.push(given);
+        }
+        else if (arg.startsWith("-"))
+            return usageError(io, `Unknown option "${arg}" for "gdt init".`, "gdt init --help");
+        else
+            return usageError(io, `Unexpected argument "${arg}" for "gdt init".`, "gdt init --help");
+    }
+    const root = findRepository(io.cwd);
+    if (root === null) {
+        io.stderr(`${io.cwd} is not inside a Git repository. Run gdt from a checkout of the target repository.\n`);
+        return EXIT_FAILED;
+    }
+    const user = readUserConfig(io.env);
+    if (user.findings.length > 0) {
+        io.stderr(`${user.findings.map((finding) => finding.message).join("\n")}\n`);
+        return EXIT_FAILED;
+    }
+    const specs = { developer, tester, reviewer };
+    const given = ROLES.filter((role) => specs[role] !== undefined);
+    // AC-6: without a user config that defines all three roles, `gdt init` only reports the proposal.
+    if (given.length === 0 && !ROLES.every((role) => user.roles[role] !== undefined)) {
+        const facts = proposal(root, io.env);
+        io.stdout(json ? `${JSON.stringify(facts, null, 2)}\n` : formatProposal(facts));
+        return EXIT_OK;
+    }
+    let roles;
+    if (given.length > 0) {
+        if (given.length < ROLES.length) {
+            const missing = ROLES.filter((role) => specs[role] === undefined)
+                .map((role) => `"--${role}"`)
+                .join(", ");
+            return usageError(io, `Missing ${missing} for "gdt init".`, "gdt init --help");
+        }
+        roles = {};
+        for (const role of ROLES) {
+            const parsed = parseRoleSpec(specs[role] ?? "");
+            if ("error" in parsed) {
+                io.stderr(`${parsed.error}\n`);
+                return EXIT_FAILED;
+            }
+            roles[role] = parsed;
+        }
+        // AC-5: refuse before writing anything when the user config already defines a role.
+        if (!force && user.defined.length > 0) {
+            io.stderr(`The user config ${user.path} already defines roles (${user.defined.join(", ")}); use --force to replace them\n`);
+            return EXIT_FAILED;
+        }
+    }
+    const languages = shippedLanguages();
+    if (language !== undefined && !languages.includes(language)) {
+        io.stderr(`No locale for language "${language}"; available languages: ${languages.join(", ")}\n`);
+        return EXIT_FAILED;
+    }
+    if (existsSync(join(root, CONFIG_PATH)) && !force) {
+        io.stderr(`${CONFIG_PATH} already exists; use --force to replace it\n`);
+        return EXIT_FAILED;
+    }
+    const resolvedTerminal = terminal ?? (herdrPreflight(io.env) === null ? "herdr" : "headless");
+    const checks = requiredChecks.length > 0 ? requiredChecks : detectedChecks(root, io.env);
+    if (checks.length === 0 && !allowNoRequiredChecks) {
+        io.stderr("No required checks detected; pass --required-check <name> for each check, or --allow-no-required-checks to accept none\n");
+        return EXIT_FAILED;
+    }
+    // AC-5: write the roles to the user config; AC-6 leaves an existing user config untouched.
+    if (roles !== undefined) {
+        const userError = writeUserConfig(io.env, roles);
+        if (userError !== null) {
+            io.stderr(`${userError}\n`);
+            return EXIT_FAILED;
+        }
+        io.stdout(`roles: written to ${user.path}\n`);
+    }
+    else {
+        io.stdout(`roles: from ${user.path}\n`);
+    }
+    const text = serializeConfig({
+        language: language ?? DEFAULT_LANGUAGE,
+        terminal: resolvedTerminal,
+        requiredChecks: checks,
+        allowNoRequiredChecks,
+    });
+    const writeError = writeConfig(root, text);
+    if (writeError !== null) {
+        io.stderr(`${writeError}\n`);
+        return EXIT_FAILED;
+    }
+    // AC-4: the three supplementary role rules files; existing files are left unchanged.
+    for (const path of createRoleRulesFiles(root))
+        io.stdout(`created ${path}\n`);
+    // AC-7: report the new config with doctor, then install the skill; the config stays in place either way.
+    const report = runDoctor(root, io.env);
+    io.stdout(formatFindings(report.findings));
+    const installed = installSkill(io.env);
+    io.stdout(installed.stdout);
+    if (installed.stderr !== "")
+        io.stderr(installed.stderr);
+    return report.ok ? EXIT_OK : EXIT_FAILED;
+}
 function checkIssue(args, io) {
     let json = false;
     let issue;
@@ -412,6 +589,8 @@ export function run(argv, io) {
             return EXIT_OK;
         case "doctor":
             return doctor(rest, io);
+        case "init":
+            return initCommand(rest, io);
         case "check-issue":
             return checkIssue(rest, io);
         case "start":

package/dist/config.js

@@ -1,16 +1,37 @@
 import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
 import { parse as parseToml, TomlError } from "smol-toml";
 import { z } from "zod";
+import { hasErrors } from "./finding.js";
 export const AGENTS = ["claude", "codex", "opencode", "mcode", "pi", "omp"];
 export const ROLES = ["developer", "tester", "reviewer"];
 export const TERMINALS = ["herdr", "headless"];
+/** AC-2: how the herdr backend places the managed panes. */
+export const HERDR_LAYOUTS = ["split", "tabs"];
 export const CONFIG_PATH = ".gdt/config.toml";
 export const LOCAL_CONFIG_PATH = ".gdt/config.local.toml";
+/** The `gdt` directory under the XDG config home that holds the per-user config. */
+export const USER_CONFIG_DIR = "gdt";
 export const DEFAULT_LANGUAGE = "en";
 export const DEFAULT_MAX_ACCEPTANCE_CRITERIA = 8;
 /** The test agent: runs `script` instead of a coding agent. Only accepted when GDT_TEST_AGENTS=1. */
 export const TEST_AGENT = "fake";
+/** The OS home directory, or `env.HOME` when it names one (AC-1 of issue #51). */
+function homeDir(env) {
+    const home = env.HOME;
+    return home === undefined || home === "" ? homedir() : home;
+}
+/**
+ * The per-user config path. `$XDG_CONFIG_HOME/gdt/config.toml` when `XDG_CONFIG_HOME` is an
+ * absolute path, otherwise `$HOME/.config/gdt/config.toml`. A relative `XDG_CONFIG_HOME` is
+ * ignored, as the XDG base directory specification requires.
+ */
+export function userConfigPath(env) {
+    const xdg = env.XDG_CONFIG_HOME;
+    const base = xdg !== undefined && isAbsolute(xdg) ? xdg : join(homeDir(env), ".config");
+    return join(base, USER_CONFIG_DIR, "config.toml");
+}
 const roleSchema = z.strictObject({
     agent: z.enum(AGENTS),
     model: z.string().min(1),
@@ -33,7 +54,10 @@ function configSchemaFor(testAgents) {
     const role = testAgents ? testRoleSchema : roleSchema;
     return z.strictObject({
         language: z.string().min(1).default(DEFAULT_LANGUAGE),
-        roles: z.strictObject({ developer: role, tester: role, reviewer: role }),
+        // Roles live in the user config now; a role that is absent is reported separately (AC-4).
+        roles: z
+            .strictObject({ developer: role.optional(), tester: role.optional(), reviewer: role.optional() })
+            .optional(),
         workflow: z.strictObject({
             max_correction_rounds: z.int().min(0).default(2),
             // Deliberately without a default: an empty gate must be an explicit choice.
@@ -41,6 +65,8 @@ function configSchemaFor(testAgents) {
             allow_no_required_checks: z.boolean().default(false),
             terminal: z.enum(TERMINALS).default("herdr"),
             supervisor_pane: z.boolean().default(false),
+            // Default `tabs`: one tab per managed pane. `split` keeps the panes in one tab.
+            herdr_layout: z.enum(HERDR_LAYOUTS).default("tabs"),
             poll_seconds: z.number().positive().default(30),
             handoff_checks: z.int().min(1).default(5),
         }),
@@ -79,7 +105,7 @@ function valueAt(data, path) {
 function formatPath(path) {
     return path.map(String).join(".");
 }
-/** The layer that supplied the value at `path`, preferring the local override. */
+/** The layer that supplied the value at `path`, preferring the later layer. */
 function sourceOf(layers, path) {
     for (let i = layers.length - 1; i >= 0; i--) {
         const layer = layers[i];
@@ -88,6 +114,18 @@ function sourceOf(layers, path) {
     }
     return layers[0]?.path ?? CONFIG_PATH;
 }
+/** The config file that last set a key of `role`; a role is only layered in the user and local config. */
+function roleSource(layers, role, fallback) {
+    for (let i = layers.length - 1; i >= 0; i--) {
+        const layer = layers[i];
+        if (layer === undefined)
+            continue;
+        const table = valueAt(layer.data, ["roles", role]);
+        if (isTable(table) && Object.keys(table).length > 0)
+            return layer.path;
+    }
+    return fallback;
+}
 function describe(value) {
     return value === undefined ? "missing" : JSON.stringify(value);
 }
@@ -115,10 +153,11 @@ function issueFindings(issue, merged, layers) {
             return [error(`${key}: ${issue.message}`, `Correct ${key} in ${file}`)];
     }
 }
-function readLayer(root, path) {
-    const text = readFileSync(join(root, path), "utf8");
+/** Reads and parses one TOML file; `display` is the path used in findings. */
+function readLayer(fullPath, display, kind) {
+    const text = readFileSync(fullPath, "utf8");
     try {
-        return { path, data: parseToml(text) };
+        return { path: display, kind, data: parseToml(text) };
     }
     catch (err) {
         const where = err instanceof TomlError ? ` at line ${err.line}, column ${err.column}` : "";
@@ -126,15 +165,72 @@ function readLayer(root, path) {
         return {
             check: "config",
             level: "error",
-            message: `${path}: invalid TOML${where}: ${reason}`,
-            fix: `Fix the TOML syntax in ${path}`,
+            message: `${display}: invalid TOML${where}: ${reason}`,
+            fix: `Fix the TOML syntax in ${display}`,
         };
     }
 }
-/** Loads, merges and validates `.gdt/config.toml` and `.gdt/config.local.toml` in `root`. */
+/**
+ * Reads the user config for `gdt init`. It parses the file and reports which role tables it
+ * contains; it does not validate the repository config, because `gdt init` may run before that
+ * file exists (AC-6).
+ */
+export function readUserConfig(env) {
+    const path = userConfigPath(env);
+    if (!existsSync(path))
+        return { path, exists: false, roles: {}, defined: [], findings: [] };
+    const layer = readLayer(path, path, "user");
+    if (!("data" in layer))
+        return { path, exists: true, roles: {}, defined: [], findings: [layer] };
+    const roles = {};
+    const defined = [];
+    const raw = layer.data.roles;
+    if (isTable(raw)) {
+        for (const role of ROLES) {
+            const table = raw[role];
+            if (!isTable(table))
+                continue;
+            defined.push(role);
+            if (typeof table.agent === "string" && typeof table.model === "string") {
+                roles[role] = {
+                    agent: table.agent,
+                    model: table.model,
+                    ...(typeof table.script === "string" ? { script: table.script } : {}),
+                };
+            }
+        }
+    }
+    return { path, exists: true, roles, defined, findings: [] };
+}
+function roleMissingFinding(role, userPath) {
+    const init = "gdt init --developer <agent>/<model> --tester <agent>/<model> --reviewer <agent>/<model>";
+    return {
+        check: "config",
+        level: "error",
+        message: `roles.${role}: missing`,
+        fix: `Add roles.${role} to ${userPath} with "${init}"`,
+    };
+}
+/**
+ * Loads the user config, the repository config and the local config, merges them in that order
+ * (later layers win per key) and validates the result. Roles are read from the user config unless
+ * the local config overrides them; a `[roles.*]` table in the repository config is an error (AC-2).
+ */
 export function loadConfig(root, env = {}) {
-    const files = [CONFIG_PATH, LOCAL_CONFIG_PATH].filter((path) => existsSync(join(root, path)));
-    if (!files.includes(CONFIG_PATH)) {
+    const userPath = userConfigPath(env);
+    const repoPath = join(root, CONFIG_PATH);
+    const localPath = join(root, LOCAL_CONFIG_PATH);
+    const userExists = existsSync(userPath);
+    const repoExists = existsSync(repoPath);
+    const localExists = existsSync(localPath);
+    const files = [];
+    if (userExists)
+        files.push(userPath);
+    if (repoExists)
+        files.push(CONFIG_PATH);
+    if (localExists)
+        files.push(LOCAL_CONFIG_PATH);
+    if (!repoExists) {
         return {
             report: { valid: false, files },
             findings: [
@@ -142,15 +238,20 @@ export function loadConfig(root, env = {}) {
                     check: "config",
                     level: "error",
                     message: `${CONFIG_PATH}: not found`,
-                    fix: `Create ${CONFIG_PATH}; example: https://github.com/gevezex/gdt/blob/main/docs/design.md#4-configuration-per-target-repository`,
+                    fix: `Create ${CONFIG_PATH}; example: https://github.com/gevezex/gdt/blob/main/examples/config.toml`,
                 },
             ],
         };
     }
     const layers = [];
     const findings = [];
-    for (const path of files) {
-        const layer = readLayer(root, path);
+    const inputs = [[repoPath, CONFIG_PATH, "repo"]];
+    if (userExists)
+        inputs.unshift([userPath, userPath, "user"]);
+    if (localExists)
+        inputs.push([localPath, LOCAL_CONFIG_PATH, "local"]);
+    for (const [full, display, kind] of inputs) {
+        const layer = readLayer(full, display, kind);
         if ("data" in layer)
             layers.push(layer);
         else
@@ -158,28 +259,89 @@ export function loadConfig(root, env = {}) {
     }
     if (findings.length > 0)
         return { report: { valid: false, files }, findings };
-    const merged = layers.reduce((acc, layer) => merge(acc, layer.data), {});
+    const userLayer = layers.find((layer) => layer.kind === "user");
+    const repoLayer = layers.find((layer) => layer.kind === "repo");
+    // AC-3: the user config holds only roles.
+    if (userLayer !== undefined) {
+        for (const key of Object.keys(userLayer.data)) {
+            if (key === "roles")
+                continue;
+            findings.push({
+                check: "config",
+                level: "error",
+                message: `${key}: not allowed in ${userPath}`,
+                fix: `Move ${key} to ${CONFIG_PATH}`,
+            });
+        }
+    }
+    // AC-2: the repository config must not commit roles.
+    const repoRoles = repoLayer?.data.roles;
+    if (isTable(repoRoles)) {
+        for (const role of Object.keys(repoRoles)) {
+            findings.push({
+                check: "config",
+                level: "error",
+                message: `roles.${role}: not allowed in ${CONFIG_PATH}`,
+                fix: `Move roles.${role} to ${userPath} or ${LOCAL_CONFIG_PATH}`,
+            });
+        }
+    }
+    else if (repoRoles !== undefined) {
+        findings.push({
+            check: "config",
+            level: "error",
+            message: `roles: not allowed in ${CONFIG_PATH}`,
+            fix: `Move roles to ${userPath} or ${LOCAL_CONFIG_PATH}`,
+        });
+    }
+    // Roles come from the user config and the local config only; the repository config is excluded.
+    const roleData = layers
+        .filter((layer) => layer.kind !== "repo")
+        .reduce((acc, layer) => (isTable(layer.data.roles) ? merge(acc, layer.data.roles) : acc), {});
+    const merged = layers.reduce((acc, layer) => {
+        const copy = { ...layer.data };
+        delete copy.roles;
+        return merge(acc, copy);
+    }, {});
+    if (Object.keys(roleData).length > 0)
+        merged.roles = roleData;
     const parsed = configSchemaFor(testAgentsEnabled(env)).safeParse(merged);
     if (!parsed.success) {
-        return {
-            report: { valid: false, files },
-            findings: parsed.error.issues.flatMap((issue) => issueFindings(issue, merged, layers)),
-        };
+        findings.push(...parsed.error.issues.flatMap((issue) => issueFindings(issue, merged, layers)));
+    }
+    // AC-4: every role the user and local configs do not define is an error pointing at the user config.
+    for (const role of ROLES) {
+        if (!isTable(valueAt(merged, ["roles", role])))
+            findings.push(roleMissingFinding(role, userPath));
     }
+    if (hasErrors(findings) || !parsed.success)
+        return { report: { valid: false, files }, findings };
     const config = parsed.data;
-    const roles = Object.fromEntries(ROLES.map((role) => {
-        const localRole = layers.length > 1 ? valueAt(layers[layers.length - 1]?.data, ["roles", role]) : undefined;
-        const source = isTable(localRole) && Object.keys(localRole).length > 0 ? LOCAL_CONFIG_PATH : CONFIG_PATH;
-        return [role, { ...config.roles[role], source }];
-    }));
+    const resolved = {
+        developer: { ...config.roles?.developer, source: roleSource(layers, "developer", userPath) },
+        tester: { ...config.roles?.tester, source: roleSource(layers, "tester", userPath) },
+        reviewer: { ...config.roles?.reviewer, source: roleSource(layers, "reviewer", userPath) },
+    };
     findings.push({
         check: "config",
         level: "ok",
-        message: files.length > 1 ? `${CONFIG_PATH} is valid, with overrides from ${LOCAL_CONFIG_PATH}` : `${CONFIG_PATH} is valid`,
+        message: localExists && userExists
+            ? `${CONFIG_PATH} is valid, with roles from ${userPath} and overrides from ${LOCAL_CONFIG_PATH}`
+            : localExists
+                ? `${CONFIG_PATH} is valid, with overrides from ${LOCAL_CONFIG_PATH}`
+                : `${CONFIG_PATH} is valid`,
         fix: "",
     });
     findings.push(...semanticFindings(root, config));
-    return { report: { valid: true, files, ...config, roles }, findings };
+    const report = {
+        valid: true,
+        files,
+        language: config.language,
+        workflow: config.workflow,
+        contract: config.contract,
+        roles: resolved,
+    };
+    return { report, findings };
 }
 /** Checks that pass the schema but would make gdt unsafe or surprising. */
 function semanticFindings(root, config) {

package/dist/doctor.js

@@ -2,7 +2,7 @@ import { spawnSync } from "node:child_process";
 import { accessSync, appendFileSync, constants, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { delimiter, dirname, join, resolve } from "node:path";
 import { adapterFor } from "./agents/index.js";
-import { CONFIG_PATH, LOCAL_CONFIG_PATH, loadConfig, ROLES, TEST_AGENT } from "./config.js";
+import { CONFIG_PATH, LOCAL_CONFIG_PATH, loadConfig, ROLES, TEST_AGENT, userConfigPath } from "./config.js";
 import { hasErrors } from "./finding.js";
 const TOOLS = [
     { name: "git", fix: "Install Git: https://git-scm.com/downloads" },
@@ -159,7 +159,7 @@ function excludeFinding(root, git, env) {
  * (docs/agents.md). Generic: any agent absent from the adapter registry is rejected here. The test
  * agent is exempt: it runs a script instead of a CLI.
  */
-export function unsupportedAgentFindings(roles) {
+export function unsupportedAgentFindings(roles, userConfig) {
     return ROLES.flatMap((role) => {
         const { agent } = roles[role];
         if (agent === TEST_AGENT || adapterFor(agent) !== undefined)
@@ -169,14 +169,14 @@ export function unsupportedAgentFindings(roles) {
                 check: `roles.${role}`,
                 level: "error",
                 message: `roles.${role}.agent: ${agent} has no unattended mode; see docs/agents.md`,
-                fix: `Set roles.${role}.agent in ${CONFIG_PATH} to an agent with an unattended mode`,
+                fix: `Set roles.${role}.agent in ${userConfig} to an agent with an unattended mode`,
             },
         ];
     });
 }
 /** Checks the agent binary of every configured role, and that the tester is independent of the developer. */
 function agentFindings(config, env) {
-    const findings = unsupportedAgentFindings(config.roles);
+    const findings = unsupportedAgentFindings(config.roles, userConfigPath(env));
     for (const role of ROLES) {
         const { agent } = config.roles[role];
         const adapter = adapterFor(agent);

package/dist/github.js

@@ -65,6 +65,30 @@ export function repository(cwd, env) {
 export function viewer(cwd, env) {
     return ghJson(["api", "user"], cwd, env).login;
 }
+/**
+ * The distinct names of the check runs and commit statuses on the latest commit of the repository's
+ * default branch, sorted alphabetically. Returns `[]` when `gh` cannot read them (no remote, no
+ * authentication, no GitHub): `gdt init` then treats the repository as having no detected checks.
+ */
+export function detectedChecks(cwd, env) {
+    try {
+        const repo = ghJson(["repo", "view", "--json", "nameWithOwner,defaultBranchRef"], cwd, env);
+        const name = typeof repo.nameWithOwner === "string" ? repo.nameWithOwner : null;
+        const branch = typeof repo.defaultBranchRef?.name === "string" ? repo.defaultBranchRef.name : null;
+        if (name === null || branch === null)
+            return [];
+        const runs = ghJson(["api", `repos/${name}/commits/${branch}/check-runs`], cwd, env);
+        const statuses = ghJson(["api", `repos/${name}/commits/${branch}/status`], cwd, env);
+        const names = [
+            ...(runs.check_runs ?? []).map((run) => run.name),
+            ...(statuses.statuses ?? []).map((status) => status.context),
+        ].filter((value) => typeof value === "string" && value !== "");
+        return [...new Set(names)].sort();
+    }
+    catch {
+        return [];
+    }
+}
 /** The issue body and the open pull requests that close the issue ("Closes #n"). */
 export function issueSnapshot(issue, cwd, env) {
     const data = ghJson(["issue", "view", String(issue), "--json", "body,closedByPullRequestsReferences"], cwd, env);