@decohere/core 0.0.1-dev.116

package/commonjs/src/extensibility/pipeline.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Pipeline", {
+    enumerable: true,
+    get: function() {
+        return Pipeline;
+    }
+});
+const _scribe = require("@decohere/scribe");
+class Pipeline {
+    stack;
+    logger = _scribe.scribe.logger(Pipeline.name);
+    currentStep;
+    constructor(...steps){
+        this.stack = steps;
+    }
+    [Symbol.dispose]() {
+        for (const [, step] of this.stack){
+            if (Symbol.dispose in step) {
+                step[Symbol.dispose]();
+            }
+        }
+    }
+    async start(context) {
+        const runStep = async (index)=>{
+            const [key, middleware, when] = this.stack[index] ?? [];
+            if (middleware == null) {
+                return;
+            }
+            if (when != null && !when(context)) {
+                this.logger.info(`Skipping step ${key}`);
+                return await runStep(index + 1);
+            }
+            this.currentStep = key;
+            this.logger.info(`Running step ${key}`);
+            await middleware.run(context, async ()=>{
+                await runStep(index + 1);
+            });
+        };
+        try {
+            await runStep(0);
+        } catch (error) {
+            const step = this.currentStep ?? "unknown";
+            if (error instanceof Error) {
+                throw new Error(`Pipeline step '${step}' failed: ${error.message}`, {
+                    cause: error
+                });
+            }
+            throw new Error(`Pipeline step '${step}' failed with non-Error value`, {
+                cause: error
+            });
+        }
+    }
+}

package/commonjs/src/extensibility/step.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Step", {
+    enumerable: true,
+    get: function() {
+        return Step;
+    }
+});
+class Step {
+    type;
+    when;
+    constructor(type, when){
+        this.type = type;
+        this.when = when;
+    }
+}

package/commonjs/src/interop/docker/docker.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Docker", {
+    enumerable: true,
+    get: function() {
+        return Docker;
+    }
+});
+const _interoperror = require("../errors/interop.error.js");
+const _shell = require("../shell/shell.js");
+class Docker extends _shell.Shell {
+    name = "docker";
+    program = "docker";
+    async build(contextDir, options = {}) {
+        if (contextDir == null || contextDir.trim() === "") {
+            throw new _interoperror.InteropError("Docker build context is required");
+        }
+        const args = [
+            "build"
+        ];
+        if (options.dockerfile) {
+            args.push("-f", options.dockerfile);
+        }
+        for (const tag of options.tags ?? []){
+            args.push("-t", tag);
+        }
+        for (const [key, value] of Object.entries(options.buildArgs ?? {})){
+            args.push("--build-arg", `${key}=${value}`);
+        }
+        for (const [id, env] of Object.entries(options.secrets ?? {})){
+            args.push("--secret", `id=${id},env=${env}`);
+        }
+        if (options.noCache) {
+            args.push("--no-cache");
+        }
+        if (options.pull) {
+            args.push("--pull");
+        }
+        args.push(contextDir);
+        return await this.run({
+            cwd: options.cwd
+        }, ...args);
+    }
+    async push(tag, options = {}) {
+        if (tag == null || tag.trim() === "") {
+            throw new _interoperror.InteropError("Docker tag is required");
+        }
+        return await this.run({
+            cwd: options.cwd
+        }, "push", tag);
+    }
+}

package/commonjs/src/interop/errors/interop.error.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "InteropError", {
+    enumerable: true,
+    get: function() {
+        return InteropError;
+    }
+});
+class InteropError extends Error {
+}

package/commonjs/src/interop/git/git.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Git", {
+    enumerable: true,
+    get: function() {
+        return Git;
+    }
+});
+const _interoperror = require("../errors/interop.error.js");
+const _shell = require("../shell/shell.js");
+const Commands = {
+    stage: "stage",
+    tag: "tag",
+    add: "add",
+    commit: "commit",
+    push: "push",
+    listFiles: "ls-files"
+};
+const defaultOptions = {
+    cwd: "./"
+};
+class Git extends _shell.Shell {
+    program = "git";
+    async getModifiedFiles(options = defaultOptions) {
+        const args = [
+            Commands.listFiles,
+            "--modified"
+        ];
+        const { cwd } = options;
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result.data;
+    }
+    async getBranchName(options = defaultOptions) {
+        const { cwd } = options;
+        const args = [
+            "rev-parse",
+            "--symbolic-full-name",
+            "--abbrev-ref",
+            "HEAD"
+        ];
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result.data[0];
+    }
+    async tag(tag, options = defaultOptions) {
+        const args = [
+            Commands.tag,
+            tag
+        ];
+        const { cwd } = options;
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result;
+    }
+    async pushTag(tag, options = defaultOptions) {
+        const { cwd, remote = "origin" } = options;
+        const result = await this.run({
+            cwd
+        }, Commands.push, remote, tag);
+        return result;
+    }
+    async commit(message, options) {
+        const optionsAndDefaults = {
+            ...defaultOptions,
+            ...options
+        };
+        const { cwd, files = [], all } = optionsAndDefaults;
+        const args = [
+            Commands.commit
+        ];
+        if (files.length > 0 && all) {
+            throw new _interoperror.InteropError("Cannot commit all and files at the same time");
+        }
+        if (files.length > 0) {
+            await this.stage({
+                files
+            });
+        }
+        if (options.all) {
+            args.push("-a");
+        }
+        args.push("-m", message);
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result;
+    }
+    async push(branch, options) {
+        const optionsAndDefaults = {
+            ...defaultOptions,
+            ...options
+        };
+        const { cwd, setUpstream } = optionsAndDefaults;
+        const args = [
+            Commands.push
+        ];
+        args.push("--set-upstream", setUpstream ?? "origin");
+        args.push(branch);
+        const result = await this.run({
+            cwd
+        }, ...args);
+        return result;
+    }
+    async pull(branch, options = defaultOptions) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, "pull", "--rebase", "origin", branch);
+    }
+    async stage(options) {
+        const optionsAndDefaults = {
+            ...defaultOptions,
+            ...options
+        };
+        const { cwd, files = [], all } = optionsAndDefaults;
+        if (all) {
+            await this.run({
+                cwd
+            }, Commands.stage, "-a");
+            return;
+        }
+        for (const file of files){
+            await this.run({
+                cwd
+            }, Commands.stage, file);
+        }
+    }
+}

package/commonjs/src/interop/git/git.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

package/commonjs/src/interop/index.js

@@ -0,0 +1,97 @@
+// << Git >>
+// << Docker >>
+"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 git () {
+        return _gittypes;
+    },
+    get npm () {
+        return _npmtypes;
+    },
+    get pnpm () {
+        return _pnpmtypes;
+    },
+    get shell () {
+        return _shelltypes;
+    },
+    get yarn () {
+        return _yarntypes;
+    }
+});
+_export_star(require("./docker/docker.js"), exports);
+_export_star(require("./git/git.js"), exports);
+const _gittypes = /*#__PURE__*/ _interop_require_wildcard(require("./git/git.types.js"));
+_export_star(require("./node/node.js"), exports);
+_export_star(require("./npm/npm.js"), exports);
+const _npmtypes = /*#__PURE__*/ _interop_require_wildcard(require("./npm/npm.types.js"));
+_export_star(require("./pnpm/pnpm.js"), exports);
+const _pnpmtypes = /*#__PURE__*/ _interop_require_wildcard(require("./pnpm/pnpm.types.js"));
+_export_star(require("./shell/shell.js"), exports);
+const _shelltypes = /*#__PURE__*/ _interop_require_wildcard(require("./shell/shell.types.js"));
+_export_star(require("./types/detect-package-manager.js"), exports);
+_export_star(require("./types/package-manager.js"), exports);
+_export_star(require("./yarn/yarn.js"), exports);
+const _yarntypes = /*#__PURE__*/ _interop_require_wildcard(require("./yarn/yarn.types.js"));
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}

package/commonjs/src/interop/node/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./node.js"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/commonjs/src/interop/node/node.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Node", {
+    enumerable: true,
+    get: function() {
+        return Node;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _shell = require("../shell/shell.js");
+class Node extends _shell.Shell {
+    program = "node";
+    async runScript(script, ...args) {
+        const spawnOpt = {
+            cwd: ".",
+            stdio: "inherit",
+            env: {
+                ...process.env
+            }
+        };
+        return new Promise((resolve, reject)=>{
+            const proc = (0, _nodechild_process.spawn)("node", [
+                script,
+                ...args
+            ], spawnOpt);
+            proc.on("exit", (code)=>{
+                if (code !== 0) {
+                    reject();
+                }
+                resolve(null);
+            });
+            proc.on("close", (code)=>{
+                resolve(null);
+                if (code === 0) {
+                    resolve({
+                        message: `${script} completed`
+                    });
+                }
+                reject(`Running '${script}' failed with code ${code}`);
+            });
+        });
+    }
+}

package/commonjs/src/interop/npm/npm.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Npm", {
+    enumerable: true,
+    get: function() {
+        return Npm;
+    }
+});
+const _interoperror = require("../errors/interop.error.js");
+const _shell = require("../shell/shell.js");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const Commands = {
+    publish: "publish",
+    version: "version",
+    link: "link",
+    install: "install"
+};
+class Npm extends _shell.Shell {
+    name = "npm";
+    program = "npm";
+    async publish(directory, options = {
+        channel: "beta"
+    }) {
+        const { cwd, dryRun, skipIfPublished, channel, authToken, otp, provenance } = options;
+        if (directory == null) {
+            throw new _interoperror.InteropError("Directory is required");
+        }
+        if (skipIfPublished && !dryRun) {
+            const alreadyPublished = await this.isPublished(directory, {
+                cwd
+            });
+            if (alreadyPublished) {
+                return {
+                    message: `Skipping publish — version already exists on registry`,
+                    data: []
+                };
+            }
+        }
+        const args = [
+            Commands.publish,
+            directory
+        ];
+        let tmpUserConfigPath;
+        args.push("--tag", channel ?? "beta");
+        if (provenance) {
+            args.push("--provenance");
+        }
+        // Explicit --token (local bootstrap). OIDC publish must not inherit cwd .npmrc / NODE_AUTH_TOKEN.
+        if (authToken?.trim()) {
+            tmpUserConfigPath = await this.createTempUserConfig(authToken.trim());
+            args.push("--userconfig", tmpUserConfigPath);
+        }
+        if (dryRun) {
+            args.push("--dry-run");
+        }
+        const env = {
+            ...process.env
+        };
+        if (!authToken?.trim()) {
+            delete env.NODE_AUTH_TOKEN;
+            delete env.NPM_TOKEN;
+            env.NPM_CONFIG_USERCONFIG = "/dev/null";
+        }
+        if (otp) {
+            env.NPM_CONFIG_OTP = otp;
+        }
+        try {
+            return await this.run({
+                cwd,
+                env
+            }, ...args);
+        } catch (error) {
+            if (skipIfPublished && !dryRun && isAlreadyPublishedError(error)) {
+                return {
+                    message: `Skipping publish — version already exists on registry`,
+                    data: []
+                };
+            }
+            throw error;
+        } finally{
+            if (tmpUserConfigPath) {
+                await this.removeTempUserConfig(tmpUserConfigPath);
+            }
+        }
+    }
+    /**
+	 * @description Runs in the directory of the package
+	 * @param options
+	 * @returns
+	 */ async version(versionType, options) {
+        const { cwd, noTag, preid } = options;
+        const args = [
+            Commands.version,
+            versionType
+        ];
+        if (noTag) {
+            args.push("--no-git-tag-version");
+        }
+        if (preid) {
+            args.push("--preid", preid);
+        }
+        return this.run({
+            cwd
+        }, ...args);
+    }
+    async link(directory, options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        const args = [
+            Commands.link,
+            directory
+        ];
+        return this.run({
+            cwd
+        }, ...args);
+    }
+    async install(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install);
+    }
+    /**
+	 * Install only `dependencies` as real folders: `--omit=dev` skips devDependencies and
+	 * `--no-bin-links` skips the `.bin` symlinks, so the result holds no symlinks at all.
+	 */ async installProduction(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install, "--omit=dev", "--no-bin-links", "--no-audit", "--no-fund", "--loglevel=error");
+    }
+    async syncLockFile(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install, "--package-lock-only", "--ignore-scripts");
+    }
+    /**
+	 * True when package@version exists on the registry.
+	 * Uses ambient npm config (cwd `.npmrc`); do not pass tokens on argv.
+	 */ async isPublished(directory, options) {
+        const { readFileSync } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:fs")));
+        const { join } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:path")));
+        try {
+            const pkgJson = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+            const spec = `${pkgJson.name}@${pkgJson.version}`;
+            await this.run(options, "view", spec, "version");
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    async createTempUserConfig(authToken) {
+        const { mkdtemp, writeFile } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises")));
+        const { tmpdir } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:os")));
+        const { join } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:path")));
+        const tempDir = await mkdtemp(join(tmpdir(), "decohere-npmrc-"));
+        const npmrcPath = join(tempDir, ".npmrc");
+        const npmrc = [
+            "registry=https://registry.npmjs.org/",
+            "always-auth=true",
+            `//registry.npmjs.org/:_authToken=${authToken}`
+        ].join("\n");
+        await writeFile(npmrcPath, `${npmrc}\n`, {
+            mode: 0o600
+        });
+        return npmrcPath;
+    }
+    async removeTempUserConfig(npmrcPath) {
+        const { rm } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:fs/promises")));
+        const { dirname } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("node:path")));
+        const dir = dirname(npmrcPath);
+        await rm(dir, {
+            recursive: true,
+            force: true
+        });
+    }
+}
+function isAlreadyPublishedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /cannot publish over the previously published versions/i.test(message);
+}

package/commonjs/src/interop/npm/npm.types.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VersionTypes", {
+    enumerable: true,
+    get: function() {
+        return VersionTypes;
+    }
+});
+const VersionTypes = {
+    major: "major",
+    minor: "minor",
+    patch: "patch",
+    prerelease: "prerelease"
+};