agency-lang 0.0.21 → 0.0.23

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

@@ -1,5 +1,5 @@
 import { SpecialVar } from "../types/specialVar.js";
-import { AgencyComment, AgencyProgram, Assignment, Literal, PromptLiteral, TypeAlias, TypeHint, VariableType } from "../types.js";
+import { AgencyComment, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, TypeAlias, TypeHint, VariableType } from "../types.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
@@ -9,7 +9,10 @@ import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
+import { IfElse } from "../types/ifElse.js";
 import { BaseGenerator } from "./baseGenerator.js";
+import { TimeBlock } from "../types/timeBlock.js";
+import { AwaitStatement } from "../types/await.js";
 export declare class AgencyGenerator extends BaseGenerator {
     private indentLevel;
     private indentSize;
@@ -25,9 +28,11 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processTypeAlias(node: TypeAlias): string;
     protected processTypeHint(node: TypeHint): string;
     protected processAssignment(node: Assignment): string;
+    protected processTimeBlock(node: TimeBlock): string;
     protected generateLiteral(literal: Literal): string;
     private generatePromptLiteral;
-    protected processPromptLiteral(variableName: string, node: PromptLiteral): string;
+    private generateStringLiteral;
+    protected processPromptLiteral(variableName: string, variableType: VariableType | undefined, node: PromptLiteral): string;
     protected processFunctionDefinition(node: FunctionDefinition): string;
     protected processFunctionCall(node: FunctionCall): string;
     protected generateFunctionCallExpression(node: FunctionCall): string;
@@ -39,6 +44,7 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processDotFunctionCall(node: DotFunctionCall): string;
     protected processMatchBlock(node: MatchBlock): string;
     protected processWhileLoop(node: WhileLoop): string;
+    protected processIfElse(node: IfElse): string;
     protected processReturnStatement(node: ReturnStatement): string;
     protected processComment(node: AgencyComment): string;
     protected processImportStatement(node: ImportStatement): string;
@@ -47,5 +53,7 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processUsesTool(node: UsesTool): string;
     protected processSpecialVar(node: SpecialVar): string;
     private indentStr;
+    protected processAwaitStatement(node: AwaitStatement): string;
+    protected processNewLine(_node: NewLine): string;
 }
 export declare function generateAgency(program: AgencyProgram): string;

package/dist/lib/backends/agencyGenerator.js

@@ -48,26 +48,41 @@ export class AgencyGenerator extends BaseGenerator {
     processTypeAlias(node) {
         this.typeAliases[node.aliasName] = node.aliasedType;
         const aliasedTypeStr = this.aliasedTypeToString(node.aliasedType);
-        return this.indentStr(`type ${node.aliasName} = ${aliasedTypeStr}\n`);
+        return this.indentStr(`type ${node.aliasName} = ${aliasedTypeStr}`);
     }
     processTypeHint(node) {
         this.typeHints[node.variableName] = node.variableType;
         const typeStr = variableTypeToString(node.variableType, this.typeAliases);
-        return this.indentStr(`${node.variableName} :: ${typeStr}\n`);
+        return this.indentStr(`${node.variableName} :: ${typeStr}`);
     }
     // Assignment and literals
     processAssignment(node) {
-        const valueCode = this.processNode(node.value).trim();
-        return this.indentStr(`${node.variableName} = ${valueCode}\n`);
+        const varName = node.typeHint
+            ? `${node.variableName}: ${variableTypeToString(node.typeHint, this.typeAliases)}`
+            : node.variableName;
+        if (node.value.type === "timeBlock") {
+            const code = this.processTimeBlock(node.value);
+            return this.indentStr(`${varName} = ${code.trim()}\n`);
+        }
+        let valueCode = this.processNode(node.value).trim();
+        return this.indentStr(`${varName} = ${valueCode}`);
+    }
+    processTimeBlock(node) {
+        this.increaseIndent();
+        const bodyCodes = [];
+        for (const stmt of node.body) {
+            bodyCodes.push(this.processNode(stmt));
+        }
+        this.decreaseIndent();
+        const bodyCodeStr = bodyCodes.join("");
+        return `time {\n${bodyCodeStr}${this.indentStr("}")}\n`;
     }
     generateLiteral(literal) {
         switch (literal.type) {
             case "number":
                 return literal.value;
             case "string":
-                // Escape backslashes and quotes
-                const escaped = literal.value;
-                return `"${escaped}"`;
+                return this.generateStringLiteral(literal);
             case "variableName":
                 return literal.value;
             case "multiLineString":
@@ -92,7 +107,20 @@ export class AgencyGenerator extends BaseGenerator {
         result += "`";
         return result;
     }
-    processPromptLiteral(variableName, node) {
+    generateStringLiteral(node) {
+        let result = '"';
+        for (const segment of node.segments) {
+            if (segment.type === "text") {
+                result += segment.value;
+            }
+            else if (segment.type === "interpolation") {
+                result += `\${${segment.variableName}}`;
+            }
+        }
+        result += '"';
+        return result;
+    }
+    processPromptLiteral(variableName, variableType, node) {
         // For agency code, prompts are just part of assignments
         // This shouldn't be called directly, but return empty string
         return "";
@@ -135,12 +163,12 @@ export class AgencyGenerator extends BaseGenerator {
         this.functionScopedVariables = [];
         this.decreaseIndent();
         // Close function
-        result += this.indentStr(`}\n\n`);
+        result += this.indentStr(`}`);
         return result;
     }
     processFunctionCall(node) {
         const expr = this.generateFunctionCallExpression(node);
-        return this.indentStr(`${expr}\n`);
+        return this.indentStr(`${expr}`);
     }
     generateFunctionCallExpression(node) {
         const args = node.arguments.map((arg) => {
@@ -160,7 +188,10 @@ export class AgencyGenerator extends BaseGenerator {
             const valueCode = this.processNode(entry.value).trim();
             return `${entry.key}: ${valueCode}`;
         });
-        return `{${entries.join(", ")}}`;
+        if (entries.length === 0) {
+            return `{}`;
+        }
+        return `{ ${entries.join(", ")} }`;
     }
     // Access expressions
     processAccessExpression(node) {
@@ -176,17 +207,17 @@ export class AgencyGenerator extends BaseGenerator {
     processDotProperty(node) {
         let objectCode = this.processNode(node.object);
         objectCode = objectCode.trim();
-        return `${objectCode}.${node.propertyName}`;
+        return this.indentStr(`${objectCode}.${node.propertyName}`);
     }
     processIndexAccess(node) {
         const arrayCode = this.processNode(node.array).trim();
         const indexCode = this.processNode(node.index).trim();
-        return `${arrayCode}[${indexCode}]`;
+        return this.indentStr(`${arrayCode}[${indexCode}]`);
     }
     processDotFunctionCall(node) {
         const objectCode = this.processNode(node.object).trim();
         const functionCallCode = this.generateFunctionCallExpression(node.functionCall);
-        return `${objectCode}.${functionCallCode}`;
+        return this.indentStr(`${objectCode}.${functionCallCode}`);
     }
     // Control flow
     processMatchBlock(node) {
@@ -222,27 +253,56 @@ export class AgencyGenerator extends BaseGenerator {
         result += this.indentStr(`}\n`);
         return result;
     }
+    processIfElse(node) {
+        const conditionCode = this.processNode(node.condition).trim();
+        const lines = [];
+        lines.push(this.indentStr(`if (${conditionCode}) {\n`));
+        const bodyLines = [];
+        this.increaseIndent();
+        for (const stmt of node.thenBody) {
+            bodyLines.push(this.processNode(stmt));
+        }
+        this.decreaseIndent();
+        lines.push(bodyLines.join("").trimEnd() + "\n");
+        const elseBodyLines = [];
+        if (node.elseBody && node.elseBody.length > 0) {
+            lines.push(this.indentStr(`} else {\n`));
+            this.increaseIndent();
+            for (const stmt of node.elseBody) {
+                elseBodyLines.push(this.processNode(stmt));
+            }
+            this.decreaseIndent();
+            lines.push(elseBodyLines.join("").trimEnd() + "\n");
+        }
+        lines.push(this.indentStr(`}\n\n`));
+        return lines.join("");
+    }
     processReturnStatement(node) {
         const valueCode = this.processNode(node.value).trim();
         return this.indentStr(`return ${valueCode}\n`);
     }
     // Utility methods
     processComment(node) {
-        return this.indentStr(`//${node.content}\n`);
+        return this.indentStr(`//${node.content}`);
     }
     processImportStatement(node) {
-        return this.indentStr(`import ${node.importedNames}from ${node.modulePath}`);
+        const str = this.indentStr(`import ${node.importedNames}from ${node.modulePath}`);
+        return str;
     }
     processGraphNode(node) {
         // Graph nodes use similar syntax to functions
         const { nodeName, body, parameters } = node;
-        const params = parameters.join(", ");
+        const params = parameters
+            .map((p) => p.typeHint
+            ? `${p.name}: ${variableTypeToString(p.typeHint, this.typeAliases)}`
+            : p.name)
+            .join(", ");
         const returnTypeStr = node.returnType
             ? ": " + variableTypeToString(node.returnType, this.typeAliases)
             : "";
         let result = this.indentStr(`node ${nodeName}(${params})${returnTypeStr} {\n`);
         this.increaseIndent();
-        this.functionScopedVariables = [...parameters];
+        this.functionScopedVariables = parameters.map((p) => p.name);
         const lines = [];
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
@@ -251,7 +311,7 @@ export class AgencyGenerator extends BaseGenerator {
         result += bodyCode;
         this.functionScopedVariables = [];
         this.decreaseIndent();
-        result += this.indentStr(`}\n\n`);
+        result += this.indentStr(`}`);
         return result;
     }
     processTool(node) {
@@ -262,7 +322,7 @@ export class AgencyGenerator extends BaseGenerator {
     processUsesTool(node) {
         // Track tool usage but don't generate code
         this.toolsUsed.push(node.toolName);
-        return this.indentStr(`+${node.toolName}\n`);
+        return this.indentStr(`+${node.toolName}`);
     }
     processSpecialVar(node) {
         return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}\n`);
@@ -270,6 +330,13 @@ export class AgencyGenerator extends BaseGenerator {
     indentStr(str) {
         return `${this.indent()}${str}`;
     }
+    processAwaitStatement(node) {
+        const code = this.processNode(node.expression);
+        return this.indentStr(`await ${code.trim()}`);
+    }
+    processNewLine(_node) {
+        return "\n";
+    }
 }
 export function generateAgency(program) {
     const generator = new AgencyGenerator();

package/dist/lib/backends/agencyGenerator.test.js

@@ -70,54 +70,6 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
             });
         });
     });
-    describe("Round-trip parsing", () => {
-        const testCases = [
-            {
-                description: "function with typed parameters",
-                input: "def add(x: number, y: number) { x }",
-            },
-            {
-                description: "function with mixed parameters",
-                input: "def mixed(a: string, b) { a }",
-            },
-            {
-                description: "function with array type",
-                input: "def process(items: number[]) { items }",
-            },
-            {
-                description: "function with union type",
-                input: "def flex(val: string | number) { val }",
-            },
-            {
-                description: "function with complex types",
-                input: "def complex(arr: string[], count: number, flag: boolean) { arr }",
-            },
-        ];
-        testCases.forEach(({ description, input }) => {
-            it(`should preserve ${description} in round-trip`, () => {
-                // First parse
-                const firstParse = parseAgency(input);
-                expect(firstParse.success).toBe(true);
-                if (!firstParse.success)
-                    return;
-                // Generate agency code
-                const generator = new AgencyGenerator();
-                const generated = generator.generate(firstParse.result);
-                // Second parse
-                const secondParse = parseAgency(generated.output);
-                expect(secondParse.success).toBe(true);
-                if (!secondParse.success)
-                    return;
-                // Compare the function nodes - they should be identical
-                const firstFunc = firstParse.result.nodes[0];
-                const secondFunc = secondParse.result.nodes[0];
-                expect(secondFunc.type).toBe("function");
-                expect(secondFunc.functionName).toBe(firstFunc.functionName);
-                expect(secondFunc.parameters).toEqual(firstFunc.parameters);
-                expect(secondFunc.body).toEqual(firstFunc.body);
-            });
-        });
-    });
     describe("Type preservation", () => {
         it("should preserve primitive types", () => {
             const input = "def test(n: number, s: string, b: boolean) { n }";

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

@@ -1,5 +1,5 @@
 import { SpecialVar } from "../types/specialVar.js";
-import { AgencyComment, AgencyNode, AgencyProgram, Assignment, Literal, PromptLiteral, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
+import { AgencyComment, AgencyNode, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
@@ -9,6 +9,9 @@ import { MatchBlock } from "../types/matchBlock.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { WhileLoop } from "../types/whileLoop.js";
+import { IfElse } from "../types/ifElse.js";
+import { TimeBlock } from "../types/timeBlock.js";
+import { AwaitStatement } from "../types/await.js";
 export declare class BaseGenerator {
     protected typeHints: TypeHintMap;
     protected graphNodes: GraphNodeDefinition[];
@@ -20,19 +23,23 @@ export declare class BaseGenerator {
     protected typeAliases: Record<string, VariableType>;
     protected functionsUsed: Set<string>;
     protected importStatements: string[];
-    protected functionSignatures: Record<string, string[]>;
-    constructor();
+    protected functionDefinitions: Record<string, FunctionDefinition>;
     generate(program: AgencyProgram): {
         output: string;
     };
+    addIfNonEmpty(str: string, lines: string[]): void;
     protected generateBuiltins(): string;
     protected processTypeAlias(node: TypeAlias): string;
     protected processTypeHint(node: TypeHint): string;
     protected collectFunctionSignature(node: FunctionDefinition): void;
     protected processGraphNodeName(node: GraphNodeDefinition): void;
     protected processNode(node: AgencyNode): string;
+    protected processNewLine(_node: NewLine): string;
+    protected processAwaitStatement(node: AwaitStatement): string;
+    protected processTimeBlock(node: TimeBlock, timingVarName: string): string;
     protected processSpecialVar(node: SpecialVar): string;
     protected processWhileLoop(node: WhileLoop): string;
+    protected processIfElse(node: IfElse): string;
     protected processImportStatement(node: ImportStatement): string;
     protected processTool(node: FunctionDefinition): string;
     protected processUsesTool(node: UsesTool): string;
@@ -47,7 +54,7 @@ export declare class BaseGenerator {
     protected processDotFunctionCall(node: DotFunctionCall): string;
     protected processIndexAccess(node: IndexAccess): string;
     protected processAssignment(node: Assignment): string;
-    protected processPromptLiteral(variableName: string, node: PromptLiteral): string;
+    protected processPromptLiteral(variableName: string, typeHint: VariableType | undefined, node: PromptLiteral): string;
     protected processFunctionDefinition(node: FunctionDefinition): string;
     protected processFunctionCall(node: FunctionCall): string;
     protected generateFunctionCallExpression(node: FunctionCall): string;

package/dist/lib/backends/baseGenerator.js

@@ -12,8 +12,8 @@ export class BaseGenerator {
     functionsUsed = new Set();
     importStatements = [];
     // collect function signatures so we can implement named args
-    functionSignatures = {};
-    constructor() { }
+    // TODO also save return types, check if used as a tool, return type cannot be null/void/undefined
+    functionDefinitions = {};
     generate(program) {
         // Pass 1: Collect all type aliases
         for (const node of program.nodes) {
@@ -52,18 +52,22 @@ export class BaseGenerator {
             this.generatedStatements.push(result);
         }
         const output = [];
-        output.push(this.preprocess() + "\n");
-        output.push(this.importStatements.join("\n") + "\n");
-        output.push(this.generateImports() + "\n");
-        output.push(this.generateBuiltins() + "\n");
-        output.push("\n");
+        this.addIfNonEmpty(this.preprocess(), output);
+        this.addIfNonEmpty(this.importStatements.join("\n"), output);
+        this.addIfNonEmpty(this.generateImports(), output);
+        this.addIfNonEmpty(this.generateBuiltins(), output);
         output.push(...this.generatedTypeAliases);
         output.push(this.generatedStatements.join(""));
-        output.push(this.postprocess() + "\n");
+        this.addIfNonEmpty(this.postprocess(), output);
         return {
-            output: output.filter((line) => line.trim() !== "").join("\n"),
+            output: output.join("\n"), //filter((line) => line.trim() !== "").join("\n"),
         };
     }
+    addIfNonEmpty(str, lines) {
+        if (str.trim() !== "") {
+            lines.push(str);
+        }
+    }
     generateBuiltins() {
         return "";
     }
@@ -76,7 +80,7 @@ export class BaseGenerator {
         return "";
     }
     collectFunctionSignature(node) {
-        this.functionSignatures[node.functionName] = node.parameters.map((param) => param.name);
+        this.functionDefinitions[node.functionName] = node;
     }
     processGraphNodeName(node) { }
     processNode(node) {
@@ -119,20 +123,40 @@ export class BaseGenerator {
                 return "";
             case "whileLoop":
                 return this.processWhileLoop(node);
+            case "ifElse":
+                return this.processIfElse(node);
             case "specialVar":
                 return this.processSpecialVar(node);
             case "indexAccess":
                 return this.processIndexAccess(node);
+            case "timeBlock":
+                throw new Error(`Time block needs to be assigned to a variable: ${JSON.stringify(node)}`);
+            case "awaitStatement":
+                return this.processAwaitStatement(node);
+            case "newLine":
+                return this.processNewLine(node);
             default:
                 throw new Error(`Unhandled Agency node type: ${node.type}`);
         }
     }
+    processNewLine(_node) {
+        return "";
+    }
+    processAwaitStatement(node) {
+        return "processAwaitStatement not implemented";
+    }
+    processTimeBlock(node, timingVarName) {
+        return "processTimeBlock not implemented";
+    }
     processSpecialVar(node) {
         return "processSpecialVar not implemented";
     }
     processWhileLoop(node) {
         return "processWhileLoop not implemented";
     }
+    processIfElse(node) {
+        return "processIfElse not implemented";
+    }
     processImportStatement(node) {
         return "processImportStatement not implemented";
     }
@@ -182,7 +206,7 @@ export class BaseGenerator {
     processAssignment(node) {
         return "processAssignment not implemented";
     }
-    processPromptLiteral(variableName, node) {
+    processPromptLiteral(variableName, typeHint, node) {
         return "processPromptLiteral not implemented";
     }
     processFunctionDefinition(node) {