@decohere/core 0.0.1-dev.116

package/es6/src/extensibility/mixwith.js

@@ -0,0 +1,26 @@
+const BLOCKED_PROTOTYPE_KEYS = new Set([
+    "constructor",
+    "prototype",
+    "name",
+    "length"
+]);
+function copyPrototypeProperties(target, source) {
+    for (const key of Reflect.ownKeys(source)){
+        if (typeof key === "string" && BLOCKED_PROTOTYPE_KEYS.has(key)) {
+            continue;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(source, key);
+        if (descriptor == null) {
+            continue;
+        }
+        Object.defineProperty(target, key, descriptor);
+    }
+}
+export function mixwith(...mixins) {
+    class Mixed {
+    }
+    for (const mixin of mixins){
+        copyPrototypeProperties(Mixed.prototype, mixin.prototype);
+    }
+    return Mixed;
+}

package/es6/src/extensibility/pipeline.js

@@ -0,0 +1,46 @@
+import { scribe } from "@decohere/scribe";
+export class Pipeline {
+    stack;
+    logger = 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/es6/src/extensibility/step.js

@@ -0,0 +1,16 @@
+/**
+ * Wraps a pipeline step with an optional `when` predicate.
+ * When `when` is provided, the step only runs if `when(ctx)` returns `true`.
+ * If `when` returns `false`, the pipeline logs `"Skipping step <name>"` and
+ * advances to the next step without invoking `run()`.
+ *
+ * Predicates are declared in the command constructor via `addDisableStepOption`,
+ * keeping skip conditions co-located with the option that controls them.
+ */ export class Step {
+    type;
+    when;
+    constructor(type, when){
+        this.type = type;
+        this.when = when;
+    }
+}

package/es6/src/interop/docker/docker.js

@@ -0,0 +1,44 @@
+import { InteropError } from "../errors/interop.error.js";
+import { Shell } from "../shell/shell.js";
+export class Docker extends Shell {
+    name = "docker";
+    program = "docker";
+    async build(contextDir, options = {}) {
+        if (contextDir == null || contextDir.trim() === "") {
+            throw new 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("Docker tag is required");
+        }
+        return await this.run({
+            cwd: options.cwd
+        }, "push", tag);
+    }
+}

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

@@ -0,0 +1,2 @@
+export class InteropError extends Error {
+}

package/es6/src/interop/git/git.js

@@ -0,0 +1,124 @@
+import { InteropError } from "../errors/interop.error.js";
+import { Shell } from "../shell/shell.js";
+const Commands = {
+    stage: "stage",
+    tag: "tag",
+    add: "add",
+    commit: "commit",
+    push: "push",
+    listFiles: "ls-files"
+};
+const defaultOptions = {
+    cwd: "./"
+};
+export class Git extends 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("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/es6/src/interop/git/git.types.js

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

package/es6/src/interop/index.js

@@ -0,0 +1,21 @@
+// << Git >>
+// << Docker >>
+export * from "./docker/docker.js";
+export * from "./git/git.js";
+export * as git from "./git/git.types.js";
+// << Node >>
+export * from "./node/node.js";
+// << Npm >>
+export * from "./npm/npm.js";
+export * as npm from "./npm/npm.types.js";
+// << Pnpm >>
+export * from "./pnpm/pnpm.js";
+export * as pnpm from "./pnpm/pnpm.types.js";
+// << Shell >>
+export * from "./shell/shell.js";
+export * as shell from "./shell/shell.types.js";
+export * from "./types/detect-package-manager.js";
+export * from "./types/package-manager.js";
+// << Yarn >>
+export * from "./yarn/yarn.js";
+export * as yarn from "./yarn/yarn.types.js";

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

@@ -0,0 +1 @@
+export * from "./node.js";

package/es6/src/interop/node/node.js

@@ -0,0 +1,35 @@
+import { spawn } from "node:child_process";
+import { Shell } from "../shell/shell.js";
+export class Node extends Shell {
+    program = "node";
+    async runScript(script, ...args) {
+        const spawnOpt = {
+            cwd: ".",
+            stdio: "inherit",
+            env: {
+                ...process.env
+            }
+        };
+        return new Promise((resolve, reject)=>{
+            const proc = 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/es6/src/interop/npm/npm.js

@@ -0,0 +1,180 @@
+import { InteropError } from "../errors/interop.error.js";
+import { Shell } from "../shell/shell.js";
+const Commands = {
+    publish: "publish",
+    version: "version",
+    link: "link",
+    install: "install"
+};
+export class Npm extends 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("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 import("node:fs");
+        const { join } = await import("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 import("node:fs/promises");
+        const { tmpdir } = await import("node:os");
+        const { join } = await import("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 import("node:fs/promises");
+        const { dirname } = await import("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/es6/src/interop/npm/npm.types.js

@@ -0,0 +1,6 @@
+export const VersionTypes = {
+    major: "major",
+    minor: "minor",
+    patch: "patch",
+    prerelease: "prerelease"
+};

package/es6/src/interop/pnpm/pnpm.js

@@ -0,0 +1,24 @@
+import { Shell } from "../shell/shell.js";
+const Commands = {
+    install: "install"
+};
+export class Pnpm extends Shell {
+    name = "pnpm";
+    program = "pnpm";
+    async install(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install);
+    }
+    async syncLockFile(options = {
+        cwd: "./"
+    }) {
+        const { cwd } = options;
+        return this.run({
+            cwd
+        }, Commands.install, "--lockfile-only", "--ignore-scripts");
+    }
+}

package/es6/src/interop/pnpm/pnpm.types.js

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

package/es6/src/interop/shell/shell.argv.js

@@ -0,0 +1,35 @@
+function fields(args) {
+    const positional = [];
+    const flags = {};
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (arg === "--") {
+            positional.push(...args.slice(i + 1));
+            break;
+        }
+        if (arg.startsWith("--")) {
+            const body = arg.slice(2);
+            const eq = body.indexOf("=");
+            if (eq !== -1) {
+                flags[body.slice(0, eq)] = body.slice(eq + 1);
+                continue;
+            }
+            const next = args[i + 1];
+            if (next != null && !next.startsWith("-")) {
+                flags[body] = next;
+                i += 1;
+            } else {
+                flags[body] = true;
+            }
+            continue;
+        }
+        positional.push(arg);
+    }
+    return {
+        _: positional,
+        ...flags
+    };
+}
+export const shellArgv = {
+    fields
+};

package/es6/src/interop/shell/shell.js

@@ -0,0 +1,95 @@
+import { spawn } from "node:child_process";
+import { scribe } from "@decohere/scribe";
+import { InteropError } from "../errors/interop.error.js";
+import { shellArgv } from "./shell.argv.js";
+export class Shell {
+    async run(options, ...args) {
+        const logger = scribe.logger(Shell.name);
+        const argv = args ?? [];
+        const argvFields = shellArgv.fields(argv);
+        const positionals = Array.isArray(argvFields._) ? argvFields._ : [];
+        const commandName = [
+            this.program,
+            ...positionals
+        ].join(" ").trim();
+        logger.info("Running", {
+            program: this.program,
+            args: argvFields
+        });
+        return new Promise((resolve, reject)=>{
+            let settled = false;
+            const resolveOnce = (response)=>{
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                resolve(response);
+            };
+            const rejectOnce = (error)=>{
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                reject(error);
+            };
+            const { cwd, env } = options;
+            const spawnOpt = {
+                cwd: cwd ?? ".",
+                stdio: [
+                    "inherit",
+                    "pipe",
+                    "pipe"
+                ],
+                env: env ?? {
+                    ...process.env
+                }
+            };
+            const proc = spawn(this.program, argv, spawnOpt);
+            const responseData = [];
+            const errorData = [];
+            proc.on("close", (code, signal)=>{
+                if (code === 0) {
+                    resolveOnce({
+                        message: `${commandName} completed`,
+                        data: responseData
+                    });
+                    return;
+                }
+                const stderr = errorData.join("\n").trim();
+                const stdout = responseData.join("\n").trim();
+                const exitCodeText = code == null ? "unknown" : String(code);
+                const signalText = signal ? ` signal ${signal}` : "";
+                const base = `Running '${commandName}' failed with code ${exitCodeText}${signalText}`;
+                const details = [
+                    stderr ? `stderr:\n${stderr}` : "",
+                    !stderr && stdout ? `stdout:\n${stdout}` : ""
+                ].filter(Boolean).join("\n");
+                rejectOnce(new InteropError(details ? `${base}\n${details}` : base));
+            });
+            proc.on("error", (err)=>{
+                rejectOnce(err);
+            });
+            proc.stdout.on("error", (err)=>{
+                rejectOnce(err);
+            });
+            proc.stdout.on("data", (data)=>{
+                const lines = this.parseStream(data);
+                console.log(data.toString());
+                responseData.push(...lines);
+            });
+            proc.stderr?.on("error", (err)=>{
+                rejectOnce(err);
+            });
+            proc.stderr?.on("data", (data)=>{
+                const lines = this.parseStream(data);
+                console.error(data.toString());
+                errorData.push(...lines);
+            });
+        });
+    }
+    parseStream(data) {
+        const dataStr = data.toString();
+        const lines = dataStr.split("\n").filter((l)=>l !== "");
+        return lines;
+    }
+}

package/es6/src/interop/shell/shell.types.js

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