agency-lang 0.0.15 → 0.0.16

package/dist/lib/parsers/returnStatement.test.js

@@ -0,0 +1,268 @@
+import { describe, it, expect } from "vitest";
+import { returnStatementParser } from "./returnStatement.js";
+describe("returnStatementParser", () => {
+    const testCases = [
+        // Happy path - returning literals
+        {
+            input: "return 42",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        {
+            input: 'return "hello"',
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "string", value: "hello" },
+                },
+            },
+        },
+        {
+            input: "return `say hello`",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "prompt",
+                        segments: [{ type: "text", value: "say hello" }],
+                    },
+                },
+            },
+        },
+        {
+            input: "return myVar",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "variableName", value: "myVar" },
+                },
+            },
+        },
+        // With optional semicolon
+        {
+            input: "return 123;",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "123" },
+                },
+            },
+        },
+        // With optional spaces
+        {
+            input: "return  42  ",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        {
+            input: "return 42",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "42" },
+                },
+            },
+        },
+        // Return function call
+        {
+            input: "return foo()",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "functionCall",
+                        functionName: "foo",
+                        arguments: [],
+                    },
+                },
+            },
+        },
+        {
+            input: "return calculate(1, 2)",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "functionCall",
+                        functionName: "calculate",
+                        arguments: [
+                            { type: "number", value: "1" },
+                            { type: "number", value: "2" },
+                        ],
+                    },
+                },
+            },
+        },
+        // Return access expression
+        {
+            input: "return obj.property",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "accessExpression",
+                        expression: {
+                            type: "dotProperty",
+                            object: { type: "variableName", value: "obj" },
+                            propertyName: "property",
+                        },
+                    },
+                },
+            },
+        },
+        // Return array
+        {
+            input: "return [1, 2, 3]",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyArray",
+                        items: [
+                            { type: "number", value: "1" },
+                            { type: "number", value: "2" },
+                            { type: "number", value: "3" },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: "return []",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyArray",
+                        items: [],
+                    },
+                },
+            },
+        },
+        // Return object
+        {
+            input: 'return { key: "value" }',
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyObject",
+                        entries: [
+                            {
+                                key: "key",
+                                value: { type: "string", value: "value" },
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+        {
+            input: "return {}",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyObject",
+                        entries: [],
+                    },
+                },
+            },
+        },
+        {
+            input: 'return { x: 1, y: 2 }',
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: {
+                        type: "agencyObject",
+                        entries: [
+                            { key: "x", value: { type: "number", value: "1" } },
+                            { key: "y", value: { type: "number", value: "2" } },
+                        ],
+                    },
+                },
+            },
+        },
+        // Negative numbers
+        {
+            input: "return -100",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "-100" },
+                },
+            },
+        },
+        // Decimal numbers
+        {
+            input: "return 3.14159",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "number", value: "3.14159" },
+                },
+            },
+        },
+        // With semicolon and spaces
+        {
+            input: "return  someValue  ;",
+            expected: {
+                success: true,
+                result: {
+                    type: "returnStatement",
+                    value: { type: "variableName", value: "someValue" },
+                },
+            },
+        },
+        // Failure cases
+        { input: "return", expected: { success: false } },
+        { input: "return;", expected: { success: false } },
+        { input: "return ", expected: { success: false } },
+        { input: "retur 5", expected: { success: false } },
+        { input: "", expected: { success: false } },
+        { input: "42", expected: { success: false } },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input}" successfully`, () => {
+                const result = returnStatementParser(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                }
+            });
+        }
+        else {
+            it(`should fail to parse "${input}"`, () => {
+                const result = returnStatementParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/lib/parsers/specialVar.test.d.ts

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

package/dist/lib/parsers/specialVar.test.js

@@ -0,0 +1,219 @@
+import { describe, it, expect } from "vitest";
+import { specialVarParser } from "./specialVar.js";
+describe("specialVar parsers", () => {
+    describe("specialVarParser", () => {
+        const testCases = [
+            // Happy path - assigning literals to special vars
+            {
+                input: '@model = "gpt-4"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "string", value: "gpt-4" },
+                    },
+                },
+            },
+            {
+                input: "@model = 42",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "number", value: "42" },
+                    },
+                },
+            },
+            {
+                input: "@model = `the best model`",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "prompt",
+                            segments: [{ type: "text", value: "the best model" }],
+                        },
+                    },
+                },
+            },
+            {
+                input: "@model = myVariable",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "variableName", value: "myVariable" },
+                    },
+                },
+            },
+            // With optional semicolon
+            {
+                input: '@model = "gpt-4";',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "string", value: "gpt-4" },
+                    },
+                },
+            },
+            {
+                input: '@model="gpt-4"',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "string", value: "gpt-4" },
+                    },
+                },
+            },
+            // Assigning arrays to special vars
+            {
+                input: "@model = []",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyArray",
+                            items: [],
+                        },
+                    },
+                },
+            },
+            {
+                input: '@model = ["gpt-4", "claude"]',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyArray",
+                            items: [
+                                { type: "string", value: "gpt-4" },
+                                { type: "string", value: "claude" },
+                            ],
+                        },
+                    },
+                },
+            },
+            // Assigning objects to special vars
+            {
+                input: "@model = {}",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyObject",
+                            entries: [],
+                        },
+                    },
+                },
+            },
+            {
+                input: '@model = { name: "gpt-4" }',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "name",
+                                    value: { type: "string", value: "gpt-4" },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+            {
+                input: '@model = { name: "gpt-4", version: 4 }',
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: {
+                            type: "agencyObject",
+                            entries: [
+                                {
+                                    key: "name",
+                                    value: { type: "string", value: "gpt-4" },
+                                },
+                                {
+                                    key: "version",
+                                    value: { type: "number", value: "4" },
+                                },
+                            ],
+                        },
+                    },
+                },
+            },
+            // Negative numbers
+            {
+                input: "@model = -100",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "number", value: "-100" },
+                    },
+                },
+            },
+            // Decimal numbers
+            {
+                input: "@model = 3.14",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "specialVar",
+                        name: "model",
+                        value: { type: "number", value: "3.14" },
+                    },
+                },
+            },
+            // Failure cases
+            { input: "@model =", expected: { success: false } },
+            { input: '@notSpecial = "value"', expected: { success: false } },
+            { input: 'model = "value"', expected: { success: false } }, // missing @
+            { input: '@Model = "value"', expected: { success: false } }, // wrong case
+            { input: '@ model = "value"', expected: { success: false } }, // space after @
+            { input: "", expected: { success: false } },
+            { input: "@", expected: { success: false } },
+            { input: "@model", expected: { success: false } },
+            { input: '@"model" = "value"', expected: { success: false } },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            if (expected.success) {
+                it(`should parse "${input}" successfully`, () => {
+                    const result = specialVarParser(input);
+                    expect(result.success).toBe(true);
+                    if (result.success) {
+                        expect(result.result).toEqual(expected.result);
+                    }
+                });
+            }
+            else {
+                it(`should fail to parse "${input}"`, () => {
+                    const result = specialVarParser(input);
+                    expect(result.success).toBe(false);
+                });
+            }
+        });
+    });
+});

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

@@ -1,22 +1,22 @@
-import { FunctionCall } from "../types.js";
+import { AgencyNode, FunctionCall } from "../types.js";
 import { Literal } from "./literals.js";
-import { AgencyArray } from "./dataStructures.js";
 export type DotProperty = {
     type: "dotProperty";
-    object: Literal | FunctionCall | AccessExpression;
+    object: AgencyNode;
     propertyName: string;
 };
 export type IndexAccess = {
     type: "indexAccess";
-    array: Literal | FunctionCall | AccessExpression | AgencyArray;
+    array: AgencyNode;
     index: Literal | FunctionCall | AccessExpression;
 };
 export type DotFunctionCall = {
     type: "dotFunctionCall";
-    object: Literal | FunctionCall | AccessExpression;
+    object: AgencyNode;
     functionCall: FunctionCall;
 };
 export type AccessExpression = {
     type: "accessExpression";
     expression: DotProperty | IndexAccess | DotFunctionCall;
 };
+export declare function accessExpression(expression: DotProperty | IndexAccess | DotFunctionCall): AccessExpression;

package/dist/lib/types/access.js

@@ -1 +1,6 @@
-export {};
+export function accessExpression(expression) {
+    return {
+        type: "accessExpression",
+        expression
+    };
+}

package/dist/lib/types/dataStructures.d.ts

@@ -1,12 +1,12 @@
-import { AccessExpression, Literal } from "../types.js";
+import { AccessExpression, IndexAccess, Literal } from "../types.js";
 import { FunctionCall } from "./function.js";
 export type AgencyArray = {
     type: "agencyArray";
-    items: (AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray | AccessExpression)[];
+    items: (IndexAccess | AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray | AccessExpression)[];
 };
 export type AgencyObjectKV = {
     key: string;
-    value: AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray | AccessExpression;
+    value: IndexAccess | AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray | AccessExpression;
 };
 export type AgencyObject = {
     type: "agencyObject";

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

@@ -1,17 +1,23 @@
-import { AgencyNode } from "../types.js";
-import { AccessExpression } from "./access.js";
+import { AgencyArray, AgencyNode, AgencyObject, VariableType } from "../types.js";
+import { AccessExpression, IndexAccess } from "./access.js";
 import { Literal } from "./literals.js";
+export type FunctionParameter = {
+    type: "functionParameter";
+    name: string;
+    typeHint?: VariableType;
+};
 export type FunctionDefinition = {
     type: "function";
     functionName: string;
-    parameters: string[];
+    parameters: FunctionParameter[];
     body: AgencyNode[];
+    returnType?: VariableType;
     docString?: DocString;
 };
 export type FunctionCall = {
     type: "functionCall";
     functionName: string;
-    arguments: (Literal | AccessExpression | FunctionCall)[];
+    arguments: (AgencyArray | AgencyObject | IndexAccess | Literal | AccessExpression | FunctionCall)[];
 };
 export type DocString = {
     type: "docString";

package/dist/lib/types/matchBlock.d.ts

@@ -1,5 +1,5 @@
 import { Assignment, AgencyComment } from "../types.js";
-import { AccessExpression } from "./access.js";
+import { AccessExpression, IndexAccess } from "./access.js";
 import { Literal } from "./literals.js";
 import { FunctionCall } from "./function.js";
 import { AgencyArray, AgencyObject } from "./dataStructures.js";
@@ -7,7 +7,7 @@ import { ReturnStatement } from "./returnStatement.js";
 export type DefaultCase = "_";
 export type MatchBlockCase = {
     type: "matchBlockCase";
-    caseValue: AccessExpression | Literal | DefaultCase;
+    caseValue: AccessExpression | Literal | DefaultCase | IndexAccess;
     body: Assignment | Literal | FunctionCall | AccessExpression | AgencyArray | AgencyObject | ReturnStatement;
 };
 export type MatchBlock = {

package/dist/lib/types/returnStatement.d.ts

@@ -1,6 +1,6 @@
-import { AccessExpression, FunctionCall, Literal } from "../types.js";
+import { AccessExpression, FunctionCall, IndexAccess, Literal } from "../types.js";
 import { AgencyArray, AgencyObject } from "./dataStructures.js";
 export type ReturnStatement = {
     type: "returnStatement";
-    value: AccessExpression | FunctionCall | Literal | AgencyObject | AgencyArray;
+    value: AccessExpression | FunctionCall | Literal | AgencyObject | AgencyArray | IndexAccess;
 };

package/dist/lib/types/whileLoop.d.ts

@@ -1,6 +1,6 @@
-import { AccessExpression, AgencyNode, FunctionCall, Literal } from "../types.js";
+import { AccessExpression, AgencyNode, FunctionCall, IndexAccess, Literal } from "../types.js";
 export type WhileLoop = {
     type: "whileLoop";
-    condition: FunctionCall | AccessExpression | Literal;
+    condition: IndexAccess | FunctionCall | AccessExpression | Literal;
     body: AgencyNode[];
 };

package/dist/lib/types.d.ts

@@ -1,7 +1,7 @@
 import { Literal } from "./types/literals.js";
 import { TypeAlias, TypeHint, VariableType } from "./types/typeHints.js";
 import { MatchBlock } from "./types/matchBlock.js";
-import { AccessExpression } from "./types/access.js";
+import { AccessExpression, DotProperty, IndexAccess } from "./types/access.js";
 import { FunctionCall, FunctionDefinition } from "./types/function.js";
 import { AgencyArray, AgencyObject } from "./types/dataStructures.js";
 import { GraphNodeDefinition } from "./types/graphNode.js";
@@ -24,13 +24,13 @@ export * from "./types/whileLoop.js";
 export type Assignment = {
     type: "assignment";
     variableName: string;
-    value: AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray;
+    value: AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray | IndexAccess;
 };
 export type AgencyComment = {
     type: "comment";
     content: string;
 };
-export type AgencyNode = TypeHint | TypeAlias | UsesTool | GraphNodeDefinition | FunctionDefinition | Assignment | Literal | FunctionCall | MatchBlock | ReturnStatement | AccessExpression | AgencyComment | AgencyObject | AgencyArray | ImportStatement | WhileLoop | SpecialVar;
+export type AgencyNode = TypeHint | TypeAlias | UsesTool | GraphNodeDefinition | FunctionDefinition | Assignment | Literal | FunctionCall | MatchBlock | ReturnStatement | AccessExpression | AgencyComment | AgencyObject | AgencyArray | ImportStatement | WhileLoop | SpecialVar | IndexAccess | DotProperty;
 export type AgencyProgram = {
     type: "agencyProgram";
     nodes: AgencyNode[];

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "agency-lang",
-  "version": "0.0.15",
+  "version": "0.0.16",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
     "test": "vitest",
     "test:run": "vitest run",
     "build": "rm -rf dist/ && tsc && tsc-alias",
-    "start": "node dist/lib/index.js",
+    "start": "node dist/index.js",
     "templates": "typestache ./lib/templates",
     "typecheck": "tsc --noEmit",
     "agency": "node ./dist/scripts/agency.js",
@@ -55,4 +55,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   }
-}
+}