dhti-cli 0.3.3 → 0.5.0

package/README.md

@@ -22,6 +22,9 @@ Generative AI features are built as [LangServe Apps](https://python.langchain.co
 
 ### Want to know more?
 
+*Watch this demo video:*
+[![WATCH DHTI DEMO](https://img.youtube.com/vi/5jFFe3wqKM0/0.jpg)](https://www.youtube.com/watch?v=5jFFe3wqKM0)
+
 Gen AI can transform medicine. But it needs a framework for collaborative research and practice. DHTI is a reference architecture and an implementation for such a framework that integrates an EMR ([OpenMRS](https://openmrs.org/)), :link: Gen AI application server ([LangServe](https://python.langchain.com/v0.2/docs/langserve/)), self-hosted LLMs for privacy ([Ollama](https://ollama.com/)), tools on [MCP server](https://github.com/dermatologist/fhir-mcp-server),  vector store for RAG ([redis](https://redis.io/)), monitoring ([LangFuse](https://langfuse.com/)), 🔥 FHIR repository with [CQL](https://nuchange.ca/2025/06/v-llm-in-the-loop-cql-execution-with-unstructured-data-and-fhir-terminology-support.html) support ([HAPI](https://cloud.alphora.com/sandbox/r4/cqm/)) and graph utilities ([Neo4j](https://neo4j.com/)) in one docker-compose! DHTI is inspired by [Bahmni](https://www.bahmni.org/) and **aims to facilitate GenAI adoption and research in areas with low resources.** The MCP server hosts pluggable, agent-invokable tools (FHIR query, summarization, terminology lookup, custom analytics, etc.) that you can extend without modifying core services.
 
 The essence of DHTI is *modularity* with an emphasis on *configuration!* It is non-opinionated on LLMs, hyperparameters and pretty much everything. DHTI supports installable Gen AI routines through [LangServe Apps](https://python.langchain.com/docs/langserve/) (which we call :curry: **elixir**) and installable UI elements through [OpenMRS O3](https://o3-docs.openmrs.org/) React container (which we call :shell: **conch**). 🔥 FHIR is used for backend and [CDS-Hooks](https://cds-hooks.org/) for frontend communication, decoupling conches from OpenMRS, making them potentially usable with any health information system. We have a [fork of the cds-hook sandbox](https://github.com/dermatologist/cds-hooks-sandbox/tree/dhti-1) for testing that uses the [order-select](https://cds-hooks.org/hooks/order-select/) hook, utilizing the contentString from the [FHIR CommunicationRequest](https://build.fhir.org/communicationrequest.html) within the [cds-hook context](https://cds-hooks.org/examples/) for user inputs (recommended).
@@ -31,7 +34,7 @@ The essence of DHTI is *modularity* with an emphasis on *configuration!* It is n
   <img src="https://github.com/dermatologist/openmrs-esm-dhti-template/blob/develop/notes/conch.jpg" />
 </p>
 
-  *[OpenMRS ESM DHTI template](https://github.com/dermatologist/openmrs-esm-dhti-template) + [DHTI elixir template](https://github.com/dermatologist/dhti-elixir-template) together forms a simple but functional EMR chatbot too!* 👉 [Try it out today!](#try-it-out)
+  *[OpenMRS ESM DHTI template](https://github.com/dermatologist/openmrs-esm-dhti-template) (frontend) + [DHTI elixir template](https://github.com/dermatologist/dhti-elixir-template) (backend) together forms a simple but functional EMR chatbot too!* 👉 [Try it out today!](#try-it-out)
 
 <p align="center">
   <img src="https://github.com/dermatologist/dhti/blob/develop/notes/cds-hook-sandbox.jpg" />
@@ -66,6 +69,7 @@ The essence of DHTI is *modularity* with an emphasis on *configuration!* It is n
 * **Quick prototyping**: CLI helps in quick prototyping and testing of Gen AI routines and UI elements.
 * **Easy to use**: Can be installed in a few minutes.
 * **Developer friendly**: Copy working files to running containers for testing.
+* **Dry-run mode**: Preview changes before execution with the `--dry-run` flag.
 * **Dependency Injection**: Dependency injection for models and hyperparameters for configuring elixirs.
 * **Generate synthetic data**: DHTI supports generating synthetic data for testing.
 * **CQL support**: [CQL for clinical decision support](https://nuchange.ca/2025/06/v-llm-in-the-loop-cql-execution-with-unstructured-data-and-fhir-terminology-support.html).
@@ -105,7 +109,7 @@ Tools to fine-tune language models for the stack are on our roadmap. We encourag
 * **EMR**: Built-in EMR, OpenMRS, for patient records.
 * 👉 [Try it out today!](#try-it-out)
 
- 🌈 *Join us to make the Gen AI equitable and help doctors save lives!*
+*Join us to make the Gen AI equitable and help doctors save lives!*
 
 ## :sparkles: Resources
 * [fhiry](https://github.com/dermatologist/fhiry): FHIR to pandas dataframe for data analytics, AI and ML!
@@ -113,8 +117,8 @@ Tools to fine-tune language models for the stack are on our roadmap. We encourag
 
 ## :sparkles: Resources (in Beta)
 * [dhti-elixir-base](https://github.com/dermatologist/dhti-elixir-base): Base classes for dhti-elixir
-* [dhti-elixir-template](https://github.com/dermatologist/dhti-elixir-template): A template for creating new dhti-elixirs.
-* [openmrs-esm-dhti-template](https://github.com/dermatologist/openmrs-esm-dhti-template): A conch template for OpenMRS
+* [dhti-elixir-template](https://github.com/dermatologist/dhti-elixir-template): A template for creating new dhti-elixirs & a **simple EMR chatbot backend**.
+* [openmrs-esm-dhti-template](https://github.com/dermatologist/openmrs-esm-dhti-template): A conch template for OpenMRS & a **simple EMR chatbot frontend**.
 * [fhir-mcp-server](https://github.com/dermatologist/fhir-mcp-server): A MCP server for hosting FHIR-compliant tools.
 
 ## :sparkles: Resources (in Alpha)
@@ -123,20 +127,20 @@ Tools to fine-tune language models for the stack are on our roadmap. We encourag
 
 ## :sunglasses: Coming soon
 
-* [dhti-elixir-fhire](https://github.com/dermatologist/dhti-elixir-fhire): An elixir for extracting embeddings from FHIR resources for Q&A on patient records.
-* [dhti-elixir-fhirs](https://github.com/dermatologist/dhti-elixir-fhirs): An elixir for text to FHIR search query conversion.
+* [dhti-elixir-fhire](https://github.com/dermatologist/dhti-elixir-fhire): An elixir for FHIR embeddings.
 * [dhti-elixir-upload](https://github.com/dermatologist/dhti-elixir-upload-file): Upload documents to the vector store for clinical knowledgebase and clinical trial matching.
-* [openmrs-esm-qa](https://github.com/dermatologist/openmrs-esm-genai): A sample conch for Q&A on patient records using the dhti-elixir-fhire elixir.
 
 ## Try it out
 
 * You only need [Node.js](https://nodejs.org/) and [Docker](https://www.docker.com/) installed to run this project. Optionally, you can install [Python](https://www.python.org/) if you want to develop new elixirs. We use a fake LLM script for testing purposes, so you don't need an OpenAI key to run this project. It just says "Paris" or "I don't know" to any prompt. You can replace it with any internal or external LLM service later.
 
+👉  **If you are in a hurry, just run `./demo.sh` from a terminal (Linux or MacOS) in the root folder to try out the demo.** Windows users can use WSL. You only need [Node.js](https://nodejs.org/) and [Docker](https://www.docker.com/). This script runs all the commands below. Once done, use `npx dhti-cli docker -d` to stop and delete all the docker containers.
+
 * `npx dhti-cli help` to see all available commands.
 
 * `npx dhti-cli compose add -m openmrs -m langserve` to add OpenMRS and Langserve elixirs to your docker-compose.yml at ~/dhti. Other available modules: `ollama, langfuse, cqlFhir, redis, neo4j and mcpFhir`. You can read the newly created docker-compose by: `npx dhti-cli compose read`
 
-* `npx dhti-cli elixir install -g https://github.com/dermatologist/dhti-elixir-template.git -n dhti-elixir-template` to install a sample elixir from github. (Optionally) You may configure the hyperparameters in `~/dhti/elixir/app/bootstrap.py`. You can install multiple elixirs.
+* `npx dhti-cli elixir install -g https://github.com/dermatologist/dhti-elixir-template.git -n dhti-elixir-template` to install a sample elixir from github. *(Optional)* You may configure the LLM and hyperparameters in `~/dhti/elixir/app/bootstrap.py`. You can install multiple elixirs.
 
 * `npx dhti-cli docker -n yourdockerhandle/genai-test:1.0 -t elixir` to build a docker image for the elixir.
 
@@ -146,6 +150,10 @@ Tools to fine-tune language models for the stack are on our roadmap. We encourag
 
 * `npx dhti-cli docker -u` to start all the docker images in your docker-compose.yml.
 
+* *(Optional)* **🔍 Dry-run mode**: Add the `--dry-run` flag to any command to preview what changes will be made without actually executing them. For example:
+  - `npx dhti-cli compose add -m langserve --dry-run` to preview modules that would be added
+  - `npx dhti-cli elixir install -n test-elixir --dry-run` to see what files would be created/modified
+
 ### :clap: Access the Conch in OpenMRS and test the integration
 
 * Go to `http://localhost/openmrs/spa/home`
@@ -161,9 +169,9 @@ You will see the text above the textbox.
 
 * `npx dhti-cli docker -d` to stop and delete all the docker containers.
 
-Read more in [notes/steps.md](/notes/steps.md). Complete documentation is in progress.
+Read [![Wiki](https://img.shields.io/badge/DHTI-wiki-demo)](https://github.com/dermatologist/dhti/wiki) for more details.
 
-### The demo uses a template with mock LLM. [Check out how to add real LLM support using Google Gemini.](/notes/add-llm.md)
+## 👋 The demo uses mock LLM. 👉 [Check out how to add real LLMs and configure them.](https://github.com/dermatologist/dhti/wiki/Configuration)
 
 :hugs: **Thank you for trying out DHTI!**
 

package/dist/commands/compose.d.ts

@@ -6,6 +6,7 @@ export default class Compose extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         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>;
     };

package/dist/commands/compose.js

@@ -1,4 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import yaml from 'js-yaml';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -11,6 +12,10 @@ export default class Compose extends Command {
     static description = 'Generates a docker-compose.yml file from a list of modules';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what changes would be made without actually making them',
+        }),
         file: Flags.string({
             char: 'f',
             default: `${os.homedir()}/dhti/docker-compose.yml`,
@@ -19,7 +24,7 @@ export default class Compose extends Command {
         // 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)',
+            description: 'Modules to add from ( langserve, openmrs, ollama, langfuse, cqlFhir, redis, neo4j, mcpFhir, mcpx and docktor)',
             multiple: true,
         }),
     };
@@ -52,6 +57,8 @@ export default class Compose extends Command {
         const webui = ['ollama-webui'];
         const fhir = ['fhir', 'postgres-db'];
         const mcpFhir = ['mcp-fhir', 'fhir', 'postgres-db'];
+        const mcpx = ['mcpx'];
+        const docktor = ['mcpx'];
         const _modules = {
             cqlFhir,
             fhir,
@@ -59,6 +66,8 @@ export default class Compose extends Command {
             langfuse,
             langserve,
             mcpFhir,
+            mcpx,
+            docktor,
             neo4j,
             ollama,
             openmrs,
@@ -71,6 +80,10 @@ export default class Compose extends Command {
             if (fs.existsSync(flags.file)) {
                 existingData = yaml.load(fs.readFileSync(flags.file, 'utf8'));
             }
+            else if (flags['dry-run']) {
+                console.log(chalk.yellow(`[DRY RUN] Would create directory: ${os.homedir()}/dhti`));
+                console.log(chalk.yellow(`[DRY RUN] Would create file: ${flags.file}`));
+            }
             else {
                 Compose.init(); // Create the file if it does not exist
             }
@@ -81,8 +94,14 @@ export default class Compose extends Command {
             }
             // Delete flags.file if args.op is reset
             if (args.op === 'reset') {
-                fs.unlinkSync(flags.file);
-                Compose.init(); // Recreate the file
+                if (flags['dry-run']) {
+                    console.log(chalk.yellow(`[DRY RUN] Would delete file: ${flags.file}`));
+                    console.log(chalk.yellow(`[DRY RUN] Would recreate file: ${flags.file}`));
+                }
+                else {
+                    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') {
@@ -91,9 +110,19 @@ export default class Compose extends Command {
                 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 (flags['dry-run']) {
+                    console.log(chalk.yellow('[DRY RUN] Would delete the following modules:'));
+                    for (const module of modulesToDelete ?? []) {
+                        if (existingData.services[module]) {
+                            console.log(chalk.cyan(`  - ${module}`));
+                        }
+                    }
+                }
+                else {
+                    for (const module of modulesToDelete ?? []) {
+                        if (existingData.services[module]) {
+                            delete existingData.services[module];
+                        }
                     }
                 }
             }
@@ -104,18 +133,35 @@ export default class Compose extends Command {
                 for (const module of flags.module ?? []) {
                     modulesToAdd = modulesToAdd.concat(_modules[module]);
                 }
-                for (const module of modulesToAdd ?? []) {
-                    existingData.services[module] = masterData.services[module];
+                if (flags['dry-run']) {
+                    console.log(chalk.yellow('[DRY RUN] Would add the following modules:'));
+                    for (const module of modulesToAdd ?? []) {
+                        console.log(chalk.cyan(`  - ${module}`));
+                    }
+                }
+                else {
+                    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];
+            if (!flags['dry-run']) {
+                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');
+            if (flags['dry-run']) {
+                console.log(chalk.yellow(`[DRY RUN] Would write to file: ${flags.file}`));
+                console.log(chalk.green('[DRY RUN] File content would be:'));
+                console.log(toWrite);
+            }
+            else {
+                console.log('Writing file:', toWrite);
+                fs.writeFileSync(flags.file, toWrite, 'utf8');
+            }
         }
         catch (error) {
             console.error(error);

package/dist/commands/conch.d.ts

@@ -9,6 +9,7 @@ export default class Conch extends Command {
         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>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         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>;

package/dist/commands/conch.js

@@ -1,4 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { exec } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -18,6 +19,10 @@ export default class Conch extends Command {
             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' }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what changes would be made without actually making them',
+        }),
         git: Flags.string({ char: 'g', default: 'none', description: 'Github repository to install' }),
         image: Flags.string({
             char: 'i',
@@ -46,9 +51,17 @@ export default class Conch extends Command {
         // 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}`);
+            const buildCommand = `cd ${flags.dev} && yarn build && docker cp dist/. ${flags.container}:/usr/share/nginx/html/${flags.name}-${flags.repoVersion}`;
+            const restartCommand = `docker restart ${flags.container}`;
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute commands:'));
+                console.log(chalk.cyan(`  ${buildCommand}`));
+                console.log(chalk.cyan(`  ${restartCommand}`));
+                return;
+            }
+            console.log(buildCommand);
             try {
-                exec(`cd ${flags.dev} && yarn build && docker cp dist/. ${flags.container}:/usr/share/nginx/html/${flags.name}-${flags.repoVersion}`, (error, stdout, stderr) => {
+                exec(buildCommand, (error, stdout, stderr) => {
                     if (error) {
                         console.error(`exec error: ${error}`);
                         return;
@@ -56,7 +69,7 @@ export default class Conch extends Command {
                     console.log(`stdout: ${stdout}`);
                     console.error(`stderr: ${stderr}`);
                 });
-                exec(`docker restart ${flags.container}`, (error, stdout, stderr) => {
+                exec(restartCommand, (error, stdout, stderr) => {
                     if (error) {
                         console.error(`exec error: ${error}`);
                         return;
@@ -68,15 +81,53 @@ export default class Conch extends Command {
             catch (error) {
                 console.log('Error copying conch to container', error);
             }
+            return;
         }
         // Create a directory to install the elixir
         if (!fs.existsSync(`${flags.workdir}/conch`)) {
-            fs.mkdirSync(`${flags.workdir}/conch`);
+            if (flags['dry-run']) {
+                console.log(chalk.yellow(`[DRY RUN] Would create directory: ${flags.workdir}/conch`));
+            }
+            else {
+                fs.mkdirSync(`${flags.workdir}/conch`);
+            }
+        }
+        if (flags['dry-run']) {
+            console.log(chalk.yellow(`[DRY RUN] Would copy resources from ${RESOURCES_DIR}/spa to ${flags.workdir}/conch`));
+        }
+        else {
+            fs.cpSync(path.join(RESOURCES_DIR, 'spa'), `${flags.workdir}/conch`, { recursive: true });
         }
-        fs.cpSync(path.join(RESOURCES_DIR, 'spa'), `${flags.workdir}/conch`, { recursive: true });
         // Rewrite files
         const rewrite = () => {
             flags.name = flags.name ?? 'openmrs-esm-genai';
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would update configuration files:'));
+                console.log(chalk.cyan(`  - ${flags.workdir}/conch/def/importmap.json`));
+                if (args.op === 'install') {
+                    console.log(chalk.green(`    Add import: ${flags.name.replace('openmrs-', '@openmrs/')} -> ./${flags.name}-${flags.repoVersion}/${flags.name}.js`));
+                }
+                if (args.op === 'uninstall') {
+                    console.log(chalk.green(`    Remove import: ${flags.name.replace('openmrs-', '@openmrs/')}`));
+                }
+                console.log(chalk.cyan(`  - ${flags.workdir}/conch/def/spa-assemble-config.json`));
+                if (args.op === 'install') {
+                    console.log(chalk.green(`    Add module: ${flags.name.replace('openmrs-', '@openmrs/')} = ${flags.repoVersion}`));
+                }
+                if (args.op === 'uninstall') {
+                    console.log(chalk.green(`    Remove module: ${flags.name.replace('openmrs-', '@openmrs/')}`));
+                }
+                console.log(chalk.cyan(`  - ${flags.workdir}/conch/Dockerfile`));
+                console.log(chalk.green(`    Update with conch=${flags.name}, version=${flags.repoVersion}, image=${flags.image}`));
+                console.log(chalk.cyan(`  - ${flags.workdir}/conch/def/routes.registry.json`));
+                if (args.op === 'install') {
+                    console.log(chalk.green(`    Add routes for ${flags.name.replace('openmrs-', '@openmrs/')}`));
+                }
+                if (args.op === 'uninstall') {
+                    console.log(chalk.green(`    Remove routes for ${flags.name.replace('openmrs-', '@openmrs/')}`));
+                }
+                return;
+            }
             // Read and process importmap.json
             const importmap = JSON.parse(fs.readFileSync(`${flags.workdir}/conch/def/importmap.json`, 'utf8'));
             if (args.op === 'install')
@@ -109,14 +160,23 @@ export default class Conch extends Command {
             fs.writeFileSync(`${flags.workdir}/conch/def/routes.registry.json`, JSON.stringify(registry, null, 2));
         };
         if (flags.git !== 'none') {
+            const cloneCommand = `git clone ${flags.git} ${flags.workdir}/conch/${flags.name}`;
+            const checkoutCommand = `cd ${flags.workdir}/conch/${flags.name} && git checkout ${flags.branch}`;
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute git commands:'));
+                console.log(chalk.cyan(`  ${cloneCommand}`));
+                console.log(chalk.cyan(`  ${checkoutCommand}`));
+                rewrite();
+                return;
+            }
             // git clone the repository
-            exec(`git clone ${flags.git} ${flags.workdir}/conch/${flags.name}`, (error, stdout, stderr) => {
+            exec(cloneCommand, (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) => {
+                exec(checkoutCommand, (error, stdout, stderr) => {
                     if (error) {
                         console.error(`exec error: ${error}`);
                         return;
@@ -131,8 +191,14 @@ export default class Conch extends Command {
         }
         // 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();
+            if (flags['dry-run']) {
+                console.log(chalk.yellow(`[DRY RUN] Would copy ${flags.dev} to ${flags.workdir}/conch/${flags.name}`));
+                rewrite();
+            }
+            else {
+                fs.cpSync(flags.dev, `${flags.workdir}/conch/${flags.name}`, { recursive: true });
+                rewrite();
+            }
         }
     }
 }

package/dist/commands/docker.d.ts

@@ -6,9 +6,10 @@ export default class Docker extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        container: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         down: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         file: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        container: 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>;

package/dist/commands/docker.js

@@ -1,4 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import yaml from 'js-yaml';
 import { exec } from 'node:child_process';
 import fs from 'node:fs';
@@ -11,17 +12,21 @@ export default class Docker extends Command {
     static description = 'Build a docker project and update docker-compose file';
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
+        container: Flags.string({
+            char: 'c',
+            default: 'dhti-langserve-1',
+            description: 'Name of the container to copy the bootstrap file to while in dev mode',
+        }),
         down: Flags.boolean({ char: 'd', default: false, description: 'Run docker-compose down after building' }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what changes would be made without actually making them',
+        }),
         file: Flags.string({
             char: 'f',
             default: `${os.homedir()}/dhti/docker-compose.yml`,
             description: 'Full path to the docker compose file to edit or run.',
         }),
-        container: Flags.string({
-            char: 'c',
-            default: 'dhti-langserve-1',
-            description: 'Name of the container to copy the bootstrap file to while in dev mode',
-        }),
         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' }),
@@ -29,7 +34,13 @@ export default class Docker extends Command {
     async run() {
         const { args, flags } = await this.parse(Docker);
         if (flags.up) {
-            exec(`docker compose -f ${flags.file} up -d`, (error, stdout, stderr) => {
+            const upCommand = `docker compose -f ${flags.file} up -d`;
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute:'));
+                console.log(chalk.cyan(`  ${upCommand}`));
+                return;
+            }
+            exec(upCommand, (error, stdout, stderr) => {
                 if (error) {
                     console.error(`exec error: ${error}`);
                     return;
@@ -40,7 +51,13 @@ export default class Docker extends Command {
             return;
         }
         if (flags.down) {
-            exec(`docker compose -f ${flags.file} down`, (error, stdout, stderr) => {
+            const downCommand = `docker compose -f ${flags.file} down`;
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute:'));
+                console.log(chalk.cyan(`  ${downCommand}`));
+                return;
+            }
+            exec(downCommand, (error, stdout, stderr) => {
                 if (error) {
                     console.error(`exec error: ${error}`);
                     return;
@@ -60,8 +77,16 @@ export default class Docker extends Command {
                 console.log('Please provide a valid path to bootstrap.py file');
                 this.exit(1);
             }
+            const copyCommand = `docker cp ${flags.file} ${flags.container}:/app/app/bootstrap.py`;
+            const restartCommand = `docker restart ${flags.container}`;
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute:'));
+                console.log(chalk.cyan(`  ${copyCommand}`));
+                console.log(chalk.cyan(`  ${restartCommand}`));
+                return;
+            }
             // copy -f to container:/app/app/ and only restart after copy completes
-            exec(`docker cp ${flags.file} ${flags.container}:/app/app/bootstrap.py`, (error, stdout, stderr) => {
+            exec(copyCommand, (error, stdout, stderr) => {
                 if (error) {
                     console.error(`exec error: ${error}`);
                     return;
@@ -69,7 +94,7 @@ export default class Docker extends Command {
                 console.log(`stdout: ${stdout}`);
                 console.error(`stderr: ${stderr}`);
                 // restart the container only after copy completes
-                exec(`docker restart ${flags.container}`, (restartError, restartStdout, restartStderr) => {
+                exec(restartCommand, (restartError, restartStdout, restartStderr) => {
                     if (restartError) {
                         console.error(`exec error: ${restartError}`);
                         return;
@@ -81,8 +106,23 @@ export default class Docker extends Command {
             return;
         }
         // cd to path, docker build tag with name
+        const buildCommand = `cd ${args.path}/${flags.type} && docker build -t ${flags.name} . > /dev/null 2>&1`;
+        if (flags['dry-run']) {
+            console.log(chalk.yellow('[DRY RUN] Would execute:'));
+            console.log(chalk.cyan(`  ${buildCommand}`));
+            console.log(chalk.yellow(`[DRY RUN] Would update docker-compose file: ${flags.file}`));
+            if (flags.type === 'elixir') {
+                console.log(chalk.green(`  Set langserve.image = ${flags.name}`));
+                console.log(chalk.green(`  Set langserve.pull_policy = if_not_present`));
+            }
+            else {
+                console.log(chalk.green(`  Set frontend.image = ${flags.name}`));
+                console.log(chalk.green(`  Set frontend.pull_policy = if_not_present`));
+            }
+            return;
+        }
         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) => {
+        exec(buildCommand, (error, stdout, stderr) => {
             if (error) {
                 spinner.fail('Docker build failed');
                 console.error(`exec error: ${error}`);

package/dist/commands/docktor.d.ts

@@ -0,0 +1,18 @@
+import { Command } from '@oclif/core';
+export default class Docktor extends Command {
+    static args: {
+        op: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        container: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        environment: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        image: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'model-path': import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        workdir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    private restartMcpxContainer;
+    run(): Promise<void>;
+}

package/dist/commands/docktor.js

@@ -0,0 +1,143 @@
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+export default class Docktor extends Command {
+    static args = {
+        op: Args.string({ description: 'Operation to perform (install, remove, restart, list)', required: true }),
+        name: Args.string({ description: 'Name of the inference pipeline (e.g., skin-cancer-classifier)', required: false }),
+    };
+    static description = 'Manage inference pipelines for MCPX';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> install my-pipeline --image my-image:latest --model-path ./models',
+        '<%= config.bin %> <%= command.id %> remove my-pipeline',
+        '<%= config.bin %> <%= command.id %> list',
+    ];
+    static flags = {
+        container: Flags.string({
+            char: 'c',
+            default: 'dhti-mcpx-1',
+            description: 'Docker container name for MCPX (use docker ps to find the correct name)',
+        }),
+        environment: Flags.string({
+            char: 'e',
+            multiple: true,
+            description: 'Environment variables to pass to docker (format: VAR=value)',
+        }),
+        image: Flags.string({ char: 'i', description: 'Docker image for the inference pipeline (required for install)' }),
+        'model-path': Flags.string({
+            char: 'm',
+            default: '/lunar/packages/mcpx-server/config',
+            description: 'Local path to the model directory (optional for install)',
+        }),
+        workdir: Flags.string({
+            char: 'w',
+            default: `${os.homedir()}/dhti`,
+            description: 'Working directory for MCPX config',
+        }),
+    };
+    async restartMcpxContainer(mcpxConfigPath, containerName) {
+        try {
+            const { execSync } = await import('node:child_process');
+            execSync(`docker cp ${mcpxConfigPath} ${containerName}:/lunar/packages/mcpx-server/`);
+            this.log(chalk.green('Copied mcp.json to container: /lunar/packages/mcpx-server/config/mcp.json'));
+            execSync(`docker restart ${containerName}`);
+            this.log(chalk.green(`Restarted ${containerName} container.`));
+        }
+        catch (err) {
+            this.log(chalk.red(`Failed to copy config or restart container '${containerName}'. Please check Docker status and container name.`));
+        }
+    }
+    async run() {
+        const { args, flags } = await this.parse(Docktor);
+        const mcpxConfigPath = path.join(flags.workdir, 'config');
+        const mcpJsonPath = path.join(mcpxConfigPath, 'mcp.json');
+        // Ensure config directory exists
+        if (!fs.existsSync(mcpxConfigPath)) {
+            fs.mkdirSync(mcpxConfigPath, { recursive: true });
+        }
+        // Ensure mcp.json exists
+        if (!fs.existsSync(mcpJsonPath)) {
+            fs.writeFileSync(mcpJsonPath, JSON.stringify({ mcpServers: {} }, null, 2));
+        }
+        let mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));
+        // Ensure mcpServers exists
+        if (!mcpConfig.mcpServers) {
+            mcpConfig.mcpServers = {};
+        }
+        if (args.op === 'install') {
+            if (!args.name) {
+                this.error('Name is required for install operation');
+            }
+            if (!flags.image) {
+                this.error('Image is required for install operation');
+            }
+            const binds = [];
+            const envVars = [];
+            if (flags['model-path']) {
+                const absModelPath = path.resolve(flags['model-path']);
+                binds.push(`${absModelPath}:/model`);
+            }
+            if (flags.environment && flags.environment.length > 0) {
+                const invalidEnvVars = flags.environment.filter((e) => {
+                    const idx = e.indexOf('=');
+                    return idx <= 0 || idx === e.length - 1;
+                });
+                if (invalidEnvVars.length > 0) {
+                    this.error(`Invalid environment variable format. Expected 'NAME=value'. Invalid entries: ${invalidEnvVars.join(', ')}`);
+                }
+                envVars.push(...flags.environment);
+            }
+            // Add socket mounting for docker tools if needed, but primarily we want the container to run as a server
+            // MCPX handles the running of the docker container.
+            // We need to configure it in mcp.json so MCPX picks it up.
+            // Based on MCP std, docker servers are defined with `docker` command.
+            // Add (merge) new server into existing mcpServers
+            mcpConfig.mcpServers[args.name] = {
+                command: 'docker',
+                args: [
+                    'run',
+                    '-i',
+                    '--rm',
+                    ...binds.flatMap((b) => ['-v', b]),
+                    ...envVars.flatMap((e) => ['-e', e]),
+                    flags.image,
+                ],
+            };
+            // Write back the updated config (preserving all other properties and existing servers)
+            fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+            this.log(chalk.green(`Inference pipeline '${args.name}' added to MCPX config.`));
+            // Copy only mcp.json to container and restart
+            await this.restartMcpxContainer(mcpxConfigPath, flags.container);
+        }
+        else if (args.op === 'remove') {
+            if (!args.name) {
+                this.error('Name is required for remove operation');
+            }
+            if (mcpConfig.mcpServers && mcpConfig.mcpServers[args.name]) {
+                delete mcpConfig.mcpServers[args.name];
+                // Write back the updated config (preserving all other properties and remaining servers)
+                fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 2));
+                this.log(chalk.green(`Inference pipeline '${args.name}' removed from MCPX config.`));
+                this.log(chalk.yellow('Please restart the MCPX container to apply changes: dhti-cli docktor restart'));
+            }
+            else {
+                this.log(chalk.yellow(`Inference pipeline '${args.name}' not found.`));
+            }
+        }
+        else if (args.op === 'restart') {
+            await this.restartMcpxContainer(mcpxConfigPath, flags.container);
+        }
+        else if (args.op === 'list') {
+            this.log(chalk.blue('Installed Inference Pipelines:'));
+            for (const [name, config] of Object.entries(mcpConfig.mcpServers)) {
+                const argsList = Array.isArray(config.args) ? config.args.join(' ') : '';
+                this.log(`- ${name}: ${argsList}`);
+            }
+        }
+        else {
+            this.error(`Unknown operation: ${args.op}`);
+        }
+    }
+}

package/dist/commands/elixir.d.ts

@@ -9,6 +9,7 @@ export default class Elixir extends Command {
         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>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         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>;

package/dist/commands/elixir.js

@@ -1,4 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import { exec } from 'node:child_process';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -18,6 +19,10 @@ export default class Elixir extends Command {
             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' }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what changes would be made without actually making them',
+        }),
         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({
@@ -47,9 +52,17 @@ export default class Elixir extends Command {
         // 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 src/${expoName}/. ${flags.container}:/app/.venv/lib/python3.12/site-packages/${expoName}`);
+            const devCommand = `cd ${flags.dev} && docker cp src/${expoName}/. ${flags.container}:/app/.venv/lib/python3.12/site-packages/${expoName}`;
+            const restartCommand = `docker restart ${flags.container}`;
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute commands:'));
+                console.log(chalk.cyan(`  ${devCommand}`));
+                console.log(chalk.cyan(`  ${restartCommand}`));
+                return;
+            }
+            console.log(devCommand);
             try {
-                exec(`cd ${flags.dev} && docker cp src/${expoName}/. ${flags.container}:/app/.venv/lib/python3.12/site-packages/${expoName}`, (error, stdout, stderr) => {
+                exec(devCommand, (error, stdout, stderr) => {
                     if (error) {
                         console.error(`exec error: ${error}`);
                         return;
@@ -57,7 +70,7 @@ export default class Elixir extends Command {
                     console.log(`stdout: ${stdout}`);
                     console.error(`stderr: ${stderr}`);
                 });
-                exec(`docker restart ${flags.container}`, (error, stdout, stderr) => {
+                exec(restartCommand, (error, stdout, stderr) => {
                     if (error) {
                         console.error(`exec error: ${error}`);
                         return;
@@ -69,23 +82,45 @@ export default class Elixir extends Command {
             catch (error) {
                 console.log('Error copying conch to container', error);
             }
+            return;
         }
         // Create a directory to install the elixir
         if (!fs.existsSync(`${flags.workdir}/elixir`)) {
-            fs.mkdirSync(`${flags.workdir}/elixir`);
+            if (flags['dry-run']) {
+                console.log(chalk.yellow(`[DRY RUN] Would create directory: ${flags.workdir}/elixir`));
+            }
+            else {
+                fs.mkdirSync(`${flags.workdir}/elixir`);
+            }
+        }
+        if (flags['dry-run']) {
+            console.log(chalk.yellow(`[DRY RUN] Would copy resources from ${RESOURCES_DIR}/genai to ${flags.workdir}/elixir`));
+        }
+        else {
+            fs.cpSync(path.join(RESOURCES_DIR, 'genai'), `${flags.workdir}/elixir`, { recursive: true });
         }
-        fs.cpSync(path.join(RESOURCES_DIR, '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/`);
+                if (flags['dry-run']) {
+                    console.log(chalk.yellow(`[DRY RUN] Would create directory: ${flags.workdir}/whl/`));
+                }
+                else {
+                    fs.mkdirSync(`${flags.workdir}/whl/`);
+                }
+            }
+            if (flags['dry-run']) {
+                console.log(chalk.yellow(`[DRY RUN] Would copy ${flags.whl} to ${flags.workdir}/elixir/whl/${path.basename(flags.whl)}`));
+                console.log(chalk.cyan('[DRY RUN] Installing elixir from whl file. Please modify boostrap.py file if needed'));
+            }
+            else {
+                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');
             }
-            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 pyproject = flags['dry-run'] ? '' : fs.readFileSync(`${flags.workdir}/elixir/pyproject.toml`, 'utf8');
+        const originalServer = flags['dry-run'] ? '' : fs.readFileSync(`${flags.workdir}/elixir/app/server.py`, 'utf8');
         let lineToAdd = '';
         if (flags.whl !== 'none') {
             lineToAdd = `${flags.name} = { file = "whl/${path.basename(flags.whl)}" }`;
@@ -96,8 +131,10 @@ export default class Elixir extends Command {
         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`);
+        if (!flags['dry-run']) {
+            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`;
@@ -108,27 +145,49 @@ ${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}`);
+        let newCliImport = '';
+        if (!flags['dry-run']) {
+            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 newLangfuseRoute = flags['dry-run'] ? '' : 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 newNormalRoute = flags['dry-run'] ? '' : 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}`);
+        const finalRoute = flags['dry-run'] ? '' : 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 (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would update files:'));
+                console.log(chalk.cyan(`  - ${flags.workdir}/elixir/pyproject.toml`));
+                console.log(chalk.green(`    Add dependency: "${flags.name}"`));
+                console.log(chalk.green(`    Add source: ${lineToAdd}`));
+                console.log(chalk.cyan(`  - ${flags.workdir}/elixir/app/server.py`));
+                console.log(chalk.green(`    Add import and routes for ${expoName}`));
+            }
+            else {
+                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);
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would update files:'));
+                console.log(chalk.cyan(`  - ${flags.workdir}/elixir/pyproject.toml`));
+                console.log(chalk.green(`    Remove source: ${lineToAdd}`));
+                console.log(chalk.cyan(`  - ${flags.workdir}/elixir/app/server.py`));
+                console.log(chalk.green(`    Remove import and routes for ${expoName}`));
+            }
+            else {
+                // 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

@@ -5,5 +5,8 @@ export default class Mimic extends Command {
     };
     static description: string;
     static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
     run(): Promise<void>;
 }

package/dist/commands/mimic.js

@@ -1,10 +1,17 @@
-import { Args, Command } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 export default class Mimic extends Command {
     static args = {
         server: Args.string({ default: 'http://localhost/fhir/$import', description: 'Server URL to submit' }), // object with input, instruction (rationale in distillation), output
     };
     static description = 'Submit a FHIR request to a server';
     static examples = ['<%= config.bin %> <%= command.id %>'];
+    static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what changes would be made without actually making them',
+        }),
+    };
     async run() {
         const { args, flags } = await this.parse(Mimic);
         const mimic_request = `{
@@ -140,6 +147,15 @@ export default class Mimic extends Command {
   } ]
 
 }`;
+        if (flags['dry-run']) {
+            console.log(chalk.yellow(`[DRY RUN] Would send POST request to: ${args.server}`));
+            console.log(chalk.cyan('[DRY RUN] Request headers:'));
+            console.log(chalk.green('  Content-Type: application/fhir+json'));
+            console.log(chalk.green('  Prefer: respond-async'));
+            console.log(chalk.cyan('[DRY RUN] Request body:'));
+            console.log(mimic_request);
+            return;
+        }
         // send a POST request to the server with the mimic_request body
         const response = await fetch(args.server, {
             body: mimic_request,
@@ -151,7 +167,6 @@ export default class Mimic extends Command {
         });
         if (!response.ok) {
             console.error(`Error: ${response.status} ${response.statusText}`);
-            return;
         }
     }
 }

package/dist/commands/synthetic.d.ts

@@ -8,6 +8,7 @@ export default class Synthetic extends Command {
     static description: string;
     static examples: string[];
     static flags: {
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         inputField: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         maxCycles: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
         maxRecords: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/synthetic.js

@@ -1,4 +1,5 @@
 import { Args, Command, Flags } from '@oclif/core';
+import chalk from 'chalk';
 import fs from 'node:fs';
 import bootstrap from '../utils/bootstrap.js';
 import { ChainService } from '../utils/chain.js';
@@ -13,6 +14,10 @@ export default class Synthetic extends Command {
         '<%= config.bin %> <%= command.id %>',
     ];
     static flags = {
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'Show what changes would be made without actually making them',
+        }),
         inputField: Flags.string({ char: 'i', default: 'input', description: 'Input field to use', options: ['input', 'instruction', 'output'] }),
         maxCycles: Flags.integer({ char: 'm', default: 0, description: 'Maximum number of cycles to run' }),
         maxRecords: Flags.integer({ char: 'r', default: 10, description: 'Maximum number of records to generate' }),
@@ -24,13 +29,35 @@ export default class Synthetic extends Command {
         // read prompt file if provided
         if (args.prompt)
             prompt = fs.readFileSync(args.prompt ?? '', 'utf8');
-        const container = await bootstrap();
-        const chain = new ChainService(container);
         // if no output file, exit with error
         if (!args.output) {
             console.log("Please provide an output file");
             this.exit(1);
         }
+        if (flags['dry-run']) {
+            console.log(chalk.yellow('[DRY RUN] Synthetic data generation simulation'));
+            console.log(chalk.cyan(`  Output file: ${args.output}`));
+            console.log(chalk.cyan(`  Max records: ${flags.maxRecords}`));
+            if (flags.maxCycles) {
+                console.log(chalk.cyan(`  Max cycles: ${flags.maxCycles}`));
+                console.log(chalk.cyan(`  Output field: ${flags.outputField}`));
+                console.log(chalk.green('[DRY RUN] Would generate synthetic data in batches using LLM'));
+                console.log(chalk.green(`[DRY RUN] Would write ${flags.maxRecords} records to ${args.output}`));
+            }
+            else {
+                console.log(chalk.cyan(`  Input file: ${args.input}`));
+                console.log(chalk.cyan(`  Input field: ${flags.inputField}`));
+                console.log(chalk.cyan(`  Output field: ${flags.outputField}`));
+                if (args.prompt) {
+                    console.log(chalk.cyan(`  Prompt file: ${args.prompt}`));
+                }
+                console.log(chalk.green('[DRY RUN] Would process input file records using LLM'));
+                console.log(chalk.green(`[DRY RUN] Would write processed records to ${args.output}`));
+            }
+            return;
+        }
+        const container = await bootstrap();
+        const chain = new ChainService(container);
         if (flags.maxCycles) { // No input file, can process in batches
             const input = {
                 input: prompt,

package/dist/resources/docker-compose-master.yml

@@ -10,7 +10,7 @@ services:
       - backend
     ports:
       - "80:80"
-      - "9000:80"
+      - "9001:80"
 
 
   frontend:
@@ -133,7 +133,7 @@ services:
         - "hapi.fhir.enforce_referential_integrity_on_delete=false"
 
   mcp-fhir:
-    image: beapen/fhir-mcp-server:1.0
+    image: beapen/fhir-mcp-server:4.0
     ports:
       - 8006:8000
     restart: "unless-stopped"
@@ -225,6 +225,23 @@ services:
       - spring.neo4j.authentication.username=neo4j
       - spring.neo4j.authentication.password=password
 
+  mcpx:
+    image: us-central1-docker.pkg.dev/prj-common-442813/mcpx/mcpx:latest
+    ports:
+      - "8000:8000"
+      - "9000:9000"
+      - "5173:5173"
+      - "3000:3000"
+    # environment:
+    #   - MCPX_PORT=9000
+    #   - MCPX_SERVER_URL="http://10.0.0.211:9000"
+    #   - VITE_MCPX_SERVER_PORT=9000
+    #   - VITE_MCPX_SERVER_URL="http://10.0.0.211:9000"
+    restart: unless-stopped
+    volumes:
+      - mcpx-config:/lunar/packages/mcpx-server/config
+    privileged: true
+
 
 volumes:
   openmrs-data: ~
@@ -235,4 +252,5 @@ volumes:
   neo4j-db: ~
   ollama-code: ~
   ollama-root: ~
-  ollama-webui: ~
+  ollama-webui: ~
+  mcpx-config: ~

package/oclif.manifest.json

@@ -13,6 +13,12 @@
         "<%= config.bin %> <%= command.id %>"
       ],
       "flags": {
+        "dry-run": {
+          "description": "Show what changes would be made without actually making them",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "file": {
           "char": "f",
           "description": "Full path to the docker compose file to read from. Creates if it does not exist",
@@ -24,7 +30,7 @@
         },
         "module": {
           "char": "m",
-          "description": "Modules to add from ( langserve, openmrs, ollama, langfuse, cqlFhir, redis, neo4j and mcpFhir)",
+          "description": "Modules to add from ( langserve, openmrs, ollama, langfuse, cqlFhir, redis, neo4j, mcpFhir, mcpx and docktor)",
           "name": "module",
           "hasDynamicHelp": false,
           "multiple": true,
@@ -86,6 +92,12 @@
           "multiple": false,
           "type": "option"
         },
+        "dry-run": {
+          "description": "Show what changes would be made without actually making them",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "git": {
           "char": "g",
           "description": "Github repository to install",
@@ -160,6 +172,15 @@
         "<%= config.bin %> <%= command.id %>"
       ],
       "flags": {
+        "container": {
+          "char": "c",
+          "description": "Name of the container to copy the bootstrap file to while in dev mode",
+          "name": "container",
+          "default": "dhti-langserve-1",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
         "down": {
           "char": "d",
           "description": "Run docker-compose down after building",
@@ -167,6 +188,12 @@
           "allowNo": false,
           "type": "boolean"
         },
+        "dry-run": {
+          "description": "Show what changes would be made without actually making them",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "file": {
           "char": "f",
           "description": "Full path to the docker compose file to edit or run.",
@@ -176,15 +203,6 @@
           "multiple": false,
           "type": "option"
         },
-        "container": {
-          "char": "c",
-          "description": "Name of the container to copy the bootstrap file to while in dev mode",
-          "name": "container",
-          "default": "dhti-langserve-1",
-          "hasDynamicHelp": false,
-          "multiple": false,
-          "type": "option"
-        },
         "name": {
           "char": "n",
           "description": "Name of the container to build",
@@ -225,6 +243,86 @@
         "docker.js"
       ]
     },
+    "docktor": {
+      "aliases": [],
+      "args": {
+        "op": {
+          "description": "Operation to perform (install, remove, restart, list)",
+          "name": "op",
+          "required": true
+        },
+        "name": {
+          "description": "Name of the inference pipeline (e.g., skin-cancer-classifier)",
+          "name": "name",
+          "required": false
+        }
+      },
+      "description": "Manage inference pipelines for MCPX",
+      "examples": [
+        "<%= config.bin %> <%= command.id %> install my-pipeline --image my-image:latest --model-path ./models",
+        "<%= config.bin %> <%= command.id %> remove my-pipeline",
+        "<%= config.bin %> <%= command.id %> list"
+      ],
+      "flags": {
+        "container": {
+          "char": "c",
+          "description": "Docker container name for MCPX (use docker ps to find the correct name)",
+          "name": "container",
+          "default": "dhti-mcpx-1",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "environment": {
+          "char": "e",
+          "description": "Environment variables to pass to docker (format: VAR=value)",
+          "name": "environment",
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "image": {
+          "char": "i",
+          "description": "Docker image for the inference pipeline (required for install)",
+          "name": "image",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "model-path": {
+          "char": "m",
+          "description": "Local path to the model directory (optional for install)",
+          "name": "model-path",
+          "default": "/lunar/packages/mcpx-server/config",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "workdir": {
+          "char": "w",
+          "description": "Working directory for MCPX config",
+          "name": "workdir",
+          "default": "/home/runner/dhti",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
+      "id": "docktor",
+      "pluginAlias": "dhti-cli",
+      "pluginName": "dhti-cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": false,
+      "isESM": true,
+      "relativePath": [
+        "dist",
+        "commands",
+        "docktor.js"
+      ]
+    },
     "elixir": {
       "aliases": [],
       "args": {
@@ -265,6 +363,12 @@
           "multiple": false,
           "type": "option"
         },
+        "dry-run": {
+          "description": "Show what changes would be made without actually making them",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "git": {
           "char": "g",
           "description": "Github repository to install",
@@ -347,7 +451,14 @@
       "examples": [
         "<%= config.bin %> <%= command.id %>"
       ],
-      "flags": {},
+      "flags": {
+        "dry-run": {
+          "description": "Show what changes would be made without actually making them",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        }
+      },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
       "id": "mimic",
@@ -386,6 +497,12 @@
         "<%= config.bin %> <%= command.id %>"
       ],
       "flags": {
+        "dry-run": {
+          "description": "Show what changes would be made without actually making them",
+          "name": "dry-run",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "inputField": {
           "char": "i",
           "description": "Input field to use",
@@ -449,5 +566,5 @@
       ]
     }
   },
-  "version": "0.3.3"
+  "version": "0.5.0"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dhti-cli",
   "description": "DHTI CLI",
-  "version": "0.3.3",
+  "version": "0.5.0",
   "author": "Bell Eapen",
   "bin": {
     "dhti-cli": "bin/run.js"
@@ -13,6 +13,7 @@
     "@oclif/core": "^4",
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
+    "chalk": "^4.1.2",
     "child_process": "^1.0.2",
     "js-yaml": "^4.1.0",
     "medpromptjs": ">=0.4.3",