okai 0.0.10 → 0.0.12

package/dist/cs-apis.js

@@ -1,5 +1,5 @@
-import { getGroupName, splitCase } from "./utils";
-import { CSharpGenerator } from "./cs-gen";
+import { getGroupName, splitCase } from "./utils.js";
+import { CSharpGenerator } from "./cs-gen.js";
 export class CSharpApiGenerator extends CSharpGenerator {
     toApiClass(op) {
         const cls = op.request;
@@ -29,18 +29,18 @@ export class CSharpApiGenerator extends CSharpGenerator {
         }
         if (op.requiredRoles?.length) {
             const adminRole = op.requiredRoles.includes('Admin');
-            if (adminRole) {
+            if (adminRole && !this.typeHasAttr(op.request, 'ValidateIsAdmin')) {
                 sb.push(`[ValidateIsAdmin]`);
             }
             const roles = op.requiredRoles.filter(r => r !== 'Admin');
-            if (roles.length) {
+            if (roles.length && !this.typeHasAttr(op.request, 'ValidateHasRole')) {
                 sb.push(`[ValidateHasRole("${roles[0]}")]`);
             }
         }
-        else if (op.requiresAuth) {
+        else if (op.requiresAuth && !this.typeHasAttr(op.request, 'ValidateIsAuthenticated')) {
             sb.push(`[ValidateIsAuthenticated]`);
         }
-        if (cls.description) {
+        if (cls.description && !this.typeHasAttr(op.request, 'Api')) {
             sb.push(`[Api("${cls.description}")]`);
         }
         for (const attr of cls.attributes ?? []) {
@@ -55,7 +55,7 @@ export class CSharpApiGenerator extends CSharpGenerator {
         sb.push('{');
         for (const prop of cls.properties) {
             this.addNamespace(prop.namespace);
-            if (prop.description) {
+            if (prop.description && !this.propHasAttr(prop, 'ApiMember')) {
                 if (!prop.description.includes('\n')) {
                     sb.push(`    [ApiMember(Description="${prop.description.replace(/"/g, '\\"')}")]`);
                 }

package/dist/cs-ast.js

@@ -1,5 +1,5 @@
-import { plural, toPascalCase } from "./utils";
-import { Icons } from "./icons";
+import { plural, toPascalCase } from "./utils.js";
+import { Icons } from "./icons.js";
 const sys = (name, genericArgs) => ({ name, namespace: "System", genericArgs });
 const sysObj = sys("object");
 const sysDictObj = { name: "Dictionary", genericArgs: ["string", "object"], namespace: "System.Collections.Generic" };
@@ -75,6 +75,35 @@ export class CSharpAst {
         }
         return this.typeMap[type] ?? { name: type, namespace: "MyApp" };
     }
+    csharpAttribute(attr) {
+        const to = { name: toPascalCase(attr.name) };
+        const attrType = (value) => typeof value == 'string'
+            ? (`${value}`.startsWith('typeof') ? "Type" : "string")
+            : typeof value == "object"
+                ? (value instanceof Date ? "string" : Array.isArray(value) ? "array" : "object")
+                : typeof value;
+        if (attr.constructorArgs?.length) {
+            to.constructorArgs = attr.constructorArgs.map(x => {
+                const type = attrType(x.value);
+                return {
+                    name: 'String',
+                    type,
+                    value: `${x.value}`
+                };
+            });
+        }
+        if (attr.args && Object.keys(attr.args).length) {
+            to.args = Object.entries(attr.args).map(([name, value]) => {
+                const type = attrType(value);
+                return {
+                    name: toPascalCase(name),
+                    type,
+                    value: `${value}`
+                };
+            });
+        }
+        return to;
+    }
     addMetadataType(cls) {
         const type = {
             name: this.toCsName(cls.name),
@@ -110,9 +139,15 @@ export class CSharpAst {
                         args: [{ name: "Currency", type: "constant", value: "NumberCurrency.USD" }]
                     });
                 }
+                if (p.annotations?.length) {
+                    prop.attributes = p.annotations.map(x => this.csharpAttribute(x));
+                }
                 return prop;
             }),
         };
+        if (cls.annotations?.length) {
+            type.attributes = cls.annotations.map(x => this.csharpAttribute(x));
+        }
         // Add dependent types first
         type.properties.filter(x => x.namespace === 'MyApp'
             && x.name !== cls.name
@@ -588,6 +623,8 @@ export class CSharpAst {
             if (icon) {
                 if (!type.attributes)
                     type.attributes = [];
+                if (type.attributes.some(x => x.name === 'Icon'))
+                    continue;
                 type.attributes.push({
                     name: "Icon",
                     args: [{ name: "Svg", type: "string", value: icon }]

package/dist/cs-gen.js

@@ -5,6 +5,12 @@ export class CSharpGenerator {
     classes = [];
     enums = [];
     ast = { namespaces: [], operations: [], types: [] };
+    typeHasAttr(type, name) {
+        return type.attributes?.some(x => x.name === name);
+    }
+    propHasAttr(prop, name) {
+        return prop.attributes?.some(x => x.name === name);
+    }
     addNamespace(ns) {
         if (!ns || this.namespaces.includes(ns))
             return;

package/dist/index.js

@@ -45,21 +45,39 @@ function parseArgs(...args) {
                 case "/license":
                     ret.license = args[++i];
                     break;
+                case "/url":
+                    ret.baseUrl = args[++i];
+                    break;
+                case "/cached":
+                    ret.cached = true;
+                    break;
                 default:
                     ret.unknown = ret.unknown || [];
                     ret.unknown.push(arg);
                     break;
             }
         }
-        else if (ret.type === "help" && ["help", "info", "init", "ls", "rm"].includes(arg)) {
+        else if (ret.type === "help" && ["help", "info", "init", "ls", "rm", "update"].includes(arg)) {
             if (arg == "help")
                 ret.type = "help";
             else if (arg == "info")
                 ret.type = "info";
             else if (arg == "init")
                 ret.type = "init";
-            else if (arg == "rm")
+            else if (arg == "update") {
+                ret.type = "update";
+                ret.tsdFile = args[++i];
+                if (ret.tsdFile && !ret.tsdFile.endsWith('.d.ts')) {
+                    ret.tsdFile += '.d.ts';
+                }
+            }
+            else if (arg == "rm") {
                 ret.type = "remove";
+                ret.tsdFile = args[++i];
+                if (ret.tsdFile && !ret.tsdFile.endsWith('.d.ts')) {
+                    ret.tsdFile += '.d.ts';
+                }
+            }
             else if (arg == "ls") {
                 ret.type = "list";
                 ret.list = args[++i];
@@ -79,6 +97,9 @@ function parseArgs(...args) {
         }
     }
     if (ret.type === "prompt") {
+        if (!ret.cached && process.env.OKAI_CACHED) {
+            ret.cached = true;
+        }
         if (!ret.models && process.env.OKAI_MODELS) {
             ret.models = process.env.OKAI_MODELS;
         }
@@ -321,7 +342,7 @@ Options:
 }
 async function fetchGistFiles(command) {
     const url = new URL('/models/gist', command.baseUrl);
-    if (process.env.OKAI_CACHED) {
+    if (command.cached) {
         url.searchParams.append('cached', `1`);
     }
     url.searchParams.append('prompt', command.prompt);
@@ -489,7 +510,7 @@ async function createGistPreview(title, gist) {
 function chooseFile(ctx, info, gist) {
     const { screen, titleBar, fileList, preview, statusBar, result } = ctx;
     const file = gist.files[result.selectedFile];
-    screen.destroy();
+    console.clear();
     const tsd = file.content;
     const tsdAst = toAst(tsd);
     const csAst = toMetadataTypes(tsdAst);
@@ -518,8 +539,6 @@ function chooseFile(ctx, info, gist) {
     const fullTsdPath = path.join(info.slnDir, relativeServiceModelDir, tsdFileName);
     const fullApiPath = path.join(info.slnDir, relativeServiceModelDir, apiFileName);
     const fullMigrationPath = path.join(info.slnDir, relativeMigrationDir, migrationFileName);
-    const clearScreen = blessed.screen();
-    clearScreen.render();
     if (!fs.existsSync(path.dirname(fullTsdPath))) {
         console.log(`Directory does not exist: ${path.dirname(fullTsdPath)}`);
         process.exit(0);

package/dist/ts-parser.js

@@ -1,9 +1,10 @@
 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 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 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 = /@\w+\(.*\)/;
     classes = [];
     interfaces = [];
     enums = [];
@@ -23,26 +24,80 @@ export class TypeScriptParser {
     getPreviousLine(content, position) {
         const beforePosition = content.substring(0, position);
         const lineNumber = beforePosition.split('\n').length;
-        if (lineNumber > 1) {
+        if (lineNumber > 0) {
             const lines = content.split('\n');
             return lines[lineNumber - 2]; // -2 because array is 0-based and we want previous line
         }
         return undefined;
     }
+    parseMetadata(body, line) {
+        const annotations = [];
+        const commments = [];
+        const ANNOTATION = TypeScriptParser.ANNOTATION_PATTERN;
+        let previousLine = this.getPreviousLine(body, body.indexOf(line));
+        while (previousLine && (!previousLine.match(TypeScriptParser.PROPERTY_PATTERN) || previousLine.match(ANNOTATION))) {
+            const annotation = previousLine.match(ANNOTATION) ? parseAnnotation(previousLine) : undefined;
+            if (annotation) {
+                if (previousLine.trimStart().startsWith('//')) {
+                    annotation.comment = true;
+                }
+                annotations.push(annotation);
+            }
+            else {
+                const comment = this.getLineComment(previousLine);
+                if (comment) {
+                    const annotation = comment.match(ANNOTATION) ? parseAnnotation(comment) : undefined;
+                    if (annotation) {
+                        annotation.comment = true;
+                        annotations.push(annotation);
+                    }
+                    else {
+                        commments.unshift(comment);
+                    }
+                }
+            }
+            previousLine = this.getPreviousLine(body, body.indexOf(previousLine));
+        }
+        const lineComment = this.getLineComment(line);
+        if (lineComment) {
+            const annotation = lineComment.match(ANNOTATION) ? parseAnnotation(lineComment) : undefined;
+            if (annotation) {
+                annotation.comment = true;
+                annotations.push(annotation);
+            }
+            else {
+                commments.push(lineComment);
+            }
+        }
+        else if (line.match(ANNOTATION)) {
+            const annotation = parseAnnotation(line);
+            if (annotation) {
+                annotations.push(annotation);
+            }
+        }
+        return {
+            comment: commments.length ? commments.join('\n') : undefined,
+            annotations: annotations.length ? annotations : undefined,
+        };
+    }
     parseClassProperties(classBody) {
         const props = [];
         const lines = this.cleanBody(classBody).split('\n');
         lines.forEach((line, index) => {
             if (line.trim().startsWith('//'))
                 return;
+            if (line.match(TypeScriptParser.ANNOTATION_PATTERN))
+                return;
             const match = line.match(TypeScriptParser.PROPERTY_PATTERN);
             if (match?.groups) {
                 const member = {
-                    modifier: match.groups.modifier,
                     name: match.groups.name,
                     type: match.groups.type.trim(),
-                    optional: match.groups.optional === '?' || undefined,
                 };
+                if (match.groups.modifier)
+                    member.modifier = match.groups.modifier;
+                if (match.groups.optional === '?')
+                    member.optional = true;
                 // empty for properties with inline objects `salaryRange: {min:number, max:number};`
                 if (!member.type) {
                     return;
@@ -56,49 +111,82 @@ export class TypeScriptParser {
                         member.optional = true;
                     }
                 }
-                const commments = [];
-                let previousLine = this.getPreviousLine(classBody, classBody.indexOf(line));
-                while (previousLine && !previousLine.match(TypeScriptParser.PROPERTY_PATTERN)) {
-                    const comment = this.getLineComment(previousLine);
-                    if (comment)
-                        commments.unshift(comment);
-                    previousLine = this.getPreviousLine(classBody, classBody.indexOf(previousLine));
-                }
-                const lineComment = this.getLineComment(line);
-                if (lineComment) {
-                    commments.push(lineComment);
-                }
-                if (commments.length) {
-                    member.comment = commments.join('\n');
-                }
+                const { comment, annotations } = this.parseMetadata(classBody, line);
+                if (comment)
+                    member.comment = comment;
+                if (annotations)
+                    member.annotations = annotations;
+                // console.log('member', { comment, annotations, line })
                 props.push(member);
             }
         });
         return props;
     }
+    getBlockBody(content, startIndex) {
+        const bodyStartPos = content.indexOf('{', startIndex);
+        // console.log('bodyStartPos', `<|${content.substring(bodyStartPos, bodyStartPos + 20)}|>`)
+        // Find the end of the body
+        let depth = 0;
+        let bodyEndPos = bodyStartPos;
+        for (let i = bodyStartPos; i < content.length; i++) {
+            if (content[i] === '{')
+                depth++;
+            if (content[i] === '}')
+                depth--;
+            if (depth === 0) {
+                bodyEndPos = i + 1;
+                break;
+            }
+        }
+        let body = content.substring(bodyStartPos + 1, bodyEndPos - 1);
+        return body;
+    }
     parseInterfaces(content) {
         let match;
         while ((match = TypeScriptParser.INTERFACE_PATTERN.exec(content))) {
             const previousLine = this.getPreviousLine(content, match.index);
-            this.interfaces.push({
+            const body = this.getBlockBody(content, match.index);
+            const cls = {
                 name: match[1],
-                extends: match[2],
-                comment: previousLine ? this.getLineComment(previousLine) : undefined,
-                properties: this.parseClassProperties(match[3])
-            });
+                properties: this.parseClassProperties(body),
+            };
+            if (match[2]) {
+                cls.extends = match[2];
+            }
+            if (previousLine) {
+                const { comment, annotations } = this.parseMetadata(content, previousLine);
+                if (comment)
+                    cls.comment = comment;
+                if (annotations)
+                    cls.annotations = annotations;
+            }
+            this.interfaces.push(cls);
         }
     }
     parseClasses(content) {
         let match;
         while ((match = TypeScriptParser.CLASS_PATTERN.exec(content))) {
             const previousLine = this.getPreviousLine(content, match.index);
-            this.classes.push({
+            const body = this.getBlockBody(content, match.index);
+            const cls = {
                 name: match[1],
-                extends: match[2],
-                implements: match[3]?.split(',').map(i => i.trim()),
-                comment: previousLine ? this.getLineComment(previousLine) : undefined,
-                properties: this.parseClassProperties(match[4]),
-            });
+                properties: this.parseClassProperties(body),
+            };
+            if (match[2]) {
+                cls.extends = match[2];
+            }
+            const impls = match[3]?.split(',').map(i => i.trim());
+            if (impls) {
+                cls.implements = impls;
+            }
+            if (previousLine) {
+                const { comment, annotations } = this.parseMetadata(content, previousLine);
+                if (comment)
+                    cls.comment = comment;
+                if (annotations)
+                    cls.annotations = annotations;
+            }
+            this.classes.push(cls);
         }
     }
     parseEnumMembers(enumBody) {
@@ -170,3 +258,75 @@ export class TypeScriptParser {
         };
     }
 }
+export function parseAnnotation(annotation) {
+    // Match @name and everything inside ()
+    const regex = /@(\w+)\s*\((.*)\)/;
+    const match = annotation.match(regex);
+    if (!match)
+        return null;
+    const [, name, paramsStr] = match;
+    try {
+        // Handle multiple arguments by splitting on commas outside quotes/braces
+        const rawArgs = splitArgs(paramsStr);
+        // Parse each argument
+        const parsedArgs = rawArgs.map(arg => {
+            if (arg.startsWith('{')) {
+                // Parse object literals
+                return (new Function(`return ${arg}`))();
+            }
+            else if (arg.startsWith('"') || arg.startsWith("'") || arg.startsWith("`")) {
+                // Parse strings
+                return arg.slice(1, -1);
+            }
+            else if (!isNaN(parseInt(arg))) {
+                // Parse numbers
+                return Number(arg);
+            }
+            return arg;
+        });
+        const lastArg = parsedArgs[parsedArgs.length - 1];
+        const args = typeof lastArg === 'object'
+            ? lastArg
+            : undefined;
+        const constructorArgs = args ? parsedArgs.slice(0, -1) : parsedArgs;
+        const to = { name };
+        if (constructorArgs.length)
+            to.constructorArgs = constructorArgs;
+        if (args)
+            to.args = args;
+        return to;
+    }
+    catch (e) {
+        return null;
+    }
+}
+// Helper to split args while respecting objects/strings
+function splitArgs(str) {
+    const args = [];
+    let current = '';
+    let depth = 0;
+    let inQuotes = false;
+    let quoteChar = '';
+    for (let char of str) {
+        if ((char === '"' || char === "'") && !inQuotes) {
+            inQuotes = true;
+            quoteChar = char;
+        }
+        else if (char === quoteChar && inQuotes) {
+            inQuotes = false;
+        }
+        else if (char === '{')
+            depth++;
+        else if (char === '}')
+            depth--;
+        else if (char === ',' && depth === 0 && !inQuotes) {
+            args.push(current.trim());
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim())
+        args.push(current.trim());
+    return args;
+}

package/dist/tsd-gen.js

@@ -8,21 +8,50 @@ export class TsdGenerator {
             name: ast.name,
             extends: ast.extends,
             comment: ast.comment,
-            properties: ast.properties
+            properties: ast.properties,
+            annotations: ast.annotations,
         };
         return to;
     }
+    attrValue(type, value) {
+        return type === 'string' ? `"${value}"` : value;
+    }
+    toAttr(attr) {
+        const sbArgs = [];
+        if (attr?.constructorArgs?.length) {
+            for (const arg of attr.constructorArgs) {
+                sbArgs.push(this.attrValue(typeof arg, arg));
+            }
+        }
+        if (attr.args) {
+            for (const [name, value] of Object.entries(attr.args)) {
+                sbArgs.push(`${name}=${this.attrValue(typeof value, value)}`);
+            }
+        }
+        const prefix = attr.comment ? '// ' : '';
+        return `${prefix}@${attr.name}(${sbArgs.join(',')})`;
+    }
     toInterface(ast) {
         const sb = [];
         if (ast.comment) {
             sb.push(ast.comment.split('\n').map(x => `// ${x}`).join('\n'));
         }
+        if (ast.annotations?.length) {
+            for (const attr of ast.annotations) {
+                sb.push(this.toAttr(attr));
+            }
+        }
         const extend = ast.extends ? ` extends ${ast.extends}` : '';
         sb.push(`export interface ${ast.name}${extend} {`);
         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) {
+                    sb.push('  ' + this.toAttr(attr));
+                }
+            }
             sb.push(`  ${prop.name}${prop.optional ? '?' : ''}: ${prop.type}`);
         }
         sb.push('}');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "okai",
   "type": "module",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "bin": "./dist/okai.js",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -12,7 +12,7 @@
     "import": "./dist/index.js"
   },
   "scripts": {
-    "build": "bun run clean && tsc",
+    "build": "bun run clean && tsc && chmod +x ./dist/okai.js",
     "build-bun": "bun run clean && bun build.ts",
     "clean": "shx rm -rf ./dist",
     "test": "bun test --",