@quark-hq/quark-scripts 0.0.1

package/dist/app/releaseApplication.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseApplication = void 0;
+const path_1 = require("path");
+const path_2 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+class ReleaseApplication {
+    constructor(logger, git, graphProvider, adapters, topoSorter, masterBranch = "main") {
+        this.logger = logger;
+        this.git = git;
+        this.graphProvider = graphProvider;
+        this.adapters = adapters;
+        this.topoSorter = topoSorter;
+        this.masterBranch = masterBranch;
+        this.userPrompts = {};
+    }
+    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 relativeFiles = await this.git.getChangedFiles(this.masterBranch);
+        const changedFiles = relativeFiles.map(f => (0, path_1.resolve)(repoRoot, f));
+        this.logger.info(`📝 Changed files: ${changedFiles.length}`);
+        const affected = this.resolveAffectedPackages(changedFiles, graph.adjacency, 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.executePlatformJobs([...affected], graph, sorted);
+    }
+    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;
+    }
+    resolveAffectedPackages(changedFiles, adjacency, metadata) {
+        const directlyChanged = this.mapFilesToPackages(changedFiles, metadata);
+        return this.traverseReversed(directlyChanged, adjacency);
+    }
+    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;
+    }
+    traverseReversed(seeds, adjacency) {
+        const reversed = {};
+        for (const [pkg, deps] of Object.entries(adjacency)) {
+            for (const dep of deps) {
+                (reversed[dep] ?? (reversed[dep] = [])).push(pkg);
+            }
+        }
+        const affected = new Set(seeds);
+        const queue = [...seeds];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            for (const dependent of reversed[current] ?? []) {
+                if (!affected.has(dependent)) {
+                    affected.add(dependent);
+                    queue.push(dependent);
+                }
+            }
+        }
+        return affected;
+    }
+    async executePlatformJobs(affected, graph, sorted) {
+        const metadata = graph.metadata;
+        const grouped = new Map();
+        for (const pkg of affected) {
+            const meta = 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);
+        }
+        for (const [adapter, packages] of grouped.entries()) {
+            this.logger.info(`🚀 Executing adapter for ${packages.length} package(s)`);
+            let userPrompts = await adapter.execute(packages, graph, sorted, this.masterBranch);
+            this.userPrompts = { ...this.userPrompts, ...userPrompts };
+        }
+        let mapJson = "{}";
+        try {
+            mapJson = await this.git.readFile(".release/map.json", this.masterBranch);
+        }
+        catch (error) {
+            mapJson = "{}";
+        }
+        console.log(this.userPrompts);
+        const mapJsonObject = JSON.parse(mapJson);
+        for (const pkg of Object.keys(this.userPrompts)) {
+            const meta = 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;
+            }
+            console.log(pkg, "@@@@@@@@");
+            await adapter.writeUserPromptsToFiles(pkg, this.userPrompts[pkg], mapJsonObject);
+        }
+        const releaseDir = path_2.default.resolve(process.cwd(), '.release');
+        try {
+            await promises_1.default.mkdir(releaseDir, { recursive: true });
+        }
+        catch (e) {
+            // Directory already exists or another error occurred, proceed anyway
+        }
+        const updatedMapJson = JSON.stringify(mapJsonObject, null, 2);
+        await promises_1.default.writeFile(path_2.default.join(releaseDir, 'map.json'), updatedMapJson, 'utf8');
+    }
+}
+exports.ReleaseApplication = ReleaseApplication;

package/dist/app/unfreeze-application.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnfreezeApplication = void 0;
+const workspace_transitive_dependencies_1 = require("../domain/workspace-transitive-dependencies");
+const unfreeze_blocked_error_1 = require("../errors/unfreeze-blocked-error");
+function resolveReleaseEntry(packageName, localMap, mainMap) {
+    if (Object.keys(localMap).length > 0) {
+        return localMap[packageName] ?? mainMap[packageName];
+    }
+    return mainMap[packageName];
+}
+/** Workspace deps of `packageName` that are still frozen in the release map. */
+function frozenTransitiveDependencies(packageName, graph, localMap, mainMap) {
+    return (0, workspace_transitive_dependencies_1.collectTransitiveWorkspaceDependencies)(packageName, graph.adjacency).filter((dep) => resolveReleaseEntry(dep, localMap, mainMap)?.frozen === true);
+}
+/**
+ * Unfreezes a package by:
+ * 1. Restoring workspace dependency versions to workspace:* in package.json
+ * 2. Setting frozen: false in .release/map.json (preserves local manual edits)
+ *
+ * Proceeds when:
+ * - Main has the package frozen (normal unfreeze), OR
+ * - Local has the package frozen but main does not (sync to main — repairs stale local state)
+ *
+ * Refuses to unfreeze while any transitive workspace dependency is still frozen
+ * (e.g. A→B→C: unfreeze A only after B (and thus the chain) is unfrozen first).
+ */
+class UnfreezeApplication {
+    constructor(graphProvider, releaseMapStore, nodeReleaseAdapter, logger, masterBranch) {
+        this.graphProvider = graphProvider;
+        this.releaseMapStore = releaseMapStore;
+        this.nodeReleaseAdapter = nodeReleaseAdapter;
+        this.logger = logger;
+        this.masterBranch = masterBranch;
+    }
+    async execute(packageName) {
+        this.logger.info(`Unfreezing package "${packageName}"...`);
+        const graph = await this.graphProvider.build();
+        if (!graph || Object.keys(graph.metadata).length === 0) {
+            throw new Error("Dependency graph is empty. Ensure you are in a valid monorepo.");
+        }
+        if (!(packageName in graph.metadata)) {
+            throw new Error(`Package "${packageName}" not found in workspace.`);
+        }
+        // 1. Read main and local maps
+        const mainMap = await this.releaseMapStore.read(this.masterBranch);
+        const localMap = await this.releaseMapStore.readLocal();
+        const baseMap = Object.keys(localMap).length > 0 ? { ...localMap } : { ...mainMap };
+        const entry = baseMap[packageName] ?? mainMap[packageName];
+        if (!entry) {
+            throw new Error(`Package "${packageName}" not found in release map.`);
+        }
+        // 2. Proceed if frozen on main OR locally (repairs stale local when main already unfrozen)
+        const frozenOnMain = mainMap[packageName]?.frozen === true;
+        const frozenLocally = entry.frozen === true;
+        if (!frozenOnMain && !frozenLocally) {
+            throw new Error(`Package "${packageName}" is not frozen. Nothing to unfreeze.`);
+        }
+        const blockingDeps = frozenTransitiveDependencies(packageName, graph, localMap, mainMap);
+        if (blockingDeps.length > 0) {
+            throw new unfreeze_blocked_error_1.UnfreezeBlockedByFrozenDependenciesError(packageName, blockingDeps);
+        }
+        const meta = graph.metadata[packageName];
+        if (meta.platform === "maven") {
+            throw new Error("Unfreeze for Maven packages is not implemented yet.");
+        }
+        const workspacePackageNames = new Set(Object.keys(graph.metadata));
+        await this.nodeReleaseAdapter.restoreWorkspaceVersions(packageName, workspacePackageNames);
+        const { pinnedDependencies: _pinned, ...entryWithoutPins } = entry;
+        baseMap[packageName] = { ...entryWithoutPins, frozen: false };
+        await this.releaseMapStore.write(baseMap);
+        this.logger.success(`Unfroze package "${packageName}". Dependency versions restored to workspace:*.`);
+    }
+}
+exports.UnfreezeApplication = UnfreezeApplication;

package/dist/app/watchStaticApplication.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchStaticApplication = void 0;
+const IGNORE_PATTERNS = [
+    "dist/**",
+    "node_modules/**",
+    "**/*.ts",
+    "**/*.tsx",
+    "**/*.js",
+    "**/*.jsx",
+    "**/*.tsbuildinfo",
+    "**/tsconfig.json",
+    "**/.npmrc",
+    "**/package-lock.json",
+];
+class WatchStaticApplication {
+    constructor(logger, processRunner) {
+        this.logger = logger;
+        this.processRunner = processRunner;
+    }
+    async execute() {
+        this.logger.info("👀 Watching static assets...");
+        const chokidarArgs = [
+            "--yes",
+            "chokidar",
+            "**/*",
+            ...IGNORE_PATTERNS.flatMap((p) => ["-i", p]),
+            "-c",
+            "quark-scripts copy-static",
+        ];
+        this.processRunner.run("npx", chokidarArgs);
+    }
+}
+exports.WatchStaticApplication = WatchStaticApplication;

package/dist/cli/cli-containers.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliContainer = void 0;
+const publish_dev_commands_1 = require("./commands/publish-dev-commands");
+const release_commands_1 = require("./commands/release-commands");
+const prod_publish_commands_1 = require("./commands/prod-publish-commands");
+const unfreeze_commands_1 = require("./commands/unfreeze-commands");
+const publish_dev_application_1 = require("../app/publish-dev-application");
+const release_application_1 = require("../app/release-application");
+const prod_publish_application_1 = require("../app/prod-publish-application");
+const unfreeze_application_1 = require("../app/unfreeze-application");
+const consoleLogger_1 = require("../infrastructure/logging/consoleLogger");
+const nodeProcessRunner_1 = require("../infrastructure/process/nodeProcessRunner");
+const gitService_1 = require("../infrastructure/git/gitService");
+const nxGraphProvide_1 = require("../infrastructure/graph/nxGraphProvide");
+const node_release_adapter_1 = require("../infrastructure/adapters/node-release-adapter");
+const maven_release_adapter_1 = require("../infrastructure/adapters/maven-release-adapter");
+const node_prod_publish_adapter_1 = require("../infrastructure/adapters/node-prod-publish-adapter");
+const maven_prod_publish_adapter_1 = require("../infrastructure/adapters/maven-prod-publish-adapter");
+const topological_sorting_1 = require("../domain/topological-sorting");
+const quarkConfigProvider_1 = require("../infrastructure/config/quarkConfigProvider");
+const git_release_map_store_1 = require("../infrastructure/release/git-release-map-store");
+class CliContainer {
+    static create() {
+        const logger = new consoleLogger_1.ConsoleLogger();
+        const processRunner = new nodeProcessRunner_1.NodeProcessRunner();
+        const gitService = new gitService_1.NodeGitService();
+        const graphProvider = new nxGraphProvide_1.NxGraphProvider();
+        const configProvider = new quarkConfigProvider_1.QuarkConfigProvider();
+        const config = configProvider.getConfig();
+        const { masterBranch } = config.release;
+        // ── Platform adapters (shared across release + dev-publish) ────
+        const nodeReleaseAdapter = new node_release_adapter_1.NodeReleaseAdapter(graphProvider, config, logger);
+        const releaseAdapters = [
+            nodeReleaseAdapter,
+            new maven_release_adapter_1.MavenReleaseAdapter(graphProvider, config, logger),
+        ];
+        // ── Unfreeze ───────────────────────────────────────────────────
+        const releaseMapStore = new git_release_map_store_1.GitReleaseMapStore(gitService);
+        const unfreezeApp = new unfreeze_application_1.UnfreezeApplication(graphProvider, releaseMapStore, nodeReleaseAdapter, logger, masterBranch);
+        // ── Release ────────────────────────────────────────────────────
+        const topoSorter = new topological_sorting_1.TopoSorter();
+        const releaseApp = new release_application_1.ReleaseApplication(logger, gitService, graphProvider, releaseAdapters, topoSorter, releaseMapStore, masterBranch);
+        // ── Dev Publish (same adapters) ────────────────────────────────
+        const publishDevApp = new publish_dev_application_1.PublishDevApplication(logger, gitService, graphProvider, releaseAdapters, masterBranch);
+        // ── Prod Publish ────────────────────────────────────────────────
+        const prodPublishAdapters = [
+            new node_prod_publish_adapter_1.NodeProdPublishAdapter(config, logger),
+            new maven_prod_publish_adapter_1.MavenProdPublishAdapter(config, logger),
+        ];
+        const prodPublishApp = new prod_publish_application_1.ProdPublishApplication(logger, gitService, graphProvider, prodPublishAdapters, topoSorter, config);
+        // ── Commands ───────────────────────────────────────────────────
+        const commands = [
+            new publish_dev_commands_1.PublishDevCommand(publishDevApp),
+            new release_commands_1.ReleaseCommand(releaseApp),
+            new unfreeze_commands_1.UnfreezeCommand(unfreezeApp),
+            new prod_publish_commands_1.ProdPublishCommand(prodPublishApp),
+        ];
+        return new CliContainer(commands);
+    }
+    constructor(commands) {
+        this.commands = commands;
+    }
+    register(program) {
+        this.commands.forEach((command) => {
+            command.register(program);
+        });
+    }
+}
+exports.CliContainer = CliContainer;

package/dist/cli/cliCommand.js

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

package/dist/cli/cliContainers.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliContainer = void 0;
+const buildCommands_1 = require("./commands/buildCommands");
+const devCommands_1 = require("./commands/devCommands");
+const publishDevCommands_1 = require("./commands/publishDevCommands");
+const watchStaticCommands_1 = require("./commands/watchStaticCommands");
+const copyStaticCommands_1 = require("./commands/copyStaticCommands");
+const buildApplication_1 = require("../app/buildApplication");
+const devApplication_1 = require("../app/devApplication");
+const publishDevApplication_1 = require("../app/publishDevApplication");
+const watchStaticApplication_1 = require("../app/watchStaticApplication");
+const copyStaticApplication_1 = require("../app/copyStaticApplication");
+const consoleLogger_1 = require("../infrastructure/logging/consoleLogger");
+const nodeProcessRunner_1 = require("../infrastructure/process/nodeProcessRunner");
+const gitService_1 = require("../infrastructure/git/gitService");
+const releaseCommands_1 = require("./commands/releaseCommands");
+const releaseApplication_1 = require("../app/releaseApplication");
+const nxGraphProvide_1 = require("../infrastructure/graph/nxGraphProvide");
+const node_release_adapter_1 = require("../infrastructure/adapters/node-release-adapter/node-release-adapter");
+const maven_release_adapter_1 = require("../infrastructure/adapters/maven-release-adapter");
+const topological_sorting_1 = require("../domain/topological-sorting");
+const quarkConfigProvider_1 = require("../infrastructure/config/quarkConfigProvider");
+class CliContainer {
+    static create() {
+        //  Infrastructure (created ONCE)
+        const logger = new consoleLogger_1.ConsoleLogger();
+        const processRunner = new nodeProcessRunner_1.NodeProcessRunner();
+        const gitService = new gitService_1.NodeGitService();
+        const graphProvider = new nxGraphProvide_1.NxGraphProvider();
+        const configProvider = new quarkConfigProvider_1.QuarkConfigProvider();
+        const config = configProvider.getConfig();
+        //  Applications (inject dependencies)
+        const buildApp = new buildApplication_1.BuildApplication(logger, processRunner);
+        const devApp = new devApplication_1.DevApplication(logger, processRunner);
+        const publishDevApp = new publishDevApplication_1.PublishDevApplication(logger);
+        const watchStaticApp = new watchStaticApplication_1.WatchStaticApplication(logger, processRunner);
+        const copyStaticApp = new copyStaticApplication_1.CopyStaticApplication(logger, processRunner);
+        const topoSorter = new topological_sorting_1.TopoSorter();
+        const releaseAdapters = [new node_release_adapter_1.NodeReleaseAdapter(gitService, graphProvider, config), new maven_release_adapter_1.MavenReleaseAdapter(gitService, graphProvider, config)];
+        const releaseApp = new releaseApplication_1.ReleaseApplication(logger, gitService, graphProvider, releaseAdapters, topoSorter, config.release.masterBranch);
+        //  Commands
+        const commands = [
+            new buildCommands_1.BuildCommand(buildApp),
+            new devCommands_1.DevCommand(devApp),
+            new publishDevCommands_1.PublishDevCommand(publishDevApp),
+            new watchStaticCommands_1.WatchStaticCommand(watchStaticApp),
+            new copyStaticCommands_1.CopyStaticCommand(copyStaticApp),
+            new releaseCommands_1.ReleaseCommand(releaseApp),
+        ];
+        return new CliContainer(commands);
+    }
+    constructor(commands) {
+        this.commands = commands;
+    }
+    register(program) {
+        this.commands.forEach((command) => {
+            command.register(program);
+        });
+    }
+}
+exports.CliContainer = CliContainer;

package/dist/cli/commands/buildCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildCommand = void 0;
+class BuildCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("build")
+            .description("Run build process")
+            .action(async () => {
+            await this.app.execute({ skipStatic: false });
+        });
+    }
+}
+exports.BuildCommand = BuildCommand;

package/dist/cli/commands/copyStaticCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyStaticCommand = void 0;
+class CopyStaticCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("copy-static")
+            .description("Copy static assets")
+            .action(async () => {
+            await this.app.execute();
+        });
+    }
+}
+exports.CopyStaticCommand = CopyStaticCommand;

package/dist/cli/commands/devCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevCommand = void 0;
+class DevCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("dev")
+            .description("Run development environment")
+            .action(async () => {
+            await this.app.execute({ skipInitialCopy: false });
+        });
+    }
+}
+exports.DevCommand = DevCommand;

package/dist/cli/commands/prod-publish-commands.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProdPublishCommand = void 0;
+class ProdPublishCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("prod-publish")
+            .description("Publish changed packages to the production registry based on map.json diff between git tags")
+            .option("--tag <tag>", "Target git tag to compare against (defaults to latest)")
+            .action(async (options) => {
+            await this.app.execute(options.tag);
+        });
+    }
+}
+exports.ProdPublishCommand = ProdPublishCommand;

package/dist/cli/commands/publish-dev-commands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishDevCommand = void 0;
+class PublishDevCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("publish-dev")
+            .description("Publish a package to the dev registry as an alpha version")
+            .action(async () => {
+            await this.app.execute();
+        });
+    }
+}
+exports.PublishDevCommand = PublishDevCommand;

package/dist/cli/commands/publishDevCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PublishDevCommand = void 0;
+class PublishDevCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("publish-dev")
+            .description("Publish development build")
+            .action(async () => {
+            await this.app.execute();
+        });
+    }
+}
+exports.PublishDevCommand = PublishDevCommand;

package/dist/cli/commands/release-commands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseCommand = void 0;
+class ReleaseCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("release")
+            .description("Run release process")
+            .action(async () => {
+            await this.app.execute();
+        });
+    }
+}
+exports.ReleaseCommand = ReleaseCommand;

package/dist/cli/commands/releaseCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReleaseCommand = void 0;
+class ReleaseCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("release")
+            .description("Run release process")
+            .action(async () => {
+            await this.app.execute();
+        });
+    }
+}
+exports.ReleaseCommand = ReleaseCommand;

package/dist/cli/commands/relesaeCommand.js

@@ -0,0 +1,15 @@
+"use strict";
+// import { Command } from "commander";
+// import { CliCommand } from "../CliCommand";
+// import { ReleaseApplication } from "../../app/ReleaseApplication";
+// export class ReleaseCommand implements CliCommand {
+//   constructor(private readonly app: ReleaseApplication) {}
+//   register(program: Command): void {
+//     program
+//       .command("release")
+//       .description("Run release process")
+//       .action(async () => {
+//         await this.app.execute();
+//       });
+//   }
+// }

package/dist/cli/commands/unfreeze-commands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnfreezeCommand = void 0;
+class UnfreezeCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("unfreeze <package-name>")
+            .description("Unfreeze a package and restore its dependency versions to workspace:*")
+            .action(async (packageName) => {
+            await this.app.execute(packageName);
+        });
+    }
+}
+exports.UnfreezeCommand = UnfreezeCommand;

package/dist/cli/commands/watchStaticCommands.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchStaticCommand = void 0;
+class WatchStaticCommand {
+    constructor(app) {
+        this.app = app;
+    }
+    register(program) {
+        program
+            .command("watch-static")
+            .description("Watch and update static assets")
+            .action(async () => {
+            await this.app.execute();
+        });
+    }
+}
+exports.WatchStaticCommand = WatchStaticCommand;

package/dist/cli/program.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProgram = createProgram;
+const commander_1 = require("commander");
+const cli_containers_1 = require("./cli-containers");
+const pkg = require("../../package.json");
+function createProgram() {
+    const program = new commander_1.Command();
+    program
+        .name("quark")
+        .description("Polyglot build & release orchestration tool")
+        .version(pkg.version);
+    const container = cli_containers_1.CliContainer.create();
+    container.register(program);
+    return program;
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+export declare const publish_dev: Command;
+export declare const publish_prod: Command;
+export declare const release: Command;
+export declare const copyStatic: Command;
+export declare const watchStatic: Command;
+export declare const build: Command;
+export declare const dev: Command;