agency-lang 0.0.1

package/dist/parsers/functionCall.test.js

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { functionCallParser } from "./functionCall.js";
+describe("functionCallParser", () => {
+    const testCases = [
+        {
+            input: "test()",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "test",
+                    arguments: [],
+                },
+            },
+        },
+        {
+            input: "greet(name)",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "greet",
+                    arguments: [{ type: "variableName", value: "name" }],
+                },
+            },
+        },
+        {
+            input: "add(x, y)",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "add",
+                    arguments: [
+                        { type: "variableName", value: "x" },
+                        { type: "variableName", value: "y" },
+                    ],
+                },
+            },
+        },
+        {
+            input: "process(a, b, c)",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "process",
+                    arguments: [
+                        { type: "variableName", value: "a" },
+                        { type: "variableName", value: "b" },
+                        { type: "variableName", value: "c" },
+                    ],
+                },
+            },
+        },
+        {
+            input: "func(arg1,arg2)",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "func",
+                    arguments: [
+                        { type: "variableName", value: "arg1" },
+                        { type: "variableName", value: "arg2" },
+                    ],
+                },
+            },
+        },
+        {
+            input: "call( arg )",
+            expected: {
+                success: true,
+                result: {
+                    type: "functionCall",
+                    functionName: "call",
+                    arguments: [{ type: "variableName", value: "arg" }],
+                },
+            },
+        },
+        {
+            input: "test",
+            expected: { success: false },
+        },
+        {
+            input: "test(",
+            expected: { success: false },
+        },
+        {
+            input: "test)",
+            expected: { success: false },
+        },
+        {
+            input: "()",
+            expected: { success: false },
+        },
+        {
+            input: "",
+            expected: { success: false },
+        },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input}" successfully`, () => {
+                const result = functionCallParser(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                }
+            });
+        }
+        else {
+            it(`should fail to parse "${input}"`, () => {
+                const result = functionCallParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/parsers/importStatement.js

@@ -0,0 +1,3 @@
+import { capture, many1Till, oneOf, seqC, set, spaces, str, trace, } from "tarsec";
+import { optionalSemicolon } from "./parserUtils.js";
+export const importStatmentParser = trace("importStatement", seqC(set("type", "importStatement"), str("import"), spaces, capture(many1Till(str("from")), "importedNames"), str("from"), spaces, capture(many1Till(oneOf(";\n")), "modulePath"), optionalSemicolon));

package/dist/parsers/importStatement.test.js

@@ -0,0 +1,290 @@
+import { describe, it, expect } from "vitest";
+import { importStatmentParser } from "./importStatement.js";
+describe("importStatmentParser", () => {
+    const testCases = [
+        // Happy path - basic import
+        {
+            input: "import foo from bar;",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: "bar",
+                },
+            },
+        },
+        {
+            input: "import myModule from path/to/module;",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "myModule ",
+                    modulePath: "path/to/module",
+                },
+            },
+        },
+        // Module paths with double quotes
+        {
+            input: 'import foo from "bar";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: '"bar"',
+                },
+            },
+        },
+        {
+            input: 'import foo from "./local/path.js";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: '"./local/path"',
+                },
+            },
+        },
+        {
+            input: 'import bar from "../utils/helper.js";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "bar ",
+                    modulePath: '"@/utils/helper"',
+                },
+            },
+        },
+        {
+            input: 'import { useState } from "react";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "{ useState } ",
+                    modulePath: '"react"',
+                },
+            },
+        },
+        // Module paths with single quotes
+        {
+            input: "import foo from 'bar';",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: "'bar'",
+                },
+            },
+        },
+        {
+            input: "import test from './module.js';",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "test ",
+                    modulePath: "'./module'",
+                },
+            },
+        },
+        // Without semicolon (should still parse due to optionalSemicolon)
+        {
+            input: "import foo from bar\n",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: "bar",
+                },
+            },
+        },
+        {
+            input: "import test from module",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "test ",
+                    modulePath: "module",
+                },
+            },
+        },
+        {
+            input: 'import foo from "bar"\n',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: '"bar"',
+                },
+            },
+        },
+        // Multiple imported names (destructured imports)
+        {
+            input: "import { foo, bar } from module;",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "{ foo, bar } ",
+                    modulePath: "module",
+                },
+            },
+        },
+        {
+            input: 'import { foo, bar, baz } from "myModule";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "{ foo, bar, baz } ",
+                    modulePath: '"myModule"',
+                },
+            },
+        },
+        // Default and named imports
+        {
+            input: 'import React, { useState } from "react";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "React, { useState } ",
+                    modulePath: '"react"',
+                },
+            },
+        },
+        // Namespace imports
+        {
+            input: 'import * as utils from "utils";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "* as utils ",
+                    modulePath: '"utils"',
+                },
+            },
+        },
+        // Scoped packages
+        {
+            input: 'import { Parser } from "@typescript-eslint/parser";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "{ Parser } ",
+                    modulePath: '"@typescript-eslint/parser"',
+                },
+            },
+        },
+        // Spaces around keywords
+        {
+            input: "import   foo   from   bar;",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo   ",
+                    modulePath: "bar",
+                },
+            },
+        },
+        // Edge cases - single character names
+        {
+            input: "import x from y;",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "x ",
+                    modulePath: "y",
+                },
+            },
+        },
+        {
+            input: 'import x from "y";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "x ",
+                    modulePath: '"y"',
+                },
+            },
+        },
+        // Complex paths
+        {
+            input: "import foo from ../../../utils/helpers;",
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: "../../../utils/helpers",
+                },
+            },
+        },
+        {
+            input: 'import foo from "../../../utils/helpers.js";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "foo ",
+                    modulePath: '"../../../utils/helpers"',
+                },
+            },
+        },
+        // Aliased imports
+        {
+            input: 'import { foo as bar } from "module";',
+            expected: {
+                success: true,
+                result: {
+                    type: "importStatement",
+                    importedNames: "{ foo as bar } ",
+                    modulePath: '"module"',
+                },
+            },
+        },
+        // Failure cases - missing keywords
+        { input: "foo from bar;", expected: { success: false } },
+        { input: "from bar;", expected: { success: false } },
+        { input: "import foo bar;", expected: { success: false } },
+        // Failure cases - missing parts
+        { input: "import from bar;", expected: { success: false } },
+        { input: "import foo from;", expected: { success: false } },
+        { input: "import;", expected: { success: false } },
+        // Failure cases - empty input
+        { input: "", expected: { success: false } },
+        // Failure cases - just keyword
+        { input: "import", expected: { success: false } },
+        { input: "from", expected: { success: false } },
+    ];
+    testCases.forEach(({ input, expected }) => {
+        if (expected.success) {
+            it(`should parse "${input}" successfully`, () => {
+                const result = importStatmentParser(input);
+                expect(result.success).toBe(true);
+                if (result.success) {
+                    expect(result.result).toEqual(expected.result);
+                }
+            });
+        }
+        else {
+            it(`should fail to parse "${input}"`, () => {
+                const result = importStatmentParser(input);
+                expect(result.success).toBe(false);
+            });
+        }
+    });
+});

package/dist/parsers/literals.js

@@ -0,0 +1,12 @@
+import { backtick, varNameChar } from "./utils.js";
+import { capture, char, digit, many, many1Till, many1WithJoin, manyTill, map, or, seqC, set, } 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 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 variableNameParser = seqC(set("type", "variableName"), capture(many1WithJoin(varNameChar), "value"));
+export const literalParser = or(promptParser, numberParser, stringParser, variableNameParser);