agency-lang 0.0.4 → 0.0.6

package/README.md

@@ -1,6 +1,33 @@
 # Agency
 Agent Definition Language
 
+## Usage
+
+Add agency to a project:
+
+```bash
+pnpm add agency-lang
+```
+
+You can then start using the agency script on your files:
+
+```bash
+# to compile
+agency compile infile.agency outfile.ts
+
+# to compile and run
+agency run infile.agency
+
+# or simply
+agency infile.agency
+```
+
+Note that the generated files use several other libraries that you will need to install as well:
+
+```bash
+pnpm i nanoid openai egonSchiele/simplemachine statelog-client zod
+```
+
 ## troubleshooting
 ### Weird undefined error
 

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

@@ -0,0 +1,48 @@
+import { AgencyComment, AgencyProgram, Assignment, Literal, PromptLiteral, TypeAlias, TypeHint } from "../types.js";
+import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
+import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
+import { FunctionCall, FunctionDefinition } from "../types/function.js";
+import { GraphNodeDefinition } from "../types/graphNode.js";
+import { ImportStatement } from "../types/importStatement.js";
+import { MatchBlock } from "../types/matchBlock.js";
+import { ReturnStatement } from "../types/returnStatement.js";
+import { UsesTool } from "../types/tools.js";
+import { WhileLoop } from "../types/whileLoop.js";
+import { BaseGenerator } from "./baseGenerator.js";
+export declare class AgencyGenerator extends BaseGenerator {
+    private indentLevel;
+    private indentSize;
+    constructor();
+    private indent;
+    private increaseIndent;
+    private decreaseIndent;
+    protected generateBuiltins(): string;
+    protected generateImports(): string;
+    protected preprocess(): string;
+    protected postprocess(): string;
+    protected processTypeAlias(node: TypeAlias): string;
+    protected processTypeHint(node: TypeHint): string;
+    protected processAssignment(node: Assignment): string;
+    protected generateLiteral(literal: Literal): string;
+    private generatePromptLiteral;
+    protected processPromptLiteral(variableName: string, node: PromptLiteral): string;
+    protected processFunctionDefinition(node: FunctionDefinition): string;
+    protected processFunctionCall(node: FunctionCall): string;
+    protected generateFunctionCallExpression(node: FunctionCall): string;
+    protected processAgencyArray(node: AgencyArray): string;
+    protected processAgencyObject(node: AgencyObject): string;
+    protected processAccessExpression(node: AccessExpression): string;
+    protected processDotProperty(node: DotProperty): string;
+    protected processIndexAccess(node: IndexAccess): string;
+    protected processDotFunctionCall(node: DotFunctionCall): string;
+    protected processMatchBlock(node: MatchBlock): string;
+    protected processWhileLoop(node: WhileLoop): string;
+    protected processReturnStatement(node: ReturnStatement): string;
+    protected processComment(node: AgencyComment): string;
+    protected processImportStatement(node: ImportStatement): string;
+    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

@@ -0,0 +1,228 @@
+import { BaseGenerator } from "./baseGenerator.js";
+import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
+export class AgencyGenerator extends BaseGenerator {
+    indentLevel = 0;
+    indentSize = 2;
+    constructor() {
+        super();
+    }
+    indent() {
+        return " ".repeat(this.indentLevel * this.indentSize);
+    }
+    increaseIndent() {
+        this.indentLevel++;
+    }
+    decreaseIndent() {
+        this.indentLevel--;
+    }
+    // Lifecycle methods
+    generateBuiltins() {
+        return "";
+    }
+    generateImports() {
+        return "";
+    }
+    preprocess() {
+        return "";
+    }
+    postprocess() {
+        return "";
+    }
+    // Type system methods
+    processTypeAlias(node) {
+        this.typeAliases[node.aliasName] = node.aliasedType;
+        const aliasedTypeStr = variableTypeToString(node.aliasedType, this.typeAliases);
+        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.indentStr(`${node.variableName} :: ${typeStr}\n`);
+    }
+    // Assignment and literals
+    processAssignment(node) {
+        const valueCode = this.processNode(node.value).trim();
+        return this.indentStr(`${node.variableName} = ${valueCode}\n\n`);
+    }
+    generateLiteral(literal) {
+        switch (literal.type) {
+            case "number":
+                return literal.value;
+            case "string":
+                // Escape backslashes and quotes
+                const escaped = literal.value
+                    .replace(/\\/g, "\\\\")
+                    .replace(/"/g, '\\"');
+                return `"${escaped}"`;
+            case "variableName":
+                return literal.value;
+            case "prompt":
+                return this.generatePromptLiteral(literal);
+            default:
+                return "";
+        }
+    }
+    generatePromptLiteral(node) {
+        let result = "`";
+        for (const segment of node.segments) {
+            if (segment.type === "text") {
+                result += segment.value;
+            }
+            else if (segment.type === "interpolation") {
+                result += `\${${segment.variableName}}`;
+            }
+        }
+        result += "`";
+        return result;
+    }
+    processPromptLiteral(variableName, node) {
+        // For agency code, prompts are just part of assignments
+        // This shouldn't be called directly, but return empty string
+        return "";
+    }
+    // Function methods
+    processFunctionDefinition(node) {
+        const { functionName, body, parameters } = node;
+        // Build parameter list
+        const params = parameters.join(", ");
+        // Start function definition
+        let result = this.indentStr(`def ${functionName}(${params}) {\n`);
+        // Process body with increased indentation
+        this.increaseIndent();
+        this.functionScopedVariables = [...parameters];
+        for (const stmt of body) {
+            result += this.processNode(stmt);
+        }
+        this.functionScopedVariables = [];
+        this.decreaseIndent();
+        // Close function
+        result += this.indentStr(`}\n\n`);
+        return result;
+    }
+    processFunctionCall(node) {
+        const expr = this.generateFunctionCallExpression(node);
+        return this.indentStr(`${expr}\n`);
+    }
+    generateFunctionCallExpression(node) {
+        const args = node.arguments.map((arg) => {
+            return this.processNode(arg).trim();
+        });
+        return `${node.functionName}(${args.join(", ")})`;
+    }
+    // Data structures
+    processAgencyArray(node) {
+        const items = node.items.map((item) => {
+            return this.processNode(item).trim();
+        });
+        return `[${items.join(", ")}]`;
+    }
+    processAgencyObject(node) {
+        const entries = node.entries.map((entry) => {
+            const valueCode = this.processNode(entry.value).trim();
+            return `${entry.key}: ${valueCode}`;
+        });
+        return `{${entries.join(", ")}}`;
+    }
+    // Access expressions
+    processAccessExpression(node) {
+        switch (node.expression.type) {
+            case "dotProperty":
+                return this.processDotProperty(node.expression);
+            case "indexAccess":
+                return this.processIndexAccess(node.expression);
+            case "dotFunctionCall":
+                return this.processDotFunctionCall(node.expression);
+        }
+    }
+    processDotProperty(node) {
+        const objectCode = this.processNode(node.object).trim();
+        return `${objectCode}.${node.propertyName}`;
+    }
+    processIndexAccess(node) {
+        const arrayCode = this.processNode(node.array).trim();
+        const indexCode = this.processNode(node.index).trim();
+        return `${arrayCode}[${indexCode}]`;
+    }
+    processDotFunctionCall(node) {
+        const objectCode = this.processNode(node.object).trim();
+        const functionCallCode = this.generateFunctionCallExpression(node.functionCall);
+        return `${objectCode}.${functionCallCode}`;
+    }
+    // Control flow
+    processMatchBlock(node) {
+        const exprCode = this.processNode(node.expression).trim();
+        let result = this.indentStr(`match(${exprCode}) {\n`);
+        this.increaseIndent();
+        for (const caseNode of node.cases) {
+            // Handle comments within cases
+            if (caseNode.type === "comment") {
+                result += this.processComment(caseNode);
+                continue;
+            }
+            // Format case value (pattern)
+            const pattern = caseNode.caseValue === "_"
+                ? "_"
+                : this.processNode(caseNode.caseValue).trim();
+            // Format body (action)
+            const bodyCode = this.processNode(caseNode.body).trim();
+            result += this.indentStr(`${pattern} => ${bodyCode}\n`);
+        }
+        this.decreaseIndent();
+        result += this.indentStr(`}\n`);
+        return result;
+    }
+    processWhileLoop(node) {
+        const conditionCode = this.processNode(node.condition).trim();
+        let result = this.indentStr(`while (${conditionCode}) {\n`);
+        this.increaseIndent();
+        for (const stmt of node.body) {
+            result += this.processNode(stmt);
+        }
+        this.decreaseIndent();
+        result += this.indentStr(`}\n`);
+        return result;
+    }
+    processReturnStatement(node) {
+        const valueCode = this.processNode(node.value).trim();
+        return this.indentStr(`return ${valueCode}\n`);
+    }
+    // Utility methods
+    processComment(node) {
+        return this.indentStr(`// ${node.content}\n`);
+    }
+    processImportStatement(node) {
+        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.indentStr(`node ${nodeName}(${params}) {\n`);
+        this.increaseIndent();
+        this.functionScopedVariables = [...parameters];
+        for (const stmt of body) {
+            result += this.processNode(stmt);
+        }
+        this.functionScopedVariables = [];
+        this.decreaseIndent();
+        result += this.indentStr(`}\n`);
+        return result;
+    }
+    processTool(node) {
+        // For agency code, tools are just functions
+        // No special formatting needed
+        return "";
+    }
+    processUsesTool(node) {
+        // Track tool usage but don't generate code
+        this.toolsUsed.push(node.toolName);
+        return this.indentStr(`+${node.toolName}\n`);
+    }
+    indentStr(str) {
+        return `${this.indent()}${str}`;
+    }
+}
+export function generateAgency(program) {
+    const generator = new AgencyGenerator();
+    return generator.generate(program).output.trim();
+}

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

@@ -3,6 +3,7 @@ import { spawn } from "child_process";
 import * as fs from "fs";
 import { parseAgency } from "../lib/parser.js";
 import { generateGraph } from "../lib/index.js";
+import { generateAgency } from "../lib/backends/agencyGenerator.js";
 function help() {
     console.log(`
 Agency Language CLI
@@ -11,6 +12,8 @@ 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 parse <input>                  Parse .agency file and show AST
   agency <input>                        Compile and run .agency file (shorthand)
 
 Arguments:
@@ -18,32 +21,39 @@ Arguments:
   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
   agency script.agency                  Compile and run (shorthand)
 `);
 }
-function compile(inputFile, outputFile) {
+function parse(inputFile, verbose = false) {
     // 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);
+    const parseResult = parseAgency(contents, verbose);
     // Check if parsing was successful
     if (!parseResult.success) {
         console.error("Parse error:");
         console.error(parseResult);
         process.exit(1);
     }
-    const parsedProgram = parseResult.result;
+    return parseResult.result;
+}
+function compile(inputFile, outputFile, verbose = false) {
+    // Determine output file name
+    const output = outputFile || inputFile.replace(".agency", ".ts");
+    const parsedProgram = parse(inputFile, verbose);
     // Generate TypeScript code
     const generatedCode = generateGraph(parsedProgram);
     // Write to output file
@@ -51,9 +61,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("---");
@@ -71,6 +81,16 @@ function run(inputFile, outputFile) {
         }
     });
 }
+function format(inputFile, verbose = false) {
+    const parsedProgram = parse(inputFile, verbose);
+    // Generate TypeScript code
+    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() {
     const args = process.argv.slice(2);
@@ -79,7 +99,12 @@ function main() {
         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":
@@ -87,25 +112,43 @@ 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 (filteredArgs.length < 1) {
+                console.error("Error: 'format' command requires an input file");
+                console.error("Usage: agency format <input>");
+                process.exit(1);
+            }
+            format(filteredArgs[1], verbose);
+            break;
+        case "parse":
+            if (filteredArgs.length < 1) {
+                console.error("Error: 'parse' command requires an input file");
+                console.error("Usage: agency parse <input>");
+                process.exit(1);
+            }
+            const result = parse(filteredArgs[1], 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.4",
+  "version": "0.0.6",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
@@ -9,7 +9,8 @@
     "build": "rm -rf dist/ && tsc && tsc-alias",
     "start": "node dist/lib/index.js",
     "templates": "typestache ./lib/templates",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "agency": "node ./dist/scripts/agency.js"
   },
   "bin": {
     "agency": "./dist/scripts/agency.js"
@@ -38,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",