ph-cmd 0.41.5 → 0.43.0-dev.0

package/dist/src/commands/__tests__/update.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=update.test.d.ts.map

package/dist/src/commands/__tests__/update.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.test.d.ts","sourceRoot":"","sources":["../../../../src/commands/__tests__/update.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/__tests__/update.test.js

@@ -0,0 +1,150 @@
+import { Command } from "commander";
+import * as childProcess from "node:child_process";
+import * as fs from "node:fs";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { findContainerDirectory, getPackageManagerFromLockfile, getProjectInfo, } from "../../utils.js";
+import { updateCommand } from "../update.js";
+// Mock dependencies
+vi.mock("node:fs");
+vi.mock("node:child_process");
+// Import installDependency after mocking
+import { installDependency } from "../../utils.js";
+vi.mock("../../utils.js", () => ({
+    packageManagers: {
+        pnpm: {
+            buildAffected: "pnpm run build:affected",
+            updateCommand: "pnpm update {{dependency}}",
+            installCommand: "pnpm install {{dependency}}",
+            workspaceOption: "--workspace-root",
+            lockfile: "pnpm-lock.yaml",
+        },
+    },
+    getPackageManagerFromLockfile: vi.fn(),
+    getProjectInfo: vi.fn(),
+    findContainerDirectory: vi.fn(),
+    installDependency: vi.fn(),
+}));
+describe("updateCommand", () => {
+    let program;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.restoreAllMocks();
+        program = new Command();
+        updateCommand(program);
+        // Mock utils functions
+        vi.mocked(getPackageManagerFromLockfile).mockReturnValue("pnpm");
+        vi.mocked(getProjectInfo).mockReturnValue({
+            path: "/test/project",
+        });
+        vi.mocked(findContainerDirectory).mockReturnValue("/user/powerhouse/monorepo");
+        // Mock fs.readFileSync for package.json
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "@powerhousedao/builder-tools": "link:/user/powerhouse/monorepo/packages/builder-tools",
+                    },
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        // Mock fs.existsSync to return true for test paths
+        vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+            const validPaths = [
+                "/test/project",
+                "/user/powerhouse/monorepo",
+                "/test/project/package.json",
+                path.join("/test/project", "package.json"),
+                path.join("/test/project", "pnpm-lock.yaml"),
+            ];
+            return validPaths.includes(p);
+        });
+        // Mock execSync
+        vi.mocked(childProcess.execSync).mockReturnValue(Buffer.from(""));
+        // Mock installDependency
+        vi.mocked(installDependency).mockImplementation(() => { });
+    });
+    it("should register the update command with correct options", () => {
+        const cmd = program.commands.find((c) => c.name() === "update");
+        expect(cmd).toBeDefined();
+        expect(cmd?.description()).toContain("update your dependencies");
+        // Get options from the command definition, not from parsed args
+        const options = cmd?.options.map((opt) => opt.attributeName());
+        expect(options).toContain("force");
+        expect(options).toContain("packageManager");
+        expect(options).toContain("debug");
+    });
+    it("should execute update command with local dependencies", async () => {
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test"]);
+        expect(childProcess.execSync).toHaveBeenCalledWith("pnpm run build:affected", expect.objectContaining({
+            stdio: "inherit",
+            cwd: "/user/powerhouse/monorepo",
+        }));
+    });
+    it("should execute update command with force flag", async () => {
+        // Mock fs.readFileSync for the specific package.json read in this test
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {},
+                    devDependencies: {},
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        // Mock fs.existsSync to return true for test paths
+        vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+            const validPaths = [
+                "/test/project",
+                "/user/powerhouse/monorepo",
+                "/test/project/package.json",
+                path.join("/test/project", "package.json"),
+                path.join("/test/project", "pnpm-lock.yaml"),
+            ];
+            return validPaths.includes(p);
+        });
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test", "--force", "prod"]);
+        // When using --force, it should call installDependency with the latest versions
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "@powerhousedao/common@latest",
+            "@powerhousedao/design-system@latest",
+            "@powerhousedao/reactor-browser@latest",
+            "@powerhousedao/builder-tools@latest",
+            "@powerhousedao/codegen@latest",
+            "@powerhousedao/reactor-api@latest",
+            "@powerhousedao/reactor-local@latest",
+            "@powerhousedao/scalars@latest",
+            "@powerhousedao/ph-cli@latest",
+        ], "/test/project");
+    });
+    it("should handle debug flag", async () => {
+        const consoleSpy = vi.spyOn(console, "log");
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test", "--debug"]);
+        expect(consoleSpy).toHaveBeenCalledWith(">>> options", expect.any(Object));
+    });
+    it("should execute update command without local dependencies", async () => {
+        // Mock fs.readFileSync to return package.json without local dependencies
+        vi.mocked(fs.readFileSync).mockImplementation((filePath) => {
+            if (filePath === path.join("/test/project", "package.json")) {
+                return JSON.stringify({
+                    dependencies: {
+                        "@powerhousedao/builder-tools": "^0.40.0",
+                        "@powerhousedao/common": "^0.40.0",
+                    },
+                });
+            }
+            throw new Error(`Unexpected file read: ${String(filePath)}`);
+        });
+        const cmd = program.commands.find((c) => c.name() === "update");
+        await cmd?.parseAsync(["node", "test"]);
+        // Should call execSync with pnpm update for all dependencies
+        expect(childProcess.execSync).toHaveBeenCalledWith("pnpm update @powerhousedao/common @powerhousedao/design-system @powerhousedao/reactor-browser @powerhousedao/builder-tools @powerhousedao/codegen @powerhousedao/reactor-api @powerhousedao/reactor-local @powerhousedao/scalars @powerhousedao/ph-cli", expect.objectContaining({
+            stdio: "inherit",
+            cwd: "/test/project",
+        }));
+    });
+});

package/dist/src/commands/__tests__/use.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use.test.d.ts.map

package/dist/src/commands/__tests__/use.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use.test.d.ts","sourceRoot":"","sources":["../../../../src/commands/__tests__/use.test.ts"],"names":[],"mappings":""}

package/dist/src/commands/__tests__/use.test.js

@@ -0,0 +1,128 @@
+import { Command } from "commander";
+import * as fs from "node:fs";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { getPackageManagerFromLockfile, getProjectInfo, } from "../../utils.js";
+import { useCommand } from "../use.js";
+// Mock dependencies
+vi.mock("node:fs");
+// Import installDependency after mocking
+import { installDependency } from "../../utils.js";
+vi.mock("../../utils.js", () => ({
+    packageManagers: {
+        pnpm: {
+            buildAffected: "pnpm run build:affected",
+            updateCommand: "pnpm update {{dependency}}",
+            installCommand: "pnpm install {{dependency}}",
+            workspaceOption: "--workspace-root",
+            lockfile: "pnpm-lock.yaml",
+        },
+    },
+    getPackageManagerFromLockfile: vi.fn(),
+    getProjectInfo: vi.fn(),
+    installDependency: vi.fn(),
+}));
+describe("useCommand", () => {
+    let program;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.restoreAllMocks();
+        program = new Command();
+        useCommand(program);
+        // Mock utils functions
+        vi.mocked(getPackageManagerFromLockfile).mockReturnValue("pnpm");
+        vi.mocked(getProjectInfo).mockReturnValue({
+            path: "/test/project",
+        });
+        // Mock fs.existsSync to return true for test paths
+        vi.spyOn(fs, "existsSync").mockImplementation((p) => {
+            const validPaths = [
+                "/test/project",
+                "/test/project/package.json",
+                path.join("/test/project", "package.json"),
+                path.join("/test/project", "pnpm-lock.yaml"),
+            ];
+            return validPaths.includes(p);
+        });
+        // Mock installDependency
+        vi.mocked(installDependency).mockImplementation(() => { });
+    });
+    it("should register the use command with correct options", () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        expect(cmd).toBeDefined();
+        expect(cmd?.description()).toContain("change your environment");
+        const options = cmd?.options.map((opt) => opt.attributeName());
+        expect(options).toContain("dev");
+        expect(options).toContain("prod");
+        expect(options).toContain("latest");
+        expect(options).toContain("local");
+        expect(options).toContain("packageManager");
+        expect(options).toContain("debug");
+    });
+    it("should execute use command with dev environment", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--dev"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "@powerhousedao/common@dev",
+            "@powerhousedao/design-system@dev",
+            "@powerhousedao/reactor-browser@dev",
+            "@powerhousedao/builder-tools@dev",
+            "@powerhousedao/codegen@dev",
+            "@powerhousedao/reactor-api@dev",
+            "@powerhousedao/reactor-local@dev",
+            "@powerhousedao/scalars@dev",
+            "@powerhousedao/ph-cli@dev",
+        ], "/test/project");
+    });
+    it("should execute use command with prod environment", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--prod"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "@powerhousedao/common@latest",
+            "@powerhousedao/design-system@latest",
+            "@powerhousedao/reactor-browser@latest",
+            "@powerhousedao/builder-tools@latest",
+            "@powerhousedao/codegen@latest",
+            "@powerhousedao/reactor-api@latest",
+            "@powerhousedao/reactor-local@latest",
+            "@powerhousedao/scalars@latest",
+            "@powerhousedao/ph-cli@latest",
+        ], "/test/project");
+    });
+    it("should execute use command with local environment", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--local", "/path/to/local"]);
+        expect(installDependency).toHaveBeenCalledWith("pnpm", [
+            "/path/to/local/packages/common",
+            "/path/to/local/packages/design-system",
+            "/path/to/local/packages/reactor-browser",
+            "/path/to/local/packages/builder-tools",
+            "/path/to/local/packages/codegen",
+            "/path/to/local/packages/reactor-api",
+            "/path/to/local/packages/reactor-local",
+            "/path/to/local/packages/scalars",
+            "/path/to/local/clis/ph-cli",
+        ], "/test/project");
+    });
+    it("should handle debug flag", async () => {
+        const consoleSpy = vi.spyOn(console, "log");
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync(["node", "test", "--dev", "--debug"]);
+        expect(consoleSpy).toHaveBeenCalledWith(">>> options", expect.any(Object));
+    });
+    it("should throw error when no environment is specified", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await expect(cmd?.parseAsync(["node", "test"])).rejects.toThrow("❌ Please specify an environment");
+    });
+    it("should use specified package manager", async () => {
+        const cmd = program.commands.find((c) => c.name() === "use");
+        await cmd?.parseAsync([
+            "node",
+            "test",
+            "--dev",
+            "--package-manager",
+            "npm",
+        ]);
+        expect(installDependency).toHaveBeenCalledWith("npm", expect.any(Array), "/test/project");
+    });
+});

package/dist/src/commands/index.d.ts

@@ -2,6 +2,8 @@ import { type Command } from "commander";
 import { setupGlobalsCommand } from "./setup-globals.js";
 export declare const commands: (typeof setupGlobalsCommand)[];
 export default function registerCommands(program: Command): void;
-export * from "./setup-globals.js";
 export * from "./init.js";
+export * from "./setup-globals.js";
+export * from "./update.js";
+export * from "./use.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAGzD,eAAO,MAAM,QAAQ,gCAAqC,CAAC;AAE3D,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAExD;AAED,cAAc,oBAAoB,CAAC;AACnC,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIzD,eAAO,MAAM,QAAQ,gCAKpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAExD;AAED,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}

package/dist/src/commands/index.js

@@ -1,8 +1,17 @@
-import { setupGlobalsCommand } from "./setup-globals.js";
 import { initCommand } from "./init.js";
-export const commands = [setupGlobalsCommand, initCommand];
+import { setupGlobalsCommand } from "./setup-globals.js";
+import { updateCommand } from "./update.js";
+import { useCommand } from "./use.js";
+export const commands = [
+    setupGlobalsCommand,
+    initCommand,
+    useCommand,
+    updateCommand,
+];
 export default function registerCommands(program) {
     commands.forEach((command) => command(program));
 }
-export * from "./setup-globals.js";
 export * from "./init.js";
+export * from "./setup-globals.js";
+export * from "./update.js";
+export * from "./use.js";

package/dist/src/commands/update.d.ts

@@ -0,0 +1,11 @@
+import { type Command } from "commander";
+import { type CommandActionType } from "../types.js";
+export declare const update: CommandActionType<[
+    {
+        force?: string;
+        debug?: boolean;
+        packageManager?: string;
+    }
+]>;
+export declare function updateCommand(program: Command): void;
+//# sourceMappingURL=update.d.ts.map

package/dist/src/commands/update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../src/commands/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAqErD,eAAO,MAAM,MAAM,EAAE,iBAAiB,CACpC;IACE;QACE,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CAmDF,CAAC;AAEF,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,QA4B7C"}

package/dist/src/commands/update.js

@@ -0,0 +1,88 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { findContainerDirectory, getPackageManagerFromLockfile, getProjectInfo, packageManagers, } from "../utils.js";
+import { ENV_MAP, PH_PROJECT_DEPENDENCIES, updatePackageJson, } from "./use.js";
+const FILE_PROTOCOL = "file:";
+const LINK_PROTOCOL = "link:";
+const MONOREPO_FILE = "pnpm-workspace.yaml";
+const buildLocalDependencies = (localDependencyPath, pkgManagerName) => {
+    const monorepoPath = findContainerDirectory(localDependencyPath, MONOREPO_FILE);
+    if (!monorepoPath) {
+        throw new Error("Monorepo root directory not found");
+    }
+    const pkgManager = packageManagers[pkgManagerName];
+    console.log("⚙️ Building local dependencies...");
+    execSync(pkgManager.buildAffected, {
+        stdio: "inherit",
+        cwd: monorepoPath,
+    });
+};
+const getLocalDependencyPath = (projectPath) => {
+    // read package json from projectInfo.path
+    const packageJson = JSON.parse(fs.readFileSync(path.join(projectPath, "package.json"), "utf-8"));
+    // filter dependencies
+    const filteredDependencies = Object.entries({
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+    }).filter(([name]) => PH_PROJECT_DEPENDENCIES.includes(name));
+    const [_, localDependencyPath] = filteredDependencies.find(([_, version]) => version.startsWith(FILE_PROTOCOL) || version.startsWith(LINK_PROTOCOL)) || [null, null];
+    if (!localDependencyPath)
+        return null;
+    return localDependencyPath
+        .replace(FILE_PROTOCOL, "")
+        .replace(LINK_PROTOCOL, "");
+};
+export const update = (options) => {
+    const { force, packageManager, debug } = options;
+    if (debug) {
+        console.log(">>> options", options);
+    }
+    const projectInfo = getProjectInfo();
+    const pkgManagerName = (packageManager ||
+        getPackageManagerFromLockfile(projectInfo.path));
+    const localDependencyPath = getLocalDependencyPath(projectInfo.path);
+    if (debug) {
+        console.log(">>> projectInfo", projectInfo);
+        console.log(">>> pkgManagerName", pkgManagerName);
+        console.log(">>> localDependencyPath", localDependencyPath);
+    }
+    if (localDependencyPath) {
+        buildLocalDependencies(localDependencyPath, pkgManagerName);
+    }
+    if (force) {
+        const supportedEnvs = Object.keys(ENV_MAP);
+        if (!supportedEnvs.includes(force)) {
+            throw new Error(`Invalid environment: ${force}, supported envs: ${supportedEnvs.join(", ")}`);
+        }
+        const env = force;
+        updatePackageJson(env, undefined, pkgManagerName, debug);
+        return;
+    }
+    const pkgManager = packageManagers[pkgManagerName];
+    const deps = PH_PROJECT_DEPENDENCIES.join(" ");
+    const updateCommand = pkgManager.updateCommand.replace("{{dependency}}", deps);
+    const commandOptions = { cwd: projectInfo.path };
+    execSync(updateCommand, {
+        stdio: "inherit",
+        ...commandOptions,
+    });
+};
+export function updateCommand(program) {
+    program
+        .command("update")
+        .description("Allows you to update your dependencies to the latest version based on the specified range in package.json. If you want to update to the latest available version, use the --force flag.")
+        .option("--force <env>", "Force update to latest available version for the environment specified (dev, prod, latest)")
+        .option("--package-manager <packageManager>", "force package manager to use")
+        .option("--debug", "Show additional logs")
+        .addHelpText("after", `
+Examples:
+  $ ph update                          # Update dependencies based on package.json ranges
+  $ ph update --force dev              # Force update to latest dev version available
+  $ ph update --force prod             # Force update to latest stable version available (same as latest)
+  $ ph update --force latest           # Force update to latest stable version available (same as prod)
+  $ ph update --package-manager pnpm   # Specify package manager to use
+  $ ph update --debug                  # Show debug information during update
+    `)
+        .action(update);
+}

package/dist/src/commands/use.d.ts

@@ -0,0 +1,27 @@
+import { type Command } from "commander";
+import { type CommandActionType } from "../types.js";
+import { type PackageManager } from "../utils.js";
+export declare const ORG = "@powerhousedao";
+export declare const CLIS: string[];
+export declare const PACKAGES: string[];
+export declare const PH_PROJECT_DEPENDENCIES: string[];
+export declare const PH_PROJECT_LOCAL_DEPENDENCIES: string[];
+export declare const ENV_MAP: {
+    dev: string;
+    prod: string;
+    latest: string;
+};
+export type Environment = keyof typeof ENV_MAP;
+export declare const updatePackageJson: (env: Environment, localPath?: string, packageManager?: PackageManager, debug?: boolean) => void;
+export declare const use: CommandActionType<[
+    {
+        dev?: boolean;
+        prod?: boolean;
+        local?: string;
+        debug?: boolean;
+        latest?: boolean;
+        packageManager?: string;
+    }
+]>;
+export declare function useCommand(program: Command): void;
+//# sourceMappingURL=use.d.ts.map

package/dist/src/commands/use.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use.d.ts","sourceRoot":"","sources":["../../../src/commands/use.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,aAAa,CAAC;AAErB,eAAO,MAAM,GAAG,mBAAmB,CAAC;AACpC,eAAO,MAAM,IAAI,UAAa,CAAC;AAC/B,eAAO,MAAM,QAAQ,UASpB,CAAC;AAEF,eAAO,MAAM,uBAAuB,UAGnC,CAAC;AAEF,eAAO,MAAM,6BAA6B,UAGzC,CAAC;AAEF,eAAO,MAAM,OAAO;;;;CAInB,CAAC;AAGF,MAAM,MAAM,WAAW,GAAG,MAAM,OAAO,OAAO,CAAC;AAE/C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,WAAW,EAChB,YAAY,MAAM,EAClB,iBAAiB,cAAc,EAC/B,QAAQ,OAAO,SAuChB,CAAC;AAEF,eAAO,MAAM,GAAG,EAAE,iBAAiB,CACjC;IACE;QACE,GAAG,CAAC,EAAE,OAAO,CAAC;QACd,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CAwBF,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAmB1C"}

package/dist/src/commands/use.js

@@ -0,0 +1,81 @@
+import path from "node:path";
+import { getPackageManagerFromLockfile, getProjectInfo, installDependency, } from "../utils.js";
+export const ORG = "@powerhousedao";
+export const CLIS = ["ph-cli"];
+export const PACKAGES = [
+    "common",
+    "design-system",
+    "reactor-browser",
+    "builder-tools",
+    "codegen",
+    "reactor-api",
+    "reactor-local",
+    "scalars",
+];
+export const PH_PROJECT_DEPENDENCIES = [
+    ...PACKAGES.map((dependency) => `${ORG}/${dependency}`),
+    ...CLIS.map((dependency) => `${ORG}/${dependency}`),
+];
+export const PH_PROJECT_LOCAL_DEPENDENCIES = [
+    ...PACKAGES.map((dependency) => path.join("packages", dependency)),
+    ...CLIS.map((dependency) => path.join("clis", dependency)),
+];
+export const ENV_MAP = {
+    dev: "dev",
+    prod: "latest",
+    latest: "latest",
+};
+export const updatePackageJson = (env, localPath, packageManager, debug) => {
+    const dependencies = [];
+    const projectInfo = getProjectInfo();
+    const pkgManager = packageManager || getPackageManagerFromLockfile(projectInfo.path);
+    if (debug) {
+        console.log(">>> projectInfo", projectInfo);
+        console.log(">>> pkgManager", pkgManager);
+    }
+    if (localPath) {
+        const localPathDependencies = PH_PROJECT_LOCAL_DEPENDENCIES.map((dependency) => path.join(localPath, dependency));
+        dependencies.push(...localPathDependencies);
+    }
+    else {
+        dependencies.push(...PH_PROJECT_DEPENDENCIES.map((dependency) => `${dependency}@${ENV_MAP[env]}`));
+    }
+    if (debug) {
+        console.log(">>> dependencies", dependencies);
+    }
+    try {
+        console.log("⚙️ Updating dependencies...");
+        installDependency(pkgManager, dependencies, projectInfo.path);
+        console.log("✅ Dependencies updated successfully");
+    }
+    catch (error) {
+        console.error("❌ Failed to update dependencies");
+        throw error;
+    }
+};
+export const use = (options) => {
+    const { dev, prod, latest, local, packageManager, debug } = options;
+    const develop = dev ? "dev" : null;
+    const production = prod ? "prod" : null;
+    const latestEnv = latest ? "latest" : null;
+    const env = develop || production || latestEnv;
+    if (debug) {
+        console.log(">>> options", options);
+    }
+    if (!env && !local) {
+        throw new Error("❌ Please specify an environment");
+    }
+    updatePackageJson(env || "dev", local, packageManager, debug);
+};
+export function useCommand(program) {
+    program
+        .command("use")
+        .description("Allows you to change your environment (latest, development, production, local)")
+        .option("-d, --dev", "Use development environment")
+        .option("-p, --prod", "Use production environment")
+        .option("--latest", "Use latest environment")
+        .option("-l, --local <localPath>", "Use local environment (you have to specify the path to the local environment)")
+        .option("--package-manager <packageManager>", "force package manager to use")
+        .option("--debug", "Show additional logs")
+        .action(use);
+}

package/dist/src/utils.d.ts

@@ -7,27 +7,43 @@ export declare const PH_GLOBAL_PROJECT_NAME = ".ph";
 export declare const POWERHOUSE_GLOBAL_DIR: string;
 export declare const packageManagers: {
     readonly bun: {
+        readonly installCommand: "bun add {{dependency}}";
         readonly execCommand: "bun ph-cli {{arguments}}";
         readonly execScript: "bun {{arguments}}";
         readonly lockfile: "bun.lock";
         readonly globalPathRegexp: RegExp;
+        readonly updateCommand: "bun update {{dependency}}";
+        readonly buildAffected: "bun run build:affected";
+        readonly workspaceOption: "";
     };
     readonly pnpm: {
+        readonly installCommand: "pnpm add {{dependency}}";
         readonly execCommand: "pnpm exec ph-cli {{arguments}}";
         readonly execScript: "pnpm {{arguments}}";
         readonly lockfile: "pnpm-lock.yaml";
         readonly globalPathRegexp: RegExp;
+        readonly updateCommand: "pnpm update {{dependency}}";
+        readonly buildAffected: "pnpm run build:affected";
+        readonly workspaceOption: "--workspace-root";
     };
     readonly yarn: {
+        readonly installCommand: "yarn add {{dependency}}";
         readonly execCommand: "yarn ph-cli {{arguments}}";
         readonly execScript: "yarn {{arguments}}";
         readonly lockfile: "yarn.lock";
         readonly globalPathRegexp: RegExp;
+        readonly updateCommand: "yarn upgrade {{dependency}}";
+        readonly buildAffected: "yarn run build:affected";
+        readonly workspaceOption: "-W";
     };
     readonly npm: {
+        readonly installCommand: "npm install {{dependency}}";
         readonly execCommand: "npx ph-cli {{arguments}}";
         readonly execScript: "npm run {{arguments}}";
         readonly lockfile: "package-lock.json";
+        readonly updateCommand: "npm update {{dependency}} --save";
+        readonly buildAffected: "npm run build:affected";
+        readonly workspaceOption: "";
     };
 };
 export type ProjectInfo = {
@@ -43,5 +59,23 @@ export declare function getPackageManagerFromPath(dir: string): PackageManager;
 export declare function getPackageManagerFromLockfile(dir: string): PackageManager;
 export declare function getProjectInfo(debug?: boolean): ProjectInfo;
 export declare function forwardPHCommand(packageManager: PackageManager, projectPath: string, args: string, debug?: boolean): void;
+/**
+ * Recursively searches for a specific file by traversing up the directory tree.
+ * Starting from the given path, it checks each parent directory until it finds
+ * the target file or reaches the root directory.
+ *
+ * @param startPath - The absolute path of the directory to start searching from
+ * @param targetFile - The name of the file to search for (e.g., 'package.json', 'pnpm-workspace.yaml')
+ * @returns The absolute path of the directory containing the target file, or null if not found
+ *
+ * @example
+ * // Find the workspace root directory
+ * const workspaceRoot = findContainerDirectory('/path/to/project/src', 'pnpm-workspace.yaml');
+ *
+ * // Find the nearest package.json
+ * const packageDir = findContainerDirectory('/path/to/project/src/components', 'package.json');
+ */
+export declare const findContainerDirectory: (startPath: string, targetFile: string) => string | null;
+export declare function installDependency(packageManager: PackageManager, dependencies: string[], projectPath: string, workspace?: boolean): void;
 export {};
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,QAAkB,CAAC;AAC3C,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,eAAe,UAiB3B,CAAC;AACF,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAC/D,eAAO,MAAM,QAAQ,QAAY,CAAC;AAClC,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAC5C,eAAO,MAAM,qBAAqB,QAGjC,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;CAwBlB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7D,KAAK,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAE/C,wBAAgB,qBAAqB,YAEpC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,WAI9C;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,cAAsC,iBAevD;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAYrE;AAED,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAUzE;AAED,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,WAAW,CAoB3D;AAED,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,OAAO,QAmBhB"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,WAAW,QAAkB,CAAC;AAC3C,eAAO,MAAM,MAAM,WAAW,CAAC;AAC/B,eAAO,MAAM,eAAe,UAiB3B,CAAC;AACF,eAAO,MAAM,sBAAsB,2BAA2B,CAAC;AAC/D,eAAO,MAAM,QAAQ,QAAY,CAAC;AAClC,eAAO,MAAM,sBAAsB,QAAQ,CAAC;AAC5C,eAAO,MAAM,qBAAqB,QAGjC,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwClB,CAAC;AAEX,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE7D,KAAK,cAAc,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;AAE/C,wBAAgB,qBAAqB,YAEpC;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,WAI9C;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,cAAc,GAAE,cAAsC,iBAevD;AAED,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAYrE;AAED,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAUzE;AAED,wBAAgB,cAAc,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,WAAW,CAoB3D;AAED,wBAAgB,gBAAgB,CAC9B,cAAc,EAAE,cAAc,EAC9B,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,OAAO,QAmBhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GACjC,WAAW,MAAM,EACjB,YAAY,MAAM,KACjB,MAAM,GAAG,IAeX,CAAC;AAEF,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,cAAc,EAC9B,YAAY,EAAE,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,OAAO,QAuBpB"}