agency-lang 0.1.0 → 0.1.1

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

@@ -3,7 +3,7 @@ import { AccessChainElement, ValueAccess } from "../types/access.js";
 import { BlockArgument } from "../types/blockArgument.js";
 import { AgencyArray, AgencyObject } from "../types/dataStructures.js";
 import { FunctionCall, FunctionDefinition } from "../types/function.js";
-import { GraphNodeDefinition, Visibility } from "../types/graphNode.js";
+import { GraphNodeDefinition } from "../types/graphNode.js";
 import { IfElse } from "../types/ifElse.js";
 import { ImportNameType, ImportNodeStatement, ImportStatement } from "../types/importStatement.js";
 import { MatchBlock } from "../types/matchBlock.js";
@@ -95,7 +95,6 @@ export declare class AgencyGenerator {
     protected processImportNameType(node: ImportNameType): string;
     protected processImportNodeStatement(node: ImportNodeStatement): string;
     private sortAndRenderImports;
-    protected visibilityToString(vis: Visibility): string;
     protected processGraphNode(node: GraphNodeDefinition): string;
     protected processClassDefinition(node: ClassDefinition): string;
     protected processNewExpression(node: NewExpression): string;

package/dist/lib/backends/agencyGenerator.js

@@ -326,13 +326,14 @@ export class AgencyGenerator {
         const varName = node.typeHint
             ? `${node.variableName}${chainStr}: ${variableTypeToString(node.typeHint, this.typeAliases)}${bangSuffix}`
             : `${node.variableName}${chainStr}`;
+        const exportPrefix = node.exported ? "export " : "";
         const staticPrefix = node.static ? "static " : "";
         const declPrefix = node.declKind ? `${node.declKind} ` : "";
         let valueCode = node.value.type === "binOpExpression"
             ? this.processBinOpExpression(node.value, true).trim()
             : this.processNode(node.value).trim();
         return (tags +
-            this.indentStr(`${staticPrefix}${declPrefix}${varName} = ${valueCode}`));
+            this.indentStr(`${exportPrefix}${staticPrefix}${declPrefix}${varName} = ${valueCode}`));
     }
     generateLiteral(literal) {
         switch (literal.type) {
@@ -690,16 +691,6 @@ export class AgencyGenerator {
             .map((g) => g.map((e) => e.render()).join("\n"));
         return groups.join("\n\n");
     }
-    visibilityToString(vis) {
-        switch (vis) {
-            case "public":
-                return "public ";
-            case "private":
-                return "private ";
-            case undefined:
-                return "";
-        }
-    }
     processGraphNode(node) {
         const tags = this.formatAttachedTags(node);
         const { nodeName, body, parameters } = node;
@@ -707,8 +698,8 @@ export class AgencyGenerator {
         const returnTypeStr = node.returnType
             ? ": " + variableTypeToString(node.returnType, this.typeAliases) + returnTypeBang
             : "";
-        const visibilityStr = this.visibilityToString(node.visibility);
-        const prefix = `${visibilityStr}node ${nodeName}`;
+        const exportPrefix = node.exported ? "export " : "";
+        const prefix = `${exportPrefix}node ${nodeName}`;
         const renderedParams = this.renderParams(parameters);
         const signature = this.wrapList(renderedParams, prefix, "(", ")", `${returnTypeStr} {`);
         let result = this.indentStr(`${signature}\n`);

package/dist/lib/backends/typescriptBuilder.js

@@ -351,10 +351,13 @@ export class TypeScriptBuilder {
         // a separate `__initializeStatic(__ctx)` function (called once from __initializeGlobals).
         // This gives them access to __ctx for handlers and function dispatch.
         const staticVarNames = new Set();
+        const exportedStaticVarNames = new Set();
         const staticInitStatements = [];
         for (const node of program.nodes) {
             if (node.type === "assignment" && node.scope === "static") {
                 staticVarNames.add(node.variableName);
+                if (node.exported)
+                    exportedStaticVarNames.add(node.variableName);
                 const valueNode = this.processNodeInGlobalInit(node.value);
                 staticInitStatements.push(ts.assign(ts.id(node.variableName), ts.call(ts.id("__deepFreeze"), [valueNode])));
             }
@@ -363,6 +366,8 @@ export class TypeScriptBuilder {
                 node.statement.scope === "static") {
                 const stmt = node.statement;
                 staticVarNames.add(stmt.variableName);
+                if (stmt.exported)
+                    exportedStaticVarNames.add(stmt.variableName);
                 const valueNode = this.processNodeInGlobalInit(stmt.value);
                 const handler = this.buildHandlerArrow(node.handlerName);
                 staticInitStatements.push(ts.withHandler(handler, ts.assign(ts.id(stmt.variableName), ts.call(ts.id("__deepFreeze"), [valueNode]))));
@@ -427,7 +432,7 @@ export class TypeScriptBuilder {
         }
         // Emit static variable `let` declarations at module level + __initializeStatic function
         if (staticVarNames.size > 0) {
-            const staticLetDecls = [...staticVarNames].map(name => ts.letDecl(name));
+            const staticLetDecls = [...staticVarNames].map(name => exportedStaticVarNames.has(name) ? ts.export(ts.letDecl(name)) : ts.letDecl(name));
             sections.push(ts.statements([
                 ts.raw("let __staticInitPromise = null"),
                 ...staticLetDecls,
@@ -1453,6 +1458,8 @@ export class TypeScriptBuilder {
                 fn: ts.id(implName),
                 params: ts.arr(paramNodes),
                 toolDefinition: toolDef,
+                safe: ts.bool(!!node.safe),
+                exported: ts.bool(!!node.exported),
             }),
             ts.id("__toolRegistry"),
         ])

package/dist/lib/cli/commands.js

@@ -49,7 +49,7 @@ export function parse(contents, config, applyTemplate = true) {
     const parseResult = parseAgency(contents, config, applyTemplate);
     // Check if parsing was successful
     if (!parseResult.success) {
-        console.error("Failed to parse Agency program.");
+        console.error("Failed to parse Agency program.", contents.slice(0, 400));
         process.exit(1);
     }
     return parseResult.result;

package/dist/lib/cli/debug.js

@@ -5,7 +5,7 @@ import { parseAgency } from "../parser.js";
 import { getNodesOfType } from "../utils/node.js";
 import { DebuggerDriver } from "../debugger/driver.js";
 import { DebuggerUI } from "../debugger/ui.js";
-import { Screen, TerminalInput, TerminalOutput } from "@agency-lang/tui";
+import { Screen, TerminalInput, TerminalOutput } from "../tui/index.js";
 import { TraceReader } from "../runtime/trace/traceReader.js";
 import { Checkpoint } from "../runtime/state/checkpointStore.js";
 import { createDebugInterrupt } from "../runtime/interrupts.js";

package/dist/lib/cli/schedule/backends/launchd.js

@@ -61,6 +61,8 @@ export class LaunchdBackend {
             name: entry.name,
             runScriptPath,
             agentDir: path.dirname(entry.agentFile),
+            path: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+            home: os.homedir(),
             intervals: buildIntervals(entry.cron),
             logDir: entry.logDir,
         });

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

@@ -0,0 +1,14 @@
+export type TestOptions = {
+    baseDir?: string;
+    cwd?: string;
+};
+export type TestResult = {
+    name: string;
+    agentFile: string;
+    outputFile: string;
+    logDir: string;
+};
+export declare const TEST_SCHEDULE_NAME = "agency-cron-test";
+export declare const TEST_OUTPUT_FILE = "agency-cron-test.txt";
+export declare const TEST_AGENT_FILE = "agency-cron-test.agency";
+export declare function scheduleTest(opts?: TestOptions): TestResult;

package/dist/lib/cli/schedule/test.js

@@ -0,0 +1,29 @@
+import * as path from "path";
+import * as os from "os";
+import * as fs from "fs";
+import { scheduleAdd } from "./index.js";
+export const TEST_SCHEDULE_NAME = "agency-cron-test";
+export const TEST_OUTPUT_FILE = "agency-cron-test.txt";
+export const TEST_AGENT_FILE = "agency-cron-test.agency";
+const TEST_AGENT_CONTENT = `import { now } from "std::date"
+
+node main() {
+  write("${TEST_OUTPUT_FILE}", now()) with approve
+}
+`;
+export function scheduleTest(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const agentFile = path.join(cwd, TEST_AGENT_FILE);
+    const outputFile = path.join(cwd, TEST_OUTPUT_FILE);
+    fs.writeFileSync(agentFile, TEST_AGENT_CONTENT);
+    scheduleAdd({
+        file: agentFile,
+        every: "minute",
+        name: TEST_SCHEDULE_NAME,
+        baseDir: opts.baseDir,
+        force: true,
+    });
+    const baseDir = opts.baseDir ?? path.join(os.homedir(), ".agency", "schedules");
+    const logDir = path.join(baseDir, TEST_SCHEDULE_NAME, "logs");
+    return { name: TEST_SCHEDULE_NAME, agentFile, outputFile, logDir };
+}

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

@@ -0,0 +1,8 @@
+export declare function serveMcp(file: string, options: {
+    name?: string;
+}): Promise<void>;
+export declare function serveHttp(file: string, options: {
+    port?: string;
+    apiKey?: string;
+    standalone?: boolean;
+}): Promise<void>;

package/dist/lib/cli/serve.js

@@ -0,0 +1,85 @@
+import path from "path";
+import process from "process";
+import { pathToFileURL } from "url";
+import { compile, loadConfig } from "./commands.js";
+import { SymbolTable } from "../symbolTable.js";
+import { discoverExports } from "../serve/discovery.js";
+import { createMcpHandler, startStdioServer } from "../serve/mcp/adapter.js";
+import { startHttpServer } from "../serve/http/adapter.js";
+import { createLogger } from "../logger.js";
+import { VERSION } from "../version.js";
+import * as esbuild from "esbuild";
+function compileForServe(file) {
+    const config = loadConfig();
+    const absoluteFile = path.resolve(file);
+    const symbolTable = SymbolTable.build(absoluteFile, config);
+    const outputPath = compile(config, file, undefined, { symbolTable });
+    if (!outputPath) {
+        throw new Error(`Compilation failed for ${file}`);
+    }
+    const fileSymbols = symbolTable.getFile(absoluteFile);
+    const exportedNodeNames = Object.values(fileSymbols ?? {})
+        .filter((sym) => sym.kind === "node" && sym.exported)
+        .map((sym) => sym.name);
+    const moduleId = path.relative(process.cwd(), absoluteFile);
+    return { outputPath, moduleId, exportedNodeNames };
+}
+async function loadAndDiscover(compileResult) {
+    const moduleUrl = pathToFileURL(path.resolve(compileResult.outputPath)).href;
+    const mod = await import(moduleUrl);
+    const moduleExports = mod;
+    const toolRegistry = moduleExports.__toolRegistry ?? {};
+    const exports = discoverExports({
+        toolRegistry,
+        moduleExports,
+        moduleId: compileResult.moduleId,
+        exportedNodeNames: compileResult.exportedNodeNames,
+    });
+    return { exports, moduleExports };
+}
+export async function serveMcp(file, options) {
+    const compileResult = compileForServe(file);
+    const { exports } = await loadAndDiscover(compileResult);
+    const serverName = options.name ?? path.basename(file, ".agency");
+    const handler = createMcpHandler({
+        serverName,
+        serverVersion: VERSION,
+        exports,
+    });
+    startStdioServer(handler);
+}
+export async function serveHttp(file, options) {
+    const compileResult = compileForServe(file);
+    if (options.standalone) {
+        await generateStandalone(compileResult.outputPath, file);
+        return;
+    }
+    const { exports, moduleExports } = await loadAndDiscover(compileResult);
+    const port = parseInt(options.port ?? "3545", 10);
+    if (isNaN(port) || port < 1 || port > 65535) {
+        throw new Error(`Invalid port: ${options.port}`);
+    }
+    const logger = createLogger("info");
+    startHttpServer({
+        exports,
+        port,
+        apiKey: options.apiKey,
+        logger,
+        hasInterrupts: moduleExports.hasInterrupts,
+        respondToInterrupts: moduleExports.respondToInterrupts,
+    });
+}
+async function generateStandalone(compiledPath, originalFile) {
+    const outfile = path.basename(originalFile, ".agency") + ".server.js";
+    await esbuild.build({
+        entryPoints: [compiledPath],
+        bundle: true,
+        platform: "node",
+        format: "esm",
+        outfile,
+        banner: {
+            js: "// Generated by Agency — standalone HTTP server\n",
+        },
+    });
+    console.log(`Standalone server written to ${outfile}`);
+}

package/dist/lib/config.d.ts

@@ -1,4 +1,5 @@
 import { AgencyNode } from "./types.js";
+import type { LogLevel } from "./logger.js";
 import { z } from "zod";
 export declare const TYPES_THAT_DONT_TRIGGER_NEW_PART: AgencyNode["type"][];
 /**
@@ -13,6 +14,7 @@ export declare const BUILTIN_VARIABLES: string[];
  */
 export interface AgencyConfig {
     verbose?: boolean;
+    logLevel?: LogLevel;
     outDir?: string;
     /**
      * Array of AST node types to exclude from code generation
@@ -121,6 +123,12 @@ export interface AgencyConfig {
 }
 export declare const AgencyConfigSchema: z.ZodObject<{
     verbose: z.ZodOptional<z.ZodBoolean>;
+    logLevel: z.ZodOptional<z.ZodEnum<{
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+        error: "error";
+    }>>;
     outDir: z.ZodOptional<z.ZodString>;
     excludeNodeTypes: z.ZodOptional<z.ZodArray<z.ZodString>>;
     excludeBuiltinFunctions: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -136,10 +144,10 @@ export declare const AgencyConfigSchema: z.ZodObject<{
     }, z.core.$strip>>;
     client: z.ZodOptional<z.ZodObject<{
         logLevel: z.ZodOptional<z.ZodEnum<{
-            error: "error";
-            warn: "warn";
-            info: "info";
             debug: "debug";
+            info: "info";
+            warn: "warn";
+            error: "error";
         }>>;
         defaultModel: z.ZodOptional<z.ZodString>;
         openAiApiKey: z.ZodOptional<z.ZodString>;

package/dist/lib/config.js

@@ -19,6 +19,7 @@ export const BUILTIN_VARIABLES = ["color"];
 export const AgencyConfigSchema = z
     .object({
     verbose: z.boolean(),
+    logLevel: z.enum(["debug", "info", "warn", "error"]),
     outDir: z.string(),
     excludeNodeTypes: z.array(z.string()),
     excludeBuiltinFunctions: z.array(z.string()),

package/dist/lib/debugger/overlays.d.ts

@@ -1,4 +1,4 @@
-import { type Screen, type Element } from "@agency-lang/tui";
+import { type Screen, type Element } from "../tui/index.js";
 import type { Checkpoint } from "../runtime/state/checkpointStore.js";
 import type { UIState } from "./uiState.js";
 /**

package/dist/lib/debugger/overlays.js

@@ -1,4 +1,4 @@
-import { box, row, column, text, escapeStyleTags, } from "@agency-lang/tui";
+import { box, row, column, text, escapeStyleTags, } from "../tui/index.js";
 import { formatValue } from "./util.js";
 // ---------------------------------------------------------------------------
 // Rewind selector

package/dist/lib/debugger/testSession.d.ts

@@ -1,4 +1,4 @@
-import { FrameRecorder, type Frame } from "@agency-lang/tui";
+import { FrameRecorder, type Frame } from "../tui/index.js";
 import { DebuggerDriver } from "./driver.js";
 import { DebuggerUI } from "./ui.js";
 import type { Checkpoint } from "../runtime/state/checkpointStore.js";

package/dist/lib/debugger/testSession.js

@@ -1,4 +1,4 @@
-import { Screen, FrameRecorder, } from "@agency-lang/tui";
+import { Screen, FrameRecorder, } from "../tui/index.js";
 import { DebuggerDriver } from "./driver.js";
 import { DebuggerUI } from "./ui.js";
 import { hasInterrupts, createDebugInterrupt } from "../runtime/interrupts.js";

package/dist/lib/debugger/ui.d.ts

@@ -1,4 +1,4 @@
-import { Screen, type Element, type Frame } from "@agency-lang/tui";
+import { Screen, type Element, type Frame } from "../tui/index.js";
 import type { Checkpoint } from "../runtime/state/checkpointStore.js";
 import type { FunctionParameter } from "../types.js";
 import type { DebuggerCommand, DebuggerIO } from "./types.js";

package/dist/lib/debugger/ui.js

@@ -1,4 +1,4 @@
-import { box, row, column, text, escapeStyleTags, } from "@agency-lang/tui";
+import { box, row, column, text, escapeStyleTags, } from "../tui/index.js";
 import { readFileSync } from "fs";
 import { formatTypeHint } from "../cli/util.js";
 import { UIState } from "./uiState.js";

package/dist/lib/logger.d.ts

@@ -0,0 +1,8 @@
+export type LogLevel = "debug" | "info" | "warn" | "error";
+export type Logger = {
+    debug: (message: string) => void;
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+};
+export declare function createLogger(level?: LogLevel): Logger;

package/dist/lib/logger.js

@@ -0,0 +1,21 @@
+const LEVEL_ORDER = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+export function createLogger(level = "info") {
+    const threshold = LEVEL_ORDER[level];
+    function log(msgLevel, message) {
+        if (LEVEL_ORDER[msgLevel] < threshold)
+            return;
+        const timestamp = new Date().toISOString().replace("T", " ").replace("Z", "");
+        process.stderr.write(`[${timestamp}] ${msgLevel.toUpperCase()} ${message}\n`);
+    }
+    return {
+        debug: (msg) => log("debug", msg),
+        info: (msg) => log("info", msg),
+        warn: (msg) => log("warn", msg),
+        error: (msg) => log("error", msg),
+    };
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/lib/logger.test.js

@@ -0,0 +1,44 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createLogger } from "./logger.js";
+describe("createLogger", () => {
+    let spy;
+    beforeEach(() => {
+        spy = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    });
+    afterEach(() => spy.mockRestore());
+    it("logs at info level by default", () => {
+        const log = createLogger("info");
+        log.info("hello");
+        expect(spy).toHaveBeenCalledTimes(1);
+        expect(spy.mock.calls[0][0]).toContain("hello");
+    });
+    it("suppresses debug when level is info", () => {
+        const log = createLogger("info");
+        log.debug("hidden");
+        expect(spy).not.toHaveBeenCalled();
+    });
+    it("shows debug when level is debug", () => {
+        const log = createLogger("debug");
+        log.debug("visible");
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it("suppresses info when level is warn", () => {
+        const log = createLogger("warn");
+        log.warn("caution");
+        expect(spy).toHaveBeenCalledTimes(1);
+        log.info("suppressed");
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it("suppresses warn when level is error", () => {
+        const log = createLogger("error");
+        log.error("bad");
+        expect(spy).toHaveBeenCalledTimes(1);
+        log.warn("suppressed");
+        expect(spy).toHaveBeenCalledTimes(1);
+    });
+    it("includes level label in output", () => {
+        const log = createLogger("debug");
+        log.warn("test");
+        expect(spy.mock.calls[0][0]).toContain("WARN");
+    });
+});

package/dist/lib/lsp/semantics.js

@@ -165,6 +165,8 @@ function formatSignature(symbol) {
                 : `type ${symbol.name}`;
         case "class":
             return `class ${symbol.name}`;
+        case "constant":
+            return `static const ${symbol.name}${symbol.returnType ? `: ${formatTypeHint(symbol.returnType)}` : ""}`;
     }
 }
 export function formatSemanticHover(symbol) {

package/dist/lib/parser.js

@@ -1,8 +1,8 @@
 import { capture, eof, failure, getErrorMessage, many, map, or, seqC, set, setInputStr, setTraceHost, setTraceId, success, TarsecError, trace, } from "tarsec";
 import { nanoid } from "nanoid";
 import render from "./templates/backends/agency/template.js";
-import { assignmentParser, binOpParser, booleanParser, commentParser, debuggerParser, forLoopParser, functionParser, gotoStatementParser, graphNodeParser, handleBlockParser, ifParser, importNodeStatmentParser, importStatmentParser, interruptStatementParser, keywordParser, matchBlockParser, messageThreadParser, multiLineCommentParser, newLineParser, blankLineParser, BLANK_LINE_SENTINEL, optionalSpacesOrNewline, returnStatementParser, staticAssignmentParser, skillParser, tagParser, typeAliasParser, valueAccessParser, whileLoopParser, withModifierParser, classParser, AGENCY_TEMPLATE_OFFSET, setTemplateOffset, } from "./parsers/parsers.js";
-const nodeParser = or(keywordParser, importNodeStatmentParser, importStatmentParser, graphNodeParser, classParser, typeAliasParser, ifParser, forLoopParser, whileLoopParser, matchBlockParser, messageThreadParser, handleBlockParser, debuggerParser, skillParser, functionParser, returnStatementParser, gotoStatementParser, interruptStatementParser, tagParser, withModifierParser, staticAssignmentParser, assignmentParser, binOpParser, booleanParser, valueAccessParser, multiLineCommentParser, commentParser, blankLineParser, newLineParser);
+import { assignmentParser, binOpParser, booleanParser, commentParser, debuggerParser, forLoopParser, functionParser, gotoStatementParser, graphNodeParser, handleBlockParser, ifParser, importNodeStatmentParser, importStatmentParser, interruptStatementParser, keywordParser, matchBlockParser, messageThreadParser, multiLineCommentParser, newLineParser, blankLineParser, BLANK_LINE_SENTINEL, optionalSpacesOrNewline, returnStatementParser, modifiedAssignmentParser, skillParser, tagParser, typeAliasParser, valueAccessParser, whileLoopParser, withModifierParser, classParser, AGENCY_TEMPLATE_OFFSET, setTemplateOffset, } from "./parsers/parsers.js";
+const nodeParser = or(keywordParser, importNodeStatmentParser, importStatmentParser, graphNodeParser, classParser, typeAliasParser, ifParser, forLoopParser, whileLoopParser, matchBlockParser, messageThreadParser, handleBlockParser, debuggerParser, skillParser, functionParser, returnStatementParser, gotoStatementParser, interruptStatementParser, tagParser, withModifierParser, modifiedAssignmentParser, assignmentParser, binOpParser, booleanParser, valueAccessParser, multiLineCommentParser, commentParser, blankLineParser, newLineParser);
 export const agencyNode = (input) => {
     const parser = many(trace("agencyParser", map(seqC(capture(nodeParser, "node"), optionalSpacesOrNewline), (result) => result.node)));
     return parser(input);

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

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { assignmentParser, staticAssignmentParser } from "./parsers.js";
+import { assignmentParser, modifiedAssignmentParser } from "./parsers.js";
 describe("assignmentParser", () => {
     const testCases = [
         // Happy path - simple literal assignments
@@ -564,9 +564,9 @@ describe("assignmentParser", () => {
         }
     });
 });
-describe("staticAssignmentParser", () => {
+describe("modifiedAssignmentParser", () => {
     it("should parse static const with a number", () => {
-        const result = staticAssignmentParser("static const x = 42");
+        const result = modifiedAssignmentParser("static const x = 42");
         expect(result.success).toBe(true);
         if (result.success) {
             expect(result.result.type).toBe("assignment");
@@ -577,7 +577,7 @@ describe("staticAssignmentParser", () => {
         }
     });
     it("should parse static const with a string", () => {
-        const result = staticAssignmentParser('static const name = "Alice"');
+        const result = modifiedAssignmentParser('static const name = "Alice"');
         expect(result.success).toBe(true);
         if (result.success) {
             expect(result.result.static).toBe(true);
@@ -586,7 +586,7 @@ describe("staticAssignmentParser", () => {
         }
     });
     it("should parse static const with a function call", () => {
-        const result = staticAssignmentParser('static const myPrompt = read("prompt.md")');
+        const result = modifiedAssignmentParser('static const myPrompt = read("prompt.md")');
         expect(result.success).toBe(true);
         if (result.success) {
             expect(result.result.static).toBe(true);
@@ -596,19 +596,19 @@ describe("staticAssignmentParser", () => {
         }
     });
     it("should reject static let", () => {
-        const result = staticAssignmentParser("static let x = 42");
+        const result = modifiedAssignmentParser("static let x = 42");
         expect(result.success).toBe(false);
     });
     it("should reject static without const", () => {
-        const result = staticAssignmentParser("static x = 42");
+        const result = modifiedAssignmentParser("static x = 42");
         expect(result.success).toBe(false);
     });
     it("should not parse a regular assignment", () => {
-        const result = staticAssignmentParser("x = 42");
+        const result = modifiedAssignmentParser("x = 42");
         expect(result.success).toBe(false);
     });
     it("should not parse const without static", () => {
-        const result = staticAssignmentParser("const x = 42");
+        const result = modifiedAssignmentParser("const x = 42");
         expect(result.success).toBe(false);
     });
     it("regular assignmentParser should not set static", () => {

package/dist/lib/parsers/exportConst.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "vitest";
+import { modifiedAssignmentParser } from "./parsers.js";
+describe("export const", () => {
+    it("parses export const", () => {
+        const result = modifiedAssignmentParser(`export const x = 5\n`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.declKind).toBe("const");
+            expect(result.result.variableName).toBe("x");
+        }
+    });
+    it("parses export static const", () => {
+        const result = modifiedAssignmentParser(`export static const x = 5\n`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.static).toBe(true);
+            expect(result.result.declKind).toBe("const");
+        }
+    });
+    it("parses static export const (any order)", () => {
+        const result = modifiedAssignmentParser(`static export const x = 5\n`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.static).toBe(true);
+            expect(result.result.declKind).toBe("const");
+        }
+    });
+    // The parser accepts export let syntactically; the typechecker is responsible
+    // for rejecting it (export only makes sense for const declarations).
+    it("parses export let (typechecker rejects this, not parser)", () => {
+        const result = modifiedAssignmentParser(`export let x = 5\n`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.declKind).toBe("let");
+        }
+    });
+});

package/dist/lib/parsers/exportNode.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "vitest";
+import { graphNodeParser, functionParser } from "./parsers.js";
+describe("export node", () => {
+    it("parses export node", () => {
+        const result = graphNodeParser(`export node main() {\n  print("hello")\n}`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.nodeName).toBe("main");
+        }
+    });
+    it("parses node without export", () => {
+        const result = graphNodeParser(`node main() {\n  print("hello")\n}`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBeUndefined();
+        }
+    });
+});
+describe("function modifier order", () => {
+    it("parses export safe def", () => {
+        const result = functionParser(`export safe def foo() {\n  return 1\n}`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.safe).toBe(true);
+        }
+    });
+    it("parses safe export def (any order)", () => {
+        const result = functionParser(`safe export def foo() {\n  return 1\n}`);
+        expect(result.success).toBe(true);
+        if (result.success) {
+            expect(result.result.exported).toBe(true);
+            expect(result.result.safe).toBe(true);
+        }
+    });
+});

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

@@ -129,7 +129,7 @@ export declare const matchBlockParser: Parser<{
 export declare const importNodeStatmentParser: Parser<ImportNodeStatement>;
 export declare const importStatmentParser: Parser<ImportStatement>;
 export declare const assignmentParser: Parser<Assignment>;
-export declare const staticAssignmentParser: Parser<Assignment>;
+export declare const modifiedAssignmentParser: Parser<Assignment>;
 export declare const docStringParser: Parser<DocString>;
 export declare const bodyParser: (input: string) => ParserResult<AgencyNode[]>;
 export declare const _messageThreadParser: Parser<MessageThread>;