@langchain/langgraph-cli 0.0.0-preview.4

package/dist/graph/parser/parser.mjs

@@ -0,0 +1,308 @@
+import * as ts from "typescript";
+import * as vfs from "@typescript/vfs";
+import * as path from "node:path";
+import dedent from "dedent";
+import { buildGenerator } from "./schema/types.mjs";
+import { fileURLToPath } from "node:url";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const compilerOptions = {
+    noEmit: true,
+    strict: true,
+    allowUnusedLabels: true,
+};
+export class SubgraphExtractor {
+    program;
+    checker;
+    sourceFile;
+    inferFile;
+    anyPregelType;
+    anyGraphType;
+    strict;
+    constructor(program, sourceFile, inferFile, options) {
+        this.program = program;
+        this.sourceFile = sourceFile;
+        this.inferFile = inferFile;
+        this.checker = program.getTypeChecker();
+        this.strict = options?.strict ?? false;
+        this.anyPregelType = this.findTypeByName("AnyPregel");
+        this.anyGraphType = this.findTypeByName("AnyGraph");
+    }
+    findTypeByName = (needle) => {
+        let result = undefined;
+        const visit = (node) => {
+            if (ts.isTypeAliasDeclaration(node)) {
+                const symbol = node.symbol;
+                if (symbol != null) {
+                    const name = this.checker
+                        .getFullyQualifiedName(symbol)
+                        .replace(/".*"\./, "");
+                    if (name === needle)
+                        result = this.checker.getTypeAtLocation(node);
+                }
+            }
+            if (result == null)
+                ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(this.inferFile, visit);
+        if (!result)
+            throw new Error(`Failed to find "${needle}" type`);
+        return result;
+    };
+    find = (root, predicate) => {
+        let result = undefined;
+        const visit = (node) => {
+            if (predicate(node)) {
+                result = node;
+            }
+            else {
+                ts.forEachChild(node, visit);
+            }
+        };
+        if (predicate(root))
+            return root;
+        ts.forEachChild(root, visit);
+        return result;
+    };
+    findSubgraphs = (node, namespace = []) => {
+        const findAllAddNodeCalls = (acc, node) => {
+            if (ts.isCallExpression(node)) {
+                const firstChild = node.getChildAt(0);
+                if (ts.isPropertyAccessExpression(firstChild) &&
+                    this.getText(firstChild.name) === "addNode") {
+                    let nodeName = "unknown";
+                    let variables = [];
+                    const [subgraphNode, callArg] = node.arguments;
+                    if (subgraphNode && ts.isStringLiteralLike(subgraphNode)) {
+                        nodeName = this.getText(subgraphNode);
+                        if ((nodeName.startsWith(`"`) && nodeName.endsWith(`"`)) ||
+                            (nodeName.startsWith(`'`) && nodeName.endsWith(`'`))) {
+                            nodeName = nodeName.slice(1, -1);
+                        }
+                    }
+                    if (callArg) {
+                        if (ts.isFunctionLike(callArg) ||
+                            ts.isCallLikeExpression(callArg)) {
+                            variables = this.reduceChildren(callArg, this.findSubgraphIdentifiers, []);
+                        }
+                        else if (ts.isIdentifier(callArg)) {
+                            variables = this.findSubgraphIdentifiers([], callArg);
+                        }
+                    }
+                    if (variables.length > 0) {
+                        if (variables.length > 1) {
+                            const targetName = [...namespace, nodeName].join("|");
+                            const errMsg = `Multiple unique subgraph invocations found for "${targetName}"`;
+                            if (this.strict)
+                                throw new Error(errMsg);
+                            console.warn(errMsg);
+                        }
+                        acc.push({
+                            namespace: namespace,
+                            node: nodeName,
+                            subgraph: variables[0],
+                        });
+                    }
+                }
+            }
+            return acc;
+        };
+        let subgraphs = this.reduceChildren(node, findAllAddNodeCalls, []);
+        // TODO: make this more strict, only traverse the flow graph only
+        // if no `addNode` calls were found
+        if (!subgraphs.length) {
+            const candidate = this.find(node, (node) => node && "flowNode" in node && node.flowNode);
+            if (candidate?.flowNode &&
+                this.isGraphOrPregelType(this.checker.getTypeAtLocation(candidate.flowNode.node))) {
+                subgraphs = this.findSubgraphs(candidate.flowNode.node, namespace);
+            }
+        }
+        // handle recursive behaviour
+        if (subgraphs.length > 0) {
+            return [
+                ...subgraphs,
+                ...subgraphs.map(({ subgraph, node }) => this.findSubgraphs(subgraph.node, [...namespace, node])),
+            ].flat();
+        }
+        return subgraphs;
+    };
+    getSubgraphsVariables = (name) => {
+        const sourceSymbol = this.checker.getSymbolAtLocation(this.sourceFile);
+        const exports = this.checker.getExportsOfModule(sourceSymbol);
+        const targetExport = exports.find((item) => item.name === name);
+        if (!targetExport)
+            throw new Error(`Failed to find export "${name}"`);
+        const varDecls = (targetExport.declarations ?? []).filter(ts.isVariableDeclaration);
+        return varDecls.flatMap((varDecl) => {
+            if (!varDecl.initializer)
+                return [];
+            return this.findSubgraphs(varDecl.initializer, [name]);
+        });
+    };
+    getAugmentedSourceFile = (name) => {
+        const vars = this.getSubgraphsVariables(name);
+        const typeExports = [
+            { typeName: `__langgraph__${name}`, valueName: name, graphName: name },
+        ];
+        for (const { subgraph, node, namespace } of vars) {
+            typeExports.push({
+                typeName: `__langgraph__${namespace.join("_")}_${node}`,
+                valueName: subgraph.name,
+                graphName: [...namespace, node].join("|"),
+            });
+        }
+        const sourceFilePath = "__langgraph__source.mts";
+        const sourceContents = [
+            this.getText(this.sourceFile),
+            ...typeExports.map(({ typeName, valueName }) => `export type ${typeName} = typeof ${valueName}`),
+        ].join("\n\n");
+        const inferFilePath = "__langraph__infer.mts";
+        const inferContents = [
+            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source.mts"`),
+            this.inferFile.getText(this.inferFile),
+            ...typeExports.flatMap(({ typeName }) => {
+                return [
+                    dedent `
+            type ${typeName}__reflect = Reflect<${typeName}>;
+            export type ${typeName}__state = Inspect<${typeName}__reflect["state"]>;
+            export type ${typeName}__update = Inspect<${typeName}__reflect["update"]>;
+
+            type ${typeName}__builder = BuilderReflect<${typeName}>;
+            export type ${typeName}__input = Inspect<FilterAny<${typeName}__builder["input"]>>;
+            export type ${typeName}__output = Inspect<FilterAny<${typeName}__builder["output"]>>;
+            export type ${typeName}__config = Inspect<FilterAny<${typeName}__builder["config"]>>;
+          `,
+                ];
+            }),
+        ].join("\n\n");
+        return {
+            files: [
+                [sourceFilePath, sourceContents],
+                [inferFilePath, inferContents],
+            ],
+            exports: typeExports,
+        };
+    };
+    findSubgraphIdentifiers = (acc, node) => {
+        if (ts.isIdentifier(node)) {
+            const smb = this.checker.getSymbolAtLocation(node);
+            if (smb?.valueDeclaration &&
+                ts.isVariableDeclaration(smb.valueDeclaration)) {
+                const target = smb.valueDeclaration;
+                const targetType = this.checker.getTypeAtLocation(target);
+                if (this.isGraphOrPregelType(targetType)) {
+                    acc.push({ name: this.getText(target.name), node: target });
+                }
+            }
+            if (smb?.declarations) {
+                const target = smb.declarations.find(ts.isImportSpecifier);
+                if (target) {
+                    const targetType = this.checker.getTypeAtLocation(target);
+                    if (this.isGraphOrPregelType(targetType)) {
+                        acc.push({ name: this.getText(target.name), node: target });
+                    }
+                }
+            }
+        }
+        return acc;
+    };
+    isGraphOrPregelType = (type) => {
+        return (this.checker.isTypeAssignableTo(type, this.anyPregelType) ||
+            this.checker.isTypeAssignableTo(type, this.anyGraphType));
+    };
+    getText(node) {
+        return node.getText(this.sourceFile);
+    }
+    reduceChildren(node, fn, initial) {
+        let acc = initial;
+        function it(node) {
+            acc = fn(acc, node);
+            // @ts-expect-error
+            ts.forEachChild(node, it.bind(this));
+        }
+        ts.forEachChild(node, it.bind(this));
+        return acc;
+    }
+    static extractSchemas(target, name, options) {
+        const dirname = typeof target === "string" ? path.dirname(target) : __dirname;
+        const fsMap = new Map();
+        const system = vfs.createFSBackedSystem(fsMap, dirname, ts);
+        const host = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
+        const targetPath = typeof target === "string"
+            ? target
+            : path.resolve(dirname, "./__langgraph__target.mts");
+        const inferTemplatePath = path.resolve(__dirname, "./schema/types.template.mts");
+        if (typeof target !== "string") {
+            fsMap.set(targetPath, target.contents);
+            for (const [name, contents] of target.files ?? []) {
+                let tsFileName = path.resolve(dirname, name);
+                // TS for some reason uses UNIX backslashes instead of the Window ones
+                if (process.platform === "win32") {
+                    tsFileName = tsFileName.replace(/\\/g, "/");
+                }
+                fsMap.set(tsFileName, contents);
+            }
+        }
+        // TODO: this is in all instances broken, will need to address in a way
+        // that allows loading fs-backed modules from different vfs
+        // host.compilerHost.resolveModuleNames = (moduleNames, containingFile) => {
+        //   const resolvedModules: (ts.ResolvedModule | undefined)[] = [];
+        //   for (const moduleName of moduleNames) {
+        //     let target = containingFile;
+        //     const relative = path.relative(dirname, containingFile);
+        //     logger.debug(`${moduleName} ${containingFile}`);
+        //     if (
+        //       moduleName.startsWith("@langchain/langgraph") &&
+        //       relative &&
+        //       !relative.startsWith("..") &&
+        //       !path.isAbsolute(relative)
+        //     ) {
+        //       target = path.resolve(__dirname, "../", relative);
+        //       process.stderr.write(`${moduleName} ${relative} -> ${target}\n`);
+        //     }
+        //     resolvedModules.push(
+        //       ts.resolveModuleName(
+        //         moduleName,
+        //         target,
+        //         compilerOptions,
+        //         host.compilerHost
+        //       ).resolvedModule
+        //     );
+        //   }
+        //   return resolvedModules;
+        // };
+        const research = ts.createProgram({
+            rootNames: [inferTemplatePath, targetPath],
+            options: compilerOptions,
+            host: host.compilerHost,
+        });
+        const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath), research.getSourceFile(inferTemplatePath), options);
+        const { files, exports } = extractor.getAugmentedSourceFile(name);
+        for (const [name, source] of files) {
+            system.writeFile(path.resolve(dirname, name), source);
+        }
+        const extract = ts.createProgram({
+            rootNames: [path.resolve(dirname, "./__langraph__infer.mts")],
+            options: compilerOptions,
+            host: host.compilerHost,
+        });
+        const schemaGenerator = buildGenerator(extract);
+        const trySymbol = (schema, symbol) => {
+            try {
+                return schema?.getSchemaForSymbol(symbol) ?? undefined;
+            }
+            catch (e) {
+                console.warn(`Failed to obtain symbol "${symbol}":`, e?.message);
+            }
+            return undefined;
+        };
+        return Object.fromEntries(exports.map(({ typeName, graphName }) => [
+            graphName,
+            {
+                input: trySymbol(schemaGenerator, `${typeName}__input`),
+                output: trySymbol(schemaGenerator, `${typeName}__output`),
+                state: trySymbol(schemaGenerator, `${typeName}__update`),
+                config: trySymbol(schemaGenerator, `${typeName}__config`),
+            },
+        ]));
+    }
+}

package/dist/graph/parser/parser.worker.mjs

@@ -0,0 +1,7 @@
+import { tsImport } from "tsx/esm/api";
+import { parentPort } from "node:worker_threads";
+parentPort?.on("message", async (payload) => {
+    const { SubgraphExtractor } = await tsImport("./parser.mjs", import.meta.url);
+    const result = SubgraphExtractor.extractSchemas(payload.sourceFile, payload.exportSymbol, { strict: false });
+    parentPort?.postMessage(result);
+});