dhti-cli 0.8.0 → 1.1.0

package/README.md

@@ -1,58 +1,113 @@
 
 <p align="center">
-  <img src="https://github.com/dermatologist/dhti/blob/develop/notes/dhti-logo.jpg" />
+  <img src="https://github.com/dermatologist/dhti/blob/develop/notes/dhti-logo.jpg" alt="DHTI logo" />
 </p>
 
 [![npm version](https://badge.fury.io/js/dhti-cli.svg)](https://www.npmjs.com/package/dhti-cli)
-[![npm](https://img.shields.io/npm/dt/dhti-cli)](https://www.npmjs.com/package/dhti-cli)
+[![npm downloads](https://img.shields.io/npm/dt/dhti-cli)](https://www.npmjs.com/package/dhti-cli)
 [![Build](https://github.com/dermatologist/dhti/workflows/CI/badge.svg)](https://nuchange.ca)
 [![Known Vulnerabilities](https://snyk.io/test/github/dermatologist/dhti/badge.svg)](https://www.npmjs.com/package/dhti-cli)
 [![Documentation](https://badgen.net/badge/icon/documentation?icon=libraries&label)](https://dermatologist.github.io/dhti/)
 [![Wiki](https://img.shields.io/badge/DHTI-wiki-demo)](https://github.com/dermatologist/dhti/wiki)
 
+<!-- Dhanvantari reference -->
+> 🚀 Dhanvantari rose out of the water with his four hands, holding a pot full of elixirs.
 
-- 🚀 *Dhanvantari rose out of the water with his four hands, holding a pot full of elixirs!*
+# DHTI
+*DHTI enables rapid prototyping, sharing, and testing of GenAI healthcare applications inside an EHR, helping experiments move smoothly into practice. DHTI also includes [skills](/.github/skills/) that generate GenAI components from problem‑oriented [prompts](/prompts/e2e-sample.md).*
 
-### TL; DR: 🏥 DHTI enables rapid prototyping, sharing, and testing of GenAI healthcare applications within an EHR, facilitating the seamless transition of your experiments to practice! Moreover, DHTI comes with batteries included! It has the [skills](/.github/skills/) to generate GenAI components from simple problem oriented [prompts](/prompts/e2e-sample.md).
-👉 [Try it out today!](#try-it-out) and give us a star ⭐️ if you like it!
+### Why?
 
-### About
+Imagine you need to instantly determine whether a patient qualifies for a clinical trial. Your GenAI app pulls in the trial’s eligibility criteria, matches it against the patient’s EHR data, taps a vector store for RAG, relies on a self‑hosted LLM to keep everything private, and uses smart tools to fetch and analyze clinical details. The final output appears right inside the EHR—clean, clear, and clinician‑friendly. 💥 **And that’s just one example of the countless real‑world workflows DHTI makes possible.**
 
-Generative AI features are built as [LangServe Apps](https://python.langchain.com/docs/langserve/) (elixirs) that can be installed into a LangServe instance and exposed as APIs. [OpenMRS O3 esm](https://o3-docs.openmrs.org/) / [**CDS hook** clients](https://github.com/dermatologist/cds-hooks-sandbox/tree/dhti-1) (conchs) provide the interface to communicate with these APIs. All backend data exchange is done through the **FHIR API** (a base class provides all these features). dhti-cli simplifies this process by providing a CLI that includes managing a Docker Compose with all additional components, such as [Ollama](https://ollama.com/) for **local LLM hosting**. LLM and hyperparameters are **injected at runtime** and can be easily swapped. In essence, dhti decouples GenAI modules from the rest of the system. 👉 [Try it out today!](#try-it-out)
+#### How? (Technical):
+Generative AI features are built as [LangServe Apps](https://python.langchain.com/docs/langserve/) (elixirs). All backend data exchange is done through the **FHIR API** (a [base class](https://github.com/dermatologist/dhti-elixir-base) provides all these features) and displayed using CDS-Hooks. dhti-cli simplifies this process by providing a CLI that includes managing a Docker Compose with all additional components, such as [Ollama](https://ollama.com/) for **local LLM hosting**. LLM and hyperparameters are **injected at runtime** and can be easily swapped. In essence, dhti decouples GenAI modules from the rest of the system.
 
-### Want to know more?
+🚀 You can test the elixir using a real EMR system, [OpenMRS](https://openmrs.org/), that communicates with the elixir using **CDS-Hooks** or use any other CDS-Hooks compatible EMR system. You can also use the [CDS-Hooks sandbox for testing](https://github.com/dermatologist/cds-hooks-sandbox/tree/dhti-1) without an EMR.
 
-*Watch this demo video:*
-[![WATCH DHTI DEMO](https://img.youtube.com/vi/5jFFe3wqKM0/0.jpg)](https://www.youtube.com/watch?v=5jFFe3wqKM0)
+#### How (non‑technical / clinical)
+DHTI includes ready‑to‑use [skills](/.github/skills/) that can prompt agentic platforms (e.g., [AntiGravity](https://antigravity.google/), VSCode, or Claude) to generate the GenAI backends and UI components (elixirs and conches) you need. Test these components with synthetic data in OpenMRS or the CDS‑Hooks sandbox, then hand them off to production teams. Because DHTI follows open standards, that handoff (the “valley of death”) becomes smoother and more predictable. Try the [prompts](/.github/skills/start-dhti/examples/e2e-sample.md) in your preferred agentic platform after cloning this repo.
 
-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.
+## Try it out
+[[Cheatsheet](/notes/cheatsheet.md) | [Download PDF Cheatsheet](https://nuchange.ca/wp-content/uploads/2026/01/dhti_cheatsheet.pdf)]
+
+- Requirements: [Node.js](https://nodejs.org/) and [Docker](https://www.docker.com/). Optionally install [Python](https://www.python.org/) to develop or rapidly prototype elixirs.
+- The sample elixir will use Google, OpenAI, or OpenRouter models if API keys are set in your environment; otherwise it falls back to a mock LLM. You can also use [Ollama](https://ollama.com/) for local model hosting. See [setup instructions](/notes/setup-ollama.md).
+
+Quick start (try the demo script):
+```bash
+git clone https://github.com/dermatologist/dhti.git
+cd dhti
+./demo.sh    # Linux / macOS (Windows: use WSL)
+```
+
+Basic demo workflow:
+```bash
+npx dhti-cli help                         # list commands
+npx dhti-cli compose add -m langserve     # add LangServe to ~/dhti/docker-compose.yml
+npx dhti-cli compose read                 # view generated compose
+npx dhti-cli elixir install -g https://github.com/dermatologist/dhti-elixir.git -n dhti-elixir-schat -s packages/simple_chat
+npx dhti-cli docker -n yourdockerhandle/genai-test:1.0 -t elixir
+npx dhti-cli docker -u                    # start services from compose
+```
 
-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).
+Notes:
+- Configure models and hyperparameters in `~/dhti/elixir/app/bootstrap.py` or install from a local directory using `-l`.
+- Stop and remove containers with `npx dhti-cli docker -d`.
 
+✌️  Decide where to test the new elixir: OpenMRS a full EHR system, or CDS-Hooks sandbox for a lightweight testing without an EHR.
+
+💥  Test elixir in a  CDS-Hooks sandbox.
+
+* `npx dhti-cli conch start -n dhti-elixir-schat` and navigate to the Application URL displayed in the console. (Uses hapi.fhir.org).
+* In the **Rx View** tab, type in the contentString textbox and wait for the elixir to respond.
 
 <p align="center">
-  <img src="https://github.com/dermatologist/openmrs-esm-dhti-template/blob/develop/notes/conch.jpg" />
+  <img src="https://github.com/dermatologist/dhti/blob/develop/notes/cds-hook-sandbox.jpg" />
 </p>
 
-  *[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)
+* We recommend using 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 but you can use patient-view if no user input is needed.
+
+💥  Test elixir in OpenMRS.
+
+* `npx dhti-cli conch install -g dermatologist/openmrs-esm-dhti -s packages/esm-chatbot-agent -n esm-chatbot-agent` to install a sample chatbot conch from github.
+    - *(Optional)* Alternatively, use `-l <local-directory>` to install from a local directory.
+
+* `npx dhti-cli conch start -n esm-chatbot-agent -s packages/esm-chatbot-agent` to start the conch with OpenMRS.
+
+* Go to `http://localhost:8080/openmrs/spa/home`
+* Login with the following credentials:
+    - Username: admin
+    - Password: Admin123
+
+You will see the new **patient context aware chatbot** in the patient summary page. This is just an example. You can build your own! Check the implementation in the [elixir repo](https://github.com/dermatologist/dhti-elixir) and [conch repo](https://github.com/dermatologist/openmrs-esm-dhti).
 
 <p align="center">
-  <img src="https://github.com/dermatologist/dhti/blob/develop/notes/cds-hook-sandbox.jpg" />
+  <img src="https://github.com/dermatologist/openmrs-esm-dhti-template/blob/develop/notes/conch.jpg" />
 </p>
 
-*[CDS-Hooks sandbox](https://github.com/dermatologist/cds-hooks-sandbox) for testing conchs without OpenMRS.* 👉 [Try it out today!](#try-it-out)
+* `npx dhti-cli docker -d` to stop and delete all the docker containers.
 
-🚀 dhti-cli is a CLI tool for quick prototyping and testing of elixirs and conches. You can create a new docker-compose with required modules, start/stop services, install Elixirs and conch, create Docker images for them, and more. 🚀 This helps to test new ideas and share them with others quickly. 🚀 Once tested, you can transition them to the production team for deployment. Adoption of standards makes this transition easier! 👉 [Try it out today!](#try-it-out)
+## Wiki & Documentation
+* [![Wiki](https://img.shields.io/badge/DHTI-wiki-demo)](https://github.com/dermatologist/dhti/wiki)
+* [Documentation](https://dermatologist.github.io/dhti/)
+* [CLI Reference](/notes/README.md)
 
-⭐️ **Pitched at [Falling Walls Lab Illinois](https://falling-walls.com/falling-walls-lab-illinois) and released on 09/12/2025.**
+## User contributions & examples
+* [Elixirs](https://github.com/dermatologist/dhti-elixir)
+* [OpenMRS Conches / UI](https://github.com/dermatologist/openmrs-esm-dhti)
+* [CDS Hooks Sandbox for testing](https://github.com/dermatologist/cds-hooks-sandbox)
+
+## Presentations
+⭐️ **Pitched at [Falling Walls Lab Illinois](https://falling-walls.com/falling-walls-lab-illinois) and released on 2025-09-12.**
 
 ## What problems do DHTI solve?
 
 | Why | How |
 | --- | --- |
-| I know LangChain, but I don’t know how to build a chain/agent based on data in our EHR. | [This template](https://github.com/dermatologist/dhti-elixir-template) adopts FHIR and cds-hooks as standards for data retrieval and display. The [base class](https://github.com/dermatologist/dhti-elixir-base) provides reusable artifacts |
+| I know LangChain, but I don’t know how to build a chain/agent based on data in our EHR. | [These sample elixirs](https://github.com/dermatologist/dhti-elixir) adopt FHIR and cds-hooks as standards for data retrieval and display. The [base class](https://github.com/dermatologist/dhti-elixir-base) provides reusable artifacts |
 | I need a simple platform for experimenting. | This repository provides  everything to start experimenting fast. The command-line tools help to virtualize and orchestrate your experiments using [Docker](https://www.docker.com/)|
-| I am a UI designer. I want to design helpful UI for real users. | See [this template](https://github.com/dermatologist/openmrs-esm-dhti-template). It shows how to build interface components (conches) for [OpenMRS](https://openmrs.org/) an open-source EMR used by many. Read more about [OpenMRS UI](https://o3-docs.openmrs.org/) |
+| I am a UI designer. I want to design helpful UI for real users. | See [these sample conches](https://github.com/dermatologist/openmrs-esm-dhti). It shows how to build interface components (conches) for [OpenMRS](https://openmrs.org/) an open-source EMR used by many. Read more about [OpenMRS UI](https://o3-docs.openmrs.org/) |
 | We use another EMR  |  Your EMR may support CDS-Hook for displaying components. In that case, you can use [cds-hooks-sandbox for testing](https://github.com/dermatologist/cds-hooks-sandbox/tree/dhti-1) |
 | Our IT team is often unable to take my experiments to production. | Use DHTI, follow the recommended patterns, and you will make their lives easier.|
 
@@ -81,11 +136,10 @@ The essence of DHTI is *modularity* with an emphasis on *configuration!* It is n
 * **Graph utilities**: Neo4j for graph utilities.
 * **LLM**: Ollama for self-hosting LLM models.
 
-## ✨ New
-* **Local directory installation**: Install elixirs and conches from local directories using the new `-l` flag, enabling seamless integration with locally generated projects.
+## ✨ Advanced Features
 * **start-dhti skill**: New AI agent skill that orchestrates complete DHTI application development - from generating elixirs and conches to starting a fully functional DHTI server.
 * **MCPX integration**: DHTI now includes an [MCP integrator](https://docs.lunar.dev/mcpx/) that allows other MCP servers to be "installed" and exposed seamlessly to DHTI through the MCPX gateway.
-* **DOCKTOR module**: A new module, [DOCKTOR](/notes/DOCKTOR.md), support traditional machine learning model packaged as Docker containers, to be used as MCP tools, enabling the deployment of inference pipelines as agent-invokable tools. (in beta)
+* **DOCKTOR module**: A new module, [DOCKTOR](/notes/DOCKTOR.md), supports traditional machine‑learning models packaged as Docker containers. These can be used as MCP tools to deploy inference pipelines as agent‑invokable tools (in beta).
 * **MCP aware agent**: [dhti-elixir-template](https://github.com/dermatologist/dhti-elixir-template) used in the examples now includes an [MCP aware agent](https://github.com/dermatologist/dhti-elixir-template/blob/feature/agent-2/src/dhti_elixir_template/chain.py) that can autodiscover and invoke tools from the MCPX gateway. Install it using `npx dhti-cli elixir install -g https://github.com/dermatologist/dhti-elixir-template.git -n dhti-elixir-template -b feature/agent2`.
 * **Medplum integration**: [Medplum](https://www.medplum.com/) is now supported as an alternative FHIR server. Read more [here](/notes/medplum.md). This allows you to add FHIR subscriptions for real-time updates and much more.
 * **Synthea integration**: You can now generate synthetic FHIR data using [Synthea](https://synthetichealth.github.io/synthea/). Read more [here](/notes/SYNTHEA.md).
@@ -94,110 +148,28 @@ The essence of DHTI is *modularity* with an emphasis on *configuration!* It is n
 
 ## 🔧 For Gen AI Developers
 
-*Developers can build elixirs and conchs for DHTI.*
-
-:curry: Elixirs are [LangServe Apps](https://python.langchain.com/docs/langserve/)  for backend GenAI functionality. By convention, Elixirs are prefixed with *dhti-elixir-* and all elixirs depend on [dhti-elixir-base](https://github.com/dermatologist/dhti-elixir-base) which provides some base classes and defines dependencies. You can use [this template](https://github.com/dermatologist/dhti-elixir-template) or the [cookiecutter](https://github.com/dermatologist/cookiecutter-uv) to build new elixirs, and license it the way you want (We :heart: open-source!).
-
-:shell: Conches are [OpenMRS O3s](https://o3-docs.openmrs.org/) and follow the standard naming convention *openmrs-esm-*. You can use [this template](https://github.com/dermatologist/openmrs-esm-dhti-template) to build new conches.
-
-:white_check_mark:
-* **Developer friendly**: Copy working files to running containers for testing.
-* **Dependency Injection**: Dependency injection for models and hyperparameters for configuring elixirs.
-* 👉 [Try it out today!](#try-it-out)
+*Developers can build elixirs and conches for DHTI.* See CONTRIBUTING.md for details. User contributed [elixir](https://github.com/dermatologist/dhti-elixir) and [conch](https://github.com/dermatologist/openmrs-esm-dhti) repositories provide examples and templates for development.
 
 ## 🧠 For Gen AI Researchers
 
-*DHTI provides a platform to deploy language models and Gen AI applications in the context of an electronic health record.*
+*DHTI provides a platform to deploy AI models and Gen AI applications in the context of an electronic health record.*
 
-DHTI serves as a platform for testing prompts, chains and agents in healthcare applications.  Since the stack uses the :fire: FHIR data model, it is easy to load synthetic data.
+DHTI serves as a platform for testing models, prompts, chains, and agents in healthcare applications. Because the stack uses the :fire: FHIR data model, it is easy to load synthetic data. We encourage models built for this platform to be open‑sourced on [HuggingFace](https://huggingface.co/) using the `dhti-` prefix.
 
-Tools to fine-tune language models for the stack are on our roadmap. We encourage all language models built for this platform to be open sourced on [HuggingFace](https://huggingface.co/) with the names starting with *dhti-*.
+## 🚀 For clinicians
 
-:white_check_mark:
-* **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).
-* **FHIR**: Data exchange with FHIR schema and **CDS-Hooks** for frontend-backend communication.
-* **EMR**: Built-in EMR, OpenMRS, for patient records.
-* 👉 [Try it out today!](#try-it-out)
+*DHTI includes [skills](/.github/skills/) that generate GenAI components from problem‑oriented [prompts](/prompts/e2e-sample.md).*
 
-*Join us to make the Gen AI equitable and help doctors save lives!*
-
-## :sparkles: Resources
+## ✨ Resources
 * [fhiry](https://github.com/dermatologist/fhiry): FHIR to pandas dataframe for data analytics, AI and ML!
 * [pyOMOP](https://github.com/dermatologist/pyomop): For OMOP CDM support
-
-## :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 & 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)
 * [cookiecutter for scaffolding elixirs](https://github.com/dermatologist/cookiecutter-uv)
 * [cds-hooks-sandbox for testing](https://github.com/dermatologist/cds-hooks-sandbox/tree/dhti-1)
 * [Medplum integration](/notes/medplum.md)
 
-## :sunglasses: Coming soon
-
-* [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.
-
-## 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. *(Optional)* You may configure the LLM and hyperparameters in `~/dhti/elixir/app/bootstrap.py`. You can install multiple elixirs. Alternatively, use `-l <local-directory>` to install from a local directory.
-
-* `npx dhti-cli docker -n yourdockerhandle/genai-test:1.0 -t elixir` to build a docker image for the elixir.
-
-* `npx dhti-cli conch install -g https://github.com/dermatologist/openmrs-esm-dhti-template.git -n openmrs-esm-dhti-template` to install a simple OpenMRS ESM module (conch)from github. You can install multiple conches. Alternatively, use `-l <local-directory>` to install from a local directory.
-
-* `npx dhti-cli docker -n yourdockerhandle/conch-test:1.0 -t conch` to build a docker image for the conches.
-
-* `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`
-* Login with the following credentials:
-    - Username: admin
-    - Password: Admin123
-
-You will see the new conch in the left margin. Click on **Dhti app** to see the UI.
-This is just a template, though. You can build your own conchs!
-
-Add some text to the text area and click on **Submit**.
-You will see the text above the textbox.
-
-* `npx dhti-cli docker -d` to stop and delete all the docker containers.
-
-Read [![Wiki](https://img.shields.io/badge/DHTI-wiki-demo)](https://github.com/dermatologist/dhti/wiki) for more details.
-
-## 👋 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!**
-
-## 🚀 Advanced
-
-* [Detailed steps to try it out](/notes/steps.md)
-* [Setting up Ollama](/notes/setup-ollama.md)
-* [CLI Options](/notes/cli-options.md)
-
 ## Give us a star ⭐️
 If you find this project useful, give us a star. It helps others discover the project.
 
-## [Details of CLI Commands](/notes/README.md)
-
 ## Contributors
 
 * [Bell Eapen](https://nuchange.ca) ([UIS](https://www.uis.edu/directory/bell-punneliparambil-eapen)) |  [Contact](https://nuchange.ca/contact) | [![Twitter Follow](https://img.shields.io/twitter/follow/beapen?style=social)](https://twitter.com/beapen)

package/dist/commands/compose.d.ts

@@ -7,8 +7,12 @@ export default class Compose extends Command {
     static examples: string[];
     static flags: {
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         file: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        host: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         module: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        service: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        value: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     static init: () => void;
     run(): Promise<void>;

package/dist/commands/compose.js

@@ -1,10 +1,13 @@
 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';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
 export default class Compose extends Command {
     static args = {
         op: Args.string({ description: 'Operation to perform (add, delete, read or reset)' }),
@@ -16,17 +19,34 @@ export default class Compose extends Command {
             default: false,
             description: 'Show what changes would be made without actually making them',
         }),
+        env: Flags.string({
+            char: 'e',
+            description: 'Environment variable name (e.g. FHIR_BASE_URL)',
+        }),
         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',
         }),
+        host: Flags.boolean({
+            default: false,
+            description: 'Use host environment variable pattern (e.g. ${VAR_NAME:-default_value})',
+        }),
         // flag with a value (-n, --name=VALUE)
         module: Flags.string({
             char: 'm',
             description: 'Modules to add from ( langserve, openmrs, ollama, langfuse, cqlFhir, redis, neo4j, mcpFhir, mcpx and docktor)',
             multiple: true,
         }),
+        service: Flags.string({
+            char: 's',
+            default: 'langserve',
+            description: 'Service name to update environment variables',
+        }),
+        value: Flags.string({
+            char: 'v',
+            description: 'Environment variable value',
+        }),
     };
     static init = () => {
         // Create ${os.homedir()}/dhti if it does not exist
@@ -94,6 +114,105 @@ export default class Compose extends Command {
                 console.log(existingData);
                 return;
             }
+            // Handle env operation to add or update environment variables
+            if (args.op === 'env') {
+                // Validate mandatory flags
+                if (!flags.env) {
+                    console.error(chalk.red('Error: --env flag is required for env operation'));
+                    this.exit(1);
+                }
+                if (!flags.value) {
+                    console.error(chalk.red('Error: --value flag is required for env operation'));
+                    this.exit(1);
+                }
+                const serviceName = flags.service;
+                const envVarName = flags.env;
+                let envVarValue = flags.value;
+                // Apply host pattern if --host flag is present
+                if (flags.host) {
+                    // eslint-disable-next-line no-template-curly-in-string
+                    envVarValue = `\${${envVarName}:-${flags.value}}`;
+                }
+                // Check if service exists
+                if (!existingData.services[serviceName]) {
+                    console.error(chalk.red(`Error: Service '${serviceName}' not found in docker-compose.yml`));
+                    this.exit(1);
+                }
+                const service = existingData.services[serviceName];
+                // Initialize environment array if not present
+                if (!service.environment) {
+                    service.environment = [];
+                }
+                // Find if the environment variable already exists
+                const envArray = service.environment;
+                let foundIndex = -1;
+                let oldValue;
+                // Handle environment as array of strings or objects
+                for (const [index, env] of envArray.entries()) {
+                    if (typeof env === 'string') {
+                        if (env.startsWith(`${envVarName}=`)) {
+                            foundIndex = index;
+                            oldValue = env.split('=').slice(1).join('=');
+                            break;
+                        }
+                    }
+                    else if (typeof env === 'object' && env !== null && envVarName in env) {
+                        foundIndex = index;
+                        oldValue = env[envVarName];
+                        break;
+                    }
+                }
+                if (flags['dry-run']) {
+                    console.log(chalk.yellow('[DRY RUN] Would update environment variable:'));
+                    console.log(chalk.cyan(`  Service: ${serviceName}`));
+                    console.log(chalk.cyan(`  Variable: ${envVarName}`));
+                    if (foundIndex >= 0) {
+                        console.log(chalk.yellow(`  Old value: ${oldValue}`));
+                        console.log(chalk.green(`  New value: ${envVarValue}`));
+                    }
+                    else {
+                        console.log(chalk.green(`  Adding new value: ${envVarValue}`));
+                    }
+                    console.log(chalk.cyan(`  Would run: docker compose up -d (in ${path.dirname(flags.file)})`));
+                    return;
+                }
+                // Update or add the environment variable
+                if (foundIndex >= 0) {
+                    // Update existing
+                    const existingEnv = envArray[foundIndex];
+                    if (typeof existingEnv === 'string') {
+                        envArray[foundIndex] = `${envVarName}=${envVarValue}`;
+                    }
+                    else if (typeof existingEnv === 'object' && existingEnv !== null) {
+                        ;
+                        existingEnv[envVarName] = envVarValue;
+                    }
+                    console.log(chalk.blue(`Updating environment variable in service '${serviceName}':`));
+                    console.log(chalk.yellow(`  Old value: ${oldValue}`));
+                    console.log(chalk.green(`  New value: ${envVarValue}`));
+                }
+                else {
+                    // Add new
+                    envArray.push(`${envVarName}=${envVarValue}`);
+                    console.log(chalk.blue(`Adding new environment variable to service '${serviceName}':`));
+                    console.log(chalk.green(`  ${envVarName}=${envVarValue}`));
+                }
+                // Write the updated compose file
+                const updatedCompose = yaml.dump(existingData).replaceAll('null', '');
+                fs.writeFileSync(flags.file, updatedCompose, 'utf8');
+                console.log(chalk.green(`✓ docker-compose.yml updated successfully`));
+                // Run docker compose up -d to apply changes
+                try {
+                    const workdir = path.dirname(flags.file);
+                    await execAsync('docker compose up -d', { cwd: workdir });
+                    console.log(chalk.green(`✓ Docker compose reloaded successfully (docker compose up -d)`));
+                }
+                catch (error) {
+                    const err = error;
+                    console.warn(chalk.yellow(`⚠ Warning: Could not run docker compose up -d: ${err.message}`));
+                }
+                return;
+            }
             // Delete flags.file if args.op is reset
             if (args.op === 'reset') {
                 if (flags['dry-run']) {

package/dist/commands/conch.d.ts

@@ -7,15 +7,11 @@ export default class Conch extends Command {
     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>;
         '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>;
-        local: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        local: import("@oclif/core/interfaces").OptionFlag<string | undefined, 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>;
-        subdirectory: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        sources: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         workdir: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     };
     run(): Promise<void>;