agency-lang 0.0.82 → 0.0.84

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

@@ -1,5 +1,5 @@
 import { SpecialVar } from "../types/specialVar.js";
-import { AgencyComment, AgencyMultiLineComment, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, TypeAlias, TypeHint, VariableType } from "../types.js";
+import { AgencyComment, AgencyMultiLineComment, AgencyNode, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, Scope, ScopeType, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
 import { TimeBlock } from "../types/timeBlock.js";
 import { AccessChainElement, ValueAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
@@ -12,25 +12,55 @@ import { ReturnStatement } from "../types/returnStatement.js";
 import { UsesTool } from "../types/tools.js";
 import { ForLoop } from "../types/forLoop.js";
 import { WhileLoop } from "../types/whileLoop.js";
-import { BaseGenerator } from "./baseGenerator.js";
 import { AgencyConfig } from "../config.js";
 import { MessageThread } from "../types/messageThread.js";
 import { Skill } from "../types/skill.js";
-import { BinOpExpression } from "../types/binop.js";
+import { BinOpArgument, BinOpExpression, Operator } from "../types/binop.js";
 import { Keyword } from "../types/keyword.js";
-export declare class AgencyGenerator extends BaseGenerator {
+export declare class AgencyGenerator {
+    protected typeHints: TypeHintMap;
+    protected graphNodes: GraphNodeDefinition[];
+    protected generatedStatements: string[];
+    protected generatedTypeAliases: string[];
+    protected typeAliases: Record<string, VariableType>;
+    protected functionsUsed: Set<string>;
+    protected importStatements: string[];
+    protected importedNodes: ImportNodeStatement[];
+    protected importedTools: ImportToolStatement[];
+    protected functionDefinitions: Record<string, FunctionDefinition>;
+    protected currentScope: Scope[];
+    protected program: AgencyProgram | null;
+    protected agencyConfig: AgencyConfig;
     private indentLevel;
     private indentSize;
     constructor(args?: {
         config?: AgencyConfig;
     });
-    private indent;
-    private increaseIndent;
-    private decreaseIndent;
+    configDefaults(): Partial<AgencyConfig>;
+    generate(program: AgencyProgram): {
+        output: string;
+    };
+    addIfNonEmpty(str: string, lines: string[]): void;
+    protected preprocessAST(): void;
     protected generateBuiltins(): string;
     protected generateImports(): string;
     protected preprocess(): string;
     protected postprocess(): string;
+    protected collectFunctionSignature(node: FunctionDefinition): void;
+    protected processGraphNodeName(node: GraphNodeDefinition): void;
+    protected processNode(node: AgencyNode): string;
+    protected needsParensLeft(child: BinOpArgument, parentOp: Operator): boolean;
+    protected needsParensRight(child: BinOpArgument, parentOp: Operator): boolean;
+    protected startScope(scope: Scope): void;
+    protected endScope(): void;
+    protected getCurrentScope(): Scope;
+    protected scopetoString(scope: ScopeType, varName?: string): string;
+    protected isImportedTool(functionName: string): boolean;
+    protected isAgencyFunction(functionName: string, context: "valueAccess" | "functionArg" | "topLevelStatement"): boolean;
+    private indent;
+    private increaseIndent;
+    private decreaseIndent;
+    private indentStr;
     private stringifyProp;
     protected aliasedTypeToString(aliasedType: VariableType): string;
     protected processTypeAlias(node: TypeAlias): string;
@@ -65,7 +95,6 @@ export declare class AgencyGenerator extends BaseGenerator {
     protected processTool(node: FunctionDefinition): string;
     protected processUsesTool(node: UsesTool): string;
     protected processSpecialVar(node: SpecialVar): string;
-    private indentStr;
     protected processNewLine(_node: NewLine): string;
     protected processMessageThread(node: MessageThread): string;
     protected processSkill(node: Skill): string;

package/dist/lib/backends/agencyGenerator.js

@@ -1,22 +1,93 @@
-import { BaseGenerator } from "./baseGenerator.js";
 import { variableTypeToString } from "./typescriptGenerator/typeToString.js";
+import { BUILTIN_VARIABLES } from "../config.js";
+import { mergeDeep } from "../utils.js";
+import { PRECEDENCE, } from "../types/binop.js";
 import { expressionToString } from "../utils/node.js";
-export class AgencyGenerator extends BaseGenerator {
+export class AgencyGenerator {
+    typeHints = {};
+    graphNodes = [];
+    generatedStatements = [];
+    generatedTypeAliases = [];
+    typeAliases = {};
+    functionsUsed = new Set();
+    importStatements = [];
+    importedNodes = [];
+    importedTools = [];
+    functionDefinitions = {};
+    currentScope = [{ type: "global" }];
+    program = null;
+    agencyConfig = {};
     indentLevel = 0;
     indentSize = 2;
     constructor(args = {}) {
-        super(args);
-    }
-    indent(level = this.indentLevel) {
-        return " ".repeat(level * this.indentSize);
-    }
-    increaseIndent() {
-        this.indentLevel++;
+        this.agencyConfig = mergeDeep(this.configDefaults(), args.config || {});
+        if (this.agencyConfig.verbose) {
+            console.log("Generator config:", this.agencyConfig);
+        }
     }
-    decreaseIndent() {
-        this.indentLevel--;
+    configDefaults() {
+        return {};
     }
-    // Lifecycle methods
+    generate(program) {
+        this.program = program;
+        // Pass 1: Collect all type aliases
+        for (const node of program.nodes) {
+            if (node.type === "typeAlias") {
+                this.processTypeAlias(node);
+            }
+        }
+        // Pass 2: Collect all type hints
+        for (const node of program.nodes) {
+            if (node.type === "typeHint") {
+                this.processTypeHint(node);
+            }
+        }
+        // Pass 3: Collect all node names
+        for (const node of program.nodes) {
+            if (node.type === "graphNode") {
+                this.processGraphNodeName(node);
+            }
+        }
+        // Pass 4: Collect all node and tool imports
+        for (const node of program.nodes) {
+            if (node.type === "importNodeStatement") {
+                this.importedNodes.push(node);
+            }
+            else if (node.type === "importToolStatement") {
+                this.importedTools.push(node);
+            }
+        }
+        // Pass 5: Generate code for tools
+        for (const node of program.nodes) {
+            if (node.type === "function") {
+                this.generatedStatements.push(this.processTool(node));
+                this.collectFunctionSignature(node);
+            }
+        }
+        this.preprocessAST();
+        // Pass 7: Process all nodes and generate code
+        for (const node of program.nodes) {
+            const result = this.processNode(node);
+            this.generatedStatements.push(result);
+        }
+        const output = [];
+        this.addIfNonEmpty(this.preprocess(), output);
+        this.addIfNonEmpty(this.importStatements.join("\n"), output);
+        this.addIfNonEmpty(this.generateImports(), output);
+        this.addIfNonEmpty(this.generateBuiltins(), output);
+        output.push(...this.generatedTypeAliases);
+        output.push(this.generatedStatements.join(""));
+        this.addIfNonEmpty(this.postprocess(), output);
+        return {
+            output: output.join("\n"),
+        };
+    }
+    addIfNonEmpty(str, lines) {
+        if (str.trim() !== "") {
+            lines.push(str);
+        }
+    }
+    preprocessAST() { }
     generateBuiltins() {
         return "";
     }
@@ -29,8 +100,147 @@ export class AgencyGenerator extends BaseGenerator {
     postprocess() {
         return "";
     }
+    collectFunctionSignature(node) {
+        this.functionDefinitions[node.functionName] = node;
+    }
+    processGraphNodeName(node) { }
+    processNode(node) {
+        switch (node.type) {
+            case "typeHint":
+                return this.processTypeHint(node);
+            case "typeAlias":
+                return this.processTypeAlias(node);
+            case "assignment":
+                return this.processAssignment(node);
+            case "function":
+                return this.processFunctionDefinition(node);
+            case "functionCall":
+                return this.processFunctionCall(node);
+            case "valueAccess":
+                return this.processValueAccess(node);
+            case "comment":
+                return this.processComment(node);
+            case "multiLineComment":
+                return this.processMultiLineComment(node);
+            case "matchBlock":
+                return this.processMatchBlock(node);
+            case "number":
+            case "multiLineString":
+            case "string":
+            case "variableName":
+            case "prompt":
+            case "boolean":
+                return this.generateLiteral(node);
+            case "returnStatement":
+                return this.processReturnStatement(node);
+            case "agencyArray":
+                return this.processAgencyArray(node);
+            case "agencyObject":
+                return this.processAgencyObject(node);
+            case "graphNode":
+                return this.processGraphNode(node);
+            case "usesTool":
+                return this.processUsesTool(node);
+            case "importStatement":
+                this.importStatements.push(this.processImportStatement(node));
+                return "";
+            case "importNodeStatement":
+                this.importStatements.push(this.processImportNodeStatement(node));
+                return "";
+            case "importToolStatement":
+                this.importStatements.push(this.processImportToolStatement(node));
+                return "";
+            case "forLoop":
+                return this.processForLoop(node);
+            case "whileLoop":
+                return this.processWhileLoop(node);
+            case "ifElse":
+                return this.processIfElse(node);
+            case "specialVar":
+                return this.processSpecialVar(node);
+            case "timeBlock":
+                return this.processTimeBlock(node);
+            case "newLine":
+                return this.processNewLine(node);
+            case "rawCode":
+                return node.value;
+            case "messageThread":
+                return this.processMessageThread(node);
+            case "skill":
+                return this.processSkill(node);
+            case "binOpExpression":
+                return this.processBinOpExpression(node);
+            case "keyword":
+                return this.processKeyword(node);
+            default:
+                throw new Error(`Unhandled Agency node type: ${node.type}`);
+        }
+    }
+    needsParensLeft(child, parentOp) {
+        if (child.type !== "binOpExpression")
+            return false;
+        return PRECEDENCE[child.operator] < PRECEDENCE[parentOp];
+    }
+    needsParensRight(child, parentOp) {
+        if (child.type !== "binOpExpression")
+            return false;
+        return PRECEDENCE[child.operator] <= PRECEDENCE[parentOp];
+    }
+    startScope(scope) {
+        this.currentScope.push(scope);
+    }
+    endScope() {
+        this.currentScope.pop();
+    }
+    getCurrentScope() {
+        return this.currentScope[this.currentScope.length - 1];
+    }
+    scopetoString(scope, varName) {
+        if (varName && BUILTIN_VARIABLES.includes(varName)) {
+            return "";
+        }
+        switch (scope) {
+            case "global":
+                return "__globalCtx.stateStack.globals";
+            case "function":
+            case "node":
+                return "__stack.locals";
+            case "args":
+                return "__stack.args";
+            case "imported":
+                return "";
+            default:
+                throw new Error(`Unknown scope type: ${scope} for varName: ${varName}`);
+        }
+    }
+    isImportedTool(functionName) {
+        return this.importedTools
+            .map((node) => node.importedTools)
+            .flat()
+            .includes(functionName);
+    }
+    isAgencyFunction(functionName, context) {
+        if (context === "valueAccess") {
+            return false;
+        }
+        return (!!this.functionDefinitions[functionName] ||
+            this.isImportedTool(functionName));
+    }
+    // Indent helpers
+    indent(level = this.indentLevel) {
+        return " ".repeat(level * this.indentSize);
+    }
+    increaseIndent() {
+        this.indentLevel++;
+    }
+    decreaseIndent() {
+        this.indentLevel--;
+    }
+    indentStr(str) {
+        return `${this.indent()}${str}`;
+    }
+    // Type system methods
     stringifyProp(prop) {
-        // if value is a union containing undefined, render as ?:
         const isUnionWithUndefined = prop.value.type === "unionType" &&
             prop.value.types.some((t) => t.type === "primitiveType" && t.value === "undefined");
         if (isUnionWithUndefined) {
@@ -66,7 +276,6 @@ export class AgencyGenerator extends BaseGenerator {
         }
         return variableTypeToString(aliasedType, this.typeAliases);
     }
-    // Type system methods
     processTypeAlias(node) {
         this.typeAliases[node.aliasName] = node.aliasedType;
         const aliasedTypeStr = this.aliasedTypeToString(node.aliasedType);
@@ -85,12 +294,13 @@ export class AgencyGenerator extends BaseGenerator {
         const varName = node.typeHint
             ? `${node.variableName}${chainStr}: ${variableTypeToString(node.typeHint, this.typeAliases)}`
             : `${node.variableName}${chainStr}`;
+        const prefix = node.shared ? "shared " : "";
         if (node.value.type === "timeBlock") {
             const code = this.processTimeBlock(node.value);
-            return this.indentStr(`${varName} = ${code.trim()}\n`);
+            return this.indentStr(`${prefix}${varName} = ${code.trim()}\n`);
         }
         let valueCode = this.processNode(node.value).trim();
-        return this.indentStr(`${varName} = ${valueCode}`);
+        return this.indentStr(`${prefix}${varName} = ${valueCode}`);
     }
     processTimeBlock(node) {
         this.increaseIndent();
@@ -168,21 +378,17 @@ export class AgencyGenerator extends BaseGenerator {
             }
         }
         result += '"""';
-        //console.log(color.green(result));
         return result
             .split("\n")
             .map((line) => this.indentStr(line))
             .join("\n");
     }
     processPromptLiteral(variableName, variableType, 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
             .map((p) => {
             if (p.typeHint) {
@@ -204,13 +410,10 @@ export class AgencyGenerator extends BaseGenerator {
         else if (node.async === false) {
             asyncPrefix = "sync ";
         }
-        // Start function definition
         let result = this.indentStr(`${asyncPrefix}def ${functionName}(${params})${returnTypeStr} {\n`);
-        // Process body with increased indentation
         this.increaseIndent();
         if (node.docString) {
             const docLines = [`"""`, ...node.docString.value.split("\n"), `"""`];
-            //console.log(color.red(JSON.stringify(docLines)));
             const docStr = docLines.map((line) => this.indentStr(line)).join("\n");
             result += `${docStr}\n`;
         }
@@ -221,7 +424,6 @@ export class AgencyGenerator extends BaseGenerator {
         const bodyCode = lines.join("").trimEnd() + "\n";
         result += bodyCode;
         this.decreaseIndent();
-        // Close function
         result += this.indentStr(`}`);
         return result;
     }
@@ -298,16 +500,13 @@ export class AgencyGenerator extends BaseGenerator {
         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`);
         }
@@ -353,7 +552,6 @@ export class AgencyGenerator extends BaseGenerator {
         lines.push(bodyLines.join("").trimEnd() + "\n");
         if (node.elseBody && node.elseBody.length > 0) {
             if (node.elseBody.length === 1 && node.elseBody[0].type === "ifElse") {
-                // Emit "} else if (...)" instead of "} else { if (...) }"
                 const elseIfCode = this.processIfElse(node.elseBody[0]);
                 lines.push(this.indentStr(`} else ${elseIfCode.trimStart()}`));
                 return lines.join("");
@@ -417,7 +615,6 @@ export class AgencyGenerator extends BaseGenerator {
         }
     }
     processGraphNode(node) {
-        // Graph nodes use similar syntax to functions
         const { nodeName, body, parameters } = node;
         const params = parameters
             .map((p) => p.typeHint
@@ -441,8 +638,6 @@ export class AgencyGenerator extends BaseGenerator {
         return result;
     }
     processTool(node) {
-        // For agency code, tools are just functions
-        // No special formatting needed
         return "";
     }
     processUsesTool(node) {
@@ -451,9 +646,6 @@ export class AgencyGenerator extends BaseGenerator {
     processSpecialVar(node) {
         return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}`);
     }
-    indentStr(str) {
-        return `${this.indent()}${str}`;
-    }
     processNewLine(_node) {
         return "\n";
     }

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

@@ -1,2 +1 @@
-export * from "./baseGenerator.js";
 export * from "./typescriptGenerator.js";

package/dist/lib/backends/index.js

@@ -1,2 +1 @@
-export * from "./baseGenerator.js";
 export * from "./typescriptGenerator.js";

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

@@ -0,0 +1,87 @@
+import { AgencyProgram } from "../types.js";
+import { AgencyConfig } from "../config.js";
+import type { TsNode } from "../ir/tsIR.js";
+import type { ProgramInfo } from "../programInfo.js";
+export declare class TypeScriptBuilder {
+    private typeHints;
+    private typeAliases;
+    private graphNodes;
+    private generatedStatements;
+    private generatedTypeAliases;
+    private importStatements;
+    private importedNodes;
+    private importedTools;
+    private functionDefinitions;
+    private functionsUsed;
+    private currentScope;
+    private agencyConfig;
+    private adjacentNodes;
+    private currentAdjacentNodes;
+    private isInsideGraphNode;
+    private parallelThreadVars;
+    private loopVars;
+    private safeFunctions;
+    private importedFunctions;
+    private programInfo;
+    constructor(config: AgencyConfig | undefined, info: ProgramInfo);
+    private configDefaults;
+    /** Convert a TsNode to string (for use in template-based methods) */
+    private str;
+    private startScope;
+    private endScope;
+    private getCurrentScope;
+    private scopetoString;
+    private isImportedTool;
+    private isAgencyFunction;
+    private isGraphNode;
+    private isImpureImportedFunction;
+    private containsImpureCall;
+    private getScopeReturnType;
+    private agencyFileToDefaultImportName;
+    private needsParensLeft;
+    private needsParensRight;
+    build(program: AgencyProgram): TsNode;
+    private processNode;
+    private processTypeAlias;
+    private processTypeHint;
+    private processComment;
+    private processAgencyObject;
+    private processAgencyArray;
+    private generateLiteral;
+    private generateStringLiteralNode;
+    private processValueAccess;
+    private processBinOpExpression;
+    private processIfElse;
+    private processForLoop;
+    private processWhileLoop;
+    private processMatchBlock;
+    private processImportStatement;
+    private processImportNodeStatement;
+    private processImportToolStatement;
+    private processUsesTool;
+    private processTool;
+    private processFunctionDefinition;
+    private processStatement;
+    private processFunctionCallAsStatement;
+    private processFunctionCall;
+    private generateFunctionCallExpression;
+    private generateNodeCallExpression;
+    private processGraphNode;
+    private processReturnStatement;
+    private processAssignment;
+    private renderAccessChain;
+    private buildAccessChain;
+    private buildAssignmentLhs;
+    private processPromptLiteral;
+    private generatePromptFunction;
+    private buildPromptString;
+    private processSpecialVar;
+    private processTimeBlock;
+    private processMessageThread;
+    private processParallelThread;
+    private processBodyAsParts;
+    private generateBuiltins;
+    private generateImports;
+    private preprocess;
+    private postprocess;
+}

package/dist/lib/backends/typescriptBuilder.integration.test.d.ts

@@ -0,0 +1 @@
+export declare function generateWithBuilder(agencySource: string): string;

package/dist/lib/backends/typescriptBuilder.integration.test.js

@@ -0,0 +1,95 @@
+import { describe, it, expect } from "vitest";
+import { parseAgency } from "../parser.js";
+import { TypeScriptBuilder } from "./typescriptBuilder.js";
+import { TypescriptPreprocessor } from "../preprocessors/typescriptPreprocessor.js";
+import { collectProgramInfo } from "../programInfo.js";
+import { printTs } from "../ir/prettyPrint.js";
+import fs from "fs";
+import path from "path";
+function discoverFixtures(fixtureDir) {
+    const fixtures = [];
+    function scanDirectory(dir, relativePath = "") {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relPath = relativePath
+                ? `${relativePath}/${entry.name}`
+                : entry.name;
+            if (entry.isDirectory()) {
+                scanDirectory(fullPath, relPath);
+            }
+            else if (entry.isFile() && entry.name.endsWith(".agency")) {
+                const baseName = entry.name.replace(".agency", "");
+                const mtsPath = path.join(dir, `${baseName}.mjs`);
+                if (fs.existsSync(mtsPath)) {
+                    const nameWithoutExt = relativePath
+                        ? `${relativePath}/${baseName}`
+                        : baseName;
+                    try {
+                        fixtures.push({
+                            name: nameWithoutExt,
+                            agencyPath: fullPath,
+                            mtsPath: mtsPath,
+                            agencyContent: fs.readFileSync(fullPath, "utf-8"),
+                            expectedTS: fs.readFileSync(mtsPath, "utf-8"),
+                        });
+                    }
+                    catch (error) {
+                        console.error(`Cannot read fixture ${fullPath}: ${error instanceof Error ? error.message : String(error)}`);
+                    }
+                }
+                else {
+                    console.warn(`Warning: No corresponding .mjs file for ${fullPath}`);
+                }
+            }
+        }
+    }
+    scanDirectory(fixtureDir);
+    return fixtures.sort((a, b) => a.name.localeCompare(b.name));
+}
+function normalizeWhitespace(code) {
+    return (code
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((line) => line.trimEnd())
+        .join("\n")
+        .replace(/\n\n\n+/g, "\n\n")
+        .trim()
+        .concat("\n"));
+}
+export function generateWithBuilder(agencySource) {
+    const parseResult = parseAgency(agencySource);
+    if (!parseResult.success) {
+        throw new Error(`Failed to parse: ${parseResult.message}`);
+    }
+    const info = collectProgramInfo(parseResult.result);
+    const preprocessor = new TypescriptPreprocessor(parseResult.result, {}, info);
+    const preprocessedProgram = preprocessor.preprocess();
+    const builder = new TypeScriptBuilder(undefined, info);
+    const ir = builder.build(preprocessedProgram);
+    return printTs(ir);
+}
+const FIXTURES_DIR = path.resolve(__dirname, "../../tests/typescriptBuilder");
+describe("TypeScript Builder Integration Tests", () => {
+    const fixtures = discoverFixtures(FIXTURES_DIR);
+    if (fixtures.length === 0) {
+        it("should find test fixtures (add .agency + .mjs pairs to tests/typescriptBuilder/)", () => {
+            // No fixtures yet — this is expected initially.
+            // Add .agency files and run `make builder-fixtures` to generate .mjs files.
+            expect(true).toBe(true);
+        });
+        return;
+    }
+    describe.each(fixtures)("Fixture: $name", ({ name, agencyPath, agencyContent, expectedTS }) => {
+        it("should generate correct TypeScript output", () => {
+            let generatedTS;
+            try {
+                generatedTS = generateWithBuilder(agencyContent);
+            }
+            catch (error) {
+                throw new Error(`Failed to generate TypeScript for fixture: ${name}\nFile: ${agencyPath}\nError: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            expect(normalizeWhitespace(generatedTS)).toBe(normalizeWhitespace(expectedTS));
+        });
+    });
+});