@cellaware/utils 8.0.3 → 8.1.0

package/dist/chatwms/developer.d.ts

@@ -0,0 +1,27 @@
+import { KeyValuePair } from "../util.js";
+import { DataContext } from "./client.js";
+export interface SqlCacheContext {
+    contextName: DataContext;
+    variables: KeyValuePair[];
+    tables: {
+        table_name: string;
+        table_description: string;
+    }[];
+    columns: {
+        table_name: string;
+        column_id: number;
+        column_name: string;
+        data_type: string;
+        column_description: string;
+        column_comment: string;
+    }[];
+    functions: {
+        name: string;
+        type: string;
+        args: string[];
+        description: string;
+    }[];
+    tableMappings: KeyValuePair[];
+    columnMappings: KeyValuePair[];
+}
+export declare function initSqlCacheContext(): SqlCacheContext;

package/dist/chatwms/developer.js

@@ -0,0 +1,12 @@
+import { CHATWMS_CONTEXT_NAME } from "./client.js";
+export function initSqlCacheContext() {
+    return {
+        contextName: CHATWMS_CONTEXT_NAME,
+        variables: [],
+        tables: [],
+        columns: [],
+        functions: [],
+        tableMappings: [],
+        columnMappings: []
+    };
+}

package/dist/chatwms/github/issue.d.ts

@@ -0,0 +1 @@
+export declare function chatwmsGithubCreateIssue(title: string, body: any, labels: string[]): Promise<boolean>;

package/dist/chatwms/github/issue.js

@@ -0,0 +1,4 @@
+import { githubCreateIssue } from "../../github/issue.js";
+export async function chatwmsGithubCreateIssue(title, body, labels) {
+    return githubCreateIssue(`https://api.github.com/repos/cellaware/chatwms-feedback/issues`, title, body, labels);
+}

package/dist/chatwms/instance.d.ts

@@ -0,0 +1,16 @@
+export interface ChatWMSInstance {
+    id: string;
+    clientId: string;
+    customer: string;
+    description: string;
+    url: string;
+    key: string;
+}
+export declare function initChatWMSInstance(): ChatWMSInstance;
+export interface ChatWMSInstanceWarehouse {
+    instanceId: string;
+    clientId: string;
+    customer: string;
+    warehouse: string;
+}
+export declare function initChatWMSInstanceWarehouse(): ChatWMSInstanceWarehouse;

package/dist/chatwms/instance.js

@@ -0,0 +1,18 @@
+export function initChatWMSInstance() {
+    return {
+        id: '',
+        clientId: '',
+        customer: '',
+        description: '',
+        url: '',
+        key: ''
+    };
+}
+export function initChatWMSInstanceWarehouse() {
+    return {
+        instanceId: '',
+        clientId: '',
+        customer: '',
+        warehouse: '',
+    };
+}

package/dist/chatwms/report.d.ts

@@ -0,0 +1,69 @@
+import { DataContext } from "./client.js";
+import { DatagridStateBase } from "./datagrid.js";
+export declare const REPORT_VISIBILITY_PRIVATE = "private";
+export declare const REPORT_VISIBILITY_PUBLIC = "public";
+export declare const REPORT_VISIBILITY_GLOBAL = "global";
+export interface ReportParameter {
+    sequence: number;
+    name: string;
+    required: boolean;
+    exampleValue: string;
+}
+export interface Report {
+    reportId: string;
+    reportTitle: string;
+    reportRoute: string;
+    visibility: string;
+    readonly: boolean;
+    parameters: ReportParameter[];
+    folder: string;
+    brief: string;
+    clientId: string;
+    userId: string;
+    customerLevel?: boolean;
+}
+export declare function initReport(): Report;
+export interface LineReportParameter {
+    sequence: number;
+    parameterName: string;
+    columnName: string;
+}
+export interface ReportLineContentInfo extends DatagridStateBase {
+    visualizationOption: string;
+    reportParameters: LineReportParameter[];
+    contextName: DataContext;
+    specification: string;
+    query: string;
+    summary: string;
+    reviewOk?: boolean;
+    reviewConfidence?: string;
+    reviewFeedback?: string;
+    tableGroups?: string[];
+    developer?: boolean;
+    archive?: boolean;
+    referenceLineId?: string;
+}
+export interface ReportLine {
+    lineId: string;
+    lineTitle: string;
+    reportId: string;
+    contentInfo: ReportLineContentInfo;
+    sequence: number;
+    clientId: string;
+    userId: string;
+}
+export interface ReportLineResult {
+    rows: any[];
+    rowsStr: string;
+    chartRows: any[];
+}
+export declare function initReportLineResult(): ReportLineResult;
+export interface ReportUsage {
+    reportId: string;
+    reportTitle: string;
+    visibility: string;
+    clientId: string;
+    userId: string;
+    datetime: Date;
+    customerLevel?: boolean;
+}

package/dist/chatwms/report.js

@@ -0,0 +1,24 @@
+export const REPORT_VISIBILITY_PRIVATE = 'private';
+export const REPORT_VISIBILITY_PUBLIC = 'public';
+export const REPORT_VISIBILITY_GLOBAL = 'global';
+export function initReport() {
+    return {
+        reportId: '',
+        reportTitle: '',
+        reportRoute: '',
+        visibility: REPORT_VISIBILITY_PRIVATE,
+        readonly: false,
+        parameters: [],
+        folder: '',
+        brief: '',
+        clientId: '',
+        userId: ''
+    };
+}
+export function initReportLineResult() {
+    return {
+        rows: [],
+        rowsStr: '',
+        chartRows: []
+    };
+}

package/dist/chatwms/response.d.ts

@@ -0,0 +1,12 @@
+export interface ChatWMSResponse {
+    ok: boolean;
+    error: string;
+    data: any;
+}
+/**
+ * Initialization:
+ * - `ok`: `true`
+ * - `error`: `''`
+ * - `data`: `{}`
+ */
+export declare function initChatWMSResponse(data?: any): ChatWMSResponse;

package/dist/chatwms/response.js

@@ -0,0 +1,13 @@
+/**
+ * Initialization:
+ * - `ok`: `true`
+ * - `error`: `''`
+ * - `data`: `{}`
+ */
+export function initChatWMSResponse(data) {
+    return {
+        ok: true,
+        error: '',
+        data: data ?? {}
+    };
+}

package/dist/chatwms/search.d.ts

@@ -0,0 +1,12 @@
+export declare enum SearchRecordType {
+    DASHBOARD = "dashboard",
+    DASHBOARD_WIDGET = "dashboard_widget",
+    DASHBOARD_FOLDER = "dashboard_folder",
+    REPORT = "report",
+    REPORT_LINE = "report_line",
+    REPORT_FOLDER = "report_folder"
+}
+export interface SearchRecord {
+    type: SearchRecordType;
+    data: any;
+}

package/dist/chatwms/search.js

@@ -0,0 +1,9 @@
+export var SearchRecordType;
+(function (SearchRecordType) {
+    SearchRecordType["DASHBOARD"] = "dashboard";
+    SearchRecordType["DASHBOARD_WIDGET"] = "dashboard_widget";
+    SearchRecordType["DASHBOARD_FOLDER"] = "dashboard_folder";
+    SearchRecordType["REPORT"] = "report";
+    SearchRecordType["REPORT_LINE"] = "report_line";
+    SearchRecordType["REPORT_FOLDER"] = "report_folder";
+})(SearchRecordType || (SearchRecordType = {}));

package/dist/chatwms/user.d.ts

@@ -0,0 +1,27 @@
+import { HttpRequest } from "@azure/functions";
+export interface ChatWMSUserData {
+    userId: string;
+    userDetails: string;
+    identityProvider: string;
+}
+export declare function chatwmsInitUserData(): ChatWMSUserData;
+/**
+ * NOTE: will throw error if empty principal or decode issue
+ */
+export declare function chatwmsExtractUserDataFromHeaders(request: HttpRequest): ChatWMSUserData;
+export declare const CHATWMS_DEFAULT_LANGUAGE: string;
+export type ChatWMSTheme = 'light' | 'dark';
+export declare const CHATWMS_THEME_LIGHT: ChatWMSTheme;
+export declare const CHATWMS_THEME_DARK: ChatWMSTheme;
+export type ChatWMSDateFormat = 'MMDDYYYY' | 'DDMMYYYY' | 'YYYYMMDD';
+export declare const CHATWMS_DEFAULT_DATE_FORMAT: ChatWMSDateFormat;
+export interface ChatWMSUserSettings {
+    userId: string;
+    userDetails: string;
+    language: string;
+    theme: ChatWMSTheme;
+    developer?: boolean;
+    dateFormat?: ChatWMSDateFormat;
+    clientId: string;
+}
+export declare function chatwmsInitUserSettings(): ChatWMSUserSettings;

package/dist/chatwms/user.js

@@ -0,0 +1,40 @@
+import { AZURE_HEADER_PRINCIPAL } from "../azure/function.js";
+export function chatwmsInitUserData() {
+    return {
+        userId: '',
+        userDetails: '',
+        identityProvider: ''
+    };
+}
+/**
+ * NOTE: will throw error if empty principal or decode issue
+ */
+export function chatwmsExtractUserDataFromHeaders(request) {
+    // https://learn.microsoft.com/en-us/azure/static-web-apps/user-information
+    const principal = request.headers.get(AZURE_HEADER_PRINCIPAL) ?? '';
+    if (principal !== '') {
+        try {
+            const userData = JSON.parse(Buffer.from(principal, 'base64').toString('utf8'));
+            return userData;
+        }
+        catch (err) {
+            throw new Error(`Authorization error`);
+        }
+    }
+    else {
+        throw new Error(`Authorization header not found`);
+    }
+}
+export const CHATWMS_DEFAULT_LANGUAGE = 'English';
+export const CHATWMS_THEME_LIGHT = 'light';
+export const CHATWMS_THEME_DARK = 'dark';
+export const CHATWMS_DEFAULT_DATE_FORMAT = 'MMDDYYYY';
+export function chatwmsInitUserSettings() {
+    return {
+        userId: '',
+        userDetails: '',
+        language: CHATWMS_DEFAULT_LANGUAGE,
+        theme: CHATWMS_THEME_LIGHT,
+        clientId: ''
+    };
+}

package/dist/github/issue.d.ts

@@ -0,0 +1 @@
+export declare function githubCreateIssue(issueUrl: string, issueTitle: string, issueBody: any, issueLabels: string[]): Promise<boolean>;

package/dist/github/issue.js

@@ -0,0 +1,23 @@
+export async function githubCreateIssue(issueUrl, issueTitle, issueBody, issueLabels) {
+    const token = process.env.GITHUB_TOKEN ?? '';
+    if (token.length === 0) {
+        throw new Error('GITHUB: `GITHUB_TOKEN` environment variable is not set');
+    }
+    const headers = {
+        'Authorization': `token ${token}`,
+        'X-GitHub-Api-Version': '2022-11-28',
+        'Accept': 'application/vnd.github+json'
+    };
+    const body = {
+        title: issueTitle,
+        body: issueBody,
+        labels: issueLabels
+    };
+    const req = {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+    };
+    let res = await fetch(issueUrl, req);
+    return res.ok;
+}

package/dist/llm/chain-store.d.ts

@@ -0,0 +1,49 @@
+import { BaseChain } from 'langchain/chains';
+import { ModelName, ModelOptions } from './model.js';
+/**
+ * `SingleActionChain` only supports single interaction with LLM, and only 1
+ * output key is allowed. Output key is defaulted to `answer`.
+ */
+export declare class SingleActionChain extends BaseChain {
+    private _name;
+    private llm;
+    private _inputKeys;
+    private _outputKey;
+    private prompt;
+    private promptTemplate;
+    constructor(fields: any, name: string, inputKeys: string[]);
+    _call(values: any, runManager: any): Promise<any>;
+    _chainType(): string;
+    get inputKeys(): string[];
+    get outputKeys(): string[];
+    getModelName(): ModelName;
+    getPrompt(): string;
+}
+export declare function createSingleActionChain(name: string, modelName: ModelName, inputKeys: string[], prompt: string, temperature?: number, verbose?: boolean): SingleActionChain;
+/**
+ * A `ChainStore` is a chain registry and calling interface. The `ChainStore`
+ * keeps a map of all registered chains.
+ *
+ * The following chains are built-in:
+ *  - `translation_chain`: `translate()`
+ *
+ */
+export declare class ChainStore {
+    private promptsPath;
+    private chains;
+    constructor(promptsPath: string, defaultModelName?: ModelName);
+    private initBuiltinChains;
+    private static getTokenUsage;
+    private getPrompt;
+    /**
+     * - `name`: Chain name
+     * - `template`: Template chain name to copy prompt from
+     * - `options`: LLM options
+     * - `verbose`: OpenAI verbose parameter
+     */
+    addChain(name: string, template: string | null, options: ModelOptions, verbose?: boolean): void;
+    addExistingChain(chain: SingleActionChain): void;
+    callChain(name: string, args: any, tokenUsages: any[]): Promise<import("@langchain/core/utils/types.js").ChainValues>;
+    translate(statement: string, language: string, tokenUsages?: any[]): Promise<string>;
+    getPrompts(): string;
+}

package/dist/llm/chain-store.js

@@ -0,0 +1,284 @@
+import fs from 'fs';
+import { BaseChain } from 'langchain/chains';
+import { ChatPromptTemplate } from "@langchain/core/prompts";
+import { ChatOpenAI } from "@langchain/openai";
+import { StringOutputParser } from "@langchain/core/output_parsers";
+import { getLLMTransactionCost } from './cost.js';
+const CHAIN_TIMEOUT_MS = 150_000;
+const TRANSLATION_CHAIN_NAME = 'translation_chain';
+/**
+ * `SingleActionChain` only supports single interaction with LLM, and only 1
+ * output key is allowed. Output key is defaulted to `answer`.
+ */
+export class SingleActionChain extends BaseChain {
+    constructor(fields, name, inputKeys) {
+        super(fields);
+        Object.defineProperty(this, "_name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_inputKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "prompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "promptTemplate", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (inputKeys.length == 0) {
+            throw new Error(`SINGLE_ACTION_CHAIN: Chain '${name}' needs at least one input key!`);
+        }
+        this._name = name;
+        this.llm = fields.llm;
+        this._inputKeys = inputKeys;
+        this._outputKey = 'answer';
+        this.prompt = fields.prompt;
+        this.promptTemplate = ChatPromptTemplate.fromTemplate(this.prompt);
+    }
+    async _call(values, runManager) {
+        let output = {
+            [this._outputKey]: ''
+        };
+        const llmChain = this.promptTemplate
+            .pipe(this.llm)
+            .pipe(new StringOutputParser());
+        let llmInputs = {};
+        for (const inputKey of this._inputKeys) {
+            llmInputs[inputKey] = values[inputKey];
+        }
+        let callbacks = undefined;
+        if (!!runManager && !!runManager.getChild()) {
+            callbacks = runManager.getChild().handlers;
+        }
+        const llmAnswer = await llmChain.invoke(llmInputs, {
+            callbacks
+        });
+        output[this._outputKey] = llmAnswer;
+        return output;
+    }
+    _chainType() {
+        return this._name;
+    }
+    get inputKeys() {
+        return this._inputKeys;
+    }
+    get outputKeys() {
+        return [this._outputKey];
+    }
+    getModelName() {
+        return this.llm.modelName;
+    }
+    getPrompt() {
+        return this.prompt;
+    }
+}
+export function createSingleActionChain(name, modelName, inputKeys, prompt, temperature, verbose) {
+    const llm = new ChatOpenAI({
+        modelName, temperature: temperature ?? 0, configuration: {
+            organization: process.env.OPENAI_ORGANIZATION,
+            timeout: CHAIN_TIMEOUT_MS
+        }
+    });
+    return new SingleActionChain({
+        llm,
+        prompt,
+        verbose: verbose ?? false
+    }, name, inputKeys);
+}
+/**
+ * A `ChainStore` is a chain registry and calling interface. The `ChainStore`
+ * keeps a map of all registered chains.
+ *
+ * The following chains are built-in:
+ *  - `translation_chain`: `translate()`
+ *
+ */
+export class ChainStore {
+    constructor(promptsPath, defaultModelName) {
+        Object.defineProperty(this, "promptsPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "chains", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.promptsPath = promptsPath;
+        this.chains = new Map();
+        this.initBuiltinChains(defaultModelName);
+    }
+    initBuiltinChains(defaultModelName) {
+        // Translation Chain:
+        {
+            this.addExistingChain(createSingleActionChain(TRANSLATION_CHAIN_NAME, defaultModelName ?? 'gpt-4o-mini', ['statement', 'language'], `You are a helpful AI translator who translates an English statement to {language}.
+
+Given an English statement, translate the English statement into {language}. 
+
+Here is the English statement that you need to translate to {language}:
+{statement}
+
+Your translation here:
+`));
+        }
+    }
+    static getTokenUsage(chainName, modelName, tokenUsage) {
+        return {
+            chain: chainName,
+            model: modelName,
+            tokenUsage,
+            cost: getLLMTransactionCost(tokenUsage, modelName)
+        };
+    }
+    getPrompt(chainName, templateChainName) {
+        let prompt = {
+            content: '',
+            variables: []
+        };
+        const path = !!templateChainName ? `${this.promptsPath}/${templateChainName}.md` : `${this.promptsPath}/${chainName}.md`;
+        if (!fs.existsSync(path)) {
+            throw new Error(`CHAIN_STORE: Prompt file '${path}' not found`);
+        }
+        const content = fs.readFileSync(path, 'utf8');
+        if (content.length === 0) {
+            throw new Error(`CHAIN_STORE: Prompt file '${path}' is empty`);
+        }
+        let matches = content.matchAll(/{.*?}/gm);
+        let distinctMatches = new Set();
+        for (const match of Array.from(matches)) {
+            let matchStr = match[0];
+            // Exclude escaped curly braces.
+            if (!matchStr.startsWith('{{')) {
+                distinctMatches.add(matchStr.substring(1, matchStr.length - 1));
+            }
+        }
+        prompt.content = content;
+        prompt.variables = Array.from(distinctMatches);
+        return prompt;
+    }
+    /**
+     * - `name`: Chain name
+     * - `template`: Template chain name to copy prompt from
+     * - `options`: LLM options
+     * - `verbose`: OpenAI verbose parameter
+     */
+    addChain(name, template, options, verbose) {
+        const prompt = this.getPrompt(name, template);
+        let llmArgs = {
+            modelName: options.modelName,
+            temperature: options.temperature ?? 0,
+            configuration: {
+                organization: process.env.OPENAI_ORGANIZATION,
+                timeout: CHAIN_TIMEOUT_MS
+            }
+        };
+        if (!!options.openai) {
+            if (!!options.openai.reasoning_effort) {
+                llmArgs.reasoning_effort = options.openai.reasoning_effort;
+            }
+            if (!!options.openai.verbosity) {
+                llmArgs.verbosity = options.openai.verbosity;
+            }
+        }
+        const llm = new ChatOpenAI(llmArgs);
+        const chain = new SingleActionChain({
+            llm,
+            prompt: prompt.content,
+            verbose: verbose ?? false
+        }, name, prompt.variables);
+        this.chains.set(name, chain);
+    }
+    addExistingChain(chain) {
+        this.chains.set(chain._chainType(), chain);
+    }
+    async callChain(name, args, tokenUsages) {
+        let chain = this.chains.get(name);
+        if (!chain) {
+            throw new Error(`CHAIN_STORE: Chain '${name}' does not exist`);
+        }
+        let presentInputKeySet = new Set();
+        for (const inputKey of Object.keys(args)) {
+            presentInputKeySet.add(inputKey);
+        }
+        let presentInputKeys = Array.from(presentInputKeySet);
+        // Make sure all input keys are present.
+        for (const inputKey of chain.inputKeys) {
+            if (!presentInputKeys.includes(inputKey)) {
+                throw new Error(`CHAIN_STORE: Input key '${inputKey}' not present for chain '${chain._chainType()}'`);
+            }
+        }
+        return chain.invoke(args, {
+            callbacks: [
+                {
+                    handleLLMEnd: async (output) => {
+                        const usage = output?.llmOutput?.tokenUsage;
+                        tokenUsages.push(ChainStore.getTokenUsage(chain._chainType(), chain.getModelName(), usage));
+                    },
+                }
+            ]
+        });
+    }
+    async translate(statement, language, tokenUsages) {
+        // No need to translate if requested language is in default language.
+        const DEFAULT_LANGUAGE = 'English';
+        if (language.toLowerCase() === DEFAULT_LANGUAGE.toLowerCase()) {
+            return statement;
+        }
+        const translationAnswer = await this.callChain(TRANSLATION_CHAIN_NAME, { statement, language }, tokenUsages ?? []);
+        let translationAnswerStr = translationAnswer.answer;
+        /*
+            Need to check if AI indicator exists in the answer. It is possible that the
+            translation chain will include this in an answer. Pretty sure this happens
+            because the translation chain can see conversation history, and messages from
+            AI will be prefixed as such.
+        */
+        const AI_PREFIX = 'AI: ';
+        if (translationAnswerStr.includes(AI_PREFIX)) {
+            console.log(`CHAIN_STORE: Removing AI indicator from translation answer`);
+            translationAnswerStr = translationAnswerStr.substring(translationAnswerStr.indexOf(AI_PREFIX) + AI_PREFIX.length);
+        }
+        // Remove 'Your translation here:' if it is there.
+        if (translationAnswerStr.includes('Your translation here:')) {
+            translationAnswerStr = translationAnswerStr.substring(translationAnswerStr.indexOf('Your translation here:') + 'Your translation here:'.length);
+        }
+        return translationAnswerStr.trim();
+    }
+    getPrompts() {
+        let buf = '';
+        for (const chain of Array.from(this.chains.values())) {
+            buf += `================================================= =================================================
+                                            ${chain._chainType()}
+================================================= =================================================
+${chain.getPrompt()}
+`;
+        }
+        return buf;
+    }
+}

package/dist/llm/cost.d.ts

@@ -0,0 +1,3 @@
+import { ModelName } from "./model";
+export declare function getLLMCostPerToken(modelName: ModelName): any;
+export declare function getLLMTransactionCost(tokenUsage: any, modelName: ModelName): number;