@aspruyt/xfg 3.8.2 → 3.9.1

package/dist/cli/settings-command.d.ts

@@ -1,5 +1,6 @@
 import { SharedOptions } from "./sync-command.js";
 import { ProcessorFactory, RulesetProcessorFactory, RepoSettingsProcessorFactory } from "./types.js";
+import { type IRepoLifecycleManager } from "../lifecycle/index.js";
 /**
  * Options for the settings command.
  */
@@ -7,4 +8,4 @@ export type SettingsOptions = SharedOptions;
 /**
  * Run the settings command - manages GitHub Rulesets and repo settings.
  */
-export declare function runSettings(options: SettingsOptions, processorFactory?: RulesetProcessorFactory, repoProcessorFactory?: ProcessorFactory, repoSettingsProcessorFactory?: RepoSettingsProcessorFactory): Promise<void>;
+export declare function runSettings(options: SettingsOptions, processorFactory?: RulesetProcessorFactory, repoProcessorFactory?: ProcessorFactory, repoSettingsProcessorFactory?: RepoSettingsProcessorFactory, lifecycleManager?: IRepoLifecycleManager): Promise<void>;

package/dist/cli/settings-command.js

@@ -4,6 +4,7 @@ import chalk from "chalk";
 import { loadRawConfig, normalizeConfig } from "../config/index.js";
 import { validateForSettings } from "../config/validator.js";
 import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../shared/repo-detector.js";
+import { hasGitHubAppCredentials, GitHubAppTokenManager, } from "../vcs/index.js";
 import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
 import { buildErrorResult } from "../output/summary-utils.js";
@@ -11,6 +12,7 @@ import { getManagedRulesets } from "../sync/manifest.js";
 import { formatSettingsReportCLI, writeSettingsReportSummary, } from "../output/settings-report.js";
 import { buildSettingsReport, } from "./settings-report-builder.js";
 import { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
+import { RepoLifecycleManager, runLifecycleCheck, } from "../lifecycle/index.js";
 /**
  * Collects processing results for the SettingsReport.
  * Provides a centralized way to track results across rulesets and repo settings.
@@ -39,12 +41,75 @@ class ResultsCollector {
         return this.results;
     }
 }
+/**
+ * Run lifecycle checks for all unique repos before processing.
+ * Returns a Set of git URLs to skip (lifecycle errors or repos that would be created in dry-run).
+ */
+async function runLifecycleChecks(allRepos, config, options, lifecycleManager, results, collector, tokenManager) {
+    const checked = new Set();
+    const skippedRepos = new Set();
+    for (let i = 0; i < allRepos.length; i++) {
+        const repoConfig = allRepos[i];
+        if (checked.has(repoConfig.git)) {
+            continue;
+        }
+        checked.add(repoConfig.git);
+        let repoInfo;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch {
+            // URL parsing errors are handled in individual processors
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        // Resolve auth token for lifecycle gh commands
+        let lifecycleToken;
+        if (isGitHubRepo(repoInfo)) {
+            try {
+                lifecycleToken =
+                    (await tokenManager?.getTokenForRepo(repoInfo)) ??
+                        process.env.GH_TOKEN;
+            }
+            catch {
+                lifecycleToken = process.env.GH_TOKEN;
+            }
+        }
+        try {
+            const { outputLines, lifecycleResult } = await runLifecycleCheck(repoConfig, repoInfo, i, {
+                dryRun: options.dryRun ?? false,
+                workDir: options.workDir,
+                githubHosts: config.githubHosts,
+                token: lifecycleToken,
+            }, lifecycleManager, config.settings?.repo);
+            for (const line of outputLines) {
+                logger.info(line);
+            }
+            // In dry-run, skip processing repos that don't exist yet
+            if (options.dryRun && lifecycleResult.action !== "existed") {
+                skippedRepos.add(repoConfig.git);
+            }
+        }
+        catch (error) {
+            logger.error(i + 1, repoName, `Lifecycle error: ${error instanceof Error ? error.message : String(error)}`);
+            results.push(buildErrorResult(repoName, error));
+            collector.appendError(repoName, error);
+            skippedRepos.add(repoConfig.git);
+        }
+    }
+    return skippedRepos;
+}
 /**
  * Process rulesets for all configured repositories.
  */
-async function processRulesets(repos, config, options, processor, repoProcessor, results, collector) {
+async function processRulesets(repos, config, options, processor, repoProcessor, results, collector, lifecycleSkipped) {
     for (let i = 0; i < repos.length; i++) {
         const repoConfig = repos[i];
+        if (lifecycleSkipped.has(repoConfig.git)) {
+            continue;
+        }
         let repoInfo;
         try {
             repoInfo = parseGitUrl(repoConfig.git, {
@@ -126,7 +191,7 @@ async function processRulesets(repos, config, options, processor, repoProcessor,
 /**
  * Process repo settings for all configured repositories.
  */
-async function processRepoSettings(repos, config, options, processorFactory, results, collector) {
+async function processRepoSettings(repos, config, options, processorFactory, results, collector, lifecycleSkipped) {
     if (repos.length === 0) {
         return;
     }
@@ -134,6 +199,9 @@ async function processRepoSettings(repos, config, options, processorFactory, res
     console.log(`\nProcessing repo settings for ${repos.length} repositories\n`);
     for (let i = 0; i < repos.length; i++) {
         const repoConfig = repos[i];
+        if (lifecycleSkipped.has(repoConfig.git)) {
+            continue;
+        }
         let repoInfo;
         try {
             repoInfo = parseGitUrl(repoConfig.git, {
@@ -141,7 +209,7 @@ async function processRepoSettings(repos, config, options, processorFactory, res
             });
         }
         catch (error) {
-            console.error(`Failed to parse ${repoConfig.git}: ${error}`);
+            logger.error(i + 1, repoConfig.git, String(error));
             collector.appendError(repoConfig.git, error);
             continue;
         }
@@ -190,7 +258,7 @@ async function processRepoSettings(repos, config, options, processorFactory, res
             }
         }
         catch (error) {
-            console.error(`  ✗ ${repoName}: ${error}`);
+            logger.error(i + 1, repoName, String(error));
             collector.appendError(repoName, error);
         }
     }
@@ -198,7 +266,7 @@ async function processRepoSettings(repos, config, options, processorFactory, res
 /**
  * Run the settings command - manages GitHub Rulesets and repo settings.
  */
-export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory) {
+export async function runSettings(options, processorFactory = defaultRulesetProcessorFactory, repoProcessorFactory = defaultProcessorFactory, repoSettingsProcessorFactory = defaultRepoSettingsProcessorFactory, lifecycleManager) {
     const configPath = resolve(options.config);
     if (!existsSync(configPath)) {
         console.error(`Config file not found: ${configPath}`);
@@ -233,10 +301,17 @@ export async function runSettings(options, processorFactory = defaultRulesetProc
     logger.setTotal(reposWithRulesets.length + reposWithRepoSettings.length);
     const processor = processorFactory();
     const repoProcessor = repoProcessorFactory();
+    const lm = lifecycleManager ?? new RepoLifecycleManager(undefined, options.retries);
+    const tokenManager = hasGitHubAppCredentials()
+        ? new GitHubAppTokenManager(process.env.XFG_GITHUB_APP_ID, process.env.XFG_GITHUB_APP_PRIVATE_KEY)
+        : null;
     const results = [];
     const collector = new ResultsCollector();
-    await processRulesets(reposWithRulesets, config, options, processor, repoProcessor, results, collector);
-    await processRepoSettings(reposWithRepoSettings, config, options, repoSettingsProcessorFactory, results, collector);
+    // Pre-check lifecycle for all unique repos before processing
+    const allRepos = [...reposWithRulesets, ...reposWithRepoSettings];
+    const lifecycleSkipped = await runLifecycleChecks(allRepos, config, options, lm, results, collector, tokenManager);
+    await processRulesets(reposWithRulesets, config, options, processor, repoProcessor, results, collector, lifecycleSkipped);
+    await processRepoSettings(reposWithRepoSettings, config, options, repoSettingsProcessorFactory, results, collector, lifecycleSkipped);
     console.log("");
     const report = buildSettingsReport(collector.getAll());
     const lines = formatSettingsReportCLI(report);

package/dist/cli/sync-command.d.ts

@@ -1,5 +1,6 @@
 import { MergeMode, MergeStrategy } from "../config/index.js";
 import { ProcessorFactory } from "./types.js";
+import { type IRepoLifecycleManager } from "../lifecycle/index.js";
 /**
  * Shared options common to all commands.
  */
@@ -22,4 +23,4 @@ export interface SyncOptions extends SharedOptions {
 /**
  * Run the sync command - synchronizes files across repositories.
  */
-export declare function runSync(options: SyncOptions, processorFactory?: ProcessorFactory): Promise<void>;
+export declare function runSync(options: SyncOptions, processorFactory?: ProcessorFactory, lifecycleManager?: IRepoLifecycleManager): Promise<void>;

package/dist/cli/sync-command.js

@@ -2,13 +2,17 @@ import { resolve, join } from "node:path";
 import { existsSync } from "node:fs";
 import { loadRawConfig, normalizeConfig, } from "../config/index.js";
 import { validateForSync } from "../config/validator.js";
-import { parseGitUrl, getRepoDisplayName } from "../shared/repo-detector.js";
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../shared/repo-detector.js";
 import { sanitizeBranchName, validateBranchName } from "../vcs/git-ops.js";
+import { hasGitHubAppCredentials, GitHubAppTokenManager, } from "../vcs/index.js";
 import { logger } from "../shared/logger.js";
 import { generateWorkspaceName } from "../shared/workspace-utils.js";
 import { defaultProcessorFactory } from "./types.js";
 import { buildSyncReport } from "./sync-report-builder.js";
-import { formatSyncReportCLI, writeSyncReportSummary, } from "../output/sync-report.js";
+import { formatSyncReportCLI } from "../output/sync-report.js";
+import { buildLifecycleReport, formatLifecycleReportCLI, hasLifecycleChanges, } from "../output/lifecycle-report.js";
+import { writeUnifiedSummary } from "../output/unified-summary.js";
+import { RepoLifecycleManager, runLifecycleCheck, toCreateRepoSettings, } from "../lifecycle/index.js";
 /**
  * Get unique file names from all repos in the config
  */
@@ -59,7 +63,7 @@ function determineMergeOutcome(result) {
 /**
  * Run the sync command - synchronizes files across repositories.
  */
-export async function runSync(options, processorFactory = defaultProcessorFactory) {
+export async function runSync(options, processorFactory = defaultProcessorFactory, lifecycleManager) {
     const configPath = resolve(options.config);
     if (!existsSync(configPath)) {
         console.error(`Config file not found: ${configPath}`);
@@ -92,7 +96,12 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
     console.log(`Target files: ${formatFileNames(fileNames)}`);
     console.log(`Branch: ${branchName}\n`);
     const processor = processorFactory();
+    const lm = lifecycleManager ?? new RepoLifecycleManager(undefined, options.retries);
+    const tokenManager = hasGitHubAppCredentials()
+        ? new GitHubAppTokenManager(process.env.XFG_GITHUB_APP_ID, process.env.XFG_GITHUB_APP_PRIVATE_KEY)
+        : null;
     const reportResults = [];
+    const lifecycleReportInputs = [];
     for (let i = 0; i < config.repos.length; i++) {
         const repoConfig = config.repos[i];
         if (options.merge || options.mergeStrategy || options.deleteBranch) {
@@ -122,6 +131,63 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
         }
         const repoName = getRepoDisplayName(repoInfo);
         const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
+        // Resolve auth token for lifecycle gh commands
+        let lifecycleToken;
+        if (isGitHubRepo(repoInfo)) {
+            try {
+                lifecycleToken =
+                    (await tokenManager?.getTokenForRepo(repoInfo)) ??
+                        process.env.GH_TOKEN;
+            }
+            catch {
+                lifecycleToken = process.env.GH_TOKEN;
+            }
+        }
+        // Check if repo exists, create/fork/migrate if needed
+        try {
+            const { outputLines, lifecycleResult } = await runLifecycleCheck(repoConfig, repoInfo, i, {
+                dryRun: options.dryRun ?? false,
+                resolvedWorkDir: workDir,
+                githubHosts: config.githubHosts,
+                token: lifecycleToken,
+            }, lm, config.settings?.repo);
+            for (const line of outputLines) {
+                logger.info(line);
+            }
+            // Collect lifecycle result for report
+            const createSettings = toCreateRepoSettings(config.settings?.repo);
+            lifecycleReportInputs.push({
+                repoName,
+                action: lifecycleResult.action,
+                upstream: repoConfig.upstream,
+                source: repoConfig.source,
+                settings: createSettings
+                    ? {
+                        visibility: createSettings.visibility,
+                        description: createSettings.description,
+                    }
+                    : undefined,
+            });
+            // In dry-run, skip processing repos that don't exist yet
+            if (options.dryRun && lifecycleResult.action !== "existed") {
+                reportResults.push({
+                    repoName,
+                    success: true,
+                    fileChanges: [],
+                });
+                continue;
+            }
+        }
+        catch (error) {
+            logger.error(current, repoName, `Lifecycle error: ${error instanceof Error ? error.message : String(error)}`);
+            reportResults.push({
+                repoName,
+                success: false,
+                fileChanges: [],
+                error: error instanceof Error ? error.message : String(error),
+            });
+            continue;
+        }
         try {
             logger.progress(current, repoName, "Processing...");
             const result = await processor.process(repoConfig, repoInfo, {
@@ -165,13 +231,22 @@ export async function runSync(options, processorFactory = defaultProcessorFactor
             });
         }
     }
-    // Build and display report
+    // Build and display lifecycle report (before sync report)
+    const lifecycleReport = buildLifecycleReport(lifecycleReportInputs);
+    if (hasLifecycleChanges(lifecycleReport)) {
+        console.log("");
+        for (const line of formatLifecycleReportCLI(lifecycleReport)) {
+            console.log(line);
+        }
+    }
+    // Build and display sync report
     const report = buildSyncReport(reportResults);
     console.log("");
     for (const line of formatSyncReportCLI(report)) {
         console.log(line);
     }
-    writeSyncReportSummary(report, options.dryRun ?? false);
+    // Write unified summary to GITHUB_STEP_SUMMARY
+    writeUnifiedSummary(lifecycleReport, report, options.dryRun ?? false);
     // Exit with error if any failures
     const hasErrors = reportResults.some((r) => r.error);
     if (hasErrors) {

package/dist/config/normalizer.js

@@ -228,6 +228,8 @@ export function normalizeConfig(raw) {
                 files,
                 prOptions,
                 settings,
+                upstream: rawRepo.upstream,
+                source: rawRepo.source,
             });
         }
     }

package/dist/config/types.d.ts

@@ -233,6 +233,7 @@ export type RepoVisibility = "public" | "private" | "internal";
  * @see https://docs.github.com/en/rest/repos/repos#update-a-repository
  */
 export interface GitHubRepoSettings {
+    description?: string;
     hasIssues?: boolean;
     hasProjects?: boolean;
     hasWiki?: boolean;
@@ -303,6 +304,10 @@ export interface RawRepoConfig {
     };
     prOptions?: PRMergeOptions;
     settings?: RawRepoSettings;
+    /** Fork upstream repo if target doesn't exist */
+    upstream?: string;
+    /** Migrate from source repo if target doesn't exist */
+    source?: string;
 }
 export interface RawConfig {
     id: string;
@@ -330,6 +335,10 @@ export interface RepoConfig {
     files: FileContent[];
     prOptions?: PRMergeOptions;
     settings?: RepoSettings;
+    /** Fork upstream repo if target doesn't exist */
+    upstream?: string;
+    /** Migrate from source repo if target doesn't exist */
+    source?: string;
 }
 export interface Config {
     id: string;

package/dist/config/validator.js

@@ -4,6 +4,41 @@ import { validateRuleset } from "./validators/ruleset-validator.js";
 // Pattern for valid config ID: alphanumeric, hyphens, underscores
 const CONFIG_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const CONFIG_ID_MAX_LENGTH = 64;
+/**
+ * Check if a string looks like a valid git URL.
+ * Supports SSH (git@host:path) and HTTPS (https://host/path) formats.
+ */
+function isValidGitUrl(url) {
+    // SSH format: git@hostname:path
+    if (/^git@[^:]+:.+$/.test(url)) {
+        return true;
+    }
+    // HTTPS format: https://hostname/path
+    if (/^https?:\/\/[^/]+\/.+$/.test(url)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Check if a git URL points to GitHub (github.com).
+ * Used to reject GitHub URLs as migration sources (not supported).
+ */
+function isGitHubUrl(url, githubHosts) {
+    const hosts = ["github.com", ...(githubHosts ?? [])];
+    for (const host of hosts) {
+        if (url.startsWith(`git@${host}:`) ||
+            url.match(new RegExp(`^https?://${escapeRegExp(host)}/`))) {
+            return true;
+        }
+    }
+    return false;
+}
 function getGitDisplayName(git) {
     if (Array.isArray(git)) {
         return git[0] || "unknown";
@@ -201,6 +236,33 @@ export function validateRawConfig(config) {
         if (Array.isArray(repo.git) && repo.git.length === 0) {
             throw new Error(`Repo at index ${i} has empty git array`);
         }
+        // Validate lifecycle fields (upstream/source)
+        if (repo.upstream !== undefined && repo.source !== undefined) {
+            throw new Error(`Repo ${getGitDisplayName(repo.git)}: 'upstream' and 'source' are mutually exclusive. ` +
+                `Use 'upstream' to fork, or 'source' to migrate, not both.`);
+        }
+        if (repo.upstream !== undefined) {
+            if (typeof repo.upstream !== "string") {
+                throw new Error(`Repo ${getGitDisplayName(repo.git)}: 'upstream' must be a string`);
+            }
+            if (!isValidGitUrl(repo.upstream)) {
+                throw new Error(`Repo ${getGitDisplayName(repo.git)}: 'upstream' must be a valid git URL ` +
+                    `(SSH: git@host:path or HTTPS: https://host/path)`);
+            }
+        }
+        if (repo.source !== undefined) {
+            if (typeof repo.source !== "string") {
+                throw new Error(`Repo ${getGitDisplayName(repo.git)}: 'source' must be a string`);
+            }
+            if (!isValidGitUrl(repo.source)) {
+                throw new Error(`Repo ${getGitDisplayName(repo.git)}: 'source' must be a valid git URL ` +
+                    `(SSH: git@host:path or HTTPS: https://host/path)`);
+            }
+            if (isGitHubUrl(repo.source, config.githubHosts)) {
+                throw new Error(`Repo ${getGitDisplayName(repo.git)}: 'source' cannot be a GitHub URL. ` +
+                    `Migration from GitHub is not supported. Currently supported sources: Azure DevOps`);
+            }
+        }
         // Validate per-repo file overrides
         if (repo.files) {
             if (typeof repo.files !== "object" || Array.isArray(repo.files)) {

package/dist/lifecycle/ado-migration-source.d.ts

@@ -0,0 +1,15 @@
+import { ICommandExecutor } from "../shared/command-executor.js";
+import { type RepoInfo } from "../shared/repo-detector.js";
+import type { IMigrationSource, LifecyclePlatform } from "./types.js";
+/**
+ * Azure DevOps implementation of IMigrationSource.
+ * Uses git clone --mirror to get all refs for migration.
+ */
+export declare class AdoMigrationSource implements IMigrationSource {
+    private readonly executor;
+    private readonly retries;
+    readonly platform: LifecyclePlatform;
+    constructor(executor?: ICommandExecutor, retries?: number);
+    private assertAdo;
+    cloneForMigration(repoInfo: RepoInfo, workDir: string): Promise<void>;
+}

package/dist/lifecycle/ado-migration-source.js

@@ -0,0 +1,37 @@
+import { escapeShellArg } from "../shared/shell-utils.js";
+import { defaultExecutor, } from "../shared/command-executor.js";
+import { withRetry } from "../shared/retry-utils.js";
+import { isAzureDevOpsRepo, } from "../shared/repo-detector.js";
+/**
+ * Azure DevOps implementation of IMigrationSource.
+ * Uses git clone --mirror to get all refs for migration.
+ */
+export class AdoMigrationSource {
+    executor;
+    retries;
+    platform = "azure-devops";
+    constructor(executor = defaultExecutor, retries = 3) {
+        this.executor = executor;
+        this.retries = retries;
+    }
+    assertAdo(repoInfo) {
+        if (!isAzureDevOpsRepo(repoInfo)) {
+            throw new Error(`AdoMigrationSource requires Azure DevOps repo, got: ${repoInfo.type}`);
+        }
+    }
+    async cloneForMigration(repoInfo, workDir) {
+        this.assertAdo(repoInfo);
+        const command = `git clone --mirror ${escapeShellArg(repoInfo.gitUrl)} ${escapeShellArg(workDir)}`;
+        try {
+            await withRetry(() => this.executor.exec(command, process.cwd()), {
+                retries: this.retries,
+            });
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to clone migration source ${repoInfo.gitUrl}: ${msg}. ` +
+                `Ensure you have authentication configured for Azure DevOps ` +
+                `(e.g., AZURE_DEVOPS_EXT_PAT or git credential helper).`);
+        }
+    }
+}

package/dist/lifecycle/github-lifecycle-provider.d.ts

@@ -0,0 +1,56 @@
+import { ICommandExecutor } from "../shared/command-executor.js";
+import { type RepoInfo } from "../shared/repo-detector.js";
+import type { IRepoLifecycleProvider, LifecyclePlatform, CreateRepoSettings } from "./types.js";
+/**
+ * GitHub implementation of IRepoLifecycleProvider.
+ * Uses gh CLI for all operations.
+ */
+export interface GitHubLifecycleProviderOptions {
+    executor?: ICommandExecutor;
+    retries?: number;
+    cwd?: string;
+    /** Timeout in ms for waiting for fork readiness (default: 60000) */
+    forkReadyTimeoutMs?: number;
+    /** Poll interval in ms for fork readiness checks (default: 2000) */
+    forkPollIntervalMs?: number;
+}
+export declare class GitHubLifecycleProvider implements IRepoLifecycleProvider {
+    readonly platform: LifecyclePlatform;
+    private readonly executor;
+    private readonly retries;
+    private readonly cwd;
+    private readonly forkReadyTimeoutMs;
+    private readonly forkPollIntervalMs;
+    constructor(options?: GitHubLifecycleProviderOptions);
+    /**
+     * Check if a GitHub owner is an organization (vs user).
+     * Uses gh api to query the user/org endpoint.
+     */
+    private isOrganization;
+    private assertGitHub;
+    /**
+     * Build GH_TOKEN prefix for gh CLI commands.
+     * Returns "GH_TOKEN=<escaped_token> " when token is provided, "" otherwise.
+     * Token is escaped via escapeShellArg to prevent injection.
+     */
+    private buildTokenPrefix;
+    exists(repoInfo: RepoInfo, token?: string): Promise<boolean>;
+    create(repoInfo: RepoInfo, settings?: CreateRepoSettings, token?: string): Promise<void>;
+    fork(upstream: RepoInfo, target: RepoInfo, settings?: CreateRepoSettings, token?: string): Promise<void>;
+    /**
+     * Wait for a forked repo to become available via the GitHub API.
+     * GitHub forks are created asynchronously; polls exists() with a timeout.
+     */
+    private waitForForkReady;
+    /**
+     * Apply settings to an existing repo using gh repo edit.
+     */
+    private applyRepoSettings;
+    receiveMigration(repoInfo: RepoInfo, sourceDir: string, settings?: CreateRepoSettings, token?: string): Promise<void>;
+    /**
+     * Delete the README.md that --add-readme creates.
+     * This leaves the repo with a default branch established (from the initial
+     * commit) but no files, so xfg sync starts from a clean state.
+     */
+    private deleteReadme;
+}