@quark-hq/quark-scripts 0.0.1

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

@@ -0,0 +1,289 @@
+"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.NodeReleaseAdapter = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const semver = __importStar(require("semver"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+class NodeReleaseAdapter {
+    constructor(git, graphProvider, quarkConfig) {
+        this.git = git;
+        this.graphProvider = graphProvider;
+        this.quarkConfig = quarkConfig;
+        this.userPrompts = {};
+    }
+    supports(meta) {
+        return meta.platform === "node";
+    }
+    async execute(packages, graph, sorted, masterBranch) {
+        const sortedPackages = sorted.filter((pkg) => packages.includes(pkg));
+        let mapJson = '';
+        try {
+            mapJson = await this.git.readFile(".release/map.json", masterBranch);
+        }
+        catch (error) {
+            mapJson = "{}";
+        }
+        // console.log(mapJson, "mapJson");
+        const mapJsonObject = JSON.parse(mapJson);
+        for (const pkg of sortedPackages) {
+            if (!this.userPrompts[pkg]) {
+                this.userPrompts[pkg] = await this.askUser(pkg, graph, mapJsonObject, sorted);
+            }
+        }
+        return this.userPrompts;
+    }
+    async askUser(pkg, graph, mapJsonObject, sorted) {
+        console.log("\n" + chalk_1.default.gray("──────────────────────────────────────────"));
+        console.log(chalk_1.default.bold.cyan(`📦  Releasing: ${pkg}`));
+        console.log(chalk_1.default.gray("──────────────────────────────────────────\n"));
+        let isNewPackage = !mapJsonObject[pkg];
+        let isFrozenPackage = mapJsonObject[pkg]?.frozen;
+        let isMajorBumpDisabled = isNewPackage || isFrozenPackage;
+        const response = await (0, prompts_1.default)([
+            {
+                type: "select",
+                name: "bump",
+                message: chalk_1.default.yellow("Select version bump type"),
+                choices: [
+                    {
+                        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("1.0.0", "patch")}`}`,
+                        description: `→ ${semver.inc("1.0.0", "patch")}`,
+                        value: "patch",
+                        disabled: isNewPackage,
+                    },
+                    {
+                        title: `✨  Minor (new features) ${isNewPackage ? "Disabled as package is new" : `→ ${semver.inc("1.0.0", "minor")}`}`,
+                        description: `→ ${semver.inc("1.0.0", "minor")}`,
+                        value: "minor",
+                        disabled: isNewPackage,
+                    },
+                    {
+                        title: `💥  Major (breaking changes) ${isNewPackage ? "Disabled as package is new" : isFrozenPackage ? "Disabled as package is frozen" : `→ ${semver.inc("1.0.0", "major")}`}`,
+                        description: `→ ${semver.inc("1.0.0", "major")}`,
+                        value: "major",
+                        disabled: 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: () => {
+                console.log(chalk_1.default.red("\n❌ Release cancelled by user"));
+                process.exit(1);
+            },
+        });
+        const result = {
+            bump: response.bump,
+            frozen: mapJsonObject[pkg]?.frozen || false,
+            baseVersion: mapJsonObject[pkg]?.newVersion || "1.0.0",
+            newVersion: response.bump === "new" ? "1.0.0" : (semver.inc(mapJsonObject[pkg]?.newVersion || "1.0.0", response.bump) ?? "1.0.0"),
+            changelog: response.changelog,
+        };
+        if (result.bump === "major") {
+            await this.handleMajorVersionBumpConfig(pkg, graph, mapJsonObject, sorted);
+        }
+        return result;
+    }
+    async handleMajorVersionBumpConfig(pkg, graph, mapJsonObject, sorted) {
+        const invertedAdjacenyList = await this.graphProvider.getInvertedAdjacencyList(graph.adjacency);
+        const dependents = sorted.filter((dep) => invertedAdjacenyList[pkg].includes(dep));
+        let choise = "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"
+                    }
+                ]
+            });
+            choise = response.dependencies;
+        }
+        if (choise === "all") {
+            await this.handleFrozenDependents(pkg, graph, mapJsonObject, dependents);
+        }
+        else if (choise === "none") {
+            await this.handleMajorVersionBump(pkg, graph, mapJsonObject, dependents);
+        }
+        else if (choise === "selective") {
+            await this.handleSelectiveMajorVersionBump(pkg, graph, mapJsonObject, dependents, invertedAdjacenyList);
+        }
+    }
+    isValidTopologicalSelection(ordered, selected, invertedAdjacencyList) {
+        if (selected.length === 0)
+            return true;
+        const selectedSet = new Set(selected);
+        for (const node of selected) {
+            // invertedAdjacencyList[node] = nodes that depend ON this node
+            const dependents = invertedAdjacencyList[node] ?? [];
+            for (const dependent of dependents) {
+                // dependent is in our candidate list but not selected — invalid
+                if (ordered.includes(dependent) && !selectedSet.has(dependent)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    async handleSelectiveMajorVersionBump(pkg, graph, mapJsonObject, dependents, invertedAdjacenyList) {
+        const selected = await this.handleSelectiveMajorVersionBumpPrompt(dependents);
+        // Handle case where user presses enter or doesn't select any items (prompt cancelled)
+        if (!selected || !Array.isArray(selected)) {
+            console.log(chalk_1.default.yellow("No selection made. Operation cancelled."));
+            return;
+        }
+        if (this.isValidTopologicalSelection(dependents, selected, invertedAdjacenyList)) {
+            const unSelected = dependents.filter((dependent) => !selected.includes(dependent));
+            await this.handleMajorVersionBump(pkg, graph, mapJsonObject, unSelected);
+            await this.handleFrozenDependents(pkg, graph, mapJsonObject, selected);
+        }
+        else {
+            console.log(chalk_1.default.red("Selection must be a continuous suffix of the list. Please select a continuous suffix of the list."));
+            await this.handleSelectiveMajorVersionBump(pkg, graph, mapJsonObject, dependents, invertedAdjacenyList);
+        }
+    }
+    async handleSelectiveMajorVersionBumpPrompt(dependents) {
+        const response = await (0, prompts_1.default)({
+            type: "multiselect",
+            name: "dependencies",
+            message: "Select the dependencies to freeze",
+            choices: dependents.map((dependent) => ({
+                title: dependent,
+                value: dependent
+            })),
+        });
+        return response.dependencies;
+    }
+    async handleMajorVersionBump(pkg, graph, mapJsonObject, dependents) {
+        dependents.forEach(async (dependent) => {
+            this.userPrompts[dependent] = {
+                bump: "major",
+                frozen: false,
+                baseVersion: mapJsonObject[dependent]?.newVersion || "1.0.0",
+                newVersion: semver.inc(mapJsonObject[dependent]?.newVersion || "1.0.0", "major") || "1.0.0",
+                changelog: "Dependency version bumped to major version due to major version bump of " + pkg
+            };
+        });
+    }
+    async handleFrozenDependents(pkg, graph, mapJsonObject, dependents) {
+        console.log("🔄 Handling frozen dependents for ", pkg);
+        dependents.forEach(async (dependent) => {
+            this.userPrompts[dependent] = {
+                bump: mapJsonObject[dependent]?.bumpType,
+                frozen: true,
+                baseVersion: mapJsonObject[dependent]?.baseVersion || "1.0.0",
+                newVersion: mapJsonObject[dependent]?.newVersion || "1.0.0",
+                changelog: "Dependency version frozen due to major version bump of " + pkg
+            };
+        });
+    }
+    async writeUserPromptsToFiles(pkg, prompt, mapJsonObject) {
+        console.log("prompt", pkg);
+        mapJsonObject[pkg] = {
+            bumpType: prompt.bump,
+            baseVersion: prompt.baseVersion,
+            newVersion: prompt.newVersion,
+            changeLog: prompt.changelog,
+            frozen: prompt.frozen,
+        };
+        const pathToPackage = await this.graphProvider.getPackageJson(pkg);
+        const pacakgeJSONpath = path_1.default.resolve(process.cwd(), pathToPackage, 'package.json');
+        // Read the existing package.json, update version, and write back
+        const packageJsonContent = await promises_1.default.readFile(pacakgeJSONpath, 'utf8');
+        const packageJson = JSON.parse(packageJsonContent);
+        if (this.userPrompts[pkg].frozen) {
+            packageJson.version = prompt.newVersion;
+            if (packageJson?.dependencies) {
+                Object.keys(packageJson?.dependencies)?.forEach((dependency) => {
+                    if (dependency in mapJsonObject) {
+                        packageJson.dependencies[dependency] = mapJsonObject[dependency].newVersion;
+                    }
+                });
+            }
+            if (packageJson?.peerDependencies) {
+                Object.keys(packageJson?.peerDependencies)?.forEach((dependency) => {
+                    if (dependency in mapJsonObject) {
+                        packageJson.peerDependencies[dependency] = mapJsonObject[dependency].newVersion;
+                    }
+                });
+            }
+            if (packageJson?.devDependencies) {
+                Object.keys(packageJson?.devDependencies)?.forEach((dependency) => {
+                    if (dependency in mapJsonObject) {
+                        packageJson.devDependencies[dependency] = mapJsonObject[dependency].newVersion;
+                    }
+                });
+            }
+        }
+        else {
+            packageJson.version = prompt.newVersion;
+        }
+        await promises_1.default.writeFile(pacakgeJSONpath, JSON.stringify(packageJson, null, 2), 'utf8');
+    }
+}
+exports.NodeReleaseAdapter = NodeReleaseAdapter;

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

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeReleaseAdapter = void 0;
+const quark_security_1 = require("@quark-hq/quark-security");
+const chalk_1 = __importDefault(require("chalk"));
+const workspace_transitive_dependencies_1 = require("../../domain/workspace-transitive-dependencies");
+const base_release_adapter_1 = require("./base-release-adapter");
+const resolve_workspace_dependency_specifier_for_freeze_map_1 = require("../../domain/resolve-workspace-dependency-specifier-for-freeze-map");
+const path_1 = __importDefault(require("path"));
+const nodeRegistryEnv_1 = require("../config/nodeRegistryEnv");
+class NodeReleaseAdapter extends base_release_adapter_1.BaseReleaseAdapter {
+    constructor(graphProvider, quarkConfig, logger) {
+        super(graphProvider, quarkConfig, logger);
+    }
+    supports(meta) {
+        return meta.platform === "node";
+    }
+    getPlatformLabel(pkg) {
+        return chalk_1.default.bold.cyan(`📦  Releasing: ${pkg}`);
+    }
+    // ── Release: file writes ───────────────────────────────────────────
+    async writePackageFiles(pkg, prompt, mapJsonObject, graph) {
+        const rootPath = await this.graphProvider.getPackageJson(pkg);
+        const cwd = process.cwd();
+        // bearer:disable javascript_lang_path_traversal
+        const absRoot = (0, quark_security_1.assertPathInsideRoot)(cwd, path_1.default.resolve(cwd, rootPath));
+        const packageJsonPath = path_1.default.join(absRoot, "package.json");
+        const raw = await (0, quark_security_1.readFileSafe)(cwd, packageJsonPath);
+        const packageJson = JSON.parse(raw);
+        packageJson.version = prompt.newVersion;
+        if (prompt.frozen) {
+            this.syncDependencyVersions(packageJson, "dependencies", mapJsonObject);
+            this.syncDependencyVersions(packageJson, "peerDependencies", mapJsonObject);
+            this.syncDependencyVersions(packageJson, "devDependencies", mapJsonObject);
+            this.syncDependencyVersions(packageJson, "optionalDependencies", mapJsonObject);
+            const pinned = this.collectPinnedWorkspaceDependencyVersions(pkg, packageJson, mapJsonObject, graph.adjacency);
+            mapJsonObject[pkg] = {
+                ...mapJsonObject[pkg],
+                ...(Object.keys(pinned).length > 0
+                    ? { pinnedDependencies: pinned }
+                    : {}),
+            };
+        }
+        await (0, quark_security_1.writeFileSafe)(cwd, packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    /**
+     * After pinning, records each workspace package in the dependency closure (direct +
+     * transitive in the graph) with the exact specifier used at freeze time (see
+     * {@link resolveWorkspaceDependencySpecifierForFreezeMap}). package.json is only
+     * updated for direct dependencies.
+     */
+    collectPinnedWorkspaceDependencyVersions(pkg, packageJson, mapJsonObject, adjacency) {
+        const pinned = {};
+        const depFields = [
+            "dependencies",
+            "peerDependencies",
+            "devDependencies",
+            "optionalDependencies",
+        ];
+        for (const field of depFields) {
+            const deps = packageJson[field];
+            if (!deps || typeof deps !== "object")
+                continue;
+            for (const [depName, spec] of Object.entries(deps)) {
+                if (typeof spec !== "string")
+                    continue;
+                if (spec.startsWith("workspace:"))
+                    continue;
+                if ((0, resolve_workspace_dependency_specifier_for_freeze_map_1.resolveWorkspaceDependencySpecifierForFreezeMap)(depName, mapJsonObject) === undefined) {
+                    continue;
+                }
+                pinned[depName] = spec;
+            }
+        }
+        const transitive = (0, workspace_transitive_dependencies_1.collectTransitiveWorkspaceDependencies)(pkg, adjacency);
+        for (const depName of transitive) {
+            const spec = (0, resolve_workspace_dependency_specifier_for_freeze_map_1.resolveWorkspaceDependencySpecifierForFreezeMap)(depName, mapJsonObject);
+            if (spec !== undefined) {
+                pinned[depName] = spec;
+            }
+        }
+        const sortedKeys = Object.keys(pinned).sort((a, b) => a.localeCompare(b));
+        const ordered = {};
+        for (const k of sortedKeys) {
+            ordered[k] = pinned[k];
+        }
+        return ordered;
+    }
+    syncDependencyVersions(packageJson, depField, mapJsonObject) {
+        const deps = packageJson[depField];
+        if (!deps)
+            return;
+        for (const depName of Object.keys(deps)) {
+            const spec = (0, resolve_workspace_dependency_specifier_for_freeze_map_1.resolveWorkspaceDependencySpecifierForFreezeMap)(depName, mapJsonObject);
+            if (spec !== undefined) {
+                deps[depName] = spec;
+            }
+        }
+    }
+    /** Restore workspace dependency versions to workspace:* (used when unfreezing). */
+    async restoreWorkspaceVersions(pkg, workspacePackageNames) {
+        const rootPath = await this.graphProvider.getPackageJson(pkg);
+        const cwd = process.cwd();
+        // bearer:disable javascript_lang_path_traversal
+        const absRoot = (0, quark_security_1.assertPathInsideRoot)(cwd, path_1.default.resolve(cwd, rootPath));
+        const packageJsonPath = path_1.default.join(absRoot, "package.json");
+        const raw = await (0, quark_security_1.readFileSafe)(cwd, packageJsonPath);
+        const packageJson = JSON.parse(raw);
+        const depFields = [
+            "dependencies",
+            "devDependencies",
+            "peerDependencies",
+            "optionalDependencies",
+        ];
+        for (const field of depFields) {
+            const deps = packageJson[field];
+            if (!deps || typeof deps !== "object")
+                continue;
+            for (const depName of Object.keys(deps)) {
+                if (workspacePackageNames.has(depName)) {
+                    deps[depName] = "workspace:*";
+                }
+            }
+        }
+        await (0, quark_security_1.writeFileSafe)(cwd, packageJsonPath, JSON.stringify(packageJson, null, 2));
+    }
+    // ── Dev-publish ────────────────────────────────────────────────────
+    async getCurrentVersion(packageDir) {
+        const pkgJsonPath = path_1.default.join(packageDir, "package.json");
+        const raw = await (0, quark_security_1.readFileSafe)(packageDir, pkgJsonPath);
+        return JSON.parse(raw).version ?? "1.0.0";
+    }
+    async publish(ctx, alphaVersion) {
+        const { packageName, packageDir, repoRoot } = ctx;
+        const safePackageDir = (0, quark_security_1.assertPathInsideRoot)(repoRoot, packageDir);
+        const pkgJsonPath = path_1.default.join(safePackageDir, "package.json");
+        const originalPkgJson = await (0, quark_security_1.readFileSafe)(repoRoot, pkgJsonPath);
+        const pkgJson = JSON.parse(originalPkgJson);
+        pkgJson.version = alphaVersion;
+        await (0, quark_security_1.writeFileSafe)(repoRoot, pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+        this.logger.info(`Updated version to ${alphaVersion}`);
+        const npmrcPath = path_1.default.join(repoRoot, ".npmrc");
+        const originalNpmrc = await this.readFileOrNull(repoRoot, npmrcPath);
+        await (0, quark_security_1.writeFileSafe)(repoRoot, npmrcPath, this.buildDevNpmrc());
+        this.logger.info("Overwrote project .npmrc with dev registry");
+        try {
+            this.logger.info(`Building package: ${packageName}`);
+            (0, quark_security_1.assertSpawnOk)((0, quark_security_1.spawnSyncSafe)("pnpm", ["run", "build"], {
+                cwd: safePackageDir,
+                stdio: "inherit",
+            }), "pnpm run build");
+            this.logger.info(`Publishing ${packageName}@${alphaVersion}...`);
+            (0, quark_security_1.assertSpawnOk)((0, quark_security_1.spawnSyncSafe)("pnpm", ["publish", "--no-git-check", "--access", "public"], { cwd: safePackageDir, stdio: "inherit" }), "pnpm publish");
+            this.logger.success(`Published ${packageName}@${alphaVersion} to dev registry`);
+        }
+        finally {
+            if (originalNpmrc !== null) {
+                await (0, quark_security_1.writeFileSafe)(repoRoot, npmrcPath, originalNpmrc);
+                this.logger.info("Restored original project .npmrc");
+            }
+            else {
+                await (0, quark_security_1.unlinkSafe)(repoRoot, npmrcPath).catch(() => { });
+                this.logger.info("Removed temporary project .npmrc");
+            }
+            await (0, quark_security_1.writeFileSafe)(repoRoot, pkgJsonPath, originalPkgJson);
+            this.logger.info("Restored original package.json");
+        }
+    }
+    buildDevNpmrc() {
+        const nodeConfig = this.quarkConfig.publish?.node;
+        const registryUrl = (0, nodeRegistryEnv_1.effectiveDevRegistryUrl)(nodeConfig);
+        if (!registryUrl) {
+            throw new Error("Dev registry URL not configured. Set DEV_REGISTRY_URL in .env or publish.node.registryUrl (or publish.node.devRegistryUrl) in quark-config.json");
+        }
+        const scope = (0, nodeRegistryEnv_1.effectiveNodeScope)(nodeConfig);
+        if (!scope) {
+            throw new Error("Registry scope not configured. Set SCOPE in .env or publish.node.scope in quark-config.json");
+        }
+        const authToken = process.env.DEV_AUTH_TOKEN || process.env.NEXUS_DEV_AUTH;
+        if (!authToken) {
+            throw new Error("Auth token required for dev publishing: set DEV_AUTH_TOKEN or NEXUS_DEV_AUTH");
+        }
+        const registryPath = registryUrl.replace(/^https?:/, "");
+        return [
+            `${scope}:registry=${registryUrl}`,
+            `${registryPath}:_auth=${authToken}`,
+            `${registryPath}:always-auth=true`,
+        ].join("\n") + "\n";
+    }
+    async readFileOrNull(repoRoot, filePath) {
+        try {
+            return await (0, quark_security_1.readFileSafe)(repoRoot, filePath);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+exports.NodeReleaseAdapter = NodeReleaseAdapter;

package/dist/infrastructure/config/loadDotEnv.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadDotEnvFromRepoRoot = loadDotEnvFromRepoRoot;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Loads `.env` from `cwd` into `process.env` for keys that are not already set.
+ * Tolerates spaces around `=` and optional single/double quotes on values.
+ */
+function loadDotEnvFromRepoRoot(cwd = process.cwd()) {
+    const envPath = path_1.default.resolve(cwd, ".env");
+    if (!fs_1.default.existsSync(envPath)) {
+        return;
+    }
+    const text = fs_1.default.readFileSync(envPath, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const eq = trimmed.indexOf("=");
+        if (eq === -1) {
+            continue;
+        }
+        const key = trimmed.slice(0, eq).trim();
+        let value = trimmed.slice(eq + 1).trim();
+        if ((value.startsWith("'") && value.endsWith("'")) ||
+            (value.startsWith('"') && value.endsWith('"'))) {
+            value = value.slice(1, -1).trim();
+        }
+        if (key && process.env[key] === undefined) {
+            process.env[key] = value;
+        }
+    }
+}

package/dist/infrastructure/config/nodeRegistryEnv.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEnvString = normalizeEnvString;
+exports.effectiveDevRegistryUrl = effectiveDevRegistryUrl;
+exports.effectiveProdRegistryUrl = effectiveProdRegistryUrl;
+exports.effectiveNodeScope = effectiveNodeScope;
+/**
+ * Normalizes a value from `process.env` or config (trim, strip surrounding quotes).
+ */
+function normalizeEnvString(value) {
+    if (value === undefined) {
+        return "";
+    }
+    const t = value.trim();
+    if (!t) {
+        return "";
+    }
+    if ((t.startsWith("'") && t.endsWith("'")) ||
+        (t.startsWith('"') && t.endsWith('"'))) {
+        return t.slice(1, -1).trim();
+    }
+    return t;
+}
+/** Dev registry: `DEV_REGISTRY_URL`, then quark-config `devRegistryUrl` / `registryUrl`. */
+function effectiveDevRegistryUrl(node) {
+    return (normalizeEnvString(process.env.DEV_REGISTRY_URL) ||
+        normalizeEnvString(node?.devRegistryUrl) ||
+        normalizeEnvString(node?.registryUrl));
+}
+/** Prod registry: `PROD_REGISTRY_URL`, then quark-config `prodRegistryUrl` / `registryUrl`. */
+function effectiveProdRegistryUrl(node) {
+    return (normalizeEnvString(process.env.PROD_REGISTRY_URL) ||
+        normalizeEnvString(node?.prodRegistryUrl) ||
+        normalizeEnvString(node?.registryUrl));
+}
+/** Scope: `SCOPE`, then quark-config `publish.node.scope`. */
+function effectiveNodeScope(node) {
+    return (normalizeEnvString(process.env.SCOPE) ||
+        normalizeEnvString(node?.scope) ||
+        "");
+}

package/dist/infrastructure/config/quarkConfigProvider.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuarkConfigProvider = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DEFAULT_CONFIG = {
+    release: {
+        masterBranch: "main",
+        autoCommit: false,
+        autoBump: true,
+        freeze: true,
+    },
+    publish: {
+        node: {
+            registryUrl: "",
+            scope: "",
+        },
+        maven: {
+            repositoryUrl: "",
+            repositoryId: "",
+        },
+    },
+};
+class QuarkConfigProvider {
+    getConfig() {
+        const configPath = path_1.default.resolve(process.cwd(), "quark-config.json");
+        if (!fs_1.default.existsSync(configPath)) {
+            return DEFAULT_CONFIG;
+        }
+        const raw = fs_1.default.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return {
+            release: { ...DEFAULT_CONFIG.release, ...parsed.release },
+            publish: {
+                node: {
+                    ...DEFAULT_CONFIG.publish.node,
+                    ...parsed.publish?.node,
+                },
+                maven: {
+                    ...DEFAULT_CONFIG.publish.maven,
+                    ...parsed.publish?.maven,
+                },
+            },
+        };
+    }
+}
+exports.QuarkConfigProvider = QuarkConfigProvider;