@gitpagedocs/cli 0.0.1

package/presentation/commands/diagnostics.ts

@@ -0,0 +1,174 @@
+import path from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { defaultConfigLoader } from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+// @ts-expect-error .mjs runtime module is type-less in this package.
+import { runExecutableCapture } from "../../runtime/exec.mjs";
+
+interface DoctorCheck {
+  label: string;
+  ok: boolean;
+  detail: string;
+}
+
+function readVersion(pkgRoot: string): string {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
+    return String(pkg.version ?? "unknown");
+  } catch {
+    return "unknown";
+  }
+}
+
+export async function runVersion(ctx: CommandContext): Promise<void> {
+  // eslint-disable-next-line no-console
+  console.log(`gitpagedocs ${readVersion(ctx.pkgRoot)} (node ${process.version})`);
+}
+
+/** Run `<program> --version` (argv array, no shell) and keep its first output line. */
+function probe(label: string, program: string): DoctorCheck {
+  try {
+    const out = String(runExecutableCapture(program, ["--version"], { stdio: ["ignore", "pipe", "ignore"] }));
+    return { label, ok: true, detail: out.split("\n")[0] };
+  } catch {
+    return { label, ok: false, detail: "not found" };
+  }
+}
+
+export async function runDoctor(ctx: CommandContext): Promise<void> {
+  const configPath = await defaultConfigLoader.resolveConfigPath(ctx.cwd);
+  const hasDocsDirectory = existsSync(path.join(ctx.cwd, "gitpagedocs"));
+  const checks: DoctorCheck[] = [
+    { label: "node", ok: true, detail: process.version },
+    probe("git", "git"),
+    probe("gh (GitHub CLI)", "gh"),
+    probe("pnpm", "pnpm"),
+    {
+      label: "gitpagedocs config",
+      ok: Boolean(configPath),
+      detail: configPath ? path.relative(ctx.cwd, configPath) : "not found (run `gitpagedocs init`)",
+    },
+    {
+      label: "gitpagedocs/ directory",
+      ok: hasDocsDirectory,
+      detail: hasDocsDirectory ? "present" : "missing",
+    },
+  ];
+
+  // eslint-disable-next-line no-console
+  console.log("\n  gitpagedocs doctor\n");
+  for (const c of checks) {
+    // eslint-disable-next-line no-console
+    console.log(`  ${c.ok ? "[ok]" : "[x] "} ${c.label.padEnd(22)} ${c.detail}`);
+  }
+  const failed = checks.filter((c) => !c.ok && c.label !== "gh (GitHub CLI)").length;
+  const summary = failed === 0 ? "All required checks passed." : `${failed} check(s) need attention.`;
+  // eslint-disable-next-line no-console
+  console.log(`\n  ${summary}\n`);
+}
+
+/** Used only when package.json is unreadable — the CLI's published name. */
+const FALLBACK_PACKAGE = "@gitpagedocs/cli";
+/** The bin this package installs; shown alongside the package name. */
+const BIN_NAME = "gitpagedocs";
+
+interface PackageIdentity {
+  name: string;
+  version: string;
+}
+
+/**
+ * Read the identity from the installed package.json rather than hardcoding it,
+ * so the hint always names the package the user actually has. A hardcoded name
+ * is how `update` ended up advertising an unpublished package.
+ */
+function readPackageIdentity(pkgRoot: string): PackageIdentity {
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
+    const name = typeof pkg.name === "string" && pkg.name.length > 0 ? pkg.name : FALLBACK_PACKAGE;
+    return { name, version: String(pkg.version ?? "unknown") };
+  } catch {
+    return { name: FALLBACK_PACKAGE, version: "unknown" };
+  }
+}
+
+type RegistryLookup =
+  | { status: "ok"; latest: string }
+  | { status: "missing" }
+  | { status: "unreachable" };
+
+function registryBase(): string {
+  const configured = process.env.npm_config_registry || "https://registry.npmjs.org";
+  return configured.endsWith("/") ? configured.slice(0, -1) : configured;
+}
+
+/** Resolve the dist-tag `latest` for a package. Never throws. */
+async function fetchLatest(name: string, timeoutMs = 6000): Promise<RegistryLookup> {
+  const encoded = name.split("/").map(encodeURIComponent).join("/");
+  try {
+    const response = await fetch(`${registryBase()}/${encoded}/latest`, {
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (response.status === 404) return { status: "missing" };
+    if (!response.ok) return { status: "unreachable" };
+    const body = (await response.json()) as { version?: unknown };
+    if (typeof body.version === "string" && body.version.length > 0) {
+      return { status: "ok", latest: body.version };
+    }
+    return { status: "unreachable" };
+  } catch {
+    return { status: "unreachable" };
+  }
+}
+
+/** Numeric version compare, prerelease suffix ignored. */
+function compareVersions(a: string, b: string): number {
+  const parts = (value: string): number[] =>
+    value.split("-")[0].split(".").map((piece) => Number.parseInt(piece, 10) || 0);
+  const left = parts(a);
+  const right = parts(b);
+  for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff < 0 ? -1 : 1;
+  }
+  return 0;
+}
+
+export async function runUpdate(ctx: CommandContext): Promise<void> {
+  const { name, version } = readPackageIdentity(ctx.pkgRoot);
+  const lookup = await fetchLatest(name);
+  const label = name === BIN_NAME ? `${BIN_NAME} ${version}` : `${BIN_NAME} ${version}  (${name})`;
+  const lines = ["", `  Installed: ${label}`];
+
+  if (lookup.status === "ok") {
+    lines.push(`  Latest:    ${lookup.latest}`);
+  } else if (lookup.status === "missing") {
+    lines.push(`  Latest:    unavailable — the registry has no published ${name}`);
+  } else {
+    lines.push("  Latest:    unknown — could not reach the npm registry");
+  }
+
+  if (lookup.status === "missing") {
+    lines.push(
+      "",
+      "  Nothing can be installed under that name. If the package was renamed",
+      "  or unpublished, check the current one:",
+      "    https://www.npmjs.com/package/@gitpagedocs/cli",
+    );
+  } else if (lookup.status === "ok" && compareVersions(version, lookup.latest) >= 0) {
+    lines.push("", "  Already on the latest published version.");
+  } else {
+    const target = lookup.status === "ok" ? lookup.latest : "latest";
+    lines.push(
+      "",
+      "  To update the global CLI:",
+      `    npm i -g ${name}@${target}`,
+      "  Or, in a project:",
+      `    pnpm add -D ${name}@${target}`,
+    );
+  }
+
+  lines.push("");
+  // eslint-disable-next-line no-console
+  console.log(lines.join("\n"));
+}

package/presentation/commands/docs.ts

@@ -0,0 +1,42 @@
+import {
+  FileService,
+  DocUpdater,
+  providersSection,
+  cliCommandsSection,
+  devWorkflowSection,
+  securityNoteSection,
+  CLI_COMMANDS,
+} from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+
+/** Human-readable outcome of one managed-region update. */
+function describeUpdate(result: { changed: boolean; replaced: boolean }): string {
+  if (!result.changed) return "already up to date";
+  return result.replaced ? "managed region updated" : "managed region added";
+}
+
+/**
+ * `gitpagedocs docs` — refresh the managed regions of the standard docs files
+ * with deterministic content. Idempotent and marker-bounded: manual content
+ * outside `<!-- gitpagedocs:start/end -->` is preserved; missing files are
+ * created. Covers README, CONTRIBUTING and SECURITY (master-spec docs set).
+ */
+export async function runDocs(ctx: CommandContext): Promise<void> {
+  const updater = new DocUpdater(new FileService(ctx.cwd));
+
+  const updates = [
+    { path: "README.md", generated: `${providersSection()}\n\n${cliCommandsSection(CLI_COMMANDS)}` },
+    { path: "CONTRIBUTING.md", generated: `${devWorkflowSection()}\n\n${cliCommandsSection(CLI_COMMANDS)}` },
+    { path: "SECURITY.md", generated: securityNoteSection() },
+  ];
+
+  const results = await updater.updateManagedFiles(updates);
+  // eslint-disable-next-line no-console
+  console.log("");
+  for (const r of results) {
+    // eslint-disable-next-line no-console
+    console.log(`  ${r.path}: ${describeUpdate(r)}.`);
+  }
+  // eslint-disable-next-line no-console
+  console.log("");
+}

package/presentation/commands/mcp.ts

@@ -0,0 +1,20 @@
+import type { CommandContext } from "./run-command";
+
+/**
+ * `gitpagedocs mcp start` — entry point for the MCP server. The server package
+ * (@gitpagedocs/mcp) is implemented in Phase 7; this command is wired to launch
+ * it there. Until then it reports status honestly rather than failing silently.
+ */
+export async function runMcp(ctx: CommandContext): Promise<void> {
+  const sub = ctx.args[1] ?? "start";
+  if (sub !== "start") {
+    // eslint-disable-next-line no-console
+    console.log(`\n  Unknown mcp subcommand: ${sub}\n  Usage: gitpagedocs mcp start\n`);
+    return;
+  }
+  // stderr only: stdout is the MCP stdio channel and must stay protocol-clean.
+  console.error("[gitpagedocs] Starting MCP server over stdio (Ctrl-C to stop)...");
+  // Dynamic import keeps the MCP SDK out of the frontend bundle.
+  const { startMcpServer } = await import("@gitpagedocs/mcp");
+  await startMcpServer(ctx.cwd);
+}

package/presentation/commands/pages.ts

@@ -0,0 +1,103 @@
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import type { CommandContext } from "./run-command";
+import { askConfirm } from "../ui/clack";
+import { askOwnerRepo, interactivePromptsAvailable } from "../ui/prompts";
+// @ts-expect-error .mjs runtime module
+import { detectRepoFromGit, getCurrentGitBranch, tryConfigurePagesToGitHubActions } from "../../runtime/git-ops.mjs";
+import { trimSlashes } from "../../contracts/path-segments.mjs";
+
+/** Read `--name value` (or `--name=value`) from a raw arg list. */
+function readFlag(args: string[], name: string): string {
+  const eq = args.find((a) => a.startsWith(`${name}=`));
+  if (eq) return eq.slice(name.length + 1).trim();
+  const i = args.indexOf(name);
+  if (i >= 0 && args[i + 1] && !args[i + 1].startsWith("--")) return args[i + 1].trim();
+  return "";
+}
+
+/**
+ * `gitpagedocs pages actions` / `--pages-actions` — switch the repository's
+ * GitHub Pages source to GitHub Actions. Detects owner/repo/branch from git,
+ * validates the gh CLI, and confirms before changing anything (no silent
+ * overwrite). Does NOT generate docs or push (that is `pages deploy`).
+ */
+export async function runPagesActions(ctx: CommandContext): Promise<void> {
+  let repo = detectRepoFromGit(ctx.cwd) as { owner: string; repo: string } | null;
+  if (!repo) {
+    if (!interactivePromptsAvailable()) {
+      // eslint-disable-next-line no-console
+      console.log("\n  Could not detect a GitHub repo from the git 'origin' remote.\n  Add a remote or use `--push --owner <o> --repo <r>`.\n");
+      return;
+    }
+    repo = await askOwnerRepo(null);
+  }
+  const branch = getCurrentGitBranch(ctx.cwd) as string;
+  // eslint-disable-next-line no-console
+  console.log(`\n  Detected ${repo.owner}/${repo.repo} (branch ${branch}).`);
+  const ok = await askConfirm(`Switch GitHub Pages source to GitHub Actions for ${repo.owner}/${repo.repo}?`, false);
+  if (!ok) {
+    // eslint-disable-next-line no-console
+    console.log("  Aborted. No changes made.\n");
+    return;
+  }
+  tryConfigurePagesToGitHubActions(repo.owner, repo.repo, branch, ctx.cwd);
+}
+
+/**
+ * `gitpagedocs pages deploy` — the full documented deploy flow: resolve
+ * owner/repo (from --owner/--repo or the git remote), confirm, then run the
+ * proven `--push` path (generate docs + workflow → commit → push → configure
+ * Pages→Actions) and print the final site URL. Reuses the legacy push verbatim
+ * (spawned), so `--push` behavior stays byte-identical.
+ */
+export async function runPagesDeploy(ctx: CommandContext): Promise<void> {
+  let owner = readFlag(ctx.args, "--owner");
+  let repo = readFlag(ctx.args, "--repo");
+  const docsPath = readFlag(ctx.args, "--path");
+
+  if (!owner || !repo) {
+    const detected = detectRepoFromGit(ctx.cwd) as { owner: string; repo: string } | null;
+    if (detected) {
+      owner = owner || detected.owner;
+      repo = repo || detected.repo;
+    }
+  }
+  if (!owner || !repo) {
+    if (!interactivePromptsAvailable()) {
+      // eslint-disable-next-line no-console
+      console.log("\n  Could not determine owner/repo. Pass `--owner <o> --repo <r>` or add a git 'origin' remote.\n");
+      return;
+    }
+    const answered = await askOwnerRepo(null, { owner, repo });
+    owner = answered.owner;
+    repo = answered.repo;
+  }
+
+  const pathSuffix = docsPath ? ` (path: ${docsPath})` : "";
+  // eslint-disable-next-line no-console
+  console.log(`\n  Deploy ${owner}/${repo} to GitHub Pages via Actions${pathSuffix}.`);
+  const ok = await askConfirm(
+    `Generate docs + workflow, commit, push, and switch Pages to Actions for ${owner}/${repo}?`,
+    false,
+  );
+  if (!ok) {
+    // eslint-disable-next-line no-console
+    console.log("  Aborted. No changes made.\n");
+    return;
+  }
+
+  // pkgRoot is the cli package root (cli/), where the bin lives as index.mjs.
+  const bin = path.join(ctx.pkgRoot, "index.mjs");
+  const pushArgs = ["--push", "--owner", owner, "--repo", repo, ...(docsPath ? ["--path", docsPath] : [])];
+  const result = spawnSync(process.execPath, [bin, ...pushArgs], { stdio: "inherit", cwd: ctx.cwd, env: process.env });
+
+  if (result.status === 0) {
+    const seg = docsPath ? `/${trimSlashes(docsPath)}` : "";
+    // eslint-disable-next-line no-console
+    console.log(`\n  Deployed. Final URL: https://${owner}.github.io/${repo}${seg}/\n`);
+  } else {
+    // eslint-disable-next-line no-console
+    console.log("\n  Deploy did not complete (push step failed). See output above.\n");
+  }
+}

package/presentation/commands/password.ts

@@ -0,0 +1,62 @@
+import { NodeCryptoService, deriveDocAccessKeys } from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+import { askPassword, note, outro } from "../ui/clack";
+import { interactivePromptsAvailable } from "../ui/prompts";
+import { GitPageDocsConfigRepository } from "../../infrastructure/gitpagedocs-config-file";
+
+const MIN_PASSWORD_LENGTH = 4;
+
+/**
+ * `gitpagedocs password` — interactively set a documentation access password.
+ *
+ * Type + confirm a password, derive the double-hash key pair, write the PUBLIC
+ * key into gitpagedocs/config.json (which makes the frontend gate the docs), and
+ * print the PRIVATE key for the user to copy. The password itself is never stored.
+ */
+export async function runPassword(ctx: CommandContext): Promise<void> {
+  if (!interactivePromptsAvailable()) {
+    // eslint-disable-next-line no-console
+    console.log("\n  `gitpagedocs password` is interactive — run it in a terminal (TTY).\n");
+    return;
+  }
+
+  const password = await askPassword({
+    message: "Documentation password:",
+    validate: (v) =>
+      v && v.trim().length >= MIN_PASSWORD_LENGTH
+        ? undefined
+        : `Use at least ${MIN_PASSWORD_LENGTH} characters.`,
+  });
+  const confirmation = await askPassword({
+    message: "Confirm password:",
+    validate: (v) => (v ? undefined : "Required."),
+  });
+
+  if (password !== confirmation) {
+    note("Passwords do not match. Nothing was changed.", "Aborted");
+    return;
+  }
+
+  const { privateKey, publicKey } = await deriveDocAccessKeys(password, new NodeCryptoService());
+
+  let configPath: string;
+  try {
+    configPath = await new GitPageDocsConfigRepository(ctx.cwd).patchDocsAccess(publicKey);
+  } catch (error) {
+    note(error instanceof Error ? error.message : String(error), "Could not save");
+    return;
+  }
+
+  note(
+    `Public key saved to ${configPath}\nThe documentation is now password-protected.`,
+    "Saved",
+  );
+  // eslint-disable-next-line no-console
+  console.log(
+    "\n  PRIVATE KEY (copy & keep it safe — it also unlocks the docs):\n\n" +
+      `    ${privateKey}\n\n` +
+      "  Readers can unlock with the password OR this private key.\n" +
+      "  To remove protection, set site.docsAccess.enabled to false in config.json.\n",
+  );
+  outro("Done.");
+}

package/presentation/commands/run-command.ts

@@ -0,0 +1,72 @@
+/**
+ * New-verb command layer (Phase 6). Intercepts the informational/utility
+ * commands that are NOT part of the legacy flag flow (version, doctor, provider,
+ * models, config, mcp, update) and routes them to thin handlers that consume
+ * @gitpagedocs/tools. Alias verbs (init, document, deploy, pages) are mapped in
+ * the parser and fall through to the legacy dispatch, so this returns false for
+ * them.
+ */
+export interface CommandContext {
+  argv: string[];
+  args: string[];
+  pkgRoot: string;
+  cwd: string;
+}
+
+export type CommandHandler = (ctx: CommandContext) => Promise<void>;
+
+import { runVersion, runDoctor, runUpdate } from "./diagnostics";
+import { runProvider, runModels } from "./ai-info";
+import { runConfig } from "./config-info";
+import { runConfigClear } from "./config-clear";
+import { runMcp } from "./mcp";
+import { runDocs } from "./docs";
+import { runPagesActions, runPagesDeploy } from "./pages";
+import { runPassword } from "./password";
+import { runChat } from "./chat";
+
+const REGISTRY: Record<string, CommandHandler> = {
+  version: runVersion,
+  "--version": runVersion,
+  "-v": runVersion,
+  doctor: runDoctor,
+  update: runUpdate,
+  provider: runProvider,
+  providers: runProvider,
+  models: runModels,
+  config: runConfig,
+  mcp: runMcp,
+  docs: runDocs,
+  password: runPassword,
+  chat: runChat,
+};
+
+/** Returns true if a new command handled the invocation (skip legacy flow). */
+export async function runNewCommand(argv: string[], pkgRoot: string): Promise<boolean> {
+  const args = argv.slice(2);
+  const ctx: CommandContext = { argv, args, pkgRoot, cwd: process.cwd() };
+
+  // Configure-only Pages→Actions: `--pages-actions` flag or `pages actions` verb.
+  if (args.includes("--pages-actions") || (args[0] === "pages" && args[1] === "actions")) {
+    await runPagesActions(ctx);
+    return true;
+  }
+  // Full deploy: `pages deploy` (detect owner/repo, confirm, run the proven
+  // push flow, print URL). Bare `pages`/`deploy` still fall through to legacy.
+  if (args[0] === "pages" && args[1] === "deploy") {
+    await runPagesDeploy(ctx);
+    return true;
+  }
+  // Wipe the stored AI credentials config: `config clear`.
+  if (args[0] === "config" && args[1] === "clear") {
+    await runConfigClear(ctx);
+    return true;
+  }
+
+  const handler = REGISTRY[args[0] ?? ""];
+  if (!handler) return false;
+  await handler(ctx);
+  return true;
+}
+
+export const NEW_COMMAND_NAMES = Object.keys(REGISTRY).filter((n) => !n.startsWith("-"));

package/presentation/index.ts

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { printBanner, printCredits } from "./ui/banner";
+import { resolveOptions } from "./options/resolver";
+import { migrateLegacyLayoutsInteractive } from "./ui/layouts-prompts";
+import { runNewCommand } from "./commands/run-command";
+import { dispatchMode } from "../application/use-cases/dispatch-mode";
+import type {
+  CliRuntimeParams,
+  ConfigOnlyRuntimePort,
+  HomeRuntimePort,
+} from "../application/ports/cli-runtime-ports";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { buildConfigArtifacts } from "../builders/config-orchestrator.mjs";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { createThemeTemplate } from "../builders/theme-template.mjs";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { LAYOUTS } from "../data/layouts.mjs";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { executeConfigOnly } from "../application/config-only/handler.mjs";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { executeHome } from "../application/home/handler.mjs";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { createConfigOnlyRuntime } from "../infrastructure/config-only/runtime.mjs";
+// @ts-expect-error .mjs modules are runtime-only in this package.
+import { createHomeRuntime } from "../infrastructure/home/runtime.mjs";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const root = process.cwd();
+// cli/ is the published package root (bin = cli/index.mjs). scriptDir is
+// cli/presentation, so pkgRoot = cli/ and the bundled prebuilt/ ships at
+// cli/prebuilt — works identically in-repo and when installed via npm.
+const pkgRoot = path.join(scriptDir, "..");
+const prebuiltDir = path.join(pkgRoot, "prebuilt");
+
+const params: CliRuntimeParams = {
+  root,
+  pkgRoot,
+  prebuiltDir,
+  buildConfigArtifacts,
+  createThemeTemplate,
+  layouts: LAYOUTS,
+};
+
+async function main(): Promise<void> {
+  // Commands that own stdout get no banner/credits: `mcp start` (the MCP stdio
+  // channel) and `chat` (streamed model output must be the only thing on stdout).
+  const stdoutOwnedByCommand = process.argv[2] === "mcp" || process.argv[2] === "chat";
+  if (!stdoutOwnedByCommand) printBanner();
+
+  // New informational/utility commands (version, doctor, provider, models,
+  // config, mcp, update) are handled before the legacy flag flow. Alias verbs
+  // (init, document, deploy, pages) are mapped in the parser and fall through.
+  if (await runNewCommand(process.argv, pkgRoot)) {
+    if (!stdoutOwnedByCommand) printCredits();
+    return;
+  }
+
+  const options = await resolveOptions(process.argv, process.env);
+
+  // Layouts moved out of <outputDir>/layouts/. Offer to relocate anything left
+  // behind before generating, so the config written next points at one folder.
+  if (options.mode === "config-only") {
+    await migrateLegacyLayoutsInteractive(root, options);
+  }
+
+  const configOnlyRuntime = createConfigOnlyRuntime() as ConfigOnlyRuntimePort;
+  const homeRuntime = createHomeRuntime() as HomeRuntimePort;
+  await dispatchMode(options, params, {
+    runConfigOnly: async (context) => {
+      const safePrebuiltDir =
+        typeof context.prebuiltDir === "string"
+          ? context.prebuiltDir
+          : path.join(String(context.pkgRoot ?? process.cwd()), "prebuilt");
+      await executeConfigOnly(
+        {
+          ...context,
+          prebuiltDir: safePrebuiltDir,
+        },
+        configOnlyRuntime,
+      );
+    },
+    runHome: async (context) => {
+      await executeHome(context, homeRuntime);
+    },
+    runAi: async (context) => {
+      console.log("[gitpagedocs] Iniciando Módulo de IA na CLI...");
+      const safePrebuiltDir =
+        typeof context.prebuiltDir === "string"
+          ? context.prebuiltDir
+          : path.join(String(context.pkgRoot ?? process.cwd()), "prebuilt");
+      // @ts-ignore
+      const { runAiCliCommand } = await import("../ai/application/run-ai-cli-command.ts");
+      const result = await runAiCliCommand({
+        cwd: process.cwd(),
+        onInfo: (message: string) => console.log(message),
+        // Scaffold the base gitpagedocs/ structure before AI pages are wired in.
+        onScaffold: async () => {
+          await executeConfigOnly({ ...context, prebuiltDir: safePrebuiltDir }, configOnlyRuntime);
+        },
+      });
+
+      if (result.summary.scannedFilesCount === 0) {
+        console.log("[gitpagedocs:ai] Nenhum arquivo elegível foi encontrado nos paths informados.");
+        return;
+      }
+
+      const pages = result.summary.pages ?? [];
+      console.log(
+        `\nProcesso completo. Páginas no padrão gitpagedocs: ${pages.join(", ") || "(nenhuma)"}`,
+      );
+      console.log(
+        `[gitpagedocs:ai] ${result.summary.outputs.length} arquivos markdown gerados e conectados ao config.json da versão mais recente.`,
+      );
+    },
+  });
+  printCredits();
+}
+
+main().catch((err: unknown) => {
+  console.error("Failed to create Git Page Docs scaffold.", err);
+  process.exitCode = 1;
+});