@decohere/forge 0.0.1-dev.5 → 0.0.1-dev.50

package/commonjs/src/actions/link.action.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get DEFAULT_LINK_CONFIGURATION () {
+        return DEFAULT_LINK_CONFIGURATION;
+    },
+    get LINK_MANIFEST () {
+        return LINK_MANIFEST;
+    },
+    get Link () {
+        return Link;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _mesh = require("@decohere/mesh");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+require("../extensions/project.extensions.js");
+const _errors = require("../errors.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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);
+}
+const LINK_MANIFEST = ".forge-link.json";
+const DEFAULT_LINK_CONFIGURATION = "link";
+class Link {
+    workspace;
+    #logger = _scribe.scribe.logger(Link.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        const targetDir = _nodepath.default.resolve(options.targetDir);
+        const nodeModulesDir = _nodepath.default.join(targetDir, "node_modules");
+        const stat = await _promises.default.stat(nodeModulesDir).catch(()=>null);
+        if (stat == null) {
+            throw new _errors.ForgeError(`node_modules not found in "${targetDir}". Run pnpm install first.`);
+        }
+        const projects = this.workspace.getProjects(options.configuration);
+        if (projects.length === 0) {
+            throw new _errors.ForgeError(`No projects found for configuration "${options.configuration}"`);
+        }
+        // Load any existing manifest so originalPath values are preserved on re-link
+        const manifestPath = _nodepath.default.join(targetDir, LINK_MANIFEST);
+        const existingManifestText = await _promises.default.readFile(manifestPath, "utf8").catch(()=>null);
+        const existingManifest = existingManifestText != null ? JSON.parse(existingManifestText) : null;
+        const manifest = {
+            workspaceRoot: this.workspace.rootDir,
+            links: []
+        };
+        for (const project of projects){
+            const pkg = await project.getPackageJson();
+            const packageName = pkg.name;
+            if (!packageName) {
+                this.#logger.trace(`Skipping project "${project.name}" — no package name`);
+                continue;
+            }
+            // Resolve the build output directory (no target arg — debug config is not packed)
+            const outDir = project.getOutDir();
+            const absoluteOutDir = _nodepath.default.resolve(outDir);
+            // Pre-create the output dir so the symlink is valid even before a build completes.
+            await _promises.default.mkdir(absoluteOutDir, {
+                recursive: true
+            });
+            // Compute symlink path inside target node_modules
+            const symlinkPath = _nodepath.default.join(nodeModulesDir, ...packageName.split("/"));
+            const symlinkParent = _nodepath.default.dirname(symlinkPath);
+            // Capture any existing entry so we can restore it on unlink.
+            // If a manifest already exists for this package, preserve its originalPath —
+            // the current symlink is our own and must not be treated as the original.
+            let originalPath = null;
+            const existingStat = await _promises.default.lstat(symlinkPath).catch(()=>null);
+            if (existingStat != null) {
+                const existingEntry = existingManifest?.links.find((l)=>l.packageName === packageName);
+                if (existingEntry != null) {
+                    // Already linked — preserve the recorded originalPath and replace the symlink
+                    originalPath = existingEntry.originalPath;
+                    if (existingStat.isSymbolicLink()) {
+                        await _promises.default.unlink(symlinkPath);
+                    }
+                } else if (existingStat.isSymbolicLink()) {
+                    originalPath = await _promises.default.readlink(symlinkPath);
+                    await _promises.default.unlink(symlinkPath);
+                } else {
+                    // Real directory — back it up by renaming
+                    originalPath = `${symlinkPath}.__forge_backup__`;
+                    await _promises.default.rename(symlinkPath, originalPath);
+                }
+            }
+            await _promises.default.mkdir(symlinkParent, {
+                recursive: true
+            });
+            await _promises.default.symlink(absoluteOutDir, symlinkPath, "dir");
+            manifest.links.push({
+                packageName,
+                symlinkPath,
+                originalPath
+            });
+            this.#logger.info(`Linked ${packageName} → ${absoluteOutDir}`);
+        }
+        // Create a peer node_modules at the build output root so Node can resolve
+        // bare specifiers from the real (non-symlink) paths of linked packages.
+        if (manifest.links.length > 0) {
+            const buildRoot = _nodepath.default.resolve(projects[0].getRootOut());
+            const peerNodeModulesDir = _nodepath.default.join(buildRoot, "node_modules");
+            await _promises.default.rm(peerNodeModulesDir, {
+                recursive: true,
+                force: true
+            });
+            for (const project of projects){
+                const pkg = await project.getPackageJson();
+                if (!pkg.name) continue;
+                const outDir = _nodepath.default.resolve(project.getOutDir());
+                const peerSymlink = _nodepath.default.join(peerNodeModulesDir, ...pkg.name.split("/"));
+                await _promises.default.mkdir(_nodepath.default.dirname(peerSymlink), {
+                    recursive: true
+                });
+                await _promises.default.symlink(outDir, peerSymlink, "dir");
+                this.#logger.trace(`Peer-linked ${pkg.name} → ${outDir}`);
+            }
+            manifest.peerNodeModulesDir = peerNodeModulesDir;
+            this.#logger.info(`Created peer node_modules at ${peerNodeModulesDir}`);
+        }
+        await _promises.default.writeFile(_nodepath.default.join(targetDir, LINK_MANIFEST), JSON.stringify(manifest, null, 2));
+        return _cli.ActionResponse.Success(Link.name);
+    };
+}
+Link = _ts_decorate([
+    (0, _decorators.injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _mesh.Workspace === "undefined" ? Object : _mesh.Workspace
+    ])
+], Link);
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/link.action.ts"],"sourcesContent":["import fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\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 \"../extensions/project.extensions.js\";\nimport { ForgeError } from \"../errors.js\";\n\nexport const LINK_MANIFEST = \".forge-link.json\";\n\nexport type LinkOptions = {\n\tconfiguration: string;\n\ttargetDir: string;\n};\n\nexport const DEFAULT_LINK_CONFIGURATION = \"link\";\n\nexport type LinkManifest = {\n\tworkspaceRoot: string;\n\tpeerNodeModulesDir?: string;\n\tlinks: Array<{ packageName: string; symlinkPath: string; originalPath: string | null }>;\n};\n\n@injectable()\nexport class Link implements Action<LinkOptions> {\n\t#logger = scribe.logger(Link.name);\n\n\tpublic constructor(private readonly workspace: Workspace) {}\n\n\tpublic run = async (options: LinkOptions): Promise<ActionResponse> => {\n\t\tconst targetDir = path.resolve(options.targetDir);\n\t\tconst nodeModulesDir = path.join(targetDir, \"node_modules\");\n\n\t\tconst stat = await fs.stat(nodeModulesDir).catch(() => null);\n\t\tif (stat == null) {\n\t\t\tthrow new ForgeError(\n\t\t\t\t`node_modules not found in \"${targetDir}\". Run pnpm install first.`,\n\t\t\t);\n\t\t}\n\n\t\tconst projects = this.workspace.getProjects(options.configuration);\n\t\tif (projects.length === 0) {\n\t\t\tthrow new ForgeError(`No projects found for configuration \"${options.configuration}\"`);\n\t\t}\n\n\t\t// Load any existing manifest so originalPath values are preserved on re-link\n\t\tconst manifestPath = path.join(targetDir, LINK_MANIFEST);\n\t\tconst existingManifestText = await fs.readFile(manifestPath, \"utf8\").catch(() => null);\n\t\tconst existingManifest: LinkManifest | null =\n\t\t\texistingManifestText != null ? JSON.parse(existingManifestText) : null;\n\n\t\tconst manifest: LinkManifest = {\n\t\t\tworkspaceRoot: this.workspace.rootDir,\n\t\t\tlinks: [],\n\t\t};\n\n\t\tfor (const project of projects) {\n\t\t\tconst pkg = await project.getPackageJson();\n\t\t\tconst packageName = pkg.name;\n\t\t\tif (!packageName) {\n\t\t\t\tthis.#logger.trace(`Skipping project \"${project.name}\" — no package name`);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Resolve the build output directory (no target arg — debug config is not packed)\n\t\t\tconst outDir = project.getOutDir();\n\t\t\tconst absoluteOutDir = path.resolve(outDir);\n\n\t\t\t// Pre-create the output dir so the symlink is valid even before a build completes.\n\t\t\tawait fs.mkdir(absoluteOutDir, { recursive: true });\n\n\t\t\t// Compute symlink path inside target node_modules\n\t\t\tconst symlinkPath = path.join(nodeModulesDir, ...packageName.split(\"/\"));\n\t\t\tconst symlinkParent = path.dirname(symlinkPath);\n\n\t\t\t// Capture any existing entry so we can restore it on unlink.\n\t\t\t// If a manifest already exists for this package, preserve its originalPath —\n\t\t\t// the current symlink is our own and must not be treated as the original.\n\t\t\tlet originalPath: string | null = null;\n\t\t\tconst existingStat = await fs.lstat(symlinkPath).catch(() => null);\n\t\t\tif (existingStat != null) {\n\t\t\t\tconst existingEntry = existingManifest?.links.find(\n\t\t\t\t\t(l) => l.packageName === packageName,\n\t\t\t\t);\n\t\t\t\tif (existingEntry != null) {\n\t\t\t\t\t// Already linked — preserve the recorded originalPath and replace the symlink\n\t\t\t\t\toriginalPath = existingEntry.originalPath;\n\t\t\t\t\tif (existingStat.isSymbolicLink()) {\n\t\t\t\t\t\tawait fs.unlink(symlinkPath);\n\t\t\t\t\t}\n\t\t\t\t} else if (existingStat.isSymbolicLink()) {\n\t\t\t\t\toriginalPath = await fs.readlink(symlinkPath);\n\t\t\t\t\tawait fs.unlink(symlinkPath);\n\t\t\t\t} else {\n\t\t\t\t\t// Real directory — back it up by renaming\n\t\t\t\t\toriginalPath = `${symlinkPath}.__forge_backup__`;\n\t\t\t\t\tawait fs.rename(symlinkPath, originalPath);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tawait fs.mkdir(symlinkParent, { recursive: true });\n\t\t\tawait fs.symlink(absoluteOutDir, symlinkPath, \"dir\");\n\n\t\t\tmanifest.links.push({ packageName, symlinkPath, originalPath });\n\t\t\tthis.#logger.info(`Linked ${packageName} → ${absoluteOutDir}`);\n\t\t}\n\n\t\t// Create a peer node_modules at the build output root so Node can resolve\n\t\t// bare specifiers from the real (non-symlink) paths of linked packages.\n\t\tif (manifest.links.length > 0) {\n\t\t\tconst buildRoot = path.resolve(projects[0].getRootOut());\n\t\t\tconst peerNodeModulesDir = path.join(buildRoot, \"node_modules\");\n\t\t\tawait fs.rm(peerNodeModulesDir, { recursive: true, force: true });\n\t\t\tfor (const project of projects) {\n\t\t\t\tconst pkg = await project.getPackageJson();\n\t\t\t\tif (!pkg.name) continue;\n\t\t\t\tconst outDir = path.resolve(project.getOutDir());\n\t\t\t\tconst peerSymlink = path.join(peerNodeModulesDir, ...pkg.name.split(\"/\"));\n\t\t\t\tawait fs.mkdir(path.dirname(peerSymlink), { recursive: true });\n\t\t\t\tawait fs.symlink(outDir, peerSymlink, \"dir\");\n\t\t\t\tthis.#logger.trace(`Peer-linked ${pkg.name} → ${outDir}`);\n\t\t\t}\n\t\t\tmanifest.peerNodeModulesDir = peerNodeModulesDir;\n\t\t\tthis.#logger.info(`Created peer node_modules at ${peerNodeModulesDir}`);\n\t\t}\n\n\t\tawait fs.writeFile(path.join(targetDir, LINK_MANIFEST), JSON.stringify(manifest, null, 2));\n\n\t\treturn ActionResponse.Success(Link.name);\n\t};\n}\n"],"names":["DEFAULT_LINK_CONFIGURATION","LINK_MANIFEST","Link","scribe","logger","name","workspace","run","options","targetDir","path","resolve","nodeModulesDir","join","stat","fs","catch","ForgeError","projects","getProjects","configuration","length","manifestPath","existingManifestText","readFile","existingManifest","JSON","parse","manifest","workspaceRoot","rootDir","links","project","pkg","getPackageJson","packageName","trace","outDir","getOutDir","absoluteOutDir","mkdir","recursive","symlinkPath","split","symlinkParent","dirname","originalPath","existingStat","lstat","existingEntry","find","l","isSymbolicLink","unlink","readlink","rename","symlink","push","info","buildRoot","getRootOut","peerNodeModulesDir","rm","force","peerSymlink","writeFile","stringify","ActionResponse","Success"],"mappings":";;;;;;;;;;;QAkBaA;eAAAA;;QAPAC;eAAAA;;QAgBAC;eAAAA;;;iEA3BE;iEACE;4BACU;sBAED;qBAEK;wBACR;QAChB;wBACoB;;;;;;;;;;;;;;;AAEpB,MAAMD,gBAAgB;AAOtB,MAAMD,6BAA6B;AASnC,MAAME;;IACZ,CAAA,MAAO,GAAGC,cAAM,CAACC,MAAM,CAACF,KAAKG,IAAI,EAAE;IAEnC,YAAmB,AAAiBC,SAAoB,CAAE;aAAtBA,YAAAA;IAAuB;IAEpDC,MAAM,OAAOC;QACnB,MAAMC,YAAYC,iBAAI,CAACC,OAAO,CAACH,QAAQC,SAAS;QAChD,MAAMG,iBAAiBF,iBAAI,CAACG,IAAI,CAACJ,WAAW;QAE5C,MAAMK,OAAO,MAAMC,iBAAE,CAACD,IAAI,CAACF,gBAAgBI,KAAK,CAAC,IAAM;QACvD,IAAIF,QAAQ,MAAM;YACjB,MAAM,IAAIG,kBAAU,CACnB,CAAC,2BAA2B,EAAER,UAAU,0BAA0B,CAAC;QAErE;QAEA,MAAMS,WAAW,IAAI,CAACZ,SAAS,CAACa,WAAW,CAACX,QAAQY,aAAa;QACjE,IAAIF,SAASG,MAAM,KAAK,GAAG;YAC1B,MAAM,IAAIJ,kBAAU,CAAC,CAAC,qCAAqC,EAAET,QAAQY,aAAa,CAAC,CAAC,CAAC;QACtF;QAEA,6EAA6E;QAC7E,MAAME,eAAeZ,iBAAI,CAACG,IAAI,CAACJ,WAAWR;QAC1C,MAAMsB,uBAAuB,MAAMR,iBAAE,CAACS,QAAQ,CAACF,cAAc,QAAQN,KAAK,CAAC,IAAM;QACjF,MAAMS,mBACLF,wBAAwB,OAAOG,KAAKC,KAAK,CAACJ,wBAAwB;QAEnE,MAAMK,WAAyB;YAC9BC,eAAe,IAAI,CAACvB,SAAS,CAACwB,OAAO;YACrCC,OAAO,EAAE;QACV;QAEA,KAAK,MAAMC,WAAWd,SAAU;YAC/B,MAAMe,MAAM,MAAMD,QAAQE,cAAc;YACxC,MAAMC,cAAcF,IAAI5B,IAAI;YAC5B,IAAI,CAAC8B,aAAa;gBACjB,IAAI,CAAC,CAAA,MAAO,CAACC,KAAK,CAAC,CAAC,kBAAkB,EAAEJ,QAAQ3B,IAAI,CAAC,mBAAmB,CAAC;gBACzE;YACD;YAEA,kFAAkF;YAClF,MAAMgC,SAASL,QAAQM,SAAS;YAChC,MAAMC,iBAAiB7B,iBAAI,CAACC,OAAO,CAAC0B;YAEpC,mFAAmF;YACnF,MAAMtB,iBAAE,CAACyB,KAAK,CAACD,gBAAgB;gBAAEE,WAAW;YAAK;YAEjD,kDAAkD;YAClD,MAAMC,cAAchC,iBAAI,CAACG,IAAI,CAACD,mBAAmBuB,YAAYQ,KAAK,CAAC;YACnE,MAAMC,gBAAgBlC,iBAAI,CAACmC,OAAO,CAACH;YAEnC,6DAA6D;YAC7D,6EAA6E;YAC7E,0EAA0E;YAC1E,IAAII,eAA8B;YAClC,MAAMC,eAAe,MAAMhC,iBAAE,CAACiC,KAAK,CAACN,aAAa1B,KAAK,CAAC,IAAM;YAC7D,IAAI+B,gBAAgB,MAAM;gBACzB,MAAME,gBAAgBxB,kBAAkBM,MAAMmB,KAC7C,CAACC,IAAMA,EAAEhB,WAAW,KAAKA;gBAE1B,IAAIc,iBAAiB,MAAM;oBAC1B,8EAA8E;oBAC9EH,eAAeG,cAAcH,YAAY;oBACzC,IAAIC,aAAaK,cAAc,IAAI;wBAClC,MAAMrC,iBAAE,CAACsC,MAAM,CAACX;oBACjB;gBACD,OAAO,IAAIK,aAAaK,cAAc,IAAI;oBACzCN,eAAe,MAAM/B,iBAAE,CAACuC,QAAQ,CAACZ;oBACjC,MAAM3B,iBAAE,CAACsC,MAAM,CAACX;gBACjB,OAAO;oBACN,0CAA0C;oBAC1CI,eAAe,GAAGJ,YAAY,iBAAiB,CAAC;oBAChD,MAAM3B,iBAAE,CAACwC,MAAM,CAACb,aAAaI;gBAC9B;YACD;YAEA,MAAM/B,iBAAE,CAACyB,KAAK,CAACI,eAAe;gBAAEH,WAAW;YAAK;YAChD,MAAM1B,iBAAE,CAACyC,OAAO,CAACjB,gBAAgBG,aAAa;YAE9Cd,SAASG,KAAK,CAAC0B,IAAI,CAAC;gBAAEtB;gBAAaO;gBAAaI;YAAa;YAC7D,IAAI,CAAC,CAAA,MAAO,CAACY,IAAI,CAAC,CAAC,OAAO,EAAEvB,YAAY,GAAG,EAAEI,gBAAgB;QAC9D;QAEA,0EAA0E;QAC1E,wEAAwE;QACxE,IAAIX,SAASG,KAAK,CAACV,MAAM,GAAG,GAAG;YAC9B,MAAMsC,YAAYjD,iBAAI,CAACC,OAAO,CAACO,QAAQ,CAAC,EAAE,CAAC0C,UAAU;YACrD,MAAMC,qBAAqBnD,iBAAI,CAACG,IAAI,CAAC8C,WAAW;YAChD,MAAM5C,iBAAE,CAAC+C,EAAE,CAACD,oBAAoB;gBAAEpB,WAAW;gBAAMsB,OAAO;YAAK;YAC/D,KAAK,MAAM/B,WAAWd,SAAU;gBAC/B,MAAMe,MAAM,MAAMD,QAAQE,cAAc;gBACxC,IAAI,CAACD,IAAI5B,IAAI,EAAE;gBACf,MAAMgC,SAAS3B,iBAAI,CAACC,OAAO,CAACqB,QAAQM,SAAS;gBAC7C,MAAM0B,cAActD,iBAAI,CAACG,IAAI,CAACgD,uBAAuB5B,IAAI5B,IAAI,CAACsC,KAAK,CAAC;gBACpE,MAAM5B,iBAAE,CAACyB,KAAK,CAAC9B,iBAAI,CAACmC,OAAO,CAACmB,cAAc;oBAAEvB,WAAW;gBAAK;gBAC5D,MAAM1B,iBAAE,CAACyC,OAAO,CAACnB,QAAQ2B,aAAa;gBACtC,IAAI,CAAC,CAAA,MAAO,CAAC5B,KAAK,CAAC,CAAC,YAAY,EAAEH,IAAI5B,IAAI,CAAC,GAAG,EAAEgC,QAAQ;YACzD;YACAT,SAASiC,kBAAkB,GAAGA;YAC9B,IAAI,CAAC,CAAA,MAAO,CAACH,IAAI,CAAC,CAAC,6BAA6B,EAAEG,oBAAoB;QACvE;QAEA,MAAM9C,iBAAE,CAACkD,SAAS,CAACvD,iBAAI,CAACG,IAAI,CAACJ,WAAWR,gBAAgByB,KAAKwC,SAAS,CAACtC,UAAU,MAAM;QAEvF,OAAOuC,mBAAc,CAACC,OAAO,CAAClE,KAAKG,IAAI;IACxC,EAAE;AACH"}

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

@@ -153,4 +153,4 @@ Publish = _ts_decorate([
     ])
 ], 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":["Publish","npm","Npm","scribe","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","ForgeError","publishResponses","publishProjects","failed","filter","r","succeeded","ActionResponse","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","formatUnknownError","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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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/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":["Publish","npm","Npm","scribe","logger","name","workspace","run","options","projects","getProjects","configuration","token","resolveToken","otp","resolveOtp","length","ForgeError","publishResponses","publishProjects","failed","filter","r","succeeded","ActionResponse","Error","Success","Promise","all","project","isPrivate","info","map","publishProject","channel","dryRun","outDir","getOutDir","response","publish","authToken","skipIfPublished","packageName","data","join","trace","message","projectName","reason","formatUnknownError","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/commonjs/src/actions/sync-lock-file.action.js

@@ -40,4 +40,4 @@ SyncLockFile = _ts_decorate([
     (0, _decorators.injectable)()
 ], SyncLockFile);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -47,9 +47,8 @@ class Tag {
             const git = new _interop.Git();
             await git.tag(tag);
             if (options.push) {
-                const branch = await git.getBranchName();
-                this.#logger.info(`Pushing branch: ${branch}`);
-                await git.push(branch);
+                // Tag-only: Publish checks out a commit SHA (detached HEAD). Pushing a
+                // branch name is wrong there and unnecessary — the version label is the tag.
                 this.#logger.info(`Pushing tag: ${tag}`);
                 await git.pushTag(tag);
             }
@@ -73,4 +72,4 @@ Tag = _ts_decorate([
     ])
 ], Tag);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/actions/unlink.action.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Unlink", {
+    enumerable: true,
+    get: function() {
+        return Unlink;
+    }
+});
+const _promises = /*#__PURE__*/ _interop_require_default(require("node:fs/promises"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _decorators = require("@decohere/crucible/decorators");
+const _cli = require("@decohere/nexus/cli");
+const _scribe = require("@decohere/scribe");
+const _errors = require("../errors.js");
+const _linkaction = require("./link.action.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+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;
+}
+class Unlink {
+    #logger = _scribe.scribe.logger(Unlink.name);
+    run = async (options)=>{
+        const targetDir = _nodepath.default.resolve(options.targetDir);
+        const manifestPath = _nodepath.default.join(targetDir, _linkaction.LINK_MANIFEST);
+        const manifestStat = await _promises.default.stat(manifestPath).catch(()=>null);
+        if (manifestStat == null) {
+            throw new _errors.ForgeError(`No link manifest found at "${manifestPath}". Nothing to unlink.`);
+        }
+        const manifest = JSON.parse(await _promises.default.readFile(manifestPath, "utf8"));
+        for (const { packageName, symlinkPath, originalPath } of manifest.links){
+            const stat = await _promises.default.lstat(symlinkPath).catch(()=>null);
+            if (stat?.isSymbolicLink()) {
+                await _promises.default.unlink(symlinkPath);
+                this.#logger.trace(`Removed symlink for ${packageName}`);
+            }
+            if (originalPath != null) {
+                const backupStat = await _promises.default.stat(originalPath).catch(()=>null);
+                if (backupStat != null) {
+                    await _promises.default.rename(originalPath, symlinkPath);
+                    this.#logger.trace(`Restored original dir for ${packageName}`);
+                } else {
+                    // originalPath is a symlink target string — recreate the symlink
+                    await _promises.default.mkdir(_nodepath.default.dirname(symlinkPath), {
+                        recursive: true
+                    });
+                    await _promises.default.symlink(originalPath, symlinkPath, "dir");
+                    this.#logger.trace(`Restored original symlink for ${packageName}`);
+                }
+            }
+            this.#logger.info(`Unlinked ${packageName}`);
+        }
+        await _promises.default.unlink(manifestPath);
+        if (manifest.peerNodeModulesDir != null) {
+            await _promises.default.rm(manifest.peerNodeModulesDir, {
+                recursive: true,
+                force: true
+            });
+            this.#logger.info(`Removed peer node_modules at ${manifest.peerNodeModulesDir}`);
+        }
+        return _cli.ActionResponse.Success(Unlink.name);
+    };
+}
+Unlink = _ts_decorate([
+    (0, _decorators.injectable)()
+], Unlink);
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/actions/version.action.js

@@ -206,4 +206,4 @@ Version = _ts_decorate([
     ])
 ], Version);
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/actions/version.action.ts"],"sourcesContent":["import { execSync } from \"node:child_process\";\nimport { readdir, readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { HasPackageJson } 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 { Git } from \"@decohere/nexus/interop\";\nimport { Semver, SemverError, type VersionType, VersionTypes } from \"@decohere/nexus/semver\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type VersionResponse = ResultStatus & {\n\tname: string;\n};\n\nexport const DefaultChannel = \"beta\";\nexport const DefaultReleaseType = VersionTypes.prerelease;\n\nexport type VersionOptions = {\n\treleaseType?: VersionType;\n\tchannel?: string;\n\tversion?: string;\n\tdryRun?: boolean;\n\tcommit?: boolean;\n\tmessage?: string;\n\t/** Read pending .changeset entries to determine the highest bump type */\n\tfromChangesets?: boolean;\n};\n\nconst DefaultVersionOptions: VersionOptions = {\n\treleaseType: DefaultReleaseType,\n\tchannel: DefaultChannel,\n\tdryRun: false,\n};\n\n@injectable()\nexport class Version implements Action<VersionOptions> {\n\t#logger = scribe.logger(Version.name);\n\tpublic constructor(private readonly workspace: Workspace) {}\n\tpublic async run(options: VersionOptions): Promise<ActionResponse> {\n\t\tconst response = await this.version(this.workspace, options);\n\t\tconst messages = response.data\n\t\t\t.flatMap((d) => (!d.succeeded && d.error ? [d.error] : []))\n\t\t\t.join(\"\\n\");\n\t\tif (messages) {\n\t\t\tthrow new ForgeError(`There was an error versioning the workspace ${messages}`);\n\t\t}\n\n\t\treturn response;\n\t}\n\n\tpublic async version(\n\t\tworkspace: Workspace,\n\t\toptions: VersionOptions = DefaultVersionOptions,\n\t): Promise<ActionResponse<VersionResponse>> {\n\t\tconst projects = workspace.getProjects(\"debug\");\n\t\tconst rootVersion = await this.resolveBaseVersion(workspace, options);\n\t\tconst releaseType = options.fromChangesets\n\t\t\t? await this.resolveReleaseTypeFromChangesets()\n\t\t\t: (options.releaseType ?? DefaultReleaseType);\n\t\tconst channel = options.channel ?? DefaultChannel;\n\t\tconst nextVersion = this.getNextVersion(rootVersion, releaseType, channel);\n\t\tthis.#logger.info(`${rootVersion} → ${nextVersion} [${releaseType}]`);\n\n\t\tif (options.dryRun) {\n\t\t\tthis.#logger.info(\n\t\t\t\t`[dry-run] Would bump all packages to ${nextVersion} — skipping file writes`,\n\t\t\t);\n\t\t\treturn ActionResponse.Success(Version.name, [\n\t\t\t\t{ name: workspace.name, succeeded: true },\n\t\t\t\t...projects.map((p) => ({ name: p.name, succeeded: true })),\n\t\t\t]);\n\t\t}\n\n\t\tawait workspace.persistPackageJson(\n\t\t\t(await workspace.getPackageJson()).withVersion(nextVersion.toString()),\n\t\t);\n\n\t\tconst responses = await Promise.all([\n\t\t\t...[this.updatePackageJson(workspace.name, workspace, nextVersion)],\n\t\t\t...projects.map((project) => this.updatePackageJson(project.name, project, nextVersion)),\n\t\t]);\n\t\tconst failed = responses.filter((r) => !r.succeeded);\n\t\tif (failed.length) {\n\t\t\treturn ActionResponse.Error(Version.name, responses);\n\t\t}\n\n\t\tif (options.commit) {\n\t\t\tconst files = [workspace.packageJsonPath, ...projects.map((p) => p.packageJsonPath)];\n\t\t\tconst message = options.message ?? `chore: version packages ${nextVersion}`;\n\t\t\tthis.#logger.info(`Committing: ${message}`);\n\t\t\tawait new Git().commit(message, { files });\n\t\t}\n\n\t\treturn ActionResponse.Success(Version.name, responses);\n\t}\n\n\tprivate async resolveBaseVersion(\n\t\tworkspace: Workspace,\n\t\toptions: VersionOptions,\n\t): Promise<string> {\n\t\tif (options.version != null && options.version.trim().length > 0) {\n\t\t\treturn options.version.trim();\n\t\t}\n\n\t\tconst gitTagVersion = this.resolveVersionFromGitTag();\n\t\tif (gitTagVersion != null) {\n\t\t\tthis.#logger.info(`Using latest git tag version as base: ${gitTagVersion}`);\n\t\t\treturn gitTagVersion;\n\t\t}\n\n\t\tconst workspaceVersion = await workspace.getVersion();\n\t\tthis.#logger.info(\n\t\t\t`No semver git tags found, falling back to workspace package.json version: ${workspaceVersion}`,\n\t\t);\n\t\treturn workspaceVersion;\n\t}\n\n\tprivate resolveVersionFromGitTag(): string | undefined {\n\t\ttry {\n\t\t\tconst tags = execSync('git tag --list \"v*\" --sort=-version:refname', {\n\t\t\t\tencoding: \"utf8\",\n\t\t\t})\n\t\t\t\t.trim()\n\t\t\t\t.split(\"\\n\")\n\t\t\t\t.filter(Boolean);\n\n\t\t\tif (tags.length === 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\treturn tags[0].replace(/^v/, \"\");\n\t\t} catch {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Reads all pending .changeset/*.md entries and returns the highest bump type\n\t * found across all of them. Precedence: major > minor > patch.\n\t */\n\tprivate async resolveReleaseTypeFromChangesets(): Promise<VersionType> {\n\t\tconst changesetDir = join(process.cwd(), \".changeset\");\n\t\tlet entries: string[];\n\t\ttry {\n\t\t\tentries = await readdir(changesetDir);\n\t\t} catch {\n\t\t\tthrow new ForgeError(\n\t\t\t\t\"No .changeset directory found. Run `pnpm changeset` to create an entry.\",\n\t\t\t);\n\t\t}\n\n\t\tconst files = entries.filter((e) => e.endsWith(\".md\") && e !== \"README.md\");\n\t\tif (files.length === 0) {\n\t\t\tthrow new ForgeError(\n\t\t\t\t\"No pending changeset entries found in .changeset/. Run `pnpm changeset` to create one.\",\n\t\t\t);\n\t\t}\n\n\t\tconst precedence: Record<string, number> = { major: 3, minor: 2, patch: 1, prerelease: 0 };\n\t\tlet maxType: VersionType = VersionTypes.patch;\n\t\tlet maxPrecedence = 0;\n\n\t\tfor (const file of files) {\n\t\t\tconst content = await readFile(join(changesetDir, file), \"utf8\");\n\t\t\tconst match = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n\t\t\tif (!match) continue;\n\t\t\tfor (const line of match[1].split(\"\\n\")) {\n\t\t\t\tconst bumpType = line.match(/^\"[^\"]+\"\\s*:\\s*(\\w+)/)?.[1] as VersionType | undefined;\n\t\t\t\tconst p = bumpType != null ? (precedence[bumpType] ?? -1) : -1;\n\t\t\t\tif (p > maxPrecedence) {\n\t\t\t\t\tmaxType = bumpType as VersionType;\n\t\t\t\t\tmaxPrecedence = p;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.#logger.info(`Resolved release type from ${files.length} changeset(s): ${maxType}`);\n\t\treturn maxType;\n\t}\n\n\tprivate getNextVersion(\n\t\tcurrentVersion: string,\n\t\tversionType: VersionType,\n\t\tpreid: string,\n\t): Semver {\n\t\ttry {\n\t\t\treturn new Semver(currentVersion).increment(versionType, preid);\n\t\t} catch (error) {\n\t\t\tif (error instanceof SemverError) {\n\t\t\t\tthrow new ForgeError(error.message);\n\t\t\t}\n\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tprivate async updatePackageJson(\n\t\tname: string,\n\t\thasJson: HasPackageJson,\n\t\tversion: Semver,\n\t): Promise<VersionResponse> {\n\t\ttry {\n\t\t\tconst packageJson = await hasJson.getPackageJson();\n\t\t\tawait hasJson.persistPackageJson(packageJson.withVersion(version.toString()));\n\t\t\tthis.#logger.trace(name);\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tsucceeded: true,\n\t\t\t};\n\t\t} catch (reason) {\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tsucceeded: false,\n\t\t\t\terror: `${name}: ${formatUnknownError(reason)}`,\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["DefaultChannel","DefaultReleaseType","Version","VersionTypes","prerelease","DefaultVersionOptions","releaseType","channel","dryRun","scribe","logger","name","workspace","run","options","response","version","messages","data","flatMap","d","succeeded","error","join","ForgeError","projects","getProjects","rootVersion","resolveBaseVersion","fromChangesets","resolveReleaseTypeFromChangesets","nextVersion","getNextVersion","info","ActionResponse","Success","map","p","persistPackageJson","getPackageJson","withVersion","toString","responses","Promise","all","updatePackageJson","project","failed","filter","r","length","Error","commit","files","packageJsonPath","message","Git","trim","gitTagVersion","resolveVersionFromGitTag","workspaceVersion","getVersion","tags","execSync","encoding","split","Boolean","undefined","replace","changesetDir","process","cwd","entries","readdir","e","endsWith","precedence","major","minor","patch","maxType","maxPrecedence","file","content","readFile","match","line","bumpType","currentVersion","versionType","preid","Semver","increment","SemverError","hasJson","packageJson","trace","reason","formatUnknownError"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/actions/version.action.ts"],"sourcesContent":["import { execSync } from \"node:child_process\";\nimport { readdir, readFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { injectable } from \"@decohere/crucible/decorators\";\nimport type { HasPackageJson } 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 { Git } from \"@decohere/nexus/interop\";\nimport { Semver, SemverError, type VersionType, VersionTypes } from \"@decohere/nexus/semver\";\nimport { scribe } from \"@decohere/scribe\";\nimport { ForgeError, formatUnknownError } from \"../errors.js\";\n\nexport type VersionResponse = ResultStatus & {\n\tname: string;\n};\n\nexport const DefaultChannel = \"beta\";\nexport const DefaultReleaseType = VersionTypes.prerelease;\n\nexport type VersionOptions = {\n\treleaseType?: VersionType;\n\tchannel?: string;\n\tversion?: string;\n\tdryRun?: boolean;\n\tcommit?: boolean;\n\tmessage?: string;\n\t/** Read pending .changeset entries to determine the highest bump type */\n\tfromChangesets?: boolean;\n};\n\nconst DefaultVersionOptions: VersionOptions = {\n\treleaseType: DefaultReleaseType,\n\tchannel: DefaultChannel,\n\tdryRun: false,\n};\n\n@injectable()\nexport class Version implements Action<VersionOptions> {\n\t#logger = scribe.logger(Version.name);\n\tpublic constructor(private readonly workspace: Workspace) {}\n\tpublic async run(options: VersionOptions): Promise<ActionResponse> {\n\t\tconst response = await this.version(this.workspace, options);\n\t\tconst messages = response.data\n\t\t\t.flatMap((d) => (!d.succeeded && d.error ? [d.error] : []))\n\t\t\t.join(\"\\n\");\n\t\tif (messages) {\n\t\t\tthrow new ForgeError(`There was an error versioning the workspace ${messages}`);\n\t\t}\n\n\t\treturn response;\n\t}\n\n\tpublic async version(\n\t\tworkspace: Workspace,\n\t\toptions: VersionOptions = DefaultVersionOptions,\n\t): Promise<ActionResponse<VersionResponse>> {\n\t\tconst projects = workspace.getProjects(\"debug\");\n\t\tconst rootVersion = await this.resolveBaseVersion(workspace, options);\n\t\tconst releaseType = options.fromChangesets\n\t\t\t? await this.resolveReleaseTypeFromChangesets()\n\t\t\t: (options.releaseType ?? DefaultReleaseType);\n\t\tconst channel = options.channel ?? DefaultChannel;\n\t\tconst nextVersion = this.getNextVersion(rootVersion, releaseType, channel);\n\t\tthis.#logger.info(`${rootVersion} → ${nextVersion} [${releaseType}]`);\n\n\t\tif (options.dryRun) {\n\t\t\tthis.#logger.info(\n\t\t\t\t`[dry-run] Would bump all packages to ${nextVersion} — skipping file writes`,\n\t\t\t);\n\t\t\treturn ActionResponse.Success(Version.name, [\n\t\t\t\t{ name: workspace.name, succeeded: true },\n\t\t\t\t...projects.map((p) => ({ name: p.name, succeeded: true })),\n\t\t\t]);\n\t\t}\n\n\t\tawait workspace.persistPackageJson(\n\t\t\t(await workspace.getPackageJson()).withVersion(nextVersion.toString()),\n\t\t);\n\n\t\tconst responses = await Promise.all([\n\t\t\t...[this.updatePackageJson(workspace.name, workspace, nextVersion)],\n\t\t\t...projects.map((project) => this.updatePackageJson(project.name, project, nextVersion)),\n\t\t]);\n\t\tconst failed = responses.filter((r) => !r.succeeded);\n\t\tif (failed.length) {\n\t\t\treturn ActionResponse.Error(Version.name, responses);\n\t\t}\n\n\t\tif (options.commit) {\n\t\t\tconst files = [workspace.packageJsonPath, ...projects.map((p) => p.packageJsonPath)];\n\t\t\tconst message = options.message ?? `chore: version packages ${nextVersion}`;\n\t\t\tthis.#logger.info(`Committing: ${message}`);\n\t\t\tawait new Git().commit(message, { files });\n\t\t}\n\n\t\treturn ActionResponse.Success(Version.name, responses);\n\t}\n\n\tprivate async resolveBaseVersion(\n\t\tworkspace: Workspace,\n\t\toptions: VersionOptions,\n\t): Promise<string> {\n\t\tif (options.version != null && options.version.trim().length > 0) {\n\t\t\treturn options.version.trim();\n\t\t}\n\n\t\tconst gitTagVersion = this.resolveVersionFromGitTag();\n\t\tif (gitTagVersion != null) {\n\t\t\tthis.#logger.info(`Using latest git tag version as base: ${gitTagVersion}`);\n\t\t\treturn gitTagVersion;\n\t\t}\n\n\t\tconst workspaceVersion = await workspace.getVersion();\n\t\tthis.#logger.info(\n\t\t\t`No semver git tags found, falling back to workspace package.json version: ${workspaceVersion}`,\n\t\t);\n\t\treturn workspaceVersion;\n\t}\n\n\tprivate resolveVersionFromGitTag(): string | undefined {\n\t\ttry {\n\t\t\tconst tags = execSync('git tag --list \"v*\" --sort=-version:refname', {\n\t\t\t\tencoding: \"utf8\",\n\t\t\t})\n\t\t\t\t.trim()\n\t\t\t\t.split(\"\\n\")\n\t\t\t\t.filter(Boolean);\n\n\t\t\tif (tags.length === 0) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\treturn tags[0].replace(/^v/, \"\");\n\t\t} catch {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Reads all pending .changeset/*.md entries and returns the highest bump type\n\t * found across all of them. Precedence: major > minor > patch.\n\t */\n\tprivate async resolveReleaseTypeFromChangesets(): Promise<VersionType> {\n\t\tconst changesetDir = join(process.cwd(), \".changeset\");\n\t\tlet entries: string[];\n\t\ttry {\n\t\t\tentries = await readdir(changesetDir);\n\t\t} catch {\n\t\t\tthrow new ForgeError(\n\t\t\t\t\"No .changeset directory found. Run `pnpm changeset` to create an entry.\",\n\t\t\t);\n\t\t}\n\n\t\tconst files = entries.filter((e) => e.endsWith(\".md\") && e !== \"README.md\");\n\t\tif (files.length === 0) {\n\t\t\tthrow new ForgeError(\n\t\t\t\t\"No pending changeset entries found in .changeset/. Run `pnpm changeset` to create one.\",\n\t\t\t);\n\t\t}\n\n\t\tconst precedence: Record<string, number> = { major: 3, minor: 2, patch: 1, prerelease: 0 };\n\t\tlet maxType: VersionType = VersionTypes.patch;\n\t\tlet maxPrecedence = 0;\n\n\t\tfor (const file of files) {\n\t\t\tconst content = await readFile(join(changesetDir, file), \"utf8\");\n\t\t\tconst match = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n\t\t\tif (!match) continue;\n\t\t\tfor (const line of match[1].split(\"\\n\")) {\n\t\t\t\tconst bumpType = line.match(/^\"[^\"]+\"\\s*:\\s*(\\w+)/)?.[1] as VersionType | undefined;\n\t\t\t\tconst p = bumpType != null ? (precedence[bumpType] ?? -1) : -1;\n\t\t\t\tif (p > maxPrecedence) {\n\t\t\t\t\tmaxType = bumpType as VersionType;\n\t\t\t\t\tmaxPrecedence = p;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tthis.#logger.info(`Resolved release type from ${files.length} changeset(s): ${maxType}`);\n\t\treturn maxType;\n\t}\n\n\tprivate getNextVersion(\n\t\tcurrentVersion: string,\n\t\tversionType: VersionType,\n\t\tpreid: string,\n\t): Semver {\n\t\ttry {\n\t\t\treturn new Semver(currentVersion).increment(versionType, preid);\n\t\t} catch (error) {\n\t\t\tif (error instanceof SemverError) {\n\t\t\t\tthrow new ForgeError(error.message);\n\t\t\t}\n\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tprivate async updatePackageJson(\n\t\tname: string,\n\t\thasJson: HasPackageJson,\n\t\tversion: Semver,\n\t): Promise<VersionResponse> {\n\t\ttry {\n\t\t\tconst packageJson = await hasJson.getPackageJson();\n\t\t\tawait hasJson.persistPackageJson(packageJson.withVersion(version.toString()));\n\t\t\tthis.#logger.trace(name);\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tsucceeded: true,\n\t\t\t};\n\t\t} catch (reason) {\n\t\t\treturn {\n\t\t\t\tname,\n\t\t\t\tsucceeded: false,\n\t\t\t\terror: `${name}: ${formatUnknownError(reason)}`,\n\t\t\t};\n\t\t}\n\t}\n}\n"],"names":["DefaultChannel","DefaultReleaseType","Version","VersionTypes","prerelease","DefaultVersionOptions","releaseType","channel","dryRun","scribe","logger","name","workspace","run","options","response","version","messages","data","flatMap","d","succeeded","error","join","ForgeError","projects","getProjects","rootVersion","resolveBaseVersion","fromChangesets","resolveReleaseTypeFromChangesets","nextVersion","getNextVersion","info","ActionResponse","Success","map","p","persistPackageJson","getPackageJson","withVersion","toString","responses","Promise","all","updatePackageJson","project","failed","filter","r","length","Error","commit","files","packageJsonPath","message","Git","trim","gitTagVersion","resolveVersionFromGitTag","workspaceVersion","getVersion","tags","execSync","encoding","split","Boolean","undefined","replace","changesetDir","process","cwd","entries","readdir","e","endsWith","precedence","major","minor","patch","maxType","maxPrecedence","file","content","readFile","match","line","bumpType","currentVersion","versionType","preid","Semver","increment","SemverError","hasJson","packageJson","trace","reason","formatUnknownError"],"mappings":"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"}

package/commonjs/src/actions/watch.action.js

@@ -33,6 +33,7 @@ class Watch {
             return _cli.ActionResponse.Skipped(Watch.name);
         }
         await this.workspace.watch(options.configuration);
+        this.#logger.info(`Starting watch`);
         return _cli.ActionResponse.Blocking(Watch.name);
     };
     [Symbol.dispose]() {
@@ -47,4 +48,4 @@ Watch = _ts_decorate([
     ])
 ], Watch);
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/commands/build.command.js

@@ -46,4 +46,4 @@ class BuildCommand extends _cli.DecohereCommand {
     };
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/commands/dependency.command.js

@@ -85,4 +85,4 @@ class ReportCommand extends _cli.DecohereCommand {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/src/projects/forge/src/commands/dependency.command.ts"],"sourcesContent":["import type { CommandHandler } from \"@decohere/nexus/cli\";\nimport { CommandResponse, ConfigurationOption, DecohereCommand } from \"@decohere/nexus/cli\";\nimport type { CommitFilesOptions } from \"../actions/commit.action.js\";\nimport { CommitFiles } from \"../actions/commit.action.js\";\nimport { ReportDependencies } from \"../actions/dependency-report.action.js\";\nimport type { DependenciesOptions } from \"../actions/dependency-sync.action.js\";\nimport { SyncDependencies as DependencySync } from \"../actions/dependency-sync.action.js\";\nimport type { SyncLockFileOptions } from \"../actions/sync-lock-file.action.js\";\nimport { SyncLockFile } from \"../actions/sync-lock-file.action.js\";\nimport { Release } from \"../workspace.config.js\";\n\nexport class DependencyCommand extends DecohereCommand {\n\tpublic constructor(name?: string, handler?: CommandHandler) {\n\t\tsuper(name ?? DependencyCommand);\n\t\tthis.description(\"Analyze and sync workspace dependencies\");\n\t\tthis.addOption(new ConfigurationOption(\"release\"));\n\t\tthis.registerSubcommand(ReportCommand, handler);\n\t\tthis.registerSubcommand(SyncCommand, handler);\n\t}\n}\n\ntype SyncActions = {\n\tsyncDependencies: DependencySync;\n\tsyncLockFile: SyncLockFile;\n\tcommitFiles: CommitFiles;\n};\n\nclass SyncCommand extends DecohereCommand<SyncActions> {\n\tpublic override get actions() {\n\t\treturn [DependencySync, SyncLockFile, CommitFiles];\n\t}\n\n\tpublic constructor() {\n\t\tsuper(SyncCommand);\n\t\tthis.description(\"Sync workspace dependency manifests\");\n\t\tthis.option(\n\t\t\t\"--log-diff\",\n\t\t\t\"Log what changed in each project's dependencies after syncing\",\n\t\t\tfalse,\n\t\t);\n\t\tthis.option(\"--no-sync\", \"Skip lockfile sync after syncing dependencies\", true);\n\t\tthis.option(\"--commit\", \"Commit synced workspace manifest changes\", false);\n\t\tthis.option(\"--message <message>\", \"Commit message (used with --commit)\");\n\t}\n\n\tpublic override async run(actions: SyncActions, options: Record<string, unknown>) {\n\t\tconst responses: CommandResponse<SyncActions> = {};\n\t\tconst configuration =\n\t\t\ttypeof options.configuration === \"string\" ? options.configuration : Release.name;\n\n\t\tconst syncDependencyOptions: DependenciesOptions = {\n\t\t\tconfiguration,\n\t\t\tlogDiff: options.logDiff === true,\n\t\t};\n\n\t\tconst syncLockOptions: SyncLockFileOptions = {\n\t\t\tsync: options.sync !== false,\n\t\t\tdryRun: options.dryRun === true,\n\t\t};\n\n\t\tconst commitOptions: CommitFilesOptions = {\n\t\t\tconfiguration,\n\t\t\tcommit: options.commit === true,\n\t\t\tdryRun: options.dryRun === true,\n\t\t\tmessage: typeof options.message === \"string\" ? options.message : undefined,\n\t\t};\n\n\t\tresponses.syncDependencies = await actions.syncDependencies.run(syncDependencyOptions);\n\t\tthis.throwOnErrors({ syncDependencies: responses.syncDependencies });\n\n\t\tresponses.syncLockFile = await actions.syncLockFile.run(syncLockOptions);\n\t\tthis.throwOnErrors({ syncLockFile: responses.syncLockFile });\n\n\t\tresponses.commitFiles = await actions.commitFiles.run(commitOptions);\n\t\tthis.throwOnErrors({ commitFiles: responses.commitFiles });\n\n\t\treturn CommandResponse.success(options, responses);\n\t}\n}\n\nclass ReportCommand extends DecohereCommand {\n\tpublic override get actions() {\n\t\treturn [ReportDependencies];\n\t}\n\n\tpublic constructor() {\n\t\tsuper(ReportCommand);\n\t\tthis.description(\"Report resolved dependencies for workspace projects\");\n\t\tthis.option(\"--file <file>\", \"Optional file path to write the report to\");\n\t\tthis.option(\n\t\t\t\"--fail-on-drift\",\n\t\t\t\"Exit with an error if resolved dependencies differ from what is declared in package.json\",\n\t\t\tfalse,\n\t\t);\n\t}\n}\n"],"names":["DependencyCommand","DecohereCommand","name","handler","description","addOption","ConfigurationOption","registerSubcommand","ReportCommand","SyncCommand","actions","DependencySync","SyncLockFile","CommitFiles","option","run","options","responses","configuration","Release","syncDependencyOptions","logDiff","syncLockOptions","sync","dryRun","commitOptions","commit","message","undefined","syncDependencies","throwOnErrors","syncLockFile","commitFiles","CommandResponse","success","ReportDependencies"],"mappings":";;;;+BAWaA;;;eAAAA;;;qBAVyD;8BAE1C;wCACO;sCAEgB;oCAEtB;iCACL;AAEjB,MAAMA,0BAA0BC,oBAAe;IACrD,YAAmBC,IAAa,EAAEC,OAAwB,CAAE;QAC3D,KAAK,CAACD,QAAQF;QACd,IAAI,CAACI,WAAW,CAAC;QACjB,IAAI,CAACC,SAAS,CAAC,IAAIC,wBAAmB,CAAC;QACvC,IAAI,CAACC,kBAAkB,CAACC,eAAeL;QACvC,IAAI,CAACI,kBAAkB,CAACE,aAAaN;IACtC;AACD;AAQA,MAAMM,oBAAoBR,oBAAe;IACxC,IAAoBS,UAAU;QAC7B,OAAO;YAACC,sCAAc;YAAEC,gCAAY;YAAEC,yBAAW;SAAC;IACnD;IAEA,aAAqB;QACpB,KAAK,CAACJ;QACN,IAAI,CAACL,WAAW,CAAC;QACjB,IAAI,CAACU,MAAM,CACV,cACA,iEACA;QAED,IAAI,CAACA,MAAM,CAAC,aAAa,iDAAiD;QAC1E,IAAI,CAACA,MAAM,CAAC,YAAY,4CAA4C;QACpE,IAAI,CAACA,MAAM,CAAC,uBAAuB;IACpC;IAEA,MAAsBC,IAAIL,OAAoB,EAAEM,OAAgC,EAAE;QACjF,MAAMC,YAA0C,CAAC;QACjD,MAAMC,gBACL,OAAOF,QAAQE,aAAa,KAAK,WAAWF,QAAQE,aAAa,GAAGC,wBAAO,CAACjB,IAAI;QAEjF,MAAMkB,wBAA6C;YAClDF;YACAG,SAASL,QAAQK,OAAO,KAAK;QAC9B;QAEA,MAAMC,kBAAuC;YAC5CC,MAAMP,QAAQO,IAAI,KAAK;YACvBC,QAAQR,QAAQQ,MAAM,KAAK;QAC5B;QAEA,MAAMC,gBAAoC;YACzCP;YACAQ,QAAQV,QAAQU,MAAM,KAAK;YAC3BF,QAAQR,QAAQQ,MAAM,KAAK;YAC3BG,SAAS,OAAOX,QAAQW,OAAO,KAAK,WAAWX,QAAQW,OAAO,GAAGC;QAClE;QAEAX,UAAUY,gBAAgB,GAAG,MAAMnB,QAAQmB,gBAAgB,CAACd,GAAG,CAACK;QAChE,IAAI,CAACU,aAAa,CAAC;YAAED,kBAAkBZ,UAAUY,gBAAgB;QAAC;QAElEZ,UAAUc,YAAY,GAAG,MAAMrB,QAAQqB,YAAY,CAAChB,GAAG,CAACO;QACxD,IAAI,CAACQ,aAAa,CAAC;YAAEC,cAAcd,UAAUc,YAAY;QAAC;QAE1Dd,UAAUe,WAAW,GAAG,MAAMtB,QAAQsB,WAAW,CAACjB,GAAG,CAACU;QACtD,IAAI,CAACK,aAAa,CAAC;YAAEE,aAAaf,UAAUe,WAAW;QAAC;QAExD,OAAOC,oBAAe,CAACC,OAAO,CAAClB,SAASC;IACzC;AACD;AAEA,MAAMT,sBAAsBP,oBAAe;IAC1C,IAAoBS,UAAU;QAC7B,OAAO;YAACyB,0CAAkB;SAAC;IAC5B;IAEA,aAAqB;QACpB,KAAK,CAAC3B;QACN,IAAI,CAACJ,WAAW,CAAC;QACjB,IAAI,CAACU,MAAM,CAAC,iBAAiB;QAC7B,IAAI,CAACA,MAAM,CACV,mBACA,4FACA;IAEF;AACD"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/forge/src/commands/dependency.command.ts"],"sourcesContent":["import type { CommandHandler } from \"@decohere/nexus/cli\";\nimport { CommandResponse, ConfigurationOption, DecohereCommand } from \"@decohere/nexus/cli\";\nimport type { CommitFilesOptions } from \"../actions/commit.action.js\";\nimport { CommitFiles } from \"../actions/commit.action.js\";\nimport { ReportDependencies } from \"../actions/dependency-report.action.js\";\nimport type { DependenciesOptions } from \"../actions/dependency-sync.action.js\";\nimport { SyncDependencies as DependencySync } from \"../actions/dependency-sync.action.js\";\nimport type { SyncLockFileOptions } from \"../actions/sync-lock-file.action.js\";\nimport { SyncLockFile } from \"../actions/sync-lock-file.action.js\";\nimport { Release } from \"../workspace.config.js\";\n\nexport class DependencyCommand extends DecohereCommand {\n\tpublic constructor(name?: string, handler?: CommandHandler) {\n\t\tsuper(name ?? DependencyCommand);\n\t\tthis.description(\"Analyze and sync workspace dependencies\");\n\t\tthis.addOption(new ConfigurationOption(\"release\"));\n\t\tthis.registerSubcommand(ReportCommand, handler);\n\t\tthis.registerSubcommand(SyncCommand, handler);\n\t}\n}\n\ntype SyncActions = {\n\tsyncDependencies: DependencySync;\n\tsyncLockFile: SyncLockFile;\n\tcommitFiles: CommitFiles;\n};\n\nclass SyncCommand extends DecohereCommand<SyncActions> {\n\tpublic override get actions() {\n\t\treturn [DependencySync, SyncLockFile, CommitFiles];\n\t}\n\n\tpublic constructor() {\n\t\tsuper(SyncCommand);\n\t\tthis.description(\"Sync workspace dependency manifests\");\n\t\tthis.option(\n\t\t\t\"--log-diff\",\n\t\t\t\"Log what changed in each project's dependencies after syncing\",\n\t\t\tfalse,\n\t\t);\n\t\tthis.option(\"--no-sync\", \"Skip lockfile sync after syncing dependencies\", true);\n\t\tthis.option(\"--commit\", \"Commit synced workspace manifest changes\", false);\n\t\tthis.option(\"--message <message>\", \"Commit message (used with --commit)\");\n\t}\n\n\tpublic override async run(actions: SyncActions, options: Record<string, unknown>) {\n\t\tconst responses: CommandResponse<SyncActions> = {};\n\t\tconst configuration =\n\t\t\ttypeof options.configuration === \"string\" ? options.configuration : Release.name;\n\n\t\tconst syncDependencyOptions: DependenciesOptions = {\n\t\t\tconfiguration,\n\t\t\tlogDiff: options.logDiff === true,\n\t\t};\n\n\t\tconst syncLockOptions: SyncLockFileOptions = {\n\t\t\tsync: options.sync !== false,\n\t\t\tdryRun: options.dryRun === true,\n\t\t};\n\n\t\tconst commitOptions: CommitFilesOptions = {\n\t\t\tconfiguration,\n\t\t\tcommit: options.commit === true,\n\t\t\tdryRun: options.dryRun === true,\n\t\t\tmessage: typeof options.message === \"string\" ? options.message : undefined,\n\t\t};\n\n\t\tresponses.syncDependencies = await actions.syncDependencies.run(syncDependencyOptions);\n\t\tthis.throwOnErrors({ syncDependencies: responses.syncDependencies });\n\n\t\tresponses.syncLockFile = await actions.syncLockFile.run(syncLockOptions);\n\t\tthis.throwOnErrors({ syncLockFile: responses.syncLockFile });\n\n\t\tresponses.commitFiles = await actions.commitFiles.run(commitOptions);\n\t\tthis.throwOnErrors({ commitFiles: responses.commitFiles });\n\n\t\treturn CommandResponse.success(options, responses);\n\t}\n}\n\nclass ReportCommand extends DecohereCommand {\n\tpublic override get actions() {\n\t\treturn [ReportDependencies];\n\t}\n\n\tpublic constructor() {\n\t\tsuper(ReportCommand);\n\t\tthis.description(\"Report resolved dependencies for workspace projects\");\n\t\tthis.option(\"--file <file>\", \"Optional file path to write the report to\");\n\t\tthis.option(\n\t\t\t\"--fail-on-drift\",\n\t\t\t\"Exit with an error if resolved dependencies differ from what is declared in package.json\",\n\t\t\tfalse,\n\t\t);\n\t}\n}\n"],"names":["DependencyCommand","DecohereCommand","name","handler","description","addOption","ConfigurationOption","registerSubcommand","ReportCommand","SyncCommand","actions","DependencySync","SyncLockFile","CommitFiles","option","run","options","responses","configuration","Release","syncDependencyOptions","logDiff","syncLockOptions","sync","dryRun","commitOptions","commit","message","undefined","syncDependencies","throwOnErrors","syncLockFile","commitFiles","CommandResponse","success","ReportDependencies"],"mappings":";;;;+BAWaA;;;eAAAA;;;qBAVyD;8BAE1C;wCACO;sCAEgB;oCAEtB;iCACL;AAEjB,MAAMA,0BAA0BC,oBAAe;IACrD,YAAmBC,IAAa,EAAEC,OAAwB,CAAE;QAC3D,KAAK,CAACD,QAAQF;QACd,IAAI,CAACI,WAAW,CAAC;QACjB,IAAI,CAACC,SAAS,CAAC,IAAIC,wBAAmB,CAAC;QACvC,IAAI,CAACC,kBAAkB,CAACC,eAAeL;QACvC,IAAI,CAACI,kBAAkB,CAACE,aAAaN;IACtC;AACD;AAQA,MAAMM,oBAAoBR,oBAAe;IACxC,IAAoBS,UAAU;QAC7B,OAAO;YAACC,sCAAc;YAAEC,gCAAY;YAAEC,yBAAW;SAAC;IACnD;IAEA,aAAqB;QACpB,KAAK,CAACJ;QACN,IAAI,CAACL,WAAW,CAAC;QACjB,IAAI,CAACU,MAAM,CACV,cACA,iEACA;QAED,IAAI,CAACA,MAAM,CAAC,aAAa,iDAAiD;QAC1E,IAAI,CAACA,MAAM,CAAC,YAAY,4CAA4C;QACpE,IAAI,CAACA,MAAM,CAAC,uBAAuB;IACpC;IAEA,MAAsBC,IAAIL,OAAoB,EAAEM,OAAgC,EAAE;QACjF,MAAMC,YAA0C,CAAC;QACjD,MAAMC,gBACL,OAAOF,QAAQE,aAAa,KAAK,WAAWF,QAAQE,aAAa,GAAGC,wBAAO,CAACjB,IAAI;QAEjF,MAAMkB,wBAA6C;YAClDF;YACAG,SAASL,QAAQK,OAAO,KAAK;QAC9B;QAEA,MAAMC,kBAAuC;YAC5CC,MAAMP,QAAQO,IAAI,KAAK;YACvBC,QAAQR,QAAQQ,MAAM,KAAK;QAC5B;QAEA,MAAMC,gBAAoC;YACzCP;YACAQ,QAAQV,QAAQU,MAAM,KAAK;YAC3BF,QAAQR,QAAQQ,MAAM,KAAK;YAC3BG,SAAS,OAAOX,QAAQW,OAAO,KAAK,WAAWX,QAAQW,OAAO,GAAGC;QAClE;QAEAX,UAAUY,gBAAgB,GAAG,MAAMnB,QAAQmB,gBAAgB,CAACd,GAAG,CAACK;QAChE,IAAI,CAACU,aAAa,CAAC;YAAED,kBAAkBZ,UAAUY,gBAAgB;QAAC;QAElEZ,UAAUc,YAAY,GAAG,MAAMrB,QAAQqB,YAAY,CAAChB,GAAG,CAACO;QACxD,IAAI,CAACQ,aAAa,CAAC;YAAEC,cAAcd,UAAUc,YAAY;QAAC;QAE1Dd,UAAUe,WAAW,GAAG,MAAMtB,QAAQsB,WAAW,CAACjB,GAAG,CAACU;QACtD,IAAI,CAACK,aAAa,CAAC;YAAEE,aAAaf,UAAUe,WAAW;QAAC;QAExD,OAAOC,oBAAe,CAACC,OAAO,CAAClB,SAASC;IACzC;AACD;AAEA,MAAMT,sBAAsBP,oBAAe;IAC1C,IAAoBS,UAAU;QAC7B,OAAO;YAACyB,0CAAkB;SAAC;IAC5B;IAEA,aAAqB;QACpB,KAAK,CAAC3B;QACN,IAAI,CAACJ,WAAW,CAAC;QACjB,IAAI,CAACU,MAAM,CAAC,iBAAiB;QAC7B,IAAI,CAACA,MAAM,CACV,mBACA,4FACA;IAEF;AACD"}

package/commonjs/src/commands/docker.command.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "DockerCommand", {
+    enumerable: true,
+    get: function() {
+        return DockerCommand;
+    }
+});
+const _cli = require("@decohere/nexus/cli");
+const _dockeraction = require("../actions/docker.action.js");
+class DockerCommand extends _cli.DecohereCommand {
+    get actions() {
+        return [
+            _dockeraction.Docker
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Build Docker images for workspace projects");
+        this.addOption(new _cli.ConfigurationOption("release"));
+        this.addOption(new _cli.DryRunOption("Build images without pushing to a registry"));
+        this.option("--push", "Push built images after a successful build", false);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9jb21tYW5kcy9kb2NrZXIuY29tbWFuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb25maWd1cmF0aW9uT3B0aW9uLCBEZWNvaGVyZUNvbW1hbmQsIERyeVJ1bk9wdGlvbiB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQgeyBEb2NrZXIgfSBmcm9tIFwiLi4vYWN0aW9ucy9kb2NrZXIuYWN0aW9uLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBEb2NrZXJDb21tYW5kIGV4dGVuZHMgRGVjb2hlcmVDb21tYW5kIHtcblx0cHVibGljIG92ZXJyaWRlIGdldCBhY3Rpb25zKCkge1xuXHRcdHJldHVybiBbRG9ja2VyXTtcblx0fVxuXG5cdHB1YmxpYyBjb25zdHJ1Y3RvcihuYW1lOiBzdHJpbmcpIHtcblx0XHRzdXBlcihuYW1lKTtcblx0XHR0aGlzLmRlc2NyaXB0aW9uKFwiQnVpbGQgRG9ja2VyIGltYWdlcyBmb3Igd29ya3NwYWNlIHByb2plY3RzXCIpO1xuXHRcdHRoaXMuYWRkT3B0aW9uKG5ldyBDb25maWd1cmF0aW9uT3B0aW9uKFwicmVsZWFzZVwiKSk7XG5cdFx0dGhpcy5hZGRPcHRpb24obmV3IERyeVJ1bk9wdGlvbihcIkJ1aWxkIGltYWdlcyB3aXRob3V0IHB1c2hpbmcgdG8gYSByZWdpc3RyeVwiKSk7XG5cdFx0dGhpcy5vcHRpb24oXCItLXB1c2hcIiwgXCJQdXNoIGJ1aWx0IGltYWdlcyBhZnRlciBhIHN1Y2Nlc3NmdWwgYnVpbGRcIiwgZmFsc2UpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRG9ja2VyQ29tbWFuZCIsIkRlY29oZXJlQ29tbWFuZCIsImFjdGlvbnMiLCJEb2NrZXIiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJhZGRPcHRpb24iLCJDb25maWd1cmF0aW9uT3B0aW9uIiwiRHJ5UnVuT3B0aW9uIiwib3B0aW9uIl0sIm1hcHBpbmdzIjoiOzs7OytCQUdhQTs7O2VBQUFBOzs7cUJBSHNEOzhCQUM1QztBQUVoQixNQUFNQSxzQkFBc0JDLG9CQUFlO0lBQ2pELElBQW9CQyxVQUFVO1FBQzdCLE9BQU87WUFBQ0Msb0JBQU07U0FBQztJQUNoQjtJQUVBLFlBQW1CQyxJQUFZLENBQUU7UUFDaEMsS0FBSyxDQUFDQTtRQUNOLElBQUksQ0FBQ0MsV0FBVyxDQUFDO1FBQ2pCLElBQUksQ0FBQ0MsU0FBUyxDQUFDLElBQUlDLHdCQUFtQixDQUFDO1FBQ3ZDLElBQUksQ0FBQ0QsU0FBUyxDQUFDLElBQUlFLGlCQUFZLENBQUM7UUFDaEMsSUFBSSxDQUFDQyxNQUFNLENBQUMsVUFBVSw4Q0FBOEM7SUFDckU7QUFDRCJ9

package/commonjs/src/commands/forge.command.js

@@ -21,4 +21,4 @@ class ForgeCommand extends _cli.DecohereCommand {
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zcmMvcHJvamVjdHMvZm9yZ2Uvc3JjL2NvbW1hbmRzL2ZvcmdlLmNvbW1hbmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBBY3Rpb25zIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7XG5cdHR5cGUgQ29tbWFuZEhhbmRsZXIsXG5cdHR5cGUgQ29tbWFuZFJlc3BvbnNlLFxuXHR0eXBlIENvbW1hbmRUeXBlLFxuXHREZWNvaGVyZUNvbW1hbmQsXG59IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5cbmV4cG9ydCBjbGFzcyBGb3JnZUNvbW1hbmQgZXh0ZW5kcyBEZWNvaGVyZUNvbW1hbmQge1xuXHRwdWJsaWMgY29uc3RydWN0b3IoY29tbWFuZHM6IFJlY29yZDxzdHJpbmcsIENvbW1hbmRUeXBlPiwgaGFuZGxlcjogQ29tbWFuZEhhbmRsZXIpIHtcblx0XHRzdXBlcihGb3JnZUNvbW1hbmQpO1xuXHRcdHRoaXMuZGVzY3JpcHRpb24oXCJSdW4gZm9yZ2Ugd29ya3NwYWNlIHdvcmtmbG93c1wiKTtcblx0XHR0aGlzLmV4aXRPdmVycmlkZSgpO1xuXHRcdHRoaXMucmVnaXN0ZXJTdWJjb21tYW5kKGNvbW1hbmRzLCBoYW5kbGVyKTtcblx0fVxuXG5cdHB1YmxpYyBydW4oX2FjdGlvbnM6IEFjdGlvbnMsIF9vcHRpb25zOiBuZXZlcik6IFByb21pc2U8Q29tbWFuZFJlc3BvbnNlPiB7XG5cdFx0cmV0dXJuIHRoaXMuaGVscCgpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiRm9yZ2VDb21tYW5kIiwiRGVjb2hlcmVDb21tYW5kIiwiY29tbWFuZHMiLCJoYW5kbGVyIiwiZGVzY3JpcHRpb24iLCJleGl0T3ZlcnJpZGUiLCJyZWdpc3RlclN1YmNvbW1hbmQiLCJydW4iLCJfYWN0aW9ucyIsIl9vcHRpb25zIiwiaGVscCJdLCJtYXBwaW5ncyI6Ijs7OzsrQkFRYUE7OztlQUFBQTs7O3FCQUZOO0FBRUEsTUFBTUEscUJBQXFCQyxvQkFBZTtJQUNoRCxZQUFtQkMsUUFBcUMsRUFBRUMsT0FBdUIsQ0FBRTtRQUNsRixLQUFLLENBQUNIO1FBQ04sSUFBSSxDQUFDSSxXQUFXLENBQUM7UUFDakIsSUFBSSxDQUFDQyxZQUFZO1FBQ2pCLElBQUksQ0FBQ0Msa0JBQWtCLENBQUNKLFVBQVVDO0lBQ25DO0lBRU9JLElBQUlDLFFBQWlCLEVBQUVDLFFBQWUsRUFBNEI7UUFDeEUsT0FBTyxJQUFJLENBQUNDLElBQUk7SUFDakI7QUFDRCJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9jb21tYW5kcy9mb3JnZS5jb21tYW5kLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgQWN0aW9ucyB9IGZyb20gXCJAZGVjb2hlcmUvbmV4dXMvY2xpXCI7XG5pbXBvcnQge1xuXHR0eXBlIENvbW1hbmRIYW5kbGVyLFxuXHR0eXBlIENvbW1hbmRSZXNwb25zZSxcblx0dHlwZSBDb21tYW5kVHlwZSxcblx0RGVjb2hlcmVDb21tYW5kLFxufSBmcm9tIFwiQGRlY29oZXJlL25leHVzL2NsaVwiO1xuXG5leHBvcnQgY2xhc3MgRm9yZ2VDb21tYW5kIGV4dGVuZHMgRGVjb2hlcmVDb21tYW5kIHtcblx0cHVibGljIGNvbnN0cnVjdG9yKGNvbW1hbmRzOiBSZWNvcmQ8c3RyaW5nLCBDb21tYW5kVHlwZT4sIGhhbmRsZXI6IENvbW1hbmRIYW5kbGVyKSB7XG5cdFx0c3VwZXIoRm9yZ2VDb21tYW5kKTtcblx0XHR0aGlzLmRlc2NyaXB0aW9uKFwiUnVuIGZvcmdlIHdvcmtzcGFjZSB3b3JrZmxvd3NcIik7XG5cdFx0dGhpcy5leGl0T3ZlcnJpZGUoKTtcblx0XHR0aGlzLnJlZ2lzdGVyU3ViY29tbWFuZChjb21tYW5kcywgaGFuZGxlcik7XG5cdH1cblxuXHRwdWJsaWMgcnVuKF9hY3Rpb25zOiBBY3Rpb25zLCBfb3B0aW9uczogbmV2ZXIpOiBQcm9taXNlPENvbW1hbmRSZXNwb25zZT4ge1xuXHRcdHJldHVybiB0aGlzLmhlbHAoKTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIkZvcmdlQ29tbWFuZCIsIkRlY29oZXJlQ29tbWFuZCIsImNvbW1hbmRzIiwiaGFuZGxlciIsImRlc2NyaXB0aW9uIiwiZXhpdE92ZXJyaWRlIiwicmVnaXN0ZXJTdWJjb21tYW5kIiwicnVuIiwiX2FjdGlvbnMiLCJfb3B0aW9ucyIsImhlbHAiXSwibWFwcGluZ3MiOiI7Ozs7K0JBUWFBOzs7ZUFBQUE7OztxQkFGTjtBQUVBLE1BQU1BLHFCQUFxQkMsb0JBQWU7SUFDaEQsWUFBbUJDLFFBQXFDLEVBQUVDLE9BQXVCLENBQUU7UUFDbEYsS0FBSyxDQUFDSDtRQUNOLElBQUksQ0FBQ0ksV0FBVyxDQUFDO1FBQ2pCLElBQUksQ0FBQ0MsWUFBWTtRQUNqQixJQUFJLENBQUNDLGtCQUFrQixDQUFDSixVQUFVQztJQUNuQztJQUVPSSxJQUFJQyxRQUFpQixFQUFFQyxRQUFlLEVBQTRCO1FBQ3hFLE9BQU8sSUFBSSxDQUFDQyxJQUFJO0lBQ2pCO0FBQ0QifQ==