agency-lang 0.0.16 → 0.0.18

package/dist/lib/backends/agencyGenerator.js

@@ -66,12 +66,13 @@ export class AgencyGenerator extends BaseGenerator {
                 return literal.value;
             case "string":
                 // Escape backslashes and quotes
-                const escaped = literal.value
-                    .replace(/\\/g, "\\\\")
-                    .replace(/"/g, '\\"');
+                const escaped = literal.value;
                 return `"${escaped}"`;
             case "variableName":
                 return literal.value;
+            case "multiLineString":
+                const escapedMultiLine = literal.value;
+                return `"""${escapedMultiLine}"""`;
             case "prompt":
                 return this.generatePromptLiteral(literal);
             default:
@@ -111,8 +112,11 @@ export class AgencyGenerator extends BaseGenerator {
             }
         })
             .join(", ");
+        const returnTypeStr = node.returnType
+            ? ": " + variableTypeToString(node.returnType, this.typeAliases)
+            : "";
         // Start function definition
-        let result = this.indentStr(`def ${functionName}(${params}) {\n`);
+        let result = this.indentStr(`def ${functionName}(${params})${returnTypeStr} {\n`);
         // Process body with increased indentation
         this.increaseIndent();
         if (node.docString) {
@@ -233,7 +237,10 @@ export class AgencyGenerator extends BaseGenerator {
         // Graph nodes use similar syntax to functions
         const { nodeName, body, parameters } = node;
         const params = parameters.join(", ");
-        let result = this.indentStr(`node ${nodeName}(${params}) {\n`);
+        const returnTypeStr = node.returnType
+            ? ": " + variableTypeToString(node.returnType, this.typeAliases)
+            : "";
+        let result = this.indentStr(`node ${nodeName}(${params})${returnTypeStr} {\n`);
         this.increaseIndent();
         this.functionScopedVariables = [...parameters];
         const lines = [];
@@ -244,7 +251,7 @@ export class AgencyGenerator extends BaseGenerator {
         result += bodyCode;
         this.functionScopedVariables = [];
         this.decreaseIndent();
-        result += this.indentStr(`}\n`);
+        result += this.indentStr(`}\n\n`);
         return result;
     }
     processTool(node) {

package/dist/lib/backends/baseGenerator.d.ts

@@ -11,10 +11,11 @@ import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
 export declare class BaseGenerator {
     protected typeHints: TypeHintMap;
-    protected graphNodes: string[];
+    protected graphNodes: GraphNodeDefinition[];
     protected generatedStatements: string[];
     protected generatedTypeAliases: string[];
     protected functionScopedVariables: string[];
+    protected globalScopedVariables: string[];
     protected toolsUsed: string[];
     protected typeAliases: Record<string, VariableType>;
     protected functionsUsed: Set<string>;

package/dist/lib/backends/baseGenerator.js

@@ -4,6 +4,7 @@ export class BaseGenerator {
     generatedStatements = [];
     generatedTypeAliases = [];
     functionScopedVariables = [];
+    globalScopedVariables = [];
     // collect tools for a prompt
     toolsUsed = [];
     typeAliases = {};
@@ -39,7 +40,13 @@ export class BaseGenerator {
                 this.collectFunctionSignature(node);
             }
         }
-        // Pass 5: Process all nodes and generate code
+        // Pass 5: Collect global scoped variables
+        for (const node of program.nodes) {
+            if (node.type === "assignment") {
+                this.globalScopedVariables.push(node.variableName);
+            }
+        }
+        // Pass 6: Process all nodes and generate code
         for (const node of program.nodes) {
             const result = this.processNode(node);
             this.generatedStatements.push(result);
@@ -91,6 +98,7 @@ export class BaseGenerator {
             case "matchBlock":
                 return this.processMatchBlock(node);
             case "number":
+            case "multiLineString":
             case "string":
             case "variableName":
             case "prompt":

package/dist/lib/backends/graphGenerator.js

@@ -7,6 +7,7 @@ import * as renderStartNode from "../templates/backends/graphGenerator/startNode
 import * as renderRunNodeFunction from "../templates/backends/graphGenerator/runNodeFunction.js";
 import { TypeScriptGenerator } from "./typescriptGenerator.js";
 import { mapFunctionName } from "./typescriptGenerator/builtins.js";
+import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 export class GraphGenerator extends TypeScriptGenerator {
     typeHints = {};
     generatedStatements = [];
@@ -203,7 +204,7 @@ export class GraphGenerator extends TypeScriptGenerator {
         else {
             const returnCode = this.processNode(node.value);
             if (node.value.type === "functionCall" &&
-                this.graphNodes.includes(node.value.functionName)) {
+                this.graphNodes.map((n) => n.nodeName).includes(node.value.functionName)) {
                 // we're going to return a goToNode call, so just return that directly
                 return `return ${returnCode}\n`;
             }
@@ -211,7 +212,7 @@ export class GraphGenerator extends TypeScriptGenerator {
         }
     }
     processGraphNodeName(node) {
-        this.graphNodes.push(node.nodeName);
+        this.graphNodes.push(node);
     }
     processGraphNode(node) {
         const { nodeName, body, parameters } = node;
@@ -234,13 +235,16 @@ export class GraphGenerator extends TypeScriptGenerator {
         this.isInsideGraphNode = false;
         return graphNode.default({
             name: nodeName,
+            /* returnType: node.returnType
+              ? variableTypeToString(node.returnType, this.typeAliases)
+              : "any", */
             body: bodyCode.join("\n"),
             hasParam: parameters.length > 0,
             paramName: parameters[0] || "input",
         });
     }
     processFunctionCall(node) {
-        if (this.graphNodes.includes(node.functionName)) {
+        if (this.graphNodes.map((n) => n.nodeName).includes(node.functionName)) {
             this.currentAdjacentNodes.push(node.functionName);
             this.functionsUsed.add(node.functionName);
             const functionCallCode = this.generateNodeCallExpression(node);
@@ -258,10 +262,11 @@ export class GraphGenerator extends TypeScriptGenerator {
                 this.functionsUsed.add(arg.functionName);
                 return this.generateFunctionCallExpression(arg);
                 /*       } else if (arg.type === "accessExpression") {
-                        return this.processAccessExpression(arg);
-                      } else if (arg.type === "indexAccess") {
-                        return this.processIndexAccess(arg);
-                 */ }
+                return this.processAccessExpression(arg);
+              } else if (arg.type === "indexAccess") {
+                return this.processIndexAccess(arg);
+         */
+            }
             else {
                 return this.processNode(arg);
                 //        return this.generateLiteral(arg);
@@ -279,7 +284,9 @@ export class GraphGenerator extends TypeScriptGenerator {
     } */
     generateImports() {
         let arr = [
-            renderImports.default({ nodes: JSON.stringify(this.graphNodes) }),
+            renderImports.default({
+                nodes: JSON.stringify(this.graphNodes.map((n) => n.nodeName)),
+            }),
         ];
         arr.push(builtinTools.default({}));
         return arr.join("\n");
@@ -299,14 +306,17 @@ export class GraphGenerator extends TypeScriptGenerator {
                 toNodes: JSON.stringify(adjacent),
             }));
         });
-        if (this.graphNodes.includes("main")) {
+        if (this.graphNodes.map((n) => n.nodeName).includes("main")) {
             lines.push(renderStartNode.default({
                 startNode: "main",
             }));
         }
         for (const node of this.graphNodes) {
             lines.push(renderRunNodeFunction.default({
-                nodeName: node,
+                nodeName: node.nodeName,
+                returnType: node.returnType
+                    ? variableTypeToString(node.returnType, this.typeAliases)
+                    : "any",
             }));
         }
         lines.push("export default graph;");

package/dist/lib/backends/typescriptGenerator.js

@@ -135,7 +135,8 @@ export class TypeScriptGenerator extends BaseGenerator {
             .filter((s) => s.type === "interpolation")
             .map((s) => s.variableName);
         for (const varName of interpolatedVars) {
-            if (!this.functionScopedVariables.includes(varName)) {
+            if (!this.functionScopedVariables.includes(varName) &&
+                !this.globalScopedVariables.includes(varName)) {
                 throw new Error(`Variable '${varName}' used in prompt interpolation but not defined. ` +
                     `Referenced in assignment to '${variableName}'.`);
             }
@@ -152,7 +153,7 @@ export class TypeScriptGenerator extends BaseGenerator {
     }
     processTool(node) {
         const { functionName, body, parameters } = node;
-        if (this.graphNodes.includes(functionName)) {
+        if (this.graphNodes.map((n) => n.nodeName).includes(functionName)) {
             throw new Error(`There is already a node named '${functionName}'. Functions can't have the same name as an existing node.`);
         }
         const properties = {};
@@ -193,6 +194,9 @@ export class TypeScriptGenerator extends BaseGenerator {
         return renderFunctionDefinition.default({
             functionName,
             args: "{" + args + "}",
+            returnType: node.returnType
+                ? variableTypeToString(node.returnType, this.typeAliases)
+                : "any",
             functionBody: bodyCode.join("\n"),
         });
     }
@@ -220,10 +224,11 @@ export class TypeScriptGenerator extends BaseGenerator {
                 this.functionsUsed.add(arg.functionName);
                 return this.generateFunctionCallExpression(arg);
                 /*       } else if (arg.type === "accessExpression") {
-                        return this.processAccessExpression(arg);
-                      } else if (arg.type === "indexAccess") {
-                        return this.processIndexAccess(arg);
-                 */ }
+                return this.processAccessExpression(arg);
+              } else if (arg.type === "indexAccess") {
+                return this.processIndexAccess(arg);
+         */
+            }
             else {
                 //        return this.generateLiteral(arg);
                 return this.processNode(arg);
@@ -252,6 +257,8 @@ export class TypeScriptGenerator extends BaseGenerator {
                 return literal.value;
             case "string":
                 return `"${escape(literal.value)}"`;
+            case "multiLineString":
+                return `\`${escape(literal.value)}\``;
             case "variableName":
                 return literal.value;
             case "prompt":

package/dist/lib/parsers/function.d.ts

@@ -1,4 +1,4 @@
-import { AgencyNode, DocString, FunctionDefinition, FunctionParameter } from "../types.js";
+import { AgencyNode, DocString, FunctionDefinition, FunctionParameter, VariableType } from "../types.js";
 import { Parser } from "tarsec";
 import { GraphNodeDefinition } from "../types/graphNode.js";
 import { WhileLoop } from "../types/whileLoop.js";
@@ -7,5 +7,6 @@ export declare const bodyParser: Parser<AgencyNode[]>;
 export declare const whileLoopParser: Parser<WhileLoop>;
 export declare const functionParameterParserWithTypeHint: Parser<FunctionParameter>;
 export declare const functionParameterParser: Parser<FunctionParameter>;
+export declare const functionReturnTypeParser: Parser<VariableType>;
 export declare const functionParser: Parser<FunctionDefinition>;
 export declare const graphNodeParser: Parser<GraphNodeDefinition>;

package/dist/lib/parsers/function.js

@@ -1,4 +1,4 @@
-import { capture, char, debug, many1, many1Till, many1WithJoin, map, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
+import { capture, captureCaptures, char, debug, many1, many1Till, many1WithJoin, map, optional, or, sepBy, seqC, set, space, spaces, str, succeed, trace, } from "tarsec";
 import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { assignmentParser } from "./assignment.js";
 import { commentParser } from "./comment.js";
@@ -21,5 +21,6 @@ export const bodyParser = trace("functionBodyParser", (input) => {
 export const whileLoopParser = trace("whileLoopParser", seqC(set("type", "whileLoop"), str("while"), optionalSpaces, char("("), optionalSpaces, capture(or(indexAccessParser, functionCallParser, accessExpressionParser, literalParser), "condition"), optionalSpaces, char(")"), optionalSpaces, char("{"), spaces, capture(bodyParser, "body"), optionalSpaces, char("}")));
 export const functionParameterParserWithTypeHint = trace("functionParameterParserWithTypeHint", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "typeHint")));
 export const functionParameterParser = trace("functionParameterParser", seqC(set("type", "functionParameter"), capture(many1WithJoin(varNameChar), "name")));
-export const functionParser = trace("functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, char("{"), optionalSpaces, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
-export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(or(sepBy(comma, many1WithJoin(varNameChar)), succeed([])), "parameters"), optionalSpaces, char(")"), optionalSpaces, char("{"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+export const functionReturnTypeParser = trace("functionReturnTypeParser", seqC(char(":"), optionalSpaces, captureCaptures(variableTypeParser)));
+export const functionParser = trace("functionParser", seqC(set("type", "function"), str("def"), many1(space), capture(many1Till(char("(")), "functionName"), char("("), optionalSpaces, capture(sepBy(comma, or(functionParameterParserWithTypeHint, functionParameterParser)), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpaces, capture(or(docStringParser, succeed(undefined)), "docString"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));
+export const graphNodeParser = trace("graphNodeParser", seqC(set("type", "graphNode"), str("node"), many1(space), capture(many1Till(char("(")), "nodeName"), char("("), optionalSpaces, capture(or(sepBy(comma, many1WithJoin(varNameChar)), succeed([])), "parameters"), optionalSpaces, char(")"), optionalSpaces, capture(optional(functionReturnTypeParser), "returnType"), optionalSpaces, char("{"), optionalSpaces, capture(bodyParser, "body"), optionalSpaces, char("}"), optionalSemicolon));