agency-lang 0.0.17 → 0.0.19

package/dist/lib/backends/agencyGenerator.js

@@ -112,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) {
@@ -234,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 = [];
@@ -245,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,7 +11,7 @@ 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[];

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/typeToZodSchema.js

@@ -4,6 +4,10 @@ export const DEFAULT_SCHEMA = "z.string()";
  * Maps Agency types to Zod schema strings
  */
 export function mapTypeToZodSchema(variableType, typeAliases) {
+    console.log({ variableType, typeAliases });
+    if (!variableType) {
+        throw new Error("Variable type is undefined");
+    }
     if (variableType.type === "primitiveType") {
         switch (variableType.value.toLowerCase()) {
             case "number":

package/dist/lib/backends/typescriptGenerator.js

@@ -153,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 = {};
@@ -162,6 +162,7 @@ export class TypeScriptGenerator extends BaseGenerator {
                 type: "primitiveType",
                 value: "string",
             };
+            console.log({ typeHint, typeAliases: this.typeAliases });
             const tsType = mapTypeToZodSchema(typeHint, this.typeAliases);
             properties[param.name] = tsType;
         });
@@ -194,6 +195,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"),
         });
     }
@@ -303,6 +307,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             type: "primitiveType",
             value: "string",
         };
+        console.log(">>>", { variableType });
         const zodSchema = mapTypeToZodSchema(variableType, this.typeAliases);
         //console.log("Generated Zod schema for variable", variableName, "Variable type:", variableType, ":", zodSchema, "aliases:", this.typeAliases, "hints:", this.typeHints);
         const typeString = variableTypeToString(variableType, this.typeAliases);

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));