@gitpagedocs/cli 1.1.44

package/presentation/commands/ai-info.ts

@@ -0,0 +1,57 @@
+import { PROVIDER_CATALOG, ALL_PROVIDER_IDS, createModelRegistry, type AiProviderId } from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+
+function capsLabel(caps: { streaming: boolean; vision: boolean; audio: boolean }): string {
+  const parts: string[] = [];
+  if (caps.streaming) parts.push("stream");
+  if (caps.vision) parts.push("vision");
+  if (caps.audio) parts.push("audio");
+  return parts.join(", ") || "text";
+}
+
+/** `gitpagedocs provider [id]` — list providers or show one provider's detail. */
+export async function runProvider(ctx: CommandContext): Promise<void> {
+  const requested = ctx.args[1] as AiProviderId | undefined;
+  if (requested && PROVIDER_CATALOG[requested]) {
+    const spec = PROVIDER_CATALOG[requested];
+    // eslint-disable-next-line no-console
+    console.log(
+      `\n  ${spec.label} (${spec.id})\n` +
+        `    default model : ${spec.defaultModel}\n` +
+        `    capabilities  : ${capsLabel(spec.capabilities)}\n` +
+        `    base url      : ${spec.baseUrl || "(user-provided)"}\n` +
+        `    models        : ${spec.models.map((m) => m.id).join(", ")}\n`,
+    );
+    return;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`\n  AI providers (${ALL_PROVIDER_IDS.length}):\n`);
+  for (const id of ALL_PROVIDER_IDS) {
+    const spec = PROVIDER_CATALOG[id];
+    // eslint-disable-next-line no-console
+    console.log(`  ${id.padEnd(14)} ${spec.label.padEnd(18)} ${spec.defaultModel}`);
+  }
+  // eslint-disable-next-line no-console
+  console.log("\n  Detail: gitpagedocs provider <id>\n");
+}
+
+/** `gitpagedocs models [provider]` — list models for one or all providers. */
+export async function runModels(ctx: CommandContext): Promise<void> {
+  const models = createModelRegistry();
+  const requested = ctx.args[1] as AiProviderId | undefined;
+  const ids = requested && PROVIDER_CATALOG[requested] ? [requested] : ALL_PROVIDER_IDS;
+  // eslint-disable-next-line no-console
+  console.log("");
+  for (const id of ids) {
+    const list = models.list(id);
+    // eslint-disable-next-line no-console
+    console.log(`  ${PROVIDER_CATALOG[id].label} (${id}):`);
+    for (const m of list) {
+      // eslint-disable-next-line no-console
+      console.log(`    - ${m.id}${m.id === PROVIDER_CATALOG[id].defaultModel ? "  (default)" : ""}`);
+    }
+  }
+  // eslint-disable-next-line no-console
+  console.log("");
+}

package/presentation/commands/config-info.ts

@@ -0,0 +1,24 @@
+import path from "node:path";
+import { defaultConfigLoader, isAppError } from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+
+/** `gitpagedocs config` — resolve and summarize the active gitpagedocs config. */
+export async function runConfig(ctx: CommandContext): Promise<void> {
+  try {
+    const { config, sourcePath, extension } = await defaultConfigLoader.loadGitPageDocsConfig(ctx.cwd);
+    const site = (config as { site?: Record<string, unknown> }).site ?? {};
+    // eslint-disable-next-line no-console
+    console.log(
+      `\n  Config: ${path.relative(ctx.cwd, sourcePath)} (${extension})\n` +
+        `    site name        : ${String(site.name ?? "—")}\n` +
+        `    default language : ${String(site.defaultLanguage ?? "—")}\n` +
+        `    languages        : ${
+          Array.isArray(site.supportedLanguages) ? (site.supportedLanguages as string[]).join(", ") : "—"
+        }\n`,
+    );
+  } catch (error) {
+    const message = isAppError(error) ? error.message : String(error);
+    // eslint-disable-next-line no-console
+    console.log(`\n  No usable config found: ${message}\n  Run \`gitpagedocs init\` to generate one.\n`);
+  }
+}

package/presentation/commands/diagnostics.ts

@@ -0,0 +1,70 @@
+import path from "node:path";
+import { readFileSync, existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { defaultConfigLoader } from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+
+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})`);
+}
+
+function probe(label: string, command: string): { label: string; ok: boolean; detail: string } {
+  try {
+    const out = execSync(command, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim();
+    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 checks: Array<{ label: string; ok: boolean; detail: string }> = [];
+  checks.push({ label: "node", ok: true, detail: process.version });
+  checks.push(probe("git", "git --version"));
+  checks.push(probe("gh (GitHub CLI)", "gh --version"));
+  checks.push(probe("pnpm", "pnpm --version"));
+
+  const configPath = await defaultConfigLoader.resolveConfigPath(ctx.cwd);
+  checks.push({
+    label: "gitpagedocs config",
+    ok: Boolean(configPath),
+    detail: configPath ? path.relative(ctx.cwd, configPath) : "not found (run `gitpagedocs init`)",
+  });
+  checks.push({
+    label: "gitpagedocs/ directory",
+    ok: existsSync(path.join(ctx.cwd, "gitpagedocs")),
+    detail: existsSync(path.join(ctx.cwd, "gitpagedocs")) ? "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 ? "✓" : "✗"}  ${c.label.padEnd(22)} ${c.detail}`);
+  }
+  const failed = checks.filter((c) => !c.ok && c.label !== "gh (GitHub CLI)").length;
+  // eslint-disable-next-line no-console
+  console.log(`\n  ${failed === 0 ? "All required checks passed." : `${failed} check(s) need attention.`}\n`);
+}
+
+export async function runUpdate(ctx: CommandContext): Promise<void> {
+  const current = readVersion(ctx.pkgRoot);
+  // eslint-disable-next-line no-console
+  console.log(
+    `\n  Installed: gitpagedocs ${current}\n` +
+      "  To update the global CLI:\n" +
+      "    npm i -g gitpagedocs@latest\n" +
+      "  Or, in a project:\n" +
+      "    pnpm add -D gitpagedocs@latest\n",
+  );
+}

package/presentation/commands/docs.ts

@@ -0,0 +1,37 @@
+import {
+  FileService,
+  DocUpdater,
+  providersSection,
+  cliCommandsSection,
+  devWorkflowSection,
+  securityNoteSection,
+  CLI_COMMANDS,
+} from "@gitpagedocs/tools";
+import type { CommandContext } from "./run-command";
+
+/**
+ * `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) {
+    const state = r.changed ? (r.replaced ? "managed region updated" : "managed region added") : "already up to date";
+    // eslint-disable-next-line no-console
+    console.log(`  ${r.path}: ${state}.`);
+  }
+  // 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,91 @@
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import type { CommandContext } from "./run-command";
+import { askConfirm } from "../ui/clack";
+// @ts-expect-error .mjs runtime module
+import { detectRepoFromGit, getCurrentGitBranch, tryConfigurePagesToGitHubActions } from "../../runtime/git-ops.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> {
+  const repo = detectRepoFromGit(ctx.cwd) as { owner: string; repo: string } | null;
+  if (!repo) {
+    // 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;
+  }
+  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) {
+    // 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;
+  }
+
+  // eslint-disable-next-line no-console
+  console.log(`\n  Deploy ${owner}/${repo} to GitHub Pages via Actions${docsPath ? ` (path: ${docsPath})` : ""}.`);
+  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;
+  }
+
+  const bin = path.join(ctx.pkgRoot, "cli", "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 ? `/${docsPath.replace(/^\/+|\/+$/g, "")}` : "";
+    // 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/run-command.ts

@@ -0,0 +1,62 @@
+/**
+ * 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 { runMcp } from "./mcp";
+import { runDocs } from "./docs";
+import { runPagesActions, runPagesDeploy } from "./pages";
+
+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,
+};
+
+/** 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;
+  }
+
+  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,108 @@
+#!/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 { 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> {
+  // `mcp start` owns stdout (the MCP stdio channel) — no banner/credits there.
+  const stdoutOwnedByCommand = process.argv[2] === "mcp";
+  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);
+  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...");
+      // @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),
+      });
+
+      if (result.summary.scannedFilesCount === 0) {
+        console.log("[gitpagedocs:ai] Nenhum arquivo elegível foi encontrado nos paths informados.");
+        return;
+      }
+
+      if (result.runConfigScaffold) {
+        console.log("\n[gitpagedocs] Scaffolding GitPageDocs ecosystem automatically...");
+        const safePrebuiltDir = typeof context.prebuiltDir === "string" ? context.prebuiltDir : path.join(String(context.pkgRoot ?? process.cwd()), "prebuilt");
+        await executeConfigOnly({ ...context, prebuiltDir: safePrebuiltDir }, configOnlyRuntime);
+      }
+
+      console.log(`\n🎉 Processo completo! Arquivos gerados: ${result.summary.outputs.join(", ")}`);
+    },
+  });
+  printCredits();
+}
+
+main().catch((err: unknown) => {
+  console.error("Failed to create Git Page Docs scaffold.", err);
+  process.exitCode = 1;
+});

package/presentation/options/parser.ts

@@ -0,0 +1,104 @@
+import type { CliOptions } from "../../domain/models/cli-options";
+import { DEFAULTS } from "./schema";
+
+const KNOWN_FLAGS = new Set([
+  "--build",
+  "--serve",
+  "--layoutconfig",
+  "--full",
+  "--push",
+  "--home",
+  "--search",
+  "--path",
+  "--output",
+  "--interactive",
+  "-i",
+  "--ai",
+  "--pages-actions",
+]);
+
+function readOptionValue(args: string[], optionName: string): string {
+  const equalsArg = args.find((a) => a.startsWith(`${optionName}=`));
+  if (equalsArg) return equalsArg.slice(optionName.length + 1).trim();
+  const index = args.indexOf(optionName);
+  if (index >= 0) {
+    const next = args[index + 1];
+    if (next && !next.startsWith("--")) return next.trim();
+  }
+  return "";
+}
+
+export function parseCliOptions(argv: string[], env: NodeJS.ProcessEnv): CliOptions {
+  const args = argv.slice(2);
+
+  let githubOwner = readOptionValue(args, "--owner");
+  let githubRepo = readOptionValue(args, "--repo");
+  const docsPath = readOptionValue(args, "--path");
+  const outputDir = readOptionValue(args, "--output");
+  const searchRaw = readOptionValue(args, "--search");
+
+  const fallbackDashedArgs = args
+    .filter((a) => a.startsWith("--"))
+    .filter((a) => !KNOWN_FLAGS.has(a))
+    .filter((a) => !a.startsWith("--owner"))
+    .filter((a) => !a.startsWith("--repo"))
+    .filter((a) => !a.startsWith("--path"))
+    .filter((a) => !a.startsWith("--home"))
+    .filter((a) => !a.startsWith("--output"))
+    .filter((a) => !a.startsWith("--search"))
+    .map((a) => a.replace(/^--/, "").trim())
+    .filter(Boolean);
+
+  if (!githubOwner && fallbackDashedArgs[0]) githubOwner = fallbackDashedArgs[0];
+  if (!githubRepo && fallbackDashedArgs[1]) githubRepo = fallbackDashedArgs[1];
+
+  // New verb aliases (Phase 6) that map onto existing modes without new modes.
+  const command = args[0];
+  const isDocument = command === "document" || (command?.startsWith("document:") ?? false);
+  const isDeploy = command === "deploy" || command === "pages";
+
+  const isBuild = args.includes("--build") || env.GITPAGEDOCS_BUILD === "1";
+  const isServe = args.includes("--serve");
+  const useLocalLayoutConfig = args.includes("--layoutconfig");
+  const shouldPush = args.includes("--push") || isDeploy;
+  const isHome = args.includes("--home");
+  const isInteractive = args.includes("--interactive") || args.includes("-i");
+  const isAi = command === "ai" || args.includes("--ai") || isDocument;
+  const aiCommand =
+    command === "ai"
+      ? args[1]
+      : command === "document"
+        ? args[1] ?? "repo"
+        : command?.startsWith("document:")
+          ? command.split(":")[1]
+          : undefined;
+
+  const mode: import("../../domain/models/cli-options").CliMode = isAi ? "ai" : isHome ? "home" : args.includes("--full") ? "full" : "config-only";
+  const repositorySearch =
+    searchRaw === "true"
+      ? true
+      : searchRaw === "false"
+        ? false
+        : isHome
+          ? DEFAULTS.home.repositorySearch
+          : undefined;
+
+  const normalizedPath = docsPath.trim();
+
+  return {
+    isBuild,
+    isServe,
+    mode,
+    aiCommand,
+    outputDir: outputDir || (isHome ? DEFAULTS.home.outputDir : DEFAULTS.outputDir),
+    useLocalLayoutConfig,
+    shouldPush,
+    githubOwner,
+    githubRepo,
+    docsPath: normalizedPath,
+    basePath: normalizedPath,
+    repositorySearch,
+    isInteractive,
+    hasArgs: args.length > 0,
+  };
+}

package/presentation/options/resolver.ts

@@ -0,0 +1,25 @@
+import type { CliOptions } from "../../domain/models/cli-options";
+import { parseCliOptions } from "./parser";
+import { shouldRunInteractive, promptConfigOnlyOptions, promptHomeOptions } from "../ui/prompts";
+import { DEFAULTS } from "./schema";
+
+export async function resolveOptions(argv: string[], env: NodeJS.ProcessEnv): Promise<CliOptions> {
+  const parsed = parseCliOptions(argv, env);
+
+  if (parsed.mode === "home") {
+    parsed.repositorySearch = parsed.repositorySearch ?? DEFAULTS.home.repositorySearch;
+    parsed.basePath = parsed.basePath ?? parsed.docsPath ?? DEFAULTS.home.basePath;
+  }
+
+  const runHomeInteractive = parsed.isInteractive || (shouldRunInteractive(argv) && parsed.mode === "home");
+  if (runHomeInteractive && parsed.mode === "home") {
+    return promptHomeOptions(parsed);
+  }
+
+  const runConfigInteractive = parsed.isInteractive || (shouldRunInteractive(argv) && parsed.mode === "config-only");
+  if (runConfigInteractive && parsed.mode === "config-only") {
+    return promptConfigOnlyOptions(parsed);
+  }
+
+  return parsed;
+}

package/presentation/options/schema.ts

@@ -0,0 +1,10 @@
+export const DEFAULTS = {
+  outputDir: "gitpagedocs",
+  repositorySearch: false,
+  basePath: "",
+  home: {
+    outputDir: "gitpagedocshome",
+    repositorySearch: false,
+    basePath: "",
+  },
+} as const;

package/presentation/ui/banner.ts

@@ -0,0 +1,13 @@
+export function printBanner(): void {
+  console.log("");
+  console.log("  Git Page Docs");
+  console.log("  by Vidigal-code");
+  console.log("  https://github.com/Vidigal-code/git-page-docs");
+  console.log("");
+}
+
+export function printCredits(): void {
+  console.log("");
+  console.log("  Powered by Vidigal-code - git-page-docs");
+  console.log("");
+}