@quark-hq/quark-scripts 0.0.1

package/dist/infrastructure/adapters/base-release-adapter.js

@@ -0,0 +1,281 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseReleaseAdapter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const transitive_dependents_1 = require("../../domain/transitive-dependents");
+const new_package_freeze_from_map_1 = require("../../domain/new-package-freeze-from-map");
+const topological_sorting_1 = require("../../domain/topological-sorting");
+const prompts_1 = __importDefault(require("prompts"));
+const semver = __importStar(require("semver"));
+/**
+ * Unified base for all platform adapters.
+ *
+ * Implements both PlatformReleaseAdapter (version-bump prompting, freeze
+ * cascading, map.json writes) and PlatformDevPublishAdapter (alpha publish
+ * to dev registry).
+ *
+ * Subclasses only implement platform detection, file writes, version reading,
+ * and the dev-publish build+publish cycle.
+ */
+class BaseReleaseAdapter {
+    constructor(graphProvider, quarkConfig, logger) {
+        this.graphProvider = graphProvider;
+        this.quarkConfig = quarkConfig;
+        this.logger = logger;
+        this.userPrompts = {};
+        this.topoSorter = new topological_sorting_1.TopoSorter();
+    }
+    async execute(packages, graph, sorted, existingMap) {
+        const sortedPackages = sorted.filter((pkg) => packages.includes(pkg));
+        for (const pkg of sortedPackages) {
+            if (!this.userPrompts[pkg]) {
+                this.userPrompts[pkg] = await this.promptForPackage(pkg, graph, existingMap, sorted);
+            }
+        }
+        return this.userPrompts;
+    }
+    async writeUserPromptsToFiles(pkg, prompt, mapJsonObject, graph) {
+        mapJsonObject[pkg] = {
+            bumpType: prompt.bump,
+            baseVersion: prompt.baseVersion,
+            newVersion: prompt.newVersion,
+            changeLog: prompt.changelog,
+            frozen: prompt.frozen,
+        };
+        await this.writePackageFiles(pkg, prompt, mapJsonObject, graph);
+    }
+    // ── Prompting ──────────────────────────────────────────────────────
+    async promptForPackage(pkg, graph, existingMap, sorted) {
+        this.logger.info("\n" + chalk_1.default.gray("──────────────────────────────────────────"));
+        this.logger.info(this.getPlatformLabel(pkg));
+        this.logger.info(chalk_1.default.gray("──────────────────────────────────────────\n"));
+        const isNewPackage = !existingMap[pkg];
+        const isFrozenPackage = existingMap[pkg]?.frozen;
+        const isMajorBumpDisabled = isNewPackage || isFrozenPackage;
+        const currentVersion = existingMap[pkg]?.newVersion || "1.0.0";
+        const response = await (0, prompts_1.default)([
+            {
+                type: "select",
+                name: "bump",
+                message: chalk_1.default.yellow("Select version bump type"),
+                choices: this.buildBumpChoices(currentVersion, isNewPackage, isFrozenPackage, isMajorBumpDisabled),
+            },
+            {
+                type: "text",
+                name: "changelog",
+                message: chalk_1.default.yellow("Enter changelog description"),
+                validate: (value) => value.trim().length === 0
+                    ? "Changelog cannot be empty"
+                    : true,
+            },
+        ], {
+            onCancel: () => {
+                throw new Error("Release cancelled by user");
+            },
+        });
+        const result = {
+            bump: response.bump,
+            frozen: existingMap[pkg]?.frozen || false,
+            baseVersion: currentVersion,
+            newVersion: response.bump === "new"
+                ? "1.0.0"
+                : semver.inc(currentVersion, response.bump) ?? "1.0.0",
+            changelog: response.changelog,
+        };
+        if (isNewPackage) {
+            const freezePolicy = (0, new_package_freeze_from_map_1.resolveNewPackageFreezeFromReleaseMap)(pkg, graph.adjacency, existingMap);
+            if (freezePolicy.shouldFreeze) {
+                result.frozen = true;
+                const deps = freezePolicy.frozenWorkspaceDependencies.join(", ");
+                this.logger.warn(chalk_1.default.yellow(`Package "${pkg}" is new but transitively depends on frozen workspace package(s) in .release/map.json (${deps}). ` +
+                    `It will be marked frozen: workspace dependencies will be pinned to the versions in the map, and pinnedDependencies will be recorded.`));
+            }
+        }
+        if (result.bump === "major") {
+            await this.handleMajorVersionBumpConfig(pkg, graph, existingMap);
+        }
+        return result;
+    }
+    buildBumpChoices(currentVersion, isNewPackage, isFrozenPackage, isMajorBumpDisabled) {
+        return [
+            {
+                title: "🆕  New Package",
+                description: !isNewPackage
+                    ? "Disabled as package already published"
+                    : "New Package Found",
+                value: "new",
+                disabled: !isNewPackage,
+            },
+            {
+                title: `🐛  Patch (bug fixes) ${isNewPackage ? "Disabled as package is new" : `→ ${semver.inc(currentVersion, "patch")}`}`,
+                description: `→ ${semver.inc(currentVersion, "patch")}`,
+                value: "patch",
+                disabled: isNewPackage,
+            },
+            {
+                title: `✨  Minor (new features) ${isNewPackage ? "Disabled as package is new" : `→ ${semver.inc(currentVersion, "minor")}`}`,
+                description: `→ ${semver.inc(currentVersion, "minor")}`,
+                value: "minor",
+                disabled: isNewPackage,
+            },
+            {
+                title: `💥  Major (breaking changes) ${isNewPackage ? "Disabled as package is new" : isFrozenPackage ? "Disabled as package is frozen" : `→ ${semver.inc(currentVersion, "major")}`}`,
+                description: `→ ${semver.inc(currentVersion, "major")}`,
+                value: "major",
+                disabled: isMajorBumpDisabled,
+            },
+        ];
+    }
+    // ── Major-bump cascading ───────────────────────────────────────────
+    async handleMajorVersionBumpConfig(pkg, graph, existingMap) {
+        const invertedAdjacencyList = await this.graphProvider.getInvertedAdjacencyList(graph.adjacency);
+        const transitiveDependents = (0, transitive_dependents_1.collectTransitiveDependents)(pkg, invertedAdjacencyList);
+        const dependents = transitiveDependents.length === 0
+            ? []
+            : this.topoSorter.sort(graph.adjacency, transitiveDependents);
+        if (dependents.length === 0)
+            return;
+        let choice = "none";
+        if (this.quarkConfig?.release?.freeze) {
+            const response = await (0, prompts_1.default)({
+                type: "select",
+                name: "dependencies",
+                message: "Select the dependencies to freeze",
+                choices: [
+                    {
+                        title: "All",
+                        description: "Freeze all dependents at their current published version",
+                        value: "all",
+                    },
+                    {
+                        title: "None",
+                        description: "Auto-cascade major bump to all dependents",
+                        value: "none",
+                    },
+                    {
+                        title: "Selective",
+                        description: "Select which dependents to freeze and which to cascade",
+                        value: "selective",
+                    },
+                ],
+            });
+            choice = response.dependencies;
+        }
+        if (choice === "all") {
+            this.freezeDependents(pkg, existingMap, dependents);
+        }
+        else if (choice === "none") {
+            this.cascadeMajorBump(pkg, existingMap, dependents);
+        }
+        else if (choice === "selective") {
+            await this.handleSelectiveMajorVersionBump(pkg, existingMap, dependents, invertedAdjacencyList);
+        }
+    }
+    cascadeMajorBump(pkg, existingMap, dependents) {
+        for (const dependent of dependents) {
+            const currentVersion = existingMap[dependent]?.newVersion || "1.0.0";
+            this.userPrompts[dependent] = {
+                bump: "major",
+                frozen: false,
+                baseVersion: currentVersion,
+                newVersion: semver.inc(currentVersion, "major") || "1.0.0",
+                changelog: `Dependency version bumped to major version due to major version bump of ${pkg}`,
+            };
+        }
+    }
+    freezeDependents(pkg, existingMap, dependents) {
+        this.logger.info(`Handling frozen dependents for ${pkg}`);
+        for (const dependent of dependents) {
+            this.userPrompts[dependent] = {
+                bump: existingMap[dependent]?.bumpType ?? "patch",
+                frozen: true,
+                baseVersion: existingMap[dependent]?.baseVersion || "1.0.0",
+                newVersion: existingMap[dependent]?.newVersion || "1.0.0",
+                changelog: `Dependency version frozen due to major version bump of ${pkg}`,
+            };
+        }
+    }
+    // ── Selective freeze ───────────────────────────────────────────────
+    async handleSelectiveMajorVersionBump(pkg, existingMap, dependents, invertedAdjacencyList) {
+        const MAX_ATTEMPTS = 5;
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            const selected = await this.promptSelectiveDependents(dependents);
+            if (!selected || !Array.isArray(selected)) {
+                this.logger.warn("No selection made. Operation cancelled.");
+                return;
+            }
+            if (this.isValidTopologicalSelection(dependents, selected, invertedAdjacencyList)) {
+                const unSelected = dependents.filter((dep) => !selected.includes(dep));
+                this.cascadeMajorBump(pkg, existingMap, unSelected);
+                this.freezeDependents(pkg, existingMap, selected);
+                return;
+            }
+            this.logger.error("Invalid selection: freezing a package requires freezing every downstream dependent shown in this list. Please try again.");
+        }
+        throw new Error("Maximum selection attempts exceeded. Release aborted.");
+    }
+    async promptSelectiveDependents(dependents) {
+        const response = await (0, prompts_1.default)({
+            type: "multiselect",
+            name: "dependencies",
+            message: "Select the dependencies to freeze",
+            choices: dependents.map((dep) => ({
+                title: dep,
+                value: dep,
+            })),
+        });
+        return response.dependencies;
+    }
+    isValidTopologicalSelection(ordered, selected, invertedAdjacencyList) {
+        if (selected.length === 0)
+            return true;
+        const selectedSet = new Set(selected);
+        for (const node of selected) {
+            const dependents = invertedAdjacencyList[node] ?? [];
+            for (const dependent of dependents) {
+                if (ordered.includes(dependent) &&
+                    !selectedSet.has(dependent)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+exports.BaseReleaseAdapter = BaseReleaseAdapter;

package/dist/infrastructure/adapters/maven-prod-publish-adapter.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MavenProdPublishAdapter = void 0;
+/**
+ * Boilerplate adapter for Maven prod publishing.
+ *
+ * Extend this class with real implementation when Maven prod-publish
+ * support is needed. The key extension points are:
+ *
+ *   - readPackageIdentity()  – parse pom.xml for artifactId + version
+ *   - versionExistsInRegistry() – check the Maven repo for duplicates
+ *   - publish() – run `mvn deploy` against the prod repository
+ *
+ * Configure via `publish.maven` in quark-config.json:
+ *   {
+ *     "publish": {
+ *       "maven": {
+ *         "repositoryUrl": "https://your-nexus/repository/releases/",
+ *         "prodRepositoryUrl": "https://your-nexus/repository/releases/",
+ *         "repositoryId": "releases"
+ *       }
+ *     }
+ *   }
+ *
+ * If only `repositoryUrl` is set, it is used for both dev and prod.
+ */
+class MavenProdPublishAdapter {
+    constructor(quarkConfig, logger) {
+        this.quarkConfig = quarkConfig;
+        this.logger = logger;
+    }
+    supports(meta) {
+        return meta.platform === "maven";
+    }
+    async readPackageIdentity(_packageDir) {
+        throw new Error("Maven prod-publish is not implemented yet. " +
+            "Override readPackageIdentity() in a concrete subclass.");
+    }
+    async versionExistsInRegistry(_packageName, _version) {
+        throw new Error("Maven prod-publish is not implemented yet. " +
+            "Override versionExistsInRegistry() in a concrete subclass.");
+    }
+    async publish(_packageDir) {
+        throw new Error("Maven prod-publish is not implemented yet. " +
+            "Override publish() in a concrete subclass.");
+    }
+}
+exports.MavenProdPublishAdapter = MavenProdPublishAdapter;

package/dist/infrastructure/adapters/maven-release-adapter.js

@@ -0,0 +1,58 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MavenReleaseAdapter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const base_release_adapter_1 = require("./base-release-adapter");
+/**
+ * Boilerplate adapter for Maven release and dev-publish.
+ *
+ * Extend this class with real implementation when Maven support
+ * is needed. The key extension points are:
+ *
+ *   Release:
+ *   - writePackageFiles()  – update pom.xml with new version / frozen deps
+ *
+ *   Dev-publish:
+ *   - getCurrentVersion()  – read current version from pom.xml
+ *   - publish()            – build + deploy to the dev Maven repository
+ *
+ * Configure via `publish.maven` in quark-config.json:
+ *   {
+ *     "publish": {
+ *       "maven": {
+ *         "repositoryUrl": "https://your-nexus/repository/releases/",
+ *         "devRepositoryUrl": "https://your-nexus/repository/snapshots/",
+ *         "repositoryId": "releases"
+ *       }
+ *     }
+ *   }
+ *
+ * If only `repositoryUrl` is set, it is used for both dev and prod.
+ */
+class MavenReleaseAdapter extends base_release_adapter_1.BaseReleaseAdapter {
+    constructor(graphProvider, quarkConfig, logger) {
+        super(graphProvider, quarkConfig, logger);
+    }
+    supports(meta) {
+        return meta.platform === "maven";
+    }
+    getPlatformLabel(pkg) {
+        return chalk_1.default.bold.magenta(`☕  Releasing (Maven): ${pkg}`);
+    }
+    async writePackageFiles(_pkg, _prompt, _mapJsonObject, _graph) {
+        throw new Error("Maven release is not implemented yet. " +
+            "Override writePackageFiles() in a concrete subclass.");
+    }
+    async getCurrentVersion(_packageDir) {
+        throw new Error("Maven dev-publish is not implemented yet. " +
+            "Override getCurrentVersion() in a concrete subclass.");
+    }
+    async publish(_ctx, _alphaVersion) {
+        throw new Error("Maven dev-publish is not implemented yet. " +
+            "Override publish() in a concrete subclass.");
+    }
+}
+exports.MavenReleaseAdapter = MavenReleaseAdapter;

package/dist/infrastructure/adapters/node-prod-publish-adapter.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProdPublishAdapter = void 0;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const semver_1 = __importDefault(require("semver"));
+const quark_security_1 = require("@quark-hq/quark-security");
+const nodeRegistryEnv_1 = require("../config/nodeRegistryEnv");
+class NodeProdPublishAdapter {
+    constructor(quarkConfig, logger) {
+        this.quarkConfig = quarkConfig;
+        this.logger = logger;
+    }
+    supports(meta) {
+        return meta.platform === "node";
+    }
+    async readPackageIdentity(packageDir) {
+        const safeDir = (0, quark_security_1.assertPathInsideRoot)(process.cwd(), packageDir);
+        const pkgJsonPath = path_1.default.join(safeDir, "package.json");
+        const raw = await promises_1.default.readFile(pkgJsonPath, "utf8");
+        const pkgJson = JSON.parse(raw);
+        return { name: pkgJson.name, version: pkgJson.version };
+    }
+    async versionExistsInRegistry(packageName, version) {
+        (0, quark_security_1.assertValidNpmPackageName)(packageName, "package name");
+        if (!semver_1.default.valid(version)) {
+            throw new Error(`Invalid semver version: ${version}`);
+        }
+        const registries = this.getUniqueRegistryUrls();
+        for (const url of registries) {
+            const r = (0, quark_security_1.spawnSyncSafe)("npm", [
+                "view",
+                `${packageName}@${version}`,
+                "version",
+                "--registry",
+                url,
+            ], { stdio: "pipe" });
+            if (r.status === 0 && !r.error) {
+                this.logger.warn(`${packageName}@${version} already exists in registry: ${(0, quark_security_1.stripUrlCredentials)(url)}`);
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Publishes to registries in order: dev (or fallback {@link NodePublishConfig.registryUrl}),
+     * then prod — matching the legacy prod-publish flow. Duplicate URLs are skipped so the same
+     * registry is not published twice.
+     */
+    async publish(packageDir) {
+        const safeDir = (0, quark_security_1.assertPathInsideRoot)(process.cwd(), packageDir);
+        const registries = this.getPublishRegistryUrlsInOrder();
+        for (const registryUrl of registries) {
+            this.logger.info(`Publishing to registry: ${(0, quark_security_1.stripUrlCredentials)(registryUrl)}`);
+            (0, quark_security_1.assertSpawnOk)((0, quark_security_1.spawnSyncSafe)("pnpm", [
+                "publish",
+                "--registry",
+                registryUrl,
+                "--no-git-checks",
+            ], {
+                cwd: safeDir,
+                stdio: "inherit",
+            }), `pnpm publish (${(0, quark_security_1.stripUrlCredentials)(registryUrl)})`);
+        }
+    }
+    /**
+     * Ordered list for publish: dev URL first, then prod URL. Values come from
+     * `.env` (`DEV_REGISTRY_URL`, `PROD_REGISTRY_URL`) when set, else quark-config
+     * {@link NodePublishConfig.devRegistryUrl}, {@link NodePublishConfig.prodRegistryUrl},
+     * {@link NodePublishConfig.registryUrl}.
+     */
+    getPublishRegistryUrlsInOrder() {
+        const nodeConfig = this.quarkConfig.publish?.node;
+        const devUrl = (0, nodeRegistryEnv_1.effectiveDevRegistryUrl)(nodeConfig);
+        const prodUrl = (0, nodeRegistryEnv_1.effectiveProdRegistryUrl)(nodeConfig);
+        const ordered = [];
+        if (devUrl) {
+            ordered.push(devUrl);
+        }
+        if (prodUrl && prodUrl !== devUrl) {
+            ordered.push(prodUrl);
+        }
+        if (ordered.length === 0) {
+            throw new Error("No registry URLs configured. Set DEV_REGISTRY_URL / PROD_REGISTRY_URL in .env or publish.node.registryUrl (and optional dev/prod URLs) in quark-config.json");
+        }
+        return ordered;
+    }
+    /**
+     * Returns deduplicated list of all registry URLs that need checking.
+     * Collects the effective dev URL and effective prod URL, then deduplicates.
+     * If both flows resolve to the same URL, only one check is performed.
+     */
+    getUniqueRegistryUrls() {
+        const nodeConfig = this.quarkConfig.publish?.node;
+        const effectiveDevUrl = (0, nodeRegistryEnv_1.effectiveDevRegistryUrl)(nodeConfig);
+        const effectiveProdUrl = (0, nodeRegistryEnv_1.effectiveProdRegistryUrl)(nodeConfig);
+        const urls = new Set();
+        if (effectiveDevUrl)
+            urls.add(effectiveDevUrl);
+        if (effectiveProdUrl)
+            urls.add(effectiveProdUrl);
+        if (urls.size === 0) {
+            throw new Error("No registry URLs configured. Set DEV_REGISTRY_URL / PROD_REGISTRY_URL in .env or publish.node.registryUrl in quark-config.json");
+        }
+        return [...urls];
+    }
+}
+exports.NodeProdPublishAdapter = NodeProdPublishAdapter;

package/dist/infrastructure/adapters/node-release-adapter/node-file-update.js

@@ -0,0 +1 @@
+"use strict";