@gitpagedocs/cli 1.1.61 → 1.1.63

package/presentation/ui/prompts.ts

@@ -1,138 +1,146 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { execSync } from "node:child_process";
-import type { CliOptions } from "../../domain/models/cli-options";
-import { DEFAULTS } from "../options/schema";
-import { askText, askConfirm, note } from "./clack";
-
-function isCiOrNonTty(): boolean {
-  if (process.env.CI === "true") return true;
-  if (process.env.GITHUB_ACTIONS === "true") return true;
-  if (process.stdin && !process.stdin.isTTY) return true;
-  return false;
-}
-
-/** True when clack prompts can run (interactive TTY, not CI). */
-export function interactivePromptsAvailable(): boolean {
-  return !isCiOrNonTty();
-}
-
-export function shouldRunInteractive(argv: string[]): boolean {
-  if (isCiOrNonTty()) return false;
-  const args = argv.slice(2);
-  if (args.includes("--interactive") || args.includes("-i")) return true;
-  if (args.length === 0) return true;
-  if (args.length === 1 && args[0] === "--home") return true;
-  return false;
-}
-
-export async function promptHomeOptions(parsed: CliOptions): Promise<CliOptions> {
-  const outputDir = await askText({
-    message: "Output directory:",
-    defaultValue: parsed.outputDir ?? DEFAULTS.home.outputDir,
-    validate: (v) => (v && v.trim() ? undefined : "Required"),
-  });
-  const repositorySearch = await askConfirm(
-    "Enable repository search home?",
-    parsed.repositorySearch ?? DEFAULTS.repositorySearch,
-  );
-  const basePath = await askText({
-    message: "Base path (e.g. git-page-docs, empty for root):",
-    defaultValue: parsed.basePath ?? DEFAULTS.basePath,
-  });
-
-  return {
-    ...parsed,
-    outputDir: outputDir.trim(),
-    repositorySearch,
-    basePath: basePath?.trim() ?? "",
-  };
-}
-
-/**
- * Deploy/--push needs a GitHub owner + repo. When they are missing, prompt for
- * them (pre-filled from the git `origin` remote when available) instead of
- * crashing with "`--push` requires owner and repo".
- */
-export async function askOwnerRepo(
-  detected: { owner: string; repo: string } | null,
-  defaults?: { owner?: string; repo?: string },
-): Promise<{ owner: string; repo: string }> {
-  const owner = await askText({
-    message: "GitHub owner (user or organization):",
-    defaultValue: defaults?.owner || detected?.owner || "",
-    validate: (v) => (v && v.trim() ? undefined : "Owner is required."),
-  });
-  const repo = await askText({
-    message: "GitHub repository name:",
-    defaultValue: defaults?.repo || detected?.repo || "",
-    validate: (v) => (v && v.trim() ? undefined : "Repository is required."),
-  });
-  return { owner: owner.trim(), repo: repo.trim() };
-}
-
-export async function promptDeployOptions(
-  parsed: CliOptions,
-  detected: { owner: string; repo: string } | null,
-): Promise<CliOptions> {
-  note(
-    "Deploy publishes gitpagedocs to GitHub Pages and needs the target\nrepository (owner/repo). Press Enter to accept a detected value.",
-    "GitHub Pages deploy",
-  );
-  const { owner, repo } = await askOwnerRepo(detected, {
-    owner: parsed.githubOwner,
-    repo: parsed.githubRepo,
-  });
-
-  return {
-    ...parsed,
-    githubOwner: owner,
-    githubRepo: repo,
-  };
-}
-
-/**
- * Deploy/--push needs a git repository in the current folder. When there isn't
- * one, offer to run `git init` instead of crashing with "not a git repository".
- * In CI/non-TTY this is a no-op so the downstream guard still reports clearly.
- */
-export async function ensureGitRepoInteractive(root: string): Promise<void> {
-  if (existsSync(path.join(root, ".git"))) return;
-  if (!interactivePromptsAvailable()) return;
-  const init = await askConfirm(
-    "This folder is not a git repository yet. Initialize one here (git init)?",
-    true,
-  );
-  if (!init) {
-    note("Deploy needs a git repository. Run `git init`, then retry.", "Heads up");
-    return;
-  }
-  try {
-    execSync("git init", { cwd: root, stdio: "ignore" });
-    note("Initialized an empty git repository.", "git");
-  } catch {
-    note("Could not run `git init`. Initialize git manually, then retry.", "git");
-  }
-}
-
-export async function promptConfigOnlyOptions(parsed: CliOptions): Promise<CliOptions> {
-  const useLocalLayoutConfig = await askConfirm(
-    "Generate local layout templates?",
-    parsed.useLocalLayoutConfig ?? false,
-  );
-  const githubOwner = await askText({
-    message: "GitHub owner (optional):",
-    defaultValue: parsed.githubOwner ?? "",
-  });
-  const githubRepo = await askText({
-    message: "GitHub repo (optional):",
-    defaultValue: parsed.githubRepo ?? "",
-  });
-
-  return {
-    ...parsed,
-    useLocalLayoutConfig,
-    githubOwner: githubOwner?.trim() ?? "",
-    githubRepo: githubRepo?.trim() ?? "",
-  };
-}
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+import type { CliOptions } from "../../domain/models/cli-options";
+import { DEFAULTS } from "../options/schema";
+import { askText, askConfirm, note } from "./clack";
+import { interactivePromptsAvailable, promptingEnabled } from "./tty";
+import { askLayoutsSource, askLayoutsDir } from "./layouts-prompts";
+
+export { interactivePromptsAvailable };
+
+/**
+ * Every command prompts when it runs in a real terminal, so a bare invocation
+ * reflects what the user actually needs instead of silently taking defaults.
+ * CI, a piped stdin, and an explicit `--no-interactive` / `--yes` / `-y` opt out;
+ * `--interactive` / `-i` remains accepted and reads the same either way.
+ */
+export function shouldRunInteractive(argv: string[]): boolean {
+  return promptingEnabled(argv.slice(2));
+}
+
+export async function promptHomeOptions(parsed: CliOptions): Promise<CliOptions> {
+  const outputDir = await askText({
+    message: "Output directory:",
+    defaultValue: parsed.outputDir ?? DEFAULTS.home.outputDir,
+    validate: (v) => (v && v.trim() ? undefined : "Required"),
+  });
+  const repositorySearch = await askConfirm(
+    "Enable repository search home?",
+    parsed.repositorySearch ?? DEFAULTS.repositorySearch,
+  );
+  const basePath = await askText({
+    message: "Base path (e.g. git-page-docs, empty for root):",
+    defaultValue: parsed.basePath ?? DEFAULTS.basePath,
+  });
+
+  return {
+    ...parsed,
+    outputDir: outputDir.trim(),
+    repositorySearch,
+    basePath: basePath?.trim() ?? "",
+  };
+}
+
+/**
+ * Deploy/--push needs a GitHub owner + repo. When they are missing, prompt for
+ * them (pre-filled from the git `origin` remote when available) instead of
+ * crashing with "`--push` requires owner and repo".
+ */
+export async function askOwnerRepo(
+  detected: { owner: string; repo: string } | null,
+  defaults?: { owner?: string; repo?: string },
+): Promise<{ owner: string; repo: string }> {
+  const owner = await askText({
+    message: "GitHub owner (user or organization):",
+    defaultValue: defaults?.owner || detected?.owner || "",
+    validate: (v) => (v && v.trim() ? undefined : "Owner is required."),
+  });
+  const repo = await askText({
+    message: "GitHub repository name:",
+    defaultValue: defaults?.repo || detected?.repo || "",
+    validate: (v) => (v && v.trim() ? undefined : "Repository is required."),
+  });
+  return { owner: owner.trim(), repo: repo.trim() };
+}
+
+export async function promptDeployOptions(
+  parsed: CliOptions,
+  detected: { owner: string; repo: string } | null,
+): Promise<CliOptions> {
+  note(
+    "Deploy publishes gitpagedocs to GitHub Pages and needs the target\nrepository (owner/repo). Press Enter to accept a detected value.",
+    "GitHub Pages deploy",
+  );
+  const { owner, repo } = await askOwnerRepo(detected, {
+    owner: parsed.githubOwner,
+    repo: parsed.githubRepo,
+  });
+
+  return {
+    ...parsed,
+    githubOwner: owner,
+    githubRepo: repo,
+  };
+}
+
+/**
+ * Deploy/--push needs a git repository in the current folder. When there isn't
+ * one, offer to run `git init` instead of crashing with "not a git repository".
+ * In CI/non-TTY this is a no-op so the downstream guard still reports clearly.
+ */
+export async function ensureGitRepoInteractive(root: string): Promise<void> {
+  if (existsSync(path.join(root, ".git"))) return;
+  if (!interactivePromptsAvailable()) return;
+  const init = await askConfirm(
+    "This folder is not a git repository yet. Initialize one here (git init)?",
+    true,
+  );
+  if (!init) {
+    note("Deploy needs a git repository. Run `git init`, then retry.", "Heads up");
+    return;
+  }
+  try {
+    execSync("git init", { cwd: root, stdio: "ignore" });
+    note("Initialized an empty git repository.", "git");
+  } catch {
+    note("Could not run `git init`. Initialize git manually, then retry.", "git");
+  }
+}
+
+/**
+ * Ask only for what the command line did not already answer, so an explicit
+ * flag is never second-guessed by a prompt.
+ */
+export async function promptConfigOnlyOptions(parsed: CliOptions): Promise<CliOptions> {
+  const useLocalLayoutConfig = parsed.explicit.useLocalLayoutConfig
+    ? parsed.useLocalLayoutConfig
+    : await askLayoutsSource(parsed.useLocalLayoutConfig ?? false);
+
+  const layoutsDir =
+    useLocalLayoutConfig && !parsed.explicit.layoutsDir
+      ? await askLayoutsDir(parsed.layoutsDir)
+      : parsed.layoutsDir;
+
+  const githubOwner = parsed.explicit.githubOwner
+    ? parsed.githubOwner
+    : await askText({
+        message: "GitHub owner (optional):",
+        defaultValue: parsed.githubOwner ?? "",
+      });
+
+  const githubRepo = parsed.explicit.githubRepo
+    ? parsed.githubRepo
+    : await askText({
+        message: "GitHub repo (optional):",
+        defaultValue: parsed.githubRepo ?? "",
+      });
+
+  return {
+    ...parsed,
+    useLocalLayoutConfig,
+    layoutsDir,
+    githubOwner: githubOwner?.trim() ?? "",
+    githubRepo: githubRepo?.trim() ?? "",
+  };
+}

package/presentation/ui/tty.ts

@@ -0,0 +1,37 @@
+/**
+ * Terminal capability detection.
+ *
+ * Kept in its own module so every prompt module can ask "may I prompt?" without
+ * importing the prompt modules themselves (which would be circular).
+ */
+
+/** Environment variables that mark a non-interactive automated run. */
+const CI_ENV_FLAGS = ["CI", "GITHUB_ACTIONS"] as const;
+
+/** Flags that explicitly opt out of prompting. */
+export const NON_INTERACTIVE_FLAGS = ["--no-interactive", "--yes", "-y"] as const;
+
+function isCiOrNonTty(): boolean {
+  for (const flag of CI_ENV_FLAGS) {
+    if (process.env[flag] === "true") return true;
+  }
+  return Boolean(process.stdin && !process.stdin.isTTY);
+}
+
+/** True when clack prompts can run (interactive TTY, not CI). */
+export function interactivePromptsAvailable(): boolean {
+  return !isCiOrNonTty();
+}
+
+/** True when the user explicitly asked for a non-interactive run. */
+export function promptingOptedOut(args: readonly string[]): boolean {
+  return NON_INTERACTIVE_FLAGS.some((flag) => args.includes(flag));
+}
+
+/**
+ * True when prompts should run for this invocation: a real terminal, and no
+ * explicit opt-out.
+ */
+export function promptingEnabled(args: readonly string[]): boolean {
+  return interactivePromptsAvailable() && !promptingOptedOut(args);
+}

package/runtime/git-ops.mjs

@@ -1,110 +1,110 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { execSync } from "node:child_process";
-
-/** Detect { owner, repo } from the git `origin` remote URL, or null. */
-export function detectRepoFromGit(root) {
-  try {
-    const url = execSync("git remote get-url origin", { cwd: root, stdio: "pipe" }).toString().trim();
-    const match = url.match(/[:/]([^/:]+)\/([^/]+?)(?:\.git)?$/);
-    if (match) return { owner: match[1], repo: match[2] };
-  } catch {
-    // no remote / not a repo
-  }
-  return null;
-}
-
-export function tryConfigurePagesToGitHubActions(owner, repo, branch, root) {
-  try {
-    execSync("gh --version", { cwd: root, stdio: "ignore" });
-  } catch {
-    console.warn(
-      "GitHub CLI (gh) not found. Could not auto-configure Pages source. Set GitHub Pages source to 'GitHub Actions' manually in repository settings.",
-    );
-    return;
-  }
-
-  const candidates = [
-    `gh api -X PUT "repos/${owner}/${repo}/pages" -f build_type=workflow`,
-    `gh api -X POST "repos/${owner}/${repo}/pages" -f build_type=workflow`,
-    `gh api -X POST "repos/${owner}/${repo}/pages" -f source[branch]=${branch} -f source[path]=/`,
-    `gh api -X PUT "repos/${owner}/${repo}/pages" -f source[branch]=${branch} -f source[path]=/ -f build_type=workflow`,
-  ];
-
-  for (const command of candidates) {
-    try {
-      execSync(command, { cwd: root, stdio: "ignore" });
-      console.log("GitHub Pages source configured for GitHub Actions.");
-      return;
-    } catch {
-      // Try next candidate endpoint.
-    }
-  }
-
-  console.warn(
-    "Could not auto-configure Pages source through GitHub API. Set repository Pages source to 'GitHub Actions' manually.",
-  );
-}
-
-export function getCurrentGitBranch(root) {
-  try {
-    const branch = execSync("git branch --show-current", { cwd: root, stdio: "pipe" }).toString().trim();
-    return branch || "main";
-  } catch {
-    return "main";
-  }
-}
-
-export function runGitPushForGeneratedArtifacts(options, root, sanitizeSegment) {
-  const owner = sanitizeSegment(options.githubOwner);
-  const repo = sanitizeSegment(options.githubRepo);
-  if (!owner || !repo) {
-    throw new Error("`--push` requires owner and repo. Use `--owner <owner> --repo <repo>` or `--<owner> --<repo>`.");
-  }
-  if (!existsSync(path.join(root, ".git"))) {
-    throw new Error("Current directory is not a git repository. Initialize git before using --push.");
-  }
-
-  const repoUrl = `https://github.com/${owner}/${repo}.git`;
-  try {
-    execSync("git remote get-url origin", { cwd: root, stdio: "ignore" });
-  } catch {
-    execSync(`git remote add origin "${repoUrl}"`, { cwd: root, stdio: "inherit" });
-  }
-
-  execSync('git add "gitpagedocs" ".github/workflows/gitpagedocs-pages.yml"', { cwd: root, stdio: "inherit" });
-
-  let hasStagedChanges = false;
-  try {
-    execSync("git diff --cached --quiet", { cwd: root, stdio: "ignore" });
-    hasStagedChanges = false;
-  } catch {
-    hasStagedChanges = true;
-  }
-
-  if (!hasStagedChanges) {
-    return;
-  }
-
-  execSync('git commit -m "chore: setup gitpagedocs pages workflow"', { cwd: root, stdio: "inherit" });
-
-  const currentBranch = getCurrentGitBranch(root);
-  try {
-    execSync(`git push -u origin ${currentBranch}`, { cwd: root, stdio: "inherit" });
-    tryConfigurePagesToGitHubActions(owner, repo, currentBranch, root);
-    return;
-  } catch {
-    console.warn("Initial push failed. Trying automatic rebase with remote branch...");
-  }
-
-  try {
-    execSync(`git pull --rebase origin ${currentBranch}`, { cwd: root, stdio: "inherit" });
-    execSync(`git push -u origin ${currentBranch}`, { cwd: root, stdio: "inherit" });
-  } catch {
-    throw new Error(
-      `Failed to push after automatic rebase on branch '${currentBranch}'. Resolve conflicts and run 'git push -u origin ${currentBranch}' manually.`,
-    );
-  }
-
-  tryConfigurePagesToGitHubActions(owner, repo, currentBranch, root);
-}
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { execSync } from "node:child_process";
+
+/** Detect { owner, repo } from the git `origin` remote URL, or null. */
+export function detectRepoFromGit(root) {
+  try {
+    const url = execSync("git remote get-url origin", { cwd: root, stdio: "pipe" }).toString().trim();
+    const match = url.match(/[:/]([^/:]+)\/([^/]+?)(?:\.git)?$/);
+    if (match) return { owner: match[1], repo: match[2] };
+  } catch {
+    // no remote / not a repo
+  }
+  return null;
+}
+
+export function tryConfigurePagesToGitHubActions(owner, repo, branch, root) {
+  try {
+    execSync("gh --version", { cwd: root, stdio: "ignore" });
+  } catch {
+    console.warn(
+      "GitHub CLI (gh) not found. Could not auto-configure Pages source. Set GitHub Pages source to 'GitHub Actions' manually in repository settings.",
+    );
+    return;
+  }
+
+  const candidates = [
+    `gh api -X PUT "repos/${owner}/${repo}/pages" -f build_type=workflow`,
+    `gh api -X POST "repos/${owner}/${repo}/pages" -f build_type=workflow`,
+    `gh api -X POST "repos/${owner}/${repo}/pages" -f source[branch]=${branch} -f source[path]=/`,
+    `gh api -X PUT "repos/${owner}/${repo}/pages" -f source[branch]=${branch} -f source[path]=/ -f build_type=workflow`,
+  ];
+
+  for (const command of candidates) {
+    try {
+      execSync(command, { cwd: root, stdio: "ignore" });
+      console.log("GitHub Pages source configured for GitHub Actions.");
+      return;
+    } catch {
+      // Try next candidate endpoint.
+    }
+  }
+
+  console.warn(
+    "Could not auto-configure Pages source through GitHub API. Set repository Pages source to 'GitHub Actions' manually.",
+  );
+}
+
+export function getCurrentGitBranch(root) {
+  try {
+    const branch = execSync("git branch --show-current", { cwd: root, stdio: "pipe" }).toString().trim();
+    return branch || "main";
+  } catch {
+    return "main";
+  }
+}
+
+export function runGitPushForGeneratedArtifacts(options, root, sanitizeSegment) {
+  const owner = sanitizeSegment(options.githubOwner);
+  const repo = sanitizeSegment(options.githubRepo);
+  if (!owner || !repo) {
+    throw new Error("`--push` requires owner and repo. Use `--owner <owner> --repo <repo>` or `--<owner> --<repo>`.");
+  }
+  if (!existsSync(path.join(root, ".git"))) {
+    throw new Error("Current directory is not a git repository. Initialize git before using --push.");
+  }
+
+  const repoUrl = `https://github.com/${owner}/${repo}.git`;
+  try {
+    execSync("git remote get-url origin", { cwd: root, stdio: "ignore" });
+  } catch {
+    execSync(`git remote add origin "${repoUrl}"`, { cwd: root, stdio: "inherit" });
+  }
+
+  execSync('git add "gitpagedocs" ".github/workflows/gitpagedocs-pages.yml"', { cwd: root, stdio: "inherit" });
+
+  let hasStagedChanges = false;
+  try {
+    execSync("git diff --cached --quiet", { cwd: root, stdio: "ignore" });
+    hasStagedChanges = false;
+  } catch {
+    hasStagedChanges = true;
+  }
+
+  if (!hasStagedChanges) {
+    return;
+  }
+
+  execSync('git commit -m "chore: setup gitpagedocs pages workflow"', { cwd: root, stdio: "inherit" });
+
+  const currentBranch = getCurrentGitBranch(root);
+  try {
+    execSync(`git push -u origin ${currentBranch}`, { cwd: root, stdio: "inherit" });
+    tryConfigurePagesToGitHubActions(owner, repo, currentBranch, root);
+    return;
+  } catch {
+    console.warn("Initial push failed. Trying automatic rebase with remote branch...");
+  }
+
+  try {
+    execSync(`git pull --rebase origin ${currentBranch}`, { cwd: root, stdio: "inherit" });
+    execSync(`git push -u origin ${currentBranch}`, { cwd: root, stdio: "inherit" });
+  } catch {
+    throw new Error(
+      `Failed to push after automatic rebase on branch '${currentBranch}'. Resolve conflicts and run 'git push -u origin ${currentBranch}' manually.`,
+    );
+  }
+
+  tryConfigurePagesToGitHubActions(owner, repo, currentBranch, root);
+}

package/runtime/layouts-migrator.d.mts

@@ -0,0 +1,11 @@
+export interface LayoutsMigrationResult {
+  moved: string[];
+  failed: Array<{ file: string; reason: string }>;
+}
+
+export declare function listFilesRecursively(absoluteDir: string): string[];
+
+export declare function executeLayoutsMigration(
+  root: string,
+  plan: { from: string; to: string; files: string[] },
+): LayoutsMigrationResult;

package/runtime/layouts-migrator.mjs

@@ -0,0 +1,103 @@
+/**
+ * Filesystem side of the legacy layouts migration.
+ *
+ * The decision of *what* moves lives in the domain planner; this module only
+ * reads directories and performs the move, so both halves stay testable on
+ * their own.
+ */
+import {
+  existsSync,
+  readdirSync,
+  statSync,
+  mkdirSync,
+  renameSync,
+  copyFileSync,
+  rmSync,
+} from "node:fs";
+import path from "node:path";
+
+/**
+ * List every file under a directory, as POSIX paths relative to it.
+ *
+ * @param {string} absoluteDir
+ * @returns {string[]} Empty when the directory is absent or unreadable.
+ */
+export function listFilesRecursively(absoluteDir) {
+  if (!absoluteDir || !existsSync(absoluteDir)) return [];
+
+  const found = [];
+  const walk = (currentDir, prefix) => {
+    let entries;
+    try {
+      entries = readdirSync(currentDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const absolute = path.join(currentDir, entry);
+      const relative = prefix ? `${prefix}/${entry}` : entry;
+      let isDirectory = false;
+      try {
+        isDirectory = statSync(absolute).isDirectory();
+      } catch {
+        continue;
+      }
+      if (isDirectory) walk(absolute, relative);
+      else found.push(relative);
+    }
+  };
+
+  walk(absoluteDir, "");
+  return found.sort();
+}
+
+/**
+ * Move one file, falling back to copy + delete when rename is not possible
+ * (different volumes, or a locked handle on Windows).
+ *
+ * @param {string} fromAbsolute
+ * @param {string} toAbsolute
+ */
+function moveFile(fromAbsolute, toAbsolute) {
+  mkdirSync(path.dirname(toAbsolute), { recursive: true });
+  try {
+    renameSync(fromAbsolute, toAbsolute);
+  } catch {
+    copyFileSync(fromAbsolute, toAbsolute);
+    rmSync(fromAbsolute, { force: true });
+  }
+}
+
+/**
+ * Execute a migration plan produced by `planLayoutsMigration`.
+ *
+ * Files are moved one by one so a single failure is reported without aborting
+ * the rest; the legacy folder is removed only once it is genuinely empty.
+ *
+ * @param {string} root Project root the plan's paths are relative to.
+ * @param {{ from: string, to: string, files: string[] }} plan
+ * @returns {{ moved: string[], failed: Array<{ file: string, reason: string }> }}
+ */
+export function executeLayoutsMigration(root, plan) {
+  const moved = [];
+  const failed = [];
+
+  const fromRoot = path.join(root, ...plan.from.split("/"));
+  const toRoot = path.join(root, ...plan.to.split("/"));
+
+  for (const file of plan.files) {
+    const segments = file.split("/");
+    try {
+      moveFile(path.join(fromRoot, ...segments), path.join(toRoot, ...segments));
+      moved.push(file);
+    } catch (error) {
+      failed.push({ file, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+
+  if (failed.length === 0 && listFilesRecursively(fromRoot).length === 0) {
+    rmSync(fromRoot, { recursive: true, force: true });
+  }
+
+  return { moved, failed };
+}