agentlang 0.3.0 → 0.3.2

package/out/runtime/module.js

@@ -6,15 +6,23 @@ import { AdminSession } from './auth/defs.js';
 import { FetchModuleFn, PathAttributeName } from './defs.js';
 import { logger } from './logger.js';
 import { FlowStepPattern } from '../language/syntax.js';
-import { getAgentDirectives, getAgentDirectivesJson, getAgentGlossary, getAgentResponseSchema, getAgentScenarios, registerAgentDirectives, registerAgentGlossary, registerAgentResponseSchema, registerAgentScenarios, removeAgentDirectives, removeAgentGlossary, removeAgentResponseSchema, removeAgentScenarios, } from './agents/common.js';
+import { getAgentDirectives, getAgentDirectivesJson, getAgentGlossary, getAgentGlossaryJson, getAgentResponseSchema, getAgentScenarios, getAgentScenariosJson, registerAgentDirectives, registerAgentGlossary, registerAgentResponseSchema, registerAgentScenarios, removeAgentDirectives, removeAgentGlossary, removeAgentResponseSchema, removeAgentScenarios, } from './agents/common.js';
 export class ModuleEntry {
     constructor(name, moduleName) {
+        this.taggedAsPublic = false;
         this.name = name;
         this.moduleName = moduleName;
     }
     getFqName() {
         return makeFqName(this.moduleName, this.name);
     }
+    setPublic(flag) {
+        this.taggedAsPublic = flag;
+        return this;
+    }
+    isPublic() {
+        return this.taggedAsPublic;
+    }
 }
 function normalizePropertyNames(props) {
     // Convert iterator to array for compatibility with different Node.js versions
@@ -452,6 +460,9 @@ export class Record extends ModuleEntry {
             const ms = `@meta ${JSON.stringify(metaObj)}`;
             scms = `${scms},\n    ${ms}`;
         }
+        if (this.isPublic()) {
+            s = `@public ${s}`;
+        }
         return s.concat('\n{', scms, '\n}\n');
     }
     getUserAttributes() {
@@ -835,22 +846,28 @@ export class Agent extends Record {
         if (conds) {
             attrs.push(`    directives ${conds}`);
         }
-        const scns = getAgentScenarios(fqName);
+        const scns = getAgentScenariosJson(fqName);
         if (scns) {
-            attrs.push(`    scenarios ${JSON.stringify(scns)}`);
+            attrs.push(`    scenarios ${scns}`);
         }
-        const gls = getAgentGlossary(fqName);
+        const gls = getAgentGlossaryJson(fqName);
         if (gls) {
-            attrs.push(`    glossary ${JSON.stringify(gls)}`);
+            attrs.push(`    glossary ${gls}`);
         }
         const rscm = getAgentResponseSchema(fqName);
         if (rscm) {
             attrs.push(`   responseSchema ${rscm}`);
         }
-        return `agent ${Agent.NormalizeName(this.name)}
+        const s = `agent ${Agent.NormalizeName(this.name)}
 {
 ${attrs.join(',\n')}
 }`;
+        if (this.isPublic()) {
+            return `@public ${s}`;
+        }
+        else {
+            return s;
+        }
     }
     static EscapeName(n) {
         if (n.endsWith(Agent.Suffix)) {
@@ -893,6 +910,10 @@ export class Event extends Record {
         super(...arguments);
         this.type = RecordType.EVENT;
     }
+    isSystemDefined() {
+        var _a;
+        return ((_a = this.meta) === null || _a === void 0 ? void 0 : _a.get(SystemDefinedEvent)) === 'true';
+    }
 }
 var RelType;
 (function (RelType) {
@@ -911,7 +932,7 @@ export function newRelNodeEntry(nodeFqName, alias) {
 function relNodeEntryToString(node) {
     let n = `${node.origName}`;
     if (node.origAlias) {
-        n = n.concat(` as ${node.origAlias}`);
+        n = n.concat(` @as ${node.origAlias}`);
     }
     return n;
 }
@@ -1093,10 +1114,10 @@ export class Relationship extends Record {
     }
 }
 export class Workflow extends ModuleEntry {
-    constructor(name, patterns, moduleName, generatedName = false) {
+    constructor(name, patterns, moduleName, isPrePost = false) {
         super(name, moduleName);
         this.statements = patterns;
-        this.generatedName = generatedName;
+        this.isPrePost = isPrePost;
     }
     async addStatement(stmtCode) {
         const result = await parseStatement(stmtCode);
@@ -1222,11 +1243,30 @@ export class Workflow extends ModuleEntry {
     statementsToStrings() {
         return this.statementsToStringsHelper(this.statements);
     }
+    setPublic(flag) {
+        super.setPublic(flag);
+        if (!this.isPrePost) {
+            const n = normalizeWorkflowName(this.name);
+            const event = getEvent(n, this.moduleName);
+            event.setPublic(flag);
+        }
+        return this;
+    }
     toString() {
-        const n = this.generatedName ? untangleWorkflowName(this.name) : this.name;
-        let s = `workflow ${normalizeWorkflowName(n)} {\n`;
+        const n = this.isPrePost ? untangleWorkflowName(this.name) : this.name;
+        const nn = normalizeWorkflowName(n);
+        let s = `workflow ${nn} {\n`;
         const ss = this.statementsToStringsHelper(this.statements);
         s = s.concat(joinStatements(ss));
+        if (!this.isPrePost) {
+            const event = getEvent(nn, this.moduleName);
+            if ((event.isPublic() && event.isSystemDefined()) || this.isPublic()) {
+                s = `@public ${s}`;
+            }
+        }
+        else if (this.isPublic()) {
+            s = `@public ${s}`;
+        }
         return s.concat('\n}');
     }
 }
@@ -1310,6 +1350,46 @@ export class Flow extends ModuleEntry {
     }`;
     }
 }
+export class Scenario extends ModuleEntry {
+    constructor(name, moduleName, scn) {
+        super(name, moduleName);
+        this.def = scn;
+    }
+    toString() {
+        const obj = {
+            user: this.def.user,
+            ai: this.def.ai,
+        };
+        return `scenario ${this.name} ${JSON.stringify(obj)}`;
+    }
+}
+export class Directive extends ModuleEntry {
+    constructor(name, moduleName, def) {
+        super(name, moduleName);
+        this.def = def;
+    }
+    toString() {
+        const obj = {
+            if: this.def.if,
+            then: this.def.then,
+        };
+        return `directive ${this.name} ${JSON.stringify(obj)}`;
+    }
+}
+export class GlossaryEntry extends ModuleEntry {
+    constructor(name, moduleName, def) {
+        super(name, moduleName);
+        this.def = def;
+    }
+    toString() {
+        const obj = {
+            name: this.def.name,
+            meaning: this.def.meaning,
+            synonyms: this.def.synonyms,
+        };
+        return `glossaryEntry ${this.name} ${JSON.stringify(obj)}`;
+    }
+}
 export function flowGraphNext(graph, currentNode, onCondition) {
     var _a;
     if (!currentNode) {
@@ -1440,6 +1520,108 @@ export class Module {
         }
         return undefined;
     }
+    getAllDecisions() {
+        return this.entries.filter((e) => {
+            return e instanceof Decision;
+        });
+    }
+    removeDecision(name) {
+        for (let i = 0; i < this.entries.length; ++i) {
+            const entry = this.entries[i];
+            if (entry.name === name && entry instanceof Decision) {
+                this.entries.splice(i, 1);
+                return true;
+            }
+        }
+        return false;
+    }
+    addScenario(name, scn) {
+        const entry = new Scenario(name, this.name, scn);
+        this.addEntry(entry);
+        return entry;
+    }
+    getScenario(name) {
+        if (this.hasEntry(name)) {
+            const e = this.getEntry(name);
+            if (e instanceof Scenario) {
+                return e;
+            }
+        }
+        return undefined;
+    }
+    getAllScenarios() {
+        return this.entries.filter((e) => {
+            return e instanceof Scenario;
+        });
+    }
+    removeScenario(name) {
+        for (let i = 0; i < this.entries.length; ++i) {
+            const entry = this.entries[i];
+            if (entry.name === name && entry instanceof Scenario) {
+                this.entries.splice(i, 1);
+                break;
+            }
+        }
+        return this;
+    }
+    addDirective(name, cond) {
+        const entry = new Directive(name, this.name, cond);
+        this.addEntry(entry);
+        return entry;
+    }
+    getDirective(name) {
+        if (this.hasEntry(name)) {
+            const e = this.getEntry(name);
+            if (e instanceof Directive) {
+                return e;
+            }
+        }
+        return undefined;
+    }
+    getAllDirectives() {
+        return this.entries.filter((e) => {
+            return e instanceof Directive;
+        });
+    }
+    removeDirective(name) {
+        for (let i = 0; i < this.entries.length; ++i) {
+            const entry = this.entries[i];
+            if (entry.name === name && entry instanceof Directive) {
+                this.entries.splice(i, 1);
+                break;
+            }
+        }
+        return this;
+    }
+    addGlossaryEntry(name, ge) {
+        const entry = new GlossaryEntry(name, this.name, ge);
+        this.addEntry(entry);
+        return entry;
+    }
+    getGlossaryEntry(name) {
+        if (this.hasEntry(name)) {
+            const e = this.getEntry(name);
+            if (e instanceof GlossaryEntry) {
+                return e;
+            }
+        }
+        return undefined;
+    }
+    getAllGlossaryEntries() {
+        return this.entries.filter((e) => {
+            return e instanceof GlossaryEntry;
+        });
+    }
+    removeGlossaryEntry(name) {
+        for (let i = 0; i < this.entries.length; ++i) {
+            const entry = this.entries[i];
+            if (entry.name === name && entry instanceof GlossaryEntry) {
+                this.entries.splice(i, 1);
+                break;
+            }
+        }
+        return this;
+    }
     addStandaloneStatement(stmt) {
         const s = new StandaloneStatement(stmt, this.name);
         this.addEntry(s);
@@ -1465,6 +1647,12 @@ export class Module {
             throw new Error(`Entry ${entryName} not found in module ${this.name}`);
         return this.entries[idx];
     }
+    getEntrySafe(entryName) {
+        const idx = this.getEntryIndex(entryName);
+        if (idx < 0)
+            return undefined;
+        return this.entries[idx];
+    }
     getRecord(recordName) {
         const e = this.getEntry(recordName);
         if (e instanceof Record) {
@@ -1524,10 +1712,24 @@ export class Module {
         });
     }
     getWorkflowForEvent(eventName) {
-        return this.getEntry(asWorkflowName(eventName));
+        const entry = this.getEntrySafe(asWorkflowName(eventName));
+        if (entry)
+            return entry;
+        else
+            return undefined;
+    }
+    eventIsPublic(eventName) {
+        const entry = this.getEntry(eventName);
+        if (entry instanceof Event) {
+            return entry.isPublic();
+        }
+        return false;
     }
     isPrePostEvent(eventName) {
-        return this.getWorkflowForEvent(eventName).generatedName;
+        const wf = this.getWorkflowForEvent(eventName);
+        if (wf)
+            return wf.isPrePost;
+        return false;
     }
     isEntryOfType(t, name) {
         const entry = this.getEntriesOfType(t).find((v) => {
@@ -1703,6 +1905,10 @@ const TextualTypes = new Set(['String', 'Email', 'UUID', 'DateTime', 'Date', 'Ti
 function isTextualType(type) {
     return TextualTypes.has(type);
 }
+const NumericTypes = new Set(['Int', 'Number', 'Float', 'Decimal']);
+function isNumericType(type) {
+    return NumericTypes.has(type);
+}
 export function isBuiltInType(type) {
     return builtInTypes.has(type);
 }
@@ -1824,6 +2030,9 @@ export function isArrayAttribute(attrSpec) {
 export function isObjectAttribute(attrSpec) {
     return getBooleanProperty('object', attrSpec);
 }
+export function isNumericAttribute(attrSpec) {
+    return isNumericType(attrSpec.type);
+}
 export function getAttributeExpr(attrSpec) {
     return getAnyProperty('expr', attrSpec);
 }
@@ -1897,7 +2106,7 @@ function normalizeWorkflowName(n) {
     }
     return n;
 }
-export function addWorkflow(name, moduleName = activeModule, statements, hdr) {
+export function addWorkflow(name, moduleName = activeModule, statements, hdr, ispub = false) {
     if (hdr) {
         name = prePostWorkflowName(hdr.tag, hdr.prefix, hdr.name, moduleName);
     }
@@ -1908,9 +2117,11 @@ export function addWorkflow(name, moduleName = activeModule, statements, hdr) {
             throw new Error(`Not an event, cannot attach workflow to ${entry.name}`);
     }
     else {
-        addEvent(name, moduleName);
-        const event = module.getEntry(name);
+        const event = addEvent(name, moduleName);
         event.addMeta(SystemDefinedEvent, 'true');
+        if (ispub) {
+            event.setPublic(true);
+        }
     }
     if (!statements)
         statements = new Array();
@@ -2239,7 +2450,11 @@ export class Instance {
         attrs.forEach((v, k) => {
             const attrSpec = this.record.schema.get(k);
             if (attrSpec) {
-                if ((isArrayAttribute(attrSpec) || isObjectAttribute(attrSpec)) && isString(v)) {
+                const isstr = isString(v);
+                if (isNumericAttribute(attrSpec) && isstr) {
+                    attrs.set(k, Number(v));
+                }
+                else if ((isArrayAttribute(attrSpec) || isObjectAttribute(attrSpec)) && isstr) {
                     const obj = JSON.parse(v);
                     attrs.set(k, obj);
                 }
@@ -2533,7 +2748,7 @@ export function makeInstance(moduleName, entryName, attributes, queryAttributes,
     if (schema.size > 0) {
         attributes.forEach((value, key) => {
             if (!schema.has(key)) {
-                throw new Error(`Invalid attribute ${key} specified for ${moduleName}/${entryName}`);
+                throw new Error(`Invalid attribute '${key}' specified for ${moduleName}/${entryName}`);
             }
             const spec = getAttributeSpec(schema, key);
             if (value != null && value != undefined)
@@ -2628,6 +2843,10 @@ export function defineAgentEvent(moduleName, agentName, instruction) {
         event.addMeta(DocumentationMetaTag, `This event will trigger an agent which has the instruction - "${instruction}".
     So make sure to pass all relevant information in the 'message' attribute of this event.`);
     }
+    const agent = module.getAgent(agentName);
+    if (agent && agent.isPublic()) {
+        event.setPublic(true);
+    }
     module.addEntry(event);
 }
 export function isTimer(eventInst) {