@gitpagedocs/cli 0.0.1

package/ai/presentation/ai-prompts.ts

@@ -0,0 +1,239 @@
+import {
+    AI_MODEL_DEFAULTS,
+    OLLAMA_DEFAULT_BASE_URL,
+    type AiProviderId,
+} from '../config';
+import { PROVIDER_CATALOG, legacyProviderToCatalogId } from '@gitpagedocs/tools/ai';
+import type { AiCliConfig, AiCliRunPlan } from '../core/models/ai-cli-config';
+import {
+    askText,
+    askConfirm,
+    askSelect,
+    askMultiSelect,
+    intro,
+} from '../../presentation/ui/clack';
+
+export interface InteractiveCliAnswers {
+    provider: AiProviderId;
+    apiKeyOrHost: string;
+    model: string;
+    targetDirs: string[];
+    languages: Array<'pt' | 'en' | 'es'>;
+    outputDir: string;
+    filePrefix: string;
+    saveConfig: boolean;
+    runConfigScaffold: boolean;
+    contextPrompt: string;
+}
+
+function parseCommaSeparated(value: string): string[] {
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+
+function validateCommaSeparatedDirectories(value: string): string | undefined {
+    const values = parseCommaSeparated(value);
+    if (!values.length) return 'Provide at least one path.';
+    return undefined;
+}
+
+const CUSTOM_MODEL = '__custom_model__';
+
+/**
+ * Ask for the model as a SELECT of the provider's real catalog models (with the
+ * default marked), plus a "Custom" escape hatch — so an invalid id like "4.8"
+ * can't be typed by mistake and rejected later as a 404 by the provider.
+ */
+async function askModel(provider: AiProviderId): Promise<string> {
+    const catalogId = legacyProviderToCatalogId(provider);
+    const spec = catalogId ? PROVIDER_CATALOG[catalogId] : undefined;
+    const fallback = AI_MODEL_DEFAULTS[provider] || '';
+
+    if (!spec || spec.models.length === 0) {
+        return String(await askText({ message: 'Which model do you want to use?', defaultValue: fallback }));
+    }
+
+    const picked = await askSelect<string>(
+        'Which model do you want to use?',
+        [
+            ...spec.models.map((m) => ({
+                value: m.id,
+                label: m.id === spec.defaultModel ? `${m.id} (default)` : m.id,
+            })),
+            { value: CUSTOM_MODEL, label: 'Custom — enter a model id manually' },
+        ],
+        spec.defaultModel,
+    );
+
+    if (picked !== CUSTOM_MODEL) return picked;
+
+    return String(
+        await askText({
+            message: 'Enter the model id:',
+            defaultValue: spec.defaultModel,
+            validate: (value) => (value.trim() ? undefined : 'Provide a model id'),
+        }),
+    );
+}
+
+function toPlan(answers: InteractiveCliAnswers): AiCliRunPlan {
+    const config: AiCliConfig = {
+        version: 1,
+        ai: {
+            provider: answers.provider,
+            model: answers.model,
+            apiKey: answers.provider === 'ollama' ? undefined : answers.apiKeyOrHost,
+            baseUrl: answers.provider === 'ollama' ? answers.apiKeyOrHost : undefined,
+            paths: answers.targetDirs,
+            languages: answers.languages,
+            outputDir: answers.outputDir,
+            filePrefix: answers.filePrefix,
+            contextPrompt: answers.contextPrompt,
+        },
+    };
+
+    return {
+        config,
+        saveConfig: answers.saveConfig,
+        runConfigScaffold: answers.runConfigScaffold,
+    };
+}
+
+export async function promptMissingDirectories(
+    missingDirectories: string[],
+): Promise<{ replacementPaths: string[]; abort: boolean }> {
+    const recoveryMode = await askSelect(
+        `I couldn't find ${missingDirectories.length} directory(ies): ${missingDirectories.join(', ')}`,
+        [
+            { value: 'fix', label: 'Fix paths now (recommended)' },
+            { value: 'skip', label: 'Skip missing paths and continue' },
+            { value: 'abort', label: 'Abort execution' },
+        ],
+        'fix',
+    );
+
+    if (recoveryMode === 'abort') {
+        return { replacementPaths: [], abort: true };
+    }
+    if (recoveryMode === 'skip') {
+        return { replacementPaths: [], abort: false };
+    }
+
+    const fixedPaths = await askText({
+        message: 'Enter new paths (comma-separated):',
+        validate: validateCommaSeparatedDirectories,
+    });
+
+    return {
+        replacementPaths: parseCommaSeparated(String(fixedPaths || '')),
+        abort: false,
+    };
+}
+
+export async function promptUseExistingConfig(existingConfig: AiCliConfig): Promise<AiCliRunPlan | null> {
+    const useExistingConfig = await askConfirm(
+        'Found .gitpagedocsconfig. Do you want to use this configuration?',
+        true,
+    );
+
+    if (!useExistingConfig) return null;
+
+    const runConfigScaffold = await askConfirm(
+        'Generate the base gitpagedocs structure first, so the AI pages are wired into the docs viewer?',
+        true,
+    );
+
+    return {
+        config: existingConfig,
+        saveConfig: false,
+        runConfigScaffold,
+    };
+}
+
+export async function runAiInteractivePrompt(existingConfig?: AiCliConfig | null): Promise<AiCliRunPlan> {
+    intro('GitPageDocs AI CLI - interactive mode');
+
+    if (existingConfig) {
+        const existingPlan = await promptUseExistingConfig(existingConfig);
+        if (existingPlan) return existingPlan;
+    }
+
+    const provider = await askSelect<AiProviderId>(
+        'Which AI provider should be used to generate documentation?',
+        [
+            { value: 'openai', label: 'OpenAI (GPT)' },
+            { value: 'claude', label: 'Anthropic (Claude)' },
+            { value: 'gemini', label: 'Google Gemini' },
+            { value: 'ollama', label: 'Ollama (Local Open Source)' },
+        ],
+        'openai',
+    );
+
+    const apiKeyOrHost = await askText({
+        message: provider === 'ollama' ? 'Ollama host URL:' : 'Provider API key:',
+        defaultValue: provider === 'ollama' ? OLLAMA_DEFAULT_BASE_URL : undefined,
+        validate: (input) => (input.length > 0 ? undefined : 'Required field'),
+    });
+
+    const model = await askModel(provider);
+
+    const targetDirsRaw = await askText({
+        message:
+            'Paths to analyze (comma-separated). You can include multiple repositories (e.g., src,cli,../other-repo/src):',
+        defaultValue: 'src,cli',
+        validate: validateCommaSeparatedDirectories,
+    });
+
+    const languages = await askMultiSelect<'en' | 'pt' | 'es'>(
+        'Documentation languages to generate:',
+        [
+            { value: 'en', label: 'English (en)' },
+            { value: 'pt', label: 'Portuguese (pt)' },
+            { value: 'es', label: 'Español (es)' },
+        ],
+        ['en', 'pt', 'es'],
+    );
+
+    const outputDir = await askText({
+        message: 'Output directory for generated markdown files:',
+        defaultValue: 'gitpagedocs/docs',
+        validate: (value) => (value.trim() ? undefined : 'Provide an output directory'),
+    });
+
+    const filePrefix = await askText({
+        message: 'Output file prefix:',
+        defaultValue: 'ai-generated',
+        validate: (value) => (value.trim() ? undefined : 'Provide a prefix'),
+    });
+
+    const contextPrompt = await askText({
+        message: 'Extra instructions for AI (optional):',
+        defaultValue:
+            'You are a senior technical writer. Generate professional, clear documentation with architectural insight following FSD, SOLID, and Clean Code principles.',
+    });
+
+    const saveConfig = await askConfirm(
+        'Save this configuration to .gitpagedocsconfig for future manual use?',
+        true,
+    );
+
+    const runConfigScaffold = await askConfirm(
+        'Generate the base gitpagedocs structure first, so the AI pages are wired into the docs viewer?',
+        true,
+    );
+
+    return toPlan({
+        provider,
+        apiKeyOrHost,
+        model,
+        targetDirs: parseCommaSeparated(targetDirsRaw),
+        languages,
+        outputDir,
+        filePrefix,
+        contextPrompt,
+        saveConfig,
+        runConfigScaffold,
+    });
+}

package/application/config-only/handler.mjs

@@ -0,0 +1,57 @@
+/** Config-only use case - orchestrates build, write, and optional push */
+
+import { sanitizeSegment } from "../../domain/services/sanitize-segment.mjs";
+import { reportAll } from "../report/config-only-reporter.mjs";
+
+/**
+ * Execute config-only use case
+ * @param {Object} params
+ * @param {Object} params.options - Parsed CLI options
+ * @param {string} params.root - Project root
+ * @param {string} params.pkgRoot - Package root
+ * @param {string} params.prebuiltDir - Prebuilt directory path
+ * @param {Function} params.buildConfigArtifacts - Artifact builder
+ * @param {Function} params.createThemeTemplate - Theme template creator
+ * @param {Array} params.layouts - Layout definitions
+ * @param {import("../ports/cli-runtime-ports").ConfigOnlyRuntimePort} runtime
+ */
+export async function executeConfigOnly(params, runtime) {
+  if (!runtime) {
+    throw new Error("Config-only runtime is required.");
+  }
+
+  const { options, root, pkgRoot, prebuiltDir, buildConfigArtifacts, createThemeTemplate, layouts } = params;
+
+  const artifacts = buildConfigArtifacts({
+    useLocalLayoutConfig: options.useLocalLayoutConfig,
+    layoutsDir: options.layoutsDir,
+    githubOwner: sanitizeSegment(options.githubOwner),
+    githubRepo: sanitizeSegment(options.githubRepo),
+    root,
+  });
+
+  await runtime.writeConfigOnlyOutput({
+    root,
+    pkgRoot,
+    outputDir: options.outputDir,
+    layoutsDir: options.layoutsDir,
+    artifacts,
+    useLocalLayoutConfig: options.useLocalLayoutConfig,
+    layouts,
+    createThemeTemplate,
+  });
+
+  if (options.shouldPush) {
+    await runtime.ensureGitHubPagesWorkflow(
+      () => runtime.getCurrentGitBranch(root),
+      (relativePath, content) => runtime.writeText(root, relativePath, content),
+      options.docsPath || "",
+    );
+    runtime.runGitPushForGeneratedArtifacts(options, root, sanitizeSegment);
+  }
+
+  const reportLines = reportAll(options, runtime.hasPath(prebuiltDir));
+  for (const line of reportLines) {
+    runtime.logInfo(line);
+  }
+}

package/application/home/handler.mjs

@@ -0,0 +1,87 @@
+/** Home distribution use case - static site + auxiliary files */
+
+import { STATIC_OUTPUT_DIR, ARTIFACTS_DIR } from "../../home/constants.mjs";
+import { trimSlashes } from "../../contracts/path-segments.mjs";
+
+/**
+ * Execute home distribution use case
+ * @param {Object} params
+ * @param {Object} params.options - Parsed CLI options
+ * @param {string} params.root - Project root
+ * @param {string} params.pkgRoot - Package root
+ * @param {Function} params.buildConfigArtifacts - Artifact builder
+ * @param {Function} params.createThemeTemplate - Theme template creator
+ * @param {Array} params.layouts - Layout definitions
+ * @param {import("../ports/cli-runtime-ports").HomeRuntimePort} runtime
+ */
+export async function executeHome(params, runtime) {
+  if (!runtime) {
+    throw new Error("Home runtime is required.");
+  }
+
+  const { options, root, pkgRoot, buildConfigArtifacts, createThemeTemplate, layouts } = params;
+  const outputDir = options.outputDir || "gitpagedocshome";
+  const repositorySearch = options.repositorySearch ?? false;
+  const basePath = options.basePath ?? "";
+
+  const isCurrentDir = outputDir === "." || outputDir === "./";
+  const targetDir = isCurrentDir ? root : runtime.joinPath(root, outputDir);
+
+  if (!isCurrentDir) {
+    runtime.ensureDirEmpty(root, outputDir);
+  }
+
+  const pathSegment = basePath ? trimSlashes(basePath) : "";
+  const buildEnv = {
+    ...process.env,
+    GITHUB_ACTIONS: "true",
+    GITPAGEDOCS_REPOSITORY_SEARCH: String(repositorySearch),
+    GITPAGEDOCS_BASE_PATH: pathSegment ? `/${pathSegment}` : "/",
+    GITPAGEDOCS_PATH: pathSegment,
+  };
+
+  const artifacts = buildConfigArtifacts({
+    useLocalLayoutConfig: false,
+    layoutsDir: options.layoutsDir,
+    githubOwner: "",
+    githubRepo: "",
+    root,
+  });
+
+  await runtime.writeConfigOnlyOutput({
+    root,
+    pkgRoot,
+    outputDir: ARTIFACTS_DIR,
+    layoutsDir: options.layoutsDir,
+    artifacts,
+    useLocalLayoutConfig: false,
+    layouts,
+    createThemeTemplate,
+  });
+
+  runtime.runNextBuild(root, buildEnv);
+
+  const outPath = runtime.joinPath(root, STATIC_OUTPUT_DIR);
+  if (!runtime.existsPath(outPath)) {
+    throw new Error(`Static export not found at ${STATIC_OUTPUT_DIR}/. Ensure next.config exports when GITHUB_ACTIONS=true.`);
+  }
+
+  const destBase = isCurrentDir ? root : targetDir;
+  if (isCurrentDir) {
+    for (const name of runtime.readDirNames(outPath)) {
+      runtime.copyRecursive(runtime.joinPath(outPath, name), runtime.joinPath(destBase, name));
+    }
+  } else {
+    runtime.copyRecursive(outPath, destBase);
+  }
+  runtime.copyRecursive(runtime.joinPath(root, ARTIFACTS_DIR), runtime.joinPath(destBase, ARTIFACTS_DIR));
+
+  await runtime.writeHomeFiles(root, isCurrentDir ? "." : outputDir, { repositorySearch, basePath });
+  await runtime.writeText(root, (isCurrentDir ? "" : outputDir + "/") + ".nojekyll", "");
+
+  const cdDir = isCurrentDir ? "." : outputDir;
+  runtime.logSuccess(`Generated: ${cdDir}/ (static site + .env + Dockerfile + README.md)`);
+  runtime.logInfo(`Serve: cd ${cdDir} && npx serve .`);
+  runtime.logInfo(`Docker: cd ${cdDir} && docker build -t gitpagedocshome . && docker run -p 3000:80 gitpagedocshome`);
+}
+

package/application/ports/cli-runtime-ports.ts

@@ -0,0 +1,93 @@
+import type { CliOptions } from "../../domain/models/cli-options";
+
+export interface BuildArtifactsInput {
+  useLocalLayoutConfig: boolean;
+  /** Repo-relative layouts home the generated config should reference. */
+  layoutsDir: string;
+  githubOwner: string;
+  githubRepo: string;
+  root: string;
+}
+
+export interface LayoutDefinition {
+  file: string;
+  [key: string]: unknown;
+}
+
+export interface BuiltConfigArtifacts {
+  rootConfig: unknown;
+  /** UI-string bundle per language, written to `<outputDir>/langs/<lang>.json`. */
+  languageBundles: Record<string, unknown>;
+  layoutsConfig: unknown;
+  fallbackLayoutsConfig: unknown;
+  docs?: Record<string, Record<string, string>>;
+  docsHtml?: Record<string, Record<string, string>>;
+  versionConfigs: Record<string, Record<string, unknown>>;
+}
+
+export interface CliRuntimeParams {
+  root: string;
+  pkgRoot: string;
+  prebuiltDir: string;
+  buildConfigArtifacts: (input: BuildArtifactsInput) => BuiltConfigArtifacts;
+  createThemeTemplate: (layout: LayoutDefinition) => unknown;
+  layouts: LayoutDefinition[];
+}
+
+export interface CliCommandContext extends CliRuntimeParams {
+  options: CliOptions;
+}
+
+export interface CliCommandRunner {
+  runConfigOnly: (params: CliCommandContext) => Promise<void>;
+  runHome: (params: CliCommandContext) => Promise<void>;
+  runAi: (params: CliCommandContext) => Promise<void>;
+}
+
+export interface ConfigOnlyOutputInput {
+  root: string;
+  pkgRoot: string;
+  outputDir: string;
+  /** Repo-relative layouts home local layouts are written to. */
+  layoutsDir: string;
+  artifacts: BuiltConfigArtifacts;
+  useLocalLayoutConfig: boolean;
+  layouts: LayoutDefinition[];
+  createThemeTemplate: (layout: LayoutDefinition) => unknown;
+}
+
+export interface ConfigOnlyRuntimePort {
+  hasPath: (absolutePath: string) => boolean;
+  writeConfigOnlyOutput: (input: ConfigOnlyOutputInput) => Promise<void>;
+  writeText: (root: string, relativePath: string, data: string) => Promise<void>;
+  ensureGitHubPagesWorkflow: (
+    getCurrentGitBranch: () => string,
+    writeText: (relativePath: string, content: string) => Promise<void>,
+    docsPath?: string,
+  ) => Promise<void>;
+  getCurrentGitBranch: (root: string) => string;
+  runGitPushForGeneratedArtifacts: (
+    options: CliOptions,
+    root: string,
+    sanitizeSegment: (value: string | undefined | null) => string,
+  ) => void;
+  logInfo: (message: string) => void;
+}
+
+export interface HomeRuntimePort {
+  joinPath: (...parts: string[]) => string;
+  ensureDirEmpty: (root: string, relativeDir: string) => void;
+  copyRecursive: (src: string, dest: string) => void;
+  readDirNames: (absolutePath: string) => string[];
+  existsPath: (absolutePath: string) => boolean;
+  runNextBuild: (root: string, env: NodeJS.ProcessEnv) => void;
+  writeConfigOnlyOutput: (input: ConfigOnlyOutputInput) => Promise<void>;
+  writeHomeFiles: (
+    root: string,
+    outputDir: string,
+    options: { repositorySearch?: boolean; basePath?: string },
+  ) => Promise<void>;
+  writeText: (root: string, relativePath: string, data: string) => Promise<void>;
+  logSuccess: (message: string) => void;
+  logInfo: (message: string) => void;
+}

package/application/report/config-only-reporter.mjs

@@ -0,0 +1,68 @@
+/** Config-only command output messages - SRP: single place for all report messages */
+import { resolveRenderingUrl } from "../../builders/project-links.mjs";
+import { normalizeLayoutsDir } from "../../contracts/layouts-paths.mjs";
+import { languageArtifactPaths } from "../../contracts/langs-paths.mjs";
+import { SUPPORTED_LANGUAGES } from "../../contracts/languages.mjs";
+
+export function reportConfigOnlySuccess(options) {
+  const langs = languageArtifactPaths(options.outputDir);
+  return [
+    `Generated: ${options.outputDir}/ (config-only)`,
+    `UI strings: ${langs.dir}/{${SUPPORTED_LANGUAGES.join(",")}}.json (enable/disable each language in ${langs.config} -> site.languages)`,
+    "No index.html/index.js generated.",
+  ];
+}
+
+export function reportLayoutConfig(options) {
+  const layoutsDir = normalizeLayoutsDir(options.layoutsDir);
+  if (options.useLocalLayoutConfig) {
+    return [`Local layouts generated in ${layoutsDir}/ (--layoutconfig).`];
+  }
+  return [`Using official remote layouts config by default (no local ${layoutsDir}/ generated).`];
+}
+
+export function reportRenderingUrl(options) {
+  if (options.githubOwner && options.githubRepo) {
+    return [
+      `Configured rendering URL: ${resolveRenderingUrl(options.githubOwner, options.githubRepo)}`,
+      `Official viewer remains available: https://vidigal-code.github.io/git-page-docs/${options.githubOwner}/${options.githubRepo}?modetheme=light&lang=pt`,
+    ];
+  }
+  return [];
+}
+
+export function reportPushMode() {
+  return [
+    "Generated: .github/workflows/gitpagedocs-pages.yml",
+    "Push mode enabled: committed and pushed gitpagedocs/ + workflow to origin.",
+  ];
+}
+
+export function reportBuildFlag() {
+  return ["`--build` keeps compatibility flag but output remains gitpagedocs/."];
+}
+
+export function reportFullOrServeSkipped() {
+  return ["External commands were skipped (no prebuilt copy and no local serve spawn)."];
+}
+
+export function reportPrebuiltDetected() {
+  return ["`prebuilt/` detected, but ignored by config-only generator."];
+}
+
+export function reportAll(options, prebuiltDetected) {
+  const lines = [...reportConfigOnlySuccess(options), ...reportLayoutConfig(options), ...reportRenderingUrl(options)];
+  if (options.shouldPush) {
+    lines.push(...reportPushMode());
+  }
+  if (options.isBuild) {
+    lines.push(...reportBuildFlag());
+  }
+  if (options.mode === "full" || options.isServe) {
+    lines.push(...reportFullOrServeSkipped());
+  }
+  if (prebuiltDetected) {
+    lines.push(...reportPrebuiltDetected());
+  }
+  return lines;
+}

package/application/use-cases/dispatch-mode.ts

@@ -0,0 +1,18 @@
+import type { CliOptions } from "../../domain/models/cli-options";
+import type { CliCommandRunner, CliRuntimeParams } from "../ports/cli-runtime-ports";
+
+export async function dispatchMode(
+  options: CliOptions,
+  params: CliRuntimeParams,
+  runner: CliCommandRunner,
+): Promise<void> {
+  if (options.mode === "ai") {
+    await runner.runAi({ ...params, options });
+    return;
+  }
+  if (options.mode === "home") {
+    await runner.runHome({ ...params, options });
+    return;
+  }
+  await runner.runConfigOnly({ ...params, options });
+}

package/builders/config-orchestrator.mjs

@@ -0,0 +1,35 @@
+/** Orchestrate build of config artifacts for gitpagedocs */
+
+import { LAYOUTS, FALLBACK_LAYOUTS } from "../data/layouts.mjs";
+import { DOCS } from "../content/docs.mjs";
+import { DOC_VERSIONS } from "../data/version-constants.mjs";
+import { buildRootConfig } from "./root-config-builder.mjs";
+import { buildVersionConfig } from "./version-config-builder.mjs";
+import { buildLanguageArtifacts } from "./language-bundles-builder.mjs";
+
+/**
+ * Build all config artifacts (root, languages, layouts, versions, docs).
+ * @param {object} options - { useLocalLayoutConfig, githubOwner, githubRepo, layoutsDir }
+ * @returns {object} { rootConfig, languageBundles, layoutsConfig, fallbackLayoutsConfig, docs, docsHtml, versionConfigs }
+ */
+export function buildConfigArtifacts(options = {}) {
+  const { languageToggles, languageBundles } = buildLanguageArtifacts();
+  const rootConfig = buildRootConfig({ ...options, languageToggles });
+  const layoutsConfig = { layouts: LAYOUTS };
+  const fallbackLayoutsConfig = { layouts: FALLBACK_LAYOUTS };
+
+  const versionConfigs = {};
+  for (const versionId of DOC_VERSIONS) {
+    versionConfigs[versionId] = buildVersionConfig(versionId, options);
+  }
+
+  return {
+    rootConfig,
+    languageBundles,
+    layoutsConfig,
+    fallbackLayoutsConfig,
+    docs: DOCS,
+    docsHtml: {},
+    versionConfigs,
+  };
+}

package/builders/language-bundles-builder.mjs

@@ -0,0 +1,24 @@
+/** Build the `site.languages` toggles + per-language UI string bundles for gitpagedocs */
+import { buildLanguageToggles, splitLanguageBundles } from "@gitpagedocs/tools/i18n";
+import { SUPPORTED_LANGUAGES } from "../contracts/languages.mjs";
+import { defaultLangMenu } from "../data/i18n-langmenu.mjs";
+import { defaultTranslations } from "../data/i18n-translations.mjs";
+
+function assertLanguageStrings(languages) {
+  const missing = languages.filter((language) => !defaultLangMenu[language]);
+  if (missing.length > 0) {
+    throw new Error(`No UI strings (i18n-langmenu) for supported language(s): ${missing.join(", ")}`);
+  }
+}
+
+/**
+ * @returns {{ languageToggles: Record<string, boolean>, languageBundles: Record<string, object> }}
+ */
+export function buildLanguageArtifacts() {
+  const languages = [...SUPPORTED_LANGUAGES];
+  assertLanguageStrings(languages);
+  return {
+    languageToggles: buildLanguageToggles(languages),
+    languageBundles: splitLanguageBundles(languages, defaultLangMenu, defaultTranslations),
+  };
+}

package/builders/project-links.mjs

@@ -0,0 +1,50 @@
+/** Shared derivation of project URLs from CLI options (single source of truth
+ * for root and version config builders). */
+
+import { layoutsArtifactPaths } from "../contracts/layouts-paths.mjs";
+
+export const DEFAULT_PROJECT_LINK = "https://github.com/Vidigal-code/git-page-docs";
+export const DEFAULT_RENDERING_URL = "https://vidigal-code.github.io/git-page-docs/";
+
+export function resolveProjectLink(githubOwner, githubRepo) {
+  return githubOwner && githubRepo
+    ? `https://github.com/${githubOwner}/${githubRepo}`
+    : DEFAULT_PROJECT_LINK;
+}
+
+export function resolveRenderingUrl(githubOwner, githubRepo) {
+  return githubOwner && githubRepo
+    ? `https://${githubOwner}.github.io/${githubRepo}/`
+    : DEFAULT_RENDERING_URL;
+}
+
+/**
+ * Where the viewer should look for locally generated layouts.
+ *
+ * Mirrors resolveSourceViewerPath: user repositories use the symbolic HEAD ref
+ * so any default branch resolves. Without an owner/repo pair there is no URL to
+ * build, so the repo-relative path is returned - the viewer reads it directly in
+ * local mode and still discovers it by probing the repository otherwise.
+ *
+ * @param {string} githubOwner
+ * @param {string} githubRepo
+ * @param {string} layoutsDir Repo-relative layouts home.
+ * @returns {{ config: string, templates: string }}
+ */
+export function resolveLayoutsLinks(githubOwner, githubRepo, layoutsDir) {
+  const paths = layoutsArtifactPaths(layoutsDir);
+  if (!githubOwner || !githubRepo) {
+    return { config: paths.config, templates: paths.templates };
+  }
+  const base = `${resolveProjectLink(githubOwner, githubRepo)}/blob/HEAD`;
+  return { config: `${base}/${paths.config}`, templates: `${base}/${paths.templates}` };
+}
+
+export function resolveSourceViewerPath(githubOwner, githubRepo) {
+  // User repositories use the symbolic HEAD ref so any default branch works
+  // (github.com, the trees API and raw.githubusercontent all accept it);
+  // the official repository keeps its stable main link.
+  return githubOwner && githubRepo
+    ? `${resolveProjectLink(githubOwner, githubRepo)}/tree/HEAD`
+    : `${DEFAULT_PROJECT_LINK}/tree/main`;
+}