agentlang 0.0.16 → 0.0.17

package/src/language/agentlang.langium

@@ -154,7 +154,7 @@ Delete: 'delete' pattern=Pattern;
 
 Purge: 'purge' pattern=Pattern;
 
-SetAttribute: name=QueryId op=('='|'<>'|'<'|'<='|'>'|'>='|'in'|'like'|'between')? value=AttributeValueExpression;
+SetAttribute: name=QueryId op=('='|'<>' | '!=' |'<'|'<='|'>'|'>='|'in'|'like'|'between')? value=AttributeValueExpression;
 
 AttributeValueExpression: Expr;
 
@@ -170,7 +170,7 @@ Logical infers Expr:
     Comparison ({infer BinExpr.e1=current} op=('or'|'and') e2=Comparison)*;
 
 Comparison infers Expr:
-    PrimExpr ({infer BinExpr.e1=current} op=('='|'<>'|'<'|'<='|'>'|'>='|'in'|'like') e2=PrimExpr)*;
+    PrimExpr ({infer BinExpr.e1=current} op=('=' | '!=' | '<>'|'<'|'<='|'>'|'>='|'in'|'like') e2=PrimExpr)*;
 
 PrimExpr: Literal | Group | NegExpr | NotExpr;
 

package/src/language/generated/ast.ts

@@ -3,7 +3,7 @@
  * DO NOT EDIT MANUALLY!
  ******************************************************************************/
 
-/* eslint-disable */
+ 
 import * as langium from 'langium';
 
 export const AgentlangTerminals = {
@@ -18,6 +18,7 @@ export const AgentlangTerminals = {
 export type AgentlangTerminalNames = keyof typeof AgentlangTerminals;
 
 export type AgentlangKeywordNames =
+    | "!="
     | "("
     | ")"
     | "*"
@@ -311,7 +312,7 @@ export interface BinExpr extends langium.AstNode {
     readonly $type: 'BinExpr';
     e1: Expr | PrimExpr;
     e2: Expr | PrimExpr;
-    op: '*' | '+' | '-' | '/' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'and' | 'in' | 'like' | 'or';
+    op: '!=' | '*' | '+' | '-' | '/' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'and' | 'in' | 'like' | 'or';
 }
 
 export const BinExpr = 'BinExpr';
@@ -1061,7 +1062,7 @@ export interface SetAttribute extends langium.AstNode {
     readonly $container: CrudMapBody;
     readonly $type: 'SetAttribute';
     name: QueryId;
-    op?: '<' | '<=' | '<>' | '=' | '>' | '>=' | 'between' | 'in' | 'like';
+    op?: '!=' | '<' | '<=' | '<>' | '=' | '>' | '>=' | 'between' | 'in' | 'like';
     value: AttributeValueExpression;
 }
 

package/src/language/generated/grammar.ts

@@ -4423,6 +4423,10 @@ export const AgentlangGrammar = (): Grammar => loadedAgentlangGrammar ?? (loaded
                   "$type": "Keyword",
                   "value": "<>"
                 },
+                {
+                  "$type": "Keyword",
+                  "value": "!="
+                },
                 {
                   "$type": "Keyword",
                   "value": "<"
@@ -4763,6 +4767,10 @@ export const AgentlangGrammar = (): Grammar => loadedAgentlangGrammar ?? (loaded
                       "$type": "Keyword",
                       "value": "="
                     },
+                    {
+                      "$type": "Keyword",
+                      "value": "!="
+                    },
                     {
                       "$type": "Keyword",
                       "value": "<>"

package/src/runtime/agents/common.ts

@@ -67,7 +67,7 @@ The default query operator is '=' (equals). So an expression like 'employeeId? "
 '{age?< 50}' - which means 'where age less-than 50'. The comparison operators supported by a query pattern are:
 
 =         - equals
-<>        - not-equals
+!=        - not-equals
 <         - less-than
 <=        - less-than or equals
 >         - greater-than
@@ -148,6 +148,20 @@ A fix for the reference-error is shown below:
 {Employee {id? 101}} @as employee;
 {SendEmail {to employee.email, body "hello"}}
 
+Keep in mind that the only valid syntax for the 'if' condition is:
+
+if (<expr>) {
+    <patterns>
+} else if (<expr>) {
+    <patterns>
+} else {
+    <patterns>
+}
+
+The following usage is NOT valid:
+
+<pattern> if (<expr>)
+
 A pattern may execute asynchronously and its eventual result can be handled by patterns provided in the '@then' clause. An example is shown below:
 
 {sendChatMessage {to "amy", "text" "hello"}} @as response @then {
@@ -241,7 +255,7 @@ As an example, if the user request is "send an email to employee 101 with this m
 [{employee {id? 101}} @as emp;
  {email {to emp.email, body "please call me as soon as possible"}}]
 
-Note that each pattern in the array is separated by a ; and not a comma(,).
+You MUST separate each pattern in the array with a semi-colon (;)  and never use a comma (,) for this purpose.
 
 Now consider the following module definition and generate appropriate patterns in response to the user instructions. You must return only valid patterns or workflows,
 no other descriptive text or comments are needed.

package/src/runtime/auth/cognito.ts

@@ -34,6 +34,7 @@ import {
 let fromEnv: any = undefined;
 let CognitoIdentityProviderClient: any = undefined;
 let SignUpCommand: any = undefined;
+let ConfirmSignUp: any = undefined;
 let AdminGetUserCommand: any = undefined;
 let InitiateAuthCommand: any = undefined;
 let AuthenticationDetails: any = undefined;
@@ -51,6 +52,7 @@ if (isNodeEnv) {
   const cip = await import('@aws-sdk/client-cognito-identity-provider');
   CognitoIdentityProviderClient = cip.CognitoIdentityProviderClient;
   SignUpCommand = cip.SignUpCommand;
+  ConfirmSignUp = cip.ConfirmSignUpCommand;
   AdminGetUserCommand = cip.AdminGetUserCommand;
   InitiateAuthCommand = cip.InitiateAuthCommand;
 
@@ -321,6 +323,8 @@ export class CognitoAuth implements AgentlangAuth {
   }
 
   async signUp(
+    firstName: string,
+    lastName: string,
     username: string,
     password: string,
     userData: Map<string, string> | undefined,
@@ -340,6 +344,14 @@ export class CognitoAuth implements AgentlangAuth {
         Name: 'name',
         Value: username,
       },
+      {
+        Name: 'given_name',
+        Value: firstName,
+      },
+      {
+        Name: 'family_name',
+        Value: lastName,
+      },
     ];
     if (userData) {
       userData.forEach((v: string, k: string) => {
@@ -384,6 +396,24 @@ export class CognitoAuth implements AgentlangAuth {
     }
   }
 
+  async confirmSignup(username: string, confirmationCode: string, env: Environment): Promise<void> {
+    try {
+      const client = new CognitoIdentityProviderClient({
+        region: process.env.AWS_REGION || 'us-west-2',
+        credentials: fromEnv(),
+      });
+      const command = new ConfirmSignUp({
+        ClientId: this.config.get('ClientId'),
+        Username: username,
+        ConfirmationCode: confirmationCode,
+      });
+      await client.send(command);
+    } catch (error: any) {
+      logger.error(`Failed to confirm signup: ${error.message}`);
+      throw error;
+    }
+  }
+
   async login(
     username: string,
     password: string,

package/src/runtime/auth/interface.ts

@@ -22,12 +22,15 @@ export type LogoutCallback = (status: boolean) => void;
 
 export interface AgentlangAuth {
   signUp(
+    firstName: string,
+    lastName: string,
     username: string,
     password: string,
     userData: Map<string, any> | undefined,
     env: Environment,
     cb: SignUpCallback
   ): any;
+  confirmSignup(username: string, confirmationCode: string, env: Environment): Promise<void>;
   login(username: string, password: string, env: Environment, cb: LoginCallback): any;
   logout(sessionInfo: SessionInfo, env: Environment, cb?: LogoutCallback): any;
   verifyToken(token: string, env?: Environment): any;

package/src/runtime/interpreter.ts

@@ -1127,8 +1127,15 @@ async function evaluateCrudMap(crud: CrudMap, env: Environment): Promise<void> {
           for (let j = 0; j < lastRes.length; ++j) {
             const newEnv: Environment = Environment.from(env);
             if (isContainsRelationship(rel.name, moduleName)) {
-              const ppath = lastRes[j].attributes.get(PathAttributeName);
-              newEnv.setParentPath(ppath + '/' + escapeFqName(relEntry.getFqName()));
+              const currInst: Instance = lastRes[j];
+              let ppath = '';
+              if (relEntry.isParent(currInst)) {
+                ppath = currInst.lookup(PathAttributeName);
+                newEnv.setParentPath(ppath + '/' + escapeFqName(relEntry.getFqName()));
+              } else {
+                ppath = currInst.lookup(ParentAttributeName);
+                newEnv.setParentPath(ppath);
+              }
               newEnv.setNormalizedParentPath(ppath);
               await evaluatePattern(rel.pattern, newEnv);
               lastRes[j].attachRelatedInstances(rel.name, newEnv.getLastResult());
@@ -1303,11 +1310,17 @@ async function handleAgentInvocation(agentEventInst: Instance, env: Environment)
       logger.debug(`Agent ${agent.name} generated pattern: ${result}`);
       try {
         let rs = result.trim();
-        if (rs.startsWith('[')) {
+        let isWf = rs.startsWith('workflow');
+        const isGrp = rs.startsWith('[');
+        if (!isWf && !isGrp && rs.indexOf(';') > 0) {
+          rs = `workflow T {${rs}}`;
+          isWf = true;
+        } else if (!isWf && isGrp) {
           const stmts = rs.substring(1, rs.length - 1);
           rs = `workflow T {${stmts}}`;
+          isWf = true;
         }
-        if (rs.startsWith('workflow')) {
+        if (isWf) {
           const wf = await parseWorkflow(rs);
           if (agent.runWorkflows) {
             await evaluateStatements(wf.statements, env);
@@ -1334,7 +1347,10 @@ function cleanupAgentResponse(response: string | undefined): string | undefined
     }
     const parts = resp.split('\n');
     const validated = parts.filter((s: string) => {
-      const stmt = s.trim();
+      let stmt = s.trim();
+      if (stmt.endsWith(',')) {
+        stmt = `${stmt.substring(0, stmt.length - 1)};`;
+      }
       const r =
         stmt.startsWith('{') ||
         stmt.startsWith('}') ||
@@ -1479,6 +1495,7 @@ async function evaluateExpression(expr: Expr, env: Environment): Promise<void> {
         result = v1 >= v2;
         break;
       case '<>':
+      case '!=':
         result = v1 != v2;
         break;
       case 'like':

package/src/runtime/jsmodules.ts

@@ -36,7 +36,7 @@ export async function importModule(path: string, name: string, moduleFileName?:
     }
     path = `${s}${sep}${path}`;
   }
-  if (!(path.startsWith(sep) || path.startsWith('.'))) {
+  if ((path.startsWith(sep) || path.startsWith('.')) && moduleFileName) {
     path = process.cwd() + sep + path;
   }
   const m = await import(/* @vite-ignore */ path);

package/src/runtime/module.ts

@@ -139,6 +139,8 @@ function attributePropertyValueToString(
     if (isTextualType(attrType) && propValue != 'now()' && propValue != 'uuid()') {
       return `"${propValue}"`;
     }
+  } else if (propName == 'comment') {
+    return `"${propValue}"`;
   }
   return `${propValue}`;
 }
@@ -171,7 +173,7 @@ function normalizeMetaValue(metaValue: any): any {
       return normalizeMetaValue(value.pattern.expr);
     });
   } else if (v.bool != undefined) {
-    return v.bool;
+    return v.bool == 'true' ? true : false;
   } else if (v.id) {
     return v.id;
   } else if (v.map) {
@@ -884,6 +886,11 @@ export class Entity extends Record {
   getRbacSpecifications(): RbacSpecification[] | undefined {
     return this.rbac;
   }
+
+  isConfigEntity(): boolean {
+    const v = this.getMeta('configEntity');
+    return v == true;
+  }
 }
 
 export class Event extends Record {
@@ -1286,6 +1293,12 @@ export class Module {
     return entry;
   }
 
+  getConfigEntity(): Entity | undefined {
+    return this.getEntityEntries().find((e: Entity) => {
+      return e.isConfigEntity();
+    });
+  }
+
   addAgent(agentEntry: Agent): Agent {
     return this.addEntry(agentEntry) as Agent;
   }
@@ -1590,6 +1603,7 @@ export const propertyNames = new Set([
   '@readonly',
   '@enum',
   '@oneof',
+  '@comment',
 ]);
 
 const TextualTypes = new Set(['String', 'Email', 'UUID', 'DateTime', 'Date', 'Time', 'Path']);

package/src/runtime/modules/auth.ts

@@ -173,7 +173,11 @@ workflow RemoveUserSession {
 }
 
 workflow signup {
-  await Auth.signUpUser(signup.email, signup.password, signup.userData)
+  await Auth.signUpUser(signup.firstName, signup.lastName, signup.email, signup.password, signup.userData)
+}
+
+workflow confirmSignup {
+  await Auth.confirmSignupUser(confirmSignup.email, confirmSignup.confirmationCode)
 }
 
 workflow login {
@@ -573,7 +577,10 @@ function fetchAuthImpl(): AgentlangAuth {
     throw new Error('Auth not initialized');
   }
 }
+
 export async function signUpUser(
+  firstName: string,
+  lastName: string,
   username: string,
   password: string,
   userData: object,
@@ -582,6 +589,8 @@ export async function signUpUser(
   let result: any;
   try {
     await fetchAuthImpl().signUp(
+      firstName,
+      lastName,
       username,
       password,
       userData ? new Map(Object.entries(userData)) : undefined,
@@ -597,6 +606,24 @@ export async function signUpUser(
   }
 }
 
+export async function confirmSignupUser(
+  username: string,
+  confirmationCode: string,
+  env: Environment
+): Promise<any> {
+  try {
+    console.log('confirmSignupUser', username, confirmationCode, env);
+    await fetchAuthImpl().confirmSignup(username, confirmationCode, env);
+    return {
+      status: 'ok',
+      message: 'User confirmed successfully',
+    };
+  } catch (err: any) {
+    logger.error(`Confirm signup failed for ${username}: ${err.message}`);
+    throw err; // Re-throw to preserve error type for HTTP status mapping
+  }
+}
+
 export async function loginUser(
   username: string,
   password: string,
@@ -870,7 +897,10 @@ export function requireAuth(moduleName: string, eventName: string): boolean {
   if (isAuthEnabled()) {
     const f =
       moduleName == CoreAuthModuleName &&
-      (eventName == 'login' || eventName == 'signup' || eventName == 'refreshToken');
+      (eventName == 'login' ||
+        eventName == 'signup' ||
+        eventName == 'confirmSignup' ||
+        eventName == 'refreshToken');
     return !f;
   } else {
     return false;

package/src/syntaxes/agentlang.monarch.ts

@@ -4,9 +4,9 @@ export default {
         '@actions','@after','@as','@async','@before','@catch','@distinct','@enum','@expr','@from','@into','@meta','@oneof','@rbac','@ref','@then','@upsert','@with_unique','agent','allow','and','await','between','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','like','module','not','not_found','onSubscription','or','purge','query','read','record','relationship','resolver','return','roles','subscribe','true','update','upsert','where','workflow'
     ],
     operators: [
-        '*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'
+        '!=','*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'
     ],
-    symbols: /\(|\)|\*|\+|,|-|\.|\/|:|;|<|<=|<>|=|>|>=|\?|@|\[|\]|\{|\}/,
+    symbols: /!=|\(|\)|\*|\+|,|-|\.|\/|:|;|<|<=|<>|=|>|>=|\?|@|\[|\]|\{|\}/,
 
     tokenizer: {
         initial: [