@nodetool-ai/node-sdk 0.7.0-rc.23 → 0.8.2

package/dist/class-name-to-title.js

@@ -0,0 +1,59 @@
+/**
+ * Convert a node className (e.g. "GPT_4_1_Nano", "StableDiffusionXL",
+ * "Ideogram_V3_Balanced") into a human-readable title shown in the node
+ * menu.
+ *
+ * Rules:
+ *  - "_" is treated as a word separator (so "Imagen_4_Ultra" yields three
+ *    chunks: "Imagen", "4", "Ultra").
+ *  - camelCase / PascalCase boundaries are split, while uppercase runs are
+ *    kept together — so "StableDiffusionXL" becomes "Stable Diffusion XL"
+ *    rather than "Stable Diffusion X L", and "SDXL_Ad_Inpaint" stays as
+ *    "SDXL Ad Inpaint" rather than "S D X L Ad Inpaint".
+ *  - Consecutive purely-numeric tokens are joined with a "." — this
+ *    reconstructs the version numbers in the original model slugs (so
+ *    "GPT_4_1_Nano" → "GPT 4.1 Nano", "Flux_1_1_Pro_Ultra" →
+ *    "Flux 1.1 Pro Ultra", "Veo_3_1_Lite" → "Veo 3.1 Lite").
+ *
+ * @example
+ * classNameToTitle("GPT_4_1_Nano")           // "GPT 4.1 Nano"
+ * classNameToTitle("Imagen_4_Ultra")         // "Imagen 4 Ultra"
+ * classNameToTitle("Ideogram_V3_Balanced")   // "Ideogram V3 Balanced"
+ * classNameToTitle("StableDiffusionXL")      // "Stable Diffusion XL"
+ * classNameToTitle("Recraft_20B_SVG")        // "Recraft 20B SVG"
+ */
+export function classNameToTitle(className) {
+    // Stryker disable next-line ConditionalExpression,BlockStatement: fast-path for "" — the general path below also yields "" for "" (split → filtered to [] → join → ""), so removing it changes nothing (equivalent).
+    if (!className) {
+        return "";
+    }
+    // 1) Split on underscores AND camelCase / acronym boundaries.
+    //    The regex passes are applied per underscore-delimited chunk so
+    //    purely-numeric tokens stay intact for the merge step below.
+    const splitWordBoundaries = (part) => {
+        // "fooBar" → "foo Bar", "foo4" → "foo 4"
+        let spaced = part.replace(/([a-z])([A-Z0-9])/g, "$1 $2");
+        // Stryker disable next-line Regex: collapsing the [A-Z]+ run to a single [A-Z] is equivalent — the space always lands right before the final Cap-lower pair ("XLLightning" → "XL Lightning"), so the leading caps stay glued either way.
+        spaced = spaced.replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2");
+        return spaced.split(" ");
+    };
+    const tokens = className
+        .split("_")
+        .flatMap(splitWordBoundaries)
+        .filter((tok) => tok.length > 0);
+    // 2) Merge consecutive purely-numeric tokens with "." so the version
+    //    numbers in slugs like "gpt-4.1-nano" round-trip ("4_1" → "4.1").
+    const merged = [];
+    for (const tok of tokens) {
+        const last = merged[merged.length - 1];
+        // Stryker disable next-line ConditionalExpression: forcing `last !== undefined` true is equivalent — the digit regexes still gate the merge (/^\d+$/.test(undefined) is false), so a non-numeric or first token never merges either way.
+        if (last !== undefined && /^\d+$/.test(last) && /^\d+$/.test(tok)) {
+            merged[merged.length - 1] = `${last}.${tok}`;
+        }
+        else {
+            merged.push(tok);
+        }
+    }
+    return merged.join(" ");
+}
+//# sourceMappingURL=class-name-to-title.js.map

package/dist/class-name-to-title.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"class-name-to-title.js","sourceRoot":"","sources":["../src/class-name-to-title.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAAiB;IAChD,qNAAqN;IACrN,IAAI,CAAC,SAAS,EAAE,CAAC;QACf,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,8DAA8D;IAC9D,oEAAoE;IACpE,iEAAiE;IACjE,MAAM,mBAAmB,GAAG,CAAC,IAAY,EAAY,EAAE;QACrD,yCAAyC;QACzC,IAAI,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;QACzD,yOAAyO;QACzO,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,uBAAuB,EAAE,OAAO,CAAC,CAAC;QAC1D,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC3B,CAAC,CAAC;IACF,MAAM,MAAM,GAAG,SAAS;SACrB,KAAK,CAAC,GAAG,CAAC;SACV,OAAO,CAAC,mBAAmB,CAAC;SAC5B,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAEnC,qEAAqE;IACrE,sEAAsE;IACtE,MAAM,MAAM,GAAa,EAAE,CAAC;IAC5B,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;QACvC,yOAAyO;QACzO,IAAI,IAAI,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YAClE,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,GAAG,IAAI,IAAI,GAAG,EAAE,CAAC;QAC/C,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnB,CAAC;IACH,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC1B,CAAC"}

package/dist/code-analysis.d.ts

@@ -0,0 +1,234 @@
+/**
+ * AST primitives for the body of a Code node (`nodetool.code.Code`).
+ *
+ * A Code node's `code` property is the body of one async function: declared
+ * dynamic inputs arrive on an `inputs` object, and outputs leave through
+ * `emit(name, value)` / `output(name, value)` — or, for a body that calls
+ * neither, through the legacy returned object's keys. Everything a checker
+ * needs to say about such a body —
+ * does it parse, what does it return, which names does it invent — is derived
+ * here, so the graph validator, the code-generation planner and the editor all
+ * read the same AST rather than three approximations of it.
+ *
+ * Pure functions, no I/O: the parser is the only dependency.
+ */
+import * as acorn from "acorn";
+/** A top-level entry of a parsed body: a statement or an import/export. */
+export type CodeBodyStatement = acorn.Statement | acorn.ModuleDeclaration;
+export interface ParsedCodeBody {
+    statements: CodeBodyStatement[];
+}
+export interface CodeParseError {
+    /** Acorn's message, already prefixed with the position it points at. */
+    error: string;
+    /** 1-based line the parser stopped on, when it reported one. */
+    line?: number;
+}
+/**
+ * Parse a Code node body into its top-level statement list.
+ *
+ * The body is a bare statement list with `return` at the top level, which most
+ * of the time parses directly. Anything the direct parse rejects gets a second
+ * pass wrapped in an async function, so `await` in odd positions doesn't read
+ * as a syntax error.
+ */
+export declare function parseCodeBody(code: string): ParsedCodeBody | CodeParseError;
+/** `"import"` / `"export"` for every module declaration at the top level. */
+export declare function moduleDeclarationKinds(statements: readonly CodeBodyStatement[]): string[];
+/**
+ * Specifiers of the top-level static `import` declarations, in source order.
+ *
+ * These are the only imports the guest loader can serve: it resolves a
+ * specifier the run declared, and nothing else.
+ */
+export declare function staticImportSpecifiers(statements: readonly CodeBodyStatement[]): string[];
+/** One static import declaration's specifier and the names it pulls off it. */
+export interface StaticImportBinding {
+    readonly specifier: string;
+    /**
+     * Names in `import { a, b as c }` — the exported names, not the local
+     * aliases, so they can be checked against what the module declares.
+     * A default or namespace import contributes nothing: it names no export.
+     */
+    readonly named: readonly string[];
+}
+/**
+ * Specifier plus imported names for every top-level static `import`, in source
+ * order.
+ *
+ * {@link staticImportSpecifiers} answers which modules a body wants;
+ * this answers which of their exports it wants, so a loader can refuse a
+ * misspelled name with the module's own export list instead of leaving the
+ * guest to report "Could not find export".
+ */
+export declare function staticImportBindings(statements: readonly CodeBodyStatement[]): StaticImportBinding[];
+/**
+ * The names a module's source exports, or `null` when they cannot be decided.
+ *
+ * `null` means "do not check": the source did not parse, or it carries an
+ * `export * from …` whose names live in another file. A caller that refuses an
+ * import on this list must treat `null` as permission, never as an empty
+ * module.
+ *
+ * Used to turn QuickJS's "Could not find export 'websearch'" — which names
+ * neither the module's exports nor the near miss — into a refusal made before
+ * the guest starts, with both.
+ */
+export declare function exportedNames(source: string): string[] | null;
+/** Module access the loader refuses outright, anywhere in the body. */
+export interface DynamicModuleAccess {
+    /** `import(...)` — the loader denies every dynamic resolution. */
+    dynamicImport: boolean;
+    /** `require(...)` — CommonJS does not exist in the guest. */
+    require: boolean;
+}
+export declare function dynamicModuleAccess(statements: readonly CodeBodyStatement[]): DynamicModuleAccess;
+/** Outcome of inspecting one `return` argument. */
+export interface ReturnShape {
+    /** Keys the returned object literal definitely carries. */
+    keys: Set<string>;
+    /** A spread or a computed key hides the real key set. */
+    opaque: boolean;
+    /** The expression cannot be an object with named keys (`return 5`). */
+    notAnObject: boolean;
+}
+/**
+ * Shapes a return argument can take. A ternary splits into one shape per
+ * branch, so `return cond ? {a, b} : {a}` is caught on the branch that drops
+ * `b` instead of passing on the union.
+ */
+export declare function returnShapes(argument: acorn.Expression | null | undefined): ReturnShape[];
+export interface CodeBodyFacts {
+    /** Every `return` belonging to the body itself. */
+    returns: acorn.ReturnStatement[];
+    /** Control can reach the end of the statement list without returning. */
+    fallsThrough: boolean;
+}
+/** The body's own `return` statements, and whether control can fall past them. */
+export declare function analyzeCodeBody(statements: readonly CodeBodyStatement[]): CodeBodyFacts;
+/** The two host bridges a body delivers outputs through. */
+export declare const CODE_OUTPUT_CALLEES: readonly string[];
+/** Output handles a body names through `emit`/`output` calls. */
+export interface OutputCallNames {
+    /** Literal handle names, in source order, deduplicated. */
+    names: string[];
+    /** A call whose first argument is not a string literal hides its handle. */
+    nonLiteral: boolean;
+}
+/**
+ * Handles the body delivers to via `emit(name, …)` / `output(name, …)`.
+ *
+ * Presence in the AST is the whole rule: a call inside a branch, a loop or a
+ * helper function counts, because the contract is per-handle existence rather
+ * than per-path coverage. `x.output(…)` is a method on something else and is
+ * not counted.
+ */
+export declare function outputCallNames(statements: readonly CodeBodyStatement[]): OutputCallNames;
+/** The global a body reads its input streams through. */
+export declare const CODE_STREAM_GLOBAL = "stream";
+/** Input handles a body names through `stream` calls. */
+export interface StreamCallNames {
+    /** Literal handle names, in source order, deduplicated. */
+    names: string[];
+    /** A call whose first argument is not a string literal hides its handle. */
+    nonLiteral: boolean;
+    /** The body iterates every connected handle via `stream.any()`. */
+    usesAny: boolean;
+}
+/**
+ * Handles the body takes from via `stream(name)`, `stream.first(name)` and
+ * `stream.open(name)`, plus whether it also uses `stream.any()`.
+ *
+ * Presence in the AST is the whole rule, as for {@link outputCallNames}: a call
+ * inside a branch or a loop counts. `x.stream(…)` is a method on something else,
+ * and a body that binds `stream` itself reports nothing — the calls are that
+ * binding's, not the sandbox's.
+ */
+export declare function streamCallNames(statements: readonly CodeBodyStatement[]): StreamCallNames;
+/**
+ * Every name the code itself binds — variables, functions, classes, parameters,
+ * catch clauses, and undeclared assignment targets. A reference to anything
+ * else has to come from the sandbox or from a dynamic input, so this is the
+ * allowlist a caller subtracts before deciding a name was invented.
+ */
+export declare function collectBoundNames(code: string): string[];
+/**
+ * Names the code tests with `typeof`. `typeof x` is the one read that never
+ * throws on a missing binding, so a name guarded anywhere in the body is one
+ * the author already treats as optional — a caller deciding whether a name is
+ * undefined has to subtract these.
+ */
+export declare function typeofGuardedNames(statements: readonly CodeBodyStatement[]): Set<string>;
+/** The global every declared input of a Code node arrives on. */
+export declare const CODE_INPUTS_GLOBAL = "inputs";
+/**
+ * Input names the body reads off the `inputs` global, and whether it also
+ * reaches for the object in a way this analysis cannot resolve to names.
+ *
+ * `inputs.text` and `inputs["text"]` both count. A dynamic read
+ * (`inputs[key]`), a spread, or passing `inputs` somewhere sets `opaque`:
+ * the body uses inputs the reader cannot enumerate, so a caller must not
+ * conclude an undeclared slot is unused. A body that shadows `inputs` with
+ * its own binding reports nothing — the reads are that binding's, not the
+ * node's.
+ */
+export declare function inputsMemberReads(statements: readonly CodeBodyStatement[]): {
+    names: string[];
+    opaque: boolean;
+};
+/**
+ * Identifiers the code reads without binding them. Property names, object
+ * keys and labels are excluded: none of them resolve against the scope chain,
+ * so none of them can throw a ReferenceError.
+ */
+export declare function freeIdentifiers(statements: readonly CodeBodyStatement[]): string[];
+/**
+ * Rewrite a pre-`inputs` Code node body: every free read of a declared input
+ * becomes `inputs.<name>`.
+ *
+ * Inputs used to arrive as globals of their own name. Bodies written that way
+ * throw a ReferenceError now, so this is the mechanical half of that move —
+ * offsets come from the AST, so a name inside a string or a comment, an object
+ * key, or a locally shadowed binding is left alone.
+ *
+ * Returns the rewritten source and the names it touched. `changed` is false
+ * when there was nothing to do, when the body does not parse, or when it binds
+ * `inputs` itself — rewriting into a shadowed name would silently change which
+ * object is read.
+ */
+export declare function migrateCodeBodyToInputs(code: string, inputNames: readonly string[]): {
+    code: string;
+    changed: boolean;
+    rewritten: string[];
+};
+/**
+ * Property names the Code node itself owns. A body that reads `inputs.code`
+ * is not naming a user handle — it is colliding with the editor field.
+ */
+export declare const CODE_NODE_OWN_PROPERTIES: ReadonlySet<string>;
+/**
+ * Input handle names the body itself names: `inputs.foo` / `inputs["foo"]`
+ * and `stream("foo")` / `stream.first("foo")` / `stream.open("foo")`.
+ *
+ * A named read is a handle. The editor shows it and an agent can connect to
+ * it without a separate "add dynamic input" step.
+ */
+export declare function inferredCodeInputNames(code: string): string[];
+/**
+ * Output handle names the body itself names: `emit("foo")` / `output("foo")`,
+ * or — when the body uses neither — the keys of the last `return { … }`.
+ */
+export declare function inferredCodeOutputNames(code: string): string[];
+/**
+ * What would make a Code step the workflow planner wrote fail or pass nothing
+ * on, checked before anything runs.
+ *
+ * `inputs` are the handles the build connects, `output` the handle the next
+ * step reads. Each problem is a sentence the planner can act on: the repair
+ * round sends them back verbatim.
+ */
+export declare function plannedCodeStepProblems(code: string, handles: {
+    inputs: readonly string[];
+    output: string;
+}): string[];
+//# sourceMappingURL=code-analysis.d.ts.map

package/dist/code-analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-analysis.d.ts","sourceRoot":"","sources":["../src/code-analysis.ts"],"names":[],"mappings":"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"}