@pagopa/dx-cli 0.15.1 → 0.15.3

package/dist/domain/doctor.js

@@ -0,0 +1,50 @@
+import { ResultAsync } from "neverthrow";
+import { checkMonorepoScripts } from "./package-json.js";
+import { checkPreCommitConfig } from "./repository.js";
+import { checkTurboConfig } from "./repository.js";
+import { checkWorkspaces } from "./workspace.js";
+export const runDoctor = async (dependencies, config) => {
+    // Get repository root - doctor command requires being in a repository
+    const repoRootResult = await dependencies.repositoryReader.findRepositoryRoot();
+    if (repoRootResult.isErr()) {
+        return {
+            checks: [
+                {
+                    checkName: "Repository Detection",
+                    errorMessage: "Could not find repository root. Make sure to run this command inside a Git repository.",
+                    isValid: false,
+                },
+            ],
+            hasErrors: true,
+        };
+    }
+    const repositoryRoot = repoRootResult.value;
+    const doctorChecks = [
+        ResultAsync.fromPromise(checkPreCommitConfig(dependencies, repositoryRoot), () => new Error("Error checking pre-commit configuration")),
+        ResultAsync.fromPromise(checkTurboConfig(dependencies, repositoryRoot, config), () => new Error("Error checking Turbo configuration")),
+        ResultAsync.fromPromise(checkMonorepoScripts(dependencies, repositoryRoot), () => new Error("Error checking monorepo scripts")),
+        ResultAsync.fromPromise(checkWorkspaces(dependencies, repositoryRoot), () => new Error("Error checking monorepo scripts")),
+    ];
+    return ResultAsync.combine(doctorChecks).match(toDoctorResult, () => ({
+        checks: [],
+        hasErrors: true,
+    }));
+};
+const toDoctorResult = (validationCheckResults) => {
+    const checks = validationCheckResults.map((result) => {
+        if (result.isOk()) {
+            return result.value;
+        }
+        return {
+            checkName: "Unknown",
+            errorMessage: result.error.message,
+            isValid: false,
+        };
+    });
+    const hasErrors = checks.some((check) => !check.isValid);
+    return {
+        checks,
+        hasErrors,
+    };
+};
+export const printDoctorResult = ({ validationReporter }, result) => result.checks.map(validationReporter.reportCheckResult);

package/dist/domain/environment.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod/v4";
+import { CloudAccount, CloudAccountService } from "./cloud-account.js";
+import { TerraformBackend } from "./remote-backend.js";
+export declare const environmentShort: Record<Environment["name"], string>;
+export declare const environmentSchema: z.ZodObject<{
+    cloudAccounts: z.ZodArray<z.ZodObject<{
+        csp: z.ZodDefault<z.ZodEnum<{
+            azure: "azure";
+        }>>;
+        defaultLocation: z.ZodString;
+        displayName: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    name: z.ZodEnum<{
+        dev: "dev";
+        prod: "prod";
+        uat: "uat";
+    }>;
+    prefix: z.ZodString;
+}, z.core.$strip>;
+export type Environment = z.infer<typeof environmentSchema>;
+export type EnvironmentId = Pick<Environment, "name" | "prefix">;
+export type EnvironmentInitStatus = {
+    initialized: false;
+    issues: EnvironmentInitIssue[];
+} | {
+    initialized: true;
+};
+type CloudAccountNotInitializedIssue = {
+    cloudAccount: CloudAccount;
+    type: "CLOUD_ACCOUNT_NOT_INITIALIZED";
+};
+type EnvironmentInitIssue = CloudAccountNotInitializedIssue | MissingRemoteBackendIssue;
+type MissingRemoteBackendIssue = {
+    type: "MISSING_REMOTE_BACKEND";
+};
+export declare function getInitializationStatus(cloudAccountService: CloudAccountService, environment: Environment): Promise<EnvironmentInitStatus>;
+export declare function getTerraformBackend(cloudAccountService: CloudAccountService, environment: Environment): Promise<TerraformBackend | undefined>;
+export declare function hasUserPermissionToInitialize(cloudAccountService: CloudAccountService, environment: Environment): Promise<boolean>;
+export {};

package/dist/domain/environment.js

@@ -0,0 +1,57 @@
+import { z } from "zod/v4";
+import { cloudAccountSchema, } from "./cloud-account.js";
+export const environmentShort = {
+    dev: "d",
+    prod: "p",
+    uat: "u",
+};
+export const environmentSchema = z.object({
+    cloudAccounts: z.array(cloudAccountSchema).min(1),
+    name: z.enum(["dev", "prod", "uat"]),
+    prefix: z.string().min(2).max(4),
+});
+export async function getInitializationStatus(cloudAccountService, environment) {
+    const issues = [];
+    for (const cloudAccount of environment.cloudAccounts) {
+        const initialized = await cloudAccountService.isInitialized(cloudAccount.id, environment);
+        if (!initialized) {
+            issues.push({
+                cloudAccount,
+                type: "CLOUD_ACCOUNT_NOT_INITIALIZED",
+            });
+        }
+    }
+    const terraformBackend = await getTerraformBackend(cloudAccountService, environment);
+    if (!terraformBackend) {
+        issues.push({
+            type: "MISSING_REMOTE_BACKEND",
+        });
+    }
+    if (issues.length > 0) {
+        return {
+            initialized: false,
+            issues,
+        };
+    }
+    return {
+        initialized: true,
+    };
+}
+export async function getTerraformBackend(cloudAccountService, environment) {
+    for (const cloudAccount of environment.cloudAccounts) {
+        const backend = await cloudAccountService.getTerraformBackend(cloudAccount.id, environment);
+        if (backend) {
+            return backend;
+        }
+    }
+    return undefined;
+}
+export async function hasUserPermissionToInitialize(cloudAccountService, environment) {
+    for (const cloudAccount of environment.cloudAccounts) {
+        const result = await cloudAccountService.hasUserPermissionToInitialize(cloudAccount.id);
+        if (!result) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/domain/github-repo.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod/v4";
+export declare const githubRepoSchema: z.ZodObject<{
+    owner: z.ZodString;
+    repo: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>;
+export type GitHubRepo = z.infer<typeof githubRepoSchema>;

package/dist/domain/github-repo.js

@@ -0,0 +1,8 @@
+import { z } from "zod/v4";
+export const githubRepoSchema = z.object({
+    owner: z.string().min(1),
+    repo: z
+        .string()
+        .min(1)
+        .transform((repo) => repo.replace(/\.git$/, "")),
+});

package/dist/domain/github.d.ts

@@ -0,0 +1,37 @@
+export interface GitHubService {
+    /**
+     * Creates a pull request in a GitHub repository.
+     * @throws Error if pull request creation fails
+     */
+    createPullRequest(params: PullRequestBody): Promise<PullRequest>;
+    /**
+     * Gets a GitHub repository by owner and name.
+     * @throws RepositoryNotFoundError if repository doesn't exist (404)
+     * @throws Error for other failures
+     */
+    getRepository(owner: string, name: string): Promise<Repository>;
+}
+type PullRequestBody = {
+    base: string;
+    body: string;
+    head: string;
+    owner: string;
+    repo: string;
+    title: string;
+};
+export declare class PullRequest {
+    readonly url: string;
+    constructor(url: string);
+}
+export declare class Repository {
+    readonly name: string;
+    readonly owner: string;
+    get fullName(): string;
+    get ssh(): string;
+    get url(): string;
+    constructor(name: string, owner: string);
+}
+export declare class RepositoryNotFoundError extends Error {
+    constructor(owner: string, name: string);
+}
+export {};

package/dist/domain/github.js

@@ -0,0 +1,29 @@
+export class PullRequest {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+}
+export class Repository {
+    name;
+    owner;
+    get fullName() {
+        return `${this.owner}/${this.name}`;
+    }
+    get ssh() {
+        return `git@github.com:${this.owner}/${this.name}.git`;
+    }
+    get url() {
+        return `https://github.com/${this.owner}/${this.name}`;
+    }
+    constructor(name, owner) {
+        this.name = name;
+        this.owner = owner;
+    }
+}
+export class RepositoryNotFoundError extends Error {
+    constructor(owner, name) {
+        super(`Repository ${owner}/${name} not found`);
+        this.name = "RepositoryNotFoundError";
+    }
+}

package/dist/domain/info.d.ts

@@ -0,0 +1,11 @@
+import { Dependencies } from "./dependencies.js";
+import { PackageManager } from "./package-json.js";
+export type InfoResult = {
+    node?: string;
+    packageManager: PackageManager;
+    terraform?: string;
+    turbo?: string;
+};
+export type GetInfo = () => Promise<InfoResult>;
+export declare const getInfo: (dependencies: Dependencies) => GetInfo;
+export declare const printInfo: (result: InfoResult) => void;

package/dist/domain/info.js

@@ -0,0 +1,52 @@
+import { getLogger } from "@logtape/logtape";
+import { join } from "node:path";
+const detectFromLockFile = async (dependencies, repositoryRoot) => {
+    const { repositoryReader } = dependencies;
+    const pnpmResult = await repositoryReader.fileExists(join(repositoryRoot, "pnpm-lock.yaml"));
+    if (pnpmResult.isOk() && pnpmResult.value)
+        return "pnpm";
+    const yarnResult = await repositoryReader.fileExists(join(repositoryRoot, "yarn.lock"));
+    if (yarnResult.isOk() && yarnResult.value)
+        return "yarn";
+    const npmResult = await repositoryReader.fileExists(join(repositoryRoot, "package-lock.json"));
+    if (npmResult.isOk() && npmResult.value)
+        return "npm";
+    return undefined;
+};
+const detectPackageManager = async (dependencies, repositoryRoot) => {
+    // Try to read package.json to get packageManager field
+    const packageJsonResult = await dependencies.packageJsonReader.readPackageJson(repositoryRoot);
+    const packageManager = packageJsonResult.map((pkg) => pkg.packageManager).unwrapOr(undefined) ??
+        (await detectFromLockFile(dependencies, repositoryRoot));
+    return packageManager ?? "npm";
+};
+const detectNodeVersion = async ({ repositoryReader }, nodeVersionFilePath) => await repositoryReader
+    .readFile(nodeVersionFilePath)
+    .map((nodeVersion) => nodeVersion.trim())
+    .unwrapOr(undefined);
+const detectTerraformVersion = async ({ repositoryReader }, terraformVersionFilePath) => await repositoryReader
+    .readFile(terraformVersionFilePath)
+    .map((tfVersion) => tfVersion.trim())
+    .unwrapOr(undefined);
+const detectTurboVersion = async (dependencies, repositoryRoot) => {
+    const packageJsonResult = await dependencies.packageJsonReader.readPackageJson(repositoryRoot);
+    return packageJsonResult
+        .map((pkg) => pkg.devDependencies.get("turbo")?.trim())
+        .unwrapOr(undefined);
+};
+export const getInfo = (dependencies) => async () => {
+    // Get repository root, fallback to current working directory if not in a repository
+    const repositoryRoot = await dependencies.repositoryReader
+        .findRepositoryRoot()
+        .unwrapOr(process.cwd());
+    return {
+        node: await detectNodeVersion({ repositoryReader: dependencies.repositoryReader }, `${repositoryRoot}/.node-version`),
+        packageManager: await detectPackageManager(dependencies, repositoryRoot),
+        terraform: await detectTerraformVersion({ repositoryReader: dependencies.repositoryReader }, `${repositoryRoot}/.terraform-version`),
+        turbo: await detectTurboVersion(dependencies, repositoryRoot),
+    };
+};
+export const printInfo = (result) => {
+    const logger = getLogger("json");
+    logger.info(JSON.stringify(result));
+};

package/dist/domain/package-json.d.ts

@@ -0,0 +1,42 @@
+import { ResultAsync } from "neverthrow";
+import { z } from "zod/v4";
+import { Dependencies } from "./dependencies.js";
+import { ValidationCheckResult } from "./validation.js";
+export declare const scriptSchema: z.ZodObject<{
+    name: z.core.$ZodBranded<z.ZodString, "ScriptName">;
+    script: z.ZodString;
+}, z.core.$strip>;
+export declare const dependencySchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strip>;
+declare const PackageName: z.core.$ZodBranded<z.ZodString, "PackageName">;
+export type PackageName = z.infer<typeof PackageName>;
+declare const packageManagerSchema: z.ZodEnum<{
+    npm: "npm";
+    pnpm: "pnpm";
+    yarn: "yarn";
+}>;
+export declare const packageJsonSchema: z.ZodObject<{
+    dependencies: z.ZodPipe<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodTransform<Map<string, string>, Record<string, string> | undefined>>;
+    devDependencies: z.ZodPipe<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodTransform<Map<string, string>, Record<string, string> | undefined>>;
+    name: z.core.$ZodBranded<z.ZodString, "PackageName">;
+    packageManager: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodEnum<{
+        npm: "npm";
+        pnpm: "pnpm";
+        yarn: "yarn";
+    }>>>;
+    scripts: z.ZodPipe<z.ZodOptional<z.ZodRecord<z.core.$ZodBranded<z.ZodString, "ScriptName">, z.ZodString>>, z.ZodTransform<Map<string & z.core.$brand<"ScriptName">, string>, Record<string & z.core.$brand<"ScriptName">, string> | undefined>>;
+}, z.core.$strip>;
+export type Dependency = z.infer<typeof dependencySchema>;
+export type PackageJson = z.infer<typeof packageJsonSchema>;
+export type PackageJsonReader = {
+    getDependencies(cwd: string, type: "dev" | "prod"): ResultAsync<Map<Dependency["name"], Dependency["version"]>, Error>;
+    getRootRequiredScripts(): Map<Script["name"], Script["script"]>;
+    getScripts(cwd: string): ResultAsync<Map<Script["name"], Script["script"]>, Error>;
+    readPackageJson(cwd: string): ResultAsync<PackageJson, Error>;
+};
+export type PackageManager = z.infer<typeof packageManagerSchema>;
+export type Script = z.infer<typeof scriptSchema>;
+export declare const checkMonorepoScripts: (dependencies: Pick<Dependencies, "packageJsonReader">, repositoryRoot: string) => Promise<ValidationCheckResult>;
+export {};

package/dist/domain/package-json.js

@@ -0,0 +1,69 @@
+import { err, ok } from "neverthrow";
+import { z } from "zod/v4";
+const ScriptName = z.string().brand();
+export const scriptSchema = z.object({
+    name: ScriptName,
+    script: z.string(),
+});
+export const dependencySchema = z.object({
+    name: z.string(),
+    version: z.string(),
+});
+const PackageName = z.string().min(1).brand();
+const scriptsSchema = z
+    .record(ScriptName, z.string())
+    .optional()
+    .transform((obj) => new Map(obj
+    ? Object.entries(obj).map(([name, script]) => [
+        ScriptName.parse(name),
+        script,
+    ])
+    : []));
+const dependenciesSchema = z
+    // An object where keys are Dependency["name"] and values are their versions (string for now, but we could type them as well)
+    .record(z.string(), z.string())
+    .optional()
+    // Transform the record into a Map<Dependency["name"], Dependency["version"]>
+    .transform((obj) => new Map(obj
+    ? Object.entries(obj).map(([name, version]) => [name, version])
+    : []));
+const packageManagerSchema = z.enum(["npm", "pnpm", "yarn"]);
+export const packageJsonSchema = z.object({
+    dependencies: dependenciesSchema,
+    devDependencies: dependenciesSchema,
+    name: PackageName,
+    packageManager: z
+        .string()
+        .transform((str) => str.split("@")[0])
+        .pipe(packageManagerSchema)
+        .optional(),
+    scripts: scriptsSchema,
+});
+const findMissingScripts = (availableScripts, requiredScripts) => {
+    const availableScriptNames = new Set(availableScripts.keys());
+    const requiredScriptNames = new Set(requiredScripts.keys());
+    // Returns a set of scripts that are required, but not listed in the package.json
+    return requiredScriptNames.difference(availableScriptNames);
+};
+export const checkMonorepoScripts = async (dependencies, repositoryRoot) => {
+    const { packageJsonReader } = dependencies;
+    const checkName = "Monorepo Scripts";
+    const scriptsResult = await packageJsonReader.getScripts(repositoryRoot);
+    if (scriptsResult.isErr()) {
+        return err(scriptsResult.error);
+    }
+    const requiredScriptsMap = packageJsonReader.getRootRequiredScripts();
+    const missingScripts = findMissingScripts(scriptsResult.value, requiredScriptsMap);
+    if (missingScripts.size === 0) {
+        return ok({
+            checkName,
+            isValid: true,
+            successMessage: "Monorepo scripts are correctly set up",
+        });
+    }
+    return ok({
+        checkName,
+        errorMessage: `Missing required scripts: ${Array.from(missingScripts).join(", ")}`,
+        isValid: false,
+    });
+};

package/dist/domain/remote-backend.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod/v4";
+export declare const terraformBackendSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    resourceGroupName: z.ZodString;
+    storageAccountName: z.ZodString;
+    subscriptionId: z.ZodString;
+    type: z.ZodLiteral<"azurerm">;
+}, z.core.$strip>], "type">;
+export type TerraformBackend = z.infer<typeof terraformBackendSchema>;

package/dist/domain/remote-backend.js

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+export const terraformBackendSchema = z.discriminatedUnion("type", [
+    z.object({
+        resourceGroupName: z.string().min(1),
+        storageAccountName: z.string().min(1),
+        subscriptionId: z.string().min(1),
+        type: z.literal("azurerm"),
+    }),
+]);

package/dist/domain/repository.d.ts

@@ -0,0 +1,13 @@
+import { ResultAsync } from "neverthrow";
+import { Config } from "../config.js";
+import { Dependencies } from "./dependencies.js";
+import { ValidationCheckResult } from "./validation.js";
+import { Workspace } from "./workspace.js";
+export type RepositoryReader = {
+    fileExists(path: string): ResultAsync<boolean, Error>;
+    findRepositoryRoot(cwd?: string): ResultAsync<string, Error>;
+    getWorkspaces(repoRoot: string): ResultAsync<Workspace[], Error>;
+    readFile(path: string): ResultAsync<string, Error>;
+};
+export declare const checkPreCommitConfig: (dependencies: Pick<Dependencies, "repositoryReader">, repositoryRoot: string) => Promise<ValidationCheckResult>;
+export declare const checkTurboConfig: (dependencies: Pick<Dependencies, "packageJsonReader" | "repositoryReader">, repositoryRoot: string, config: Config) => Promise<ValidationCheckResult>;

package/dist/domain/repository.js

@@ -0,0 +1,72 @@
+import { ok } from "neverthrow";
+import fs from "node:path";
+import coerce from "semver/functions/coerce.js";
+import semverGte from "semver/functions/gte.js";
+const isVersionValid = (version, minVersion) => {
+    const minAcceptedSemVer = coerce(minVersion);
+    const dependencySemVer = coerce(version);
+    if (!minAcceptedSemVer || !dependencySemVer) {
+        return false;
+    }
+    return semverGte(dependencySemVer, minAcceptedSemVer);
+};
+export const checkPreCommitConfig = async (dependencies, repositoryRoot) => {
+    const { repositoryReader } = dependencies;
+    const checkName = "Pre-commit Configuration";
+    const preCommitResult = await repositoryReader.fileExists(fs.join(repositoryRoot, ".pre-commit-config.yaml"));
+    if (preCommitResult.isOk() && preCommitResult.value) {
+        return ok({
+            checkName,
+            isValid: true,
+            successMessage: "Pre-commit configuration is present in the repository root",
+        });
+    }
+    const errorMessage = preCommitResult.isErr()
+        ? preCommitResult.error.message
+        : `Pre-commit configuration is not present in the repository root. Please add a .pre-commit-config.yaml file to the repository root.`;
+    return ok({
+        checkName,
+        errorMessage,
+        isValid: false,
+    });
+};
+export const checkTurboConfig = async (dependencies, repositoryRoot, config) => {
+    const { packageJsonReader, repositoryReader } = dependencies;
+    const checkName = "Turbo Configuration";
+    const turboResult = await repositoryReader.fileExists(fs.join(repositoryRoot, "turbo.json"));
+    if (turboResult.isErr()) {
+        return ok({
+            checkName,
+            errorMessage: turboResult.error.message,
+            isValid: false,
+        });
+    }
+    const dependenciesResult = await packageJsonReader.getDependencies(repositoryRoot, "dev");
+    if (dependenciesResult.isErr()) {
+        return ok({
+            checkName,
+            errorMessage: dependenciesResult.error.message,
+            isValid: false,
+        });
+    }
+    const turboVersion = dependenciesResult.value.get("turbo");
+    if (!turboVersion) {
+        return ok({
+            checkName,
+            errorMessage: "Turbo dependency not found in devDependencies. Please add 'turbo' to your devDependencies.",
+            isValid: false,
+        });
+    }
+    if (!isVersionValid(turboVersion, config.minVersions.turbo)) {
+        return ok({
+            checkName,
+            errorMessage: `Turbo version (${turboVersion}) is too low. Minimum required version is ${config.minVersions.turbo}.`,
+            isValid: false,
+        });
+    }
+    return ok({
+        checkName,
+        isValid: true,
+        successMessage: "Turbo configuration is present in the monorepo root and turbo dependency is installed",
+    });
+};

package/dist/domain/validation.d.ts

@@ -0,0 +1,16 @@
+import { Result } from "neverthrow";
+export type ValidationCheck = FailedCheck | SuccessfulCheck;
+export type ValidationCheckResult = Result<ValidationCheck, Error>;
+export type ValidationReporter = {
+    reportCheckResult(result: ValidationCheck): void;
+};
+type FailedCheck = Pick<SuccessfulCheck, "checkName"> & {
+    errorMessage: string;
+    isValid: false;
+};
+type SuccessfulCheck = {
+    checkName: string;
+    isValid: true;
+    successMessage: string;
+};
+export {};

package/dist/domain/validation.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/workspace.d.ts

@@ -0,0 +1,9 @@
+import { z } from "zod/v4";
+import { Dependencies } from "./dependencies.js";
+import { ValidationCheckResult } from "./validation.js";
+export declare const workspaceSchema: z.ZodObject<{
+    name: z.core.$ZodBranded<z.ZodString, "WorkspaceName">;
+    path: z.ZodString;
+}, z.core.$strip>;
+export type Workspace = z.infer<typeof workspaceSchema>;
+export declare const checkWorkspaces: (dependencies: Pick<Dependencies, "repositoryReader">, monorepoDir: string) => Promise<ValidationCheckResult>;

package/dist/domain/workspace.js

@@ -0,0 +1,32 @@
+import { ok } from "neverthrow";
+import { z } from "zod/v4";
+const WorkspaceName = z.string().min(1).brand();
+export const workspaceSchema = z.object({
+    name: WorkspaceName,
+    path: z.string(),
+});
+export const checkWorkspaces = async (dependencies, monorepoDir) => {
+    const { repositoryReader } = dependencies;
+    const checkName = "Workspaces";
+    const workspacesResult = await repositoryReader.getWorkspaces(monorepoDir);
+    if (workspacesResult.isErr()) {
+        return ok({
+            checkName,
+            errorMessage: "Something is wrong with the workspaces configuration. If you need help, please contact the DevEx team.",
+            isValid: false,
+        });
+    }
+    const { length: workspaceNumber } = workspacesResult.value;
+    if (workspaceNumber === 0) {
+        return ok({
+            checkName,
+            errorMessage: "No workspace configuration found. Make sure to configure workspaces in pnpm-workspace.yaml.",
+            isValid: false,
+        });
+    }
+    return ok({
+        checkName,
+        isValid: true,
+        successMessage: `Found ${workspaceNumber} workspace${workspaceNumber === 1 ? "" : "s"}`,
+    });
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import "core-js/actual/set/index.js";
+export declare const runCli: (version: string) => void;

package/dist/index.js

@@ -0,0 +1,35 @@
+import "core-js/actual/set/index.js";
+import { Octokit } from "octokit";
+import codemodRegistry from "./adapters/codemods/index.js";
+import { makeCli } from "./adapters/commander/index.js";
+import { makeValidationReporter } from "./adapters/logtape/validation-reporter.js";
+import { makePackageJsonReader } from "./adapters/node/package-json.js";
+import { makeRepositoryReader } from "./adapters/node/repository.js";
+import { OctokitGitHubService } from "./adapters/octokit/index.js";
+import { getConfig } from "./config.js";
+import { getInfo } from "./domain/info.js";
+import { applyCodemodById } from "./use-cases/apply-codemod.js";
+import { listCodemods } from "./use-cases/list-codemods.js";
+export const runCli = (version) => {
+    // Creating the adapters
+    const repositoryReader = makeRepositoryReader();
+    const packageJsonReader = makePackageJsonReader();
+    const validationReporter = makeValidationReporter();
+    const octokit = new Octokit({
+        auth: process.env.GITHUB_TOKEN,
+    });
+    const gitHubService = new OctokitGitHubService(octokit);
+    const deps = {
+        gitHubService,
+        packageJsonReader,
+        repositoryReader,
+        validationReporter,
+    };
+    const config = getConfig();
+    const useCases = {
+        applyCodemodById: applyCodemodById(codemodRegistry, getInfo(deps)),
+        listCodemods: listCodemods(codemodRegistry),
+    };
+    const program = makeCli(deps, config, useCases, version);
+    program.parse();
+};

package/dist/use-cases/__tests__/apply-codemod.test.d.ts

@@ -0,0 +1 @@
+export {};