agency-lang 0.0.56 → 0.0.58

package/README.md

@@ -25,7 +25,7 @@ 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 piemachine statelog-client zod
+pnpm i nanoid openai piemachine statelog-client zod smoltalk
 ```
 
 ## troubleshooting

package/dist/lib/backends/agencyGenerator.js

@@ -186,14 +186,12 @@ export class AgencyGenerator extends BaseGenerator {
                 .join("\n");
             result += `${docLines}\n`;
         }
-        this.functionScopedVariables = [...parameters.map((p) => p.name)];
         const lines = [];
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
         }
         const bodyCode = lines.join("").trimEnd() + "\n";
         result += bodyCode;
-        this.functionScopedVariables = [];
         this.decreaseIndent();
         // Close function
         result += this.indentStr(`}`);
@@ -365,14 +363,12 @@ export class AgencyGenerator extends BaseGenerator {
             : "";
         let result = this.indentStr(`node ${nodeName}(${params})${returnTypeStr} {\n`);
         this.increaseIndent();
-        this.functionScopedVariables = parameters.map((p) => p.name);
         const lines = [];
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
         }
         const bodyCode = lines.join("").trimEnd() + "\n";
         result += bodyCode;
-        this.functionScopedVariables = [];
         this.decreaseIndent();
         result += this.indentStr(`}`);
         return result;

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

@@ -1,5 +1,5 @@
 import { SpecialVar } from "../types/specialVar.js";
-import { AgencyComment, AgencyNode, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
+import { AgencyComment, AgencyNode, AgencyProgram, Assignment, Literal, NewLine, PromptLiteral, Scope, ScopeType, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
 import { AwaitStatement } from "../types/await.js";
 import { TimeBlock } from "../types/timeBlock.js";
 import { AccessExpression, DotFunctionCall, DotProperty, IndexAccess } from "../types/access.js";
@@ -15,26 +15,11 @@ import { WhileLoop } from "../types/whileLoop.js";
 import { AgencyConfig } from "../config.js";
 import { MessageThread } from "../types/messageThread.js";
 import { Skill } from "../types/skill.js";
-type Scope = GlobalScope | FunctionScope | NodeScope;
-type GlobalScope = {
-    type: "global";
-};
-type FunctionScope = {
-    type: "function";
-    functionName: string;
-};
-type NodeScope = {
-    type: "node";
-    nodeName: string;
-};
 export declare class BaseGenerator {
     protected typeHints: TypeHintMap;
     protected graphNodes: GraphNodeDefinition[];
     protected generatedStatements: string[];
     protected generatedTypeAliases: string[];
-    protected functionScopedVariables: string[];
-    protected globalScopedVariables: string[];
-    protected functionParameters: string[];
     protected typeAliases: Record<string, VariableType>;
     protected functionsUsed: Set<string>;
     protected importStatements: string[];
@@ -94,9 +79,7 @@ export declare class BaseGenerator {
     protected startScope(scope: Scope): void;
     protected endScope(): void;
     protected getCurrentScope(): Scope;
-    protected getScopeVar(): string;
-    protected generateScopedVariableName(variableName: string): string;
+    protected scopetoString(scope: ScopeType): string;
     protected isImportedTool(functionName: string): boolean;
     protected isAgencyFunction(functionName: string): boolean;
 }
-export {};

package/dist/lib/backends/baseGenerator.js

@@ -4,9 +4,6 @@ export class BaseGenerator {
     graphNodes = [];
     generatedStatements = [];
     generatedTypeAliases = [];
-    functionScopedVariables = [];
-    globalScopedVariables = [];
-    functionParameters = [];
     typeAliases = {};
     // collect functions used to see what builtin helpers to include
     functionsUsed = new Set();
@@ -64,12 +61,6 @@ export class BaseGenerator {
                 this.collectFunctionSignature(node);
             }
         }
-        // Pass 6: Collect global scoped variables
-        for (const node of program.nodes) {
-            if (node.type === "assignment") {
-                this.globalScopedVariables.push(node.variableName);
-            }
-        }
         /* For each function, mark whether it is async or not.
            A function has to be run synchronously if
            - it or any of its child functions could throw an interrupt
@@ -294,31 +285,19 @@ export class BaseGenerator {
     getCurrentScope() {
         return this.currentScope[this.currentScope.length - 1];
     }
-    /* This function is used during assignment, so we can figure out whether this variable
-    should be assigned on local or global scope. There's a related function `generateScopedVariableName`,
-    which is used when retrieving the value of a variable. */
-    getScopeVar() {
-        const currentScope = this.getCurrentScope();
-        switch (currentScope.type) {
+    scopetoString(scope) {
+        switch (scope) {
             case "global":
                 return "__stateStack.globals";
             case "function":
             case "node":
                 return "__stack.locals";
+            case "args":
+                return "__stack.args";
+            default:
+                throw new Error(`Unknown scope type: ${scope}`);
         }
     }
-    generateScopedVariableName(variableName) {
-        if (this.functionParameters.includes(variableName)) {
-            return `__stack.args.${variableName}`;
-        }
-        if (this.functionScopedVariables.includes(variableName)) {
-            return `__stack.locals.${variableName}`;
-        }
-        else if (this.globalScopedVariables.includes(variableName)) {
-            return `__stateStack.globals.${variableName}`;
-        }
-        return variableName;
-    }
     isImportedTool(functionName) {
         return this.importedTools
             .map((node) => node.importedTools)

package/dist/lib/backends/graphGenerator.js

@@ -22,11 +22,6 @@ export class GraphGenerator extends TypeScriptGenerator {
     }
     configDefaults() {
         return {
-            log: {
-                host: "https://statelog.adit.io",
-                projectId: "agency-lang",
-                debugMode: false,
-            },
             client: {
                 logLevel: "warn",
                 defaultModel: "gpt-4o-mini",
@@ -61,18 +56,13 @@ export class GraphGenerator extends TypeScriptGenerator {
         } */
         this.adjacentNodes[nodeName] = [];
         this.currentAdjacentNodes = [];
-        this.functionParameters = [];
         this.isInsideGraphNode = true;
-        for (const param of parameters) {
-            this.functionParameters.push(param.name);
-        }
         for (const stmt of body) {
             if (stmt.type === "functionCall" && this.isGraphNode(stmt.functionName)) {
                 throw new Error(`Call to graph node '${stmt.functionName}' inside graph node '${nodeName}' was not returned. All calls to graph nodes must be returned, eg (return ${stmt.functionName}(...)).`);
             }
         }
         const bodyCode = this.processBodyAsParts(body);
-        this.functionParameters = [];
         this.adjacentNodes[nodeName] = [...this.currentAdjacentNodes];
         this.isInsideGraphNode = false;
         this.endScope();

package/dist/lib/backends/typescriptGenerator.js

@@ -132,13 +132,7 @@ export class TypeScriptGenerator extends BaseGenerator {
     }
     processAssignment(node) {
         const { variableName, typeHint, value } = node;
-        const _currentScope = this.getCurrentScope();
-        if (_currentScope.type === "global") {
-            this.globalScopedVariables.push(variableName);
-        }
-        else {
-            this.functionScopedVariables.push(variableName);
-        }
+        const scopeVar = this.scopetoString(node.scope);
         const typeAnnotation = "";
         if (value.type === "prompt") {
             return this.processPromptLiteral(variableName, typeHint, value);
@@ -147,7 +141,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             // Direct assignment for other literal types
             const code = this.processNode(value);
             return renderFunctionCallAssignment.default({
-                variableName: `${this.getScopeVar()}.${variableName}`,
+                variableName: `${scopeVar}.${variableName}`,
                 functionCode: code.trim(),
                 nodeContext: this.getCurrentScope().type === "node",
                 globalScope: this.getCurrentScope().type === "global",
@@ -159,14 +153,13 @@ export class TypeScriptGenerator extends BaseGenerator {
             return code;
         }
         else if (value.type === "messageThread") {
-            const varName = `${this.getScopeVar()}.${variableName}`;
+            const varName = `${scopeVar}.${variableName}`;
             return this.processMessageThread(value, varName);
         }
         else {
             // Direct assignment for other literal types
             const code = this.processNode(value);
-            return (`${this.getScopeVar()}.${variableName}${typeAnnotation} = ${code.trim()};` +
-                "\n");
+            return (`${scopeVar}.${variableName}${typeAnnotation} = ${code.trim()};` + "\n");
         }
     }
     /*
@@ -240,11 +233,7 @@ export class TypeScriptGenerator extends BaseGenerator {
         this.startScope({ type: "function", functionName: node.functionName });
         const { functionName, body, parameters } = node;
         const args = parameters.map((p) => p.name);
-        this.functionScopedVariables = [...parameters.map((p) => p.name)];
-        this.functionParameters = args;
         const bodyCode = this.processBodyAsParts(body);
-        this.functionScopedVariables = [];
-        this.functionParameters = [];
         this.endScope();
         const argsStr = args.map((arg) => `"${arg}"`).join(", ") || "";
         return renderFunctionDefinition.default({
@@ -318,7 +307,7 @@ export class TypeScriptGenerator extends BaseGenerator {
             case "multiLineString":
                 return this.generateStringLiteral(literal.segments);
             case "variableName":
-                return this.generateScopedVariableName(literal.value);
+                return `${this.scopetoString(literal.scope)}.${literal.value}`;
             case "prompt":
                 return this.processPromptLiteral(DEFAULT_PROMPT_NAME, this.getScopeReturnType(), literal);
         }
@@ -393,7 +382,11 @@ export class TypeScriptGenerator extends BaseGenerator {
             }
             else {
                 // Interpolation segment
-                stringParts.push("${" + this.generateScopedVariableName(segment.variableName) + "}");
+                stringParts.push("${" +
+                    this.scopetoString(segment.scope) +
+                    "." +
+                    segment.variableName +
+                    "}");
             }
         }
         return "`" + stringParts.join("") + "`";
@@ -461,7 +454,14 @@ export class TypeScriptGenerator extends BaseGenerator {
         const metadataObj = `{
       messages: __self.messages_${this.currentMessageThreadNodeId.at(-1)}.getMessages(),
     }`;
-        const scopedFunctionArgs = functionArgs.map((arg) => this.generateScopedVariableName(arg));
+        const scopedFunctionArgs = functionArgs.map((arg) => {
+            // Find the scope for this interpolated variable from the prompt segments
+            const interpSegment = prompt.segments.find((s) => s.type === "interpolation" && s.variableName === arg);
+            const scope = interpSegment?.type === "interpolation"
+                ? interpSegment.scope
+                : undefined;
+            return `${this.scopetoString(scope)}.${arg}`;
+        });
         return promptFunction.default({
             variableName,
             argsStr,

package/dist/lib/cli/commands.js

@@ -6,6 +6,7 @@ import { spawn } from "child_process";
 import * as fs from "fs";
 import * as path from "path";
 import { parseAgency } from "../parser.js";
+import { findRecursively } from "./util.js";
 // Load configuration from agency.json
 export function loadConfig(configPath, verbose = false) {
     let config = {};
@@ -94,31 +95,13 @@ export function getImports(program) {
     return [...toolAndNodeImports, ...importStatements];
 }
 const compiledFiles = new Set();
-const dirSearched = new Set();
 export function compile(config, inputFile, _outputFile) {
     // Check if the input is a directory
     const stats = fs.statSync(inputFile);
     const verbose = config.verbose ?? false;
     if (stats.isDirectory()) {
-        dirSearched.add(path.resolve(inputFile));
-        // Find all .agency files in the directory
-        const files = fs.readdirSync(inputFile);
-        const agencyFiles = files.filter((file) => file.endsWith(".agency"));
-        for (const file of agencyFiles) {
-            const fullPath = path.join(inputFile, file);
-            compile(config, fullPath, undefined);
-        }
-        // Find all subdirectories and compile their .agency files
-        const subdirs = files.filter((file) => {
-            const fullPath = path.join(inputFile, file);
-            return fs.statSync(fullPath).isDirectory();
-        });
-        for (const subdir of subdirs) {
-            const fullSubdirPath = path.join(inputFile, subdir);
-            const resolvedSubdirPath = path.resolve(fullSubdirPath);
-            if (!dirSearched.has(resolvedSubdirPath)) {
-                compile(config, fullSubdirPath, undefined);
-            }
+        for (const { path } of findRecursively(inputFile)) {
+            compile(config, path, undefined);
         }
         return null;
     }
@@ -188,21 +171,8 @@ export async function format(contents, config) {
 export function formatFile(inputPath, inPlace, config) {
     const stats = fs.statSync(inputPath);
     if (stats.isDirectory()) {
-        // Format all .agency files in directory
-        const files = fs.readdirSync(inputPath);
-        const agencyFiles = files.filter((file) => file.endsWith(".agency"));
-        for (const file of agencyFiles) {
-            const fullPath = path.join(inputPath, file);
-            formatFile(fullPath, inPlace, config);
-        }
-        // Recursively format subdirectories
-        const subdirs = files.filter((file) => {
-            const fullPath = path.join(inputPath, file);
-            return fs.statSync(fullPath).isDirectory();
-        });
-        for (const subdir of subdirs) {
-            const fullSubdirPath = path.join(inputPath, subdir);
-            formatFile(fullSubdirPath, inPlace, config);
+        for (const { path } of findRecursively(inputPath)) {
+            formatFile(path, inPlace, config);
         }
         return;
     }

package/dist/lib/cli/evaluate.d.ts

@@ -1 +1,2 @@
-export declare function evaluate(target?: string, argsFilePath?: string, resultsFilePath?: string): Promise<void>;
+import { AgencyConfig } from "../config.js";
+export declare function evaluate(config: AgencyConfig, target?: string, argsFilePath?: string, resultsFilePath?: string): Promise<void>;

package/dist/lib/cli/evaluate.js

@@ -81,7 +81,7 @@ async function createArgsFileInteractively(filename, selectedNode) {
     console.log(`Args file saved to ${filename}`);
     return argsFile;
 }
-export async function evaluate(target, argsFilePath, resultsFilePath) {
+export async function evaluate(config, target, argsFilePath, resultsFilePath) {
     // A. Resolve target
     let { filename, nodeName } = target
         ? parseTarget(target)
@@ -162,7 +162,13 @@ export async function evaluate(target, argsFilePath, resultsFilePath) {
         const argsString = hasArgs
             ? argsRecordToString(c.args, selectedNode.parameters)
             : "";
-        const json = executeNode(filename, nodeName, hasArgs, argsString, undefined);
+        const json = executeNode({
+            config,
+            agencyFile: filename,
+            nodeName,
+            hasArgs,
+            argsString,
+        });
         console.log("\nOutput:");
         console.log(JSON.stringify(json.data, null, 2));
         const ratingResponse = await prompts({

package/dist/lib/cli/test.d.ts

@@ -1,2 +1,3 @@
-export declare function fixtures(target?: string): Promise<void>;
-export declare function test(testFile?: string): Promise<void>;
+import { AgencyConfig } from "../config.js";
+export declare function fixtures(config: AgencyConfig, target?: string): Promise<void>;
+export declare function test(config: AgencyConfig, testFile: string): Promise<void>;

package/dist/lib/cli/test.js

@@ -2,8 +2,9 @@ import { parseAgency } from "../parser.js";
 import { getNodesOfType } from "../utils/node.js";
 import fs from "fs";
 import prompts from "prompts";
-import { executeJudge, executeNode, parseTarget, pickANode, promptForArgs, promptForTarget, } from "./util.js";
+import { executeJudge, executeNode, findRecursively, parseTarget, pickANode, promptForArgs, promptForTarget, } from "./util.js";
 import { color } from "termcolors";
+import path from "path";
 function readFile(filename) {
     console.log("Trying to read file", filename, "...");
     const data = fs.readFileSync(filename);
@@ -17,7 +18,7 @@ function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluati
         tests = JSON.parse(fs.readFileSync(testFilePath, "utf-8"));
     }
     else {
-        tests = { sourceFile: agencyFilename, tests: [] };
+        tests = { sourceFile: path.basename(agencyFilename), tests: [] };
     }
     const testCase = {
         nodeName,
@@ -32,7 +33,7 @@ function writeTestCase(agencyFilename, nodeName, input, expectedOutput, evaluati
     fs.writeFileSync(testFilePath, JSON.stringify(tests, null, 2));
     return testFilePath;
 }
-export async function fixtures(target) {
+export async function fixtures(config, target) {
     let { filename, nodeName } = target
         ? parseTarget(target)
         : await promptForTarget();
@@ -56,7 +57,13 @@ export async function fixtures(target) {
     const selectedNode = nodes.find((n) => n.nodeName === nodeName);
     let { hasArgs, argsString } = await promptForArgs(selectedNode);
     console.log("Running program from entrypoint", nodeName);
-    let json = executeNode(filename, nodeName, hasArgs, argsString);
+    let json = executeNode({
+        config,
+        agencyFile: filename,
+        nodeName,
+        hasArgs,
+        argsString,
+    });
     // Handle interrupt discovery
     const interruptHandlers = [];
     while (json.data &&
@@ -105,7 +112,14 @@ export async function fixtures(target) {
         }
         interruptHandlers.push(handler);
         // Continue execution with this handler to see if there are more interrupts
-        json = executeNode(filename, nodeName, hasArgs, argsString, interruptHandlers);
+        json = executeNode({
+            config,
+            agencyFile: filename,
+            nodeName,
+            hasArgs,
+            argsString,
+            interruptHandlers,
+        });
     }
     console.log("\nFinal Output:");
     console.log(JSON.stringify(json.data, null, 2));
@@ -166,34 +180,16 @@ export async function fixtures(target) {
     const testFilePath = writeTestCase(filename, nodeName, inputStr, expectedOutput, criteria, interruptHandlers.length > 0 ? interruptHandlers : undefined);
     console.log(`Test case saved to ${testFilePath}`);
 }
-export async function test(testFile) {
-    let selectedFile;
-    if (testFile) {
-        selectedFile = testFile;
-    }
-    else {
-        const testFiles = fs
-            .readdirSync(process.cwd())
-            .filter((file) => file.endsWith(".test.json"))
-            .map((file) => ({
-            title: file,
-            value: file,
-        }));
-        if (testFiles.length === 0) {
-            console.log("No .test.json files found in the current directory.");
-            return;
+export async function test(config, testFile) {
+    const stats = fs.statSync(testFile);
+    if (stats.isDirectory()) {
+        for (const { path } of findRecursively(testFile, ".test.json")) {
+            await test(config, path);
         }
-        const response = await prompts({
-            type: "select",
-            name: "filename",
-            message: "Select a test file to run:",
-            choices: testFiles,
-        });
-        if (!response.filename)
-            return;
-        selectedFile = response.filename;
+        return;
     }
-    const tests = JSON.parse(fs.readFileSync(selectedFile, "utf-8"));
+    console.log(color.yellow(`Running tests for ${testFile}...`));
+    const tests = JSON.parse(fs.readFileSync(testFile, "utf-8"));
     let passed = 0;
     const total = tests.tests.length;
     for (let i = 0; i < total; i++) {
@@ -207,7 +203,15 @@ export async function test(testFile) {
         if (testCase.description) {
             console.log(color.cyan("Description:", testCase.description), "\n");
         }
-        const result = executeNode(tests.sourceFile, testCase.nodeName, hasArgs, testCase.input, testCase.interruptHandlers);
+        const relativeSourceFilePath = path.join(path.dirname(testFile), tests.sourceFile);
+        const result = executeNode({
+            config,
+            agencyFile: relativeSourceFilePath,
+            nodeName: testCase.nodeName,
+            hasArgs,
+            argsString: testCase.input,
+            interruptHandlers: testCase.interruptHandlers,
+        });
         let testPassed = true;
         for (const criterion of testCase.evaluationCriteria) {
             if (criterion.type === "exact") {

package/dist/lib/cli/util.d.ts

@@ -1,4 +1,5 @@
 import { GraphNodeDefinition, VariableType } from "../types.js";
+import { AgencyConfig } from "../config.js";
 export declare function parseTarget(target: string): {
     filename: string;
     nodeName: string;
@@ -12,11 +13,18 @@ export declare function promptForArgs(selectedNode: GraphNodeDefinition): Promis
     hasArgs: boolean;
     argsString: string;
 }>;
-export declare function executeNode(agencyFile: string, nodeName: string, hasArgs: boolean, argsString: string, interruptHandlers?: Array<{
-    action: "approve" | "reject" | "modify";
-    modifiedArgs?: Record<string, any>;
-    expectedMessage?: string;
-}>): {
+export declare function executeNode({ config, agencyFile, nodeName, hasArgs, argsString, interruptHandlers, }: {
+    config: AgencyConfig;
+    agencyFile: string;
+    nodeName: string;
+    hasArgs: boolean;
+    argsString: string;
+    interruptHandlers?: Array<{
+        action: "approve" | "reject" | "modify";
+        modifiedArgs?: Record<string, any>;
+        expectedMessage?: string;
+    }>;
+}): {
     data: any;
     [key: string]: any;
 };
@@ -29,3 +37,6 @@ export declare function executeJudge(actualOutput: string, expectedOutput: strin
     score: number;
     reasoning: string;
 };
+export declare function findRecursively(dirName: string, ext?: string, searched?: string[]): Generator<{
+    path: string;
+}>;

package/dist/lib/cli/util.js

@@ -89,9 +89,9 @@ export async function promptForArgs(selectedNode) {
     }
     return { hasArgs, argsString };
 }
-export function executeNode(agencyFile, nodeName, hasArgs, argsString, interruptHandlers) {
+export function executeNode({ config, agencyFile, nodeName, hasArgs, argsString, interruptHandlers, }) {
     const outFile = agencyFile.replace(".agency", ".js");
-    compile({}, agencyFile, outFile);
+    compile(config, agencyFile);
     const evaluateScript = renderEvaluate({
         filename: outFile,
         nodeName,
@@ -158,3 +158,24 @@ export function executeJudge(actualOutput, expectedOutput, judgePrompt, interrup
     const results = readFileSync("__judge_evaluate.json", "utf-8");
     return JSON.parse(results).data;
 }
+export function* findRecursively(dirName, ext = ".agency", searched = []) {
+    searched.push(path.resolve(dirName));
+    // Find all .agency files in the directory
+    const files = fs.readdirSync(dirName);
+    const filesToProcess = files.filter((file) => {
+        return ((file.endsWith(ext) ||
+            fs.statSync(path.join(dirName, file)).isDirectory()) &&
+            !file.startsWith("."));
+    });
+    for (const file of filesToProcess) {
+        const fullPath = path.join(dirName, file);
+        if (fs.statSync(fullPath).isDirectory()) {
+            if (!searched.includes(path.resolve(fullPath))) {
+                yield* findRecursively(fullPath, ext, searched);
+            }
+        }
+        else {
+            yield { path: fullPath };
+        }
+    }
+}

package/dist/lib/preprocessors/typescriptPreprocessor.d.ts

@@ -90,4 +90,10 @@ export declare class TypescriptPreprocessor {
      * Extract domain from URL string
      */
     protected _extractDomain(url: string): string | null;
+    /**
+     * Resolve variable scopes by annotating AST nodes with their scope.
+     * After this pass, every VariableNameLiteral, InterpolationSegment, and Assignment
+     * will have a `scope` property indicating whether the variable is global, local, or args.
+     */
+    protected resolveVariableScopes(): void;
 }

package/dist/lib/preprocessors/typescriptPreprocessor.js

@@ -25,6 +25,7 @@ export class TypescriptPreprocessor {
         this.filterExcludedBuiltinFunctions();
         this.validateFetchDomains();
         this.addNodeIDsToMessageThreads();
+        this.resolveVariableScopes();
         return this.program;
     }
     addNodeIDsToMessageThreads() {
@@ -903,4 +904,70 @@ export class TypescriptPreprocessor {
             return null; // Invalid URL
         }
     }
+    /**
+     * Resolve variable scopes by annotating AST nodes with their scope.
+     * After this pass, every VariableNameLiteral, InterpolationSegment, and Assignment
+     * will have a `scope` property indicating whether the variable is global, local, or args.
+     */
+    resolveVariableScopes() {
+        const varNameToScope = {};
+        // First, for each variable name, we try to collect its scope.
+        for (const { node, scopes } of walkNodes(this.program.nodes)) {
+            if (scopes.length === 0) {
+                throw new Error(`Top-level nodes should have at least the global scope in their scopes array. Node: ${JSON.stringify({ node })}, scopes: ${JSON.stringify({ scopes })}`);
+            }
+            if (node.type === "assignment") {
+                varNameToScope[node.variableName] = scopes.at(-1)?.type || "global";
+            }
+            else if (node.type === "function" || node.type === "graphNode") {
+                // Parameters are in the function's scope
+                for (const param of node.parameters) {
+                    varNameToScope[param.name] = "args";
+                }
+            }
+            else if (node.type === "importStatement") {
+                // todo imported names need to get parsed better,
+                // into an array
+            }
+            else if (node.type === "importNodeStatement") {
+                node.importedNodes.forEach((n) => {
+                    varNameToScope[n] = "global";
+                });
+            }
+            else if (node.type === "importToolStatement") {
+                node.importedTools.forEach((t) => {
+                    varNameToScope[t] = "global";
+                });
+            }
+        }
+        const lookupScope = (varName) => {
+            if (varName in varNameToScope) {
+                return varNameToScope[varName];
+            }
+            return "global";
+            // TODO enable this
+            /* throw new Error(
+              `Variable "${varName}" is referenced but not defined in any scope.`,
+            ); */
+        };
+        // Then, whenever we see a variable being referenced,
+        // we try to look up its scope and set it on that variable.
+        for (const { node, scopes } of walkNodes(this.program.nodes)) {
+            if (node.type === "assignment") {
+                node.scope = lookupScope(node.variableName);
+            }
+            else if (node.type === "variableName") {
+                node.scope = lookupScope(node.value);
+            }
+            else if (node.type === "prompt" ||
+                node.type === "string" ||
+                node.type === "multiLineString") {
+                node.segments.forEach((seg) => {
+                    if (seg.type === "interpolation") {
+                        seg.scope = lookupScope(seg.variableName);
+                    }
+                });
+            }
+        }
+    }
 }

package/dist/lib/typeChecker.js

@@ -319,22 +319,28 @@ export class TypeChecker {
                 return true;
         }
         // Same kind matching
-        if (resolvedSource.type === "primitiveType" && resolvedTarget.type === "primitiveType") {
+        if (resolvedSource.type === "primitiveType" &&
+            resolvedTarget.type === "primitiveType") {
             return resolvedSource.value === resolvedTarget.value;
         }
-        if (resolvedSource.type === "stringLiteralType" && resolvedTarget.type === "stringLiteralType") {
+        if (resolvedSource.type === "stringLiteralType" &&
+            resolvedTarget.type === "stringLiteralType") {
             return resolvedSource.value === resolvedTarget.value;
         }
-        if (resolvedSource.type === "numberLiteralType" && resolvedTarget.type === "numberLiteralType") {
+        if (resolvedSource.type === "numberLiteralType" &&
+            resolvedTarget.type === "numberLiteralType") {
             return resolvedSource.value === resolvedTarget.value;
         }
-        if (resolvedSource.type === "booleanLiteralType" && resolvedTarget.type === "booleanLiteralType") {
+        if (resolvedSource.type === "booleanLiteralType" &&
+            resolvedTarget.type === "booleanLiteralType") {
             return resolvedSource.value === resolvedTarget.value;
         }
-        if (resolvedSource.type === "arrayType" && resolvedTarget.type === "arrayType") {
+        if (resolvedSource.type === "arrayType" &&
+            resolvedTarget.type === "arrayType") {
             return this.isAssignable(resolvedSource.elementType, resolvedTarget.elementType);
         }
-        if (resolvedSource.type === "objectType" && resolvedTarget.type === "objectType") {
+        if (resolvedSource.type === "objectType" &&
+            resolvedTarget.type === "objectType") {
             // Structural: source must have all properties of target with compatible types
             for (const targetProp of resolvedTarget.properties) {
                 const sourceProp = resolvedSource.properties.find((p) => p.key === targetProp.key);

package/dist/lib/types/literals.d.ts

@@ -1,3 +1,4 @@
+import { ScopeType } from "../types.js";
 import { AgencyObject } from "./dataStructures.js";
 import { Skill } from "./skill.js";
 import { UsesTool } from "./tools.js";
@@ -17,6 +18,7 @@ export type MultiLineStringLiteral = {
 export type VariableNameLiteral = {
     type: "variableName";
     value: string;
+    scope?: ScopeType;
 };
 export type PromptSegment = TextSegment | InterpolationSegment;
 export type TextSegment = {
@@ -26,6 +28,7 @@ export type TextSegment = {
 export type InterpolationSegment = {
     type: "interpolation";
     variableName: string;
+    scope?: ScopeType;
 };
 export type PromptLiteral = {
     type: "prompt";

package/dist/lib/types.d.ts

@@ -2,18 +2,18 @@ import { AccessExpression, 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 { IfElse } from "./types/ifElse.js";
 import { ImportNodeStatement, ImportStatement, ImportToolStatement } from "./types/importStatement.js";
 import { Literal, RawCode } from "./types/literals.js";
 import { MatchBlock } from "./types/matchBlock.js";
+import { MessageThread } from "./types/messageThread.js";
 import { ReturnStatement } from "./types/returnStatement.js";
+import { Skill } from "./types/skill.js";
 import { SpecialVar } from "./types/specialVar.js";
 import { TimeBlock } from "./types/timeBlock.js";
 import { UsesTool } from "./types/tools.js";
 import { TypeAlias, TypeHint, VariableType } from "./types/typeHints.js";
 import { WhileLoop } from "./types/whileLoop.js";
-import { IfElse } from "./types/ifElse.js";
-import { MessageThread } from "./types/messageThread.js";
-import { Skill } from "./types/skill.js";
 export * from "./types/access.js";
 export * from "./types/dataStructures.js";
 export * from "./types/function.js";
@@ -23,18 +23,36 @@ export * from "./types/importStatement.js";
 export * from "./types/literals.js";
 export * from "./types/matchBlock.js";
 export * from "./types/returnStatement.js";
+export * from "./types/specialVar.js";
+export * from "./types/timeBlock.js";
 export * from "./types/tools.js";
 export * from "./types/typeHints.js";
 export * from "./types/whileLoop.js";
-export * from "./types/timeBlock.js";
-export * from "./types/specialVar.js";
-export * from "./types/ifElse.js";
+export type Scope = GlobalScope | FunctionScope | NodeScope;
+export type ScopeType = Scope["type"] | "args";
+export type GlobalScope = {
+    type: "global";
+};
+export type FunctionScope = {
+    type: "function";
+    functionName: string;
+    args?: boolean;
+};
+export type NodeScope = {
+    type: "node";
+    nodeName: string;
+    args?: boolean;
+};
 export type Assignment = {
     type: "assignment";
     variableName: string;
     typeHint?: VariableType;
+    scope?: ScopeType;
     value: AccessExpression | Literal | FunctionCall | AgencyObject | AgencyArray | IndexAccess | TimeBlock | MessageThread;
 };
+export declare function globalScope(): Scope;
+export declare function functionScope(functionName: string, args?: boolean): Scope;
+export declare function nodeScope(nodeName: string, args?: boolean): Scope;
 export type AgencyComment = {
     type: "comment";
     content: string;

package/dist/lib/types.js

@@ -7,9 +7,17 @@ export * from "./types/importStatement.js";
 export * from "./types/literals.js";
 export * from "./types/matchBlock.js";
 export * from "./types/returnStatement.js";
+export * from "./types/specialVar.js";
+export * from "./types/timeBlock.js";
 export * from "./types/tools.js";
 export * from "./types/typeHints.js";
 export * from "./types/whileLoop.js";
-export * from "./types/timeBlock.js";
-export * from "./types/specialVar.js";
-export * from "./types/ifElse.js";
+export function globalScope() {
+    return { type: "global" };
+}
+export function functionScope(functionName, args = false) {
+    return { type: "function", functionName, args };
+}
+export function nodeScope(nodeName, args = false) {
+    return { type: "node", nodeName, args };
+}

package/dist/lib/utils/node.d.ts

@@ -1,10 +1,11 @@
-import { AgencyNode } from "../types.js";
+import { AgencyNode, Scope } from "../types.js";
 export declare function getAllVariablesInBody(body: AgencyNode[]): Generator<{
     name: string;
     node: AgencyNode;
 }>;
 export declare function getNodesOfType<T extends AgencyNode["type"]>(nodes: AgencyNode[], type: T): AgencyNode[];
-export declare function walkNodes(nodes: AgencyNode[], ancestors?: AgencyNode[]): Generator<{
+export declare function walkNodes(nodes: AgencyNode[], ancestors?: AgencyNode[], scopes?: Scope[]): Generator<{
     node: AgencyNode;
     ancestors: AgencyNode[];
+    scopes: Scope[];
 }>;

package/dist/lib/utils/node.js

@@ -1,3 +1,4 @@
+import { functionScope, globalScope, nodeScope, } from "../types.js";
 export function* getAllVariablesInBody(body) {
     for (const { node } of walkNodes(body)) {
         if (node.type === "assignment") {
@@ -19,6 +20,7 @@ export function* getAllVariablesInBody(body) {
             yield* getAllVariablesInBody(node.body);
         }
         else if (node.type === "ifElse") {
+            yield* getAllVariablesInBody([node.condition]);
             yield* getAllVariablesInBody(node.thenBody);
             if (node.elseBody) {
                 yield* getAllVariablesInBody(node.elseBody);
@@ -131,78 +133,84 @@ export function getNodesOfType(nodes, type) {
     }
     return result;
 }
-export function* walkNodes(nodes, ancestors = []) {
+export function* walkNodes(nodes, ancestors = [], scopes = []) {
+    if (scopes.length === 0) {
+        scopes.push(globalScope());
+    }
     for (const node of nodes) {
-        yield { node, ancestors };
+        yield { node, ancestors, scopes };
         if (node.type === "function") {
-            yield* walkNodes(node.body, [...ancestors, node]);
+            yield* walkNodes(node.body, [...ancestors, node], [...scopes, functionScope(node.functionName)]);
         }
         else if (node.type === "graphNode") {
-            yield* walkNodes(node.body, [...ancestors, node]);
+            yield* walkNodes(node.body, [...ancestors, node], [...scopes, nodeScope(node.nodeName)]);
         }
         else if (node.type === "ifElse") {
-            yield* walkNodes(node.thenBody, [...ancestors, node]);
+            yield* walkNodes([node.condition], [...ancestors, node], scopes);
+            yield* walkNodes(node.thenBody, [...ancestors, node], scopes);
             if (node.elseBody) {
-                yield* walkNodes(node.elseBody, [...ancestors, node]);
+                yield* walkNodes(node.elseBody, [...ancestors, node], scopes);
             }
         }
         else if (node.type === "whileLoop") {
-            yield* walkNodes(node.body, [...ancestors, node]);
+            yield* walkNodes([node.condition], [...ancestors, node], scopes);
+            yield* walkNodes(node.body, [...ancestors, node], scopes);
         }
         else if (node.type === "timeBlock") {
-            yield* walkNodes(node.body, [...ancestors, node]);
+            yield* walkNodes(node.body, [...ancestors, node], scopes);
         }
         else if (node.type === "messageThread") {
-            yield* walkNodes(node.body, [...ancestors, node]);
+            yield* walkNodes(node.body, [...ancestors, node], scopes);
         }
         else if (node.type === "returnStatement") {
-            yield* walkNodes([node.value], [...ancestors, node]);
+            yield* walkNodes([node.value], [...ancestors, node], scopes);
         }
         else if (node.type === "assignment") {
-            yield* walkNodes([node.value], [...ancestors, node]);
+            yield* walkNodes([node.value], [...ancestors, node], scopes);
         }
         else if (node.type === "functionCall") {
-            yield* walkNodes(node.arguments, [...ancestors, node]);
+            yield* walkNodes(node.arguments, [...ancestors, node], scopes);
         }
         else if (node.type === "matchBlock") {
+            yield* walkNodes([node.expression], [...ancestors, node], scopes);
             for (const caseItem of node.cases) {
                 if (caseItem.type === "comment")
                     continue;
                 if (caseItem.caseValue !== "_") {
-                    yield* walkNodes([caseItem.caseValue], [...ancestors, node]);
+                    yield* walkNodes([caseItem.caseValue], [...ancestors, node], scopes);
                 }
-                yield* walkNodes([caseItem.body], [...ancestors, node]);
+                yield* walkNodes([caseItem.body], [...ancestors, node], scopes);
             }
         }
         else if (node.type === "accessExpression") {
             const expr = node.expression;
             if (expr.type === "dotProperty") {
-                yield* walkNodes([expr.object], [...ancestors, node]);
+                yield* walkNodes([expr.object], [...ancestors, node], scopes);
             }
             else if (expr.type === "indexAccess") {
-                yield* walkNodes([expr.array], [...ancestors, node]);
-                yield* walkNodes([expr.index], [...ancestors, node]);
+                yield* walkNodes([expr.array], [...ancestors, node], scopes);
+                yield* walkNodes([expr.index], [...ancestors, node], scopes);
             }
             else if (expr.type === "dotFunctionCall") {
-                yield* walkNodes([expr.object], [...ancestors, node]);
-                yield* walkNodes([expr.functionCall], [...ancestors, node]);
+                yield* walkNodes([expr.object], [...ancestors, node], scopes);
+                yield* walkNodes([expr.functionCall], [...ancestors, node], scopes);
             }
         }
         else if (node.type === "dotProperty") {
-            yield* walkNodes([node.object], [...ancestors, node]);
+            yield* walkNodes([node.object], [...ancestors, node], scopes);
         }
         else if (node.type === "indexAccess") {
-            yield* walkNodes([node.array], [...ancestors, node]);
-            yield* walkNodes([node.index], [...ancestors, node]);
+            yield* walkNodes([node.array], [...ancestors, node], scopes);
+            yield* walkNodes([node.index], [...ancestors, node], scopes);
         }
         else if (node.type === "agencyArray") {
-            yield* walkNodes(node.items, [...ancestors, node]);
+            yield* walkNodes(node.items, [...ancestors, node], scopes);
         }
         else if (node.type === "agencyObject") {
-            yield* walkNodes(node.entries.map((e) => e.value), [...ancestors, node]);
+            yield* walkNodes(node.entries.map((e) => e.value), [...ancestors, node], scopes);
         }
         else if (node.type === "specialVar") {
-            yield* walkNodes([node.value], [...ancestors, node]);
+            yield* walkNodes([node.value], [...ancestors, node], scopes);
         }
     }
 }

package/dist/scripts/agency.js

@@ -4,10 +4,11 @@ import { evaluate } from "../lib/cli/evaluate.js";
 import { fixtures, test } from "../lib/cli/test.js";
 import { _parseAgency } from "../lib/parser.js";
 import { TypescriptPreprocessor } from "../lib/preprocessors/typescriptPreprocessor.js";
-import { typeCheck, formatErrors } from "../lib/typeChecker.js";
+import { formatErrors, typeCheck } from "../lib/typeChecker.js";
 import { Command } from "commander";
 import * as fs from "fs";
 import { TarsecError } from "tarsec";
+import process from "process";
 const program = new Command();
 program
     .name("agency")
@@ -23,93 +24,104 @@ function getConfig() {
     }
     return config;
 }
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms * 1000));
-}
 program
     .command("compile")
     .alias("build")
-    .description("Compile .agency file or directory to JavaScript")
-    .argument("<input>", "Path to .agency input file or directory")
-    .argument("[output]", "Path to output .js file (optional)")
-    .action(async (input, output) => {
-    compile(getConfig(), input, output);
+    .description("Compile .agency file(s) or directory(s) to JavaScript")
+    .argument("<inputs...>", "Paths to .agency input files or directories")
+    .action(async (inputs) => {
+    const config = getConfig();
+    for (const input of inputs) {
+        compile(config, input);
+    }
 });
 program
     .command("run")
-    .description("Compile and run .agency file")
-    .argument("<input>", "Path to .agency input file")
-    .argument("[output]", "Path to output .js file (optional)")
-    .action((input, output) => {
-    run(getConfig(), input, output);
+    .description("Compile and run .agency file(s)")
+    .argument("[input]", "Paths to .agency input file")
+    .action((input) => {
+    const config = getConfig();
+    run(config, input);
 });
 program
     .command("format")
     .alias("fmt")
-    .description("Format .agency file or directory (reads from stdin if no input)")
-    .argument("[input]", "Path to .agency input file or directory")
+    .description("Format .agency file(s) or directory(s) (reads from stdin if no input)")
+    .argument("[inputs...]", "Paths to .agency input files or directories")
     .option("-i, --in-place", "Format file(s) in-place")
-    .action(async (input, opts) => {
+    .action(async (inputs, opts) => {
     const config = getConfig();
-    if (!input) {
+    if (inputs.length === 0) {
         const contents = await readStdin();
         const formatted = await format(contents, config);
         console.log(formatted);
     }
     else {
-        formatFile(input, opts.inPlace ?? false, config);
+        for (const input of inputs) {
+            formatFile(input, opts.inPlace ?? false, config);
+        }
     }
 });
 program
     .command("ast")
     .alias("parse")
-    .description("Parse .agency file and show AST (reads from stdin if no input)")
-    .argument("[input]", "Path to .agency input file")
-    .action(async (input) => {
+    .description("Parse .agency file(s) and show AST (reads from stdin if no input)")
+    .argument("[inputs...]", "Paths to .agency input files")
+    .action(async (inputs) => {
     const config = getConfig();
-    let contents;
-    if (!input) {
-        contents = await readStdin();
+    if (inputs.length === 0) {
+        const contents = await readStdin();
+        const result = parse(contents, config);
+        console.log(JSON.stringify(result, null, 2));
     }
     else {
-        contents = readFile(input);
+        for (const input of inputs) {
+            const contents = readFile(input);
+            const result = parse(contents, config);
+            console.log(JSON.stringify(result, null, 2));
+        }
     }
-    const result = parse(contents, config);
-    console.log(JSON.stringify(result, null, 2));
 });
 program
     .command("graph")
     .alias("mermaid")
-    .description("Render Mermaid graph from .agency file (reads from stdin if no input)")
-    .argument("[input]", "Path to .agency input file")
-    .action(async (input) => {
+    .description("Render Mermaid graph from .agency file(s) (reads from stdin if no input)")
+    .argument("[inputs...]", "Paths to .agency input files")
+    .action(async (inputs) => {
     const config = getConfig();
-    let contents;
-    if (!input) {
-        contents = await readStdin();
+    if (inputs.length === 0) {
+        const contents = await readStdin();
+        renderGraph(contents, config);
     }
     else {
-        contents = readFile(input);
+        for (const input of inputs) {
+            const contents = readFile(input);
+            renderGraph(contents, config);
+        }
     }
-    renderGraph(contents, config);
 });
 program
     .command("preprocess")
-    .description("Parse .agency file and show AST after preprocessing (reads from stdin if no input)")
-    .argument("[input]", "Path to .agency input file")
-    .action(async (input) => {
+    .description("Parse .agency file(s) and show AST after preprocessing (reads from stdin if no input)")
+    .argument("[inputs...]", "Paths to .agency input files")
+    .action(async (inputs) => {
     const config = getConfig();
-    let contents;
-    if (!input) {
-        contents = await readStdin();
+    const process = (contents) => {
+        const parsedProgram = parse(contents, config);
+        const preprocessor = new TypescriptPreprocessor(parsedProgram, config);
+        preprocessor.preprocess();
+        console.log(JSON.stringify(preprocessor.program, null, 2));
+    };
+    if (inputs.length === 0) {
+        const contents = await readStdin();
+        process(contents);
     }
     else {
-        contents = readFile(input);
+        for (const input of inputs) {
+            const contents = readFile(input);
+            process(contents);
+        }
     }
-    const parsedProgram = parse(contents, config);
-    const preprocessor = new TypescriptPreprocessor(parsedProgram, config);
-    preprocessor.preprocess();
-    console.log(JSON.stringify(preprocessor.program, null, 2));
 });
 program
     .command("evaluate")
@@ -119,7 +131,7 @@ program
     .option("--args <path>", "Path to eval args JSON file")
     .option("--results <path>", "Path to existing results file (to resume)")
     .action(async (target, opts) => {
-    await evaluate(target, opts.args, opts.results);
+    await evaluate(getConfig(), target, opts.args, opts.results);
 });
 program
     .command("gen-fixtures")
@@ -127,59 +139,87 @@ program
     .description("Generate test fixtures")
     .argument("[target]", "Target in file.agency:nodeName format")
     .action(async (target) => {
-    await fixtures(target);
+    await fixtures(getConfig(), target);
 });
 program
     .command("test")
     .description("Run tests")
-    .argument("[testFile]", "Path to .test.json file")
+    .argument("[inputs...]", "Paths to .test.json files or directories")
     .action(async (testFile) => {
-    await test(testFile);
+    for (const file of testFile) {
+        await test(getConfig(), file);
+    }
 });
 program
     .command("diagnostics")
     .description("Run diagnostics for VSCode")
-    .argument("[testFile]", "Path to .test.json file")
-    .action(async (testFile) => {
-    const contents = testFile ? readFile(testFile) : await readStdin();
-    try {
-        _parseAgency(contents);
-    }
-    catch (error) {
-        if (error instanceof TarsecError) {
-            console.log(JSON.stringify(error.data, null, 2));
+    .argument("[inputs...]", "Paths to .agency input files")
+    .action(async (inputs) => {
+    if (inputs.length === 0) {
+        const contents = await readStdin();
+        try {
+            _parseAgency(contents);
         }
-        else {
-            throw error;
+        catch (error) {
+            if (error instanceof TarsecError) {
+                console.log(JSON.stringify(error.data, null, 2));
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    else {
+        for (const input of inputs) {
+            const contents = readFile(input);
+            try {
+                _parseAgency(contents);
+            }
+            catch (error) {
+                if (error instanceof TarsecError) {
+                    console.log(JSON.stringify(error.data, null, 2));
+                }
+                else {
+                    throw error;
+                }
+            }
         }
     }
 });
 program
     .command("typecheck")
     .alias("tc")
-    .description("Type check .agency file (reads from stdin if no input)")
-    .argument("[input]", "Path to .agency input file")
+    .description("Type check .agency file(s) (reads from stdin if no input)")
+    .argument("[inputs...]", "Paths to .agency input files")
     .option("--strict", "Enable strict types (untyped variables are errors)")
-    .action(async (input, opts) => {
+    .action(async (inputs, opts) => {
     const config = getConfig();
+    let hasErrors = false;
+    const runTypeCheck = (contents) => {
+        const parsedProgram = parse(contents, config);
+        const { errors } = typeCheck(parsedProgram, config);
+        if (errors.length > 0) {
+            console.error(formatErrors(errors));
+            hasErrors = true;
+        }
+        else {
+            console.log("No type errors found.");
+        }
+    };
     if (opts.strict)
         config.strictTypes = true;
-    let contents;
-    if (!input) {
-        contents = await readStdin();
+    if (inputs.length === 0) {
+        const contents = await readStdin();
+        runTypeCheck(contents);
     }
     else {
-        contents = readFile(input);
+        for (const input of inputs) {
+            const contents = readFile(input);
+            runTypeCheck(contents);
+        }
     }
-    const parsedProgram = parse(contents, config);
-    const { errors } = typeCheck(parsedProgram, config);
-    if (errors.length > 0) {
-        console.error(formatErrors(errors));
+    if (hasErrors)
         process.exit(1);
-    }
-    else {
-        console.log("No type errors found.");
-    }
 });
 // Default: treat unknown args as a file to run
 program.arguments("[file]").action((file) => {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "agency-lang",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {
     "test": "vitest",
     "test:run": "vitest run",
+    "test:agency": "node ./dist/scripts/agency.js test -v tests/agency",
     "build": "rm -rf dist/ && tsc && tsc-alias && cp -r lib/agents dist/lib/agents",
     "start": "node dist/index.js",
     "templates": "typestache ./lib/templates",
@@ -54,7 +55,7 @@
     "piemachine": "^0.0.8",
     "prompts": "^2.4.2",
     "smoltalk": "^0.0.18",
-    "statelog-client": "^0.0.36",
+    "statelog-client": "^0.0.38",
     "tarsec": "^0.1.8",
     "typestache": "^0.4.4",
     "zod": "^4.3.5"