agency-lang 0.0.15 → 0.0.16

package/dist/lib/backends/agencyGenerator.js

@@ -100,12 +100,28 @@ export class AgencyGenerator extends BaseGenerator {
     processFunctionDefinition(node) {
         const { functionName, body, parameters } = node;
         // Build parameter list
-        const params = parameters.join(", ");
+        const params = parameters
+            .map((p) => {
+            if (p.typeHint) {
+                const typeStr = variableTypeToString(p.typeHint, this.typeAliases);
+                return `${p.name}: ${typeStr}`;
+            }
+            else {
+                return p.name;
+            }
+        })
+            .join(", ");
         // Start function definition
         let result = this.indentStr(`def ${functionName}(${params}) {\n`);
         // Process body with increased indentation
         this.increaseIndent();
-        this.functionScopedVariables = [...parameters];
+        if (node.docString) {
+            const docLines = [`"""`, node.docString.value, `"""`]
+                .map((line) => this.indentStr(line))
+                .join("\n");
+            result += `${docLines}\n`;
+        }
+        this.functionScopedVariables = [...parameters.map((p) => p.name)];
         const lines = [];
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
@@ -154,7 +170,8 @@ export class AgencyGenerator extends BaseGenerator {
         }
     }
     processDotProperty(node) {
-        const objectCode = this.processNode(node.object).trim();
+        let objectCode = this.processNode(node.object);
+        objectCode = objectCode.trim();
         return `${objectCode}.${node.propertyName}`;
     }
     processIndexAccess(node) {

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,205 @@
+import { describe, it, expect } from "vitest";
+import { AgencyGenerator } from "./agencyGenerator.js";
+import { parseAgency } from "../parser.js";
+describe("AgencyGenerator - Function Parameter Type Hints", () => {
+    describe("processFunctionDefinition", () => {
+        const testCases = [
+            {
+                description: "single parameter with type hint",
+                input: "def add(x: number) { x }",
+                expectedOutput: "def add(x: number) {\nx\n}",
+            },
+            {
+                description: "multiple parameters with type hints",
+                input: "def add(x: number, y: number) { x }",
+                expectedOutput: "def add(x: number, y: number) {\nx\n}",
+            },
+            {
+                description: "mixed typed and untyped parameters",
+                input: "def mixed(x: number, y) { x }",
+                expectedOutput: "def mixed(x: number, y) {\nx\n}",
+            },
+            {
+                description: "array type hint",
+                input: "def process(items: number[]) { items }",
+                expectedOutput: "def process(items: number[]) {\nitems\n}",
+            },
+            {
+                description: "union type hint",
+                input: "def flexible(value: string | number) { value }",
+                expectedOutput: "def flexible(value: string | number) {\nvalue\n}",
+            },
+            {
+                description: "type hint with docstring",
+                input: 'def add(x: number, y: number) {\n  """Adds two numbers"""\n  x\n}',
+                expectedOutput: 'def add(x: number, y: number) {\n  """\n  Adds two numbers\n  """\nx\n}',
+            },
+            {
+                description: "multiple array types",
+                input: "def multi(arr: string[], count: number) { arr }",
+                expectedOutput: "def multi(arr: string[], count: number) {\narr\n}",
+            },
+            {
+                description: "nested array type",
+                input: "def nested(matrix: number[][]) { matrix }",
+                expectedOutput: "def nested(matrix: number[][]) {\nmatrix\n}",
+            },
+            {
+                description: "custom type name",
+                input: "def handle(data: CustomType) { data }",
+                expectedOutput: "def handle(data: CustomType) {\ndata\n}",
+            },
+            {
+                description: "untyped parameters (backward compatibility)",
+                input: "def old(x, y) { x }",
+                expectedOutput: "def old(x, y) {\nx\n}",
+            },
+        ];
+        testCases.forEach(({ description, input, expectedOutput }) => {
+            it(`should correctly generate ${description}`, () => {
+                const parseResult = parseAgency(input);
+                expect(parseResult.success).toBe(true);
+                if (!parseResult.success)
+                    return;
+                const generator = new AgencyGenerator();
+                const result = generator.generate(parseResult.result);
+                // Normalize whitespace for comparison
+                const normalizedOutput = result.output.trim();
+                const normalizedExpected = expectedOutput.trim();
+                expect(normalizedOutput).toBe(normalizedExpected);
+            });
+        });
+    });
+    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 }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("n: number");
+            expect(result.output).toContain("s: string");
+            expect(result.output).toContain("b: boolean");
+        });
+        it("should preserve array types", () => {
+            const input = "def test(nums: number[], strs: string[]) { nums }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("nums: number[]");
+            expect(result.output).toContain("strs: string[]");
+        });
+        it("should preserve union types", () => {
+            const input = "def test(val: string | number | boolean) { val }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("val: string | number | boolean");
+        });
+        it("should preserve nested array types", () => {
+            const input = "def test(matrix: number[][]) { matrix }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("matrix: number[][]");
+        });
+    });
+    describe("Mixed typed and untyped parameters", () => {
+        it("should handle first parameter typed, second untyped", () => {
+            const input = "def test(x: number, y) { x }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("x: number");
+            expect(result.output).toContain(", y)");
+            expect(result.output).not.toContain("y:");
+        });
+        it("should handle first parameter untyped, second typed", () => {
+            const input = "def test(x, y: string) { x }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("y: string");
+            expect(result.output).toMatch(/test\(x,/);
+            expect(result.output).not.toContain("x:");
+        });
+        it("should handle alternating typed and untyped parameters", () => {
+            const input = "def test(a, b: number, c, d: string) { a }";
+            const parseResult = parseAgency(input);
+            expect(parseResult.success).toBe(true);
+            if (!parseResult.success)
+                return;
+            const generator = new AgencyGenerator();
+            const result = generator.generate(parseResult.result);
+            expect(result.output).toContain("b: number");
+            expect(result.output).toContain("d: string");
+            expect(result.output).not.toContain("a:");
+            expect(result.output).not.toContain("c:");
+        });
+    });
+});

package/dist/lib/backends/baseGenerator.js

@@ -69,7 +69,7 @@ export class BaseGenerator {
         return "";
     }
     collectFunctionSignature(node) {
-        this.functionSignatures[node.functionName] = node.parameters;
+        this.functionSignatures[node.functionName] = node.parameters.map((param) => param.name);
     }
     processGraphNodeName(node) { }
     processNode(node) {
@@ -113,6 +113,8 @@ export class BaseGenerator {
                 return this.processWhileLoop(node);
             case "specialVar":
                 return this.processSpecialVar(node);
+            case "indexAccess":
+                return this.processIndexAccess(node);
             default:
                 throw new Error(`Unhandled Agency node type: ${node.type}`);
         }

package/dist/lib/backends/graphGenerator.js

@@ -257,12 +257,14 @@ export class GraphGenerator extends TypeScriptGenerator {
             if (arg.type === "functionCall") {
                 this.functionsUsed.add(arg.functionName);
                 return this.generateFunctionCallExpression(arg);
-            }
-            else if (arg.type === "accessExpression") {
-                return this.processAccessExpression(arg);
-            }
+                /*       } else if (arg.type === "accessExpression") {
+                        return this.processAccessExpression(arg);
+                      } else if (arg.type === "indexAccess") {
+                        return this.processIndexAccess(arg);
+                 */ }
             else {
-                return this.generateLiteral(arg);
+                return this.processNode(arg);
+                //        return this.generateLiteral(arg);
             }
         });
         const argsString = parts.join(", ");

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

@@ -1,14 +1,14 @@
 import { AgencyComment, AgencyProgram, Assignment, Literal, PromptLiteral, PromptSegment, TypeAlias, TypeHint, TypeHintMap } from "../types.js";
+import { SpecialVar } from "../types/specialVar.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
+import { ImportStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
-import { BaseGenerator } from "./baseGenerator.js";
 import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
-import { ImportStatement } from "../types/importStatement.js";
 import { WhileLoop } from "../types/whileLoop.js";
-import { SpecialVar } from "../types/specialVar.js";
+import { BaseGenerator } from "./baseGenerator.js";
 export declare class TypeScriptGenerator extends BaseGenerator {
     constructor();
     protected generateBuiltins(): string;

package/dist/lib/backends/typescriptGenerator.js

@@ -1,15 +1,15 @@
+import * as renderSpecialVar from "../templates/backends/graphGenerator/specialVar.js";
+import * as builtinTools from "../templates/backends/typescriptGenerator/builtinTools.js";
+import * as renderFunctionDefinition from "../templates/backends/typescriptGenerator/functionDefinition.js";
 import * as renderImports from "../templates/backends/typescriptGenerator/imports.js";
 import * as promptFunction from "../templates/backends/typescriptGenerator/promptFunction.js";
 import * as renderTool from "../templates/backends/typescriptGenerator/tool.js";
 import * as renderToolCall from "../templates/backends/typescriptGenerator/toolCall.js";
-import * as renderFunctionDefinition from "../templates/backends/typescriptGenerator/functionDefinition.js";
-import * as renderSpecialVar from "../templates/backends/graphGenerator/specialVar.js";
 import { escape, zip } from "../utils.js";
 import { BaseGenerator } from "./baseGenerator.js";
 import { generateBuiltinHelpers, mapFunctionName, } from "./typescriptGenerator/builtins.js";
 import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
 import { DEFAULT_SCHEMA, mapTypeToZodSchema, } from "./typescriptGenerator/typeToZodSchema.js";
-import * as builtinTools from "../templates/backends/typescriptGenerator/builtinTools.js";
 export class TypeScriptGenerator extends BaseGenerator {
     constructor() {
         super();
@@ -157,12 +157,12 @@ export class TypeScriptGenerator extends BaseGenerator {
         }
         const properties = {};
         parameters.forEach((param) => {
-            const typeHint = this.typeHints[param] || {
+            const typeHint = param.typeHint || {
                 type: "primitiveType",
                 value: "string",
             };
             const tsType = mapTypeToZodSchema(typeHint, this.typeAliases);
-            properties[param] = tsType;
+            properties[param.name] = tsType;
         });
         let schema = "";
         for (const [key, value] of Object.entries(properties)) {
@@ -183,13 +183,13 @@ export class TypeScriptGenerator extends BaseGenerator {
      */
     processFunctionDefinition(node) {
         const { functionName, body, parameters } = node;
-        this.functionScopedVariables = [...parameters];
+        this.functionScopedVariables = [...parameters.map((p) => p.name)];
         const bodyCode = [];
         for (const stmt of body) {
             bodyCode.push(this.processNode(stmt));
         }
         this.functionScopedVariables = [];
-        const args = parameters.join(", ") || "";
+        const args = parameters.map((p) => p.name).join(", ") || "";
         return renderFunctionDefinition.default({
             functionName,
             args: "{" + args + "}",
@@ -219,12 +219,14 @@ export class TypeScriptGenerator extends BaseGenerator {
             if (arg.type === "functionCall") {
                 this.functionsUsed.add(arg.functionName);
                 return this.generateFunctionCallExpression(arg);
-            }
-            else if (arg.type === "accessExpression") {
-                return this.processAccessExpression(arg);
-            }
+                /*       } else if (arg.type === "accessExpression") {
+                        return this.processAccessExpression(arg);
+                      } else if (arg.type === "indexAccess") {
+                        return this.processIndexAccess(arg);
+                 */ }
             else {
-                return this.generateLiteral(arg);
+                //        return this.generateLiteral(arg);
+                return this.processNode(arg);
             }
         });
         let argsString = "";

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

@@ -1,6 +1,4 @@
-import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
-import { Parser, ParserResult } from "tarsec";
-export declare const dotPropertyParser: (input: string) => ParserResult<DotProperty>;
+import { ParserResult } from "tarsec";
+import { AccessExpression, IndexAccess } from "../types/access.js";
+export declare function accessExpressionParser(input: string): ParserResult<AccessExpression>;
 export declare const indexAccessParser: (input: string) => ParserResult<IndexAccess>;
-export declare const dotFunctionCallParser: (input: string) => ParserResult<DotFunctionCall>;
-export declare const accessExpressionParser: Parser<AccessExpression>;

package/dist/lib/parsers/access.js

@@ -1,19 +1,60 @@
-import { capture, char, many1WithJoin, or, seqC, set, } from "tarsec";
+import { capture, char, failure, or, sepBy1, seqC, set, success, } from "tarsec";
+import { accessExpression, } from "../types/access.js";
 import { agencyArrayParser } from "./dataStructures.js";
 import { functionCallParser } from "./functionCall.js";
-import { literalParser } from "./literals.js";
-import { optionalSemicolon } from "./parserUtils.js";
-import { varNameChar } from "./utils.js";
-export const dotPropertyParser = (input) => {
-    const parser = seqC(set("type", "dotProperty"), capture(or(literalParser, functionCallParser), "object"), char("."), capture(many1WithJoin(varNameChar), "propertyName"));
-    return parser(input);
-};
+import { literalParser, variableNameParser } from "./literals.js";
+function createAccessExpression(arr) {
+    const expression = _createAccessExpression(arr);
+    return expression;
+}
+function _createAccessExpression(arr) {
+    if (arr.length < 1) {
+        throw new Error(`Not enough items to create access expression: ${JSON.stringify(arr)}`);
+    }
+    if (arr.length === 1) {
+        return arr[0];
+    }
+    if (arr.length > 1) {
+        const head = arr.slice(0, -1);
+        const last = arr.at(-1);
+        switch (last?.type) {
+            case "variableName":
+                return accessExpression({
+                    type: "dotProperty",
+                    object: _createAccessExpression(head),
+                    propertyName: last.value,
+                });
+            case "functionCall":
+                return accessExpression({
+                    type: "dotFunctionCall",
+                    object: _createAccessExpression(head),
+                    functionCall: last,
+                });
+            case "indexAccess":
+                return accessExpression({
+                    type: "indexAccess",
+                    array: _createAccessExpression([...head, last.array]),
+                    index: last.index,
+                });
+            default:
+                throw new Error(`unknown type ${last && last.type} in createAccessExpression`);
+        }
+    }
+    throw new Error(`we should NEVER get here: ${JSON.stringify(arr)} `);
+}
+export function accessExpressionParser(input) {
+    const parser = sepBy1(char("."), or(indexAccessParser, functionCallParser, variableNameParser));
+    const result = parser(input);
+    if (result.success === false) {
+        return result;
+    }
+    if (result.result.length < 2) {
+        return failure("Didn't find property access or function call", input);
+    }
+    const access = createAccessExpression(result.result);
+    return success(access, result.rest);
+}
 export const indexAccessParser = (input) => {
     const parser = seqC(set("type", "indexAccess"), capture(or(agencyArrayParser, functionCallParser, literalParser), "array"), char("["), capture(or(functionCallParser, literalParser), "index"), char("]"));
     return parser(input);
 };
-export const dotFunctionCallParser = (input) => {
-    const parser = seqC(set("type", "dotFunctionCall"), capture(or(functionCallParser, literalParser), "object"), char("."), capture(functionCallParser, "functionCall"));
-    return parser(input);
-};
-export const accessExpressionParser = seqC(set("type", "accessExpression"), capture(or(dotFunctionCallParser, dotPropertyParser, indexAccessParser), "expression"), optionalSemicolon);