@decohere/forge 0.0.1-dev.5

package/es6/src/actions/dependency-report.action.js

@@ -0,0 +1,134 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { injectable } from "@decohere/crucible/decorators";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { io } from "@decohere/nexus/io";
+import { scribe } from "@decohere/scribe";
+import { formatUnknownError } from "../errors.js";
+// biome-ignore lint/style/useImportType: <DI>
+import { DependencyResolver } from "../services/dependency-resolver.service.js";
+export class ReportDependencies {
+    workspace;
+    resolver;
+    #logger = scribe.logger(ReportDependencies.name);
+    constructor(workspace, resolver){
+        this.workspace = workspace;
+        this.resolver = resolver;
+    }
+    async run(options) {
+        const { configuration, file, failOnDrift } = options;
+        try {
+            const projectDeps = await this.analyzeWorkspace(this.workspace, configuration);
+            this.logReport(projectDeps);
+            if (file) {
+                await this.writeReportFile(file, projectDeps);
+            }
+            if (failOnDrift) {
+                const driftReport = this.buildDriftReport(projectDeps);
+                this.throwOnDrift(driftReport);
+            }
+            return ActionResponse.Success(ReportDependencies.name, projectDeps);
+        } catch (error) {
+            const message = formatUnknownError(error);
+            return ActionResponse.Error(ReportDependencies.name, message);
+        }
+    }
+    async analyzeWorkspace(workspace, configuration) {
+        const projects = workspace.getProjects(configuration);
+        const workspacePackages = await this.resolver.getWorkspacePackages(this.workspace, projects);
+        return Promise.all(projects.map((project)=>this.analyzeProject(project, workspacePackages)));
+    }
+    async analyzeProject(project, workspacePackages) {
+        const { entry, currentPackage, updatedPackage, warnings } = await this.getDependencies(project, workspacePackages);
+        const drift = this.resolver.computeDrift(currentPackage, updatedPackage);
+        return {
+            projectName: project.name,
+            entry,
+            drift,
+            warnings
+        };
+    }
+    async getDependencies(project, workspacePackages) {
+        const currentPackage = await project.getPackageJson();
+        const { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(project, workspacePackages);
+        const entry = {
+            projectName: project.name,
+            dependencies: Object.keys(updatedPackage.dependencies ?? {}),
+            devDependencies: Object.keys(updatedPackage.devDependencies ?? {})
+        };
+        return {
+            entry,
+            currentPackage,
+            updatedPackage,
+            warnings
+        };
+    }
+    buildDriftReport(reports) {
+        return Object.fromEntries(reports.filter((r)=>r.drift != null).map((r)=>[
+                r.projectName,
+                r.drift
+            ]));
+    }
+    throwOnDrift(driftReport) {
+        const driftedProjects = Object.keys(driftReport);
+        if (driftedProjects.length > 0) {
+            for (const [projectName, drift] of Object.entries(driftReport)){
+                this.#logger.warn(`Dependency drift in '${projectName}'`, {
+                    original: drift.original,
+                    updated: drift.updated
+                });
+            }
+            throw new Error(`Dependency drift detected in: ${driftedProjects.join(", ")}`);
+        }
+    }
+    logReport(reports) {
+        for (const { entry, warnings } of reports){
+            this.#logger.info(`${entry.projectName}:`);
+            if (entry.dependencies.length) {
+                this.#logger.info(`  dependencies: ${entry.dependencies.join(", ")}`);
+            }
+            if (entry.devDependencies.length) {
+                this.#logger.info(`  devDependencies: ${entry.devDependencies.join(", ")}`);
+            }
+            for (const warning of warnings){
+                this.#logger.warn(`  warning: ${warning.file}:${warning.line}: ${warning.message}`);
+            }
+        }
+    }
+    async writeReportFile(file, reports) {
+        const lines = reports.flatMap(({ entry, warnings })=>[
+                `${entry.projectName}:`,
+                ...entry.dependencies.length ? [
+                    `  dependencies: ${entry.dependencies.join(", ")}`
+                ] : [],
+                ...entry.devDependencies.length ? [
+                    `  devDependencies: ${entry.devDependencies.join(", ")}`
+                ] : [],
+                ...warnings.map((w)=>`  warning: ${w.file}:${w.line}: ${w.message}`),
+                ""
+            ]);
+        await io.writeFile(file, lines.join("\n"), {
+            mkdir: true
+        });
+        this.#logger.info(`Report written to ${file}`);
+    }
+}
+ReportDependencies = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace,
+        typeof DependencyResolver === "undefined" ? Object : DependencyResolver
+    ])
+], ReportDependencies);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/dependency-report.action.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { io } from \"@decohere/nexus/io\";\nimport { scribe } from \"@decohere/scribe\";\nimport { formatUnknownError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { DependencyResolver } from \"../services/dependency-resolver.service.js\";\nimport type { DependencyWarning, DriftEntry, Package } from \"../types/dependency.types.js\";\n\ntype ReportOptions = {\n\tconfiguration: string;\n\tfile?: string;\n\tfailOnDrift?: boolean;\n};\n\ntype ReportEntry = {\n\tprojectName: string;\n\tdependencies: string[];\n\tdevDependencies: string[];\n};\n\ntype DriftReport = Record<string, DriftEntry>;\n\ntype ProjectReport = {\n\tprojectName: string;\n\tentry: ReportEntry;\n\tdrift: DriftEntry | null;\n\twarnings: DependencyWarning[];\n};\n\n@injectable()\nexport class ReportDependencies implements Action<ReportOptions> {\n\t#logger = scribe.logger(ReportDependencies.name);\n\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\tprivate readonly resolver: DependencyResolver,\n\t) {}\n\n\tpublic async run(options: ReportOptions): Promise<ActionResponse<ProjectReport>> {\n\t\tconst { configuration, file, failOnDrift } = options;\n\n\t\ttry {\n\t\t\tconst projectDeps = await this.analyzeWorkspace(this.workspace, configuration);\n\t\t\tthis.logReport(projectDeps);\n\n\t\t\tif (file) {\n\t\t\t\tawait this.writeReportFile(file, projectDeps);\n\t\t\t}\n\n\t\t\tif (failOnDrift) {\n\t\t\t\tconst driftReport = this.buildDriftReport(projectDeps);\n\t\t\t\tthis.throwOnDrift(driftReport);\n\t\t\t}\n\n\t\t\treturn ActionResponse.Success(ReportDependencies.name, projectDeps);\n\t\t} catch (error) {\n\t\t\tconst message = formatUnknownError(error);\n\t\t\treturn ActionResponse.Error<ProjectReport>(ReportDependencies.name, message);\n\t\t}\n\t}\n\n\tprivate async analyzeWorkspace(\n\t\tworkspace: Workspace,\n\t\tconfiguration: string,\n\t): Promise<ProjectReport[]> {\n\t\tconst projects = workspace.getProjects(configuration);\n\t\tconst workspacePackages = await this.resolver.getWorkspacePackages(\n\t\t\tthis.workspace,\n\t\t\tprojects,\n\t\t);\n\t\treturn Promise.all(\n\t\t\tprojects.map((project) => this.analyzeProject(project, workspacePackages)),\n\t\t);\n\t}\n\n\tprivate async analyzeProject(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<ProjectReport> {\n\t\tconst { entry, currentPackage, updatedPackage, warnings } = await this.getDependencies(\n\t\t\tproject,\n\t\t\tworkspacePackages,\n\t\t);\n\t\tconst drift = this.resolver.computeDrift(currentPackage, updatedPackage);\n\t\treturn { projectName: project.name, entry, drift, warnings };\n\t}\n\n\tprivate async getDependencies(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<{\n\t\tentry: ReportEntry;\n\t\tcurrentPackage: PackageJson;\n\t\tupdatedPackage: PackageJson;\n\t\twarnings: DependencyWarning[];\n\t}> {\n\t\tconst currentPackage = await project.getPackageJson();\n\t\tconst { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(\n\t\t\tproject,\n\t\t\tworkspacePackages,\n\t\t);\n\n\t\tconst entry: ReportEntry = {\n\t\t\tprojectName: project.name,\n\t\t\tdependencies: Object.keys(updatedPackage.dependencies ?? {}),\n\t\t\tdevDependencies: Object.keys(updatedPackage.devDependencies ?? {}),\n\t\t};\n\n\t\treturn { entry, currentPackage, updatedPackage, warnings };\n\t}\n\n\tprivate buildDriftReport(reports: ProjectReport[]): DriftReport {\n\t\treturn Object.fromEntries(\n\t\t\treports\n\t\t\t\t.filter((r): r is ProjectReport & { drift: DriftEntry } => r.drift != null)\n\t\t\t\t.map((r) => [r.projectName, r.drift]),\n\t\t);\n\t}\n\n\tprivate throwOnDrift(driftReport: DriftReport): void {\n\t\tconst driftedProjects = Object.keys(driftReport);\n\t\tif (driftedProjects.length > 0) {\n\t\t\tfor (const [projectName, drift] of Object.entries(driftReport)) {\n\t\t\t\tthis.#logger.warn(`Dependency drift in '${projectName}'`, {\n\t\t\t\t\toriginal: drift.original,\n\t\t\t\t\tupdated: drift.updated,\n\t\t\t\t});\n\t\t\t}\n\t\t\tthrow new Error(`Dependency drift detected in: ${driftedProjects.join(\", \")}`);\n\t\t}\n\t}\n\n\tprivate logReport(reports: ProjectReport[]) {\n\t\tfor (const { entry, warnings } of reports) {\n\t\t\tthis.#logger.info(`${entry.projectName}:`);\n\t\t\tif (entry.dependencies.length) {\n\t\t\t\tthis.#logger.info(`  dependencies: ${entry.dependencies.join(\", \")}`);\n\t\t\t}\n\t\t\tif (entry.devDependencies.length) {\n\t\t\t\tthis.#logger.info(`  devDependencies: ${entry.devDependencies.join(\", \")}`);\n\t\t\t}\n\t\t\tfor (const warning of warnings) {\n\t\t\t\tthis.#logger.warn(`  warning: ${warning.file}:${warning.line}: ${warning.message}`);\n\t\t\t}\n\t\t}\n\t}\n\n\tprivate async writeReportFile(file: string, reports: ProjectReport[]) {\n\t\tconst lines = reports.flatMap(({ entry, warnings }) => [\n\t\t\t`${entry.projectName}:`,\n\t\t\t...(entry.dependencies.length\n\t\t\t\t? [`  dependencies: ${entry.dependencies.join(\", \")}`]\n\t\t\t\t: []),\n\t\t\t...(entry.devDependencies.length\n\t\t\t\t? [`  devDependencies: ${entry.devDependencies.join(\", \")}`]\n\t\t\t\t: []),\n\t\t\t...warnings.map((w) => `  warning: ${w.file}:${w.line}: ${w.message}`),\n\t\t\t\"\",\n\t\t]);\n\t\tawait io.writeFile(file, lines.join(\"\\n\"), { mkdir: true });\n\t\tthis.#logger.info(`Report written to ${file}`);\n\t}\n}\n"],"names":["injectable","Workspace","ActionResponse","io","scribe","formatUnknownError","DependencyResolver","ReportDependencies","logger","name","workspace","resolver","run","options","configuration","file","failOnDrift","projectDeps","analyzeWorkspace","logReport","writeReportFile","driftReport","buildDriftReport","throwOnDrift","Success","error","message","Error","projects","getProjects","workspacePackages","getWorkspacePackages","Promise","all","map","project","analyzeProject","entry","currentPackage","updatedPackage","warnings","getDependencies","drift","computeDrift","projectName","getPackageJson","computeProjectDependencies","dependencies","Object","keys","devDependencies","reports","fromEntries","filter","r","driftedProjects","length","entries","warn","original","updated","join","info","warning","line","lines","flatMap","w","writeFile","mkdir"],"mappings":"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"}

package/es6/src/actions/dependency-sync.action.js

@@ -0,0 +1,92 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { injectable } from "@decohere/crucible/decorators";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { scribe } from "@decohere/scribe";
+import { formatUnknownError } from "../errors.js";
+// biome-ignore lint/style/useImportType: <DI>
+import { DependencyResolver } from "../services/dependency-resolver.service.js";
+export class SyncDependencies {
+    workspace;
+    resolver;
+    #logger = scribe.logger(SyncDependencies.name);
+    constructor(workspace, resolver){
+        this.workspace = workspace;
+        this.resolver = resolver;
+    }
+    async run(options) {
+        const { configuration, logDiff } = options;
+        const projects = this.workspace.getProjects(configuration);
+        const workspacePackages = await this.resolver.getWorkspacePackages(this.workspace, projects);
+        const computed = await Promise.all(projects.map((project)=>this.computeDependenciesFor(project, workspacePackages)));
+        const results = computed.map((c)=>c.syncResult);
+        if (results.some((r)=>!r.succeeded)) {
+            return ActionResponse.Error(SyncDependencies.name, results);
+        }
+        const succeeded = computed.filter((c)=>c.succeeded);
+        await Promise.all(succeeded.map((c)=>c.project.persistPackageJson(c.updatedPackage)));
+        const syncResults = succeeded.map((c)=>{
+            const drift = this.resolver.computeDrift(c.originalPackage, c.updatedPackage);
+            if (drift && logDiff) {
+                this.#logger.warn(`Dependency drift synced in '${c.syncResult.projectName}'`, drift);
+            }
+            return {
+                ...c.syncResult,
+                drift
+            };
+        });
+        const failedResults = results.filter((r)=>!r.succeeded);
+        return ActionResponse.Success(SyncDependencies.name, [
+            ...syncResults,
+            ...failedResults
+        ]);
+    }
+    async computeDependenciesFor(project, workspacePackages) {
+        try {
+            const originalPackage = await project.getPackageJson();
+            const { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(project, workspacePackages);
+            for (const warning of warnings){
+                this.#logger.warn(`${warning.file}:${warning.line}: ${warning.message}`);
+            }
+            return {
+                succeeded: true,
+                syncResult: {
+                    projectName: project.name,
+                    succeeded: true
+                },
+                project,
+                originalPackage,
+                updatedPackage
+            };
+        } catch (error) {
+            const message = formatUnknownError(error);
+            return {
+                succeeded: false,
+                syncResult: {
+                    projectName: project.name,
+                    error: `${project.name}: ${message}`,
+                    succeeded: false
+                }
+            };
+        }
+    }
+}
+SyncDependencies = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace,
+        typeof DependencyResolver === "undefined" ? Object : DependencyResolver
+    ])
+], SyncDependencies);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/dependency-sync.action.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { PackageJson, Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { scribe } from \"@decohere/scribe\";\nimport { formatUnknownError } from \"../errors.js\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { DependencyResolver } from \"../services/dependency-resolver.service.js\";\nimport type { Package, SyncprojectResult } from \"../types/dependency.types.js\";\n\nexport type DependenciesOptions = {\n\tconfiguration: string;\n\tlogDiff?: boolean;\n};\n\ntype SyncComputed =\n\t| { succeeded: false; syncResult: SyncprojectResult }\n\t| {\n\t\t\tsucceeded: true;\n\t\t\tsyncResult: SyncprojectResult;\n\t\t\tproject: Project;\n\t\t\toriginalPackage: PackageJson;\n\t\t\tupdatedPackage: PackageJson;\n\t  };\n\n@injectable()\nexport class SyncDependencies implements Action<DependenciesOptions> {\n\t#logger = scribe.logger(SyncDependencies.name);\n\n\tpublic constructor(\n\t\tprivate readonly workspace: Workspace,\n\t\tprivate readonly resolver: DependencyResolver,\n\t) {}\n\n\tpublic async run(options: DependenciesOptions): Promise<ActionResponse<SyncprojectResult>> {\n\t\tconst { configuration, logDiff } = options;\n\n\t\tconst projects = this.workspace.getProjects(configuration);\n\t\tconst workspacePackages = await this.resolver.getWorkspacePackages(\n\t\t\tthis.workspace,\n\t\t\tprojects,\n\t\t);\n\n\t\tconst computed = await Promise.all(\n\t\t\tprojects.map((project) => this.computeDependenciesFor(project, workspacePackages)),\n\t\t);\n\n\t\tconst results = computed.map((c) => c.syncResult);\n\t\tif (results.some((r) => !r.succeeded)) {\n\t\t\treturn ActionResponse.Error(SyncDependencies.name, results);\n\t\t}\n\n\t\tconst succeeded = computed.filter(\n\t\t\t(c): c is SyncComputed & { succeeded: true } => c.succeeded,\n\t\t);\n\n\t\tawait Promise.all(succeeded.map((c) => c.project.persistPackageJson(c.updatedPackage)));\n\n\t\tconst syncResults = succeeded.map((c) => {\n\t\t\tconst drift = this.resolver.computeDrift(c.originalPackage, c.updatedPackage);\n\t\t\tif (drift && logDiff) {\n\t\t\t\tthis.#logger.warn(`Dependency drift synced in '${c.syncResult.projectName}'`, drift);\n\t\t\t}\n\t\t\treturn { ...c.syncResult, drift };\n\t\t});\n\n\t\tconst failedResults = results.filter((r) => !r.succeeded);\n\n\t\treturn ActionResponse.Success(SyncDependencies.name, [...syncResults, ...failedResults]);\n\t}\n\n\tprivate async computeDependenciesFor(\n\t\tproject: Project,\n\t\tworkspacePackages: Map<string, Package>,\n\t): Promise<SyncComputed> {\n\t\ttry {\n\t\t\tconst originalPackage = await project.getPackageJson();\n\t\t\tconst { updatedPackage, warnings } = await this.resolver.computeProjectDependencies(\n\t\t\t\tproject,\n\t\t\t\tworkspacePackages,\n\t\t\t);\n\t\t\tfor (const warning of warnings) {\n\t\t\t\tthis.#logger.warn(`${warning.file}:${warning.line}: ${warning.message}`);\n\t\t\t}\n\t\t\treturn {\n\t\t\t\tsucceeded: true,\n\t\t\t\tsyncResult: { projectName: project.name, succeeded: true },\n\t\t\t\tproject,\n\t\t\t\toriginalPackage,\n\t\t\t\tupdatedPackage,\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tconst message = formatUnknownError(error);\n\t\t\treturn {\n\t\t\t\tsucceeded: false,\n\t\t\t\tsyncResult: {\n\t\t\t\t\tprojectName: project.name,\n\t\t\t\t\terror: `${project.name}: ${message}`,\n\t\t\t\t\tsucceeded: false,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["injectable","Workspace","ActionResponse","scribe","formatUnknownError","DependencyResolver","SyncDependencies","logger","name","workspace","resolver","run","options","configuration","logDiff","projects","getProjects","workspacePackages","getWorkspacePackages","computed","Promise","all","map","project","computeDependenciesFor","results","c","syncResult","some","r","succeeded","Error","filter","persistPackageJson","updatedPackage","syncResults","drift","computeDrift","originalPackage","warn","projectName","failedResults","Success","getPackageJson","warnings","computeProjectDependencies","warning","file","line","message","error"],"mappings":"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"}

package/es6/src/actions/index.js

@@ -0,0 +1,13 @@
+export * from "./build.action.js";
+export * from "./clean.action.js";
+export * from "./commit.action.js";
+export * from "./copy.action.js";
+export * from "./dependency-report.action.js";
+export * from "./dependency-sync.action.js";
+export * from "./publish.action.js";
+export * from "./sync-lock-file.action.js";
+export * from "./tag.action.js";
+export * from "./version.action.js";
+export * from "./watch.action.js";
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2FjdGlvbnMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vYnVpbGQuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9jbGVhbi5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvbW1pdC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2NvcHkuYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9kZXBlbmRlbmN5LXJlcG9ydC5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2RlcGVuZGVuY3ktc3luYy5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3B1Ymxpc2guYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zeW5jLWxvY2stZmlsZS5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3RhZy5hY3Rpb24uanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3ZlcnNpb24uYWN0aW9uLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi93YXRjaC5hY3Rpb24uanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9CQUFvQjtBQUNsQyxjQUFjLG9CQUFvQjtBQUNsQyxjQUFjLHFCQUFxQjtBQUNuQyxjQUFjLG1CQUFtQjtBQUNqQyxjQUFjLGdDQUFnQztBQUM5QyxjQUFjLDhCQUE4QjtBQUM1QyxjQUFjLHNCQUFzQjtBQUNwQyxjQUFjLDZCQUE2QjtBQUMzQyxjQUFjLGtCQUFrQjtBQUNoQyxjQUFjLHNCQUFzQjtBQUNwQyxjQUFjLG9CQUFvQiJ9

package/es6/src/actions/publish.action.js

@@ -0,0 +1,147 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { injectable } from "@decohere/crucible/decorators";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { Npm } from "@decohere/nexus/interop";
+import { scribe } from "@decohere/scribe";
+import { ForgeError, formatUnknownError } from "../errors.js";
+export class Publish {
+    workspace;
+    // TODO: probably best to inject npm
+    npm = new Npm();
+    #logger = scribe.logger(Publish.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const projects = this.workspace.getProjects(options.configuration);
+        const token = await this.resolveToken(options);
+        const otp = await this.resolveOtp(options);
+        if (projects.length === 0) {
+            throw new ForgeError(`No projects found to publish`);
+        }
+        const publishResponses = await this.publishProjects(projects, {
+            ...options,
+            token,
+            otp
+        });
+        const failed = publishResponses.filter((r)=>!r.succeeded);
+        if (failed.length) {
+            return ActionResponse.Error(Publish.name, publishResponses);
+        }
+        return ActionResponse.Success(Publish.name, publishResponses);
+    }
+    async publishProjects(projects, options) {
+        return await Promise.all(projects.filter((project)=>{
+            if (project.isPrivate) {
+                this.#logger.info(`Skipping private package: ${project.name}`);
+                return false;
+            }
+            return true;
+        }).map(async (project)=>await this.publishProject(project, options)));
+    }
+    async publishProject(project, options) {
+        const { channel, dryRun, token, otp } = options;
+        const outDir = project.getOutDir();
+        this.#logger.info(`${dryRun ? "[dry-run] " : ""}Publishing ${project.name}`);
+        try {
+            const response = await this.npm.publish(outDir, {
+                channel,
+                dryRun,
+                authToken: token,
+                otp,
+                skipIfPublished: true
+            });
+            const packageName = response.data?.join("");
+            this.#logger.trace(`${project.name} → ${packageName ?? response.message}`);
+            return {
+                projectName: project.name,
+                succeeded: true,
+                message: response.message,
+                packageName
+            };
+        } catch (reason) {
+            const message = formatUnknownError(reason);
+            return {
+                projectName: project.name,
+                succeeded: false,
+                message,
+                error: `${project.name}: ${message}`
+            };
+        }
+    }
+    async resolveToken(options) {
+        if (options.token?.trim()) {
+            return options.token.trim();
+        }
+        if (options.promptAuth) {
+            return await this.promptSecret("npm access token: ");
+        }
+        return undefined;
+    }
+    async resolveOtp(options) {
+        if (options.otp?.trim()) {
+            return options.otp.trim();
+        }
+        if (options.promptAuth || options.promptOtp) {
+            return await this.promptSecret("npm OTP: ");
+        }
+        return undefined;
+    }
+    async promptSecret(label) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw new ForgeError(`Cannot prompt for secret without an interactive TTY`);
+        }
+        process.stdout.write(label);
+        const stdin = process.stdin;
+        stdin.setEncoding("utf8");
+        stdin.resume();
+        stdin.setRawMode?.(true);
+        let value = "";
+        return await new Promise((resolve, reject)=>{
+            const cleanup = ()=>{
+                stdin.setRawMode?.(false);
+                stdin.pause();
+                stdin.removeListener("data", onData);
+                process.stdout.write("\n");
+            };
+            const onData = (chunk)=>{
+                const char = chunk;
+                if (char === "\u0003") {
+                    cleanup();
+                    reject(new ForgeError("Input cancelled"));
+                    return;
+                }
+                if (char === "\r" || char === "\n") {
+                    cleanup();
+                    resolve(value.trim());
+                    return;
+                }
+                if (char === "\u0008" || char === "\u007f") {
+                    value = value.slice(0, -1);
+                    return;
+                }
+                value += char;
+            };
+            stdin.on("data", onData);
+        });
+    }
+}
+Publish = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Publish);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/publish.action.ts"],"sourcesContent":["import { injectable } from \"@decohere/crucible/decorators\";\nimport type { Project } from \"@decohere/mesh\";\n// biome-ignore lint/style/useImportType: <DI>\nimport { Workspace } from \"@decohere/mesh\";\nimport type { Action, ResultStatus } from \"@decohere/nexus/cli\";\nimport { ActionResponse } from \"@decohere/nexus/cli\";\nimport { Npm } from \"@decohere/nexus/interop\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type PublishOptions = {\n\tconfiguration: string;\n\tchannel?: string;\n\tdryRun?: boolean;\n\ttoken?: string;\n\totp?: string;\n\tpromptAuth?: boolean;\n\tpromptOtp?: boolean;\n};\n\nexport type PublishResponse = ResultStatus & {\n\tprojectName: string;\n\tmessage: string;\n\tpackageName?: string;\n};\n\n@injectable()\nexport class Publish implements Action<PublishOptions> {\n\t// TODO: probably best to inject npm\n\tprivate readonly npm = new Npm();\n\t#logger = scribe.logger(Publish.name);\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic async run(options: PublishOptions): Promise<ActionResponse<PublishResponse>> {\n\t\tconst projects = this.workspace.getProjects(options.configuration);\n\t\tconst token = await this.resolveToken(options);\n\t\tconst otp = await this.resolveOtp(options);\n\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found to publish`);\n\t\t}\n\t\tconst publishResponses = await this.publishProjects(projects, {\n\t\t\t...options,\n\t\t\ttoken,\n\t\t\totp,\n\t\t});\n\t\tconst failed = publishResponses.filter((r) => !r.succeeded);\n\t\tif (failed.length) {\n\t\t\treturn ActionResponse.Error(Publish.name, publishResponses);\n\t\t}\n\t\treturn ActionResponse.Success(Publish.name, publishResponses);\n\t}\n\n\tpublic async publishProjects(projects: readonly Project[], options: PublishOptions) {\n\t\treturn await Promise.all(\n\t\t\tprojects\n\t\t\t\t.filter((project) => {\n\t\t\t\t\tif (project.isPrivate) {\n\t\t\t\t\t\tthis.#logger.info(`Skipping private package: ${project.name}`);\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t\treturn true;\n\t\t\t\t})\n\t\t\t\t.map(async (project) => await this.publishProject(project, options)),\n\t\t);\n\t}\n\n\tprivate async publishProject(\n\t\tproject: Project,\n\t\toptions: PublishOptions,\n\t): Promise<PublishResponse> {\n\t\tconst { channel, dryRun, token, otp } = options;\n\t\tconst outDir = project.getOutDir();\n\t\tthis.#logger.info(`${dryRun ? \"[dry-run] \" : \"\"}Publishing ${project.name}`);\n\n\t\ttry {\n\t\t\tconst response = await this.npm.publish(outDir, {\n\t\t\t\tchannel,\n\t\t\t\tdryRun,\n\t\t\t\tauthToken: token,\n\t\t\t\totp,\n\t\t\t\tskipIfPublished: true,\n\t\t\t});\n\n\t\t\tconst packageName = response.data?.join(\"\");\n\t\t\tthis.#logger.trace(`${project.name} → ${packageName ?? response.message}`);\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\tsucceeded: true,\n\t\t\t\tmessage: response.message,\n\t\t\t\tpackageName,\n\t\t\t};\n\t\t} catch (reason) {\n\t\t\tconst message = formatUnknownError(reason);\n\t\t\treturn {\n\t\t\t\tprojectName: project.name,\n\t\t\t\tsucceeded: false,\n\t\t\t\tmessage,\n\t\t\t\terror: `${project.name}: ${message}`,\n\t\t\t};\n\t\t}\n\t}\n\n\tprivate async resolveToken(options: PublishOptions): Promise<string | undefined> {\n\t\tif (options.token?.trim()) {\n\t\t\treturn options.token.trim();\n\t\t}\n\n\t\tif (options.promptAuth) {\n\t\t\treturn await this.promptSecret(\"npm access token: \");\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tprivate async resolveOtp(options: PublishOptions): Promise<string | undefined> {\n\t\tif (options.otp?.trim()) {\n\t\t\treturn options.otp.trim();\n\t\t}\n\n\t\tif (options.promptAuth || options.promptOtp) {\n\t\t\treturn await this.promptSecret(\"npm OTP: \");\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tprivate async promptSecret(label: string): Promise<string | undefined> {\n\t\tif (!process.stdin.isTTY || !process.stdout.isTTY) {\n\t\t\tthrow new ForgeError(`Cannot prompt for secret without an interactive TTY`);\n\t\t}\n\n\t\tprocess.stdout.write(label);\n\t\tconst stdin = process.stdin;\n\t\tstdin.setEncoding(\"utf8\");\n\t\tstdin.resume();\n\t\tstdin.setRawMode?.(true);\n\n\t\tlet value = \"\";\n\n\t\treturn await new Promise<string>((resolve, reject) => {\n\t\t\tconst cleanup = () => {\n\t\t\t\tstdin.setRawMode?.(false);\n\t\t\t\tstdin.pause();\n\t\t\t\tstdin.removeListener(\"data\", onData);\n\t\t\t\tprocess.stdout.write(\"\\n\");\n\t\t\t};\n\n\t\t\tconst onData = (chunk: string) => {\n\t\t\t\tconst char = chunk;\n\t\t\t\tif (char === \"\\u0003\") {\n\t\t\t\t\tcleanup();\n\t\t\t\t\treject(new ForgeError(\"Input cancelled\"));\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (char === \"\\r\" || char === \"\\n\") {\n\t\t\t\t\tcleanup();\n\t\t\t\t\tresolve(value.trim());\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif (char === \"\\u0008\" || char === \"\\u007f\") {\n\t\t\t\t\tvalue = value.slice(0, -1);\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tvalue += char;\n\t\t\t};\n\n\t\t\tstdin.on(\"data\", onData);\n\t\t});\n\t}\n}\n"],"names":["injectable","Workspace","ActionResponse","Npm","scribe","ForgeError","formatUnknownError","Publish","npm","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","publishResponses","publishProjects","failed","filter","r","succeeded","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","error","trim","promptAuth","promptSecret","undefined","promptOtp","label","process","stdin","isTTY","stdout","write","setEncoding","resume","setRawMode","value","resolve","reject","cleanup","pause","removeListener","onData","chunk","char","slice","on"],"mappings":"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"}

package/es6/src/actions/sync-lock-file.action.js

@@ -0,0 +1,33 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { injectable } from "@decohere/crucible/decorators";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { Pnpm } from "@decohere/nexus/interop";
+import { scribe } from "@decohere/scribe";
+import { formatUnknownError } from "../errors.js";
+export class SyncLockFile {
+    #logger = scribe.logger(SyncLockFile.name);
+    #pnpm = new Pnpm();
+    async run(options) {
+        const shouldSync = options.sync ?? true;
+        if (options.dryRun || !shouldSync) {
+            this.#logger.info(options.dryRun ? "[dry-run] Skipping lockfile sync" : "Skipping lockfile sync");
+            return ActionResponse.Skipped(SyncLockFile.name);
+        }
+        try {
+            await this.#pnpm.syncLockFile();
+        } catch (reason) {
+            return ActionResponse.Error(SyncLockFile.name, `Failed syncing lockfile: ${formatUnknownError(reason)}`);
+        }
+        return ActionResponse.Success(SyncLockFile.name);
+    }
+}
+SyncLockFile = _ts_decorate([
+    injectable()
+], SyncLockFile);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2FjdGlvbnMvc3luYy1sb2NrLWZpbGUuYWN0aW9uLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGluamVjdGFibGUgfSBmcm9tIFwiQGRlY29oZXJlL2NydWNpYmxlL2RlY29yYXRvcnNcIjtcbmltcG9ydCB0eXBlIHsgQWN0aW9uIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IEFjdGlvblJlc3BvbnNlIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IFBucG0gfSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2ludGVyb3BcIjtcbmltcG9ydCB7IHNjcmliZSB9IGZyb20gXCJAZGVjb2hlcmUvc2NyaWJlXCI7XG5pbXBvcnQgeyBmb3JtYXRVbmtub3duRXJyb3IgfSBmcm9tIFwiLi4vZXJyb3JzLmpzXCI7XG5cbmV4cG9ydCB0eXBlIFN5bmNMb2NrRmlsZU9wdGlvbnMgPSB7XG5cdHN5bmM/OiBib29sZWFuO1xuXHRkcnlSdW4/OiBib29sZWFuO1xufTtcblxuQGluamVjdGFibGUoKVxuZXhwb3J0IGNsYXNzIFN5bmNMb2NrRmlsZSBpbXBsZW1lbnRzIEFjdGlvbjxTeW5jTG9ja0ZpbGVPcHRpb25zPiB7XG5cdCNsb2dnZXIgPSBzY3JpYmUubG9nZ2VyKFN5bmNMb2NrRmlsZS5uYW1lKTtcblx0I3BucG0gPSBuZXcgUG5wbSgpO1xuXG5cdHB1YmxpYyBhc3luYyBydW4ob3B0aW9uczogU3luY0xvY2tGaWxlT3B0aW9ucyk6IFByb21pc2U8QWN0aW9uUmVzcG9uc2U+IHtcblx0XHRjb25zdCBzaG91bGRTeW5jID0gb3B0aW9ucy5zeW5jID8/IHRydWU7XG5cblx0XHRpZiAob3B0aW9ucy5kcnlSdW4gfHwgIXNob3VsZFN5bmMpIHtcblx0XHRcdHRoaXMuI2xvZ2dlci5pbmZvKFxuXHRcdFx0XHRvcHRpb25zLmRyeVJ1biA/IFwiW2RyeS1ydW5dIFNraXBwaW5nIGxvY2tmaWxlIHN5bmNcIiA6IFwiU2tpcHBpbmcgbG9ja2ZpbGUgc3luY1wiLFxuXHRcdFx0KTtcblx0XHRcdHJldHVybiBBY3Rpb25SZXNwb25zZS5Ta2lwcGVkKFN5bmNMb2NrRmlsZS5uYW1lKTtcblx0XHR9XG5cblx0XHR0cnkge1xuXHRcdFx0YXdhaXQgdGhpcy4jcG5wbS5zeW5jTG9ja0ZpbGUoKTtcblx0XHR9IGNhdGNoIChyZWFzb24pIHtcblx0XHRcdHJldHVybiBBY3Rpb25SZXNwb25zZS5FcnJvcihcblx0XHRcdFx0U3luY0xvY2tGaWxlLm5hbWUsXG5cdFx0XHRcdGBGYWlsZWQgc3luY2luZyBsb2NrZmlsZTogJHtmb3JtYXRVbmtub3duRXJyb3IocmVhc29uKX1gLFxuXHRcdFx0KTtcblx0XHR9XG5cblx0XHRyZXR1cm4gQWN0aW9uUmVzcG9uc2UuU3VjY2VzcyhTeW5jTG9ja0ZpbGUubmFtZSk7XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJpbmplY3RhYmxlIiwiQWN0aW9uUmVzcG9uc2UiLCJQbnBtIiwic2NyaWJlIiwiZm9ybWF0VW5rbm93bkVycm9yIiwiU3luY0xvY2tGaWxlIiwibG9nZ2VyIiwibmFtZSIsInJ1biIsIm9wdGlvbnMiLCJzaG91bGRTeW5jIiwic3luYyIsImRyeVJ1biIsImluZm8iLCJTa2lwcGVkIiwic3luY0xvY2tGaWxlIiwicmVhc29uIiwiRXJyb3IiLCJTdWNjZXNzIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQSxTQUFTQSxVQUFVLFFBQVEsZ0NBQWdDO0FBRTNELFNBQVNDLGNBQWMsUUFBUSxzQkFBc0I7QUFDckQsU0FBU0MsSUFBSSxRQUFRLDBCQUEwQjtBQUMvQyxTQUFTQyxNQUFNLFFBQVEsbUJBQW1CO0FBQzFDLFNBQVNDLGtCQUFrQixRQUFRLGVBQWU7QUFRbEQsT0FBTyxNQUFNQztJQUNaLENBQUEsTUFBTyxHQUFHRixPQUFPRyxNQUFNLENBQUNELGFBQWFFLElBQUksRUFBRTtJQUMzQyxDQUFBLElBQUssR0FBRyxJQUFJTCxPQUFPO0lBRW5CLE1BQWFNLElBQUlDLE9BQTRCLEVBQTJCO1FBQ3ZFLE1BQU1DLGFBQWFELFFBQVFFLElBQUksSUFBSTtRQUVuQyxJQUFJRixRQUFRRyxNQUFNLElBQUksQ0FBQ0YsWUFBWTtZQUNsQyxJQUFJLENBQUMsQ0FBQSxNQUFPLENBQUNHLElBQUksQ0FDaEJKLFFBQVFHLE1BQU0sR0FBRyxxQ0FBcUM7WUFFdkQsT0FBT1gsZUFBZWEsT0FBTyxDQUFDVCxhQUFhRSxJQUFJO1FBQ2hEO1FBRUEsSUFBSTtZQUNILE1BQU0sSUFBSSxDQUFDLENBQUEsSUFBSyxDQUFDUSxZQUFZO1FBQzlCLEVBQUUsT0FBT0MsUUFBUTtZQUNoQixPQUFPZixlQUFlZ0IsS0FBSyxDQUMxQlosYUFBYUUsSUFBSSxFQUNqQixDQUFDLHlCQUF5QixFQUFFSCxtQkFBbUJZLFNBQVM7UUFFMUQ7UUFFQSxPQUFPZixlQUFlaUIsT0FBTyxDQUFDYixhQUFhRSxJQUFJO0lBQ2hEO0FBQ0QifQ==

package/es6/src/actions/tag.action.js

@@ -0,0 +1,67 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+import { injectable } from "@decohere/crucible/decorators";
+// biome-ignore lint/style/useImportType: <DI>
+import { Workspace } from "@decohere/mesh";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { Git } from "@decohere/nexus/interop";
+import { scribe } from "@decohere/scribe";
+import { ForgeError, formatUnknownError } from "../errors.js";
+export class Tag {
+    workspace;
+    #logger = scribe.logger(Tag.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        try {
+            const version = await this.workspace.getVersion();
+            const prefix = options.prefix ?? "v";
+            const tag = `${prefix}${version}`;
+            if (options.dryRun) {
+                this.#logger.info(`[dry-run] ${tag}`);
+                return ActionResponse.Success(Tag.name, [
+                    {
+                        tag,
+                        succeeded: true
+                    }
+                ]);
+            }
+            this.#logger.info(`Creating tag: ${tag}`);
+            const git = new Git();
+            await git.tag(tag);
+            if (options.push) {
+                const branch = await git.getBranchName();
+                this.#logger.info(`Pushing branch: ${branch}`);
+                await git.push(branch);
+                this.#logger.info(`Pushing tag: ${tag}`);
+                await git.pushTag(tag);
+            }
+            return ActionResponse.Success(Tag.name, [
+                {
+                    tag,
+                    succeeded: true
+                }
+            ]);
+        } catch (reason) {
+            const error = formatUnknownError(reason);
+            throw new ForgeError(`Failed to create tag: ${error}`);
+        }
+    }
+}
+Tag = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Tag);
+
+//# sourceMappingURL=data:application/json;base64,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