@quark-hq/quark-scripts 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Acko Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/app/base-application.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseApplication = void 0;
+const path_1 = require("path");
+/**
+ * Shared infrastructure for any command that operates on the monorepo graph:
+ *   - repository health checks
+ *   - dependency graph construction
+ *   - changed-file detection and package ownership resolution
+ */
+class BaseApplication {
+    constructor(logger, git, graphProvider, masterBranch) {
+        this.logger = logger;
+        this.git = git;
+        this.graphProvider = graphProvider;
+        this.masterBranch = masterBranch;
+    }
+    async ensureRepositoryHealthy() {
+        const repoRoot = await this.git.getRepositoryRoot();
+        this.logger.info(`Repo root: ${repoRoot}`);
+        const currentBranch = await this.git.getCurrentBranch();
+        this.logger.info(`Current branch: ${currentBranch}`);
+        await this.git.fetch(this.masterBranch);
+        const behind = await this.git.commitsBehind(this.masterBranch);
+        if (behind > 0) {
+            throw new Error(`Branch is ${behind} commits behind origin/${this.masterBranch}`);
+        }
+        return repoRoot;
+    }
+    async buildGraph() {
+        const graph = await this.graphProvider.build();
+        if (!graph || Object.keys(graph.adjacency).length === 0) {
+            throw new Error("Dependency graph is empty");
+        }
+        return graph;
+    }
+    async getChangedAbsolutePaths(repoRoot) {
+        const relativeFiles = await this.git.getChangedFiles(this.masterBranch);
+        return relativeFiles.map((f) => (0, path_1.resolve)(repoRoot, f));
+    }
+    isPackageAffected(packageDir, changedFiles) {
+        return changedFiles.some((file) => file.startsWith(packageDir + "/"));
+    }
+    mapFilesToPackages(changedFiles, metadata) {
+        const changed = new Set();
+        for (const file of changedFiles) {
+            const owner = this.findOwningPackage(file, metadata);
+            if (owner !== null) {
+                changed.add(owner);
+            }
+        }
+        return changed;
+    }
+    findOwningPackage(file, metadata) {
+        let bestMatch = null;
+        for (const [name, { rootDir }] of Object.entries(metadata)) {
+            if (!file.startsWith(rootDir + "/"))
+                continue;
+            if (bestMatch === null ||
+                rootDir.length > bestMatch.rootDir.length) {
+                bestMatch = { name, rootDir };
+            }
+        }
+        return bestMatch?.name ?? null;
+    }
+}
+exports.BaseApplication = BaseApplication;

package/dist/app/buildApplication.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildApplication = void 0;
+class BuildApplication {
+    constructor(logger, processRunner) {
+        this.logger = logger;
+        this.processRunner = processRunner;
+    }
+    async execute(options) {
+        this.logger.info("🔨 Building package...");
+        this.logger.info("→ Compiling TypeScript...");
+        this.processRunner.run("npx", ["--yes", "tsc"]);
+        if (!options.skipStatic) {
+            this.logger.info("→ Copying static assets...");
+            this.processRunner.run("npx", ["--yes", "quark-scripts", "copy-static"]);
+        }
+        this.logger.success("✅ Build completed successfully");
+    }
+}
+exports.BuildApplication = BuildApplication;

package/dist/app/copyStaticApplication.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyStaticApplication = void 0;
+const IGNORE_PATTERNS = [
+    "dist/**",
+    "node_modules/**",
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.tsbuildinfo",
+    "**/tsconfig.json",
+    "**/.npmrc",
+    "**/package-lock.json",
+];
+class CopyStaticApplication {
+    constructor(logger, processRunner) {
+        this.logger = logger;
+        this.processRunner = processRunner;
+    }
+    async execute() {
+        this.logger.info("📦 Copying static assets...");
+        const copyfilesArgs = [
+            "--yes",
+            "copyfiles",
+            "**/*",
+            "dist/",
+            ...IGNORE_PATTERNS.flatMap((p) => ["--exclude", p]),
+        ];
+        this.processRunner.run("npx", copyfilesArgs);
+        this.logger.success("✅ Static assets copied successfully");
+    }
+}
+exports.CopyStaticApplication = CopyStaticApplication;

package/dist/app/devApplication.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevApplication = void 0;
+const IGNORE_PATTERNS = [
+    "dist/**",
+    "node_modules/**",
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.tsbuildinfo",
+    "**/tsconfig.json",
+    "**/.npmrc",
+    "**/package-lock.json",
+];
+class DevApplication {
+    constructor(logger, processRunner) {
+        this.logger = logger;
+        this.processRunner = processRunner;
+    }
+    async execute(options) {
+        this.logger.info("🚀 Starting development mode...");
+        if (!options.skipInitialCopy) {
+            this.logger.info("→ Initial copy of static assets...");
+            try {
+                this.processRunner.run("npx", [
+                    "--yes",
+                    "quark-scripts",
+                    "copy-static",
+                ]);
+            }
+            catch {
+                this.logger.warn("⚠️ Initial copy failed, continuing...");
+            }
+        }
+        const tscWatchCmd = "npx --yes tsc --watch --preserveWatchOutput";
+        const chokidarCmd = [
+            "npx",
+            "--yes",
+            "chokidar",
+            "**/*",
+            ...IGNORE_PATTERNS.flatMap((p) => ["-i", p]),
+            "-c",
+            "quark-scripts copy-static",
+        ].join(" ");
+        this.logger.info("→ Starting watchers...");
+        this.processRunner.run("npx", [
+            "--yes",
+            "concurrently",
+            "--names",
+            "TSC,ASSETS",
+            "--prefix-colors",
+            "cyan,magenta",
+            tscWatchCmd,
+            chokidarCmd,
+        ]);
+    }
+}
+exports.DevApplication = DevApplication;

package/dist/app/prod-publish-application.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProdPublishApplication = void 0;
+class ProdPublishApplication {
+    constructor(logger, git, graphProvider, adapters, topoSorter, quarkConfig) {
+        this.logger = logger;
+        this.git = git;
+        this.graphProvider = graphProvider;
+        this.adapters = adapters;
+        this.topoSorter = topoSorter;
+        this.quarkConfig = quarkConfig;
+    }
+    async execute(targetTag) {
+        this.logger.info("Building dependency graph...");
+        const graph = await this.graphProvider.build();
+        this.logger.info("Resolving git tags...");
+        const [previousTag, latestTag] = await this.git.getTags(targetTag);
+        if (previousTag === null) {
+            this.logger.info(`No older tag: using empty release map baseline → ${latestTag}`);
+        }
+        else {
+            this.logger.info(`Comparing tags: ${previousTag} → ${latestTag}`);
+        }
+        const { changedPackages, oldMap, newMap } = await this.detectChangedPackages(previousTag, latestTag);
+        const freezeFiltered = this.applyFreezePublishFilter(changedPackages, oldMap, newMap);
+        if (freezeFiltered.length === 0) {
+            this.logger.warn(changedPackages.length === 0
+                ? "No package changes detected for this release (map at latest tag vs baseline)."
+                : "No packages qualify for prod publish after freeze policy (same-version unfrozen map-only updates are skipped).");
+            return;
+        }
+        const ordered = this.topoSorter.sort(graph.adjacency, freezeFiltered);
+        this.logger.info(`Changed packages: ${ordered.join(", ")}`);
+        const validated = await this.validateAll(ordered, graph.metadata);
+        await this.publishAll(validated);
+        this.logger.success(`Published ${validated.length} package(s) to prod registry.`);
+    }
+    async validateAll(changedPackages, metadata) {
+        const toPublish = [];
+        for (const pkgName of changedPackages) {
+            const meta = metadata[pkgName];
+            if (!meta) {
+                this.logger.warn(`Package "${pkgName}" not found in graph, skipping.`);
+                continue;
+            }
+            const adapter = this.adapters.find((a) => a.supports(meta));
+            if (!adapter) {
+                this.logger.warn(`No prod-publish adapter for platform "${meta.platform}", skipping ${pkgName}.`);
+                continue;
+            }
+            const identity = await adapter.readPackageIdentity(meta.rootDir);
+            const exists = await adapter.versionExistsInRegistry(identity.name, identity.version);
+            if (exists) {
+                throw new Error(`Version ${identity.name}@${identity.version} already exists in prod registry. Aborting all publish operations.`);
+            }
+            toPublish.push({
+                packageName: pkgName,
+                packageDir: meta.rootDir,
+                adapter,
+                identity,
+            });
+        }
+        return toPublish;
+    }
+    async publishAll(packages) {
+        for (const { adapter, identity, packageDir } of packages) {
+            this.logger.info(`Publishing ${identity.name}@${identity.version}...`);
+            await adapter.publish(packageDir);
+            this.logger.success(`Published ${identity.name}@${identity.version}`);
+        }
+    }
+    /**
+     * When {@link QuarkConfig.release.freeze} is enabled, skip **updated** packages that
+     * stayed on the same `newVersion` while remaining unfrozen — those
+     * are map-only churn (e.g. changelog) and are not registry-ready compared to frozen
+     * artifacts. New packages and any version bump still publish.
+     */
+    applyFreezePublishFilter(changed, oldMap, newMap) {
+        if (!this.quarkConfig.release.freeze) {
+            return changed;
+        }
+        return changed.filter((key) => {
+            const prev = oldMap[key];
+            const next = newMap[key];
+            if (!prev) {
+                return true;
+            }
+            const prevVer = prev.newVersion ?? "";
+            const nextVer = next.newVersion ?? "";
+            if (prevVer !== nextVer) {
+                return true;
+            }
+            if (next.frozen === true) {
+                return true;
+            }
+            this.logger.warn(`Skipping prod publish for "${key}": release.freeze is enabled, version unchanged (${nextVer}), and package is not frozen (map-only update).`);
+            return false;
+        });
+    }
+    async detectChangedPackages(previousTag, latestTag) {
+        const oldMapRaw = previousTag === null
+            ? "{}"
+            : await this.git.readFileFromRef(".release/map.json", previousTag);
+        const newMapRaw = await this.git.readFileFromRef(".release/map.json", latestTag);
+        const oldMap = JSON.parse(oldMapRaw);
+        const newMap = JSON.parse(newMapRaw);
+        const allKeys = new Set([
+            ...Object.keys(oldMap),
+            ...Object.keys(newMap),
+        ]);
+        const changed = [];
+        for (const key of allKeys) {
+            const isAdded = !(key in oldMap);
+            const isUpdated = key in oldMap &&
+                key in newMap &&
+                JSON.stringify(oldMap[key]) !== JSON.stringify(newMap[key]);
+            if (isAdded || isUpdated) {
+                changed.push(key);
+            }
+        }
+        return { changedPackages: changed, oldMap, newMap };
+    }
+}
+exports.ProdPublishApplication = ProdPublishApplication;

package/dist/app/publish-dev-application.js

@@ -0,0 +1,104 @@
+"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.PublishDevApplication = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const prompts_1 = __importDefault(require("prompts"));
+const semver = __importStar(require("semver"));
+const base_application_1 = require("./base-application");
+class PublishDevApplication extends base_application_1.BaseApplication {
+    constructor(logger, git, graphProvider, adapters, masterBranch = "main") {
+        super(logger, git, graphProvider, masterBranch);
+        this.adapters = adapters;
+    }
+    async execute() {
+        this.logger.info("Performing repository checks...");
+        const repoRoot = await this.ensureRepositoryHealthy();
+        this.logger.info("Building dependency graph...");
+        const graph = await this.buildGraph();
+        const changedFiles = await this.getChangedAbsolutePaths(repoRoot);
+        const changedPackages = this.mapFilesToPackages(changedFiles, graph.metadata);
+        if (changedPackages.size === 0) {
+            this.logger.warn(`No packages have changed since ${this.masterBranch}. Nothing to publish.`);
+            return;
+        }
+        this.logger.info(`Changed packages: ${[...changedPackages].join(", ")}`);
+        const packageName = await this.promptPackageName(changedPackages);
+        const meta = graph.metadata[packageName];
+        const adapter = this.adapters.find((a) => a.supports(meta));
+        if (!adapter) {
+            throw new Error(`No dev-publish adapter for platform "${meta.platform}"`);
+        }
+        const currentVersion = await adapter.getCurrentVersion(meta.rootDir);
+        const alphaVersion = this.generateAlphaVersion(currentVersion);
+        this.logger.info(`Version: ${currentVersion} → ${chalk_1.default.bold(alphaVersion)}`);
+        await adapter.publish({ packageName, packageDir: meta.rootDir, repoRoot }, alphaVersion);
+    }
+    async promptPackageName(changedPackages) {
+        const packages = [...changedPackages].sort();
+        const response = await (0, prompts_1.default)({
+            type: "autocomplete",
+            name: "packageName",
+            message: chalk_1.default.yellow("Select the changed package to publish as alpha:"),
+            choices: packages.map((pkg) => ({
+                title: pkg,
+                value: pkg,
+            })),
+            suggest: async (input, choices) => choices.filter((c) => c.title
+                .toLowerCase()
+                .includes(input.toLowerCase())),
+        }, {
+            onCancel: () => {
+                throw new Error("Publish cancelled by user");
+            },
+        });
+        if (!response.packageName) {
+            throw new Error("No package name provided");
+        }
+        return response.packageName;
+    }
+    generateAlphaVersion(currentVersion) {
+        const parsed = semver.parse(currentVersion);
+        if (!parsed) {
+            throw new Error(`Invalid semver version: ${currentVersion}`);
+        }
+        const base = `${parsed.major}.${parsed.minor}.${parsed.patch}`;
+        return `${base}-alpha.${Date.now()}`;
+    }
+}
+exports.PublishDevApplication = PublishDevApplication;

package/dist/app/publishDevApplication.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishDevApplication = void 0;
+class PublishDevApplication {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    async execute() {
+        this.logger.info("📦 Publishing to dev registry...");
+        const PublishScript = require("../scripts/dev").default;
+        const publish = new PublishScript();
+        await publish.run();
+        this.logger.success("✅ Published to dev registry");
+    }
+}
+exports.PublishDevApplication = PublishDevApplication;

package/dist/app/release-application.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseApplication = void 0;
+const base_application_1 = require("./base-application");
+class ReleaseApplication extends base_application_1.BaseApplication {
+    constructor(logger, git, graphProvider, adapters, topoSorter, releaseMapStore, masterBranch = "main") {
+        super(logger, git, graphProvider, masterBranch);
+        this.adapters = adapters;
+        this.topoSorter = topoSorter;
+        this.releaseMapStore = releaseMapStore;
+    }
+    async execute() {
+        this.logger.info("Performing repository checks...");
+        const repoRoot = await this.ensureRepositoryHealthy();
+        this.logger.info("Building dependency graph...");
+        const graph = await this.buildGraph();
+        this.logger.success("Repository checks passed");
+        this.logger.info(`Total packages: ${Object.keys(graph.adjacency).length}`);
+        const changedFiles = await this.getChangedAbsolutePaths(repoRoot);
+        this.logger.info(`Changed files: ${changedFiles.length}`);
+        const affected = this.resolveDirectlyChangedPackages(changedFiles, graph.metadata);
+        this.logger.info(`Affected packages: ${[...affected].join(", ")}`);
+        const sorted = this.topoSorter.sort(graph.adjacency, [...affected]);
+        this.logger.info(`Execution order: ${sorted.join(" → ")}`);
+        await this.executeRelease([...affected], graph, sorted);
+    }
+    // ── Affected-package resolution ────────────────────────────────────
+    /**
+     * Only packages whose files changed. Dependents are not included here;
+     * when the user chooses a **major** bump for a package, the release adapter
+     * adds direct dependents (freeze / cascade) via {@link BaseReleaseAdapter}.
+     */
+    resolveDirectlyChangedPackages(changedFiles, metadata) {
+        return this.mapFilesToPackages(changedFiles, metadata);
+    }
+    // ── Release orchestration ──────────────────────────────────────────
+    async executeRelease(affected, graph, sorted) {
+        const existingMap = await this.releaseMapStore.readMergedWithLocal(this.masterBranch);
+        const allPrompts = await this.collectPrompts(affected, graph, sorted, existingMap);
+        await this.writePromptResults(allPrompts, graph, existingMap);
+        await this.releaseMapStore.write(existingMap);
+    }
+    async collectPrompts(affected, graph, sorted, existingMap) {
+        const grouped = this.groupByAdapter(affected, graph);
+        let allPrompts = {};
+        for (const [adapter, packages] of grouped.entries()) {
+            this.logger.info(`Executing adapter for ${packages.length} package(s)`);
+            const adapterPrompts = await adapter.execute(packages, graph, sorted, existingMap);
+            allPrompts = { ...allPrompts, ...adapterPrompts };
+        }
+        return allPrompts;
+    }
+    async writePromptResults(allPrompts, graph, mapJsonObject) {
+        for (const [pkg, prompt] of Object.entries(allPrompts)) {
+            const meta = graph.metadata[pkg];
+            if (!meta)
+                continue;
+            const adapter = this.adapters.find((a) => a.supports(meta));
+            if (!adapter) {
+                this.logger.warn(`No adapter found for ${pkg}`);
+                continue;
+            }
+            await adapter.writeUserPromptsToFiles(pkg, prompt, mapJsonObject, graph);
+        }
+    }
+    groupByAdapter(affected, graph) {
+        const grouped = new Map();
+        for (const pkg of affected) {
+            const meta = graph.metadata[pkg];
+            if (!meta)
+                continue;
+            const adapter = this.adapters.find((a) => a.supports(meta));
+            if (!adapter) {
+                this.logger.warn(`No adapter found for ${pkg}`);
+                continue;
+            }
+            if (!grouped.has(adapter)) {
+                grouped.set(adapter, []);
+            }
+            grouped.get(adapter).push(pkg);
+        }
+        return grouped;
+    }
+}
+exports.ReleaseApplication = ReleaseApplication;