@powerhousedao/ph-cli 0.33.2-dev.0 → 0.34.2-dev.0

package/dist/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "@powerhousedao/ph-cli",
+    "version": "0.34.2-dev.0",
+    "description": "",
+    "license": "AGPL-3.0-only",
+    "type": "module",
+    "publishConfig": {
+        "access": "public"
+    },
+    "bin": {
+        "ph-cli": "dist/src/cli.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc --build",
+        "dev": "concurrently -P 'pnpm -w run build:tsc --watch' 'nodemon --watch \"../..\" -e ts,tsx,js,json dist/src/cli.js -- {@}' --",
+        "prepublishOnly": "npm run build",
+        "lint": "eslint .",
+        "lint:nx": "eslint . --fix --quiet",
+        "lint:fix": "eslint --fix"
+    },
+    "keywords": [],
+    "author": "",
+    "devDependencies": {
+        "@powerhousedao/analytics-engine-core": "^0.3.2",
+        "@powerhousedao/analytics-engine-graphql": "^0.2.2",
+        "@powerhousedao/analytics-engine-pg": "^0.4.0",
+        "concurrently": "^9.1.2",
+        "document-drive": "workspace:*",
+        "graphql-tag": "^2.12.6",
+        "knex": "^3.1.0",
+        "luxon": "^3.5.0",
+        "nodemon": "^3.1.9"
+    },
+    "dependencies": {
+        "@powerhousedao/builder-tools": "workspace:*",
+        "@powerhousedao/codegen": "workspace:*",
+        "@powerhousedao/config": "workspace:*",
+        "@powerhousedao/connect": "workspace:*",
+        "@powerhousedao/design-system": "workspace:*",
+        "@powerhousedao/reactor-local": "workspace:*",
+        "@powerhousedao/scalars": "workspace:*",
+        "colorette": "^2.0.20",
+        "commander": "^12.1.0",
+        "document-model": "workspace:*",
+        "graphql": "^16.9.0",
+        "pm2": "^5.4.3"
+    }
+}

package/dist/src/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

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

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

package/dist/src/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import registerCommands from "./commands/index.js";
+const program = new Command();
+program
+    .name("ph-cli")
+    .description("CLI tool for Powerhouse DAO")
+    .version("1.0.0");
+registerCommands(program);
+program.parse(process.argv);

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

@@ -0,0 +1,6 @@
+import { ConnectStudioOptions } from "@powerhousedao/builder-tools/connect-studio";
+import { Command } from "commander";
+export type ConnectOptions = ConnectStudioOptions;
+export declare function startConnect(connectOptions: ConnectOptions): Promise<void | undefined>;
+export declare function connectCommand(program: Command): void;
+//# sourceMappingURL=connect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"connect.d.ts","sourceRoot":"","sources":["../../../src/commands/connect.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EAErB,MAAM,6CAA6C,CAAC;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,MAAM,MAAM,cAAc,GAAG,oBAAoB,CAAC;AAElD,wBAAsB,YAAY,CAAC,cAAc,EAAE,cAAc,6BAIhE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAmC9C"}

package/dist/src/commands/connect.js

@@ -0,0 +1,44 @@
+import { startConnectStudio, } from "@powerhousedao/builder-tools/connect-studio";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+import packageJson from "../../package.json" with { type: "json" };
+const version = packageJson.version;
+export async function startConnect(connectOptions) {
+    const { documentModelsDir, editorsDir } = getConfig();
+    const options = { documentModelsDir, editorsDir, ...connectOptions };
+    return await startConnectStudio(options);
+}
+export function connectCommand(program) {
+    program
+        .command("connect")
+        .description("Starts Connect Studio")
+        .option("-p, --port <port>", "Port to run the server on", "3000")
+        .option("-h, --host", "Expose the server to the network")
+        .option("--https", "Enable HTTPS")
+        .option("--open", "Open the browser")
+        .option("--config-file <configFile>", "Path to the powerhouse.config.js file")
+        .option("-le, --local-editors <localEditors>", "Link local document editors path")
+        .option("-ld, --local-documents <localDocuments>", "Link local documents path")
+        .action(async (...args) => {
+        const connectOptions = args.at(0) || {};
+        const { documentModelsDir, editorsDir, packages, studio, logLevel } = getConfig();
+        await startConnectStudio({
+            port: studio?.port?.toString() || undefined,
+            packages,
+            phCliVersion: typeof version === "string" ? version : undefined,
+            localDocuments: documentModelsDir || undefined,
+            localEditors: editorsDir || undefined,
+            open: studio?.openBrowser,
+            logLevel: logLevel,
+            ...connectOptions,
+        });
+    });
+}
+if (process.argv.at(2) === "spawn") {
+    const optionsArg = process.argv.at(3);
+    const options = optionsArg
+        ? JSON.parse(optionsArg)
+        : {};
+    startConnect(options).catch((e) => {
+        throw e;
+    });
+}

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

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { CommandActionType } from "../types.js";
+export declare const dev: CommandActionType<[
+    {
+        generate?: boolean;
+        watch?: boolean;
+        switchboardPort?: number;
+        configFile?: string;
+        httpsKeyFile?: string;
+        httpsCertFile?: string;
+    }
+]>;
+export declare function devCommand(program: Command): void;
+//# sourceMappingURL=dev.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../src/commands/dev.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAoFhD,eAAO,MAAM,GAAG,EAAE,iBAAiB,CACjC;IACE;QACE,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,YAAY,CAAC,EAAE,MAAM,CAAC;QACtB,aAAa,CAAC,EAAE,MAAM,CAAC;KACxB;CACF,CAoBF,CAAC;AAEF,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,QAiB1C"}

package/dist/src/commands/dev.js

@@ -0,0 +1,88 @@
+import { blue, green, red } from "colorette";
+import { fork } from "node:child_process";
+import path, { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getConfig } from "../utils.js";
+import { DefaultSwitchboardOptions, } from "./switchboard.js";
+const __dirname = import.meta.dirname || dirname(fileURLToPath(import.meta.url));
+function spawnLocalSwitchboard(options) {
+    const child = fork(path.join(__dirname, "switchboard.js"), ["spawn", JSON.stringify(options)], { silent: true });
+    return new Promise((resolve) => {
+        child.on("message", (message) => {
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string
+            const text = message.toString();
+            if (text.startsWith("driveUrl:")) {
+                const driveUrl = text.substring("driveUrl:".length);
+                resolve({ driveUrl });
+            }
+        });
+        child.stdout.on("data", (data) => {
+            const message = data.toString();
+            const lines = message.split("\n").filter((line) => line.trim().length);
+            for (const line of lines) {
+                process.stdout.write(blue(`[Switchboard]: ${line}\n`));
+            }
+        });
+        child.stderr.on("error", (data) => {
+            process.stderr.write(red(`[Switchboard]: ${data.toString()}`));
+        });
+        child.on("error", (err) => {
+            process.stderr.write(red(`[Switchboard]: ${err}`));
+        });
+        child.on("exit", (code) => {
+            console.log(`Switchboard process exited with code ${code}`);
+        });
+    });
+}
+async function spawnConnect(options, localReactorUrl) {
+    const child = fork(path.join(__dirname, "connect.js"), ["spawn", JSON.stringify(options ?? {})], {
+        silent: true,
+        env: {
+            ...process.env,
+            // TODO add studio variables?
+            LOCAL_DOCUMENT_MODELS: options?.localDocuments,
+            LOCAL_DOCUMENT_EDITORS: options?.localEditors,
+            PH_CONNECT_DEFAULT_DRIVES_URL: localReactorUrl,
+        },
+    });
+    return new Promise((resolve) => {
+        child.stdout.on("data", (data) => {
+            resolve();
+            process.stdout.write(green(`[Connect]: ${data.toString()}`));
+        });
+        child.stderr.on("data", (data) => {
+            process.stderr.write(red(`[Connect]: ${data.toString()}`));
+        });
+        child.on("close", (code) => {
+            console.log(`Connect process exited with code ${code}`);
+        });
+    });
+}
+export const dev = async ({ generate, watch, switchboardPort = DefaultSwitchboardOptions.port, configFile, }) => {
+    try {
+        const baseConfig = getConfig(configFile);
+        const https = baseConfig.reactor?.https;
+        const { driveUrl } = await spawnLocalSwitchboard({
+            generate,
+            port: switchboardPort,
+            watch,
+            https,
+        });
+        await spawnConnect({ configFile }, driveUrl);
+    }
+    catch (error) {
+        console.error(error);
+    }
+};
+export function devCommand(program) {
+    program
+        .command("dev")
+        .description("Starts dev environment")
+        .option("--generate", "generate code when document model is updated")
+        .option("--switchboard-port <port>", "port to use for the switchboard")
+        .option("--https-key-file <HTTPS_KEY_FILE>", "path to the ssl key file")
+        .option("--https-cert-file <HTTPS_CERT_FILE>", "path to the ssl cert file")
+        .option("--config-file <configFile>", "Path to the powerhouse.config.js file")
+        .option("-w, --watch", "if the switchboard should watch for local changes to document models and processors")
+        .action(dev);
+}

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

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import { CommandActionType } from "../types.js";
+export declare const generate: CommandActionType<[
+    string | undefined,
+    {
+        interactive?: boolean;
+        editors?: string;
+        processors?: string;
+        documentModels?: string;
+        skipFormat?: boolean;
+        watch?: boolean;
+        editor?: string;
+        processor?: string;
+        documentTypes?: string;
+        processorType?: "analytics" | "operational";
+        subgraph?: string;
+        importScript?: string;
+    }
+]>;
+export declare function generateCommand(program: Command): void;
+//# sourceMappingURL=generate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../../src/commands/generate.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,eAAO,MAAM,QAAQ,EAAE,iBAAiB,CACtC;IACE,MAAM,GAAG,SAAS;IAClB;QACE,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,aAAa,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC;QAC5C,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,YAAY,CAAC,EAAE,MAAM,CAAC;KACvB;CACF,CAwEF,CAAC;AAEF,wBAAgB,eAAe,CAAC,OAAO,EAAE,OAAO,QAkB/C"}

package/dist/src/commands/generate.js

@@ -0,0 +1,74 @@
+import { generate as generateCode, generateEditor, generateFromFile, generateImportScript, generateProcessor, generateSubgraph, } from "@powerhousedao/codegen";
+import { getConfig } from "@powerhousedao/config/powerhouse";
+export const generate = async (filePath, options) => {
+    const baseConfig = getConfig();
+    const config = {
+        ...baseConfig,
+        ...{
+            ...(options.editors && { editorsDir: options.editors }),
+            ...(options.processors && { processorsDir: options.processors }),
+            ...(options.documentModels && {
+                documentModelsDir: options.documentModels,
+            }),
+            ...(options.skipFormat && { skipFormat: options.skipFormat }),
+            ...(options.interactive && { interactive: options.interactive }),
+            ...(options.watch && { watch: options.watch }),
+        },
+    };
+    const command = {
+        editor: !!options.editor,
+        editorName: options.editor,
+        documentTypes: options.documentTypes,
+        processor: !!options.processor,
+        processorName: options.processor,
+        processorType: options.processorType,
+        subgraph: !!options.subgraph,
+        subgraphName: options.subgraph,
+        importScript: !!options.importScript,
+        importScriptName: options.importScript,
+    };
+    if (command.editor) {
+        if (!command.editorName) {
+            throw new Error("Editor name is required (--editor or -e)");
+        }
+        await generateEditor(command.editorName, command.documentTypes?.split(/[|,;]/g) ?? [], config);
+        return;
+    }
+    if (command.processor && options.processor) {
+        const processorType = options.processorType === "operational" ? "operational" : "analytics";
+        await generateProcessor(options.processor, processorType, options.documentTypes?.split(",") ?? [], config);
+        return;
+    }
+    if (command.subgraph && command.subgraphName) {
+        await generateSubgraph(command.subgraphName, null, config);
+        return;
+    }
+    if (command.importScript && command.importScriptName) {
+        await generateImportScript(command.importScriptName, config);
+        return;
+    }
+    if (filePath) {
+        await generateFromFile(filePath, config);
+        return;
+    }
+    await generateCode(config);
+};
+export function generateCommand(program) {
+    program
+        .command("generate")
+        .description("Generate code from the document models")
+        .argument("[document-model-file]", "Path to the document model file")
+        .option("-i, --interactive", "Run the command in interactive mode")
+        .option("--editors <type>", "Path to the editors directory")
+        .option("-e, --editor <type>", "Editor Name")
+        .option("--processors <type>", "Path to the processors directory")
+        .option("-p, --processor <type>", "Processor Name")
+        .option("--processor-type <type>", "Processor Type")
+        .option("-s, --subgraph <type>", "Subgraph Name")
+        .option("--document-models <type>", "Path to the document models directory")
+        .option("--document-types <type>", "Supported document types by the editor")
+        .option("-is, --import-script <type>", "Import Script Name")
+        .option("-sf, --skip-format", "Skip formatting the generated code")
+        .option("-w, --watch", "Watch the generated code")
+        .action(generate);
+}

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

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function helpCommand(program: Command): void;
+//# sourceMappingURL=help.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/commands/help.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAO3C"}

package/dist/src/commands/help.js

@@ -0,0 +1,8 @@
+export function helpCommand(program) {
+    program
+        .command("help")
+        .description("Display help information")
+        .action(() => {
+        program.help();
+    });
+}

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

@@ -0,0 +1,14 @@
+import { Command } from "commander";
+import { devCommand } from "./dev.js";
+export declare const commands: (typeof devCommand)[];
+export default function registerCommands(program: Command): void;
+export * from "./connect.js";
+export * from "./dev.js";
+export * from "./generate.js";
+export * from "./help.js";
+export * from "./install.js";
+export * from "./list.js";
+export * from "./service.js";
+export * from "./switchboard.js";
+export * from "./uninstall.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAUtC,eAAO,MAAM,QAAQ,uBAWpB,CAAC;AAEF,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAC,OAAO,EAAE,OAAO,QAExD;AAED,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,gBAAgB,CAAC"}

package/dist/src/commands/index.js

@@ -0,0 +1,34 @@
+import { connectCommand } from "./connect.js";
+import { devCommand } from "./dev.js";
+import { generateCommand } from "./generate.js";
+import { helpCommand } from "./help.js";
+import { inspectCommand } from "./inspect.js";
+import { installCommand } from "./install.js";
+import { listCommand } from "./list.js";
+import { serviceCommand } from "./service.js";
+import { reactorCommand } from "./switchboard.js";
+import { uninstallCommand } from "./uninstall.js";
+export const commands = [
+    devCommand,
+    connectCommand,
+    generateCommand,
+    reactorCommand,
+    helpCommand,
+    installCommand,
+    uninstallCommand,
+    serviceCommand,
+    listCommand,
+    inspectCommand,
+];
+export default function registerCommands(program) {
+    commands.forEach((command) => command(program));
+}
+export * from "./connect.js";
+export * from "./dev.js";
+export * from "./generate.js";
+export * from "./help.js";
+export * from "./install.js";
+export * from "./list.js";
+export * from "./service.js";
+export * from "./switchboard.js";
+export * from "./uninstall.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/commands/inspect.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,eAAO,MAAM,OAAO,EAAE,iBAAiB,CACrC;IACE,MAAM;IACN;QACE,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CACF,CAyDF,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAQ9C"}

package/dist/src/commands/inspect.js

@@ -0,0 +1,57 @@
+// import { Manifest } from "document-model";
+import path from "node:path";
+import { getProjectInfo } from "../utils.js";
+export const inspect = async (packageName, options) => {
+    if (options.debug) {
+        console.log(">>> command arguments", { options });
+    }
+    const projectInfo = getProjectInfo(options.debug);
+    if (options.debug) {
+        console.log("\n>>> projectInfo", projectInfo);
+    }
+    try {
+        const manifest = (await import(path.join(packageName, "manifest")));
+        console.log(manifest.name);
+        if (manifest.documentModels) {
+            console.log("\nDocument Models:");
+            manifest.documentModels.forEach((model) => {
+                console.log(`- ${model.name} (${model.id})`);
+            });
+        }
+        if (manifest.editors) {
+            console.log("\nEditors:");
+            manifest.editors.forEach((editor) => {
+                console.log(`- ${editor.name} (${editor.id})`);
+            });
+        }
+        if (manifest.processors) {
+            console.log("\nProcessors:");
+            manifest.processors.forEach((processor) => {
+                console.log(`- ${processor.name} (${processor.id})`);
+            });
+        }
+        if (manifest.subgraphs) {
+            console.log("\nSubgraphs:");
+            manifest.subgraphs.forEach((subgraph) => {
+                console.log(`- ${subgraph.name} (${subgraph.id})`);
+            });
+        }
+    }
+    catch (e) {
+        if (options.debug) {
+            console.error(e);
+        }
+        else {
+            console.log("No manifest found in the package");
+        }
+    }
+};
+export function inspectCommand(program) {
+    program
+        .command("inspect")
+        .alias("is")
+        .description("Inspect a package")
+        .option("--debug", "Show additional logs")
+        .argument("<packageName>", "The name of the package to inspect")
+        .action(inspect);
+}

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

@@ -0,0 +1,15 @@
+import { Command } from "commander";
+import { CommandActionType } from "../types.js";
+import { PackageManager } from "../utils.js";
+export declare function installDependency(packageManager: PackageManager, dependencies: string[], projectPath: string, workspace?: boolean): void;
+export declare const install: CommandActionType<[
+    string[] | undefined,
+    {
+        debug?: boolean;
+        global?: boolean;
+        workspace?: boolean;
+        packageManager?: string;
+    }
+]>;
+export declare function installCommand(program: Command): void;
+//# sourceMappingURL=install.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../../../src/commands/install.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAGL,cAAc,EAIf,MAAM,aAAa,CAAC;AAErB,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,cAAc,EAC9B,YAAY,EAAE,MAAM,EAAE,EACtB,WAAW,EAAE,MAAM,EACnB,SAAS,CAAC,EAAE,OAAO,QAuBpB;AAED,eAAO,MAAM,OAAO,EAAE,iBAAiB,CACrC;IACE,MAAM,EAAE,GAAG,SAAS;IACpB;QACE,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,MAAM,CAAC,EAAE,OAAO,CAAC;QACjB,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB;CACF,CAkEF,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAkB9C"}

package/dist/src/commands/install.js

@@ -0,0 +1,80 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import { getPackageManagerFromLockfile, getProjectInfo, packageManagers, SUPPORTED_PACKAGE_MANAGERS, updateConfigFile, } from "../utils.js";
+export function installDependency(packageManager, dependencies, projectPath, workspace) {
+    if (!fs.existsSync(projectPath)) {
+        throw new Error(`Project path not found: ${projectPath}`);
+    }
+    const manager = packageManagers[packageManager];
+    let installCommand = manager.installCommand.replace("{{dependency}}", dependencies.join(" "));
+    if (workspace) {
+        installCommand += ` ${manager.workspaceOption}`;
+    }
+    const commandOptions = { cwd: projectPath };
+    execSync(installCommand, {
+        stdio: "inherit",
+        ...commandOptions,
+    });
+}
+export const install = (dependencies, options) => {
+    if (options.debug) {
+        console.log(">>> command arguments", { dependencies, options });
+    }
+    if (!dependencies || dependencies.length === 0) {
+        throw new Error("❌ Dependency name is required");
+    }
+    if (options.packageManager &&
+        !SUPPORTED_PACKAGE_MANAGERS.includes(options.packageManager)) {
+        throw new Error("❌ Unsupported package manager. Supported package managers: npm, yarn, pnpm, bun");
+    }
+    const projectInfo = getProjectInfo(options.debug);
+    if (options.debug) {
+        console.log("\n>>> projectInfo", projectInfo);
+    }
+    const isGlobal = options.global || projectInfo.isGlobal;
+    const packageManager = options.packageManager || getPackageManagerFromLockfile(projectInfo.path);
+    if (options.debug) {
+        console.log("\n>>> installDependency arguments:");
+        console.log(">>> packageManager", packageManager);
+        console.log(">>> dependencies", dependencies);
+        console.log(">>> isGlobal", isGlobal);
+        console.log(">>> projectPath", projectInfo.path);
+        console.log(">>> workspace", options.workspace);
+    }
+    try {
+        console.log("installing dependencies 📦 ...");
+        installDependency(packageManager, dependencies, projectInfo.path, options.workspace);
+        console.log("Dependency installed successfully 🎉");
+    }
+    catch (error) {
+        console.error("❌ Failed to install dependencies");
+        throw error;
+    }
+    if (options.debug) {
+        console.log("\n>>> updateConfigFile arguments:");
+        console.log(">>> dependencies", dependencies);
+        console.log(">>> projectPath", projectInfo.path);
+    }
+    try {
+        console.log("⚙️ Updating powerhouse config file...");
+        updateConfigFile(dependencies, projectInfo.path, "install");
+        console.log("Config file updated successfully 🎉");
+    }
+    catch (error) {
+        console.error("❌ Failed to update config file");
+        throw error;
+    }
+};
+export function installCommand(program) {
+    program
+        .command("install")
+        .alias("add")
+        .alias("i")
+        .description("Install a powerhouse dependency")
+        .argument("[dependencies...]", "Names of the dependencies to install")
+        .option("-g, --global", "Install the dependency globally")
+        .option("--debug", "Show additional logs")
+        .option("-w, --workspace", "Install the dependency in the workspace (use this option for monorepos)")
+        .option("--package-manager <packageManager>", "force package manager to use")
+        .action(install);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/commands/list.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGhD,eAAO,MAAM,IAAI,EAAE,iBAAiB,CAClC;IACE;QACE,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB;CACF,CA6BF,CAAC;AAEF,wBAAgB,WAAW,CAAC,OAAO,EAAE,OAAO,QAO3C"}

package/dist/src/commands/list.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+import { getProjectInfo } from "../utils.js";
+export const list = async (options) => {
+    if (options.debug) {
+        console.log(">>> command arguments", { options });
+    }
+    const projectInfo = getProjectInfo(options.debug);
+    if (options.debug) {
+        console.log("\n>>> projectInfo", projectInfo);
+    }
+    try {
+        const phConfig = (await import(path.join(projectInfo.path, "powerhouse.config.json")));
+        if (!phConfig.packages || phConfig.packages.length === 0) {
+            console.log("No packages found in the project");
+            return;
+        }
+        console.log("Installed Packages:\n");
+        phConfig.packages.forEach((pkg) => {
+            console.log(pkg.packageName);
+        });
+    }
+    catch (e) {
+        console.log("No packages found in the project");
+    }
+};
+export function listCommand(program) {
+    program
+        .command("list")
+        .alias("l")
+        .description("List installed packages")
+        .option("--debug", "Show additional logs")
+        .action(list);
+}

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

@@ -0,0 +1,5 @@
+import { Command } from "commander";
+import { CommandActionType } from "../types.js";
+export declare const manageService: CommandActionType<[string, string]>;
+export declare function serviceCommand(program: Command): void;
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../src/commands/service.ts"],"names":[],"mappings":"AACA,OAAO,EAAY,OAAO,EAAE,MAAM,WAAW,CAAC;AAK9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAOhD,eAAO,MAAM,aAAa,EAAE,iBAAiB,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAmC7D,CAAC;AAEF,wBAAgB,cAAc,CAAC,OAAO,EAAE,OAAO,QAS9C"}