@aspruyt/xfg 3.9.12 → 3.9.14

package/dist/cli/index.d.ts

@@ -1,6 +1,6 @@
 export { runSync } from "./sync-command.js";
 export { runSettings } from "./settings-command.js";
 export { program } from "./program.js";
-export { type IRepositoryProcessor, type ProcessorFactory, type IRulesetProcessor, type RulesetProcessorFactory, type RepoSettingsProcessorFactory, type IRepoSettingsProcessor, defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
+export { type IRepositoryProcessor, type ProcessorFactory, type IRulesetProcessor, type RulesetProcessorFactory, type RepoSettingsProcessorFactory, type IRepoSettingsProcessor, type ILabelsProcessor, type LabelsProcessorFactory, defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./types.js";
 export type { SyncOptions, SharedOptions } from "./sync-command.js";
 export type { SettingsOptions } from "./settings-command.js";

package/dist/cli/index.js

@@ -6,4 +6,4 @@ export { program } from "./program.js";
 // For ESM compatibility, re-export everything from types.js
 export { 
 // Runtime values
-defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, } from "./types.js";
+defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./types.js";

package/dist/cli/settings/lifecycle-checks.d.ts

@@ -0,0 +1,11 @@
+import type { GitHubAppTokenManager } from "../../vcs/index.js";
+import type { RepoResult } from "../../output/github-summary.js";
+import type { IRepoLifecycleManager } from "../../lifecycle/index.js";
+import type { Config, RepoConfig } from "../../config/types.js";
+import type { ResultsCollector } from "./results-collector.js";
+import type { SettingsOptions } from "../settings-command.js";
+/**
+ * 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).
+ */
+export declare function runLifecycleChecks(allRepos: RepoConfig[], config: Config, options: SettingsOptions, lifecycleManager: IRepoLifecycleManager, results: RepoResult[], collector: ResultsCollector, tokenManager: GitHubAppTokenManager | null): Promise<Set<string>>;

package/dist/cli/settings/lifecycle-checks.js

@@ -0,0 +1,64 @@
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../../shared/repo-detector.js";
+import { logger } from "../../shared/logger.js";
+import { buildErrorResult } from "../../output/summary-utils.js";
+import { runLifecycleCheck } from "../../lifecycle/index.js";
+/**
+ * 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).
+ */
+export 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;
+}

package/dist/cli/settings/process-labels.d.ts

@@ -0,0 +1,9 @@
+import type { RepoResult } from "../../output/github-summary.js";
+import type { ILabelsProcessor, IRepositoryProcessor } from "../types.js";
+import type { Config, RepoConfig } from "../../config/types.js";
+import type { ResultsCollector } from "./results-collector.js";
+import type { SettingsOptions } from "../settings-command.js";
+/**
+ * Process labels for all configured repositories.
+ */
+export declare function processLabels(repos: RepoConfig[], config: Config, options: SettingsOptions, processor: ILabelsProcessor, repoProcessor: IRepositoryProcessor, results: RepoResult[], collector: ResultsCollector, lifecycleSkipped: Set<string>, indexOffset: number): Promise<void>;

package/dist/cli/settings/process-labels.js

@@ -0,0 +1,125 @@
+import { resolve, join } from "node:path";
+import chalk from "chalk";
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../../shared/repo-detector.js";
+import { logger } from "../../shared/logger.js";
+import { generateWorkspaceName } from "../../shared/workspace-utils.js";
+import { getManagedLabels, parseManifestContent, MANIFEST_FILENAME, } from "../../sync/manifest.js";
+import { defaultExecutor } from "../../shared/command-executor.js";
+import { escapeShellArg } from "../../shared/shell-utils.js";
+/**
+ * Process labels for all configured repositories.
+ */
+export async function processLabels(repos, config, options, processor, repoProcessor, results, collector, lifecycleSkipped, indexOffset) {
+    if (repos.length === 0) {
+        return;
+    }
+    console.log(`\nProcessing labels for ${repos.length} repositories\n`);
+    for (let i = 0; i < repos.length; i++) {
+        const repoConfig = repos[i];
+        const current = indexOffset + i + 1;
+        if (lifecycleSkipped.has(repoConfig.git)) {
+            continue;
+        }
+        let repoInfo;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            logger.error(current, repoConfig.git, String(error));
+            collector.appendError(repoConfig.git, error);
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        if (!isGitHubRepo(repoInfo)) {
+            logger.skip(current, repoName, "GitHub Labels only supported for GitHub repos");
+            continue;
+        }
+        const managedLabels = await fetchManagedLabels(repoInfo, config.id);
+        try {
+            logger.progress(current, repoName, "Processing labels...");
+            const result = await processor.process(repoConfig, repoInfo, {
+                configId: config.id,
+                dryRun: options.dryRun,
+                managedLabels,
+                noDelete: options.noDelete,
+            });
+            if (result.planOutput && result.planOutput.lines.length > 0) {
+                logger.info("");
+                logger.info(chalk.bold(`${repoName} - Labels:`));
+                for (const line of result.planOutput.lines) {
+                    logger.info(line);
+                }
+            }
+            if (result.skipped) {
+                logger.skip(current, repoName, result.message);
+            }
+            else if (result.success) {
+                logger.success(current, repoName, result.message);
+                if (result.manifestUpdate && result.manifestUpdate.labels.length > 0) {
+                    const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
+                    logger.progress(current, repoName, "Updating manifest...");
+                    const manifestResult = await repoProcessor.updateManifestOnly(repoInfo, repoConfig, {
+                        branchName: "chore/sync-labels",
+                        workDir,
+                        configId: config.id,
+                        dryRun: options.dryRun,
+                        retries: options.retries,
+                    }, { labels: result.manifestUpdate.labels });
+                    if (!manifestResult.success && !manifestResult.skipped) {
+                        logger.info(`Warning: Failed to update manifest for ${repoName}: ${manifestResult.message}`);
+                    }
+                }
+            }
+            else {
+                logger.error(current, repoName, result.message);
+                collector.appendError(repoName, result.message);
+            }
+            const existing = results.find((r) => r.repoName === repoName);
+            if (existing) {
+                existing.labelsPlanDetails = result.planOutput?.entries;
+            }
+            else {
+                results.push({
+                    repoName,
+                    status: result.skipped
+                        ? "skipped"
+                        : result.success
+                            ? "succeeded"
+                            : "failed",
+                    message: result.message,
+                    labelsPlanDetails: result.planOutput?.entries,
+                });
+            }
+            if (!result.skipped) {
+                collector.getOrCreate(repoName).labelsResult = result;
+            }
+        }
+        catch (error) {
+            logger.error(current, repoName, String(error));
+            collector.appendError(repoName, error);
+        }
+    }
+}
+/**
+ * Fetches the managed labels list from a remote GitHub repo's manifest.
+ * Returns an empty array if the manifest doesn't exist or can't be read.
+ *
+ * Uses the project's ICommandExecutor + escapeShellArg pattern for safe
+ * command execution. All inputs are from parsed config (owner/repo), not
+ * user input.
+ */
+async function fetchManagedLabels(repoInfo, configId) {
+    try {
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/contents/${MANIFEST_FILENAME}`;
+        const command = `gh api ${escapeShellArg(endpoint)} --jq '.content'`;
+        const base64Content = await defaultExecutor.exec(command, process.cwd());
+        const content = Buffer.from(base64Content.trim(), "base64").toString("utf-8");
+        const manifest = parseManifestContent(content);
+        return getManagedLabels(manifest, configId);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/cli/settings/process-repo-settings.d.ts

@@ -0,0 +1,9 @@
+import type { RepoResult } from "../../output/github-summary.js";
+import type { RepoSettingsProcessorFactory } from "../types.js";
+import type { Config, RepoConfig } from "../../config/types.js";
+import type { ResultsCollector } from "./results-collector.js";
+import type { SettingsOptions } from "../settings-command.js";
+/**
+ * Process repo settings for all configured repositories.
+ */
+export declare function processRepoSettings(repos: RepoConfig[], config: Config, options: SettingsOptions, processorFactory: RepoSettingsProcessorFactory, results: RepoResult[], collector: ResultsCollector, lifecycleSkipped: Set<string>, indexOffset: number): Promise<void>;

package/dist/cli/settings/process-repo-settings.js

@@ -0,0 +1,80 @@
+import chalk from "chalk";
+import { parseGitUrl, getRepoDisplayName } from "../../shared/repo-detector.js";
+import { logger } from "../../shared/logger.js";
+/**
+ * Process repo settings for all configured repositories.
+ */
+export async function processRepoSettings(repos, config, options, processorFactory, results, collector, lifecycleSkipped, indexOffset) {
+    if (repos.length === 0) {
+        return;
+    }
+    const processor = processorFactory();
+    console.log(`\nProcessing repo settings for ${repos.length} repositories\n`);
+    for (let i = 0; i < repos.length; i++) {
+        const repoConfig = repos[i];
+        const current = indexOffset + i + 1;
+        if (lifecycleSkipped.has(repoConfig.git)) {
+            continue;
+        }
+        let repoInfo;
+        try {
+            repoInfo = parseGitUrl(repoConfig.git, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            logger.error(current, repoConfig.git, String(error));
+            collector.appendError(repoConfig.git, error);
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        try {
+            const result = await processor.process(repoConfig, repoInfo, {
+                dryRun: options.dryRun,
+            });
+            if (result.planOutput && result.planOutput.lines.length > 0) {
+                logger.info("");
+                logger.info(chalk.bold(`${repoName} - Repo Settings:`));
+                for (const line of result.planOutput.lines) {
+                    logger.info(line);
+                }
+                if (result.warnings && result.warnings.length > 0) {
+                    for (const warning of result.warnings) {
+                        logger.info(chalk.yellow(`Warning: ${warning}`));
+                    }
+                }
+            }
+            if (result.skipped) {
+                // Silent skip
+            }
+            else if (result.success) {
+                logger.success(current, repoName, result.message);
+            }
+            else {
+                logger.error(current, repoName, result.message);
+                collector.appendError(repoName, result.message);
+            }
+            if (!result.skipped) {
+                const existing = results.find((r) => r.repoName === repoName);
+                if (existing) {
+                    existing.repoSettingsPlanDetails = result.planOutput?.entries;
+                }
+                else {
+                    results.push({
+                        repoName,
+                        status: result.success ? "succeeded" : "failed",
+                        message: result.message,
+                        repoSettingsPlanDetails: result.planOutput?.entries,
+                    });
+                }
+            }
+            if (!result.skipped) {
+                collector.getOrCreate(repoName).settingsResult = result;
+            }
+        }
+        catch (error) {
+            logger.error(current, repoName, String(error));
+            collector.appendError(repoName, error);
+        }
+    }
+}

package/dist/cli/settings/process-rulesets.d.ts

@@ -0,0 +1,9 @@
+import type { RepoResult } from "../../output/github-summary.js";
+import type { IRulesetProcessor, IRepositoryProcessor } from "../types.js";
+import type { Config, RepoConfig } from "../../config/types.js";
+import type { ResultsCollector } from "./results-collector.js";
+import type { SettingsOptions } from "../settings-command.js";
+/**
+ * Process rulesets for all configured repositories.
+ */
+export declare function processRulesets(repos: RepoConfig[], config: Config, options: SettingsOptions, processor: IRulesetProcessor, repoProcessor: IRepositoryProcessor, results: RepoResult[], collector: ResultsCollector, lifecycleSkipped: Set<string>): Promise<void>;

package/dist/cli/settings/process-rulesets.js

@@ -0,0 +1,118 @@
+import { resolve, join } from "node:path";
+import chalk from "chalk";
+import { parseGitUrl, getRepoDisplayName, isGitHubRepo, } from "../../shared/repo-detector.js";
+import { logger } from "../../shared/logger.js";
+import { generateWorkspaceName } from "../../shared/workspace-utils.js";
+import { buildErrorResult } from "../../output/summary-utils.js";
+import { getManagedRulesets, parseManifestContent, MANIFEST_FILENAME, } from "../../sync/manifest.js";
+import { defaultExecutor } from "../../shared/command-executor.js";
+import { escapeShellArg } from "../../shared/shell-utils.js";
+/**
+ * Process rulesets for all configured repositories.
+ */
+export 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, {
+                githubHosts: config.githubHosts,
+            });
+        }
+        catch (error) {
+            logger.error(i + 1, repoConfig.git, String(error));
+            results.push(buildErrorResult(repoConfig.git, error));
+            collector.appendError(repoConfig.git, error);
+            continue;
+        }
+        const repoName = getRepoDisplayName(repoInfo);
+        if (!isGitHubRepo(repoInfo)) {
+            logger.skip(i + 1, repoName, "GitHub Rulesets only supported for GitHub repos");
+            continue;
+        }
+        const managedRulesets = await fetchManagedRulesets(repoInfo, config.id);
+        try {
+            logger.progress(i + 1, repoName, "Processing rulesets...");
+            const result = await processor.process(repoConfig, repoInfo, {
+                configId: config.id,
+                dryRun: options.dryRun,
+                managedRulesets,
+                noDelete: options.noDelete,
+            });
+            if (result.planOutput && result.planOutput.lines.length > 0) {
+                logger.info("");
+                logger.info(chalk.bold(`${repoName} - Rulesets:`));
+                for (const line of result.planOutput.lines) {
+                    logger.info(line);
+                }
+            }
+            if (result.skipped) {
+                logger.skip(i + 1, repoName, result.message);
+            }
+            else if (result.success) {
+                logger.success(i + 1, repoName, result.message);
+                if (result.manifestUpdate &&
+                    result.manifestUpdate.rulesets.length > 0) {
+                    const workDir = resolve(join(options.workDir ?? "./tmp", generateWorkspaceName(i)));
+                    logger.progress(i + 1, repoName, "Updating manifest...");
+                    const manifestResult = await repoProcessor.updateManifestOnly(repoInfo, repoConfig, {
+                        branchName: "chore/sync-rulesets",
+                        workDir,
+                        configId: config.id,
+                        dryRun: options.dryRun,
+                        retries: options.retries,
+                    }, result.manifestUpdate);
+                    if (!manifestResult.success && !manifestResult.skipped) {
+                        logger.info(`Warning: Failed to update manifest for ${repoName}: ${manifestResult.message}`);
+                    }
+                }
+            }
+            else {
+                logger.error(i + 1, repoName, result.message);
+                collector.appendError(repoName, result.message);
+            }
+            results.push({
+                repoName,
+                status: result.skipped
+                    ? "skipped"
+                    : result.success
+                        ? "succeeded"
+                        : "failed",
+                message: result.message,
+                rulesetPlanDetails: result.planOutput?.entries,
+            });
+            if (!result.skipped) {
+                collector.getOrCreate(repoName).rulesetResult = result;
+            }
+        }
+        catch (error) {
+            logger.error(i + 1, repoName, String(error));
+            results.push(buildErrorResult(repoName, error));
+            collector.appendError(repoName, error);
+        }
+    }
+}
+/**
+ * Fetches the managed rulesets list from a remote GitHub repo's manifest.
+ * Returns an empty array if the manifest doesn't exist or can't be read.
+ *
+ * Uses the project's ICommandExecutor + escapeShellArg pattern for safe
+ * command execution. All inputs are from parsed config (owner/repo), not
+ * user input.
+ */
+async function fetchManagedRulesets(repoInfo, configId) {
+    try {
+        const endpoint = `/repos/${repoInfo.owner}/${repoInfo.repo}/contents/${MANIFEST_FILENAME}`;
+        const command = `gh api ${escapeShellArg(endpoint)} --jq '.content'`;
+        const base64Content = await defaultExecutor.exec(command, process.cwd());
+        const content = Buffer.from(base64Content.trim(), "base64").toString("utf-8");
+        const manifest = parseManifestContent(content);
+        return getManagedRulesets(manifest, configId);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/cli/settings/results-collector.d.ts

@@ -0,0 +1,11 @@
+import type { ProcessorResults } from "../settings-report-builder.js";
+/**
+ * Collects processing results for the SettingsReport.
+ * Provides a centralized way to track results across rulesets, repo settings, and labels.
+ */
+export declare class ResultsCollector {
+    private readonly results;
+    getOrCreate(repoName: string): ProcessorResults;
+    appendError(repoName: string, error: unknown): void;
+    getAll(): ProcessorResults[];
+}

package/dist/cli/settings/results-collector.js

@@ -0,0 +1,28 @@
+/**
+ * Collects processing results for the SettingsReport.
+ * Provides a centralized way to track results across rulesets, repo settings, and labels.
+ */
+export class ResultsCollector {
+    results = [];
+    getOrCreate(repoName) {
+        let result = this.results.find((r) => r.repoName === repoName);
+        if (!result) {
+            result = { repoName };
+            this.results.push(result);
+        }
+        return result;
+    }
+    appendError(repoName, error) {
+        const existing = this.getOrCreate(repoName);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        if (existing.error) {
+            existing.error += `; ${errorMsg}`;
+        }
+        else {
+            existing.error = errorMsg;
+        }
+    }
+    getAll() {
+        return this.results;
+    }
+}

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

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