@aspruyt/xfg 4.0.2 → 4.0.4

package/dist/config/validator.d.ts

@@ -6,7 +6,7 @@ import type { RawConfig, RawRepoSettings, RawRootSettings } from "./types.js";
 export declare function validateRawConfig(config: RawConfig): void;
 /**
  * Validates that config is suitable for the sync command.
- * @throws Error if files section is missing or empty
+ * @throws ValidationError if neither files nor settings are present
  */
 export declare function validateForSync(config: RawConfig): void;
 /**

package/dist/config/validator.js

@@ -2,7 +2,8 @@ import { isTextContent, isObjectContent, isStructuredFileExtension, validateFile
 import { validateRepoSettings } from "./validators/repo-settings-validator.js";
 import { validateRuleset } from "./validators/ruleset-validator.js";
 import { escapeRegExp } from "../shared/shell-utils.js";
-import { ValidationError } from "./errors.js";
+import { isPlainObject } from "../shared/type-guards.js";
+import { ValidationError } from "../shared/errors.js";
 // Pattern for valid config ID: alphanumeric, hyphens, underscores
 const CONFIG_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
 const CONFIG_ID_MAX_LENGTH = 64;
@@ -90,9 +91,7 @@ function validateFileConfigFields(fileConfig, fileName, context) {
         }
     }
     if (fileConfig.vars !== undefined) {
-        if (typeof fileConfig.vars !== "object" ||
-            fileConfig.vars === null ||
-            Array.isArray(fileConfig.vars)) {
+        if (!isPlainObject(fileConfig.vars)) {
             throw new ValidationError(`${context} file '${fileName}' vars must be an object with string values`);
         }
         for (const [key, value] of Object.entries(fileConfig.vars)) {
@@ -106,7 +105,7 @@ function validateFileConfigFields(fileConfig, fileName, context) {
  * Validates a single label configuration.
  */
 function validateLabel(label, name, context) {
-    if (typeof label !== "object" || label === null || Array.isArray(label)) {
+    if (!isPlainObject(label)) {
         throw new ValidationError(`${context}: label '${name}' must be an object`);
     }
     const l = label;
@@ -139,26 +138,21 @@ function buildRootSettingsContext(config) {
 /**
  * Validates settings object containing rulesets, labels, and repo settings.
  */
-function validateSettings(settings, context, rootRulesetNames, hasRootRepoSettings, rootLabelNames) {
-    if (typeof settings !== "object" ||
-        settings === null ||
-        Array.isArray(settings)) {
+function validateSettings(settings, context, rootCtx) {
+    if (!isPlainObject(settings)) {
         throw new ValidationError(`${context}: settings must be an object`);
     }
-    const s = settings;
-    if (s.rulesets !== undefined) {
-        if (typeof s.rulesets !== "object" ||
-            s.rulesets === null ||
-            Array.isArray(s.rulesets)) {
+    if (settings.rulesets !== undefined) {
+        if (!isPlainObject(settings.rulesets)) {
             throw new ValidationError(`${context}: rulesets must be an object`);
         }
-        const rulesets = s.rulesets;
+        const rulesets = settings.rulesets;
         for (const [name, ruleset] of Object.entries(rulesets)) {
             // Skip reserved key
             if (name === "inherit")
                 continue;
             if (ruleset === false) {
-                if (rootRulesetNames && !rootRulesetNames.includes(name)) {
+                if (rootCtx && !rootCtx.rulesetNames.includes(name)) {
                     throw new ValidationError(`${context}: Cannot opt out of '${name}' - not defined in root settings.rulesets`);
                 }
                 continue; // Skip further validation for false entries
@@ -166,18 +160,16 @@ function validateSettings(settings, context, rootRulesetNames, hasRootRepoSettin
             validateRuleset(ruleset, name, context);
         }
     }
-    if (s.labels !== undefined) {
-        if (typeof s.labels !== "object" ||
-            s.labels === null ||
-            Array.isArray(s.labels)) {
+    if (settings.labels !== undefined) {
+        if (!isPlainObject(settings.labels)) {
             throw new ValidationError(`${context}: labels must be an object`);
         }
-        const labels = s.labels;
+        const labels = settings.labels;
         for (const [name, label] of Object.entries(labels)) {
             if (name === "inherit")
                 continue;
             if (label === false) {
-                if (rootLabelNames && !rootLabelNames.includes(name)) {
+                if (rootCtx && !rootCtx.labelNames.includes(name)) {
                     throw new ValidationError(`${context}: Cannot opt out of label '${name}' - not defined in root settings.labels`);
                 }
                 continue;
@@ -185,23 +177,24 @@ function validateSettings(settings, context, rootRulesetNames, hasRootRepoSettin
             validateLabel(label, name, context);
         }
     }
-    if (s.deleteOrphaned !== undefined && typeof s.deleteOrphaned !== "boolean") {
+    if (settings.deleteOrphaned !== undefined &&
+        typeof settings.deleteOrphaned !== "boolean") {
         throw new ValidationError(`${context}: settings.deleteOrphaned must be a boolean`);
     }
-    if (s.repo !== undefined) {
-        if (s.repo === false) {
-            if (!rootRulesetNames) {
+    if (settings.repo !== undefined) {
+        if (settings.repo === false) {
+            if (!rootCtx) {
                 // Root level — repo: false not valid here
                 throw new ValidationError(`${context}: repo: false is not valid at root level. Define repo settings or remove the field.`);
             }
             // Per-repo level — check root has repo settings to opt out of
-            if (!hasRootRepoSettings) {
+            if (!rootCtx.hasRepoSettings) {
                 throw new ValidationError(`${context}: Cannot opt out of repo settings — not defined in root settings.repo`);
             }
             // Valid opt-out, skip further repo validation
         }
         else {
-            validateRepoSettings(s.repo, context);
+            validateRepoSettings(settings.repo, context);
         }
     }
 }
@@ -225,7 +218,7 @@ function validateRootFiles(config) {
     for (const fileName of Object.keys(config.files)) {
         validateFileName(fileName);
         const fileConfig = config.files[fileName];
-        if (!fileConfig || typeof fileConfig !== "object") {
+        if (!isPlainObject(fileConfig)) {
             throw new ValidationError(`File '${fileName}' must have a configuration object`);
         }
         validateFileConfigFields(fileConfig, fileName, `File '${fileName}':`);
@@ -276,9 +269,7 @@ function validatePrOptions(config) {
 function validateGroups(config) {
     if (config.groups === undefined)
         return;
-    if (typeof config.groups !== "object" ||
-        config.groups === null ||
-        Array.isArray(config.groups)) {
+    if (!isPlainObject(config.groups)) {
         throw new ValidationError("groups must be an object");
     }
     const rootCtx = buildRootSettingsContext(config);
@@ -298,18 +289,20 @@ function validateGroups(config) {
             }
         }
         if (group.settings !== undefined) {
-            validateSettings(group.settings, `groups.${groupName}`, rootCtx.rulesetNames, rootCtx.hasRepoSettings, rootCtx.labelNames);
+            validateSettings(group.settings, `groups.${groupName}`, rootCtx);
         }
     }
 }
-function validateRepoEntry(config, repo, index) {
+function validateRepoGitField(repo, index) {
     if (!repo.git) {
         throw new ValidationError(`Repo at index ${index} missing required field: git`);
     }
     if (Array.isArray(repo.git) && repo.git.length === 0) {
         throw new ValidationError(`Repo at index ${index} has empty git array`);
     }
-    const repoLabel = getGitDisplayName(repo.git);
+    return getGitDisplayName(repo.git);
+}
+function validateRepoOrigins(config, repo, repoLabel) {
     if (repo.upstream !== undefined && repo.source !== undefined) {
         throw new ValidationError(`Repo ${repoLabel}: 'upstream' and 'source' are mutually exclusive. ` +
             `Use 'upstream' to fork, or 'source' to migrate, not both.`);
@@ -336,81 +329,99 @@ function validateRepoEntry(config, repo, index) {
                 `Migration from GitHub is not supported. Currently supported sources: Azure DevOps`);
         }
     }
-    if (repo.groups !== undefined) {
-        if (!Array.isArray(repo.groups) ||
-            !repo.groups.every((g) => typeof g === "string")) {
-            throw new ValidationError(`Repo at index ${index}: groups must be an array of strings`);
+}
+function validateRepoGroups(config, repo, index) {
+    if (repo.groups === undefined)
+        return;
+    if (!Array.isArray(repo.groups) ||
+        !repo.groups.every((g) => typeof g === "string")) {
+        throw new ValidationError(`Repo at index ${index}: groups must be an array of strings`);
+    }
+    const seen = new Set();
+    for (const groupName of repo.groups) {
+        if (!config.groups || !config.groups[groupName]) {
+            throw new ValidationError(`Repo at index ${index}: group '${groupName}' is not defined in root 'groups'`);
         }
-        const seen = new Set();
+        if (seen.has(groupName)) {
+            throw new ValidationError(`Repo at index ${index}: duplicate group '${groupName}'`);
+        }
+        seen.add(groupName);
+    }
+}
+function validateRepoFiles(config, repo, index, repoLabel) {
+    if (!repo.files)
+        return;
+    if (!isPlainObject(repo.files)) {
+        throw new ValidationError(`Repo at index ${index}: files must be an object`);
+    }
+    const knownFiles = new Set(config.files ? Object.keys(config.files) : []);
+    if (repo.groups && config.groups) {
         for (const groupName of repo.groups) {
-            if (!config.groups || !config.groups[groupName]) {
-                throw new ValidationError(`Repo at index ${index}: group '${groupName}' is not defined in root 'groups'`);
-            }
-            if (seen.has(groupName)) {
-                throw new ValidationError(`Repo at index ${index}: duplicate group '${groupName}'`);
-            }
-            seen.add(groupName);
-        }
-    }
-    if (repo.files) {
-        if (typeof repo.files !== "object" || Array.isArray(repo.files)) {
-            throw new ValidationError(`Repo at index ${index}: files must be an object`);
-        }
-        const knownFiles = new Set(config.files ? Object.keys(config.files) : []);
-        if (repo.groups && config.groups) {
-            for (const groupName of repo.groups) {
-                const group = config.groups[groupName];
-                if (group?.files) {
-                    for (const fn of Object.keys(group.files)) {
-                        if (fn !== "inherit")
-                            knownFiles.add(fn);
-                    }
+            const group = config.groups[groupName];
+            if (group?.files) {
+                for (const fn of Object.keys(group.files)) {
+                    if (fn !== "inherit")
+                        knownFiles.add(fn);
                 }
             }
         }
-        for (const fileName of Object.keys(repo.files)) {
-            if (fileName === "inherit") {
-                const inheritValue = repo.files.inherit;
-                if (typeof inheritValue !== "boolean") {
-                    throw new ValidationError(`Repo at index ${index}: files.inherit must be a boolean`);
-                }
-                continue;
-            }
-            if (!knownFiles.has(fileName)) {
-                throw new ValidationError(`Repo at index ${index} references undefined file '${fileName}'. File must be defined in root 'files' object or in a referenced group.`);
-            }
-            const fileOverride = repo.files[fileName];
-            if (fileOverride === false) {
-                continue;
-            }
-            if (fileOverride.override && !fileOverride.content) {
-                throw new ValidationError(`Repo ${repoLabel} has override: true for file '${fileName}' but no content defined. ` +
-                    `Use content: "" for an empty text file override, or content: {} for an empty JSON/YAML override.`);
+    }
+    for (const fileName of Object.keys(repo.files)) {
+        if (fileName === "inherit") {
+            const inheritValue = repo.files.inherit;
+            if (typeof inheritValue !== "boolean") {
+                throw new ValidationError(`Repo at index ${index}: files.inherit must be a boolean`);
             }
-            validateFileConfigFields(fileOverride, fileName, `Repo ${repoLabel}:`);
-        }
-    }
-    if (repo.settings !== undefined) {
-        const rootCtx = buildRootSettingsContext(config);
-        if (repo.groups && config.groups) {
-            for (const groupName of repo.groups) {
-                const group = config.groups[groupName];
-                if (group?.settings?.rulesets) {
-                    for (const name of Object.keys(group.settings.rulesets)) {
-                        if (name !== "inherit")
-                            rootCtx.rulesetNames.push(name);
-                    }
+            continue;
+        }
+        if (!knownFiles.has(fileName)) {
+            throw new ValidationError(`Repo at index ${index} references undefined file '${fileName}'. File must be defined in root 'files' object or in a referenced group.`);
+        }
+        const fileOverride = repo.files[fileName];
+        if (fileOverride === false) {
+            continue;
+        }
+        if (fileOverride.override && !fileOverride.content) {
+            throw new ValidationError(`Repo ${repoLabel} has override: true for file '${fileName}' but no content defined. ` +
+                `Use content: "" for an empty text file override, or content: {} for an empty JSON/YAML override.`);
+        }
+        validateFileConfigFields(fileOverride, fileName, `Repo ${repoLabel}:`);
+    }
+}
+function validateRepoSettingsEntry(config, repo, repoLabel) {
+    if (repo.settings === undefined)
+        return;
+    const rootCtx = buildRootSettingsContext(config);
+    if (repo.groups && config.groups) {
+        for (const groupName of repo.groups) {
+            const group = config.groups[groupName];
+            if (group?.settings?.rulesets) {
+                for (const name of Object.keys(group.settings.rulesets)) {
+                    if (name !== "inherit")
+                        rootCtx.rulesetNames.push(name);
                 }
-                if (group?.settings?.labels) {
-                    for (const name of Object.keys(group.settings.labels)) {
-                        if (name !== "inherit")
-                            rootCtx.labelNames.push(name);
-                    }
+            }
+            if (group?.settings?.labels) {
+                for (const name of Object.keys(group.settings.labels)) {
+                    if (name !== "inherit")
+                        rootCtx.labelNames.push(name);
                 }
             }
         }
-        validateSettings(repo.settings, `Repo ${repoLabel}`, rootCtx.rulesetNames, rootCtx.hasRepoSettings, rootCtx.labelNames);
     }
+    validateSettings(repo.settings, `Repo ${repoLabel}`, rootCtx);
+}
+function validateRepoEntry(config, repo, index) {
+    const repoLabel = validateRepoGitField(repo, index);
+    validateRepoOrigins(config, repo, repoLabel);
+    validateRepoGroups(config, repo, index);
+    validateRepoFiles(config, repo, index, repoLabel);
+    validateRepoSettingsEntry(config, repo, repoLabel);
+}
+function hasGroupFiles(config) {
+    return (isPlainObject(config.groups) &&
+        Object.values(config.groups).some((g) => g.files &&
+            Object.keys(g.files).filter((k) => k !== "inherit" && g.files[k] !== false).length > 0));
 }
 /**
  * Validates raw config structure before normalization.
@@ -418,20 +429,12 @@ function validateRepoEntry(config, repo, index) {
  */
 export function validateRawConfig(config) {
     validateConfigId(config);
-    const hasFiles = config.files &&
-        typeof config.files === "object" &&
-        Object.keys(config.files).length > 0;
-    const hasSettings = config.settings && typeof config.settings === "object";
-    const hasGroupFiles = config.groups &&
-        typeof config.groups === "object" &&
-        !Array.isArray(config.groups) &&
-        Object.values(config.groups).some((g) => g.files &&
-            Object.keys(g.files).filter((k) => k !== "inherit" && g.files[k] !== false).length > 0);
-    const hasGroupSettings = config.groups &&
-        typeof config.groups === "object" &&
-        !Array.isArray(config.groups) &&
-        Object.values(config.groups).some((g) => g.settings && typeof g.settings === "object");
-    if (!hasFiles && !hasSettings && !hasGroupFiles && !hasGroupSettings) {
+    const hasFiles = isPlainObject(config.files) && Object.keys(config.files).length > 0;
+    const hasSettings = isPlainObject(config.settings);
+    const hasGrpFiles = hasGroupFiles(config);
+    const hasGrpSettings = isPlainObject(config.groups) &&
+        Object.values(config.groups).some((g) => g.settings && isPlainObject(g.settings));
+    if (!hasFiles && !hasSettings && !hasGrpFiles && !hasGrpSettings) {
         throw new ValidationError("Config requires at least one of: 'files' or 'settings'. " +
             "Use 'files' to sync configuration files, or 'settings' to manage repository settings.");
     }
@@ -456,21 +459,17 @@ export function validateRawConfig(config) {
 // =============================================================================
 /**
  * Validates that config is suitable for the sync command.
- * @throws Error if files section is missing or empty
+ * @throws ValidationError if neither files nor settings are present
  */
 export function validateForSync(config) {
     const hasRootFiles = config.files && Object.keys(config.files).length > 0;
-    const hasGroupFiles = config.groups &&
-        Object.values(config.groups).some((g) => g.files &&
-            Object.keys(g.files).filter((k) => k !== "inherit" && g.files[k] !== false).length > 0);
+    const hasGrpFiles = hasGroupFiles(config);
     const hasSettings = hasActionableSettings(config.settings);
     const hasRepoSettings = config.repos.some((repo) => hasActionableSettings(repo.settings));
-    const hasGroupSettings = config.groups &&
-        typeof config.groups === "object" &&
-        !Array.isArray(config.groups) &&
+    const hasGroupSettings = isPlainObject(config.groups) &&
         Object.values(config.groups).some((g) => g.settings && hasActionableSettings(g.settings));
     if (!hasRootFiles &&
-        !hasGroupFiles &&
+        !hasGrpFiles &&
         !hasSettings &&
         !hasRepoSettings &&
         !hasGroupSettings) {

package/dist/config/validators/file-validator.d.ts

@@ -1,10 +1,8 @@
 import { isTextContent } from "../merge.js";
+import { isPlainObject } from "../../shared/type-guards.js";
 export { isTextContent };
+export { isPlainObject as isObjectContent };
 declare const VALID_STRATEGIES: string[];
-/**
- * Check if content is object type (for JSON/YAML output).
- */
-export declare function isObjectContent(content: unknown): boolean;
 /**
  * Check if file extension is for structured output (JSON/YAML).
  */

package/dist/config/validators/file-validator.js

@@ -1,14 +1,10 @@
 import { extname, isAbsolute } from "node:path";
 import { isTextContent } from "../merge.js";
-import { ValidationError } from "../errors.js";
+import { ValidationError } from "../../shared/errors.js";
+import { isPlainObject } from "../../shared/type-guards.js";
 export { isTextContent };
+export { isPlainObject as isObjectContent };
 const VALID_STRATEGIES = ["replace", "append", "prepend"];
-/**
- * Check if content is object type (for JSON/YAML output).
- */
-export function isObjectContent(content) {
-    return (typeof content === "object" && content !== null && !Array.isArray(content));
-}
 /**
  * Check if file extension is for structured output (JSON/YAML).
  */

package/dist/config/validators/repo-settings-validator.js

@@ -1,4 +1,4 @@
-import { ValidationError } from "../errors.js";
+import { ValidationError } from "../../shared/errors.js";
 const VALID_VISIBILITY = ["public", "private", "internal"];
 const VALID_SQUASH_MERGE_COMMIT_TITLE = ["PR_TITLE", "COMMIT_OR_PR_TITLE"];
 const VALID_SQUASH_MERGE_COMMIT_MESSAGE = [

package/dist/config/validators/ruleset-validator.js

@@ -1,29 +1,45 @@
-import { ValidationError } from "../errors.js";
-const VALID_RULESET_TARGETS = ["branch", "tag"];
-const VALID_ENFORCEMENT_LEVELS = ["active", "disabled", "evaluate"];
-const VALID_ACTOR_TYPES = ["Team", "User", "Integration"];
-const VALID_BYPASS_MODES = ["always", "pull_request"];
+import { ValidationError } from "../../shared/errors.js";
+/** Compile-time validates an array matches a type union, while keeping string[] runtime type for .includes() */
+function validValues(values) {
+    return values;
+}
+const VALID_RULESET_TARGETS = validValues(["branch", "tag"]);
+const VALID_ENFORCEMENT_LEVELS = validValues([
+    "active",
+    "disabled",
+    "evaluate",
+]);
+const VALID_ACTOR_TYPES = validValues([
+    "Team",
+    "User",
+    "Integration",
+]);
+const VALID_BYPASS_MODES = validValues(["always", "pull_request"]);
 const VALID_PATTERN_OPERATORS = [
     "starts_with",
     "ends_with",
     "contains",
     "regex",
 ];
-const VALID_MERGE_METHODS = ["merge", "squash", "rebase"];
-const VALID_ALERTS_THRESHOLDS = [
+const VALID_MERGE_METHODS = validValues([
+    "merge",
+    "squash",
+    "rebase",
+]);
+const VALID_ALERTS_THRESHOLDS = validValues([
     "none",
     "errors",
     "errors_and_warnings",
     "all",
-];
-const VALID_SECURITY_THRESHOLDS = [
+]);
+const VALID_SECURITY_THRESHOLDS = validValues([
     "none",
     "critical",
     "high_or_higher",
     "medium_or_higher",
     "all",
-];
-const VALID_RULE_TYPES = [
+]);
+const VALID_RULE_TYPES = validValues([
     "pull_request",
     "required_status_checks",
     "required_signatures",
@@ -45,7 +61,7 @@ const VALID_RULE_TYPES = [
     "file_extension_restriction",
     "max_file_path_length",
     "max_file_size",
-];
+]);
 /**
  * Validates a single ruleset rule.
  */

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { runSync } from "./cli/index.js";
 export type { SyncOptions, SharedOptions } from "./cli/index.js";
-export { type IRepositoryProcessor, type ProcessorFactory, defaultProcessorFactory, type IRulesetProcessor, type RulesetProcessorFactory, defaultRulesetProcessorFactory, type RepoSettingsProcessorFactory, defaultRepoSettingsProcessorFactory, type ILabelsProcessor, type LabelsProcessorFactory, defaultLabelsProcessorFactory, } from "./cli/index.js";
+export { type ProcessorFactory, type RulesetProcessorFactory, type RepoSettingsProcessorFactory, type LabelsProcessorFactory, } from "./cli/index.js";
+export type { IRepositoryProcessor } from "./sync/index.js";
+export type { IRulesetProcessor, ILabelsProcessor } from "./settings/index.js";

package/dist/index.js

@@ -1,3 +1,2 @@
 // Public API for library consumers
 export { runSync } from "./cli/index.js";
-export { defaultProcessorFactory, defaultRulesetProcessorFactory, defaultRepoSettingsProcessorFactory, defaultLabelsProcessorFactory, } from "./cli/index.js";

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

@@ -8,8 +8,9 @@ import type { IMigrationSource, LifecyclePlatform } from "./types.js";
 export declare class AdoMigrationSource implements IMigrationSource {
     private readonly executor;
     private readonly retries;
+    private readonly cwd;
     readonly platform: LifecyclePlatform;
-    constructor(executor?: ICommandExecutor, retries?: number);
+    constructor(executor: ICommandExecutor, retries: number | undefined, cwd: string);
     private assertAdo;
     cloneForMigration(repoInfo: RepoInfo, workDir: string): Promise<void>;
 }

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

@@ -1,7 +1,7 @@
 import { escapeShellArg } from "../shared/shell-utils.js";
-import { defaultExecutor, } from "../shared/command-executor.js";
 import { withRetry } from "../shared/retry-utils.js";
 import { toErrorMessage } from "../shared/type-guards.js";
+import { LifecycleError } from "../shared/errors.js";
 import { isAzureDevOpsRepo, } from "../shared/repo-detector.js";
 /**
  * Azure DevOps implementation of IMigrationSource.
@@ -10,27 +10,29 @@ import { isAzureDevOpsRepo, } from "../shared/repo-detector.js";
 export class AdoMigrationSource {
     executor;
     retries;
+    cwd;
     platform = "azure-devops";
-    constructor(executor = defaultExecutor, retries = 3) {
+    constructor(executor, retries = 3, cwd) {
         this.executor = executor;
         this.retries = retries;
+        this.cwd = cwd;
     }
     assertAdo(repoInfo) {
         if (!isAzureDevOpsRepo(repoInfo)) {
-            throw new Error(`AdoMigrationSource requires Azure DevOps repo, got: ${repoInfo.type}`);
+            throw new LifecycleError(`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()), {
+            await withRetry(() => this.executor.exec(command, this.cwd), {
                 retries: this.retries,
             });
         }
         catch (error) {
             const msg = toErrorMessage(error);
-            throw new Error(`Failed to clone migration source ${repoInfo.gitUrl}: ${msg}. ` +
+            throw new LifecycleError(`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

@@ -1,18 +1,20 @@
 import { ICommandExecutor } from "../shared/command-executor.js";
 import { type RepoInfo } from "../shared/repo-detector.js";
+import type { DebugWarnLog } from "../shared/logger.js";
 import type { IRepoLifecycleProvider, LifecyclePlatform, CreateRepoSettings } from "./types.js";
 /**
  * GitHub implementation of IRepoLifecycleProvider.
  * Uses gh CLI for all operations.
  */
 interface GitHubLifecycleProviderOptions {
-    executor?: ICommandExecutor;
+    executor: ICommandExecutor;
     retries?: number;
-    cwd?: string;
+    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;
+    log?: DebugWarnLog;
 }
 export declare class GitHubLifecycleProvider implements IRepoLifecycleProvider {
     readonly platform: LifecyclePlatform;
@@ -21,7 +23,8 @@ export declare class GitHubLifecycleProvider implements IRepoLifecycleProvider {
     private readonly cwd;
     private readonly forkReadyTimeoutMs;
     private readonly forkPollIntervalMs;
-    constructor(options?: GitHubLifecycleProviderOptions);
+    private readonly log?;
+    constructor(options: GitHubLifecycleProviderOptions);
     /**
      * Check if a GitHub owner is an organization (vs user).
      * Uses gh api to query the user/org endpoint.