@inditextech/docouture-cli 0.1.0-SNAPSHOT.40.1

package/build/bin.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+'use strict';
+import { runNew } from './commands/new.js';
+import { runVersion } from './commands/version.js';
+import { runDev } from './commands/dev.js';
+import { runBuild } from './commands/build.js';
+import { runDoctor } from './commands/doctor.js';
+import { runPublish } from './commands/publish.js';
+import { runUpgrade } from './commands/upgrade.js';
+import { runEject } from './commands/eject.js';
+import { runTeardown } from './commands/teardown.js';
+import { runCompletion } from './commands/completion.js';
+import { readCliInfo } from './lib/cli-info.js';
+import { setContext } from './lib/cli-context.js';
+import { theme } from './lib/theme.js';
+import { extractGlobalFlags } from './lib/global-flags.js';
+const COMMAND_ORDER = [
+    'new',
+    'version',
+    'dev',
+    'build',
+    'publish',
+    'doctor',
+    'upgrade',
+    'eject',
+    'teardown',
+    'completion',
+];
+const COMMAND_INFO = {
+    new: {
+        usageLine: 'new <name>',
+        summary: 'Scaffold a new documentation site',
+        help: `Usage:
+  docouture new <name> [--dir <path>] [--title <title>] [--mode standalone|versioned] [--pm npm|pnpm] [--yes]
+
+Scaffold an Antora documentation site into docs/ (and its workflows into
+.github/workflows/), plus AGENTS.md and agent skills (.opencode/skills/,
+.claude/skills/) into the root of an existing git repository. --dir/cwd
+can be anywhere inside that repository — the actual top-level is found
+automatically. If any workflows, skills or a docouture-managed AGENTS.md
+section already exist, prompts to overwrite them (refuses outright when
+not running interactively). Prompts interactively for anything not given
+as a flag when run in a terminal (pass --yes to always use defaults, and
+to never prompt to overwrite, instead).
+
+Options:
+  --dir <path>     Repository root to scaffold into (default: cwd, or its enclosing repo)
+  --title <title>  Site title (default: title-cased from <name>)
+  --mode <mode>    'standalone' (default) or 'versioned'
+  --pm <pm>        'npm' or 'pnpm' (default: auto-detected from a lockfile/packageManager
+                   field, or how docouture itself was invoked)
+  --yes            Skip the interactive wizard, use defaults for anything unset
+`,
+    },
+    version: {
+        usageLine: 'version <value>',
+        summary: 'Set the version recorded in docs/antora.yml',
+        help: `Usage:
+  docouture version <value> [--dir <path>] [--file <path>] [--prerelease | --stable]
+
+Set the version recorded in docs/antora.yml.
+
+Options:
+  --dir <path>   Repository root (default: cwd, or its enclosing repo)
+  --file <path>  antora.yml path directly, overrides --dir
+  --prerelease   Mark this version as a prerelease
+  --stable       Mark this version as stable (mutually exclusive with --prerelease)
+`,
+    },
+    dev: {
+        usageLine: 'dev',
+        summary: 'Build and serve the site with live reload',
+        help: `Usage:
+  docouture dev [--port <port>] [--dir <path>]
+
+Build the site and serve it with live reload, rebuilding on every
+change to docs/ or antora-playbook.yml. --dir is the repository root
+(the parent of docs/), same as new/version — not the site directory.
+
+Options:
+  --port <port>  Port to listen on (default: 5000)
+  --dir <path>   Repository root (default: cwd, or its enclosing repo)
+`,
+    },
+    build: {
+        usageLine: 'build',
+        summary: 'Build the site once',
+        help: `Usage:
+  docouture build [--dir <path>]
+
+Build the site once: a thin wrapper around the site's own 'npm run
+build' (antora --fetch antora-playbook.yml).
+
+Options:
+  --dir <path>  Repository root (default: cwd, or its enclosing repo)
+`,
+    },
+    publish: {
+        usageLine: 'publish <target>',
+        summary: 'Publish the already-built site',
+        help: `Usage:
+  docouture publish <target> [--dir <path>] [--<option> <value> ...]
+
+Publish the already-built site (output.dir in antora-playbook.yml,
+default build/site — run 'docouture build' first) using the
+'@inditextech/docouture-publish-<target>' driver, e.g. 'gh-pages'. That
+package must be a devDependency of the site itself. Options come
+from docs/package.json's own "docouture".publish.<target> object,
+overridden by any --flags given here.
+
+Options:
+  --dir <path>          Repository root (default: cwd, or its enclosing repo)
+  --<option> <value>    Forwarded to the publish driver as one of its own options
+  --user-name/--user-email  Combined into a nested {user:{name,email}} option
+
+Example:
+  docouture publish gh-pages --branch gh-pages
+`,
+    },
+    doctor: {
+        usageLine: 'doctor',
+        summary: 'Check environment and site health',
+        help: `Usage:
+  docouture doctor [--dir <path>] [--json]
+
+Check that the environment and site configuration are healthy: Node
+version, the four names that must agree (component name, start page,
+content path, package name), git history, that antora is installed,
+and (advisory only) whether AGENTS.md and the scaffolded skills are
+still present.
+
+Options:
+  --dir <path>  Repository root (default: cwd, or its enclosing repo)
+  --json        Print a machine-readable report to stdout instead
+`,
+    },
+    upgrade: {
+        usageLine: 'upgrade',
+        summary: 'Re-sync workflows and agent support files',
+        help: `Usage:
+  docouture upgrade [--dir <path>] [--title <title>] [--dry-run]
+
+Re-sync an already-scaffolded repository's .github/workflows/ and
+agent support files (AGENTS.md, .opencode/skills/, .claude/skills/)
+from the CLI's current templates — --dir/cwd can be anywhere inside
+that repository, the actual top-level is found automatically.
+Workflows and skills are fully overwritten; AGENTS.md is merged
+instead — only docouture' own managed section is replaced, anything a
+human added around it survives. Does not touch docs/. --dry-run lists
+what would be written without changing anything.
+
+Options:
+  --dir <path>   Repository root (default: cwd, or its enclosing repo)
+  --title <title>  Override the title read back from docs/antora.yml
+  --dry-run      List what would be written without changing anything
+`,
+    },
+    eject: {
+        usageLine: 'eject <target>',
+        summary: 'Copy a bundled default file out for customization',
+        help: `Usage:
+  docouture eject <target> [--dir <path>]
+
+Copy a bundled default file out into docs/ for local customization.
+'kroki': docs/kroki-compose.yml, the docker compose definition
+@inditextech/docouture-antora-extensions' kroki-prewarm.js starts
+automatically when a build needs Kroki (kroki-enabled: true) and finds
+nothing already running — auto-detected and preferred over the
+bundled default once it exists. Refuses to overwrite an existing file.
+
+Options:
+  --dir <path>  Repository root (default: cwd, or its enclosing repo)
+`,
+    },
+    teardown: {
+        usageLine: 'teardown <target>',
+        summary: 'Stop a service docouture started for you',
+        help: `Usage:
+  docouture teardown <target> [--dir <path>]
+
+Stop a service docouture started for you. 'kroki': runs 'docker compose
+down' against whichever kroki-compose.yml is actually in effect (an
+ejected docs/kroki-compose.yml if you have one, else the bundled
+default) — the manual counterpart to kroki-prewarm.js's own auto-start,
+which never stops it itself.
+
+Options:
+  --dir <path>  Repository root (default: cwd, or its enclosing repo)
+`,
+    },
+    completion: {
+        usageLine: 'completion <shell>',
+        summary: 'Print a shell completion script (bash|zsh)',
+        help: `Usage:
+  docouture completion <bash|zsh>
+
+Print a shell completion script for docouture to stdout.
+
+Examples:
+  eval "$(docouture completion bash)"
+  docouture completion zsh > "\${fpath[1]}/_docouture"
+`,
+    },
+};
+// Top-level equivalent of each COMMAND_INFO entry's `summary` — printed as
+// the title of the bare/--help screen, same 'docouture — <summary>' shape as
+// 'docouture <command> --help' uses for a single command.
+const CLI_SUMMARY = 'Scaffold, build, and publish Antora documentation sites';
+// Left column width of the command table below, including the 2-space
+// indent — wide enough for the longest usageLine ('completion <shell>').
+const COMMAND_COLUMN_WIDTH = 22;
+const USAGE = `Usage: docouture <command> [options]
+
+Commands:
+${COMMAND_ORDER.map((cmd) => {
+    const info = COMMAND_INFO[cmd];
+    return `  ${info.usageLine}`.padEnd(COMMAND_COLUMN_WIDTH) + info.summary;
+}).join('\n')}
+
+Global options:
+  -h, --help     Show help (pass after a command for command-specific help)
+  -v, --version  Print the installed @inditextech/docouture-cli version and exit
+  --json         Machine-readable output where supported (currently: doctor)
+  --verbose      Print extra diagnostic detail to stderr (same as DEBUG=docouture)
+  --no-color     Disable coloured output regardless of TTY detection
+
+Run 'docouture <command> --help' for command-specific usage and options.
+`;
+const RUNNERS = {
+    new: runNew,
+    version: runVersion,
+    dev: runDev,
+    build: runBuild,
+    publish: runPublish,
+    doctor: runDoctor,
+    upgrade: runUpgrade,
+    eject: runEject,
+    teardown: runTeardown,
+    completion: async (argv) => runCompletion(argv),
+};
+// completion's whole output must be shell-consumable on stdout (piped to a
+// file, or `eval`'d directly on every shell startup if a user wires it into
+// their rc file) — the banner is harmless there too, since it only ever
+// goes to stderr, but printing it on every single new shell would still be
+// needless noise for something meant to be sourced silently.
+const QUIET_COMMANDS = new Set(['completion']);
+// build/bin.js -> package root, 1 level up — see readCliInfo's own comment.
+async function banner() {
+    const { name, version } = await readCliInfo(import.meta.url, 1);
+    return `${theme.bold(theme.info(name))} ${theme.dim(`v${version}`)}`;
+}
+// Recognises the three global flags anywhere in argv (before or after the
+// command name — `docouture --verbose dev` and `docouture dev --verbose` both
+// work), strips them out, and returns what's left for command dispatch —
+// see lib/global-flags.ts.
+async function main() {
+    const { json, verbose, noColor, rest: argv } = extractGlobalFlags(process.argv.slice(2));
+    setContext({ json, verbose, noColor });
+    const [command, ...rest] = argv;
+    if (command === '--version' || command === '-v') {
+        console.log(await banner());
+        return 0;
+    }
+    // Bare invocation prints help and succeeds — mirrors git/npm's own
+    // convention of treating "show me what you can do" as a legitimate,
+    // successful outcome rather than an error, unlike a genuinely unknown
+    // command below.
+    if (command === undefined || command === '--help' || command === '-h' || command === 'help') {
+        console.log(await banner());
+        console.log('');
+        console.log(theme.bold(`docouture — ${CLI_SUMMARY}`));
+        console.log('');
+        console.log(USAGE);
+        return 0;
+    }
+    if (command in COMMAND_INFO && (rest[0] === '--help' || rest[0] === '-h')) {
+        const info = COMMAND_INFO[command];
+        console.log(await banner());
+        console.log('');
+        console.log(theme.bold(`docouture ${command} — ${info.summary}`));
+        console.log('');
+        console.log(info.help);
+        return 0;
+    }
+    if (!(command in RUNNERS)) {
+        console.error(`unknown command: '${command}'\n`);
+        console.error(await banner());
+        console.error('');
+        console.error(theme.bold(`docouture — ${CLI_SUMMARY}`));
+        console.error('');
+        console.error(USAGE);
+        return 1;
+    }
+    // Printed once per invocation, to stderr — so it never lands in piped or
+    // parsed stdout — right before the command actually runs, rather than
+    // only on --version/--help/error paths as before. Suppressed under
+    // --json (stdout is promised clean there; a stray stderr banner is still
+    // needless noise for a script capturing combined output) and for
+    // completion (see QUIET_COMMANDS' own comment). The title line repeats
+    // the same '<command> — <summary>' shown on --help, so a plain run gives
+    // just as much "what is this" context as asking for help would — followed
+    // by a blank line so the command's own output never runs straight on
+    // from the banner/title.
+    if (!json && !QUIET_COMMANDS.has(command)) {
+        const info = COMMAND_INFO[command];
+        console.error(await banner());
+        console.error('');
+        console.error(theme.bold(`docouture ${command} — ${info.summary}`));
+        console.error('');
+    }
+    return RUNNERS[command](rest);
+}
+main()
+    .then((code) => {
+    process.exitCode = code;
+})
+    .catch((err) => {
+    console.error(err instanceof Error ? err.stack : String(err));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=bin.js.map

package/build/commands/build.js

@@ -0,0 +1,22 @@
+'use strict';
+import { join, resolve } from 'node:path';
+import { parseArgs } from '../lib/args.js';
+import { ANTORA_LOG_LEVEL_ARGS } from '../lib/antora-log.js';
+import { exists } from '../lib/copy-template.js';
+import { findRepoRoot } from '../lib/repo-root.js';
+import { runNpmScript } from '../lib/run-script.js';
+export async function runBuild(argv) {
+    const { flags } = parseArgs(argv);
+    // --dir (or cwd) can be anywhere inside the repository — findRepoRoot
+    // walks up to the actual repository root, same as `new`/`version`/`doctor`.
+    const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+    const target = await findRepoRoot(startDir);
+    const siteRoot = join(target, 'docs');
+    if (!(await exists(join(siteRoot, 'package.json')))) {
+        console.error(`no package.json found at '${siteRoot}'`);
+        console.error('pass --dir <path> to a component root (the parent of docs/), or run docouture new first');
+        return 1;
+    }
+    return runNpmScript('build', { cwd: siteRoot, args: [...ANTORA_LOG_LEVEL_ARGS] });
+}
+//# sourceMappingURL=build.js.map

package/build/commands/completion.js

@@ -0,0 +1,69 @@
+'use strict';
+// `docouture completion <bash|zsh>` — prints a completion script to stdout (so
+// `docouture completion bash > file` and `eval "$(docouture completion bash)"` both
+// work); everything else this command has to say (usage errors) goes to
+// stderr, same discipline as every other command. The candidate list is
+// kept here as a literal array rather than derived from bin.ts's dispatch
+// table, since introducing a shared "registry" module for nine commands
+// that essentially never change is more machinery than the problem needs —
+// see COMMANDS' own comment for what keeps it honest.
+// Kept in sync with bin.ts's RUNNERS keys by test (completion.spec.ts) —
+// not by import, since bin.ts is the entrypoint and importing it back here
+// would run its top-level `main()` invocation.
+export const COMMANDS = [
+    'new',
+    'version',
+    'dev',
+    'build',
+    'publish',
+    'doctor',
+    'upgrade',
+    'eject',
+    'teardown',
+    'completion',
+];
+function bashScript() {
+    const words = COMMANDS.join(' ');
+    return `# docouture bash completion
+#
+# Install for the current session:
+#   eval "$(docouture completion bash)"
+#
+# Install permanently, e.g. on macOS with Homebrew's bash-completion@2:
+#   docouture completion bash > "$(brew --prefix)/etc/bash_completion.d/docouture"
+_docouture_completions() {
+  local cur=\${COMP_WORDS[COMP_CWORD]}
+  COMPREPLY=($(compgen -W "${words}" -- "$cur"))
+}
+complete -F _docouture_completions docouture
+`;
+}
+function zshScript() {
+    const words = COMMANDS.map((c) => `'${c}'`).join(' ');
+    return `#compdef docouture
+# docouture zsh completion
+#
+# Install by placing this on your $fpath, e.g.:
+#   docouture completion zsh > "\${fpath[1]}/_docouture"
+_docouture() {
+  local -a commands
+  commands=(${words})
+  _describe 'docouture command' commands
+}
+_docouture
+`;
+}
+export function runCompletion(argv) {
+    const shell = argv[0];
+    if (shell === 'bash') {
+        process.stdout.write(bashScript());
+        return 0;
+    }
+    if (shell === 'zsh') {
+        process.stdout.write(zshScript());
+        return 0;
+    }
+    console.error('usage: docouture completion <bash|zsh>');
+    return 1;
+}
+//# sourceMappingURL=completion.js.map

package/build/commands/dev.js

@@ -0,0 +1,67 @@
+'use strict';
+import { join, resolve } from 'node:path';
+import ora from 'ora';
+import { parseArgs } from '../lib/args.js';
+import { exists } from '../lib/copy-template.js';
+import { findRepoRoot } from '../lib/repo-root.js';
+import { startDevServer } from '../lib/dev-server.js';
+export async function runDev(argv) {
+    const { flags } = parseArgs(argv);
+    // --dir (or cwd) can be anywhere inside the repository — findRepoRoot
+    // walks up to the actual repository root, same as `new`/`version`/`doctor`.
+    const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+    const target = await findRepoRoot(startDir);
+    const siteRoot = join(target, 'docs');
+    if (!(await exists(join(siteRoot, 'antora-playbook.local.yml')))) {
+        console.error(`no antora-playbook.local.yml found at '${siteRoot}'`);
+        console.error('pass --dir <path> to a component root (the parent of docs/), or run docouture new first');
+        return 1;
+    }
+    let port;
+    if (typeof flags.port === 'string') {
+        port = Number(flags.port);
+        if (!Number.isInteger(port) || port <= 0) {
+            console.error(`invalid --port: '${flags.port}'`);
+            return 1;
+        }
+    }
+    // Spinner covers only the initial build+listen wait, where the previous
+    // behaviour was otherwise silent for however long the first Antora build
+    // takes — ora auto-detects a non-TTY stderr (CI, piped output) and
+    // degrades to plain text on its own, so this stays quiet under
+    // automation without a separate flag. Once the server is up, log/logError
+    // below revert to plain per-rebuild lines exactly as before.
+    const spinner = ora({ text: 'Starting dev server…', stream: process.stderr }).start();
+    let ready = false;
+    const log = (msg) => {
+        if (ready)
+            console.error(`dev ${msg}`);
+    };
+    const logError = (msg) => {
+        if (ready)
+            console.error(`dev ${msg}`);
+    };
+    try {
+        const server = await startDevServer({ siteRoot, port, log, logError });
+        ready = true;
+        spinner.succeed(`Serving ${server.url}`);
+        await new Promise((resolvePromise) => {
+            const shutdown = () => {
+                void server.close().then(resolvePromise);
+            };
+            process.once('SIGINT', shutdown);
+            process.once('SIGTERM', shutdown);
+        });
+        return 0;
+    }
+    catch (err) {
+        if (err?.code === 'EADDRINUSE') {
+            spinner.fail(`port ${port ?? 5000} is already in use`);
+            console.error('  stop whatever is listening on it, or pass --port <port>');
+            return 1;
+        }
+        spinner.fail(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+}
+//# sourceMappingURL=dev.js.map

package/build/commands/doctor.js

@@ -0,0 +1,156 @@
+'use strict';
+import { readFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { parseArgs } from '../lib/args.js';
+import { exists } from '../lib/copy-template.js';
+import { findRepoRoot } from '../lib/repo-root.js';
+import { getContext } from '../lib/cli-context.js';
+import { theme } from '../lib/theme.js';
+import { readSourceUrl, readStartPageComponent, readStartPath } from '../lib/playbook-yml.js';
+import { checkAgentFilesPresent, checkAntoraAvailable, checkGitHasCommit, checkNamesAgree, checkNodeVersion, checkReleaseLabelExists, } from '../lib/doctor-checks.js';
+async function readJson(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function readAntoraYmlName(content) {
+    const match = /^name:\s*(.+?)\s*$/m.exec(content);
+    return match?.[1] ?? null;
+}
+// Every check is recorded here as it runs, in section order, regardless of
+// whether the human-readable report or --json is what actually gets
+// printed — this is the one source of truth both output modes read from,
+// so they can never drift from each other on which checks ran or what they
+// found.
+function record(report, section, result, severity) {
+    report.push({ ...result, section, severity: result.ok ? 'ok' : severity });
+    if (severity === 'fail')
+        return result.ok ? 0 : 1;
+    return 0;
+}
+function printResult(result) {
+    const ok = theme.success(' ok ');
+    const fail = theme.error('FAIL');
+    console.log(`  ${result.ok ? ok : fail}  ${result.label} — ${result.message}`);
+    if (!result.ok && result.detail) {
+        console.log(`         ${result.detail}`);
+    }
+}
+// Same rendering as printResult, but never contributes to the overall exit
+// code — used only for advisory checks (agent files, release label): 'warn'
+// instead of 'FAIL' so a missing file reads as advisory, not as the same
+// severity as a broken build.
+function printAdvisory(result) {
+    const ok = theme.success(' ok ');
+    const warn = theme.warn('warn');
+    console.log(`  ${result.ok ? ok : warn}  ${result.label} — ${result.message}`);
+    if (!result.ok && result.detail) {
+        console.log(`         ${result.detail}`);
+    }
+}
+export async function runDoctor(argv) {
+    const { flags } = parseArgs(argv);
+    const json = getContext().json;
+    const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+    // --dir (or cwd) can be anywhere inside the repository — its root, inside
+    // docs/, wherever — findRepoRoot walks up to find the actual repository
+    // root the same way `git` itself would, so doctor always looks at
+    // <repoRoot>/docs regardless of where it was invoked from.
+    const target = await findRepoRoot(startDir);
+    const siteRoot = join(target, 'docs');
+    if (!(await exists(siteRoot))) {
+        console.error(`no site found at '${siteRoot}'`);
+        console.error('pass --dir <path> to a component root (the parent of docs/), or run docouture new first');
+        return 1;
+    }
+    let status = 0;
+    const report = [];
+    const log = (line) => {
+        if (!json)
+            console.log(line);
+    };
+    log('toolchain');
+    const pkg = await readJson(join(siteRoot, 'package.json'));
+    const nodeResult = checkNodeVersion(pkg?.engines?.node, process.version);
+    status |= record(report, 'toolchain', nodeResult, 'fail');
+    if (!json)
+        printResult(nodeResult);
+    log('names');
+    const playbookFile = join(siteRoot, 'antora-playbook.yml');
+    const antoraYmlFile = join(siteRoot, 'src', 'antora.yml');
+    const playbookContent = (await exists(playbookFile)) ? await readFile(playbookFile, 'utf8') : null;
+    const antoraYmlContent = (await exists(antoraYmlFile)) ? await readFile(antoraYmlFile, 'utf8') : null;
+    if (!playbookContent) {
+        const result = { ok: false, label: 'antora-playbook.yml', message: `not found at '${playbookFile}'` };
+        status |= record(report, 'names', result, 'fail');
+        if (!json)
+            printResult(result);
+    }
+    if (!antoraYmlContent) {
+        const result = { ok: false, label: 'src/antora.yml', message: `not found at '${antoraYmlFile}'` };
+        status |= record(report, 'names', result, 'fail');
+        if (!json)
+            printResult(result);
+    }
+    if (playbookContent && antoraYmlContent) {
+        const sourceUrl = readSourceUrl(playbookContent);
+        if (sourceUrl && sourceUrl !== '.') {
+            // The repository-root-relative form of `src/antora.yml`'s real
+            // location — see lib/playbook-yml.ts's own comment on why `url: .`
+            // only works when the playbook itself sits at the repository root.
+            const descriptorPath = relative(target, dirname(antoraYmlFile)).split(sep).join('/');
+            const results = checkNamesAgree({
+                antoraYmlName: readAntoraYmlName(antoraYmlContent),
+                startPageComponent: readStartPageComponent(playbookContent),
+                startPath: readStartPath(playbookContent),
+                descriptorPath,
+                packageName: pkg?.name ?? null,
+            });
+            for (const result of results) {
+                status |= record(report, 'names', result, 'fail');
+                if (!json)
+                    printResult(result);
+            }
+        }
+        else {
+            const result = {
+                ok: false,
+                label: 'content source url',
+                message: `content.sources[0].url is '.' but the playbook does not sit at the repository root`,
+                detail: "url: '.' only works when antora-playbook.yml sits at the repository root — use 'url: ..' (or however many levels reach it) otherwise",
+            };
+            status |= record(report, 'names', result, 'fail');
+            if (!json)
+                printResult(result);
+        }
+    }
+    log('content');
+    const gitResult = await checkGitHasCommit(target);
+    status |= record(report, 'content', gitResult, 'fail');
+    if (!json)
+        printResult(gitResult);
+    log('dependencies');
+    const antoraResult = checkAntoraAvailable(siteRoot);
+    status |= record(report, 'dependencies', antoraResult, 'fail');
+    if (!json)
+        printResult(antoraResult);
+    log('agent files');
+    for (const result of checkAgentFilesPresent(target)) {
+        record(report, 'agent files', result, 'warn');
+        if (!json)
+            printAdvisory(result);
+    }
+    log('release');
+    const releaseResult = await checkReleaseLabelExists(target);
+    record(report, 'release', releaseResult, 'warn');
+    if (!json)
+        printAdvisory(releaseResult);
+    if (json) {
+        process.stdout.write(`${JSON.stringify({ status: status === 0 ? 'ok' : 'fail', checks: report }, null, 2)}\n`);
+    }
+    return status === 0 ? 0 : 1;
+}
+//# sourceMappingURL=doctor.js.map