agency-lang 0.0.85 → 0.0.86

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

@@ -1,5 +1,5 @@
 import { SpecialVar } from "../types/specialVar.js";
-import { AgencyComment, AgencyMultiLineComment, AgencyNode, AgencyProgram, Assignment, Literal, NewLine, Scope, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
+import { AgencyComment, AgencyMultiLineComment, AgencyNode, AgencyProgram, Assignment, DebuggerStatement, Literal, NewLine, Scope, TypeAlias, TypeHint, TypeHintMap, VariableType } from "../types.js";
 import { AccessChainElement, ValueAccess } from "../types/access.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
@@ -80,6 +80,7 @@ export declare class AgencyGenerator {
     protected processWhileLoop(node: WhileLoop): string;
     protected processIfElse(node: IfElse): string;
     protected processReturnStatement(node: ReturnStatement): string;
+    protected processDebuggerStatement(node: DebuggerStatement): string;
     protected processComment(node: AgencyComment): string;
     protected processMultiLineComment(node: AgencyMultiLineComment): string;
     protected processImportStatement(node: ImportStatement): string;

package/dist/lib/backends/agencyGenerator.js

@@ -64,10 +64,33 @@ export class AgencyGenerator {
             }
         }
         this.preprocessAST();
+        // Types that should have a blank line before/after them at the top level
+        const BLOCK_TYPES = new Set([
+            "graphNode", "function", "typeAlias",
+        ]);
+        const NO_SPACE_TYPES = new Set([
+            "comment", "multiLineComment"
+        ]);
         // Pass 7: Process all nodes and generate code
+        const stmtPairs = [];
         for (const node of program.nodes) {
             const result = this.processNode(node);
-            this.generatedStatements.push(result);
+            if (result !== "") {
+                stmtPairs.push({ type: node.type, code: result });
+            }
+        }
+        // Join top-level statements: blank line between block declarations,
+        // single newline between simple statements
+        const stmtLines = [];
+        for (let i = 0; i < stmtPairs.length; i++) {
+            if (i > 0) {
+                const prev = stmtPairs[i - 1];
+                const curr = stmtPairs[i];
+                if (BLOCK_TYPES.has(prev.type) || (BLOCK_TYPES.has(curr.type) && !NO_SPACE_TYPES.has(prev.type))) {
+                    stmtLines.push(""); // blank line
+                }
+            }
+            stmtLines.push(stmtPairs[i].code);
         }
         const output = [];
         this.addIfNonEmpty(this.preprocess(), output);
@@ -75,7 +98,7 @@ export class AgencyGenerator {
         this.addIfNonEmpty(this.generateImports(), output);
         this.addIfNonEmpty(this.generateBuiltins(), output);
         output.push(...this.generatedTypeAliases);
-        output.push(this.generatedStatements.join(""));
+        output.push(stmtLines.join("\n"));
         this.addIfNonEmpty(this.postprocess(), output);
         return {
             output: output.join("\n"),
@@ -131,6 +154,8 @@ export class AgencyGenerator {
                 return this.generateLiteral(node);
             case "returnStatement":
                 return this.processReturnStatement(node);
+            case "debuggerStatement":
+                return this.processDebuggerStatement(node);
             case "agencyArray":
                 return this.processAgencyArray(node);
             case "agencyObject":
@@ -195,8 +220,8 @@ export class AgencyGenerator {
     }
     isImportedTool(functionName) {
         return this.importedTools
-            .map((node) => node.importedTools)
-            .flat()
+            .flatMap((node) => node.importedTools)
+            .flatMap((n) => n.importedNames)
             .includes(functionName);
     }
     isAgencyFunction(functionName, context) {
@@ -359,7 +384,7 @@ export class AgencyGenerator {
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
         }
-        const bodyCode = lines.join("").trimEnd() + "\n";
+        const bodyCode = lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         result += bodyCode;
         this.decreaseIndent();
         result += this.indentStr(`}`);
@@ -459,9 +484,11 @@ export class AgencyGenerator {
             : node.itemVar;
         let result = this.indentStr(`for (${vars} in ${iterableCode}) {\n`);
         this.increaseIndent();
+        const lines = [];
         for (const stmt of node.body) {
-            result += this.processNode(stmt);
+            lines.push(this.processNode(stmt));
         }
+        result += lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         this.decreaseIndent();
         result += this.indentStr(`}`);
         return result;
@@ -470,9 +497,11 @@ export class AgencyGenerator {
         const conditionCode = this.processNode(node.condition).trim();
         let result = this.indentStr(`while (${conditionCode}) {\n`);
         this.increaseIndent();
+        const lines = [];
         for (const stmt of node.body) {
-            result += this.processNode(stmt);
+            lines.push(this.processNode(stmt));
         }
+        result += lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         this.decreaseIndent();
         result += this.indentStr(`}`);
         return result;
@@ -487,7 +516,7 @@ export class AgencyGenerator {
             bodyLines.push(this.processNode(stmt));
         }
         this.decreaseIndent();
-        lines.push(bodyLines.join("").trimEnd() + "\n");
+        lines.push(bodyLines.filter(s => s !== "").join("\n").trimEnd() + "\n");
         if (node.elseBody && node.elseBody.length > 0) {
             if (node.elseBody.length === 1 && node.elseBody[0].type === "ifElse") {
                 const elseIfCode = this.processIfElse(node.elseBody[0]);
@@ -502,7 +531,7 @@ export class AgencyGenerator {
                     elseBodyLines.push(this.processNode(stmt));
                 }
                 this.decreaseIndent();
-                lines.push(elseBodyLines.join("").trimEnd() + "\n");
+                lines.push(elseBodyLines.filter(s => s !== "").join("\n").trimEnd() + "\n");
             }
         }
         lines.push(this.indentStr(`}`));
@@ -512,6 +541,9 @@ export class AgencyGenerator {
         const valueCode = this.processNode(node.value).trim();
         return this.indentStr(`return ${valueCode}`);
     }
+    processDebuggerStatement(node) {
+        return this.indentStr(node.label ? `debugger(${JSON.stringify(node.label)})` : "debugger()");
+    }
     // Utility methods
     processComment(node) {
         return this.indentStr(`//${node.content}`);
@@ -521,7 +553,10 @@ export class AgencyGenerator {
     }
     processImportStatement(node) {
         const importedNames = node.importedNames.map((name) => this.processImportNameType(name));
-        const str = this.indentStr(`import ${importedNames.join(", ")} from "${node.modulePath}"`);
+        const modulePath = node.modulePath.startsWith("std::")
+            ? node.modulePath.replace(/\.agency$/, "")
+            : node.modulePath;
+        const str = this.indentStr(`import ${importedNames.join(", ")} from "${modulePath}"`);
         return str;
     }
     processImportNameType(node) {
@@ -540,7 +575,8 @@ export class AgencyGenerator {
         return `import node { ${node.importedNodes.join(", ")} } from "${node.agencyFile}"`;
     }
     processImportToolStatement(node) {
-        return `import tool { ${node.importedTools.join(", ")} } from "${node.agencyFile}"`;
+        const toolNames = node.importedTools.flatMap((n) => n.importedNames);
+        return `import tool { ${toolNames.join(", ")} } from "${node.agencyFile}"`;
     }
     visibilityToString(vis) {
         switch (vis) {
@@ -569,7 +605,7 @@ export class AgencyGenerator {
         for (const stmt of body) {
             lines.push(this.processNode(stmt));
         }
-        const bodyCode = lines.join("").trimEnd() + "\n";
+        const bodyCode = lines.filter(s => s !== "").join("\n").trimEnd() + "\n";
         result += bodyCode;
         this.decreaseIndent();
         result += this.indentStr(`}`);
@@ -585,7 +621,7 @@ export class AgencyGenerator {
         return this.indentStr(`@${node.name} = ${this.processNode(node.value).trim()}`);
     }
     processNewLine(_node) {
-        return "\n";
+        return "";
     }
     processMessageThread(node) {
         this.increaseIndent();
@@ -594,7 +630,7 @@ export class AgencyGenerator {
             bodyCodes.push(this.processNode(stmt));
         }
         this.decreaseIndent();
-        const bodyCodeStr = bodyCodes.join("");
+        const bodyCodeStr = bodyCodes.filter(s => s !== "").join("\n").trimEnd() + "\n";
         const threadType = node.threadType;
         return this.indentStr(`${threadType} {\n${bodyCodeStr}${this.indentStr("}")}`);
     }
@@ -605,7 +641,7 @@ export class AgencyGenerator {
             bodyCodes.push(this.processNode(stmt));
         }
         this.decreaseIndent();
-        const bodyCodeStr = bodyCodes.join("");
+        const bodyCodeStr = bodyCodes.filter(s => s !== "").join("\n").trimEnd() + "\n";
         let handlerStr;
         if (node.handler.kind === "inline") {
             const paramStr = node.handler.param.typeHint
@@ -617,7 +653,7 @@ export class AgencyGenerator {
                 handlerBodyCodes.push(this.processNode(stmt));
             }
             this.decreaseIndent();
-            const handlerBodyStr = handlerBodyCodes.join("");
+            const handlerBodyStr = handlerBodyCodes.filter(s => s !== "").join("\n").trimEnd() + "\n";
             handlerStr = `(${paramStr}) {\n${handlerBodyStr}${this.indentStr("}")}`;
         }
         else {

package/dist/lib/backends/agencyGenerator.test.js

@@ -57,7 +57,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         ];
         testCases.forEach(({ description, input, expectedOutput }) => {
             it(`should correctly generate ${description}`, () => {
-                const parseResult = parseAgency(input);
+                const parseResult = parseAgency(input, {}, false);
                 expect(parseResult.success).toBe(true);
                 if (!parseResult.success)
                     return;
@@ -73,7 +73,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
     describe("Type preservation", () => {
         it("should preserve primitive types", () => {
             const input = "def test(n: number, s: string, b: boolean) { n }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -85,7 +85,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should preserve array types", () => {
             const input = "def test(nums: number[], strs: string[]) { nums }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -96,7 +96,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should preserve union types", () => {
             const input = "def test(val: string | number | boolean) { val }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -106,7 +106,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should preserve nested array types", () => {
             const input = "def test(matrix: number[][]) { matrix }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -118,7 +118,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
     describe("Mixed typed and untyped parameters", () => {
         it("should handle first parameter typed, second untyped", () => {
             const input = "def test(x: number, y) { x }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -130,7 +130,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should handle first parameter untyped, second typed", () => {
             const input = "def test(x, y: string) { x }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;
@@ -142,7 +142,7 @@ describe("AgencyGenerator - Function Parameter Type Hints", () => {
         });
         it("should handle alternating typed and untyped parameters", () => {
             const input = "def test(a, b: number, c, d: string) { a }";
-            const parseResult = parseAgency(input);
+            const parseResult = parseAgency(input, {}, false);
             expect(parseResult.success).toBe(true);
             if (!parseResult.success)
                 return;

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

@@ -15,6 +15,9 @@ export declare class TypeScriptBuilder {
     private loopVars;
     private insideMessageThread;
     private insideHandlerBody;
+    /** Stack of loop subKeys for generating break/continue cleanup code.
+     * Pushed when entering a stepped loop, popped when leaving. */
+    private _loopContextStack;
     private _asyncBranchCheckNeeded;
     /** Tracks the current substep nesting path. Empty when at the top level
      * of a stepped body. Non-empty when inside a block (if/else, etc.) that
@@ -60,6 +63,7 @@ export declare class TypeScriptBuilder {
     private needsParensRight;
     build(program: AgencyProgram): TsNode;
     private processNode;
+    private processKeyword;
     private processTypeAlias;
     private processTypeHint;
     private processComment;
@@ -101,6 +105,8 @@ export declare class TypeScriptBuilder {
      * response format from type hints, and tools from config object.
      */
     private processLlmCall;
+    private processSentinel;
+    private processDebuggerStatement;
     private buildPromptString;
     private processSpecialVar;
     private processMessageThread;

package/dist/lib/backends/typescriptBuilder.js

@@ -1,8 +1,11 @@
 import { formatTypeHint } from "../cli/util.js";
+import { toCompiledImportPath } from "../importPaths.js";
 import { BUILTIN_FUNCTIONS, BUILTIN_TOOLS, BUILTIN_VARIABLES, TYPES_THAT_DONT_TRIGGER_NEW_PART, } from "../config.js";
 import * as renderImports from "../templates/backends/typescriptGenerator/imports.js";
 import * as renderInterruptAssignment from "../templates/backends/typescriptGenerator/interruptAssignment.js";
 import * as renderInterruptReturn from "../templates/backends/typescriptGenerator/interruptReturn.js";
+import * as renderRewindCheckpoint from "../templates/backends/typescriptGenerator/rewindCheckpoint.js";
+import * as renderDebugger from "../templates/backends/typescriptGenerator/debugger.js";
 import { PRECEDENCE, } from "../types/binop.js";
 import { expressionToString, getBaseVarName, walkNodesArray, } from "../utils/node.js";
 import path from "path";
@@ -34,6 +37,9 @@ export class TypeScriptBuilder {
     loopVars = [];
     insideMessageThread = false;
     insideHandlerBody = false;
+    /** Stack of loop subKeys for generating break/continue cleanup code.
+     * Pushed when entering a stepped loop, popped when leaving. */
+    _loopContextStack = [];
     /*
     We break up every function and node body into steps,
     and wrap each statement in an if statement. If that statement
@@ -138,8 +144,8 @@ export class TypeScriptBuilder {
     }
     isImportedTool(functionName) {
         return this.programInfo.importedTools
-            .map((node) => node.importedTools)
-            .flat()
+            .flatMap((node) => node.importedTools)
+            .flatMap((n) => n.importedNames)
             .includes(functionName);
     }
     // Runtime functions that need __state (ctx injection) like user-defined agency functions.
@@ -360,11 +366,37 @@ export class TypeScriptBuilder {
             case "binOpExpression":
                 return this.processBinOpExpression(node);
             case "keyword":
-                return node.value === "break" ? ts.break() : ts.continue();
+                return this.processKeyword(node);
+            case "sentinel":
+                return this.processSentinel(node);
+            case "debuggerStatement":
+                return this.processDebuggerStatement(node);
             default:
                 throw new Error(`Unhandled Agency node type: ${node.type}`);
         }
     }
+    processKeyword(node) {
+        const keyword = node.value === "break" ? ts.break() : ts.continue();
+        // Inside a handler body or not inside a stepped loop: emit bare keyword
+        const loopSubKey = this._loopContextStack[this._loopContextStack.length - 1];
+        if (this.insideHandlerBody || loopSubKey === undefined) {
+            return keyword;
+        }
+        // Inside a stepped loop: emit cleanup before the keyword.
+        // For continue, we also need to increment the iteration counters
+        // so the next iteration doesn't replay the current one.
+        const iterStore = `__stack.locals.__iteration_${loopSubKey}`;
+        const currentIterVar = `__currentIter_${loopSubKey}`;
+        const stmts = [
+            ts.raw(`__stack.resetLoopIteration("${loopSubKey}")`),
+        ];
+        if (node.value === "continue") {
+            stmts.push(ts.raw(`${iterStore}++`));
+            stmts.push(ts.raw(`${currentIterVar}++`));
+        }
+        stmts.push(keyword);
+        return ts.statements(stmts);
+    }
     // ------- Type system (side effects only) -------
     processTypeAlias(node) {
         return ts.raw(`type ${node.aliasName} = ${formatTypeHint(node.aliasedType)};`);
@@ -535,12 +567,14 @@ export class TypeScriptBuilder {
         }
         const subStepPath = [...this._subStepPath];
         const subKey = subStepPath.join("_");
+        this._loopContextStack.push(subKey);
         const bodyNodes = node.body.map((stmt, i) => {
             this._subStepPath.push(i);
             const result = this.processStatement(stmt);
             this._subStepPath.pop();
             return result;
         });
+        this._loopContextStack.pop();
         // Unregister loop variables
         this.loopVars = this.loopVars.filter((v) => v !== node.itemVar && v !== node.indexVar);
         // Range form: for (i in range(start, end))
@@ -584,13 +618,16 @@ export class TypeScriptBuilder {
     }
     processWhileLoopWithSteps(node) {
         const subStepPath = [...this._subStepPath];
+        const subKey = subStepPath.join("_");
         const condition = this.processNode(node.condition);
+        this._loopContextStack.push(subKey);
         const bodyNodes = node.body.map((stmt, i) => {
             this._subStepPath.push(i);
             const result = this.processStatement(stmt);
             this._subStepPath.pop();
             return result;
         });
+        this._loopContextStack.pop();
         return ts.whileSteps(subStepPath, condition, bodyNodes);
     }
     processMatchBlockWithSteps(node) {
@@ -614,7 +651,7 @@ export class TypeScriptBuilder {
         return ts.ifSteps(subStepPath, branches, elseBranch);
     }
     processImportStatement(node) {
-        const from = node.modulePath.replace(/\.agency$/, ".js");
+        const from = toCompiledImportPath(node.modulePath);
         const imports = node.importedNames.map((nameType) => {
             switch (nameType.type) {
                 case "namedImport":
@@ -643,17 +680,17 @@ export class TypeScriptBuilder {
         return ts.empty(); // handled in preprocess
     }
     processImportToolStatement(node) {
-        const importNames = node.importedTools
-            .map((toolName) => [
+        const toolNames = node.importedTools.flatMap((n) => n.importedNames);
+        const importNames = toolNames
+            .flatMap((toolName) => [
             toolName,
             `__${toolName}Tool`,
             `__${toolName}ToolParams`,
-        ])
-            .flat();
+        ]);
         return ts.importDecl({
             importKind: "named",
             names: importNames,
-            from: node.agencyFile.replace(/\.agency$/, ".js"),
+            from: toCompiledImportPath(node.agencyFile),
         });
     }
     // ------- TsRaw wrapper methods (template-heavy) -------
@@ -720,7 +757,9 @@ export class TypeScriptBuilder {
             entries[def.functionName] = this.buildToolRegistryEntry(def.functionName, def.functionName, false);
         }
         // Add imported tools (they import __toolNameTool and __toolNameToolParams)
-        const importedToolNames = this.programInfo.importedTools.flatMap((node) => node.importedTools);
+        const importedToolNames = this.programInfo.importedTools
+            .flatMap((node) => node.importedTools)
+            .flatMap((n) => n.importedNames);
         for (const toolName of importedToolNames) {
             entries[toolName] = this.buildToolRegistryEntry(toolName, toolName, false);
         }
@@ -1316,6 +1355,25 @@ export class TypeScriptBuilder {
         }
         return ts.statements(stmts);
     }
+    processSentinel(node) {
+        if (node.value === "checkpoint") {
+            const promptNode = this.processNode(node.data.prompt);
+            const varRef = ts.scopedVar(node.data.targetVariable, node.data.scope, this.moduleId);
+            return ts.raw(renderRewindCheckpoint.default({
+                targetVariable: node.data.targetVariable,
+                prompt: printTs(promptNode),
+                response: printTs(varRef),
+            }));
+        }
+        return ts.empty();
+    }
+    processDebuggerStatement(node) {
+        const code = renderDebugger.default({
+            label: node.label !== undefined ? JSON.stringify(node.label) : "undefined",
+            nodeContext: this.isInsideGraphNode,
+        });
+        return ts.raw(code);
+    }
     buildPromptString({ segments, typeHints, skills, }) {
         const promptParts = [];
         for (const segment of segments) {
@@ -1481,6 +1539,17 @@ export class TypeScriptBuilder {
         return ts.handleSteps(subStepPath, handler, bodyNodes);
     }
     processBodyAsParts(body, opts = {}) {
+        // Debugger mode: insert breakpoints before each step-triggering statement
+        if (this.agencyConfig?.debugger) {
+            const expanded = [];
+            for (const stmt of body) {
+                if (!TYPES_THAT_DONT_TRIGGER_NEW_PART.includes(stmt.type) && stmt.type !== "debuggerStatement") {
+                    expanded.push({ type: "debuggerStatement" });
+                }
+                expanded.push(stmt);
+            }
+            body = expanded;
+        }
         const parts = [[]];
         // Maps step index to the branch key (subStepPath) captured at processing time
         const branchKeys = {};

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

@@ -3,7 +3,7 @@ import { AgencyProgram } from "../index.js";
 import { type SymbolTable } from "../symbolTable.js";
 export declare function loadConfig(configPath?: string, verbose?: boolean): AgencyConfig;
 export declare function readStdin(): Promise<string>;
-export declare function parse(contents: string, config: AgencyConfig): AgencyProgram;
+export declare function parse(contents: string, config: AgencyConfig, applyTemplate?: boolean): AgencyProgram;
 export declare function readFile(inputFile: string): string;
 export declare function renderGraph(contents: string, config: AgencyConfig): void;
 export declare function resetCompilationCache(): void;

package/dist/lib/cli/commands.js

@@ -6,6 +6,7 @@ import { collectProgramInfo } from "../programInfo.js";
 import { typeCheck, formatErrors } from "../typeChecker.js";
 import { buildSymbolTable } from "../symbolTable.js";
 import { resolveImports } from "../preprocessors/importResolver.js";
+import { resolveAgencyImportPath, isStdlibImport, getStdlibDir, } from "../importPaths.js";
 import { renderMermaidAscii } from "beautiful-mermaid";
 import { spawn } from "child_process";
 import * as fs from "fs";
@@ -52,14 +53,14 @@ export function readStdin() {
         });
     });
 }
-export function parse(contents, config) {
+export function parse(contents, config, applyTemplate = true) {
     const verbose = config.verbose ?? false;
-    const parseResult = parseAgency(contents, config);
+    const parseResult = parseAgency(contents, config, applyTemplate);
     // Check if parsing was successful
     if (!parseResult.success) {
         console.error("Parse error:");
         console.error(parseResult);
-        process.exit(1);
+        throw new Error("Failed to parse Agency program");
     }
     return parseResult.result;
 }
@@ -120,7 +121,8 @@ export function compile(config, inputFile, _outputFile, options) {
     }
     compiledFiles.add(absoluteInputFile);
     const contents = readFile(inputFile);
-    const parsedProgram = parse(contents, config);
+    const isStdlibFile = absoluteInputFile.startsWith(getStdlibDir());
+    const parsedProgram = parse(contents, config, !isStdlibFile);
     // Build symbol table once at the top level, reuse for recursive calls
     const symbolTable = options?.symbolTable ?? buildSymbolTable(absoluteInputFile, config);
     // Resolve unified imports into specialized AST nodes
@@ -140,10 +142,9 @@ export function compile(config, inputFile, _outputFile, options) {
         }
     }
     const imports = getImports(resolvedProgram);
-    const inputDir = path.dirname(absoluteInputFile);
     for (const importPath of imports) {
-        const absPath = path.resolve(inputDir, importPath);
-        if (config.restrictImports) {
+        const absPath = resolveAgencyImportPath(importPath, absoluteInputFile);
+        if (config.restrictImports && !isStdlibImport(importPath)) {
             const projectRoot = process.cwd();
             if (!absPath.startsWith(projectRoot + path.sep) &&
                 absPath !== projectRoot) {
@@ -154,7 +155,7 @@ export function compile(config, inputFile, _outputFile, options) {
     }
     // Update the import path in the AST to reference the new .ts file
     resolvedProgram.nodes.forEach((node) => {
-        if (node.type === "importStatement") {
+        if (node.type === "importStatement" && !isStdlibImport(node.modulePath)) {
             node.modulePath = node.modulePath.replace(".agency", ext);
         }
     });
@@ -204,7 +205,7 @@ export function run(config, inputFile, outputFile, resumeFile) {
     });
 }
 export async function format(contents, config) {
-    const parsedProgram = parse(contents, config);
+    const parsedProgram = parse(contents, config, false);
     const generatedCode = generateAgency(parsedProgram);
     return generatedCode;
 }

package/dist/lib/cli/test.js

@@ -5,7 +5,7 @@ import prompts from "prompts";
 import { executeJudge, executeNode, findRecursively, parseTarget, pickANode, promptForArgs, promptForTarget, } from "./util.js";
 import { color } from "../utils/termcolors.js";
 import path from "path";
-import { compile } from "./commands.js";
+import { compile, loadConfig } from "./commands.js";
 import { execFileSync } from "child_process";
 function readFile(filename) {
     console.log("Trying to read file", filename, "...");
@@ -231,14 +231,22 @@ export function mergeStats(a, b) {
 function runSingleTest(config, testFile, tests, testCase) {
     const hasArgs = testCase.input !== "";
     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 result;
+    try {
+        result = executeNode({
+            config,
+            agencyFile: relativeSourceFilePath,
+            nodeName: testCase.nodeName,
+            hasArgs,
+            argsString: testCase.input,
+            interruptHandlers: testCase.interruptHandlers,
+        });
+    }
+    catch (e) {
+        exitIfSignal(e);
+        console.log(color.red(`  ✗ Test execution error: ${e}`));
+        return false;
+    }
     let testPassed = true;
     for (const criterion of testCase.evaluationCriteria) {
         if (criterion.type === "exact") {
@@ -383,10 +391,15 @@ export async function testTs(config, inputPaths) {
                 failures.push(dir);
                 continue;
             }
-            // Compile the .agency file
+            // Compile the .agency file, merging any local agency.json config
             const agencyPath = path.join(dir, agencyFile);
+            const localConfigPath = path.join(dir, "agency.json");
+            let mergedConfig = config;
+            if (fs.existsSync(localConfigPath)) {
+                mergedConfig = { ...config, ...loadConfig(localConfigPath) };
+            }
             try {
-                compile(config, agencyPath);
+                compile(mergedConfig, agencyPath);
             }
             catch (e) {
                 console.log(color.red(`  ✗ Compilation failed: ${e}`));

package/dist/lib/cli/util.js

@@ -5,6 +5,7 @@ const onCancel = () => {
 import fs, { readFileSync } from "fs";
 import path from "path";
 import { execFileSync } from "child_process";
+import { isStdlibImport, resolveAgencyImportPath, getStdlibDir } from "../importPaths.js";
 import renderEvaluate from "../templates/cli/evaluate.js";
 import renderJudgeEvaluate from "../templates/cli/judgeEvaluate.js";
 import { compile } from "./commands.js";
@@ -201,7 +202,8 @@ export function getImportsRecursively(filename, visited = new Set()) {
     }
     visited.add(filename);
     const contents = fs.readFileSync(filename, "utf-8");
-    const parsed = parseAgency(contents, { verbose: false });
+    const isStdlibFile = filename.startsWith(getStdlibDir());
+    const parsed = parseAgency(contents, { verbose: false }, !isStdlibFile);
     if (!parsed.success) {
         console.error(`Error parsing ${filename}:`, parsed);
         return [];
@@ -209,7 +211,7 @@ export function getImportsRecursively(filename, visited = new Set()) {
     const program = parsed.result;
     const imports = getImports(program);
     for (const imp of imports) {
-        const importedFile = path.resolve(path.dirname(filename), imp);
+        const importedFile = resolveAgencyImportPath(imp, filename);
         if (fs.existsSync(importedFile)) {
             imports.push(...getImportsRecursively(importedFile, visited));
         }
@@ -226,7 +228,8 @@ export function getImports(program) {
         .map((node) => node.agencyFile.trim());
     // this makes compile() try to parse non-agency files
     const importStatements = program.nodes
-        .filter((node) => node.type === "importStatement" && node.modulePath.endsWith(".agency"))
+        .filter((node) => node.type === "importStatement" &&
+        (node.modulePath.endsWith(".agency") || isStdlibImport(node.modulePath)))
         .map((node) => node.modulePath.trim());
     return [...toolAndNodeImports, ...importStatements];
 }