agency-lang 0.0.15 → 0.0.17

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

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { optionalSemicolon } from "./parserUtils.js";
+describe("parserUtils", () => {
+    describe("optionalSemicolon", () => {
+        const testCases = [
+            // Happy path - semicolon present
+            {
+                input: ";",
+                expected: { success: true, result: ";" },
+            },
+            {
+                input: ";rest",
+                expected: { success: true, result: ";", rest: "rest" },
+            },
+            // Happy path - no semicolon (optional means success even without match)
+            {
+                input: "",
+                expected: { success: true, result: null },
+            },
+            {
+                input: "other",
+                expected: { success: true, result: null, rest: "other" },
+            },
+            {
+                input: " ;",
+                expected: { success: true, result: null, rest: " ;" },
+            },
+            {
+                input: ";;",
+                expected: { success: true, result: ";", rest: ";" },
+            },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            it(`should parse "${input}" successfully`, () => {
+                const result = optionalSemicolon(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                    if (expected.rest !== undefined) {
+                        expect(result.rest).toEqual(expected.rest);
+                    }
+                }
+            });
+        });
+    });
+});

package/dist/lib/parsers/returnStatement.js

@@ -1,8 +1,8 @@
 import { seqC, set, str, capture, or } from "tarsec";
-import { accessExpressionParser } from "./access.js";
+import { accessExpressionParser, indexAccessParser } from "./access.js";
 import { functionCallParser } from "./functionCall.js";
 import { optionalSemicolon } from "./parserUtils.js";
 import { optionalSpaces } from "./utils.js";
 import { literalParser } from "./literals.js";
 import { agencyArrayParser, agencyObjectParser } from "./dataStructures.js";
-export const returnStatementParser = seqC(set("type", "returnStatement"), str("return"), optionalSpaces, capture(or(accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value"), optionalSemicolon);
+export const returnStatementParser = seqC(set("type", "returnStatement"), str("return"), optionalSpaces, capture(or(indexAccessParser, accessExpressionParser, functionCallParser, literalParser, agencyObjectParser, agencyArrayParser), "value"), optionalSemicolon);

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

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

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/literals.d.ts

@@ -1,4 +1,4 @@
-export type Literal = NumberLiteral | StringLiteral | VariableNameLiteral | PromptLiteral;
+export type Literal = NumberLiteral | MultiLineStringLiteral | StringLiteral | VariableNameLiteral | PromptLiteral;
 export type NumberLiteral = {
     type: "number";
     value: string;
@@ -7,6 +7,10 @@ export type StringLiteral = {
     type: "string";
     value: string;
 };
+export type MultiLineStringLiteral = {
+    type: "multiLineString";
+    value: string;
+};
 export type VariableNameLiteral = {
     type: "variableName";
     value: string;

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