dhti-cli 0.1.0 → 0.1.1

package/dist/commands/compose.d.ts

@@ -0,0 +1,14 @@
+import { Command } from '@oclif/core';
+export default class Compose extends Command {
+    static args: {
+        op: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        file: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        module: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    static init: () => void;
+    run(): Promise<void>;
+}

package/dist/commands/compose.js

@@ -0,0 +1,112 @@
+import { Args, Command, Flags } from '@oclif/core';
+import yaml from 'js-yaml';
+import fs from 'node:fs';
+import os from 'node:os';
+export default class Compose extends Command {
+    static args = {
+        op: Args.string({ description: 'Operation to perform (add, delete, read or reset)' }),
+    };
+    static description = 'Generates a docker-compose.yml file from a list of modules';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        file: Flags.string({ char: 'f', default: `${os.homedir()}/dhti/docker-compose.yml`, description: 'Full path to the docker compose file to read from. Creates if it does not exist' }),
+        // flag with a value (-n, --name=VALUE)
+        module: Flags.string({ char: 'm', description: 'Modules to add from ( langserve, openmrs, ollama, langfuse, cqlFhir, redis, neo4j and mcpFhir)', multiple: true }),
+    };
+    static init = () => {
+        // Create ${os.homedir()}/dhti if it does not exist
+        if (!fs.existsSync(`${os.homedir()}/dhti`)) {
+            fs.mkdirSync(`${os.homedir()}/dhti`);
+        }
+        // Create ${os.homedir()}/dhti/docker-compose.yml if it does not exist
+        if (!fs.existsSync(`${os.homedir()}/dhti/docker-compose.yml`)) {
+            fs.writeFileSync(`${os.homedir()}/dhti/docker-compose.yml`, '', 'utf8');
+        }
+    };
+    async run() {
+        const { args, flags } = await this.parse(Compose);
+        // console.log('args', args) //args { op: 'add' }
+        // console.log('flags', flags) //flags { module: [ 'default', 'langserve', 'redis' ] }
+        const openmrs = ['gateway', 'frontend', 'backend', 'openmrs-db'];
+        const langserve = ['langserve'];
+        const ollama = ['ollama', 'ollama-webui'];
+        const langfuse = ['langfuse', 'postgres-db'];
+        const cqlFhir = ['fhir', 'postgres-db', 'cql-elm', 'cql-web'];
+        const redis = ['redis', 'redis-commander'];
+        const neo4j = ['neo4j', 'fhirg'];
+        const gateway = ['gateway'];
+        const webui = ['ollama-webui'];
+        const fhir = ['fhir', 'postgres-db'];
+        const mcpFhir = ['mcp-fhir', 'fhir', 'postgres-db'];
+        const _modules = {
+            cqlFhir,
+            fhir,
+            gateway,
+            langfuse,
+            langserve,
+            mcpFhir,
+            neo4j,
+            ollama,
+            openmrs,
+            redis,
+            webui
+        };
+        try {
+            const masterData = yaml.load(fs.readFileSync('src/resources/docker-compose-master.yml', 'utf8'));
+            let existingData = { services: {}, version: '3.8' };
+            if (fs.existsSync(flags.file)) {
+                existingData = yaml.load(fs.readFileSync(flags.file, 'utf8'));
+            }
+            else {
+                Compose.init(); // Create the file if it does not exist
+            }
+            // Echo the existing data to the console
+            if (args.op === 'read') {
+                console.log(existingData);
+                return;
+            }
+            // Delete flags.file if args.op is reset
+            if (args.op === 'reset') {
+                fs.unlinkSync(flags.file);
+                Compose.init(); // Recreate the file
+            }
+            // if existing data is not null and arg is delete, remove the modules from the existing data
+            if (Object.keys(existingData.services).length > 0 && args.op === 'delete') {
+                // Expand the modules to remove using _modules object
+                let modulesToDelete = [];
+                for (const module of flags.module ?? []) {
+                    modulesToDelete = modulesToDelete.concat(_modules[module]);
+                }
+                for (const module of modulesToDelete ?? []) {
+                    if (existingData.services[module]) {
+                        delete existingData.services[module];
+                    }
+                }
+            }
+            // if arg is add, add the modules from the master data
+            if (args.op === 'add') {
+                // Expand the modules to add using _modules object
+                let modulesToAdd = [];
+                for (const module of flags.module ?? []) {
+                    modulesToAdd = modulesToAdd.concat(_modules[module]);
+                }
+                for (const module of modulesToAdd ?? []) {
+                    existingData.services[module] = masterData.services[module];
+                }
+            }
+            // Add all volumes from master data to existing data by default
+            existingData.volumes = {};
+            for (const key of Object.keys(masterData.volumes)) {
+                existingData.volumes[key] = masterData.volumes[key];
+            }
+            const toWrite = yaml.dump(existingData).replaceAll('null', '');
+            console.log('Writing file:', toWrite);
+            fs.writeFileSync(flags.file, toWrite, 'utf8');
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+}

package/dist/commands/conch.d.ts

@@ -0,0 +1,19 @@
+import { Command } from '@oclif/core';
+export default class Conch extends Command {
+    static args: {
+        op: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        container: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        dev: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        git: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        image: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        repoVersion: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        workdir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/conch.js

@@ -0,0 +1,119 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+export default class Conch extends Command {
+    static args = {
+        op: Args.string({ description: 'Operation to perform (install, uninstall or dev)' }),
+    };
+    static description = 'Install or uninstall conchs to create a Docker image';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        branch: Flags.string({ char: 'b', default: "develop", description: 'Branch to install from' }),
+        container: Flags.string({ char: 'c', default: "dhti-frontend-1", description: 'Name of the container to copy the conch to while in dev mode' }),
+        dev: Flags.string({ char: 'd', default: "none", description: 'Dev folder to install' }),
+        git: Flags.string({ char: 'g', default: "none", description: 'Github repository to install' }),
+        image: Flags.string({ char: 'i', default: "openmrs/openmrs-reference-application-3-frontend:3.0.0-beta.17", description: 'Base image to use for the conch' }),
+        name: Flags.string({ char: 'n', description: 'Name of the elixir' }),
+        repoVersion: Flags.string({ char: 'v', default: "1.0.0", description: 'Version of the conch' }),
+        workdir: Flags.string({ char: 'w', default: `${os.homedir()}/dhti`, description: 'Working directory to install the conch' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Conch);
+        if (!flags.name) {
+            console.log("Please provide a name for the conch");
+            this.exit(1);
+        }
+        // if arg is dev then copy to docker as below
+        // docker cp ../../openmrs-esm-genai/dist/. dhti-frontend-1:/usr/share/nginx/html/openmrs-esm-genai-1.0.0
+        // docker restart dhti-frontend-1
+        if (args.op === 'dev') {
+            console.log(`cd ${flags.dev} && yarn build && docker cp dist/. ${flags.container}:/usr/share/nginx/html/${flags.name}-${flags.repoVersion}`);
+            try {
+                exec(`cd ${flags.dev} && yarn build && docker cp dist/. ${flags.container}:/usr/share/nginx/html/${flags.name}-${flags.repoVersion}`, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error(`exec error: ${error}`);
+                        return;
+                    }
+                    console.log(`stdout: ${stdout}`);
+                    console.error(`stderr: ${stderr}`);
+                });
+                exec(`docker restart ${flags.container}`, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error(`exec error: ${error}`);
+                        return;
+                    }
+                    console.log(`stdout: ${stdout}`);
+                    console.error(`stderr: ${stderr}`);
+                });
+            }
+            catch (error) {
+                console.log("Error copying conch to container", error);
+            }
+        }
+        // Create a directory to install the elixir
+        if (!fs.existsSync(`${flags.workdir}/conch`)) {
+            fs.mkdirSync(`${flags.workdir}/conch`);
+        }
+        fs.cpSync('src/resources/spa', `${flags.workdir}/conch`, { recursive: true });
+        // Rewrite files
+        const rewrite = () => {
+            flags.name = flags.name ?? 'openmrs-esm-genai';
+            // Read and process importmap.json
+            const importmap = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/importmap.json`, 'utf8'));
+            if (args.op === 'install')
+                importmap.imports[flags.name.replace('openmrs-', '@openmrs/')] = `./${flags.name}-${flags.repoVersion}/${flags.name}.js`;
+            if (args.op === 'uninstall')
+                delete importmap.imports[flags.name.replace('openmrs-', '@openmrs/')];
+            fs.writeFileSync(`${flags.workdir}/conch/def/importmap.json`, JSON.stringify(importmap, null, 2));
+            // Read and process spa-assemble-config.json
+            const spaAssembleConfig = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/spa-assemble-config.json`, 'utf8'));
+            if (args.op === 'install')
+                spaAssembleConfig.frontendModules[flags.name.replace('openmrs-', '@openmrs/')] = `${flags.repoVersion}`;
+            if (args.op === 'uninstall')
+                delete spaAssembleConfig.frontendModules[flags.name.replace('openmrs-', '@openmrs/')];
+            fs.writeFileSync(`${flags.workdir}/conch/def/spa-assemble-config.json`, JSON.stringify(spaAssembleConfig, null, 2));
+            // Read and process Dockerfile
+            let dockerfile = fs.readFileSync(`${flags.workdir}/conch/Dockerfile`, 'utf8');
+            dockerfile = dockerfile.replaceAll('conch', flags.name).replaceAll('version', flags.repoVersion).replaceAll('server-image', flags.image);
+            fs.writeFileSync(`${flags.workdir}/conch/Dockerfile`, dockerfile);
+            // Read routes.json
+            const routes = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/${flags.name}/src/routes.json`, 'utf8'));
+            // Add to routes.registry.json
+            const registry = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/routes.registry.json`, 'utf8'));
+            if (args.op === 'install')
+                registry[(flags.name).replace('openmrs-', '@openmrs/')] = routes;
+            if (args.op === 'uninstall')
+                delete registry[(flags.name).replace('openmrs-', '@openmrs/')];
+            fs.writeFileSync(`${flags.workdir}/conch/def/routes.registry.json`, JSON.stringify(registry, null, 2));
+        };
+        if (flags.git !== 'none') {
+            // git clone the repository
+            exec(`git clone ${flags.git} ${flags.workdir}/conch/${flags.name}`, (error, stdout, stderr) => {
+                if (error) {
+                    console.error(`exec error: ${error}`);
+                    return;
+                }
+                // Checkout the branch
+                exec(`cd ${flags.workdir}/conch/${flags.name} && git checkout ${flags.branch}`, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error(`exec error: ${error}`);
+                        return;
+                    }
+                    rewrite();
+                    console.log(`stdout: ${stdout}`);
+                    console.error(`stderr: ${stderr}`);
+                });
+                console.log(`stdout: ${stdout}`);
+                console.error(`stderr: ${stderr}`);
+            });
+        }
+        // If flags.dev is not none, copy the dev folder to the conch directory
+        if (flags.dev !== 'none' && args.op !== 'dev') {
+            fs.cpSync(flags.dev, `${flags.workdir}/conch/${flags.name}`, { recursive: true });
+            rewrite();
+        }
+    }
+}

package/dist/commands/docker.d.ts

@@ -0,0 +1,16 @@
+import { Command } from '@oclif/core';
+export default class Docker extends Command {
+    static args: {
+        path: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        down: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        file: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        up: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/docker.js

@@ -0,0 +1,76 @@
+import { Args, Command, Flags } from '@oclif/core';
+import yaml from 'js-yaml';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import ora from 'ora';
+export default class Docker extends Command {
+    static args = {
+        path: Args.string({ default: `${os.homedir()}/dhti`, description: 'Docker project path to build. Ex: dhti' }),
+    };
+    static description = 'Build a docker project and update docker-compose file';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
+    static flags = {
+        down: Flags.boolean({ char: 'd', default: false, description: 'Run docker-compose down after building' }),
+        file: Flags.string({ char: 'f', default: `${os.homedir()}/dhti/docker-compose.yml`, description: 'Full path to the docker compose file to edit or run.' }),
+        name: Flags.string({ char: 'n', description: 'Name of the container to build' }),
+        type: Flags.string({ char: 't', default: 'elixir', description: 'Type of the service (elixir/conch)' }),
+        up: Flags.boolean({ char: 'u', default: false, description: 'Run docker-compose up after building' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Docker);
+        if (flags.up) {
+            exec(`docker compose -f ${flags.file} up -d`, (error, stdout, stderr) => {
+                if (error) {
+                    console.error(`exec error: ${error}`);
+                    return;
+                }
+                console.log(`stdout: ${stdout}`);
+                console.error(`stderr: ${stderr}`);
+            });
+            return;
+        }
+        if (flags.down) {
+            exec(`docker compose -f ${flags.file} down`, (error, stdout, stderr) => {
+                if (error) {
+                    console.error(`exec error: ${error}`);
+                    return;
+                }
+                console.log(`stdout: ${stdout}`);
+                console.error(`stderr: ${stderr}`);
+            });
+            return;
+        }
+        if (!flags.name && (!flags.up || !flags.down)) {
+            console.log("Please provide a name for the container to build");
+            this.exit(1);
+        }
+        // cd to path, docker build tag with name
+        const spinner = ora('Running docker build ..').start();
+        exec(`cd ${args.path}/${flags.type} && docker build -t ${flags.name} . > /dev/null 2>&1`, (error, stdout, stderr) => {
+            if (error) {
+                spinner.fail('Docker build failed');
+                console.error(`exec error: ${error}`);
+                return;
+            }
+            spinner.succeed('Docker build successful');
+            console.log(`stdout: ${stdout}`);
+            console.error(`stderr: ${stderr}`);
+        });
+        // read the docker-compose file
+        const dockerCompose = yaml.load(fs.readFileSync(flags.file, 'utf8'));
+        // if type is elixir set image of backend to name, else set image of frontend to name
+        if (flags.type === 'elixir') {
+            dockerCompose.services.langserve.image = flags.name;
+            dockerCompose.services.langserve.pull_policy = "if_not_present";
+        }
+        else {
+            dockerCompose.services.frontend.image = flags.name;
+            dockerCompose.services.frontend.pull_policy = "if_not_present";
+        }
+        // write the docker-compose file
+        fs.writeFileSync(flags.file, yaml.dump(dockerCompose));
+    }
+}

package/dist/commands/elixir.d.ts

@@ -0,0 +1,20 @@
+import { Command } from '@oclif/core';
+export default class Elixir extends Command {
+    static args: {
+        op: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        container: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        dev: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        git: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        pypi: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        repoVersion: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        whl: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        workdir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/elixir.js

@@ -0,0 +1,129 @@
+import { Args, Command, Flags } from '@oclif/core';
+import { exec } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export default class Elixir extends Command {
+    static args = {
+        op: Args.string({ description: 'Operation to perform (install, uninstall or dev)' }),
+    };
+    static description = 'Install or uninstall elixirs to create a Docker image';
+    static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        branch: Flags.string({ char: 'b', default: 'develop', description: 'Branch to install from' }),
+        container: Flags.string({
+            char: 'c',
+            default: 'dhti-langserve-1',
+            description: 'Name of the container to copy the elixir to while in dev mode',
+        }),
+        dev: Flags.string({ char: 'd', default: 'none', description: 'Dev folder to install' }),
+        git: Flags.string({ char: 'g', default: 'none', description: 'Github repository to install' }),
+        name: Flags.string({ char: 'n', description: 'Name of the elixir' }),
+        pypi: Flags.string({
+            char: 'p',
+            default: 'none',
+            description: 'PyPi package to install. Ex: dhti-elixir-base = ">=0.1.0"',
+        }),
+        repoVersion: Flags.string({ char: 'v', default: '0.1.0', description: 'Version of the elixir' }),
+        whl: Flags.string({ char: 'e', default: 'none', description: 'Whl file to install' }),
+        workdir: Flags.string({
+            char: 'w',
+            default: `${os.homedir()}/dhti`,
+            description: 'Working directory to install the elixir',
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Elixir);
+        if (!flags.name) {
+            console.log('Please provide a name for the elixir');
+            this.exit(1);
+        }
+        const expoName = flags.name.replaceAll('-', '_');
+        // if arg is dev then copy to docker as below
+        // docker restart dhti-langserve-1
+        if (args.op === 'dev') {
+            console.log(`cd ${flags.dev} && docker cp ${expoName}/. ${flags.container}:/app/.venv/lib/python3.11/site-packages/${expoName}`);
+            try {
+                exec(`cd ${flags.dev} && docker cp ${expoName}/. ${flags.container}:/app/.venv/lib/python3.11/site-packages/${expoName}`, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error(`exec error: ${error}`);
+                        return;
+                    }
+                    console.log(`stdout: ${stdout}`);
+                    console.error(`stderr: ${stderr}`);
+                });
+                exec(`docker restart ${flags.container}`, (error, stdout, stderr) => {
+                    if (error) {
+                        console.error(`exec error: ${error}`);
+                        return;
+                    }
+                    console.log(`stdout: ${stdout}`);
+                    console.error(`stderr: ${stderr}`);
+                });
+            }
+            catch (error) {
+                console.log('Error copying conch to container', error);
+            }
+        }
+        // Create a directory to install the elixir
+        if (!fs.existsSync(`${flags.workdir}/elixir`)) {
+            fs.mkdirSync(`${flags.workdir}/elixir`);
+        }
+        fs.cpSync('src/resources/genai', `${flags.workdir}/elixir`, { recursive: true });
+        // if whl is not none, copy the whl file to thee whl directory
+        if (flags.whl !== 'none') {
+            if (!fs.existsSync(`${flags.workdir}/elixir/whl/`)) {
+                fs.mkdirSync(`${flags.workdir}/whl/`);
+            }
+            fs.cpSync(flags.whl, `${flags.workdir}/elixir/whl/${path.basename(flags.whl)}`);
+            console.log('Installing elixir from whl file. Please modify boostrap.py file if needed');
+        }
+        // Install the elixir from git adding to the pyproject.toml file
+        let pyproject = fs.readFileSync(`${flags.workdir}/elixir/pyproject.toml`, 'utf8');
+        const originalServer = fs.readFileSync(`${flags.workdir}/elixir/app/server.py`, 'utf8');
+        let lineToAdd = '';
+        if (flags.whl !== 'none') {
+            lineToAdd = `${flags.name} = { file = "whl/${path.basename(flags.whl)}" }`;
+        }
+        if (flags.git !== 'none') {
+            lineToAdd = `${flags.name} = { git = "${flags.git}", branch = "${flags.branch}" }`;
+        }
+        if (flags.pypi !== 'none') {
+            lineToAdd = flags.pypi;
+        }
+        pyproject = pyproject.replace('dependencies = [', `dependencies = [\n"${flags.name}",`);
+        pyproject = pyproject.replace('[tool.uv.sources]', `[tool.uv.sources]\n${lineToAdd}\n`);
+        const newPyproject = pyproject;
+        // Add the elixir import and bootstrap to the server.py file
+        let CliImport = `from ${expoName}.bootstrap import bootstrap as ${expoName}_bootstrap\n`;
+        CliImport += `${expoName}_bootstrap()\n`;
+        CliImport += `
+from ${expoName}.chain import DhtiChain as ${expoName}_chain_class
+${expoName}_chain = ${expoName}_chain_class().get_chain_as_langchain_tool()
+${expoName}_mcp_tool = ${expoName}_chain_class().get_chain_as_mcp_tool
+mcp_server.add_tool(${expoName}_mcp_tool) # type: ignore
+    `;
+        const newCliImport = fs
+            .readFileSync(`${flags.workdir}/elixir/app/server.py`, 'utf8')
+            .replace('#DHTI_CLI_IMPORT', `#DHTI_CLI_IMPORT\n${CliImport}`);
+        const langfuseRoute = `add_routes(app, ${expoName}_chain.with_config(config), path="/langserve/${expoName}")`;
+        const newLangfuseRoute = newCliImport.replace('#DHTI_LANGFUSE_ROUTE', `#DHTI_LANGFUSE_ROUTE\n    ${langfuseRoute}`);
+        const normalRoute = `add_routes(app, ${expoName}_chain, path="/langserve/${expoName}")`;
+        const newNormalRoute = newLangfuseRoute.replace('#DHTI_NORMAL_ROUTE', `#DHTI_NORMAL_ROUTE\n    ${normalRoute}`);
+        const commonRoutes = `\nadd_invokes(app, path="/langserve/${expoName}")\nadd_services(app, path="/langserve/${expoName}")`;
+        const finalRoute = newNormalRoute.replace('#DHTI_COMMON_ROUTE', `#DHTI_COMMON_ROUTES${commonRoutes}`);
+        // if args.op === install, add the line to the pyproject.toml file
+        if (args.op === 'install') {
+            fs.writeFileSync(`${flags.workdir}/elixir/pyproject.toml`, newPyproject);
+            fs.writeFileSync(`${flags.workdir}/elixir/app/server.py`, finalRoute);
+        }
+        if (args.op === 'uninstall') {
+            // if args.op === uninstall, remove the line from the pyproject.toml file
+            fs.writeFileSync(`${flags.workdir}/elixir/pyproject.toml`, pyproject.replace(lineToAdd, ''));
+            let newServer = originalServer.replace(CliImport, '');
+            newServer = newServer.replace(langfuseRoute, '');
+            newServer = newServer.replace(normalRoute, '');
+            fs.writeFileSync(`${flags.workdir}/elixir/app/server.py`, newServer);
+        }
+    }
+}

package/dist/commands/mimic.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export default class Mimic extends Command {
+    static args: {
+        server: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+}