dhti-cli 0.8.0 → 1.1.0

package/dist/commands/elixir.js

@@ -1,13 +1,17 @@
 import { Args, Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
+// eslint-disable-next-line import/default
+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 Elixir extends Command {
     static args = {
-        op: Args.string({ description: 'Operation to perform (install, uninstall or dev)' }),
+        op: Args.string({ description: 'Operation to perform (init, install, uninstall, dev or start)' }),
     };
     static description = 'Install or uninstall elixirs to create a Docker image';
     static examples = ['<%= config.bin %> <%= command.id %>'];
@@ -23,6 +27,15 @@ export default class Elixir extends Command {
             default: false,
             description: 'Show what changes would be made without actually making them',
         }),
+        elixir: Flags.string({
+            char: 'e',
+            description: 'Elixir endpoint URL',
+        }),
+        fhir: Flags.string({
+            char: 'f',
+            default: 'http://hapi.fhir.org/baseR4',
+            description: 'FHIR endpoint URL',
+        }),
         git: Flags.string({ char: 'g', default: 'none', description: 'Github repository to install' }),
         local: Flags.string({ char: 'l', default: 'none', description: 'Local directory to install from' }),
         name: Flags.string({ char: 'n', description: 'Name of the elixir' }),
@@ -50,6 +63,202 @@ export default class Elixir extends Command {
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
         const RESOURCES_DIR = path.resolve(__dirname, '../resources');
+        // Handle init operation
+        if (args.op === 'init') {
+            // Validate required flags
+            if (!flags.workdir) {
+                console.error(chalk.red('Error: workdir flag is required for init operation'));
+                this.exit(1);
+            }
+            if (!flags.name) {
+                console.error(chalk.red('Error: name flag is required for init operation'));
+                this.exit(1);
+            }
+            const targetDir = path.join(flags.workdir, 'dhti-elixir');
+            if (flags['dry-run']) {
+                console.log(chalk.yellow('[DRY RUN] Would execute init operation:'));
+                console.log(chalk.cyan(`  npx degit dermatologist/dhti-elixir ${targetDir}`));
+                console.log(chalk.cyan(`  Copy ${targetDir}/packages/starter to ${targetDir}/packages/${flags.name}`));
+                return;
+            }
+            try {
+                // Run npx degit to clone the dhti-elixir template
+                console.log(chalk.blue(`Initializing DHTI elixir template in ${targetDir}...`));
+                const degitCommand = `npx degit dermatologist/dhti-elixir ${targetDir}`;
+                await execAsync(degitCommand);
+                console.log(chalk.green('✓ DHTI elixir template cloned successfully'));
+                // Copy packages/starter subdirectory to packages/<name>
+                const simpleChatSource = path.join(targetDir, 'packages', 'starter');
+                const targetPackageDir = path.join(targetDir, 'packages', flags.name);
+                if (fs.existsSync(simpleChatSource)) {
+                    console.log(chalk.blue(`Copying starter to packages/${flags.name}...`));
+                    fs.cpSync(simpleChatSource, targetPackageDir, { recursive: true });
+                    console.log(chalk.green(`✓ starter copied to packages/${flags.name}`));
+                }
+                else {
+                    console.log(chalk.yellow(`Warning: starter not found at ${simpleChatSource}`));
+                }
+                console.log(chalk.green(`\n✓ Initialization complete! Your elixir workspace is ready at ${targetDir}`));
+                console.log(chalk.blue(`\nNext steps:`));
+                console.log(chalk.cyan(`  1. cd ${targetDir}`));
+                console.log(chalk.cyan(`  2. Follow the README.md for development instructions`));
+            }
+            catch (error) {
+                console.error(chalk.red('Error during initialization:'), error);
+                this.exit(1);
+            }
+            return;
+        }
+        // Handle start operation
+        if (args.op === 'start') {
+            // Determine the elixir endpoint URL
+            let elixirUrl = flags.elixir;
+            if (!elixirUrl) {
+                // If --elixir is not provided, construct it from --name
+                if (!flags.name) {
+                    console.error(chalk.red('Error: Either --elixir or --name flag must be provided for start operation'));
+                    this.exit(1);
+                }
+                const nameWithUnderscores = flags.name.replaceAll('-', '_');
+                elixirUrl = `http://localhost:8001/langserve/${nameWithUnderscores}/cds-services`;
+            }
+            const sandboxDir = path.join(flags.workdir, 'cds-hooks-sandbox');
+            if (flags['dry-run']) {
+                const directoryExists = fs.existsSync(sandboxDir);
+                console.log(chalk.yellow('[DRY RUN] Would execute start operation:'));
+                if (directoryExists) {
+                    console.log(chalk.cyan(`  [SKIP] Directory already exists: ${sandboxDir}`));
+                }
+                else {
+                    console.log(chalk.cyan(`  npx degit dermatologist/cds-hooks-sandbox ${sandboxDir}`));
+                    console.log(chalk.cyan(`  cd ${sandboxDir}`));
+                    console.log(chalk.cyan(`  yarn install`));
+                }
+                console.log(chalk.cyan(`  yarn dhti ${elixirUrl} ${flags.fhir}`));
+                console.log(chalk.cyan(`  Update docker-compose.yml FHIR_BASE_URL=${flags.fhir}`));
+                console.log(chalk.cyan(`  docker restart ${flags.container}`));
+                console.log(chalk.cyan(`  yarn dev`));
+                return;
+            }
+            try {
+                // Check if the directory already exists
+                const directoryExists = fs.existsSync(sandboxDir);
+                if (directoryExists) {
+                    console.log(chalk.blue(`Using existing CDS Hooks Sandbox at ${sandboxDir}...`));
+                    console.log(chalk.green('✓ Skipped clone and install (directory already exists)'));
+                }
+                else {
+                    // Clone the cds-hooks-sandbox repository
+                    console.log(chalk.blue(`Cloning CDS Hooks Sandbox to ${sandboxDir}...`));
+                    const degitCommand = `npx degit dermatologist/cds-hooks-sandbox ${sandboxDir}`;
+                    await execAsync(degitCommand);
+                    console.log(chalk.green('✓ CDS Hooks Sandbox cloned successfully'));
+                    // Install dependencies
+                    console.log(chalk.blue('Installing dependencies...'));
+                    const installCommand = `cd ${sandboxDir} && yarn install`;
+                    const { stderr: installError } = await execAsync(installCommand);
+                    if (installError && !installError.includes('warning')) {
+                        console.error(chalk.yellow(`Installation warnings: ${installError}`));
+                    }
+                    console.log(chalk.green('✓ Dependencies installed successfully'));
+                }
+                // Configure dhti endpoints
+                console.log(chalk.blue('Configuring DHTI endpoints...'));
+                const dhtiCommand = `cd ${sandboxDir} && yarn dhti ${elixirUrl} ${flags.fhir}`;
+                const { stderr: dhtiError } = await execAsync(dhtiCommand);
+                if (dhtiError && !dhtiError.includes('warning')) {
+                    console.error(chalk.yellow(`Configuration warnings: ${dhtiError}`));
+                }
+                console.log(chalk.green('✓ DHTI endpoints configured successfully'));
+                // Configure Docker container with FHIR_BASE_URL environment variable
+                console.log(chalk.blue('Setting up Docker container environment...'));
+                try {
+                    // Update the docker-compose.yml file with the new FHIR_BASE_URL
+                    const dockerComposeFile = path.join(flags.workdir, 'docker-compose.yml');
+                    if (fs.existsSync(dockerComposeFile)) {
+                        const composeContent = fs.readFileSync(dockerComposeFile, 'utf8');
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const compose = yaml.load(composeContent);
+                        if (compose.services && compose.services.langserve) {
+                            if (!compose.services.langserve.environment) {
+                                compose.services.langserve.environment = [];
+                            }
+                            // Update or add the FHIR_BASE_URL environment variable
+                            const envArray = compose.services.langserve.environment;
+                            const fhirIndex = envArray.findIndex((env) => {
+                                if (typeof env === 'string') {
+                                    return env.startsWith('FHIR_BASE_URL=');
+                                }
+                                return typeof env === 'object' && env !== null && 'FHIR_BASE_URL' in env;
+                            });
+                            if (fhirIndex >= 0) {
+                                // Update existing environment variable
+                                const existingEnv = envArray[fhirIndex];
+                                if (typeof existingEnv === 'string') {
+                                    envArray[fhirIndex] = `FHIR_BASE_URL=${flags.fhir}`;
+                                }
+                                else if (typeof existingEnv === 'object' && existingEnv !== null) {
+                                    existingEnv.FHIR_BASE_URL = flags.fhir;
+                                }
+                            }
+                            else {
+                                // Add new environment variable
+                                envArray.push(`FHIR_BASE_URL=${flags.fhir}`);
+                            }
+                            const updatedCompose = yaml.dump(compose);
+                            fs.writeFileSync(dockerComposeFile, updatedCompose);
+                            console.log(chalk.green(`✓ docker-compose.yml updated with FHIR_BASE_URL=${flags.fhir}`));
+                        }
+                        else {
+                            console.warn(chalk.yellow('⚠ Warning: langserve service not found in docker-compose.yml'));
+                        }
+                    }
+                    else {
+                        console.warn(chalk.yellow(`⚠ Warning: docker-compose.yml not found at ${dockerComposeFile}`));
+                    }
+                    // Restart the container to apply the new environment variables
+                    const upCommand = `docker compose up -d`; // Docker Compose is smart enough to re-create only the services where the configuration, including environment variables, has changed
+                    await execAsync(upCommand, { cwd: flags.workdir });
+                    console.log(chalk.green(`✓ Docker container ${flags.container} restarted (compose up -d) successfully`));
+                }
+                catch (error) {
+                    const err = error;
+                    if (err.message?.includes('No such container')) {
+                        console.warn(chalk.yellow(`⚠ Warning: Docker container ${flags.container} not found. Skipping container restart.`));
+                    }
+                    else {
+                        console.error(chalk.red(`Error setting up Docker container: ${err.message}`));
+                        this.exit(1);
+                    }
+                }
+                // Start the development server
+                console.log(chalk.blue('Starting development server...'));
+                const { spawn } = await import('node:child_process');
+                const devCommand = `yarn dhti ${elixirUrl} ${flags.fhir} && yarn dev`;
+                try {
+                    const child = spawn(devCommand, { cwd: sandboxDir, shell: true, stdio: 'inherit' });
+                    await new Promise((resolve, reject) => {
+                        child.on('exit', (code) => {
+                            if (code === 0)
+                                resolve(undefined);
+                            else
+                                reject(new Error(`Dev server exited with code ${code}`));
+                        });
+                        child.on('error', reject);
+                    });
+                }
+                catch (error) {
+                    const err = error;
+                    console.error(chalk.red('Error starting development server:'), err.message);
+                    this.exit(1);
+                }
+            }
+            catch (error) {
+                console.error(chalk.red('Error during start operation:'), error);
+                this.exit(1);
+            }
+            return;
+        }
         if (!flags.name) {
             console.log('Please provide a name for the elixir');
             this.exit(1);
@@ -90,43 +299,46 @@ export default class Elixir extends Command {
             }
             return;
         }
-        // Create a directory to install the elixir
-        if (!fs.existsSync(`${flags.workdir}/elixir`)) {
+        // Create a directory to install the elixir (only on first install)
+        const elixirDir = `${flags.workdir}/elixir`;
+        const isFirstInstall = !fs.existsSync(elixirDir);
+        if (isFirstInstall) {
             if (flags['dry-run']) {
-                console.log(chalk.yellow(`[DRY RUN] Would create directory: ${flags.workdir}/elixir`));
+                console.log(chalk.yellow(`[DRY RUN] Would create directory: ${elixirDir}`));
+                console.log(chalk.yellow(`[DRY RUN] Would copy resources from ${RESOURCES_DIR}/genai to ${elixirDir}`));
             }
             else {
-                fs.mkdirSync(`${flags.workdir}/elixir`);
+                fs.mkdirSync(elixirDir);
+                fs.cpSync(path.join(RESOURCES_DIR, 'genai'), elixirDir, { recursive: true });
+                console.log(chalk.blue(`✓ Initialized elixir directory at ${elixirDir}`));
             }
         }
-        if (flags['dry-run']) {
-            console.log(chalk.yellow(`[DRY RUN] Would copy resources from ${RESOURCES_DIR}/genai to ${flags.workdir}/elixir`));
+        else if (args.op === 'install') {
+            console.log(chalk.blue(`Using existing elixir directory at ${elixirDir}`));
         }
-        else {
-            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 whl is not none, copy the whl file to the whl directory
         if (flags.whl !== 'none') {
-            if (!fs.existsSync(`${flags.workdir}/elixir/whl/`)) {
+            const whlDir = `${elixirDir}/whl/`;
+            if (!fs.existsSync(whlDir)) {
                 if (flags['dry-run']) {
-                    console.log(chalk.yellow(`[DRY RUN] Would create directory: ${flags.workdir}/whl/`));
+                    console.log(chalk.yellow(`[DRY RUN] Would create directory: ${whlDir}`));
                 }
                 else {
-                    fs.mkdirSync(`${flags.workdir}/whl/`);
+                    fs.mkdirSync(whlDir);
                 }
             }
             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'));
+                console.log(chalk.yellow(`[DRY RUN] Would copy ${flags.whl} to ${whlDir}${path.basename(flags.whl)}`));
+                console.log(chalk.cyan('[DRY RUN] Installing elixir from whl file. Please modify bootstrap.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, `${whlDir}${path.basename(flags.whl)}`);
+                console.log('Installing elixir from whl file. Please modify bootstrap.py file if needed');
             }
         }
         // Install the elixir from git adding to the pyproject.toml file
-        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');
+        // Always read from the current state, not the template
+        let pyproject = flags['dry-run'] ? '' : fs.readFileSync(`${elixirDir}/pyproject.toml`, 'utf8');
         let lineToAdd = '';
         if (flags.whl !== 'none') {
             lineToAdd = `${flags.name} = { file = "whl/${path.basename(flags.whl)}" }`;
@@ -157,11 +369,49 @@ export default class Elixir extends Command {
             }
             lineToAdd = `${flags.name} = { path = "${absolutePath}" }`;
         }
+        // Helper function to add dependency to pyproject.toml
+        const addDependencyToPyproject = (content, depName) => {
+            // Check if dependency already exists
+            if (content.includes(`"${depName}"`)) {
+                return content;
+            }
+            // Add to dependencies array
+            return content.replace('dependencies = [', `dependencies = [\n"${depName}",`);
+        };
+        // Helper function to add source to pyproject.toml
+        const addSourceToPyproject = (content, source) => {
+            // Check if source already exists (by checking for the package name)
+            if (content.includes(`${flags.name} =`)) {
+                return content;
+            }
+            // Add to [tool.uv.sources] section
+            return content.replace('[tool.uv.sources]', `[tool.uv.sources]\n${source}\n`);
+        };
+        // Helper function to remove dependency from pyproject.toml
+        const removeDependencyFromPyproject = (content, depName) => {
+            // Remove from dependencies array - handle both formats: "depName", or "depName",\n
+            let result = content.replace(`"${depName}",`, '').replace(`"${depName}"`, '');
+            // Also try to remove with newline variations
+            result = result.replace(`\n"${depName}",`, '').replace(`"${depName}",\n`, '');
+            return result;
+        };
+        // Helper function to remove source from pyproject.toml
+        const removeSourceFromPyproject = (content, pkgName) => {
+            // Remove source line for this package
+            const sourceRegex = new RegExp(`${pkgName}\\s*=\\s*\\{[^}]*\\}\n?`, 'g');
+            return content.replace(sourceRegex, '');
+        };
+        let newPyproject = pyproject;
         if (!flags['dry-run']) {
-            pyproject = pyproject.replace('dependencies = [', `dependencies = [\n"${flags.name}",`);
-            pyproject = pyproject.replace('[tool.uv.sources]', `[tool.uv.sources]\n${lineToAdd}\n`);
+            if (args.op === 'install') {
+                newPyproject = addDependencyToPyproject(pyproject, flags.name);
+                newPyproject = addSourceToPyproject(newPyproject, lineToAdd);
+            }
+            else if (args.op === 'uninstall') {
+                newPyproject = removeDependencyFromPyproject(pyproject, flags.name);
+                newPyproject = removeSourceFromPyproject(newPyproject, flags.name);
+            }
         }
-        const newPyproject = pyproject;
         // Add the elixir import and bootstrap to the server.py file
         let CliImport = `from ${expoName}.bootstrap import bootstrap as ${expoName}_bootstrap\n`;
         CliImport += `${expoName}_bootstrap()\n`;
@@ -171,48 +421,99 @@ ${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
     `;
-        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 = 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 = 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 = flags['dry-run'] ? '' : newNormalRoute.replace('# DHTI_COMMON_ROUTE', `#DHTI_COMMON_ROUTES${commonRoutes}`);
-        // if args.op === install, add the line to the pyproject.toml file
+        // Helper function to add elixir to server.py
+        // The strategy is to append imports BEFORE the 'import uvicorn' line
+        // and append routes AFTER the route marker comments
+        const addElixirToServer = (elixirName) => {
+            // Read fresh file content each time to get the current state
+            const content = flags['dry-run'] ? '' : fs.readFileSync(`${elixirDir}/app/server.py`, 'utf8');
+            if (flags['dry-run'] || content === '') {
+                return '';
+            }
+            // Check if elixir already installed
+            if (content.includes(`${elixirName}_bootstrap`)) {
+                return content;
+            }
+            let result = content;
+            // Find where to insert the import - look for 'import uvicorn' and insert before it
+            // This way, all imports are together before uvicorn import
+            if (!result.includes('import uvicorn')) {
+                console.error(chalk.red('Error: Could not find "import uvicorn" marker in server.py'));
+                return content;
+            }
+            result = result.replace('import uvicorn', `${CliImport}\nimport uvicorn`);
+            // For routes, we need to insert into both langfuse and normal route sections
+            // But only if they exist
+            // Find the langfuse try block and insert before 'except'
+            if (result.includes('except:')) {
+                // Insert langfuse route before except with proper indentation
+                result = result.replace('except:', `    ${langfuseRoute}\n\nexcept:`);
+                // Insert normal route in the except block, after the '# DHTI_NORMAL_ROUTE' marker
+                result = result.replace('# DHTI_NORMAL_ROUTE\n', `# DHTI_NORMAL_ROUTE\n    ${normalRoute}\n`);
+            }
+            // For common routes, look for the marker and append with proper indentation
+            const commonRoutesMarker = '# DHTI_COMMON_ROUTE';
+            if (result.includes(commonRoutesMarker)) {
+                // Get the exact indentation by checking what comes after the marker
+                const markerIndex = result.indexOf(commonRoutesMarker);
+                const afterMarker = result.substring(markerIndex + commonRoutesMarker.length);
+                const newlineAndIndent = afterMarker.match(/\n[ \t]*/)?.[0] || '\n';
+                result = result.replace(commonRoutesMarker, `${commonRoutesMarker}${newlineAndIndent}${commonRoutes}`);
+            }
+            return result;
+        };
+        // Helper function to remove elixir from server.py
+        const removeElixirFromServer = () => {
+            // Read fresh file content each time to get the current state
+            const content = flags['dry-run'] ? '' : fs.readFileSync(`${elixirDir}/app/server.py`, 'utf8');
+            if (flags['dry-run'] || content === '') {
+                return '';
+            }
+            let result = content;
+            result = result.replace(CliImport, '');
+            result = result.replace(langfuseRoute, '');
+            result = result.replace(normalRoute, '');
+            result = result.replace(commonRoutes, '');
+            return result;
+        };
+        let finalRoute = '';
+        if (!flags['dry-run'] && args.op === 'install') {
+            finalRoute = addElixirToServer(expoName);
+        }
+        else if (!flags['dry-run'] && args.op === 'uninstall') {
+            finalRoute = removeElixirFromServer();
+        }
         if (args.op === 'install') {
             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.cyan(`  - ${elixirDir}/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.cyan(`  - ${elixirDir}/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);
+                fs.writeFileSync(`${elixirDir}/pyproject.toml`, newPyproject);
+                fs.writeFileSync(`${elixirDir}/app/server.py`, finalRoute);
+                console.log(chalk.green(`✓ Elixir '${flags.name}' installed successfully`));
             }
         }
         if (args.op === 'uninstall') {
             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.cyan(`  - ${elixirDir}/pyproject.toml`));
+                console.log(chalk.green(`    Remove dependency: "${flags.name}"`));
                 console.log(chalk.green(`    Remove source: ${lineToAdd}`));
-                console.log(chalk.cyan(`  - ${flags.workdir}/elixir/app/server.py`));
+                console.log(chalk.cyan(`  - ${elixirDir}/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);
+                fs.writeFileSync(`${elixirDir}/pyproject.toml`, newPyproject);
+                fs.writeFileSync(`${elixirDir}/app/server.py`, finalRoute);
+                console.log(chalk.green(`✓ Elixir '${flags.name}' uninstalled successfully`));
             }
         }
     }

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

@@ -1,4 +1,3 @@
-version: "3.7"
 
 services:
   gateway:
@@ -72,6 +71,7 @@ services:
 
   langserve:
     image: beapen/genai:latest
+    network_mode: host
     pull_policy: always
     ports:
       - "8001:8001"
@@ -86,6 +86,8 @@ services:
       - OPENAI_API_KEY=${OPENAI_API_KEY:-openai-api-key}
       - OPENAI_API_BASE=${OPENAI_API_BASE:-https://openrouter.ai/api/v1}
       - OPENROUTER_API_KEY=${OPENROUTER_API_KEY:-openrouter-api-key}
+      - FHIR_BASE_URL=${FHIR_BASE_URL:-http://localhost:8080/openmrs/ws/fhir2/R4}
+
 
   ollama:
     image: ollama/ollama:latest
@@ -213,7 +215,7 @@ services:
     environment:
       - REDIS_HOSTS=local:redis:6379
     ports:
-      - "8081:8081"
+      - "8181:8081"
 
   neo4j:
     image: neo4j:5.1-enterprise

package/dist/resources/spa/README.md

@@ -0,0 +1,3 @@
+## Notes
+
+* spa folder is not used and can be deleted once the old OpenMRS container based invocation is completely phased out.

package/dist/resources/spa/config-schema.ts

@@ -0,0 +1,53 @@
+import {Type, validator} from '@openmrs/esm-framework'
+
+/**
+ * This is the config schema. It expects a configuration object which
+ * looks like this:
+ *
+ * ```json
+ * { "casualGreeting": true, "whoToGreet": ["Mom"] }
+ * ```
+ *
+ * In OpenMRS Microfrontends, all config parameters are optional. Thus,
+ * all elements must have a reasonable default. A good default is one
+ * that works well with the reference application.
+ *
+ * To understand the schema below, please read the configuration system
+ * documentation:
+ *   https://openmrs.github.io/openmrs-esm-core/#/main/config
+ * Note especially the section "How do I make my module configurable?"
+ *   https://openmrs.github.io/openmrs-esm-core/#/main/config?id=im-developing-an-esm-module-how-do-i-make-it-configurable
+ * and the Schema Reference
+ *   https://openmrs.github.io/openmrs-esm-core/#/main/config?id=schema-reference
+ */
+export const configSchema = {
+  casualGreeting: {
+    _type: Type.Boolean,
+    _default: false,
+    _description: 'Whether to use a casual greeting (or a formal one).',
+  },
+  dhtiTitle: {
+    _type: Type.String,
+    _default: 'DHTI Template Widget',
+    _description: 'Title to display for the DHTI Template Widget',
+  },
+  dhtiRoute: {
+    _type: Type.String,
+    _default: 'http://localhost:8001/langserve/dhti_elixir_template/cds-services/dhti-service',
+    _description: 'Route for the DHTI Template Service',
+  },
+  whoToGreet: {
+    _type: Type.Array,
+    _default: ['World'],
+    _description: 'Who should be greeted. Names will be separated by a comma and space.',
+    _elements: {
+      _type: Type.String,
+    },
+    _validators: [validator((v) => v.length > 0, 'At least one person must be greeted.')],
+  },
+}
+
+export type Config = {
+  casualGreeting: boolean
+  whoToGreet: Array<string>
+}

package/dist/resources/spa/glycemic.component.tsx

@@ -0,0 +1,86 @@
+import React, { useEffect, useState } from 'react';
+import { useConfig, openmrsFetch, fhirBaseUrl } from '@openmrs/esm-framework';
+import useSWR from 'swr';
+import styles from './glycemic.scss';
+import { useDhti } from './hooks/useDhti';
+
+interface GlycemicWidgetProps {
+    patientUuid: string;
+}
+
+const GlycemicWidget: React.FC<GlycemicWidgetProps> = ({ patientUuid }) => {
+    const config = useConfig();
+    const serviceName = config?.dhtiServiceName || 'dhti_elixir_glycemic';
+    const { submitMessage, loading: aiLoading, error: aiError } = useDhti();
+    const [aiResponse, setAiResponse] = useState<any>(null);
+
+    // Check for Diabetes (SNOMED 44054006)
+    const { data: conditionsData, isLoading: conditionsLoading } = useSWR<any>(
+        patientUuid ? `${fhirBaseUrl}/Condition?patient=${patientUuid}&code=44054006` : null,
+        openmrsFetch
+    );
+
+    const isDiabetic = conditionsData?.data?.entry?.length > 0;
+
+    // Fetch HbA1c (4548-4) and Glucose (2339-0) observations
+    const { data: obsData, isLoading: obsLoading } = useSWR<any>(
+        isDiabetic ? `${fhirBaseUrl}/Observation?patient=${patientUuid}&code=4548-4,2339-0&_sort=-date&_count=5` : null,
+        openmrsFetch
+    );
+
+    useEffect(() => {
+        if (!isDiabetic && !aiResponse && !aiLoading && !aiError) {
+            submitMessage('Analyze glycemic control', patientUuid).then(setAiResponse);
+        }
+    }, [isDiabetic, patientUuid, submitMessage, aiResponse, aiLoading, aiError]);
+
+    // if (conditionsLoading) return null;
+    // if (!isDiabetic) return null;
+
+    return (
+        <div className={styles.container}>
+            <div className={styles.header}>
+                <h3>{config?.dhtiTitle || 'DHTI Glycemic Widget'}</h3>
+            </div>
+
+            <div className={styles.content}>
+                <div className={styles.observations}>
+                    <h4>Latest Readings</h4>
+                    {obsLoading ? (
+                        <p>Loading observations...</p>
+                    ) : obsData?.data?.entry?.length > 0 ? (
+                        <ul>
+                            {obsData.data.entry.map((entry: any) => {
+                                const obs = entry.resource;
+                                const value = obs.valueQuantity ? `${obs.valueQuantity.value} ${obs.valueQuantity.unit}` : obs.valueString;
+                                const date = new Date(obs.effectiveDateTime).toLocaleDateString();
+                                const name = obs.code?.text || obs.code?.coding?.[0]?.display || 'Observation';
+                                return (
+                                    <li key={obs.id}>
+                                        <strong>{name}:</strong> {value} <small>({date})</small>
+                                    </li>
+                                );
+                            })}
+                        </ul>
+                    ) : (
+                        <p>No recent HbA1c or Glucose readings found.</p>
+                    )}
+                </div>
+
+                <div className={styles.aiInsights}>
+                    <h4>GenAI Interpretation</h4>
+                    {aiLoading && <p>Generating insights...</p>}
+                    {aiError && <p className={styles.error}>Error: {aiError}</p>}
+                    {aiResponse && (
+                        <div className={styles.aiContent}>
+                            <p>{aiResponse.summary}</p>
+                            {aiResponse.detail && <p><small>{aiResponse.detail}</small></p>}
+                        </div>
+                    )}
+                </div>
+            </div>
+        </div>
+    );
+};
+
+export default GlycemicWidget;