@decohere/forge 0.0.1-dev.10

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":["/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":["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,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

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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

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

@@ -0,0 +1,189 @@
+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 { execSync } from "node:child_process";
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+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 { Semver, SemverError, VersionTypes } from "@decohere/nexus/semver";
+import { scribe } from "@decohere/scribe";
+import { ForgeError, formatUnknownError } from "../errors.js";
+export const DefaultChannel = "beta";
+export const DefaultReleaseType = VersionTypes.prerelease;
+const DefaultVersionOptions = {
+    releaseType: DefaultReleaseType,
+    channel: DefaultChannel,
+    dryRun: false
+};
+export class Version {
+    workspace;
+    #logger = scribe.logger(Version.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    async run(options) {
+        const response = await this.version(this.workspace, options);
+        const messages = response.data.flatMap((d)=>!d.succeeded && d.error ? [
+                d.error
+            ] : []).join("\n");
+        if (messages) {
+            throw new ForgeError(`There was an error versioning the workspace ${messages}`);
+        }
+        return response;
+    }
+    async version(workspace, options = DefaultVersionOptions) {
+        const projects = workspace.getProjects("debug");
+        const rootVersion = await this.resolveBaseVersion(workspace, options);
+        const releaseType = options.fromChangesets ? await this.resolveReleaseTypeFromChangesets() : options.releaseType ?? DefaultReleaseType;
+        const channel = options.channel ?? DefaultChannel;
+        const nextVersion = this.getNextVersion(rootVersion, releaseType, channel);
+        this.#logger.info(`${rootVersion} → ${nextVersion} [${releaseType}]`);
+        if (options.dryRun) {
+            this.#logger.info(`[dry-run] Would bump all packages to ${nextVersion} — skipping file writes`);
+            return ActionResponse.Success(Version.name, [
+                {
+                    name: workspace.name,
+                    succeeded: true
+                },
+                ...projects.map((p)=>({
+                        name: p.name,
+                        succeeded: true
+                    }))
+            ]);
+        }
+        await workspace.persistPackageJson((await workspace.getPackageJson()).withVersion(nextVersion.toString()));
+        const responses = await Promise.all([
+            ...[
+                this.updatePackageJson(workspace.name, workspace, nextVersion)
+            ],
+            ...projects.map((project)=>this.updatePackageJson(project.name, project, nextVersion))
+        ]);
+        const failed = responses.filter((r)=>!r.succeeded);
+        if (failed.length) {
+            return ActionResponse.Error(Version.name, responses);
+        }
+        if (options.commit) {
+            const files = [
+                workspace.packageJsonPath,
+                ...projects.map((p)=>p.packageJsonPath)
+            ];
+            const message = options.message ?? `chore: version packages ${nextVersion}`;
+            this.#logger.info(`Committing: ${message}`);
+            await new Git().commit(message, {
+                files
+            });
+        }
+        return ActionResponse.Success(Version.name, responses);
+    }
+    async resolveBaseVersion(workspace, options) {
+        if (options.version != null && options.version.trim().length > 0) {
+            return options.version.trim();
+        }
+        const gitTagVersion = this.resolveVersionFromGitTag();
+        if (gitTagVersion != null) {
+            this.#logger.info(`Using latest git tag version as base: ${gitTagVersion}`);
+            return gitTagVersion;
+        }
+        const workspaceVersion = await workspace.getVersion();
+        this.#logger.info(`No semver git tags found, falling back to workspace package.json version: ${workspaceVersion}`);
+        return workspaceVersion;
+    }
+    resolveVersionFromGitTag() {
+        try {
+            const tags = execSync('git tag --list "v*" --sort=-version:refname', {
+                encoding: "utf8"
+            }).trim().split("\n").filter(Boolean);
+            if (tags.length === 0) {
+                return undefined;
+            }
+            return tags[0].replace(/^v/, "");
+        } catch  {
+            return undefined;
+        }
+    }
+    /**
+	 * Reads all pending .changeset/*.md entries and returns the highest bump type
+	 * found across all of them. Precedence: major > minor > patch.
+	 */ async resolveReleaseTypeFromChangesets() {
+        const changesetDir = join(process.cwd(), ".changeset");
+        let entries;
+        try {
+            entries = await readdir(changesetDir);
+        } catch  {
+            throw new ForgeError("No .changeset directory found. Run `pnpm changeset` to create an entry.");
+        }
+        const files = entries.filter((e)=>e.endsWith(".md") && e !== "README.md");
+        if (files.length === 0) {
+            throw new ForgeError("No pending changeset entries found in .changeset/. Run `pnpm changeset` to create one.");
+        }
+        const precedence = {
+            major: 3,
+            minor: 2,
+            patch: 1,
+            prerelease: 0
+        };
+        let maxType = VersionTypes.patch;
+        let maxPrecedence = 0;
+        for (const file of files){
+            const content = await readFile(join(changesetDir, file), "utf8");
+            const match = content.match(/^---\n([\s\S]*?)\n---/);
+            if (!match) continue;
+            for (const line of match[1].split("\n")){
+                const bumpType = line.match(/^"[^"]+"\s*:\s*(\w+)/)?.[1];
+                const p = bumpType != null ? precedence[bumpType] ?? -1 : -1;
+                if (p > maxPrecedence) {
+                    maxType = bumpType;
+                    maxPrecedence = p;
+                }
+            }
+        }
+        this.#logger.info(`Resolved release type from ${files.length} changeset(s): ${maxType}`);
+        return maxType;
+    }
+    getNextVersion(currentVersion, versionType, preid) {
+        try {
+            return new Semver(currentVersion).increment(versionType, preid);
+        } catch (error) {
+            if (error instanceof SemverError) {
+                throw new ForgeError(error.message);
+            }
+            throw error;
+        }
+    }
+    async updatePackageJson(name, hasJson, version) {
+        try {
+            const packageJson = await hasJson.getPackageJson();
+            await hasJson.persistPackageJson(packageJson.withVersion(version.toString()));
+            this.#logger.trace(name);
+            return {
+                name,
+                succeeded: true
+            };
+        } catch (reason) {
+            return {
+                name,
+                succeeded: false,
+                error: `${name}: ${formatUnknownError(reason)}`
+            };
+        }
+    }
+}
+Version = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Version);
+
+//# 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":["execSync","readdir","readFile","join","injectable","Workspace","ActionResponse","Git","Semver","SemverError","VersionTypes","scribe","ForgeError","formatUnknownError","DefaultChannel","DefaultReleaseType","prerelease","DefaultVersionOptions","releaseType","channel","dryRun","Version","logger","name","workspace","run","options","response","version","messages","data","flatMap","d","succeeded","error","projects","getProjects","rootVersion","resolveBaseVersion","fromChangesets","resolveReleaseTypeFromChangesets","nextVersion","getNextVersion","info","Success","map","p","persistPackageJson","getPackageJson","withVersion","toString","responses","Promise","all","updatePackageJson","project","failed","filter","r","length","Error","commit","files","packageJsonPath","message","trim","gitTagVersion","resolveVersionFromGitTag","workspaceVersion","getVersion","tags","encoding","split","Boolean","undefined","replace","changesetDir","process","cwd","entries","e","endsWith","precedence","major","minor","patch","maxType","maxPrecedence","file","content","match","line","bumpType","currentVersion","versionType","preid","increment","hasJson","packageJson","trace","reason"],"mappings":"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"}

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

@@ -0,0 +1,41 @@
+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";
+export class Watch {
+    workspace;
+    #logger = scribe.logger(Watch.name);
+    constructor(workspace){
+        this.workspace = workspace;
+    }
+    run = async (options)=>{
+        if (!options.watch) {
+            this.#logger.info(`Skipping ${Watch.name}`);
+            return ActionResponse.Skipped(Watch.name);
+        }
+        await this.workspace.watch(options.configuration);
+        return ActionResponse.Blocking(Watch.name);
+    };
+    [Symbol.dispose]() {
+        this.workspace.stopWatching();
+    }
+}
+Watch = _ts_decorate([
+    injectable(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof Workspace === "undefined" ? Object : Workspace
+    ])
+], Watch);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9hY3Rpb25zL3dhdGNoLmFjdGlvbi50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBpbmplY3RhYmxlIH0gZnJvbSBcIkBkZWNvaGVyZS9jcnVjaWJsZS9kZWNvcmF0b3JzXCI7XG4vLyBiaW9tZS1pZ25vcmUgbGludC9zdHlsZS91c2VJbXBvcnRUeXBlOiA8REk+XG5pbXBvcnQgeyBXb3Jrc3BhY2UgfSBmcm9tIFwiQGRlY29oZXJlL21lc2hcIjtcbmltcG9ydCB0eXBlIHsgQWN0aW9uIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IEFjdGlvblJlc3BvbnNlIH0gZnJvbSBcIkBkZWNvaGVyZS9uZXh1cy9jbGlcIjtcbmltcG9ydCB7IHNjcmliZSB9IGZyb20gXCJAZGVjb2hlcmUvc2NyaWJlXCI7XG5cbmV4cG9ydCB0eXBlIFdhdGNoT3B0aW9ucyA9IHtcblx0d2F0Y2g6IGJvb2xlYW47XG5cdGNvbmZpZ3VyYXRpb246IHN0cmluZztcbn07XG5cbkBpbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBXYXRjaCBpbXBsZW1lbnRzIEFjdGlvbjxXYXRjaE9wdGlvbnM+IHtcblx0I2xvZ2dlciA9IHNjcmliZS5sb2dnZXIoV2F0Y2gubmFtZSk7XG5cdHB1YmxpYyBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHdvcmtzcGFjZTogV29ya3NwYWNlKSB7fVxuXG5cdHB1YmxpYyBydW4gPSBhc3luYyAob3B0aW9uczogV2F0Y2hPcHRpb25zKTogUHJvbWlzZTxBY3Rpb25SZXNwb25zZT4gPT4ge1xuXHRcdGlmICghb3B0aW9ucy53YXRjaCkge1xuXHRcdFx0dGhpcy4jbG9nZ2VyLmluZm8oYFNraXBwaW5nICR7V2F0Y2gubmFtZX1gKTtcblx0XHRcdHJldHVybiBBY3Rpb25SZXNwb25zZS5Ta2lwcGVkKFdhdGNoLm5hbWUpO1xuXHRcdH1cblxuXHRcdGF3YWl0IHRoaXMud29ya3NwYWNlLndhdGNoKG9wdGlvbnMuY29uZmlndXJhdGlvbik7XG5cdFx0cmV0dXJuIEFjdGlvblJlc3BvbnNlLkJsb2NraW5nKFdhdGNoLm5hbWUpO1xuXHR9O1xuXG5cdHB1YmxpYyBbU3ltYm9sLmRpc3Bvc2VdKCkge1xuXHRcdHRoaXMud29ya3NwYWNlLnN0b3BXYXRjaGluZygpO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiaW5qZWN0YWJsZSIsIldvcmtzcGFjZSIsIkFjdGlvblJlc3BvbnNlIiwic2NyaWJlIiwiV2F0Y2giLCJsb2dnZXIiLCJuYW1lIiwid29ya3NwYWNlIiwicnVuIiwib3B0aW9ucyIsIndhdGNoIiwiaW5mbyIsIlNraXBwZWQiLCJjb25maWd1cmF0aW9uIiwiQmxvY2tpbmciLCJTeW1ib2wiLCJkaXNwb3NlIiwic3RvcFdhdGNoaW5nIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7QUFBQSxTQUFTQSxVQUFVLFFBQVEsZ0NBQWdDO0FBQzNELDhDQUE4QztBQUM5QyxTQUFTQyxTQUFTLFFBQVEsaUJBQWlCO0FBRTNDLFNBQVNDLGNBQWMsUUFBUSxzQkFBc0I7QUFDckQsU0FBU0MsTUFBTSxRQUFRLG1CQUFtQjtBQVExQyxPQUFPLE1BQU1DOztJQUNaLENBQUEsTUFBTyxHQUFHRCxPQUFPRSxNQUFNLENBQUNELE1BQU1FLElBQUksRUFBRTtJQUNwQyxZQUFtQixBQUFpQkMsU0FBb0IsQ0FBRTthQUF0QkEsWUFBQUE7SUFBdUI7SUFFcERDLE1BQU0sT0FBT0M7UUFDbkIsSUFBSSxDQUFDQSxRQUFRQyxLQUFLLEVBQUU7WUFDbkIsSUFBSSxDQUFDLENBQUEsTUFBTyxDQUFDQyxJQUFJLENBQUMsQ0FBQyxTQUFTLEVBQUVQLE1BQU1FLElBQUksRUFBRTtZQUMxQyxPQUFPSixlQUFlVSxPQUFPLENBQUNSLE1BQU1FLElBQUk7UUFDekM7UUFFQSxNQUFNLElBQUksQ0FBQ0MsU0FBUyxDQUFDRyxLQUFLLENBQUNELFFBQVFJLGFBQWE7UUFDaEQsT0FBT1gsZUFBZVksUUFBUSxDQUFDVixNQUFNRSxJQUFJO0lBQzFDLEVBQUU7SUFFSyxDQUFDUyxPQUFPQyxPQUFPLENBQUMsR0FBRztRQUN6QixJQUFJLENBQUNULFNBQVMsQ0FBQ1UsWUFBWTtJQUM1QjtBQUNEIn0=

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

@@ -0,0 +1,34 @@
+import { CommandResponse, ConfigurationOption, DecohereCommand, NoCleanOptions } from "@decohere/nexus/cli";
+import auto from "async/auto.js";
+export class BuildCommand extends DecohereCommand {
+    constructor(name){
+        super(name ?? BuildCommand.name);
+        this.description("Build workspace projects");
+        this.addOption(new ConfigurationOption("debug"));
+        this.addOption(new NoCleanOptions(true));
+        this.option("--no-copy", "Will not copy files like package.json to outdir", true);
+        this.option("--watch", "Watches for changes in the source dir", false);
+        this.option("--file <file>", "File to build");
+    }
+    run = async (actions, options)=>{
+        const responses = await auto({
+            clean: async ()=>await actions.clean.run(options),
+            build: [
+                "clean",
+                async ()=>await actions.build.run(options)
+            ],
+            copy: [
+                "clean",
+                async ()=>await actions.copy.run(options)
+            ],
+            watch: [
+                "build",
+                "copy",
+                async ()=>await actions.watch.run(options)
+            ]
+        });
+        return CommandResponse.success(options, responses);
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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