agency-lang 0.0.59 → 0.0.60

package/README.md

@@ -22,10 +22,10 @@ agency run infile.agency
 agency infile.agency
 ```
 
-Note that the generated files use several other libraries that you will need to install as well:
+Note that the generated files use a couple of other libraries that you will need to install as well:
 
 ```bash
-pnpm i nanoid openai zod smoltalk
+pnpm i nanoid zod smoltalk
 ```
 
 ## troubleshooting

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

@@ -5,7 +5,6 @@ export declare function readStdin(): Promise<string>;
 export declare function parse(contents: string, config: AgencyConfig): AgencyProgram;
 export declare function readFile(inputFile: string): string;
 export declare function renderGraph(contents: string, config: AgencyConfig): void;
-export declare function getImports(program: AgencyProgram): string[];
 export declare function compile(config: AgencyConfig, inputFile: string, _outputFile?: string): string | null;
 export declare function run(config: AgencyConfig, inputFile: string, outputFile?: string): void;
 export declare function format(contents: string, config: AgencyConfig): Promise<string>;

package/dist/lib/cli/commands.js

@@ -6,7 +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";
+import { findRecursively, getImports } from "./util.js";
 // Load configuration from agency.json
 export function loadConfig(configPath, verbose = false) {
     let config = {};
@@ -83,17 +83,6 @@ export function renderGraph(contents, config) {
         console.log(subgraph);
     });
 }
-export function getImports(program) {
-    const toolAndNodeImports = program.nodes
-        .filter((node) => node.type === "importNodeStatement" ||
-        node.type === "importToolStatement")
-        .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"))
-        .map((node) => node.modulePath.trim());
-    return [...toolAndNodeImports, ...importStatements];
-}
 const compiledFiles = new Set();
 export function compile(config, inputFile, _outputFile) {
     // Check if the input is a directory

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

@@ -0,0 +1,3 @@
+import { AgencyConfig } from "../config.js";
+import { Result } from "../types/result.js";
+export declare function remoteRun(config: AgencyConfig, filename: string): Promise<Result<any>>;

package/dist/lib/cli/remoteRun.js

@@ -0,0 +1,23 @@
+import { getStatelogClient } from "../statelogClient.js";
+import { getImportsRecursively } from "./util.js";
+import fs from "fs";
+export async function remoteRun(config, filename) {
+    const client = getStatelogClient({
+        host: config.log?.host || "http://localhost:1065",
+        projectId: config.log?.projectId || "agency-lang",
+        debugMode: config.log?.debugMode || false,
+    });
+    const imports = getImportsRecursively(filename);
+    const allFiles = [filename, ...imports];
+    const files = allFiles.map((file) => ({
+        name: file,
+        contents: fs.readFileSync(file, "utf-8"),
+    }));
+    const result = await client.remoteRun({
+        files,
+        entrypoint: filename,
+        args: [],
+    });
+    console.log(JSON.stringify(result));
+    return result;
+}

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

@@ -0,0 +1,3 @@
+import { AgencyConfig } from "../config.js";
+import { UploadResult } from "../statelogClient.js";
+export declare function upload(config: AgencyConfig, inputFile: string): Promise<UploadResult>;

package/dist/lib/cli/upload.js

@@ -0,0 +1,50 @@
+import { getStatelogClient, mergeUploadResults, } from "../statelogClient.js";
+import fs from "fs";
+import path from "path";
+import { findRecursively, getImportsRecursively } from "./util.js";
+export async function upload(config, inputFile) {
+    // Check if the input is a directory
+    const stats = fs.statSync(inputFile);
+    const verbose = config.verbose ?? false;
+    if (stats.isDirectory()) {
+        const results = [];
+        for (const { path } of findRecursively(inputFile)) {
+            const result = await upload(config, path);
+            results.push(result);
+        }
+        const allResults = mergeUploadResults(results);
+        if (!allResults.success) {
+            console.log("Failure uploading files", allResults.error);
+        }
+        else {
+            console.log("Successfully uploaded files to Statelog");
+            console.log(allResults.value);
+        }
+        return allResults;
+    }
+    const imports = getImportsRecursively(inputFile);
+    const allFiles = [inputFile, ...imports];
+    const files = allFiles.map((file) => ({
+        name: path.relative(process.cwd(), file),
+        contents: fs.readFileSync(file, "utf-8"),
+    }));
+    const client = getStatelogClient({
+        host: config.log?.host || "http://localhost:1065",
+        projectId: config.log?.projectId || "agency-lang",
+        debugMode: config.log?.debugMode || false,
+    });
+    console.log(files);
+    const result = await client.upload({
+        projectId: config.log?.projectId || "agency-lang",
+        entrypoint: inputFile,
+        files,
+    });
+    if (!result.success) {
+        console.log("Failure uploading files", result.error);
+    }
+    else {
+        console.log("Successfully uploaded files to Statelog");
+        console.log(result.value);
+    }
+    return result;
+}

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

@@ -1,4 +1,4 @@
-import { GraphNodeDefinition, VariableType } from "../types.js";
+import { AgencyProgram, GraphNodeDefinition, VariableType } from "../types.js";
 import { AgencyConfig } from "../config.js";
 export declare function parseTarget(target: string): {
     filename: string;
@@ -40,3 +40,5 @@ export declare function executeJudge(actualOutput: string, expectedOutput: strin
 export declare function findRecursively(dirName: string, ext?: string, searched?: string[]): Generator<{
     path: string;
 }>;
+export declare function getImportsRecursively(filename: string, visited?: Set<string>): string[];
+export declare function getImports(program: AgencyProgram): string[];

package/dist/lib/cli/util.js

@@ -5,6 +5,7 @@ import { execSync } from "child_process";
 import renderEvaluate from "../templates/cli/evaluate.js";
 import renderJudgeEvaluate from "../templates/cli/judgeEvaluate.js";
 import { compile } from "./commands.js";
+import { parseAgency } from "../parser.js";
 export function parseTarget(target) {
     const colonIndex = target.lastIndexOf(":");
     if (colonIndex === -1) {
@@ -179,3 +180,38 @@ export function* findRecursively(dirName, ext = ".agency", searched = []) {
         }
     }
 }
+export function getImportsRecursively(filename, visited = new Set()) {
+    if (visited.has(filename)) {
+        return [];
+    }
+    visited.add(filename);
+    const contents = fs.readFileSync(filename, "utf-8");
+    const parsed = parseAgency(contents, { verbose: false });
+    if (!parsed.success) {
+        console.error(`Error parsing ${filename}:`, parsed);
+        return [];
+    }
+    const program = parsed.result;
+    const imports = getImports(program);
+    for (const imp of imports) {
+        const importedFile = path.resolve(path.dirname(filename), imp);
+        if (fs.existsSync(importedFile)) {
+            imports.push(...getImportsRecursively(importedFile, visited));
+        }
+        else {
+            console.warn(`Warning: Imported file ${importedFile} not found.`);
+        }
+    }
+    return imports;
+}
+export function getImports(program) {
+    const toolAndNodeImports = program.nodes
+        .filter((node) => node.type === "importNodeStatement" ||
+        node.type === "importToolStatement")
+        .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"))
+        .map((node) => node.modulePath.trim());
+    return [...toolAndNodeImports, ...importStatements];
+}

package/dist/lib/index.d.ts

@@ -3,3 +3,4 @@ export * from "./types.js";
 export * from "./backends/index.js";
 export * from "./simplemachine/index.js";
 export * from "./statelogClient.js";
+export * from "smoltalk";

package/dist/lib/index.js

@@ -3,3 +3,4 @@ export * from "./types.js";
 export * from "./backends/index.js";
 export * from "./simplemachine/index.js";
 export * from "./statelogClient.js";
+export * from "smoltalk";

package/dist/lib/preprocessors/typescriptPreprocessor.js

@@ -1,4 +1,5 @@
 import { BUILTIN_FUNCTIONS, BUILTIN_FUNCTIONS_TO_ASYNC, } from "../config.js";
+import { getImportedNames, } from "../types.js";
 import { getAllVariablesInBody, walkNodes } from "../utils/node.js";
 export class TypescriptPreprocessor {
     program;
@@ -926,8 +927,10 @@ export class TypescriptPreprocessor {
                 }
             }
             else if (node.type === "importStatement") {
-                // todo imported names need to get parsed better,
-                // into an array
+                const importedNames = node.importedNames.map(getImportedNames).flat();
+                importedNames.forEach((n) => {
+                    varNameToScope[n] = "global";
+                });
             }
             else if (node.type === "importNodeStatement") {
                 node.importedNodes.forEach((n) => {

package/dist/lib/statelogClient.d.ts

@@ -1,4 +1,13 @@
 import { JSONEdge } from "./types.js";
+import { Result } from "./types/result.js";
+export type AgencyFile = {
+    name: string;
+    contents: string;
+};
+export type UploadResult = Result<{
+    endpointUrls: string[];
+}>;
+export declare function mergeUploadResults(_results: UploadResult[]): UploadResult;
 export declare class StatelogClient {
     private host;
     private debugMode;
@@ -70,5 +79,28 @@ export declare class StatelogClient {
         model?: string;
         timeTaken?: number;
     }): Promise<void>;
+    upload({ projectId, entrypoint, files, }: {
+        projectId: string;
+        entrypoint: string;
+        files: AgencyFile[];
+    }): Promise<UploadResult>;
+    remoteRun({ files, entrypoint, args, }: {
+        files: AgencyFile[];
+        entrypoint: string;
+        args?: any[];
+    }): Promise<Result<any>>;
+    hitServer({ userId, projectId, filename, nodeName, body, }: {
+        userId: string;
+        projectId: string;
+        filename: string;
+        nodeName: string;
+        body: string;
+    }): Promise<Result<any>>;
     post(body: Record<string, any>): Promise<void>;
 }
+export declare function getStatelogClient(config: {
+    host: string;
+    traceId?: string;
+    projectId: string;
+    debugMode?: boolean;
+}): StatelogClient;

package/dist/lib/statelogClient.js

@@ -1,4 +1,16 @@
 import { nanoid } from "nanoid";
+import { failure, success } from "./types/result.js";
+import { mergeResults } from "smoltalk";
+export function mergeUploadResults(_results) {
+    const results = mergeResults(_results);
+    if (!results.success) {
+        return failure(results.error);
+    }
+    const endpointUrls = results.value.flatMap((r) => r.endpointUrls);
+    return success({
+        endpointUrls,
+    });
+}
 export class StatelogClient {
     host;
     debugMode;
@@ -106,6 +118,128 @@ export class StatelogClient {
             timeTaken,
         });
     }
+    async upload({ projectId, entrypoint, files, }) {
+        try {
+            const fullUrl = new URL(`/api/projects/${projectId}/upload`, this.host);
+            const url = fullUrl.toString();
+            const postBody = JSON.stringify({ entrypoint, files });
+            console.log({ entrypoint, files }, postBody);
+            const result = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: postBody,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to send statelog:", err);
+            });
+            if (result) {
+                if (!result.ok) {
+                    if (this.debugMode)
+                        console.error("Failed to upload files to statelog:", {
+                            result,
+                            url,
+                            files,
+                        });
+                    return failure("Failed to upload files to statelog");
+                }
+                return (await result.json());
+            }
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error sending log in statelog client:", err, {
+                    host: this.host,
+                });
+        }
+        return failure("Error uploading files to statelog");
+    }
+    async remoteRun({ files, entrypoint, args, }) {
+        try {
+            const fullUrl = new URL(`/api/run`, this.host);
+            const url = fullUrl.toString();
+            const body = JSON.stringify({
+                files,
+                entrypoint,
+                args,
+            });
+            console.log({ entrypoint, args }, body);
+            const result = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to run on statelog:", err);
+            });
+            if (result) {
+                if (!result.ok) {
+                    if (this.debugMode) {
+                        const responseBody = await result.text();
+                        console.error("Failed to run on statelog:", {
+                            result,
+                            url,
+                            body,
+                            responseBody,
+                        });
+                    }
+                    return failure("Failed to run on statelog");
+                }
+                return (await result.json());
+            }
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error running on statelog client:", err, {
+                    host: this.host,
+                });
+        }
+        return failure("Error running on statelog");
+    }
+    async hitServer({ userId, projectId, filename, nodeName, body, }) {
+        try {
+            const fullUrl = new URL(`/run/${userId}/${projectId}/${filename}/${nodeName}`, this.host);
+            const url = fullUrl.toString();
+            const result = await fetch(url, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: body,
+            }).catch((err) => {
+                if (this.debugMode)
+                    console.error("Failed to run on statelog:", err);
+            });
+            if (result) {
+                if (!result.ok) {
+                    if (this.debugMode) {
+                        const responseBody = await result.text();
+                        console.error("Failed to run on statelog:", {
+                            result,
+                            url,
+                            body,
+                            responseBody,
+                        });
+                    }
+                    return failure("Failed to run on statelog");
+                }
+                return (await result.json());
+            }
+        }
+        catch (err) {
+            if (this.debugMode)
+                console.error("Error running on statelog client:", err, {
+                    host: this.host,
+                });
+        }
+        return failure("Error running on statelog");
+    }
     async post(body) {
         if (!this.host) {
             return;
@@ -142,3 +276,14 @@ export class StatelogClient {
         }
     }
 }
+export function getStatelogClient(config) {
+    const statelogConfig = {
+        host: config.host,
+        traceId: config.traceId || nanoid(),
+        apiKey: process.env.STATELOG_API_KEY || "",
+        projectId: config.projectId,
+        debugMode: config.debugMode || false,
+    };
+    const client = new StatelogClient(statelogConfig);
+    return client;
+}

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

@@ -0,0 +1,13 @@
+export type Success<T> = {
+    success: true;
+    value: T;
+};
+export type Failure = {
+    success: false;
+    error: string;
+};
+export type Result<T> = Success<T> | Failure;
+export declare function success<T>(value: T): Success<T>;
+export declare function failure(error: string): Failure;
+export declare function mergeResults<T>(results: Result<T>[]): Result<T[]>;
+export declare function resultMap<T, U>(result: Result<T>, fn: (value: T) => U): Result<U>;

package/dist/lib/types/result.js

@@ -0,0 +1,30 @@
+export function success(value) {
+    return { success: true, value };
+}
+export function failure(error) {
+    return { success: false, error };
+}
+export function mergeResults(results) {
+    const values = [];
+    const failures = [];
+    for (const result of results) {
+        if (!result.success) {
+            failures.push(result.error);
+        }
+        else {
+            values.push(result.value);
+        }
+    }
+    if (failures.length > 0) {
+        return failure(failures.join(", "));
+    }
+    return success(values);
+}
+export function resultMap(result, fn) {
+    if (result.success) {
+        return success(fn(result.value));
+    }
+    else {
+        return result;
+    }
+}

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

@@ -0,0 +1,3 @@
+export declare const __dirname: string;
+export declare const rootDir: string;
+export declare function loadEnv(): void;

package/dist/lib/utils/envfile.js

@@ -0,0 +1,30 @@
+// parse .env file if it exists into process.env
+import { existsSync, readFileSync } from "fs";
+import { resolve, join } from "path";
+export const __dirname = import.meta.dirname;
+export const rootDir = join(__dirname, "../../");
+export function loadEnv() {
+    const envfiles = [
+        resolve(rootDir, "..", ".env.local"),
+        resolve(rootDir, "..", ".env"),
+    ];
+    for (const envfile of envfiles) {
+        if (tryEnvFile(envfile)) {
+            break;
+        }
+    }
+}
+function tryEnvFile(envfile) {
+    if (existsSync(envfile)) {
+        const env = readFileSync(envfile, "utf-8");
+        env.split("\n").forEach((line) => {
+            if (line.trim() === "" || line.startsWith("#"))
+                return;
+            const [key, value] = line.split("=");
+            process.env[key] = value;
+            // console.log("Setting", color.yellow(key), "to", color.yellow(value));
+        });
+        return true;
+    }
+    return false;
+}

package/dist/scripts/agency.js

@@ -9,6 +9,10 @@ import { Command } from "commander";
 import * as fs from "fs";
 import { TarsecError } from "tarsec";
 import process from "process";
+import { upload } from "../lib/cli/upload.js";
+import { loadEnv } from "../lib/utils/envfile.js";
+import { remoteRun } from "../lib/cli/remoteRun.js";
+loadEnv();
 const program = new Command();
 program
     .name("agency")
@@ -221,6 +225,27 @@ program
     if (hasErrors)
         process.exit(1);
 });
+program
+    .command("upload")
+    .alias("up")
+    .alias("deploy")
+    .description("Upload files to Statelog")
+    .argument("[inputs...]", "Paths to .test.json files or directories")
+    .action(async (testFile) => {
+    console.log("Uploading", testFile);
+    for (const file of testFile) {
+        await upload(getConfig(), file);
+    }
+});
+program
+    .command("remote-run")
+    .alias("rr")
+    .description("Run files on Statelog remotely")
+    .argument("[filename]", "Paths to .test.json files or directories")
+    .action(async (filename) => {
+    console.log("Running files on Statelog remotely");
+    await remoteRun(getConfig(), filename);
+});
 // Default: treat unknown args as a file to run
 program.arguments("[file]").action((file) => {
     if (!file) {

package/package.json

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