agentlang 0.0.2

package/src/runtime/util.ts

@@ -0,0 +1,513 @@
+import { isNodeEnv } from '../utils/runtime.js';
+import {
+  AliasSpec,
+  CatchSpec,
+  ExtendsClause,
+  MetaDefinition,
+  PrePostTriggerDefinition,
+  RbacSpecDefinition,
+  RecordExtraDefinition,
+  RecordSchemaDefinition,
+  Statement,
+} from '../language/generated/ast.js';
+import { readFile } from '../utils/fs-utils.js';
+import { logger } from './logger.js';
+
+export const QuerySuffix = '?';
+
+// Conditionally import Node.js specific modules
+let exec: any = undefined;
+let promisify: any = undefined;
+if (isNodeEnv) {
+  // Dynamic import for node:child_process to avoid browser compatibility issues
+  const childProcess = await import('node:child_process');
+  exec = childProcess.exec;
+
+  const nu = await import('node:util');
+  promisify = nu.promisify;
+}
+
+const importedModules = new Map<string, any>();
+
+// Usage: importModule("./mymodels/acme.js")
+export async function importModule(path: string, name: string) {
+  const m = await import(/* @vite-ignore */ path);
+  importedModules.set(name, m);
+  // e.g of dynamic fn-call:
+  //// let f = eval("(a, b) => m.add(a, b)");
+  //// console.log(f(10, 20))
+  return m;
+}
+
+export function moduleImported(moduleName: string): boolean {
+  return importedModules.has(moduleName);
+}
+
+function maybeEvalFunction(fnName: string): Function | undefined {
+  try {
+    return eval(fnName);
+  } catch (reason: any) {
+    logger.debug(reason);
+    return undefined;
+  }
+}
+
+export async function invokeModuleFn(
+  fqFnName: string,
+  args: Array<any> | null,
+  isAsync: boolean = false
+): Promise<any> {
+  try {
+    const refs: string[] = splitRefs(fqFnName);
+    const m = importedModules.get(refs[0]);
+    if (m != undefined) {
+      const f = m[refs[1]];
+      if (f != undefined) {
+        if (args == null)
+          if (isAsync) {
+            return await f();
+          } else return f();
+        else if (isAsync) {
+          return await f(...args);
+        } else return f(...args);
+      } else throw new Error(`Function not found - ${fqFnName}`);
+    } else throw new Error(`JavaScript module ${refs[0]} not found`);
+  } catch (reason: any) {
+    const pf: Function | undefined = maybeEvalFunction(fqFnName);
+    if (pf instanceof Function) {
+      if (args == null) {
+        if (isAsync) return await pf();
+        else return pf();
+      } else {
+        if (isAsync) return await pf(...args.slice(0, args.length - 1));
+        else return pf(...args.slice(0, args.length - 1));
+      }
+    } else {
+      throw new Error(reason);
+    }
+  }
+}
+
+export function isNumber(x: any): boolean {
+  return typeof x === 'number';
+}
+
+export function isMinusZero(value: number): boolean {
+  return 1 / value === -Infinity;
+}
+
+export function isBoolean(x: any): boolean {
+  return typeof x === 'boolean';
+}
+
+type MaybeString = string | undefined;
+
+export function isString(s: MaybeString): boolean {
+  return s != undefined && typeof s === 'string';
+}
+
+function asString(s: MaybeString): string {
+  if (s == undefined) return '';
+  else return s;
+}
+
+export class Path {
+  private moduleName: MaybeString;
+  private entryName: MaybeString;
+
+  constructor(moduleName: MaybeString, entryName: MaybeString) {
+    this.moduleName = moduleName;
+    this.entryName = entryName;
+  }
+
+  hasModule(): boolean {
+    return isString(this.moduleName);
+  }
+
+  hasEntry(): boolean {
+    return isString(this.entryName);
+  }
+
+  setModuleName(n: string): Path {
+    this.moduleName = n;
+    return this;
+  }
+
+  getModuleName(): string {
+    return asString(this.moduleName);
+  }
+
+  setEntryname(n: string): Path {
+    this.entryName = n;
+    return this;
+  }
+
+  getEntryName(): string {
+    return asString(this.entryName);
+  }
+
+  asFqName(): string {
+    return makeFqName(this.moduleName || '?', this.entryName || '?');
+  }
+
+  equals(p: Path): boolean {
+    return this.moduleName == p.moduleName && this.entryName == p.entryName;
+  }
+}
+
+export function newPath(): Path {
+  return new Path(undefined, undefined);
+}
+
+export function makeFqName(moduleName: string, entryName: string): string {
+  return moduleName + '/' + entryName;
+}
+
+export function forceAsFqName(entryName: string, moduleName: string): string {
+  if (entryName.indexOf('$') > 0) {
+    return restoreFqName(entryName);
+  }
+  if (isFqName(entryName)) {
+    return entryName;
+  }
+  return makeFqName(moduleName, entryName);
+}
+
+export function forceAsEscapedName(entryName: string, moduleName: string): string {
+  if (entryName.indexOf('$') > 0) {
+    return entryName;
+  }
+  if (isFqName(entryName)) {
+    return escapeFqName(entryName);
+  }
+  return `${moduleName}$${entryName}`;
+}
+
+export function isFqName(s: string): boolean {
+  return s.indexOf('/') > 0;
+}
+
+export function splitFqName(s: string): Path {
+  if (s.indexOf('/') > 0) {
+    const parts: string[] = s.split('/');
+    return new Path(parts[0], parts[1]);
+  }
+  return new Path(undefined, s);
+}
+
+export function splitRefs(s: string): string[] {
+  if (s.indexOf('.') > 0) {
+    return s.split('.');
+  } else {
+    return [s];
+  }
+}
+
+export function runShellCommand(cmd: string, options?: any, continuation?: Function) {
+  if (!isNodeEnv) {
+    console.warn('Shell commands cannot be executed in non-Node.js environments');
+    // Call continuation to allow the program flow to continue
+    if (continuation) continuation();
+    return;
+  }
+
+  if (!exec) {
+    console.error('Node.js child_process not available');
+    if (continuation) continuation();
+    return;
+  }
+
+  exec(cmd, options, (err: any, stdout: string, stderr: string) => {
+    if (err) {
+      throw new Error(`Failed to execute ${cmd} - ${err.message}`);
+    }
+    if (stdout.length > 0) {
+      console.log(stdout);
+      if (continuation) continuation();
+    }
+    if (stderr.length > 0) console.log(stderr);
+  });
+}
+
+export function escapeFqName(n: string, moduleName?: string): string {
+  if (moduleName) {
+    if (n.indexOf('/') < 0) {
+      return `${moduleName}$${n}`;
+    }
+  }
+  return n.replace('/', '$');
+}
+
+export function restoreFqName(n: string): string {
+  return n.replace('$', '/');
+}
+
+export function arrayEquals(a: Array<any>, b: Array<any>) {
+  if (a.length !== b.length) return false;
+  else {
+    // Comparing each element of your array
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+export const DefaultModuleName = 'agentlang';
+
+export function makeCoreModuleName(n: string): string {
+  return DefaultModuleName + '_' + n;
+}
+
+const InitFunctions: Function[] = [];
+
+export function registerInitFunction(f: Function) {
+  InitFunctions.push(f);
+}
+
+export async function runInitFunctions() {
+  for (let i = 0; i < InitFunctions.length; ++i) {
+    await InitFunctions[i]();
+  }
+  InitFunctions.splice(0, InitFunctions.length);
+}
+
+export function maybeExtends(ext: ExtendsClause | undefined): string | undefined {
+  return ext ? ext.parentName : undefined;
+}
+
+export function escapeQueryName(s: string): string {
+  if (s.endsWith('?')) {
+    return s.substring(0, s.length - 1);
+  } else {
+    return s;
+  }
+}
+
+export function joinStatements(stmts: string[]): string {
+  return stmts
+    .filter((s: string) => {
+      return s.trim().length > 0;
+    })
+    .join(';\n');
+}
+
+export const sleepMilliseconds = isNodeEnv
+  ? promisify(setTimeout)
+  : (m: any) => new Promise(r => setTimeout(r, m));
+
+export function now(): string {
+  return new Date().toISOString();
+}
+
+export async function slurpJsonFile(fileName: string): Promise<any> {
+  const s = await readFile(fileName);
+  return JSON.parse(s);
+}
+
+const enum ExtraType {
+  META,
+  RBAC,
+  PRE_POST_TRIGGER,
+}
+
+function findExtraSchema(
+  type: ExtraType,
+  scm: RecordSchemaDefinition | undefined
+): RecordExtraDefinition | undefined {
+  if (scm && scm.extras) {
+    return scm.extras.find((ex: RecordExtraDefinition) => {
+      switch (type) {
+        case ExtraType.META:
+          return ex.meta ? true : false;
+        case ExtraType.RBAC:
+          return ex.rbacSpec ? true : false;
+        case ExtraType.PRE_POST_TRIGGER:
+          return ex.prePost ? true : false;
+      }
+    });
+  } else {
+    return undefined;
+  }
+}
+
+export function findMetaSchema(
+  scm: RecordSchemaDefinition | undefined
+): MetaDefinition | undefined {
+  const ex = findExtraSchema(ExtraType.META, scm);
+  if (ex) {
+    return ex.meta;
+  }
+  return undefined;
+}
+
+export function findRbacSchema(
+  scm: RecordSchemaDefinition | undefined
+): RbacSpecDefinition | undefined {
+  const ex = findExtraSchema(ExtraType.RBAC, scm);
+  if (ex) {
+    return ex.rbacSpec;
+  }
+  return undefined;
+}
+
+export function findUqCompositeAttributes(
+  scm: RecordSchemaDefinition | undefined
+): Array<string> | undefined {
+  if (scm && scm.extras) {
+    const uqs = scm.extras.filter((ex: RecordExtraDefinition) => {
+      return ex.uq ? true : false;
+    });
+    if (uqs && uqs.length > 0) {
+      if (uqs.length == 1 && uqs[0].uq) {
+        return uqs[0].uq.attrs;
+      } else {
+        let attrs = new Array<string>();
+        uqs.forEach((uq: RecordExtraDefinition) => {
+          if (uq.uq) {
+            attrs = attrs.concat(uq.uq.attrs);
+          }
+        });
+        return attrs;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function findAllPrePostTriggerSchema(
+  scm: RecordSchemaDefinition | undefined
+): PrePostTriggerDefinition[] | undefined {
+  if (scm && scm.extras) {
+    let result: PrePostTriggerDefinition[] | undefined;
+    for (let i = 0; i < scm.extras.length; ++i) {
+      const rex: RecordExtraDefinition = scm.extras[i];
+      if (rex.prePost) {
+        if (result == undefined) {
+          result = new Array<PrePostTriggerDefinition>();
+        }
+        result.push(rex.prePost);
+      }
+    }
+    return result;
+  }
+  return undefined;
+}
+
+export enum CrudType {
+  CREATE,
+  UPDATE,
+  DELETE,
+  READ,
+  UPSERT,
+}
+
+export function asCrudType(s: string): CrudType {
+  const r: CrudType | undefined = CrudType[s.toUpperCase() as keyof typeof CrudType];
+  if (r == undefined) {
+    throw new Error(`${s} does not represent a valid CrudType`);
+  }
+  return r;
+}
+
+export function isPath(obj: any, ref?: string): boolean {
+  if (isString(obj)) {
+    const s = obj as string;
+    const r = s.indexOf('/') > 0;
+    if (r && ref) {
+      return s.indexOf(ref) >= 0;
+    }
+    return r;
+  } else {
+    return false;
+  }
+}
+
+export function fqNameFromPath(path: string): string | undefined {
+  const parts = path.split('/');
+  const len = parts.length;
+  if (len > 1) {
+    const n = restoreFqName(parts[len - 2]);
+    if (n.indexOf('/') > 0) {
+      return n;
+    }
+  }
+  return undefined;
+}
+
+export function firstAliasSpec(stmt: Statement): AliasSpec | undefined {
+  if (stmt.hints) {
+    for (let i = 0; i < stmt.hints.length; ++i) {
+      const rh = stmt.hints[i];
+      if (rh.aliasSpec) {
+        return rh.aliasSpec;
+      }
+    }
+  }
+  return undefined;
+}
+
+export function firstCatchSpec(stmt: Statement): CatchSpec | undefined {
+  if (stmt.hints) {
+    for (let i = 0; i < stmt.hints.length; ++i) {
+      const rh = stmt.hints[i];
+      if (rh.catchSpec) {
+        return rh.catchSpec;
+      }
+    }
+  }
+  return undefined;
+}
+
+function maybeExtractEntryName(n: string): string {
+  const i = n.indexOf('$');
+  if (i > 0) {
+    return n.substring(i + 1);
+  }
+  return n;
+}
+
+function maybeExtractModuleName(n: string, moduleName?: string | undefined): string {
+  const i = n.indexOf('$');
+  if (i > 0) {
+    return n.substring(0, i);
+  }
+  if (moduleName == undefined) {
+    throw new Error(`Failed to extract module-name from ${n}`);
+  }
+  return moduleName;
+}
+
+export function walkDownInstancePath(path: string): [string, string, string | undefined, string[]] {
+  const parts = path.split('/').filter((n: string) => {
+    return n.length > 0;
+  });
+  const nameParts = parts[0].split('$');
+  const hasParts = nameParts.length == 2;
+  let moduleName = hasParts ? nameParts[0] : parts[0];
+  let entryName = hasParts ? nameParts[1] : parts[1];
+  if (!hasParts && parts.length == 2) {
+    return [moduleName, entryName, undefined, parts];
+  }
+  if (parts.length > 1) {
+    let id: string | undefined = parts[1];
+    if (parts.length > 2) {
+      for (let i = 2; i < parts.length; ++i) {
+        const relName = parts[i];
+        moduleName = maybeExtractModuleName(relName, moduleName);
+        entryName = parts[++i];
+        moduleName = maybeExtractModuleName(entryName, moduleName);
+        entryName = maybeExtractEntryName(entryName);
+        if (i < parts.length) {
+          id = parts[++i];
+        } else {
+          id = undefined;
+        }
+      }
+    }
+    return [moduleName, entryName, id, parts];
+  }
+  return [moduleName, entryName, undefined, parts];
+}

package/src/setupClassic.ts

@@ -0,0 +1,43 @@
+import { MonacoEditorLanguageClientWrapper, type WrapperConfig } from 'monaco-editor-wrapper';
+import monarchSyntax from './syntaxes/agentlang.monarch.js';
+
+export const setupConfigClassic = () => {
+  return {
+    $type: 'classic',
+    editorAppConfig: {
+      codeResources: {
+        modified: {
+          uri: '/workspace/example.al',
+          text: `// Agentlang is running in the web!`,
+        },
+      },
+      useDiffEditor: false,
+      languageDef: {
+        languageExtensionConfig: { id: 'agentlang' },
+        monarchLanguage: monarchSyntax,
+      },
+      editorOptions: {
+        'semanticHighlighting.enabled': true,
+        theme: 'vs-dark',
+      },
+    },
+  };
+};
+
+export const executeClassic = async (htmlElement: HTMLElement) => {
+  try {
+    const config = setupConfigClassic();
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+
+    // Add the HTML container to the config
+    const wrapperConfig = {
+      ...config,
+      htmlContainer: htmlElement,
+    } as WrapperConfig;
+
+    // Initialize and start the wrapper
+    await wrapper.initAndStart(wrapperConfig);
+  } catch (error) {
+    console.error('Error initializing monaco editor:', error);
+  }
+};

package/src/setupCommon.ts

@@ -0,0 +1,33 @@
+// This file is kept for reference but is not used directly anymore
+// The monaco-editor-wrapper API has changed significantly in v6+
+
+// These functions are kept for reference but not used directly anymore
+
+/*
+export const defineUserServices = () => {
+  return {
+    userServices: {
+      // This API has changed in the latest version
+    },
+    debugLogging: true,
+  };
+};
+
+export const configureMonacoWorkers = () => {
+  // This function is kept for compatibility, but implementation has changed
+  // Use configureDefaultWorkerFactory from monaco-editor-wrapper/workers/workerLoaders in newer code
+};
+
+export const configureWorker = () => {
+  // vite does not extract the worker properly if it is URL is a variable
+  const lsWorker = new Worker(new URL('./language/main-browser', import.meta.url), {
+    type: 'module',
+    name: 'Agentlang Language Server',
+  });
+
+  return {
+    type: 'WorkerDirect',
+    worker: lsWorker,
+  };
+};
+*/

package/src/setupExtended.ts

@@ -0,0 +1,79 @@
+import { MonacoEditorLanguageClientWrapper, type WrapperConfig } from 'monaco-editor-wrapper';
+
+export const setupConfigExtended = () => {
+  const extensionFilesOrContents = new Map();
+  extensionFilesOrContents.set(
+    '/language-configuration.json',
+    new URL('../language-configuration.json', import.meta.url)
+  );
+  extensionFilesOrContents.set(
+    '/agentlang-grammar.json',
+    new URL('../syntaxes/agentlang.tmLanguage.json', import.meta.url)
+  );
+
+  return {
+    $type: 'extended',
+    editorAppConfig: {
+      codeResources: {
+        modified: {
+          uri: '/workspace/example.al',
+          text: `// Agentlang is running in the web!`,
+        },
+      },
+      useDiffEditor: false,
+      extensions: [
+        {
+          config: {
+            name: 'agentlang-web',
+            publisher: 'generator-langium',
+            version: '1.0.0',
+            engines: {
+              vscode: '*',
+            },
+            contributes: {
+              languages: [
+                {
+                  id: 'agentlang',
+                  extensions: ['.agentlang'],
+                  configuration: './language-configuration.json',
+                },
+              ],
+              grammars: [
+                {
+                  language: 'agentlang',
+                  scopeName: 'source.agentlang',
+                  path: './agentlang-grammar.json',
+                },
+              ],
+            },
+          },
+          filesOrContents: extensionFilesOrContents,
+        },
+      ],
+      userConfiguration: {
+        json: JSON.stringify({
+          'workbench.colorTheme': 'Default Dark Modern',
+          'editor.semanticHighlighting.enabled': true,
+        }),
+      },
+    },
+  };
+};
+
+export const executeExtended = async (htmlElement: HTMLElement) => {
+  try {
+    const config = setupConfigExtended();
+    const wrapper = new MonacoEditorLanguageClientWrapper();
+
+    // Add the HTML container to the config
+    const wrapperConfig = {
+      ...config,
+      htmlContainer: htmlElement,
+    } as WrapperConfig;
+
+    // Initialize and start the wrapper
+    await wrapper.initAndStart(wrapperConfig);
+  } catch (error) {
+    console.error('Error initializing monaco editor:', error);
+  }
+};

package/src/syntaxes/agentlang.monarch.ts

@@ -0,0 +1,31 @@
+// Monarch syntax highlighting for the agentlang language.
+export default {
+    keywords: [
+        '@after','@async','@before','@enum','@expr','@meta','@oneof','@rbac','@ref','@with_unique','allow','and','as','await','between','catch','contains','create','delete','else','entity','error','event','extends','false','for','if','import','in','into','like','module','not','not_found','or','purge','read','record','relationship','roles','true','update','upsert','where','workflow'
+    ],
+    operators: [
+        '*','+',',','-','.','/',':',';','<','<=','<>','=','>','>=','?','@'
+    ],
+    symbols: /\(|\)|\*|\+|,|-|\.|\/|:|;|<|<=|<>|=|>|>=|\?|@|\[|\]|\{|\}/,
+
+    tokenizer: {
+        initial: [
+            { regex: /(([_a-zA-Z][\w_]*)(\/([_a-zA-Z][\w_]*))?)/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"string"} }} },
+            { regex: /[_a-zA-Z][\w_]*/, action: { cases: { '@keywords': {"token":"keyword"}, '@default': {"token":"string"} }} },
+            { regex: /(["'])((\\{2})*|(.*?[^\\](\\{2})*))\1/, action: {"token":"string"} },
+            { regex: /-?[0-9]+/, action: {"token":"number"} },
+            { include: '@whitespace' },
+            { regex: /@symbols/, action: { cases: { '@operators': {"token":"operator"}, '@default': {"token":""} }} },
+        ],
+        whitespace: [
+            { regex: /\s+/, action: {"token":"white"} },
+            { regex: /\/\*/, action: {"token":"comment","next":"@comment"} },
+            { regex: /\/\/[^\n\r]*/, action: {"token":"comment"} },
+        ],
+        comment: [
+            { regex: /[^/\*]+/, action: {"token":"comment"} },
+            { regex: /\*\//, action: {"token":"comment","next":"@pop"} },
+            { regex: /[/\*]/, action: {"token":"comment"} },
+        ],
+    }
+};