agency-lang 0.0.16 → 0.0.18

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

@@ -1,9 +1,10 @@
-import { InterpolationSegment, Literal, NumberLiteral, PromptLiteral, StringLiteral, TextSegment, VariableNameLiteral } from "../types.js";
+import { InterpolationSegment, Literal, MultiLineStringLiteral, NumberLiteral, PromptLiteral, StringLiteral, TextSegment, VariableNameLiteral } from "../types.js";
 import { Parser } from "tarsec";
 export declare const textSegmentParser: Parser<TextSegment>;
 export declare const interpolationSegmentParser: Parser<InterpolationSegment>;
 export declare const promptParser: Parser<PromptLiteral>;
 export declare const numberParser: Parser<NumberLiteral>;
 export declare const stringParser: Parser<StringLiteral>;
+export declare const multiLineStringParser: Parser<MultiLineStringLiteral>;
 export declare const variableNameParser: Parser<VariableNameLiteral>;
 export declare const literalParser: Parser<Literal>;

package/dist/lib/parsers/literals.js

@@ -1,13 +1,14 @@
 import { backtick, varNameChar } from "./utils.js";
-import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTill, manyWithJoin, map, or, seq, seqC, set, } from "tarsec";
+import { capture, char, digit, letter, many, many1Till, many1WithJoin, manyTillOneOf, manyTillStr, manyWithJoin, map, or, seq, seqC, set, str, } from "tarsec";
 export const textSegmentParser = map(many1Till(or(backtick, char("$"))), (text) => ({
     type: "text",
     value: text,
 }));
-export const interpolationSegmentParser = seqC(set("type", "interpolation"), char("$"), char("{"), capture(many1Till(char("}")), "variableName"), char("}"));
+export const interpolationSegmentParser = seqC(set("type", "interpolation"), char("$"), char("{"), capture(manyTillStr("}"), "variableName"), char("}"));
 export const promptParser = seqC(set("type", "prompt"), backtick, capture(many(or(textSegmentParser, interpolationSegmentParser)), "segments"), backtick);
 export const numberParser = seqC(set("type", "number"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value"));
-export const stringParser = seqC(set("type", "string"), char('"'), capture(manyTill(char('"')), "value"), char('"'));
+export const stringParser = seqC(set("type", "string"), char('"'), capture(manyTillOneOf(['"', "\n"]), "value"), char('"'));
+export const multiLineStringParser = seqC(set("type", "multiLineString"), str('"""'), capture(manyTillStr('"""'), "value"), str('"""'));
 export const variableNameParser = seq([
     set("type", "variableName"),
     capture(letter, "init"),
@@ -18,4 +19,4 @@ export const variableNameParser = seq([
         value: `${captures.init}${captures.value}`,
     };
 });
-export const literalParser = or(promptParser, numberParser, stringParser, variableNameParser);
+export const literalParser = or(promptParser, numberParser, multiLineStringParser, stringParser, variableNameParser);

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { textSegmentParser, interpolationSegmentParser, promptParser, numberParser, stringParser, variableNameParser, literalParser, } from "./literals.js";
+import { textSegmentParser, interpolationSegmentParser, promptParser, numberParser, stringParser, multiLineStringParser, variableNameParser, literalParser, } from "./literals.js";
 describe("literals parsers", () => {
     describe("textSegmentParser", () => {
         const testCases = [
@@ -112,7 +112,16 @@ describe("literals parsers", () => {
             { input: "${foo", expected: { success: false } },
             { input: "$foo}", expected: { success: false } },
             { input: "{foo}", expected: { success: false } },
-            { input: "${}", expected: { success: false } },
+            {
+                input: "${}",
+                expected: {
+                    success: true,
+                    result: {
+                        type: "interpolation",
+                        variableName: "",
+                    },
+                },
+            },
             { input: "", expected: { success: false } },
             { input: "foo", expected: { success: false } },
         ];
@@ -391,13 +400,6 @@ describe("literals parsers", () => {
                     result: { type: "string", value: "tab\there" },
                 },
             },
-            {
-                input: '"newline\nhere"',
-                expected: {
-                    success: true,
-                    result: { type: "string", value: "newline\nhere" },
-                },
-            },
             {
                 input: '"special!@#$%^&*()"',
                 expected: {
@@ -425,6 +427,13 @@ describe("literals parsers", () => {
             { input: "'hello'", expected: { success: false } },
             { input: "", expected: { success: false } },
             { input: "hello", expected: { success: false } },
+            /// use """ for multi-line strings
+            {
+                input: '"newline\nhere"',
+                expected: {
+                    success: false,
+                },
+            },
         ];
         testCases.forEach(({ input, expected }) => {
             if (expected.success) {
@@ -444,6 +453,170 @@ describe("literals parsers", () => {
             }
         });
     });
+    describe("multiLineStringParser", () => {
+        const testCases = [
+            // Happy path - simple strings
+            {
+                input: '"""hello"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "hello" },
+                },
+            },
+            {
+                input: '"""world"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "world" },
+                },
+            },
+            // Empty multi-line string
+            {
+                input: '""""""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "" },
+                },
+            },
+            // Multi-line strings with actual newlines
+            {
+                input: '"""line1\nline2"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "line1\nline2" },
+                },
+            },
+            {
+                input: '"""line1\nline2\nline3"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "line1\nline2\nline3" },
+                },
+            },
+            {
+                input: '"""\nstarts with newline"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "\nstarts with newline" },
+                },
+            },
+            {
+                input: '"""ends with newline\n"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "ends with newline\n" },
+                },
+            },
+            // Strings with special characters
+            {
+                input: '"""Hello, World!"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "Hello, World!" },
+                },
+            },
+            {
+                input: '"""123"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "123" },
+                },
+            },
+            {
+                input: '"""  spaces  and  tabs\t\t"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "  spaces  and  tabs\t\t" },
+                },
+            },
+            {
+                input: '"""special!@#$%^&*()"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "special!@#$%^&*()" },
+                },
+            },
+            // Strings containing single and double quotes
+            {
+                input: '"""single\'quotes\'here"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "single'quotes'here" },
+                },
+            },
+            {
+                input: '"""double"quotes"here"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: 'double"quotes"here' },
+                },
+            },
+            {
+                input: '"""mixed"and\'quotes"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: `mixed"and'quotes` },
+                },
+            },
+            // Strings containing backticks and interpolation-like syntax
+            {
+                input: '"""`backtick`"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "`backtick`" },
+                },
+            },
+            {
+                input: '"""${notInterpolation}"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "${notInterpolation}" },
+                },
+            },
+            // Multiple consecutive newlines
+            {
+                input: '"""line1\n\n\nline2"""',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "line1\n\n\nline2" },
+                },
+            },
+            // Mixed whitespace
+            {
+                input: '"""  \n\t\n  """',
+                expected: {
+                    success: true,
+                    result: { type: "multiLineString", value: "  \n\t\n  " },
+                },
+            },
+            // Failure cases
+            { input: '"""hello', expected: { success: false } },
+            { input: 'hello"""', expected: { success: false } },
+            { input: '""hello"""', expected: { success: false } },
+            { input: '"""hello""', expected: { success: false } },
+            { input: '"hello"', expected: { success: false } },
+            { input: "'hello'", expected: { success: false } },
+            { input: "", expected: { success: false } },
+            { input: "hello", expected: { success: false } },
+        ];
+        testCases.forEach(({ input, expected }) => {
+            if (expected.success) {
+                it(`should parse ${JSON.stringify(input)} successfully`, () => {
+                    const result = multiLineStringParser(input);
+                    expect(result.success).toBe(true);
+                    if (result.success) {
+                        expect(result.result).toEqual(expected.result);
+                    }
+                });
+            }
+            else {
+                it(`should fail to parse ${JSON.stringify(input)}`, () => {
+                    const result = multiLineStringParser(input);
+                    expect(result.success).toBe(false);
+                });
+            }
+        });
+    });
     describe("variableNameParser", () => {
         const testCases = [
             // Happy path

package/dist/lib/templates/backends/graphGenerator/graphNode.d.ts

@@ -1,4 +1,4 @@
-export declare const template = "graph.node(\"{{{name}}}\", async (state) => {\n    {{#hasParam}}\n    const {{{paramName}}} = state.data;\n    {{/hasParam}}\n    {{{body}}}\n});\n";
+export declare const template = "graph.node(\"{{{name}}}\", async (state): Promise<any> => {\n    {{#hasParam}}\n    const {{{paramName}}} = state.data;\n    {{/hasParam}}\n    {{{body}}}\n});\n";
 export type TemplateType = {
     name: string | boolean | number;
     hasParam: boolean;

package/dist/lib/templates/backends/graphGenerator/graphNode.js

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/graphGenerator/graphNode.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `graph.node("{{{name}}}", async (state) => {
+export const template = `graph.node("{{{name}}}", async (state): Promise<any> => {
     {{#hasParam}}
     const {{{paramName}}} = state.data;
     {{/hasParam}}

package/dist/lib/templates/backends/graphGenerator/runNodeFunction.d.ts

@@ -1,6 +1,7 @@
-export declare const template = "export async function {{{nodeName:string}}}(data:any): Promise<any> {\n  const result = await graph.run(\"{{{nodeName:string}}}\", { messages: [], data });\n  return result.data;\n}\n";
+export declare const template = "export async function {{{nodeName:string}}}(data:any): Promise<{{{returnType:string}}}> {\n  const result = await graph.run(\"{{{nodeName:string}}}\", { messages: [], data });\n  return result.data;\n}\n";
 export type TemplateType = {
     nodeName: string;
+    returnType: string;
 };
 declare const render: (args: TemplateType) => string;
 export default render;

package/dist/lib/templates/backends/graphGenerator/runNodeFunction.js

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/graphGenerator/runNodeFunction.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `export async function {{{nodeName:string}}}(data:any): Promise<any> {
+export const template = `export async function {{{nodeName:string}}}(data:any): Promise<{{{returnType:string}}}> {
   const result = await graph.run("{{{nodeName:string}}}", { messages: [], data });
   return result.data;
 }

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

@@ -1,7 +1,8 @@
-export declare const template = "async function {{{functionName:string}}}({{{args}}}) {\n    {{{functionBody}}}\n}";
+export declare const template = "async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {\n    {{{functionBody}}}\n}";
 export type TemplateType = {
     functionName: string;
     args: string | boolean | number;
+    returnType: string | boolean | number;
     functionBody: string | boolean | number;
 };
 declare const render: (args: TemplateType) => string;

package/dist/lib/templates/backends/typescriptGenerator/functionDefinition.js

@@ -2,7 +2,7 @@
 // Source: lib/templates/backends/typescriptGenerator/functionDefinition.mustache
 // Any manual changes will be lost.
 import { apply } from "typestache";
-export const template = `async function {{{functionName:string}}}({{{args}}}) {
+export const template = `async function {{{functionName:string}}}({{{args}}}) : Promise<{{{returnType}}}> {
     {{{functionBody}}}
 }`;
 const render = (args) => {

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

@@ -11,7 +11,7 @@ export type FunctionDefinition = {
     functionName: string;
     parameters: FunctionParameter[];
     body: AgencyNode[];
-    returnType?: VariableType;
+    returnType?: VariableType | null;
     docString?: DocString;
 };
 export type FunctionCall = {

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

@@ -1,4 +1,4 @@
-import { AgencyNode, FunctionCall } from "../types.js";
+import { AgencyNode, FunctionCall, VariableType } from "../types.js";
 import { AccessExpression } from "./access.js";
 import { Literal } from "./literals.js";
 export type GraphNodeDefinition = {
@@ -6,6 +6,7 @@ export type GraphNodeDefinition = {
     nodeName: string;
     parameters: string[];
     body: AgencyNode[];
+    returnType?: VariableType | null;
 };
 export type NodeCall = {
     type: "nodeCall";

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -55,4 +55,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   }
-}
+}