dhti-cli 0.7.1 → 1.0.1

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,7 +27,17 @@ 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' }),
         pypi: Flags.string({
             char: 'p',
@@ -31,6 +45,11 @@ export default class Elixir extends Command {
             description: 'PyPi package to install. Ex: dhti-elixir-base = ">=0.1.0"',
         }),
         repoVersion: Flags.string({ char: 'v', default: '0.1.0', description: 'Version of the elixir' }),
+        subdirectory: Flags.string({
+            char: 's',
+            default: 'none',
+            description: 'Subdirectory in the repository to install from (for monorepos)',
+        }),
         whl: Flags.string({ char: 'e', default: 'none', description: 'Whl file to install' }),
         workdir: Flags.string({
             char: 'w',
@@ -44,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);
@@ -126,11 +341,31 @@ export default class Elixir extends Command {
             lineToAdd = `${flags.name} = { file = "whl/${path.basename(flags.whl)}" }`;
         }
         if (flags.git !== 'none') {
-            lineToAdd = `${flags.name} = { git = "${flags.git}", branch = "${flags.branch}" }`;
+            lineToAdd =
+                flags.subdirectory === 'none'
+                    ? `${flags.name} = { git = "${flags.git}", branch = "${flags.branch}" }`
+                    : `${flags.name} = { git = "${flags.git}", branch = "${flags.branch}", subdirectory = "${flags.subdirectory}" }`;
         }
         if (flags.pypi !== 'none') {
             lineToAdd = flags.pypi;
         }
+        if (flags.local !== 'none') {
+            // Use path for local directory installation
+            const absolutePath = path.isAbsolute(flags.local) ? flags.local : path.resolve(process.cwd(), flags.local);
+            // Validate that the path exists and is a directory (skip validation in dry-run mode)
+            if (!flags['dry-run']) {
+                if (!fs.existsSync(absolutePath)) {
+                    console.error(chalk.red(`Error: Local directory does not exist: ${absolutePath}`));
+                    this.exit(1);
+                }
+                const stats = fs.statSync(absolutePath);
+                if (!stats.isDirectory()) {
+                    console.error(chalk.red(`Error: Path is not a directory: ${absolutePath}`));
+                    this.exit(1);
+                }
+            }
+            lineToAdd = `${flags.name} = { path = "${absolutePath}" }`;
+        }
         if (!flags['dry-run']) {
             pyproject = pyproject.replace('dependencies = [', `dependencies = [\n"${flags.name}",`);
             pyproject = pyproject.replace('[tool.uv.sources]', `[tool.uv.sources]\n${lineToAdd}\n`);
@@ -152,11 +387,17 @@ mcp_server.add_tool(${expoName}_mcp_tool) # type: ignore
                 .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 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 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}`);
+        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') {
             if (flags['dry-run']) {

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

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;

package/dist/resources/spa/glycemic.scss

@@ -0,0 +1,44 @@
+.container {
+  padding: 1rem;
+  background-color: var(--ui-01);
+  border: 1px solid var(--ui-03);
+  margin-bottom: 1rem;
+}
+
+.header {
+  margin-bottom: 1rem;
+  h3 {
+    margin: 0;
+  }
+}
+
+.content {
+  display: flex;
+  gap: 2rem;
+  flex-wrap: wrap;
+}
+
+.observations, .aiInsights {
+  flex: 1;
+  min-width: 300px;
+}
+
+.observations ul {
+  list-style: none;
+  padding: 0;
+  li {
+    margin-bottom: 0.5rem;
+    border-bottom: 1px solid var(--ui-03);
+    padding-bottom: 0.25rem;
+  }
+}
+
+.aiContent {
+  background-color: var(--ui-02);
+  padding: 1rem;
+  border-radius: 4px;
+}
+
+.error {
+  color: var(--support-01);
+}

package/dist/resources/spa/hooks/useDhti.ts

@@ -0,0 +1,69 @@
+import {useState} from 'react'
+import axios from 'axios'
+import {CDSHookRequest} from '../models/request'
+import {CDSHookCard} from '../models/card'
+import {useConfig, openmrsFetch, fhirBaseUrl} from '@openmrs/esm-framework'
+
+interface UseDhtiReturn {
+  submitMessage: (newMessage: string, patientId?: string) => Promise<CDSHookCard | null>
+  loading: boolean
+  error: string | null
+}
+
+/**
+ * Custom hook to handle DHTI service submissions
+ * @returns Object with submitMessage function, loading state, and error state
+ */
+export const useDhti = (): UseDhtiReturn => {
+  const [loading, setLoading] = useState<boolean>(false)
+  const [error, setError] = useState<string | null>(null)
+  const config = useConfig()
+
+  const submitMessage = async (newMessage: string, patientId?: string): Promise<CDSHookCard | null> => {
+    setLoading(true)
+    setError(null)
+
+    try {
+      const request = new CDSHookRequest({
+        context: {input: newMessage, patientId: patientId || undefined},
+      })
+
+      // TODO: Investigate why nested input is required
+      const _request = {
+        input: request,
+      }
+
+      const response = await axios.post(
+        config?.dhtiRoute || 'http://localhost:8001/langserve/dhti_elixir_template/cds-services/dhti-service',
+        {
+          input: _request,
+          config: {},
+          kwargs: {},
+        },
+        {
+          headers: {
+            'Access-Control-Allow-Origin': '*',
+          },
+        },
+      )
+
+      // Assuming the response contains a card or cards
+      if (response.data && response.data.cards && response.data.cards.length > 0) {
+        return CDSHookCard.from(response.data.cards[0])
+      } else if (response.data && response.data.summary) {
+        // Handle case where response is directly a card (must have summary property)
+        return CDSHookCard.from(response.data)
+      }
+
+      return null
+    } catch (err: any) {
+      const errorMessage = err.response?.data?.message || err.message || 'Failed to submit message'
+      setError(errorMessage)
+      return null
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  return {submitMessage, loading, error}
+}

package/dist/resources/spa/hooks/usePatient.ts

@@ -0,0 +1,61 @@
+import useSWR from 'swr'
+import {fhirBaseUrl, openmrsFetch} from '@openmrs/esm-framework'
+
+/**
+ * This hook searches for a patient using the provided search term from the
+ * OpenMRS FHIR API. It leverages the useSWR hook from the SWR library
+ * https://swr.vercel.app/docs/data-fetching to fetch data. SWR provides a
+ * number of benefits over the standard React useEffect hook, including:
+ *
+ * - Fast, lightweight and reusable data fetching
+ * - Built-in cache and request deduplication
+ * - Real-time updates
+ * - Simplified error and loading state handling, and more.
+ *
+ *  We recommend using SWR for data fetching in your OpenMRS frontend modules.
+ *
+ * See the docs for the underlying fhir.js Client object: https://github.com/FHIR/fhir.js#api
+ * See the OpenMRS FHIR Module docs: https://wiki.openmrs.org/display/projects/OpenMRS+FHIR+Module
+ * See the OpenMRS REST API docs: https://rest.openmrs.org/#openmrs-rest-api
+ *
+ * @param query A patient name or ID
+ * @returns The first matching patient
+ */
+
+export function usePatient(query: string) {
+  // If query has a number anywhere in it, treat it as an identifier search
+  const isId = /\d/.test(query)
+  let url = null
+  if (query && query.trim()) {
+    if (isId) {
+      url = `${fhirBaseUrl}/Patient?identifier=${encodeURIComponent(query.trim())}&_summary=data`
+    } else {
+      url = `${fhirBaseUrl}/Patient?name=${encodeURIComponent(query.trim())}&_summary=data`
+    }
+  }
+  const {data, error, isLoading} = useSWR<any, Error>(url, openmrsFetch)
+
+  let patient = null
+  // * Use the code below to handle direct ID searches, if needed in future
+  // --- IGNORE ---
+  // if (isId) {
+  //   // FHIR /Patient/{id} returns the patient directly
+  //   if (data && data.resourceType === 'Patient') {
+  //     patient = data;
+  //   }
+  // } else {
+  //   if (data && data.data && Array.isArray(data.data.entry) && data.data.entry.length > 0) {
+  //     patient = data.data.entry[0].resource;
+  //   }
+  // }
+
+  if (data && data.data && Array.isArray(data.data.entry) && data.data.entry.length > 0) {
+    patient = data.data.entry[0].resource
+  }
+
+  return {
+    patient,
+    error: error,
+    isLoading,
+  }
+}

package/dist/resources/spa/index.ts

@@ -0,0 +1,17 @@
+import {getAsyncLifecycle, defineConfigSchema} from '@openmrs/esm-framework'
+import {configSchema} from './config-schema'
+
+const moduleName = '@openmrs/esm-dhti-glycemic'
+
+const options = {
+  featureName: 'dhti-glycemic',
+  moduleName,
+}
+
+export const importTranslation = require.context('../translations', false, /.json$/, 'lazy')
+
+export function startupApp() {
+  defineConfigSchema(moduleName, configSchema)
+}
+
+export const glycemic = getAsyncLifecycle(() => import('./glycemic.component'), options)