agency-lang 0.0.5 → 0.0.7

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

@@ -43,5 +43,6 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processGraphNode(node: GraphNodeDefinition): string;
     protected processTool(node: FunctionDefinition): string;
     protected processUsesTool(node: UsesTool): string;
+    private indentStr;
 }
 export declare function generateAgency(program: AgencyProgram): string;

package/dist/lib/backends/agencyGenerator.js

@@ -32,17 +32,17 @@ export class AgencyGenerator extends BaseGenerator {
     processTypeAlias(node) {
         this.typeAliases[node.aliasName] = node.aliasedType;
         const aliasedTypeStr = variableTypeToString(node.aliasedType, this.typeAliases);
-        return `${this.indent()}type ${node.aliasName} = ${aliasedTypeStr}\n`;
+        return this.indentStr(`type ${node.aliasName} = ${aliasedTypeStr}\n`);
     }
     processTypeHint(node) {
         this.typeHints[node.variableName] = node.variableType;
         const typeStr = variableTypeToString(node.variableType, this.typeAliases);
-        return `${this.indent()}${node.variableName} :: ${typeStr}\n`;
+        return this.indentStr(`${node.variableName} :: ${typeStr}\n`);
     }
     // Assignment and literals
     processAssignment(node) {
         const valueCode = this.processNode(node.value).trim();
-        return `${this.indent()}${node.variableName} = ${valueCode}\n`;
+        return this.indentStr(`${node.variableName} = ${valueCode}\n\n`);
     }
     generateLiteral(literal) {
         switch (literal.type) {
@@ -86,7 +86,7 @@ export class AgencyGenerator extends BaseGenerator {
         // Build parameter list
         const params = parameters.join(", ");
         // Start function definition
-        let result = `${this.indent()}def ${functionName}(${params}) {\n`;
+        let result = this.indentStr(`def ${functionName}(${params}) {\n`);
         // Process body with increased indentation
         this.increaseIndent();
         this.functionScopedVariables = [...parameters];
@@ -96,12 +96,12 @@ export class AgencyGenerator extends BaseGenerator {
         this.functionScopedVariables = [];
         this.decreaseIndent();
         // Close function
-        result += `${this.indent()}}\n`;
+        result += this.indentStr(`}\n\n`);
         return result;
     }
     processFunctionCall(node) {
         const expr = this.generateFunctionCallExpression(node);
-        return `${this.indent()}${expr}\n`;
+        return this.indentStr(`${expr}\n`);
     }
     generateFunctionCallExpression(node) {
         const args = node.arguments.map((arg) => {
@@ -151,7 +151,7 @@ export class AgencyGenerator extends BaseGenerator {
     // Control flow
     processMatchBlock(node) {
         const exprCode = this.processNode(node.expression).trim();
-        let result = `${this.indent()}match(${exprCode}) {\n`;
+        let result = this.indentStr(`match(${exprCode}) {\n`);
         this.increaseIndent();
         for (const caseNode of node.cases) {
             // Handle comments within cases
@@ -165,39 +165,39 @@ export class AgencyGenerator extends BaseGenerator {
                 : this.processNode(caseNode.caseValue).trim();
             // Format body (action)
             const bodyCode = this.processNode(caseNode.body).trim();
-            result += `${this.indent()}${pattern} => ${bodyCode}\n`;
+            result += this.indentStr(`${pattern} => ${bodyCode}\n`);
         }
         this.decreaseIndent();
-        result += `${this.indent()}}\n`;
+        result += this.indentStr(`}\n`);
         return result;
     }
     processWhileLoop(node) {
         const conditionCode = this.processNode(node.condition).trim();
-        let result = `${this.indent()}while (${conditionCode}) {\n`;
+        let result = this.indentStr(`while (${conditionCode}) {\n`);
         this.increaseIndent();
         for (const stmt of node.body) {
             result += this.processNode(stmt);
         }
         this.decreaseIndent();
-        result += `${this.indent()}}\n`;
+        result += this.indentStr(`}\n`);
         return result;
     }
     processReturnStatement(node) {
         const valueCode = this.processNode(node.value).trim();
-        return `${this.indent()}return ${valueCode}\n`;
+        return this.indentStr(`return ${valueCode}\n`);
     }
     // Utility methods
     processComment(node) {
-        return `${this.indent()}// ${node.content}\n`;
+        return this.indentStr(`// ${node.content}\n`);
     }
     processImportStatement(node) {
-        return `${this.indent()}import {${node.importedNames}} from "${node.modulePath}"\n`;
+        return this.indentStr(`import {${node.importedNames}} from "${node.modulePath}"\n`);
     }
     processGraphNode(node) {
         // Graph nodes use similar syntax to functions
         const { nodeName, body, parameters } = node;
         const params = parameters.join(", ");
-        let result = `${this.indent()}node ${nodeName}(${params}) {\n`;
+        let result = this.indentStr(`node ${nodeName}(${params}) {\n`);
         this.increaseIndent();
         this.functionScopedVariables = [...parameters];
         for (const stmt of body) {
@@ -205,7 +205,7 @@ export class AgencyGenerator extends BaseGenerator {
         }
         this.functionScopedVariables = [];
         this.decreaseIndent();
-        result += `${this.indent()}}\n`;
+        result += this.indentStr(`}\n`);
         return result;
     }
     processTool(node) {
@@ -216,7 +216,10 @@ export class AgencyGenerator extends BaseGenerator {
     processUsesTool(node) {
         // Track tool usage but don't generate code
         this.toolsUsed.push(node.toolName);
-        return "";
+        return this.indentStr(`+${node.toolName}\n`);
+    }
+    indentStr(str) {
+        return `${this.indent()}${str}`;
     }
 }
 export function generateAgency(program) {

package/dist/lib/parser.d.ts

@@ -4,4 +4,4 @@ export declare const agencyNode: Parser<AgencyNode[]>;
 export declare const agencyParser: Parser<AgencyProgram>;
 export declare const _multilineCommentParser: Parser<string[]>;
 export declare const multilineCommentParser: Parser<string[][]>;
-export declare function parseAgency(input: string): ParserResult<AgencyProgram>;
+export declare function parseAgency(input: string, verbose?: boolean): ParserResult<AgencyProgram>;

package/dist/lib/parser.js

@@ -9,6 +9,7 @@ import { importStatmentParser } from "./parsers/importStatement.js";
 import { matchBlockParser } from "./parsers/matchBlock.js";
 import { returnStatementParser } from "./parsers/returnStatement.js";
 import { usesToolParser } from "./parsers/tools.js";
+import { EgonLog } from "egonlog";
 export const agencyNode = (input) => {
     const parser = sepBy(spaces, trace("agencyParser", or(usesToolParser, importStatmentParser, graphNodeParser, typeAliasParser, whileLoopParser, typeHintParser, matchBlockParser, functionParser, returnStatementParser, accessExpressionParser, assignmentParser, functionCallParser, commentParser)));
     return parser(input);
@@ -16,9 +17,15 @@ export const agencyNode = (input) => {
 export const agencyParser = seqC(set("type", "agencyProgram"), capture(agencyNode, "nodes"), eof);
 export const _multilineCommentParser = between(str("/*"), str("*/"), anyChar);
 export const multilineCommentParser = search(_multilineCommentParser);
-export function parseAgency(input) {
+export function parseAgency(input, verbose = false) {
+    const logger = new EgonLog({ level: verbose ? "debug" : "warn" });
     let normalized = input;
+    logger.debug("Starting to parse agency program");
+    logger.debug(`Input: ${input}`);
+    logger.debug("================================");
     const comments = multilineCommentParser(normalized);
+    logger.debug(`Multiline comments: ${JSON.stringify(comments)}`);
+    logger.debug("================================");
     // get rid of all multiline comments
     normalized = comments.rest
         .split("\n")
@@ -33,6 +40,8 @@ export function parseAgency(input) {
             nodes: [],
         }, "");
     }
+    logger.debug(`Normalized input: ${normalized}`);
+    logger.debug("================================");
     const result = agencyParser(normalized);
     return result;
 }

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

@@ -44,7 +44,7 @@ describe("importStatmentParser", () => {
                 result: {
                     type: "importStatement",
                     importedNames: "foo ",
-                    modulePath: '"./local/path"',
+                    modulePath: '"./local/path.js"',
                 },
             },
         },
@@ -55,7 +55,7 @@ describe("importStatmentParser", () => {
                 result: {
                     type: "importStatement",
                     importedNames: "bar ",
-                    modulePath: '"@/utils/helper"',
+                    modulePath: '"../utils/helper.js"',
                 },
             },
         },
@@ -89,7 +89,7 @@ describe("importStatmentParser", () => {
                 result: {
                     type: "importStatement",
                     importedNames: "test ",
-                    modulePath: "'./module'",
+                    modulePath: "'./module.js'",
                 },
             },
         },
@@ -240,7 +240,7 @@ describe("importStatmentParser", () => {
                 result: {
                     type: "importStatement",
                     importedNames: "foo ",
-                    modulePath: '"../../../utils/helpers"',
+                    modulePath: '"../../../utils/helpers.js"',
                 },
             },
         },

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

@@ -7,7 +7,7 @@ export declare const angleBracketsArrayTypeParser: Parser<ArrayType>;
 export declare const stringLiteralTypeParser: Parser<StringLiteralType>;
 export declare const numberLiteralTypeParser: Parser<NumberLiteralType>;
 export declare const booleanLiteralTypeParser: Parser<BooleanLiteralType>;
-export declare const objectPropertyDelimiter: Parser<(string[] | ";")[]>;
+export declare const objectPropertyDelimiter: Parser<"\n" | (string | string[])[]>;
 export declare const objectPropertyParser: Parser<ObjectProperty>;
 export declare const objectPropertyDescriptionParser: Parser<{
     description: string;

package/dist/lib/parsers/typeHints.js

@@ -1,5 +1,5 @@
 import { optionalSpaces, varNameChar } from "./utils.js";
-import { capture, captureCaptures, char, count, digit, many1Till, many1WithJoin, or, sepBy, seqC, seqR, set, space, spaces, str, trace, } from "tarsec";
+import { capture, captureCaptures, char, count, digit, many1Till, many1WithJoin, oneOf, or, sepBy, seqC, seqR, set, space, spaces, str, trace, } from "tarsec";
 import { optionalSemicolon } from "./parserUtils.js";
 export const primitiveTypeParser = trace("primitiveTypeParser", seqC(set("type", "primitiveType"), capture(or(str("number"), str("string"), str("boolean")), "value")));
 export const typeAliasVariableParser = trace("typeAliasVariableParser", seqC(set("type", "typeAliasVariable"), capture(many1WithJoin(varNameChar), "aliasName")));
@@ -27,12 +27,12 @@ export const angleBracketsArrayTypeParser = trace("angleBracketsArrayTypeParser"
 export const stringLiteralTypeParser = trace("stringLiteralTypeParser", seqC(set("type", "stringLiteralType"), char('"'), capture(many1Till(char('"')), "value"), char('"')));
 export const numberLiteralTypeParser = trace("numberLiteralTypeParser", seqC(set("type", "numberLiteralType"), capture(many1WithJoin(or(char("-"), char("."), digit)), "value")));
 export const booleanLiteralTypeParser = trace("booleanLiteralTypeParser", seqC(set("type", "booleanLiteralType"), capture(or(str("true"), str("false")), "value")));
-export const objectPropertyDelimiter = seqR(optionalSpaces, char(";"), optionalSpaces);
+export const objectPropertyDelimiter = or(char("\n"), seqR(optionalSpaces, oneOf(",;"), optionalSpaces));
 export const objectPropertyParser = trace("objectPropertyParser", (input) => {
     const parser = seqC(capture(many1WithJoin(varNameChar), "key"), optionalSpaces, char(":"), optionalSpaces, capture(variableTypeParser, "value"));
     return parser(input);
 });
-export const objectPropertyDescriptionParser = seqC(char("#"), optionalSpaces, capture(many1Till(char(";")), "description"));
+export const objectPropertyDescriptionParser = seqC(char("#"), optionalSpaces, capture(many1Till(oneOf(",;\n")), "description"));
 export const objectPropertyWithDescriptionParser = trace("objectPropertyWithDescriptionParser", seqC(captureCaptures(objectPropertyParser), spaces, captureCaptures(objectPropertyDescriptionParser)));
 export const objectTypeParser = trace("objectTypeParser", (input) => {
     const parser = seqC(set("type", "objectType"), char("{"), optionalSpaces, capture(sepBy(objectPropertyDelimiter, or(objectPropertyWithDescriptionParser, objectPropertyParser)), "properties"), optionalSpaces, char("}"));

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

@@ -1012,6 +1012,24 @@ describe("objectPropertyDescriptionParser", () => {
                 },
             },
         },
+        {
+            input: "# comma,",
+            expected: {
+                success: true,
+                result: {
+                    description: "comma",
+                },
+            },
+        },
+        {
+            input: "# newline",
+            expected: {
+                success: true,
+                result: {
+                    description: "newline",
+                },
+            },
+        },
         {
             input: "#  with extra spaces  ;",
             expected: {
@@ -1022,11 +1040,11 @@ describe("objectPropertyDescriptionParser", () => {
             },
         },
         {
-            input: "# description with, punctuation!;",
+            input: "# description with punctuation!;",
             expected: {
                 success: true,
                 result: {
-                    description: "description with, punctuation!",
+                    description: "description with punctuation!",
                 },
             },
         },

package/dist/scripts/agency.js

@@ -12,40 +12,69 @@ Usage:
   agency help                           Show this help message
   agency compile <input> [output]       Compile .agency file to TypeScript
   agency run <input> [output]           Compile and run .agency file
-  agency format <input>                 Format .agency file in place
+  agency format [input]                 Format .agency file (reads from stdin if no input)
+  agency parse [input]                  Parse .agency file and show AST (reads from stdin if no input)
   agency <input>                        Compile and run .agency file (shorthand)
 
 Arguments:
-  input                                 Path to .agency input file
+  input                                 Path to .agency input file (or omit to read from stdin for format/parse)
   output                                Path to output .ts file (optional)
                                         Default: <input-name>.ts
 
+Flags:
+  -v, --verbose                         Enable verbose logging during parsing
+
 Examples:
   agency help                           Show help
   agency compile script.agency          Compile to script.ts
   agency compile script.agency out.ts   Compile to out.ts
   agency run script.agency              Compile and run script.agency
+  agency -v parse script.agency         Parse with verbose logging
+  cat script.agency | agency format     Format from stdin
+  echo "x = 5" | agency parse           Parse from stdin
   agency script.agency                  Compile and run (shorthand)
 `);
 }
-function compile(inputFile, outputFile) {
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        process.stdin.setEncoding("utf-8");
+        process.stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        process.stdin.on("end", () => {
+            resolve(data);
+        });
+        process.stdin.on("error", (err) => {
+            reject(err);
+        });
+    });
+}
+function parse(contents, verbose = false) {
+    const parseResult = parseAgency(contents, verbose);
+    // Check if parsing was successful
+    if (!parseResult.success) {
+        console.error("Parse error:");
+        console.error(parseResult);
+        process.exit(1);
+    }
+    return parseResult.result;
+}
+function readFile(inputFile) {
     // Validate input file
     if (!fs.existsSync(inputFile)) {
         console.error(`Error: Input file '${inputFile}' not found`);
         process.exit(1);
     }
-    // Determine output file name
-    const output = outputFile || inputFile.replace(".agency", ".ts");
     // Read and parse the Agency file
     const contents = fs.readFileSync(inputFile, "utf-8");
-    const parseResult = parseAgency(contents);
-    // Check if parsing was successful
-    if (!parseResult.success) {
-        console.error("Parse error:");
-        console.error(parseResult);
-        process.exit(1);
-    }
-    const parsedProgram = parseResult.result;
+    return contents;
+}
+function compile(inputFile, outputFile, verbose = false) {
+    // Determine output file name
+    const output = outputFile || inputFile.replace(".agency", ".ts");
+    const contents = readFile(inputFile);
+    const parsedProgram = parse(contents, verbose);
     // Generate TypeScript code
     const generatedCode = generateGraph(parsedProgram);
     // Write to output file
@@ -53,9 +82,9 @@ function compile(inputFile, outputFile) {
     console.log(`Generated ${output} from ${inputFile}`);
     return output;
 }
-function run(inputFile, outputFile) {
+function run(inputFile, outputFile, verbose = false) {
     // Compile the file
-    const output = compile(inputFile, outputFile);
+    const output = compile(inputFile, outputFile, verbose);
     // Run the generated TypeScript file with Node.js
     console.log(`Running ${output}...`);
     console.log("---");
@@ -73,39 +102,26 @@ function run(inputFile, outputFile) {
         }
     });
 }
-function format(inputFile) {
-    // Validate input file
-    if (!fs.existsSync(inputFile)) {
-        console.error(`Error: Input file '${inputFile}' not found`);
-        process.exit(1);
-    }
-    // Read and parse the Agency file
-    const contents = fs.readFileSync(inputFile, "utf-8");
-    const parseResult = parseAgency(contents);
-    // Check if parsing was successful
-    if (!parseResult.success) {
-        console.error("Parse error:");
-        console.error(parseResult);
-        process.exit(1);
-    }
-    const parsedProgram = parseResult.result;
-    // Generate TypeScript code
+async function format(contents, verbose = false) {
+    const parsedProgram = parse(contents, verbose);
     const generatedCode = generateAgency(parsedProgram);
-    // Write to output file
-    //fs.writeFileSync(inputFile, generatedCode, "utf-8");
-    //  console.log(`Generated ${output} from ${inputFile}`);
     console.log(generatedCode);
     return generatedCode;
 }
 // Main CLI logic
-function main() {
+async function main() {
     const args = process.argv.slice(2);
     // No arguments - show help
     if (args.length === 0) {
         help();
         return;
     }
-    const command = args[0];
+    // Extract verbose flag
+    const verboseIndex = args.findIndex((arg) => arg === "-v" || arg === "--verbose");
+    const verbose = verboseIndex !== -1;
+    // Remove verbose flag from args
+    const filteredArgs = args.filter((arg) => arg !== "-v" && arg !== "--verbose");
+    const command = filteredArgs[0];
     switch (command) {
         case "help":
         case "--help":
@@ -113,34 +129,47 @@ function main() {
             help();
             break;
         case "compile":
-            if (args.length < 2) {
+            if (filteredArgs.length < 2) {
                 console.error("Error: 'compile' command requires an input file");
                 console.error("Usage: agency compile <input> [output]");
                 process.exit(1);
             }
-            compile(args[1], args[2]);
+            compile(filteredArgs[1], filteredArgs[2], verbose);
             break;
         case "run":
-            if (args.length < 2) {
+            if (filteredArgs.length < 2) {
                 console.error("Error: 'run' command requires an input file");
                 console.error("Usage: agency run <input> [output]");
                 process.exit(1);
             }
-            run(args[1], args[2]);
+            run(filteredArgs[1], filteredArgs[2], verbose);
             break;
         case "fmt":
         case "format":
-            if (args.length < 1) {
-                console.error("Error: 'format' command requires an input file");
-                console.error("Usage: agency format <input>");
-                process.exit(1);
+            let fmtContents;
+            if (filteredArgs.length < 2) {
+                fmtContents = await readStdin();
+            }
+            else {
+                fmtContents = readFile(filteredArgs[1]);
+            }
+            format(fmtContents, verbose);
+            break;
+        case "parse":
+            let contents;
+            if (filteredArgs.length < 2) {
+                contents = await readStdin();
+            }
+            else {
+                contents = readFile(filteredArgs[1]);
             }
-            format(args[1]);
+            const result = parse(contents, verbose);
+            console.log(JSON.stringify(result, null, 2));
             break;
         default:
             // If first arg is not a recognized command, treat it as a file to run
             if (command.endsWith(".agency") || fs.existsSync(command)) {
-                run(command, args[1]);
+                run(command, filteredArgs[1], verbose);
             }
             else {
                 console.error(`Error: Unknown command '${command}'`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -39,6 +39,7 @@
   },
   "homepage": "https://github.com/egonSchiele/agency-lang#readme",
   "dependencies": {
+    "egonlog": "^0.0.2",
     "nanoid": "^5.1.6",
     "openai": "^6.15.0",
     "simplemachine": "github:egonSchiele/simplemachine",