agency-lang 0.0.16 → 0.0.17

package/dist/lib/backends/agencyGenerator.js

@@ -66,12 +66,13 @@ export class AgencyGenerator extends BaseGenerator {
                 return literal.value;
             case "string":
                 // Escape backslashes and quotes
-                const escaped = literal.value
-                    .replace(/\\/g, "\\\\")
-                    .replace(/"/g, '\\"');
+                const escaped = literal.value;
                 return `"${escaped}"`;
             case "variableName":
                 return literal.value;
+            case "multiLineString":
+                const escapedMultiLine = literal.value;
+                return `"""${escapedMultiLine}"""`;
             case "prompt":
                 return this.generatePromptLiteral(literal);
             default:

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

@@ -15,6 +15,7 @@ export declare class BaseGenerator {
     protected generatedStatements: string[];
     protected generatedTypeAliases: string[];
     protected functionScopedVariables: string[];
+    protected globalScopedVariables: string[];
     protected toolsUsed: string[];
     protected typeAliases: Record<string, VariableType>;
     protected functionsUsed: Set<string>;

package/dist/lib/backends/baseGenerator.js

@@ -4,6 +4,7 @@ export class BaseGenerator {
     generatedStatements = [];
     generatedTypeAliases = [];
     functionScopedVariables = [];
+    globalScopedVariables = [];
     // collect tools for a prompt
     toolsUsed = [];
     typeAliases = {};
@@ -39,7 +40,13 @@ export class BaseGenerator {
                 this.collectFunctionSignature(node);
             }
         }
-        // Pass 5: Process all nodes and generate code
+        // Pass 5: Collect global scoped variables
+        for (const node of program.nodes) {
+            if (node.type === "assignment") {
+                this.globalScopedVariables.push(node.variableName);
+            }
+        }
+        // Pass 6: Process all nodes and generate code
         for (const node of program.nodes) {
             const result = this.processNode(node);
             this.generatedStatements.push(result);
@@ -91,6 +98,7 @@ export class BaseGenerator {
             case "matchBlock":
                 return this.processMatchBlock(node);
             case "number":
+            case "multiLineString":
             case "string":
             case "variableName":
             case "prompt":

package/dist/lib/backends/typescriptGenerator.js

@@ -135,7 +135,8 @@ export class TypeScriptGenerator extends BaseGenerator {
             .filter((s) => s.type === "interpolation")
             .map((s) => s.variableName);
         for (const varName of interpolatedVars) {
-            if (!this.functionScopedVariables.includes(varName)) {
+            if (!this.functionScopedVariables.includes(varName) &&
+                !this.globalScopedVariables.includes(varName)) {
                 throw new Error(`Variable '${varName}' used in prompt interpolation but not defined. ` +
                     `Referenced in assignment to '${variableName}'.`);
             }
@@ -220,10 +221,11 @@ export class TypeScriptGenerator extends BaseGenerator {
                 this.functionsUsed.add(arg.functionName);
                 return this.generateFunctionCallExpression(arg);
                 /*       } else if (arg.type === "accessExpression") {
-                        return this.processAccessExpression(arg);
-                      } else if (arg.type === "indexAccess") {
-                        return this.processIndexAccess(arg);
-                 */ }
+                return this.processAccessExpression(arg);
+              } else if (arg.type === "indexAccess") {
+                return this.processIndexAccess(arg);
+         */
+            }
             else {
                 //        return this.generateLiteral(arg);
                 return this.processNode(arg);
@@ -252,6 +254,8 @@ export class TypeScriptGenerator extends BaseGenerator {
                 return literal.value;
             case "string":
                 return `"${escape(literal.value)}"`;
+            case "multiLineString":
+                return `\`${escape(literal.value)}\``;
             case "variableName":
                 return literal.value;
             case "prompt":

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/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.17",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -55,4 +55,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.16"
   }
-}
+}