@inditextech/docouture-cli 0.1.0-SNAPSHOT.40.1

package/build/commands/publish.js

@@ -0,0 +1,111 @@
+'use strict';
+import { createRequire } from 'node:module';
+import { readFile } from 'node:fs/promises';
+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 { readOutputDir } from '../lib/playbook-yml.js';
+import { resolveConfig } from '../lib/config-resolver.js';
+import { debugLog } from '../lib/debug-log.js';
+/**
+ * Resolved from the SITE's own node_modules (via its package.json), not
+ * this CLI's — a driver is a devDependency of the site being published,
+ * not of docouture itself. Exposed as its own function — rather than inlined
+ * in runPublish — so tests can inject a fake in its place: under the test
+ * runner, a bare `require()` of a package name that also happens to be a
+ * real published dependency of this monorepo can resolve to THAT real
+ * package instead of failing, regardless of the `from` path passed to
+ * `createRequire` — the dynamic-require equivalent of `vi.mock` not
+ * intercepting a plain CommonJS `require()` (see
+ * @inditextech/docouture-publish-gh-pages's own index.js for the same
+ * seam-over-mock reasoning applied to its `gh-pages` dependency).
+ */
+function loadDriver(packageJsonFile, driverPackageName) {
+    return createRequire(packageJsonFile)(driverPackageName);
+}
+async function readJson(file) {
+    try {
+        return JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Every flag except `--dir` (which this command consumes itself) is
+ * forwarded to the driver as one of its own options. `--user-name`/
+ * `--user-email`, if given, are combined into the nested `user: {name,
+ * email}` shape @inditextech/docouture-publish-gh-pages (and presumably other
+ * drivers needing a commit identity) expects — the only nested option
+ * shape a flat `--flag value` CLI syntax can't express directly.
+ */
+function flagsToOptions(flags) {
+    const { 'user-name': userName, 'user-email': userEmail, ...rest } = flags;
+    delete rest.dir;
+    const options = { ...rest };
+    if (userName !== undefined || userEmail !== undefined) {
+        options.user = { name: userName, email: userEmail };
+    }
+    return options;
+}
+export async function runPublish(argv, deps = {}) {
+    const resolveDriver = deps.loadDriver ?? loadDriver;
+    const { positional, flags } = parseArgs(argv);
+    const target = positional[0];
+    if (!target) {
+        console.error('usage: docouture publish <target> [--dir <path>] [--<option> <value> ...]');
+        console.error('example: docouture publish gh-pages --branch gh-pages');
+        return 1;
+    }
+    const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+    const repoRoot = await findRepoRoot(startDir);
+    const siteRoot = join(repoRoot, 'docs');
+    const packageJsonFile = join(siteRoot, 'package.json');
+    if (!(await exists(packageJsonFile))) {
+        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;
+    }
+    const driverPackageName = `@inditextech/docouture-publish-${target}`;
+    let driver;
+    try {
+        driver = resolveDriver(packageJsonFile, driverPackageName);
+    }
+    catch {
+        console.error(`could not load publish driver '${driverPackageName}'`);
+        console.error(`add it to ${packageJsonFile}'s devDependencies, e.g.: npm install --save-dev ${driverPackageName}`);
+        return 1;
+    }
+    const playbookFile = join(siteRoot, 'antora-playbook.yml');
+    const playbookContent = (await exists(playbookFile)) ? await readFile(playbookFile, 'utf8') : '';
+    const siteDir = resolve(siteRoot, readOutputDir(playbookContent) || 'build/site');
+    if (!(await exists(siteDir))) {
+        console.error(`no built site found at '${siteDir}' — run 'docouture build' first`);
+        return 1;
+    }
+    const packageJson = await readJson(packageJsonFile);
+    const configuredOptions = packageJson?.docouture?.publish?.[target] ?? {};
+    // CLI flags win over docs/package.json's own "docouture".publish.<target>
+    // config, which wins over whatever defaults the driver applies itself —
+    // see lib/config-resolver.ts for this precedence rule shared with upgrade.
+    const options = resolveConfig({}, configuredOptions, flagsToOptions(flags));
+    debugLog(`publishing '${target}' from ${siteDir} with options: ${JSON.stringify(options)}`);
+    const spinner = ora({ text: `Publishing to ${target}…`, stream: process.stderr }).start();
+    try {
+        const published = await driver(siteDir, options);
+        if (published === false) {
+            spinner.fail(`'${target}' driver reported it did not publish`);
+            return 1;
+        }
+        spinner.succeed(`Published to ${target}`);
+        return 0;
+    }
+    catch (err) {
+        spinner.fail(`publishing to '${target}' failed`);
+        console.error(err instanceof Error ? err.stack : String(err));
+        return 1;
+    }
+}
+//# sourceMappingURL=publish.js.map

package/build/commands/teardown.js

@@ -0,0 +1,66 @@
+'use strict';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { join, resolve } from 'node:path';
+import { parseArgs } from '../lib/args.js';
+import { exists } from '../lib/copy-template.js';
+import { findRepoRoot } from '../lib/repo-root.js';
+import { resolveEffectiveComposeFile } from '../lib/kroki-compose.js';
+// `docouture teardown kroki` — the explicit, manual stop side of GH-44's Kroki
+// auto-start. `kroki-prewarm.js` (in @inditextech/docouture-antora-extensions)
+// starts the service on demand but never stops it — see kroki-docker.js's
+// own header for why: a build has no natural "I'm completely done with this
+// machine for good" moment to hook, and stopping it mid-session would only
+// force the next build to pay the startup latency again. This command is
+// the escape hatch for the moment a human actually does know that: done for
+// the day, freeing the port for something else, before switching to a
+// project with different diagram types configured, etc.
+//
+// Targets whichever compose file is ACTUALLY in effect — an ejected
+// override at the site root if one exists, else the bundled default — via
+// the exact same resolution order kroki-docker.js's own auto-start uses
+// (lib/kroki-compose.js's `resolveEffectiveComposeFile`), so this always
+// stops the containers a build would actually have started, not
+// necessarily the package's un-customized default.
+const execFileAsync = promisify(execFile);
+const SUPPORTED_TARGETS = {
+    kroki: { description: 'Kroki diagram rendering service (docker compose)' },
+};
+export async function runTeardown(argv, deps = {}) {
+    const { positional, flags } = parseArgs(argv);
+    const target = positional[0];
+    if (!target || !(target in SUPPORTED_TARGETS)) {
+        console.error('usage: docouture teardown <target> [--dir <path>]');
+        console.error('supported targets:');
+        for (const [name, { description }] of Object.entries(SUPPORTED_TARGETS)) {
+            console.error(`  ${name} — ${description}`);
+        }
+        return 1;
+    }
+    const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+    const repoRoot = await findRepoRoot(startDir);
+    const siteRoot = join(repoRoot, '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;
+    }
+    const resolveFile = deps.resolveEffectiveComposeFile || resolveEffectiveComposeFile;
+    const composeFile = await resolveFile(siteRoot);
+    if (!composeFile) {
+        console.error(`could not find @inditextech/docouture-antora-extensions' bundled kroki-compose.yml, and no override exists at '${join(siteRoot, 'kroki-compose.yml')}'`);
+        console.error('add @inditextech/docouture-antora-extensions to devDependencies, or run docouture eject kroki first');
+        return 1;
+    }
+    try {
+        const runDockerCompose = deps.execFileAsync || execFileAsync;
+        await runDockerCompose('docker', ['compose', '-f', composeFile, 'down']);
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    console.log(`stopped the Kroki service (${composeFile})`);
+    return 0;
+}
+//# sourceMappingURL=teardown.js.map

package/build/commands/upgrade.js

@@ -0,0 +1,156 @@
+'use strict';
+import { execFileSync } from 'node:child_process';
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseArgs } from '../lib/args.js';
+import { readCliInfo } from '../lib/cli-info.js';
+import { copyTemplate, exists, renderTemplateFile } from '../lib/copy-template.js';
+import { detectPackageManager, packageManagerPlan } from '../lib/detect-package-manager.js';
+import { resolveConfig } from '../lib/config-resolver.js';
+import { findRepoRoot } from '../lib/repo-root.js';
+import { AGENTS_MD_FILENAME, mergeAgentsMd } from '../lib/agents-md.js';
+// Same check `new.ts` uses, duplicated rather than imported — it's three
+// lines, and `doctor-checks.ts` already sets the precedent of duplicating a
+// small piece of `new.ts`'s own logic instead of reaching across into a
+// module built around the interactive wizard (see its own comment on
+// AGENT_SUPPORT_CHECK_PATHS).
+function isInsideGitWorkTree(dir) {
+    try {
+        execFileSync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir, stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function titleCase(name) {
+    return name
+        .split('-')
+        .filter(Boolean)
+        .map((word) => word[0].toUpperCase() + word.slice(1))
+        .join(' ');
+}
+// docs/antora.yml's `name:`/`title:` are read the same way antora-yml.ts
+// reads `version:` — a plain top-of-line regex, not a full YAML parse, so
+// comments and formatting a human added survive untouched (this file is
+// only ever read here, never rewritten). Unlike antora-yml.ts, upgrade.ts
+// never writes this file, so that module's write-side helpers don't apply
+// here and this stays a small, local, read-only counterpart instead of
+// growing antora-yml.ts's own scope to cover a field it doesn't otherwise
+// need.
+function readAntoraField(content, key) {
+    const match = new RegExp(`^${key}:.*$`, 'm').exec(content);
+    if (!match)
+        return null;
+    const value = match[0].slice(key.length + 1).trim();
+    return value.length > 0 ? value : null;
+}
+export async function runUpgrade(argv) {
+    const { flags } = parseArgs(argv);
+    const dryRun = flags['dry-run'] === true;
+    const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+    if (!isInsideGitWorkTree(startDir)) {
+        console.error(`'${startDir}' is not inside a git repository`);
+        console.error('docouture upgrade re-syncs an already-scaffolded repository — run it from your repo root, or pass --dir <path> to one');
+        return 1;
+    }
+    // --dir/cwd can be anywhere inside the repository — findRepoRoot walks up
+    // to the actual top-level, same as new.ts and the rest of the CLI.
+    const target = await findRepoRoot(startDir);
+    // build/commands/upgrade.js -> build/templates/{workflows,agent-support} —
+    // same resolution new.ts uses, see its own comment.
+    const here = dirname(fileURLToPath(import.meta.url));
+    const templatesRoot = join(here, '..', 'templates');
+    const workflowsTemplateDir = join(templatesRoot, 'workflows');
+    const agentSupportDir = join(templatesRoot, 'agent-support');
+    // build/commands/upgrade.js -> package root, 2 levels up — see
+    // readCliInfo's own comment. Always re-read fresh: an upgrade run re-pins
+    // whatever templates reference the CLI version to the one actually
+    // installed now, which may well differ from whatever `docouture new`
+    // originally stamped in.
+    const { version: cliVersion } = await readCliInfo(import.meta.url, 2);
+    // Re-detected fresh too, same reasoning — a site may have picked up a
+    // lockfile (or a packageManager field) since it was first scaffolded.
+    const pm = packageManagerPlan(detectPackageManager(target));
+    // AGENTS.md's own __DOCOUTURE_TITLE__ placeholder (the only name/title token
+    // used outside `new.ts`'s starter/docs templates — see copy-template.ts's
+    // PLACEHOLDERS) needs a value from somewhere, but `upgrade` takes no
+    // <name> argument: it re-syncs an existing site, so the value it already
+    // recorded in docs/antora.yml at scaffold time is read back rather than
+    // asked for again. --title still overrides it, and a site with no
+    // docs/antora.yml (workflows/skills used standalone of the starter
+    // subtree) falls back to a plain, title-cased directory name.
+    const descriptorPath = join(target, 'docs', 'src', 'antora.yml');
+    let name = 'docs';
+    let fromYmlTitle;
+    if (await exists(descriptorPath)) {
+        const content = await readFile(descriptorPath, 'utf8');
+        name = readAntoraField(content, 'name') ?? name;
+        fromYmlTitle = readAntoraField(content, 'title') ?? undefined;
+    }
+    // Same three-tier precedence publish.ts uses (see lib/config-resolver.ts):
+    // --title flag > the value already recorded in docs/antora.yml > a plain
+    // title-cased fallback computed from the name above.
+    const { title } = resolveConfig({ title: titleCase(name) }, { title: fromYmlTitle }, { title: typeof flags.title === 'string' ? flags.title : undefined });
+    const values = {
+        name,
+        title,
+        // Same reasoning as repoIgnoreGlob below: __DOCOUTURE_COMPONENT_NAME__ only
+        // appears in docs/antora.yml and antora-playbook.yml, neither of which
+        // upgrade ever re-copies (see the comment above `name` itself) — this
+        // value is structurally required by TemplateValues but never actually
+        // substituted anywhere upgrade touches.
+        componentName: 'unused-by-upgrade',
+        cliVersion,
+        pmName: pm.pm,
+        pmCacheName: pm.cacheName,
+        pmLockfile: pm.lockfile,
+        pmCiCmd: pm.ciCmd,
+        pmSetupStepYaml: pm.setupStepYaml,
+        // upgrade never re-copies docs/ (see below) — package.json, the only
+        // template file this placeholder appears in, is never touched here — so
+        // there's nothing meaningful to compute it from. Not an empty string:
+        // an empty glob (see check-links.mjs's globToRegExp) compiles to a
+        // pattern matching every URL, which would be a silent, dangerous no-op
+        // if this value were ever actually substituted somewhere.
+        repoIgnoreGlob: 'unused-by-upgrade',
+    };
+    const workflowsDir = join(target, '.github', 'workflows');
+    const agentsMdFile = join(target, AGENTS_MD_FILENAME);
+    // Unlike `new.ts`, this command's whole purpose is to overwrite what's
+    // already there — workflows and agent skills are meant to be regenerable
+    // from the template on every upgrade, not merged with local edits (there
+    // is no content-hash/diff tracking anywhere in this CLI to tell a stock
+    // file from a user-edited one). `docs/` itself — the starter content a
+    // site has since written its own pages into — is never touched here.
+    // AGENTS.md is the one exception: copyTemplate's own SKIP_FILENAMES skip
+    // (see copy-template.ts) leaves it untouched by the walk above, and it's
+    // merged instead — see lib/agents-md.ts for why a blind overwrite here
+    // would silently destroy the 'Documentation state' table
+    // `documenting-your-repo` maintains outside docouture' own managed section.
+    if (dryRun) {
+        const plannedWorkflows = await copyTemplate(workflowsTemplateDir, workflowsDir, values, { dryRun: true });
+        const plannedAgentSupport = await copyTemplate(agentSupportDir, target, values, { dryRun: true });
+        console.log('would write:');
+        for (const path of [...plannedWorkflows, ...plannedAgentSupport, agentsMdFile]) {
+            console.log(`  ${relative(target, path)}`);
+        }
+        return 0;
+    }
+    await copyTemplate(workflowsTemplateDir, workflowsDir, values);
+    await copyTemplate(agentSupportDir, target, values);
+    const existingAgentsMd = (await exists(agentsMdFile)) ? await readFile(agentsMdFile, 'utf8') : undefined;
+    const renderedAgentsMd = await renderTemplateFile(join(agentSupportDir, AGENTS_MD_FILENAME), values);
+    await writeFile(agentsMdFile, mergeAgentsMd(existingAgentsMd, renderedAgentsMd), 'utf8');
+    // Relative to `target` (the repo root), not process.cwd() — cwd may be a
+    // nested subdirectory findRepoRoot walked up from, in which case
+    // relative(cwd, ...) produces a useless '../../..' chain for paths that
+    // are actually just '.github/workflows', 'AGENTS.md' etc. at the root.
+    console.log(`updated ${relative(target, workflowsDir)}`);
+    console.log(`updated ${relative(target, agentsMdFile)}`);
+    console.log(`updated ${relative(target, join(target, '.opencode', 'skills'))}`);
+    console.log(`updated ${relative(target, join(target, '.claude', 'skills'))}`);
+    return 0;
+}
+//# sourceMappingURL=upgrade.js.map

package/build/commands/version.js

@@ -0,0 +1,60 @@
+'use strict';
+import { readFile, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { parseArgs } from '../lib/args.js';
+import { exists } from '../lib/copy-template.js';
+import { findRepoRoot } from '../lib/repo-root.js';
+import { patchVersion, readVersion } from '../lib/antora-yml.js';
+// Unlike `just bump` — which moves this workspace's own package.json files
+// through npm semver arithmetic — this takes the target version as a literal
+// value rather than a bump level (major/minor/patch/...). Antora's component
+// `version` is a free-form string, not required to be semver: sites in the
+// wild use "2.1", "v3", "latest". Guessing what "minor" means for "2.1" would
+// be presumptuous, and wrong for the sites where it does not apply. If your
+// documented version does happen to be semver, compute the next value
+// yourself and pass it here.
+export async function runVersion(argv) {
+    const { positional, flags } = parseArgs(argv);
+    const value = positional[0];
+    if (!value) {
+        console.error('usage: docouture version <value> [--dir <path>] [--file <path>] [--prerelease | --stable]');
+        return 1;
+    }
+    if (flags.prerelease && flags.stable) {
+        console.error('--prerelease and --stable are mutually exclusive');
+        return 1;
+    }
+    // --dir (or cwd) can be anywhere inside the repository — findRepoRoot
+    // walks up to the actual repository root, same as dev/build/doctor, so
+    // this works whether run from the repo root, from inside docs/, or from a
+    // nested page directory. --file bypasses all of this with a literal path.
+    let file;
+    if (typeof flags.file === 'string') {
+        file = resolve(flags.file);
+    }
+    else {
+        const startDir = typeof flags.dir === 'string' ? resolve(flags.dir) : resolve(process.cwd());
+        const repoRoot = await findRepoRoot(startDir);
+        file = join(repoRoot, 'docs', 'src', 'antora.yml');
+    }
+    if (!(await exists(file))) {
+        console.error(`no antora.yml found at '${file}'`);
+        console.error('pass --dir <path> (anywhere inside the repository) or --file <path> directly');
+        return 1;
+    }
+    const content = await readFile(file, 'utf8');
+    const before = readVersion(content);
+    let patched;
+    try {
+        patched = patchVersion(content, { version: value, prerelease: flags.prerelease === true });
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        console.error(`'${file}' does not look like an Antora component descriptor`);
+        return 1;
+    }
+    await writeFile(file, patched, 'utf8');
+    console.log(`  ${before ?? '(none)'} → ${value}${flags.prerelease ? ' (prerelease)' : ''}`);
+    return 0;
+}
+//# sourceMappingURL=version.js.map

package/build/lib/agents-md.js

@@ -0,0 +1,67 @@
+'use strict';
+// AGENTS.md is the one scaffolded file `docouture new`/`docouture upgrade` never
+// treat as all-or-nothing: unlike a workflow file or a skill directory, a
+// repository may well already have its own AGENTS.md before `docouture new`
+// ever runs, and the `documenting-your-repo` skill edits this file's own
+// '## Documentation state' table over time as a repo's docs grow — content
+// no template regenerates. Rather than clobber the whole file (today's
+// behavior for every other scaffolded file) or refuse outright, docouture' own
+// content lives inside a clearly marked, mechanically findable block —
+// everything outside it (a human's own notes, or that evolving table) is
+// never touched. The template itself
+// (templates/agent-support/AGENTS.md) places MANAGED_END right before
+// '## Documentation state', so that section is deliberately outside the
+// block even on a brand-new scaffold.
+export const MANAGED_START = '<!-- docouture:start - managed by docouture; edits inside this block are overwritten by `docouture new`/`docouture upgrade` -->';
+export const MANAGED_END = '<!-- docouture:end -->';
+export const AGENTS_MD_FILENAME = 'AGENTS.md';
+// True when `content` already has a complete docouture-managed block — the
+// signal `new.ts` uses to decide whether an existing AGENTS.md counts as a
+// genuine overwrite conflict (subject to the same confirm-before-overwrite
+// prompt as workflows/skills) versus a foreign file that's simply safe to
+// append to without asking.
+export function hasManagedSection(content) {
+    const start = content.indexOf(MANAGED_START);
+    const end = content.indexOf(MANAGED_END);
+    return start !== -1 && end !== -1 && end > start;
+}
+function extractManagedBlock(templateContent) {
+    const start = templateContent.indexOf(MANAGED_START);
+    const end = templateContent.indexOf(MANAGED_END);
+    if (start === -1 || end === -1 || end <= start) {
+        // Only reachable if templates/agent-support/AGENTS.md itself loses its
+        // own markers — a packaging bug, not a runtime/user condition.
+        throw new Error('templates/agent-support/AGENTS.md is missing its docouture:start/docouture:end markers');
+    }
+    return templateContent.slice(start, end + MANAGED_END.length);
+}
+// Merges `templateContent` — this run's freshly rendered AGENTS.md, exactly
+// as `docouture new` would write it from scratch (placeholders already
+// substituted, both markers and the default '## Documentation state' tail
+// all present) — into `existing`, the AGENTS.md content already on disk (or
+// `undefined` if there wasn't one):
+//   - no existing file           -> templateContent as-is, unchanged from
+//                                    today's whole-file scaffold output.
+//   - existing has a managed     -> only that block is replaced, sliced out
+//     block already                 of templateContent; everything in
+//                                    `existing` before/after it (a human's
+//                                    own notes, the Documentation state
+//                                    table) survives byte for byte.
+//   - existing has no managed    -> templateContent (block + its own
+//     block (a foreign/human         default tail) is appended to the end
+//     AGENTS.md, or one from        of `existing`, blank-line separated;
+//     before this existed)          nothing already there is touched.
+export function mergeAgentsMd(existing, templateContent) {
+    if (existing === undefined)
+        return templateContent;
+    const start = existing.indexOf(MANAGED_START);
+    const end = existing.indexOf(MANAGED_END);
+    if (start !== -1 && end !== -1 && end > start) {
+        const before = existing.slice(0, start);
+        const after = existing.slice(end + MANAGED_END.length);
+        return `${before}${extractManagedBlock(templateContent)}${after}`;
+    }
+    const separator = existing.length === 0 ? '' : existing.endsWith('\n\n') ? '' : existing.endsWith('\n') ? '\n' : '\n\n';
+    return `${existing}${separator}${templateContent}`;
+}
+//# sourceMappingURL=agents-md.js.map

package/build/lib/antora-log.js

@@ -0,0 +1,36 @@
+'use strict';
+// Antora's own default log level is `warn` — set explicitly by @antora/
+// playbook-builder's convict schema, not the `info` @antora/logger falls
+// back to on its own when nothing configures it. Left alone, every one of
+// docouture's own Antora pipeline extensions (kroki-prewarm.js, search-index.js,
+// llms-txt.js, footer.js, nav-modules.js, not-found-page.js,
+// version-report.js — anything calling `context.getLogger('docouture-...')`)
+// logs its own healthy-run observability at `info` and is silently dropped
+// before it ever reaches stdout. `docouture build`/`docouture dev` pass this to
+// every Antora invocation they make so those lines are actually emitted —
+// the monorepo's own `just dev`/`just build-site` recipes do the same for
+// the identical reason (see justfile's own comments on this).
+export const ANTORA_LOG_LEVEL_ARGS = ['--log-level=info'];
+// Matches a JSON log line carrying `"level":"warn"` or `"level":"error"`
+// (Antora's own genuine signal, regardless of source), or one from any
+// `docouture-*` named logger regardless of level (every current and future
+// docouture extension follows that naming convention — see the file list
+// above) — docouture's own healthy-run observability, which is otherwise
+// indistinguishable from Antora's own internal `info` chatter that
+// `--log-level=info` also just turned on.
+const OBSERVABLE_LINE = /"level":"(?:warn|error)"|"name":"docouture-/;
+/**
+ * Filters raw Antora output (stdout, or stdout+stderr concatenated) down to
+ * the lines worth showing on an otherwise-quiet, successful run: see
+ * `OBSERVABLE_LINE`'s own comment for exactly which ones. Returns '' when
+ * nothing qualifies — callers should skip printing entirely rather than
+ * print a blank line. A failed run should show its raw, unfiltered output
+ * instead of this — the whole story a filter might otherwise cut short.
+ */
+export function filterObservableAntoraLog(output) {
+    return output
+        .split('\n')
+        .filter((line) => OBSERVABLE_LINE.test(line))
+        .join('\n');
+}
+//# sourceMappingURL=antora-log.js.map

package/build/lib/antora-yml.js

@@ -0,0 +1,47 @@
+'use strict';
+// Patches the two fields `docouture version` cares about — `version:` and
+// `prerelease:` — by line, rather than parsing the file into a YAML document
+// and re-serialising it. A full parse/dump round-trip would lose the comments
+// antora.yml carries (see docs-site-package's own antora.yml for an example),
+// and this file's whole reason to be readable is that a human edits it too.
+//
+// This only ever touches top-level keys, matched at the start of a line
+// (column 0), which is where Antora requires `name`/`title`/`version` to live
+// in a component descriptor.
+const VERSION_LINE = /^version:.*$/m;
+const PRERELEASE_LINE = /^prerelease:.*$/m;
+export function readVersion(content) {
+    const match = VERSION_LINE.exec(content);
+    if (!match)
+        return null;
+    const value = match[0].slice('version:'.length).trim();
+    return value.length > 0 ? value : null;
+}
+export function hasVersionLine(content) {
+    return VERSION_LINE.test(content);
+}
+export function patchVersion(content, patch) {
+    if (!VERSION_LINE.test(content)) {
+        throw new Error("no top-level 'version:' line found");
+    }
+    let next = content.replace(VERSION_LINE, `version: ${patch.version}`);
+    if (patch.prerelease) {
+        if (PRERELEASE_LINE.test(next)) {
+            next = next.replace(PRERELEASE_LINE, 'prerelease: true');
+        }
+        else {
+            // Insert directly after the version line, so a reader sees the two
+            // together rather than prerelease landing wherever the regex first
+            // matched something else.
+            next = next.replace(VERSION_LINE, (line) => `${line}\nprerelease: true`);
+        }
+    }
+    else if (PRERELEASE_LINE.test(next)) {
+        next = next.replace(`${PRERELEASE_LINE.exec(next)[0]}\n`, '');
+        // The line may be the last one in the file, with no trailing newline to
+        // consume in the replacement above — handle that case too.
+        next = next.replace(PRERELEASE_LINE, '').replace(/\n{3,}/g, '\n\n');
+    }
+    return next;
+}
+//# sourceMappingURL=antora-yml.js.map

package/build/lib/args.js

@@ -0,0 +1,26 @@
+'use strict';
+export function parseArgs(argv) {
+    const positional = [];
+    const flags = {};
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === undefined)
+            continue;
+        if (arg.startsWith('--')) {
+            const name = arg.slice(2);
+            const next = argv[i + 1];
+            if (next !== undefined && !next.startsWith('--')) {
+                flags[name] = next;
+                i++;
+            }
+            else {
+                flags[name] = true;
+            }
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    return { positional, flags };
+}
+//# sourceMappingURL=args.js.map

package/build/lib/cli-context.js

@@ -0,0 +1,17 @@
+'use strict';
+const DEFAULT_CONTEXT = { json: false, verbose: false, noColor: false };
+let context = { ...DEFAULT_CONTEXT };
+export function setContext(next) {
+    context = { ...context, ...next };
+}
+export function getContext() {
+    return context;
+}
+// Test-only: every other consumer only ever wants to add to context, never
+// to guarantee a clean slate — vitest, however, runs every *.spec.ts in the
+// same process, so a --json/--verbose/--no-color set by one test would
+// otherwise leak into the next.
+export function resetContext() {
+    context = { ...DEFAULT_CONTEXT };
+}
+//# sourceMappingURL=cli-context.js.map

package/build/lib/cli-info.js

@@ -0,0 +1,20 @@
+'use strict';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// Reads THIS package's own package.json — the one npm actually published (or
+// `just release-local` snapshot-published) — never a value baked in at
+// compile time, so it can never drift from what's really running. Callers
+// pass their own import.meta.url plus how many directories separate them
+// from the package root (bin.js lives at build/bin.js, one level down;
+// new.js lives at build/commands/new.js, two levels down), since that
+// differs by caller and there is no other reliable anchor at runtime.
+export async function readCliInfo(callerUrl, levelsToPackageRoot) {
+    const here = dirname(fileURLToPath(callerUrl));
+    const upSegments = Array.from({ length: levelsToPackageRoot }, () => '..');
+    const pkgPath = join(here, ...upSegments, 'package.json');
+    const raw = await readFile(pkgPath, 'utf8');
+    const pkg = JSON.parse(raw);
+    return { name: pkg.name ?? '@inditextech/docouture-cli', version: pkg.version ?? '0.0.0' };
+}
+//# sourceMappingURL=cli-info.js.map

package/build/lib/config-resolver.js

@@ -0,0 +1,23 @@
+'use strict';
+// The one config-precedence rule this CLI applies in more than one place —
+// CLI flags win over a persisted/configured value, which wins over a
+// hardcoded default — pulled out into a single, tested function instead of
+// each command re-deriving the same `{ ...a, ...b, ...c }` merge with its
+// own slightly different shape (publish.ts's options, upgrade.ts's title).
+// Per-command commands still own *what* the three layers are (reading
+// docs/package.json, docs/antora.yml, flags) — this only owns the merge
+// order itself, and only overrides a key when the flag/configured layer
+// actually provided a value: `undefined` never wins over a real default.
+export function resolveConfig(defaults, configured = {}, flags = {}) {
+    const result = { ...defaults };
+    for (const [key, value] of Object.entries(configured)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    for (const [key, value] of Object.entries(flags)) {
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
+//# sourceMappingURL=config-resolver.js.map