agency-lang 0.0.97 → 0.0.99

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

@@ -1,6 +1,7 @@
 import { AgencyConfig } from "../config.js";
 import { AgencyProgram } from "../index.js";
 import { type SymbolTable } from "../symbolTable.js";
+import { type ImportStrategy } from "../importStrategy.js";
 export declare function loadConfig(configPath?: string, verbose?: boolean): AgencyConfig;
 export declare function readStdin(): Promise<string>;
 export declare function parse(contents: string, config: AgencyConfig, applyTemplate?: boolean): AgencyProgram;
@@ -9,6 +10,7 @@ export declare function resetCompilationCache(): void;
 export declare function compile(config: AgencyConfig, inputFile: string, _outputFile?: string, options?: {
     ts?: boolean;
     symbolTable?: SymbolTable;
+    importStrategy?: ImportStrategy;
 }): string | null;
 export declare function run(config: AgencyConfig, inputFile: string, outputFile?: string, resumeFile?: string): void;
 export declare function format(contents: string, config: AgencyConfig): Promise<string>;

package/dist/lib/cli/commands.js

@@ -9,6 +9,7 @@ import { transformSync } from "esbuild";
 import * as fs from "fs";
 import * as path from "path";
 import { getStdlibDir, isPkgImport, isStdlibImport, resolveAgencyImportPath, } from "../importPaths.js";
+import { CompileStrategy, RunStrategy } from "../importStrategy.js";
 import { parseAgency } from "../parser.js";
 import { findRecursively, getImports } from "./util.js";
 // Load configuration from agency.json
@@ -126,8 +127,11 @@ export function compile(config, inputFile, _outputFile, options) {
     }
     const imports = getImports(resolvedProgram);
     for (const importPath of imports) {
+        // stdlib and pkg imports are pre-compiled; don't recompile them
+        if (isStdlibImport(importPath) || isPkgImport(importPath))
+            continue;
         const absPath = resolveAgencyImportPath(importPath, absoluteInputFile);
-        if (config.restrictImports && !isStdlibImport(importPath) && !isPkgImport(importPath)) {
+        if (config.restrictImports) {
             const projectRoot = process.cwd();
             if (!absPath.startsWith(projectRoot + path.sep) &&
                 absPath !== projectRoot) {
@@ -136,12 +140,21 @@ export function compile(config, inputFile, _outputFile, options) {
         }
         compile(config, absPath, undefined, { ...options, symbolTable });
     }
-    // Update the import path in the AST to reference the new .ts file
+    // Rewrite import paths in the AST using the import strategy
+    const strategy = options?.importStrategy ?? new CompileStrategy({ targetExt: ext });
+    const nonAgencyImports = [];
     resolvedProgram.nodes.forEach((node) => {
-        if (node.type === "importStatement" && !isStdlibImport(node.modulePath) && !isPkgImport(node.modulePath)) {
-            node.modulePath = node.modulePath.replace(".agency", ext);
+        if (node.type !== "importStatement")
+            return;
+        if (isStdlibImport(node.modulePath) || isPkgImport(node.modulePath))
+            return;
+        node.modulePath = strategy.rewriteImport(node.modulePath, absoluteInputFile);
+        // Collect non-Agency imports for dependency preparation
+        if (!node.modulePath.endsWith(".agency")) {
+            nonAgencyImports.push(node.modulePath);
         }
     });
+    strategy.prepareDependencies(nonAgencyImports, absoluteInputFile);
     const moduleId = path.relative(process.cwd(), absoluteInputFile);
     const generatedCode = generateTypeScript(resolvedProgram, config, info, moduleId);
     if (options?.ts) {
@@ -161,8 +174,8 @@ export function compile(config, inputFile, _outputFile, options) {
     return outputFile;
 }
 export function run(config, inputFile, outputFile, resumeFile) {
-    // Compile the file
-    const output = compile(config, inputFile, outputFile);
+    // Compile the file with RunStrategy so dependencies are prepared for execution
+    const output = compile(config, inputFile, outputFile, { importStrategy: new RunStrategy() });
     if (output === null) {
         console.error("Error: No output file generated.");
         process.exit(1);

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

@@ -4,4 +4,5 @@ export declare function debug(config: AgencyConfig, _inputFile: string, options?
     rewindSize?: number;
     trace?: string;
     checkpoint?: string;
+    distDir?: string;
 }): Promise<void>;

package/dist/lib/cli/debug.js

@@ -1,5 +1,6 @@
 import { compile } from "./commands.js";
-import { pickANode } from "./util.js";
+import { RunStrategy } from "../importStrategy.js";
+import { pickANode, resolveCompiledFile } from "./util.js";
 import { parseAgency } from "../parser.js";
 import { getNodesOfType } from "../utils/node.js";
 import { DebuggerDriver } from "../debugger/driver.js";
@@ -77,25 +78,45 @@ export async function debug(config, _inputFile, options = {}) {
             }
             traceCheckpoints = [cp];
         }
-        // Force debugger mode so the builder emits debugStep() calls
-        const debugConfig = { ...config, debugger: true };
-        // Compile the .agency file to .js
-        const outputFile = compile(debugConfig, inputFile);
-        if (outputFile === null) {
-            console.error("Error: No output file generated.");
-            process.exit(1);
+        // Resolve distDir from CLI flag or config
+        const distDir = options.distDir ?? config.distDir;
+        let absOutput;
+        if (distDir) {
+            // distDir mode: import pre-compiled JS from the dist directory
+            const compiledPath = resolveCompiledFile(distDir, inputFile);
+            // Warn if source is newer than compiled output
+            const sourceMtime = fs.statSync(inputFile).mtimeMs;
+            const compiledMtime = fs.statSync(compiledPath).mtimeMs;
+            if (sourceMtime > compiledMtime) {
+                console.warn(`Warning: ${inputFile} is newer than ${compiledPath}.\n` +
+                    `You may need to recompile before debugging.`);
+            }
+            absOutput = compiledPath;
+        }
+        else {
+            // Normal mode: compile the .agency file to .js on the fly
+            const debugConfig = { ...config, debugger: true };
+            const outputFile = compile(debugConfig, inputFile, undefined, { importStrategy: new RunStrategy() });
+            if (outputFile === null) {
+                console.error("Error: No output file generated.");
+                process.exit(1);
+            }
+            absOutput = path.resolve(outputFile);
         }
         // Signal to stdlib UI components that they should fall back to console.log
         // instead of drawing their own TUI, which would conflict with the debugger.
         process.env.AGENCY_DEBUGGER = "1";
         // Dynamically import the compiled module
-        const absOutput = path.resolve(outputFile);
         const mod = await import(absOutput);
         // Get the source map from the module
         const sourceMap = mod.__sourceMap ?? {};
+        if (distDir && Object.keys(sourceMap).length === 0) {
+            console.warn("Warning: The compiled module has an empty source map. Was it compiled with instrument: false?\n" +
+                "The debugger may not be able to step through code.");
+        }
         // Parse the .agency file to get the list of graph nodes
         const contents = fs.readFileSync(inputFile, "utf-8");
-        const parseResult = parseAgency(contents, debugConfig);
+        const parseResult = parseAgency(contents, config);
         if (!parseResult.success) {
             console.error("Error: Could not parse Agency file.");
             process.exit(1);

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

@@ -21,6 +21,11 @@ export type InterruptHandler = {
     resolvedValue?: any;
     expectedMessage?: string;
 };
+/**
+ * Resolve the compiled .js file for an .agency file from a distDir.
+ * Throws if the compiled file doesn't exist.
+ */
+export declare function resolveCompiledFile(distDir: string, agencyFile: string): string;
 type ExecuteNodeArgs = {
     config: AgencyConfig;
     agencyFile: string;

package/dist/lib/cli/util.js

@@ -11,6 +11,7 @@ import { isAgencyImport, resolveAgencyImportPath, getStdlibDir } from "../import
 import renderEvaluate from "../templates/cli/evaluate.js";
 import renderJudgeEvaluate from "../templates/cli/judgeEvaluate.js";
 import { compile } from "./commands.js";
+import { RunStrategy } from "../importStrategy.js";
 import { parseAgency } from "../parser.js";
 export function parseTarget(target) {
     const colonIndex = target.lastIndexOf(":");
@@ -103,13 +104,39 @@ export async function promptForArgs(selectedNode) {
     }
     return { hasArgs, argsString };
 }
+/**
+ * Resolve the compiled .js file for an .agency file from a distDir.
+ * Throws if the compiled file doesn't exist.
+ */
+export function resolveCompiledFile(distDir, agencyFile) {
+    const basename = path.basename(agencyFile, ".agency") + ".js";
+    const compiledPath = path.resolve(distDir, basename);
+    if (!fs.existsSync(compiledPath)) {
+        throw new Error(`Compiled file not found: ${compiledPath}\n` +
+            `Make sure you have compiled your Agency files and that distDir is correct.`);
+    }
+    return compiledPath;
+}
 export async function executeNodeAsync({ config, agencyFile, nodeName, hasArgs, argsString, interruptHandlers, }) {
-    compile(config, agencyFile);
+    const distDir = config.distDir;
+    let compiledPath;
+    if (distDir) {
+        compiledPath = resolveCompiledFile(distDir, agencyFile);
+    }
+    else {
+        compiledPath = compile(config, agencyFile, undefined, { importStrategy: new RunStrategy() });
+    }
     const baseName = agencyFile.replace(".agency", "");
     const evaluateFile = `${baseName}.evaluate.js`;
     const resultsFile = `${baseName}.evaluate.json`;
+    // The template imports via "./${filename}", so compute a relative path
+    // from the evaluate script's directory to the compiled module.
+    let importSpecifier = path.relative(path.dirname(evaluateFile), compiledPath).replace(/\\/g, "/");
+    if (!importSpecifier.startsWith(".")) {
+        importSpecifier = `./${importSpecifier}`;
+    }
     const evaluateScript = renderEvaluate({
-        filename: path.basename(agencyFile).replace(".agency", ".js"),
+        filename: importSpecifier,
         nodeName,
         hasArgs,
         args: argsString,
@@ -137,10 +164,23 @@ export async function executeNodeAsync({ config, agencyFile, nodeName, hasArgs,
     }
 }
 export function executeNode(args) {
-    const outFile = args.agencyFile.replace(".agency", ".js");
-    compile(args.config, args.agencyFile);
+    const distDir = args.config.distDir;
+    let compiledPath;
+    if (distDir) {
+        compiledPath = resolveCompiledFile(distDir, args.agencyFile);
+    }
+    else {
+        compiledPath = compile(args.config, args.agencyFile, undefined, { importStrategy: new RunStrategy() });
+    }
+    const evaluateFile = "__evaluate.js";
+    // The template imports via "./${filename}", so compute a relative path
+    // from the evaluate script's directory to the compiled module.
+    let importSpecifier = path.relative(path.dirname(evaluateFile), compiledPath).replace(/\\/g, "/");
+    if (!importSpecifier.startsWith(".")) {
+        importSpecifier = `./${importSpecifier}`;
+    }
     const evaluateScript = renderEvaluate({
-        filename: outFile,
+        filename: importSpecifier,
         nodeName: args.nodeName,
         hasArgs: args.hasArgs,
         args: args.argsString,
@@ -150,7 +190,6 @@ export function executeNode(args) {
             : undefined,
         resultsFilename: "__evaluate.json",
     });
-    const evaluateFile = "__evaluate.js";
     fs.writeFileSync(evaluateFile, evaluateScript);
     execFileSync("node", [evaluateFile], { stdio: "inherit" });
     const results = readFileSync("__evaluate.json", "utf-8");

package/dist/lib/config.d.ts

@@ -102,6 +102,10 @@ export interface AgencyConfig {
     /** Directory for auto-generated trace files. Each execution creates a new file
      *  named <timestamp>_<id>.agencytrace. */
     traceDir?: string;
+    /** Directory containing pre-compiled JS output (e.g., "dist").
+     *  When set, the debugger imports compiled modules from this directory
+     *  instead of compiling on the fly. Resolved relative to cwd. */
+    distDir?: string;
     /** Test runner configuration */
     test?: {
         /** Number of test files to run in parallel. Default: 1 (sequential). */

package/dist/lib/debugger/ui.js

@@ -395,7 +395,7 @@ export class DebuggerUI {
     renderSourcePane() {
         const moduleId = this.state.getModuleId();
         const currentLine = this.state.getCurrentLine();
-        const filePath = moduleId;
+        const filePath = this.state.resolveModulePath(moduleId, [".agency"]) ?? moduleId;
         const fileContent = readSourceFile(filePath);
         const highlighted = syntaxHighlight(fileContent, "ts");
         const lines = highlighted.split("\n");

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

@@ -19,6 +19,12 @@ export declare class UIState {
     private sourceMapCache;
     constructor();
     static fromCheckpoint(checkpoint: Checkpoint | undefined): UIState;
+    /**
+     * Resolve a moduleId (e.g., "stdlib/index.agency") to an actual file path,
+     * trying the given extensions. Handles stdlib modules that live inside
+     * node_modules/agency-lang/stdlib/ when running from an external project.
+     */
+    resolveModulePath(moduleId: string, extensions: string[]): string | null;
     private agencyToJsFile;
     setCheckpoint(checkpoint: Checkpoint | undefined): Promise<void>;
     setWithOverrides(obj: Record<string, unknown>, array: ValWithOverride[]): void;

package/dist/lib/debugger/uiState.js

@@ -1,5 +1,6 @@
 import { Checkpoint } from "../runtime/state/checkpointStore.js";
 import { GlobalStore } from "../runtime/state/globalStore.js";
+import { getStdlibDir } from "../importPaths.js";
 import fs from "fs";
 import path from "path";
 export class UIState {
@@ -30,17 +31,34 @@ export class UIState {
         uiState.setCheckpoint(checkpoint);
         return uiState;
     }
-    agencyToJsFile(agencyFile) {
-        const tsFile = agencyFile.replace(/\.agency$/, ".ts");
-        if (fs.existsSync(tsFile)) {
-            return tsFile;
+    /**
+     * Resolve a moduleId (e.g., "stdlib/index.agency") to an actual file path,
+     * trying the given extensions. Handles stdlib modules that live inside
+     * node_modules/agency-lang/stdlib/ when running from an external project.
+     */
+    resolveModulePath(moduleId, extensions) {
+        // Try the path as-is first (works when running from the agency-lang repo)
+        for (const ext of extensions) {
+            const candidate = moduleId.replace(/\.agency$/, ext);
+            if (fs.existsSync(candidate))
+                return candidate;
         }
-        const jsFile = agencyFile.replace(/\.agency$/, ".js");
-        if (fs.existsSync(jsFile)) {
-            return jsFile;
+        // If the moduleId refers to a stdlib file, resolve against the actual
+        // stdlib directory (handles npm-installed packages where stdlib lives
+        // in node_modules/agency-lang/stdlib/)
+        if (moduleId.includes("stdlib")) {
+            const basename = path.basename(moduleId);
+            for (const ext of extensions) {
+                const candidate = path.join(getStdlibDir(), basename).replace(/\.agency$/, ext);
+                if (fs.existsSync(candidate))
+                    return candidate;
+            }
         }
         return null;
     }
+    agencyToJsFile(agencyFile) {
+        return this.resolveModulePath(agencyFile, [".js", ".ts"]);
+    }
     async setCheckpoint(checkpoint) {
         const cp = Checkpoint.fromJSON(checkpoint);
         if (!cp) {

package/dist/lib/importPaths.test.js

@@ -1,5 +1,6 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
 import { findPackageRoot, resolveAgencyImportPath, getStdlibDir, toCompiledImportPath, isPkgImport, isAgencyImport, parsePkgImport, resolvePkgAgencyPath, } from "./importPaths.js";
+import { CompileStrategy, RunStrategy } from "./importStrategy.js";
 import { buildSymbolTable } from "./symbolTable.js";
 import * as fs from "fs";
 import * as os from "os";
@@ -235,3 +236,73 @@ describe("buildSymbolTable with pkg:: imports", () => {
         }
     });
 });
+describe("CompileStrategy", () => {
+    const jsStrategy = new CompileStrategy({ targetExt: ".js" });
+    const tsStrategy = new CompileStrategy({ targetExt: ".ts" });
+    it("should rewrite .agency to .js", () => {
+        expect(jsStrategy.rewriteImport("./foo.agency", "/src/main.agency")).toBe("./foo.js");
+    });
+    it("should rewrite .agency to .ts with --ts", () => {
+        expect(tsStrategy.rewriteImport("./foo.agency", "/src/main.agency")).toBe("./foo.ts");
+    });
+    it("should leave .js imports untouched", () => {
+        expect(jsStrategy.rewriteImport("./tools.js", "/src/main.agency")).toBe("./tools.js");
+    });
+    it("should leave .ts imports untouched", () => {
+        expect(jsStrategy.rewriteImport("./tools.ts", "/src/main.agency")).toBe("./tools.ts");
+    });
+    it("should leave bare specifiers untouched", () => {
+        expect(jsStrategy.rewriteImport("nanoid", "/src/main.agency")).toBe("nanoid");
+    });
+});
+describe("RunStrategy", () => {
+    const strategy = new RunStrategy();
+    it("should rewrite .agency to .js", () => {
+        expect(strategy.rewriteImport("./foo.agency", "/src/main.agency")).toBe("./foo.js");
+    });
+    it("should rewrite .ts to .js", () => {
+        expect(strategy.rewriteImport("./tools.ts", "/src/main.agency")).toBe("./tools.js");
+    });
+    it("should leave .js imports as-is", () => {
+        expect(strategy.rewriteImport("./tools.js", "/src/main.agency")).toBe("./tools.js");
+    });
+    it("should leave bare specifiers untouched", () => {
+        expect(strategy.rewriteImport("nanoid", "/src/main.agency")).toBe("nanoid");
+    });
+});
+describe("RunStrategy.prepareDependencies", () => {
+    let tmpDir;
+    const strategy = new RunStrategy();
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "agency-run-strategy-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("should compile .ts to .js when .js doesn't exist", () => {
+        const tsFile = path.join(tmpDir, "bar.ts");
+        const jsFile = path.join(tmpDir, "bar.js");
+        fs.writeFileSync(tsFile, "export const x: number = 1;");
+        const fromFile = path.join(tmpDir, "main.agency");
+        strategy.prepareDependencies(["./bar.js"], fromFile);
+        expect(fs.existsSync(jsFile)).toBe(true);
+        const content = fs.readFileSync(jsFile, "utf-8");
+        expect(content).toContain("const x = 1");
+    });
+    it("should not overwrite existing .js files", () => {
+        const jsFile = path.join(tmpDir, "bar.js");
+        fs.writeFileSync(jsFile, "// original");
+        const fromFile = path.join(tmpDir, "main.agency");
+        strategy.prepareDependencies(["./bar.js"], fromFile);
+        expect(fs.readFileSync(jsFile, "utf-8")).toBe("// original");
+    });
+    it("should throw when neither .js nor .ts exists", () => {
+        const fromFile = path.join(tmpDir, "main.agency");
+        expect(() => strategy.prepareDependencies(["./bar.js"], fromFile)).toThrow(/Cannot resolve import/);
+    });
+    it("should skip bare specifiers", () => {
+        const fromFile = path.join(tmpDir, "main.agency");
+        // Should not throw — bare specifiers are skipped
+        strategy.prepareDependencies(["nanoid"], fromFile);
+    });
+});

package/dist/lib/importStrategy.d.ts

@@ -0,0 +1,37 @@
+export type CompileOptions = {
+    /** Extension for .agency rewrites: ".js" or ".ts" */
+    targetExt: ".js" | ".ts";
+};
+export interface ImportStrategy {
+    /**
+     * Rewrite an import path for the output.
+     * Handles .agency, .js, and .ts imports.
+     */
+    rewriteImport(modulePath: string, sourceFile: string): string;
+    /**
+     * Ensure all non-Agency dependencies are available for execution.
+     * Called after compilation, before the output is executed.
+     * Errors if a dependency can't be resolved.
+     */
+    prepareDependencies(imports: string[], sourceFile: string): void;
+}
+/**
+ * Strategy for `agency compile`: produces output for a downstream build pipeline.
+ * Leaves .js/.ts imports untouched. Only rewrites .agency imports.
+ */
+export declare class CompileStrategy implements ImportStrategy {
+    protected options: CompileOptions;
+    constructor(options: CompileOptions);
+    rewriteImport(modulePath: string, _sourceFile: string): string;
+    prepareDependencies(_imports: string[], _sourceFile: string): void;
+}
+/**
+ * Strategy for `agency run` / `agency debug` / `agency test`: compiles and
+ * immediately executes. All imports must resolve to .js files that exist on disk.
+ * Compiles .ts dependencies to .js via esbuild when needed.
+ */
+export declare class RunStrategy extends CompileStrategy {
+    constructor();
+    rewriteImport(modulePath: string, sourceFile: string): string;
+    prepareDependencies(imports: string[], sourceFile: string): void;
+}

package/dist/lib/importStrategy.js

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+import { transformSync } from "esbuild";
+/**
+ * Strategy for `agency compile`: produces output for a downstream build pipeline.
+ * Leaves .js/.ts imports untouched. Only rewrites .agency imports.
+ */
+export class CompileStrategy {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    rewriteImport(modulePath, _sourceFile) {
+        if (modulePath.endsWith(".agency")) {
+            return modulePath.replace(/\.agency$/, this.options.targetExt);
+        }
+        return modulePath;
+    }
+    prepareDependencies(_imports, _sourceFile) {
+        // No-op — user's build pipeline handles dependencies
+    }
+}
+/**
+ * Strategy for `agency run` / `agency debug` / `agency test`: compiles and
+ * immediately executes. All imports must resolve to .js files that exist on disk.
+ * Compiles .ts dependencies to .js via esbuild when needed.
+ */
+export class RunStrategy extends CompileStrategy {
+    constructor() {
+        super({ targetExt: ".js" });
+    }
+    rewriteImport(modulePath, sourceFile) {
+        if (modulePath.endsWith(".agency")) {
+            return super.rewriteImport(modulePath, sourceFile);
+        }
+        // Always produce .js — Node needs .js at runtime
+        return modulePath.replace(/\.ts$/, ".js");
+    }
+    prepareDependencies(imports, sourceFile) {
+        for (const imp of imports) {
+            if (!imp.startsWith("./") && !imp.startsWith("../"))
+                continue;
+            if (!imp.endsWith(".js"))
+                continue;
+            const resolved = path.resolve(path.dirname(sourceFile), imp);
+            if (fs.existsSync(resolved))
+                continue;
+            const tsPath = resolved.replace(/\.js$/, ".ts");
+            if (fs.existsSync(tsPath)) {
+                const tsCode = fs.readFileSync(tsPath, "utf-8");
+                const result = transformSync(tsCode, {
+                    loader: "ts",
+                    format: "esm",
+                    supported: { "top-level-await": true },
+                });
+                fs.writeFileSync(resolved, result.code);
+            }
+            else {
+                throw new Error(`Cannot resolve import '${imp}' from '${sourceFile}'.\n` +
+                    `Tried: ${resolved}, ${tsPath} — neither file exists.`);
+            }
+        }
+    }
+}

package/dist/lib/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "0.0.96";
+export declare const VERSION = "0.0.99";

package/dist/lib/version.js

@@ -1 +1 @@
-export const VERSION = "0.0.96";
+export const VERSION = "0.0.99";

package/dist/scripts/agency.js

@@ -339,6 +339,7 @@ program
     .option("--rewind-size <n>", "Rolling checkpoint window size", "30")
     .option("--trace <file>", "Load and inspect a trace file")
     .option("--checkpoint <file>", "Load and inspect a checkpoint file")
+    .option("--dist-dir <dir>", "Import pre-compiled JS from this directory instead of compiling on the fly")
     .action(async (file, options) => {
     const config = getConfig();
     await debug(config, file, {
@@ -346,6 +347,7 @@ program
         rewindSize: parseInt(options.rewindSize, 10),
         trace: options.trace,
         checkpoint: options.checkpoint,
+        distDir: options.distDir,
     });
 });
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agency-lang",
-  "version": "0.0.97",
+  "version": "0.0.99",
   "description": "The Agency language",
   "main": "lib/index.js",
   "scripts": {