okai 0.0.28 → 0.0.30

package/dist/ts-once.js

@@ -1,6 +1,6 @@
 import { pick, toCamelCase, toPascalCase } from "./utils.js";
 // Tranforms that are only applied once on AI TypeScript AST
-export function createTdAstFromAIAst(tsAst) {
+export function createTdAstFromAIAst(tsAst, gropName) {
     mergeInterfacesAndClasses(tsAst);
     rewriteToPascalCase(tsAst);
     replaceReferences(tsAst);
@@ -9,6 +9,15 @@ export function createTdAstFromAIAst(tsAst) {
         // replaceUserRefs(cls)
         rewriteDuplicateTypePropNames(cls);
         rewriteSelfReferencingIds(cls);
+        convertToAuditBase(cls);
+        addCustomInputs(cls);
+        if (gropName) {
+            if (!cls.annotations)
+                cls.annotations = [];
+            if (!cls.annotations.some(x => x.name === 'tag')) {
+                cls.annotations.push({ name: 'tag', constructorArgs: [gropName] });
+            }
+        }
     });
     changeUserRefsToAuditBase(tsAst);
     return tsAst;
@@ -119,6 +128,21 @@ function rewriteSelfReferencingIds(type) {
         selfRefId.name = `parentId`;
     }
 }
+export function addCustomInputs(cls) {
+    const currencyTypeProps = [
+        "price", "cost", "total", "salary", "balance", "tax", "fee"
+    ];
+    for (const prop of cls.properties ?? []) {
+        if (currencyTypeProps.some(x => prop.name.toLowerCase().includes(x))) {
+            if (!prop.annotations)
+                prop.annotations = [];
+            prop.annotations.push({
+                name: "IntlNumber",
+                args: { Currency: "NumberCurrency.USD" }
+            });
+        }
+    }
+}
 function rewriteToPascalCase(ast) {
     ast?.classes.forEach(t => {
         t.name = toPascalCase(t.name);
@@ -131,6 +155,14 @@ function rewriteToPascalCase(ast) {
         });
     });
 }
+function convertToAuditBase(cls) {
+    const props = cls.properties ?? [];
+    const auditFields = ['createdBy', 'updatedBy', 'createdAt', 'updatedAt', 'userId'];
+    if (props.find(x => auditFields.includes(x.name))) {
+        cls.extends = 'AuditBase';
+        cls.properties = props.filter(x => !auditFields.includes(x.name));
+    }
+}
 function changeUserRefsToAuditBase(ast) {
     const user = ast.classes?.find(x => x.name === 'User') ?? ast.interfaces?.find(x => x.name === 'User');
     if (user) {
@@ -168,6 +200,7 @@ function interfaceToClass(ast) {
 export function replaceReferences(tsAst) {
     const references = [
         'Service',
+        'Task',
     ];
     // The most important types are the ones with the most references
     const refCount = (t) => t.properties?.filter(p => tsAst.classes.find(x => x.name === p.type)).length || 0;

package/dist/ts-parser.js

@@ -1,12 +1,18 @@
-import { lastLeftPart, leftPart, rightPart } from "./utils.js";
+import { lastLeftPart, lastRightPart, leftPart, rightPart, trimEnd } from "./utils.js";
 export class TypeScriptParser {
-    static CLASS_PATTERN = /class\s+(\w+)(?:\s+extends\s+(\w+))?(?:\s+implements\s+([\w,\s]+))?\s*{/g;
-    static INTERFACE_PATTERN = /interface\s+(\w+)(?:\s+extends\s+(\w+))?\s*{/g;
-    static ENUM_PATTERN = /enum\s+(\w+)\s*{([^}]*)}/g;
+    static CONFIG_TYPE_PATTERN = /export\s+type\s+Config\s*=\s*{([^}]+)}/;
+    static CONFIG_PROPERTY_PATTERN = /(\w+)\s*:\s*("[^"]*"|'[^']*')/g;
+    static DEFAULT_EXPORT_PATTERN = /export\s+default\s+({[^}]+})/;
+    static CLASS_PATTERN = /class\s+(\w+)(?:\s+extends\s+([\w\s<>,]+))?(?:\s+implements\s+([\w\s<>,]+))?\s*{/gm;
+    static INTERFACE_PATTERN = /interface\s+(\w+)(?:\s+extends\s+([\w\s<>,]+))?\s*{/gm;
+    static ENUM_PATTERN = /enum\s+(\w+)\s*{([^}]*)}/gm;
     static PROPERTY_PATTERN = /(?:(?<modifier>private|public|protected|readonly)\s+)*(?<name>\w+)(?<optional>\?)?\s*:\s*(?<type>[\w<>[\],\s]+)(?<union>\|\s*[\w<>[\],|,\s]+)?\s*;?/;
     static ENUM_MEMBER_PATTERN = /(\w+)\s*(?:=\s*("[^"]*"|'[^']*'|\d+|[^,\n]+))?\s*/;
     static ANNOTATION_PATTERN = /^\s*@([A-Za-z_][A-Za-z0-9_]*\.?[A-Za-z_]?[A-Za-z0-9_]*)/;
+    static ANNOTATION_COMMENT = /\)[\s]*\/\/.*$/;
     static REFERENCE_PATTERN = /\/\/\/\s*<reference\s+path="([^"]+)"\s*\/>/g;
+    config;
+    defaultExport;
     classes = [];
     interfaces = [];
     enums = [];
@@ -15,6 +21,12 @@ export class TypeScriptParser {
         if (line.match(TypeScriptParser.REFERENCE_PATTERN)) {
             return undefined;
         }
+        if (line.trim().startsWith('@')) {
+            if (TypeScriptParser.ANNOTATION_COMMENT.test(line)) {
+                return lastRightPart(line, '//').trim();
+            }
+            return undefined;
+        }
         // Check for single line comment at end of line
         const singleLineMatch = line.match(/.*?\/\/\s*(.+)$/);
         if (singleLineMatch) {
@@ -37,11 +49,45 @@ export class TypeScriptParser {
         }
         return undefined;
     }
+    parseConfigType(content) {
+        const match = content.match(TypeScriptParser.CONFIG_TYPE_PATTERN);
+        if (match) {
+            const configBody = match[1];
+            const config = {};
+            let propertyMatch;
+            while ((propertyMatch = TypeScriptParser.CONFIG_PROPERTY_PATTERN.exec(configBody))) {
+                const [, key, value] = propertyMatch;
+                config[key] = value.slice(1, -1); // Remove quotes
+            }
+            this.config = config;
+        }
+    }
+    parseDefaultExport(content) {
+        const match = content.match(TypeScriptParser.DEFAULT_EXPORT_PATTERN);
+        if (match) {
+            try {
+                const configStr = match[1];
+                const defaultExport = {};
+                const lines = configStr.split('\n');
+                for (const line of lines) {
+                    if (line.includes(':')) {
+                        const key = leftPart(line, ':').trim();
+                        const val = trimEnd(rightPart(line, ':').trim(), ',');
+                        defaultExport[key] = JSON.parse(val);
+                    }
+                }
+                this.defaultExport = defaultExport;
+            }
+            catch (e) {
+                console.warn('Failed to parse default export config:', e);
+            }
+        }
+    }
     parseMetadata(body, line) {
         const annotations = [];
         const commments = [];
         const ANNOTATION = TypeScriptParser.ANNOTATION_PATTERN;
-        let previousLine = this.getPreviousLine(body, body.indexOf(line));
+        let previousLine = this.getPreviousLine(body, body.lastIndexOf(line));
         while (previousLine && (!previousLine.match(TypeScriptParser.PROPERTY_PATTERN) || previousLine.match(ANNOTATION))) {
             const annotation = previousLine.match(ANNOTATION) ? parseAnnotation(previousLine) : undefined;
             if (annotation) {
@@ -53,7 +99,7 @@ export class TypeScriptParser {
                     commments.unshift(comment);
                 }
             }
-            previousLine = this.getPreviousLine(body, body.indexOf(previousLine));
+            previousLine = this.getPreviousLine(body, body.lastIndexOf(previousLine));
         }
         const lineComment = this.getLineComment(line);
         if (lineComment) {
@@ -65,10 +111,11 @@ export class TypeScriptParser {
                 annotations.push(annotation);
             }
         }
-        return {
+        const ret = {
             comment: commments.length ? commments.join('\n') : undefined,
             annotations: annotations.length ? annotations : undefined,
         };
+        return ret;
     }
     parseClassProperties(classBody) {
         const props = [];
@@ -101,7 +148,20 @@ export class TypeScriptParser {
                         member.optional = true;
                     }
                 }
-                const { comment, annotations } = this.parseMetadata(classBody, line);
+                let startIndex = index;
+                for (let i = index - 1; i >= 0; i--) {
+                    const prevLine = lines[i].trim();
+                    if (this.isComment(prevLine) || this.isAnnotation(prevLine)) {
+                        startIndex = i;
+                    }
+                    else {
+                        if (prevLine != '')
+                            break;
+                    }
+                }
+                const propMetadata = startIndex < index ? lines.slice(startIndex, index + 1).join('\n') : line;
+                // console.log('\npropMetadata <!--', propMetadata, '-->\n')
+                const { comment, annotations } = this.parseMetadata(propMetadata, line);
                 if (comment)
                     member.comment = comment;
                 if (annotations)
@@ -162,20 +222,27 @@ export class TypeScriptParser {
                 name: match[1],
                 properties: this.parseClassProperties(body),
             };
-            if (match[2]) {
-                cls.extends = match[2];
+            const inherits = splitTypes(match[2]);
+            if (inherits.length) {
+                cls.extends = inherits[0];
+                if (inherits.length > 1) {
+                    cls.implements = inherits.slice(1);
+                }
             }
-            const impls = match[3]?.split(',').map(i => i.trim());
-            if (impls) {
-                cls.implements = impls;
+            const impls = splitTypes(match[3]);
+            if (impls.length) {
+                if (!cls.implements)
+                    cls.implements = [];
+                cls.implements.push(...impls);
             }
             if (previousLine) {
-                const { comment, annotations } = this.parseMetadata(content, previousLine);
+                const { comment, annotations } = this.parseMetadata(content.substring(0, match.index), previousLine);
                 if (comment)
                     cls.comment = comment;
                 if (annotations)
                     cls.annotations = annotations;
             }
+            // console.log('cls', cls.name, previousLine, cls.annotations)
             this.classes.push(cls);
         }
     }
@@ -200,14 +267,15 @@ export class TypeScriptParser {
                 };
                 if (value) {
                     // Remove quotes if present
-                    const cleanValue = value.trim().replace(/^["']|["']$/g, '');
+                    const cleanValue = value.trim().replace(/^["'`]|["'`]$/g, '');
                     member.value = isNaN(Number(cleanValue)) ? cleanValue : Number(cleanValue);
                 }
                 else {
-                    member.value = prevIntValue + 1;
+                    member.value = prevIntValue;
                 }
                 if (typeof member.value === 'number') {
                     prevIntValue = member.value;
+                    prevIntValue++;
                 }
                 const previousLine = this.getPreviousLine(enumBody, enumBody.indexOf(line));
                 if (previousLine && this.isComment(previousLine)) {
@@ -222,6 +290,12 @@ export class TypeScriptParser {
         });
         return members;
     }
+    isAnnotation(s) {
+        if (!s)
+            return false;
+        s = s.trim();
+        return s.startsWith('@');
+    }
     isComment(s) {
         if (!s)
             return false;
@@ -247,14 +321,20 @@ export class TypeScriptParser {
             .join('\n');
     }
     parse(sourceCode) {
+        this.config = undefined;
+        this.defaultExport = undefined;
         this.classes = [];
         this.interfaces = [];
         this.enums = [];
+        this.parseConfigType(sourceCode);
+        this.parseDefaultExport(sourceCode);
         this.parseReferences(sourceCode);
         this.parseInterfaces(sourceCode);
         this.parseClasses(sourceCode);
         this.parseEnums(sourceCode);
         return {
+            config: this.config,
+            defaultExport: this.defaultExport,
             references: this.references,
             classes: this.classes,
             interfaces: this.interfaces,
@@ -264,8 +344,9 @@ export class TypeScriptParser {
 }
 export function parseAnnotation(annotation) {
     const regex = TypeScriptParser.ANNOTATION_PATTERN;
-    if (annotation.includes('//')) {
-        annotation = leftPart(annotation, '//');
+    // search for // after closing parenthesis and remove it
+    if (TypeScriptParser.ANNOTATION_COMMENT.test(annotation)) {
+        annotation = lastLeftPart(annotation, '//');
     }
     const match = annotation.match(regex);
     if (!match)
@@ -340,3 +421,38 @@ function splitArgs(str) {
         args.push(current.trim());
     return args;
 }
+export function splitTypes(input) {
+    const result = [];
+    let currentToken = '';
+    let angleBracketCount = 0;
+    // Trim and handle empty input
+    input = input?.trim();
+    if (!input)
+        return [];
+    // Process each character
+    for (let char of input) {
+        if (char === '<') {
+            angleBracketCount++;
+            currentToken += char;
+        }
+        else if (char === '>') {
+            angleBracketCount--;
+            currentToken += char;
+        }
+        else if (char === ',' && angleBracketCount === 0) {
+            // Only split on commas when we're not inside angle brackets
+            if (currentToken.trim()) {
+                result.push(currentToken.trim());
+            }
+            currentToken = '';
+        }
+        else {
+            currentToken += char;
+        }
+    }
+    // Add the last token if it exists
+    if (currentToken.trim()) {
+        result.push(currentToken.trim());
+    }
+    return result;
+}

package/dist/tsd-gen.js

@@ -1,9 +1,24 @@
+import { rightPart } from "./utils.js";
 export class TsdGenerator {
+    export = true;
     interfaces = [];
     enums = [];
     ast = { references: [], classes: [], interfaces: [], enums: [] };
+    get typePrefix() {
+        return this.export ? 'export ' : '';
+    }
+    isEnumValue(value) {
+        const parts = (value ?? '').split('.');
+        if (parts.length !== 2)
+            return false;
+        const isUpper = (charCode) => charCode >= 65 && charCode <= 90;
+        const isAlphaNum = (s) => /^[a-z0-9]+$/i.test(s);
+        return isAlphaNum(parts[0]) && isUpper(parts[0].charCodeAt(0)) && isAlphaNum(parts[1]) && isUpper(parts[1].charCodeAt(0));
+    }
     attrValue(type, value) {
-        return type === 'string' ? `"${value}"` : value;
+        return type === 'string' && !this.isEnumValue(value)
+            ? `"${value}"`
+            : value;
     }
     toAttr(attr) {
         const sbCtorArgs = [];
@@ -32,18 +47,19 @@ export class TsdGenerator {
             sb.push(ast.comment.split('\n').map(x => `// ${x}`).join('\n'));
         }
         if (ast.annotations?.length) {
-            for (const attr of ast.annotations) {
+            for (const attr of sortAnnotations(ast.annotations)) {
                 sb.push(this.toAttr(attr));
             }
         }
         const extend = ast.extends ? ` extends ${ast.extends}` : '';
-        sb.push(`export ${type} ${ast.name}${extend} {`);
+        const impls = ast.implements?.length ? ` implements ${ast.implements.join(', ')}` : '';
+        sb.push(`${this.typePrefix}${type} ${ast.name}${extend}${impls} {`);
         for (const prop of ast.properties) {
             if (prop.comment) {
                 sb.push(prop.comment.split('\n').map(x => `  // ${x}`).join('\n'));
             }
             if (prop.annotations?.length) {
-                for (const attr of prop.annotations) {
+                for (const attr of sortAnnotations(prop.annotations)) {
                     sb.push('  ' + this.toAttr(attr));
                 }
             }
@@ -57,15 +73,18 @@ export class TsdGenerator {
         if (ast.comment) {
             sb.push(ast.comment.split('\n').map(x => `// ${x}`).join('\n'));
         }
-        sb.push(`export enum ${ast.name} {`);
+        sb.push(`${this.typePrefix}enum ${ast.name} {`);
+        const allStringValuesMatch = ast.members.every(x => typeof x.value === 'string' && x.value === x.name);
         for (let i = 0; i < ast.members.length; i++) {
             const member = ast.members[i];
             if (member.comment) {
                 sb.push(member.comment.split('\n').map(x => `  // ${x}`).join('\n'));
             }
             const value = typeof member.value === 'string'
-                ? ` = '${member.value}'`
-                : member.value !== (i + 1) ? ` = ${member.value}` : '';
+                ? allStringValuesMatch
+                    ? ``
+                    : ` = ${member.value}`
+                : member.value !== i ? ` = ${member.value}` : '';
             sb.push(`  ${member.name}${value},`);
         }
         sb.push('}');
@@ -78,8 +97,23 @@ export class TsdGenerator {
             for (const ref of ast.references) {
                 sb.push(`/// <reference path="${ref.path}" />`);
             }
-            sb.push('');
         }
+        if (ast.config) {
+            sb.push(`export type Config = {`);
+            const knownKeys = ['prompt', 'api', 'migration', 'uiMjs'];
+            const maxKeyLen = Object.keys(ast.config).reduce((max, key) => Math.max(max, key.length), 0);
+            for (const knownKey of knownKeys) {
+                if (ast.config[knownKey]) {
+                    sb.push(`  ${(knownKey + ':').padEnd(maxKeyLen + 1, ' ')} ${JSON.stringify(ast.config[knownKey])}`);
+                }
+            }
+            for (const key of Object.keys(ast.config).filter(k => !knownKeys.includes(k))) {
+                sb.push(`  ${(key + ':').padEnd(maxKeyLen + 1, ' ')} ${JSON.stringify(ast.config[key])},`);
+            }
+            sb.push(`}`);
+        }
+        if (sb.length)
+            sb.push('');
         for (const cls of ast.enums ?? []) {
             sb.push(this.toEnum(cls));
             sb.push('');
@@ -96,6 +130,33 @@ export class TsdGenerator {
         return tsd;
     }
 }
+function sortAnnotations(annotations) {
+    const to = annotations.sort((x, y) => {
+        const prefix = ['Read.', 'Create.', 'Update.', 'Delete.', 'Write.'];
+        const xPrefix = prefix.findIndex(p => x.name.startsWith(p));
+        const yPrefix = prefix.findIndex(p => y.name.startsWith(p));
+        // Sort by Prefix first in order ['Read.','Write.','Update.','Delete.']
+        if (xPrefix !== yPrefix)
+            return xPrefix == -1 ? 1 : yPrefix == -1 ? -1 : xPrefix - yPrefix;
+        const xName = x.name.includes('.') ? rightPart(x.name, '.') : x.name;
+        const yName = y.name.includes('.') ? rightPart(y.name, '.') : y.name;
+        // then Sort by length of attr name
+        if (xName.length !== yName.length)
+            return xName.length - yName.length;
+        // then Sort by attr name
+        if (xName != yName)
+            return xName.localeCompare(yName);
+        // then Sort by length of constructorArgs[0]
+        if ((x.constructorArgs?.length ?? 0) > 0 && (y.constructorArgs?.length ?? 0) > 0)
+            return x.constructorArgs[0].length - y.constructorArgs[0].length;
+        // then Sort by constructorArgs.length
+        if (x.constructorArgs?.length !== y.constructorArgs?.length)
+            return (x.constructorArgs?.length ?? 0) - (y.constructorArgs?.length ?? 0);
+        // then Sort by args.length
+        return (x.args?.length ?? 0) - (y.args?.length ?? 0);
+    });
+    return to;
+}
 export function toTsd(tsAst) {
     const gen = new TsdGenerator();
     return gen.generate(tsAst);

package/dist/ui-mjs.js

@@ -1,4 +1,4 @@
-import { getGroupName, plural, toCamelCase } from "./utils.js";
+import { getGroupName, plural, toCamelCase, splitCase } from "./utils.js";
 /*
 export default {
     group: "Bookings",
@@ -24,7 +24,7 @@ export class UiMjsGroupGenerator {
     generate(ast, groupLabel) {
         if (!groupLabel) {
             const groupName = getGroupName(ast);
-            groupLabel = plural(groupName);
+            groupLabel = splitCase(plural(groupName));
         }
         const sb = [
             `export default {`,

package/dist/utils.js

@@ -89,6 +89,9 @@ export function requestKey(date) {
 export function acceptedKey(date) {
     return `accepted/${timestampKey(date)}`;
 }
+export function chatKey(date) {
+    return `chat/${timestampKey(date)}`;
+}
 export function timestampKey(date) {
     const year = date.getFullYear();
     const month = String(date.getMonth() + 1).padStart(2, '0');
@@ -149,11 +152,40 @@ export function pick(o, keys) {
     });
     return to;
 }
+export function appendQueryString(url, args) {
+    for (let k in args) {
+        if (args.hasOwnProperty(k)) {
+            let val = args[k];
+            if (typeof val == 'undefined' || typeof val == 'function' || typeof val == 'symbol')
+                continue;
+            url += url.indexOf("?") >= 0 ? "&" : "?";
+            url += k + (val === null ? '' : "=" + qsValue(val));
+        }
+    }
+    return url;
+}
+function qsValue(arg) {
+    if (arg == null)
+        return "";
+    return encodeURIComponent(arg) || "";
+}
+export function trimEnd(s, c) {
+    let end = s.length;
+    while (end > 0 && s[end - 1] === c) {
+        --end;
+    }
+    return (end < s.length) ? s.substring(0, end) : s;
+}
 export function refCount(t) {
     return t.properties?.filter(x => x.attributes?.some(x => x.name === 'References')).length || 0;
 }
 export function getGroupName(ast) {
-    return plural(ast.types.sort((x, y) => refCount(y) - refCount(x))[0].name);
+    let types = ast.types.filter(x => !x.isEnum);
+    if (types.length == 0)
+        types = ast.operations.map(x => x.request);
+    if (types.length == 0)
+        return null;
+    return plural(types.sort((x, y) => refCount(y) - refCount(x))[0].name);
 }
 export function tsdWithPrompt(tsd, prompt) {
     return `/*prompt:  ${prompt}\n*/\n\n${tsd}`;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "okai",
   "type": "module",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "bin": "./dist/okai.js",
   "main": "./dist/index.js",
   "module": "./dist/index.js",