llmz 0.0.10 → 0.0.12

package/dist/chunk-ZRCU35UV.cjs

@@ -0,0 +1,184 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+var _chunkKMZDFWYZcjs = require('./chunk-KMZDFWYZ.cjs');
+
+// src/component.ts
+var _zui = require('@bpinternal/zui');
+function assertValidComponent(component) {
+  if (!component.name) {
+    throw new Error("Component must have a name");
+  }
+  const nameRegex = /^[A-Z]{3,50}$/i;
+  if (!nameRegex.test(component.name)) {
+    throw new Error(
+      `Component name "${component.name}" must be 3-50 characters long and start with an uppercase letter`
+    );
+  }
+  if (component.aliases) {
+    for (const alias of component.aliases) {
+      if (!nameRegex.test(alias)) {
+        throw new Error(`Alias "${alias}" must be 3-50 characters long and start with an uppercase letter`);
+      }
+    }
+  }
+  if (!component.description) {
+    throw new Error("Component must have a description");
+  }
+  if (!component.examples || component.examples.length === 0) {
+    throw new Error("Component must have at least one example");
+  }
+  if (component.type === "default" && !component.default) {
+    throw new Error("Default component must have default props and children");
+  }
+  if (component.type === "leaf" && !component.leaf) {
+    throw new Error("Leaf component must have leaf props");
+  }
+  if (component.type === "container" && !component.container) {
+    throw new Error("Container component must have container props and children");
+  }
+}
+var getDefaultValue = (schema) => {
+  if (schema._def.defaultValue !== void 0) {
+    if (typeof schema._def.defaultValue === "function") {
+      return String(schema._def.defaultValue()).toString();
+    } else {
+      return String(schema._def.defaultValue);
+    }
+  }
+  return "";
+};
+function getComponentReference(component) {
+  let doc = `### <${component.name}>
+
+`;
+  doc += `${component.description}
+
+`;
+  const getPropsDoc = (props) => {
+    const shape = props.shape;
+    if (Object.keys(shape).length === 0)
+      return "_No props._\n\n";
+    const zodTypeToTsType = {
+      ZodString: "string",
+      ZodNumber: "number",
+      ZodBoolean: "boolean",
+      ZodEnum: "enum",
+      ZodArray: "array",
+      ZodObject: "object",
+      ZodDate: "date",
+      ZodBigInt: "bigint",
+      ZodSymbol: "symbol",
+      ZodUndefined: "undefined",
+      ZodNull: "null",
+      ZodVoid: "void",
+      ZodNever: "never",
+      ZodUnknown: "unknown",
+      ZodAny: "any"
+    };
+    return Object.entries(shape).map(([name, schema]) => {
+      const naked = schema.naked();
+      const zodType = naked._def.typeName;
+      const defValue = getDefaultValue(schema);
+      const typings = naked instanceof _zui.z.ZodEnum ? naked._def.values.map((x) => `"${x}"`).join(" | ") : zodTypeToTsType[zodType] || zodType;
+      const required = !schema.isOptional() ? "**(required)**" : "(optional)";
+      const def = defValue ? ` _Default: \`${defValue}\`_` : "";
+      const description = schema.description || schema.naked().description || (schema == null ? void 0 : schema._def.description) || "";
+      return `- \`${name}: ${typings}\` ${required} \u2014 ${description}${def}`;
+    }).join("\n") + "\n\n";
+  };
+  const getChildrenDoc = (children) => {
+    if (children.length === 0)
+      return "_None allowed._\n\n";
+    return "Can contain:\n" + children.map((child) => `- ${child.description} \u2014 \`<${child.component.name}>\``).join("\n") + "\n\n";
+  };
+  const getExamplesDoc = (examples) => {
+    if (!examples.length)
+      return "";
+    return "**Examples:**\n\n" + examples.map((example) => `**${example.name}** \u2014 ${example.description}
+
+\`\`\`tsx
+${example.code.trim()}
+\`\`\`
+`).join("\n");
+  };
+  switch (component.type) {
+    case "leaf":
+      doc += "**Props:**\n\n";
+      doc += getPropsDoc(component.leaf.props);
+      doc += "**Children:**\n\n";
+      doc += getChildrenDoc([]);
+      doc += getExamplesDoc(component.examples);
+      break;
+    case "container":
+      doc += "**Props:**\n\n";
+      doc += getPropsDoc(component.container.props);
+      doc += "**Children:**\n\n";
+      doc += getChildrenDoc(component.container.children);
+      doc += getExamplesDoc(component.examples);
+      break;
+    case "default":
+    default:
+      doc += "**Props:**\n\n";
+      doc += getPropsDoc(component.default.props);
+      doc += "**Children:**\n\n";
+      doc += getChildrenDoc(component.default.children);
+      doc += getExamplesDoc(component.examples);
+      break;
+  }
+  return doc.trim();
+}
+var Component = class {
+  
+  
+  // phantom type for inference
+  constructor(definition) {
+    assertValidComponent(definition);
+    this.definition = definition;
+  }
+};
+function isComponent(rendered, component) {
+  return _chunkKMZDFWYZcjs.isJsxComponent.call(void 0, component.definition.name, rendered);
+}
+function isAnyComponent(message) {
+  return _chunkKMZDFWYZcjs.isAnyJsxComponent.call(void 0, message);
+}
+function renderToTsx(component) {
+  const props = Object.entries(component.props).map(([key, value]) => {
+    if (typeof value === "string") {
+      return `${key}="${value}"`;
+    }
+    if (typeof value === "boolean") {
+      return value ? key : "";
+    }
+    if (typeof value === "number") {
+      return `${key}={${value}}`;
+    }
+    if (value === null || value === void 0) {
+      return "";
+    }
+    if (typeof value === "object") {
+      return `${key}={${JSON.stringify(value)}}`;
+    }
+    return `${key}={${String(value)}}`;
+  }).filter(Boolean).join(" ");
+  const children = component.children.map((child) => {
+    if (typeof child === "string") {
+      return child;
+    }
+    if (isAnyComponent(child)) {
+      return renderToTsx(child);
+    }
+    return String(child);
+  }).join("");
+  return `<${component.type}${props ? " " + props : ""}>${children}</${component.type}>`;
+}
+
+
+
+
+
+
+
+
+exports.assertValidComponent = assertValidComponent; exports.getComponentReference = getComponentReference; exports.Component = Component; exports.isComponent = isComponent; exports.isAnyComponent = isAnyComponent; exports.renderToTsx = renderToTsx;

package/dist/citations.d.ts

@@ -0,0 +1,63 @@
+export type Citation = {
+    id: number;
+    source: any;
+    tag: string;
+    offset?: number;
+};
+export type CitationReplaceFn = (citation: Citation) => string;
+/** These are all single-token symbols that are very rare in natural texts, making them suitable for usage within GPT Prompts. */
+export declare const RARE_SYMBOLS: {
+    readonly ARROW_UP: "↑";
+    readonly CIRCLE_BULLET: "・";
+    readonly STAR_BULLET_FULL: "★";
+    readonly STAR_BULLET_EMPTY: "☆";
+    readonly ARROW_BULLET: "→";
+    readonly SQUARE_BULLET: "■";
+    readonly TRIANGLE_BULLET: "►";
+    readonly OPENING_TAG: "【";
+    readonly CLOSING_TAG: "】";
+    readonly SS: "§";
+    readonly CROSS: "†";
+};
+export declare class CitationsManager {
+    private _citations;
+    private _nextId;
+    /**
+     * Registers a new source and returns the created Citation.
+     * @param source An object representing the source of the citation.
+     * @returns The created Citation.
+     */
+    registerSource(source: any): Citation;
+    /**
+     * Extracts citations from the provided content and cleans the content of citation tags.
+     * Non-found citations are replaced with a special "Not Found" citation.
+     * @param content The string content containing citation tags.
+     * @returns An object containing the cleaned content and an array of found citations.
+     */
+    extractCitations(content: string, replace?: CitationReplaceFn): {
+        cleaned: string;
+        citations: Citation[];
+    };
+    /**
+     * Strips citation tags from the provided content.
+     * @param content The string content containing citation tags.
+     * @returns The cleaned content without citation tags.
+     */
+    static stripCitationTags(content: string): string;
+    /**
+     * Removes citations from a deeply nested plain object and returns a new object with citations removed.
+     * @param obj The plain object to process.
+     * @returns A tuple containing the new object and an array of extracted citations with paths.
+     */
+    removeCitationsFromObject<T>(obj: T): [T, {
+        path: string;
+        citation: Citation;
+    }[]];
+    /**
+     * Re-adds citations to the cleaned content based on their offsets.
+     * @param cleaned The cleaned string without citation tags.
+     * @param citations The array of citations with offsets.
+     * @returns The string with citation tags re-added.
+     */
+    reAddCitations(cleaned: string, citations: Citation[]): string;
+}

package/dist/compiler/compiler.d.ts

@@ -0,0 +1,28 @@
+import { type TransformOptions } from '@babel/core';
+import { ToolCallEntry } from './plugins/track-tool-calls.js';
+export declare const DEFAULT_TRANSFORM_OPTIONS: TransformOptions;
+export declare const Identifiers: {
+    JSXFnIdentifier: string;
+    AsyncIterYieldFnIdentifier: string;
+    ConsoleObjIdentifier: string;
+    LineTrackingFnIdentifier: string;
+    VariableTrackingFnIdentifier: string;
+    ToolCallTrackerFnIdentifier: string;
+    ToolTrackerRetIdentifier: string;
+    CommentFnIdentifier: string;
+};
+export type CompiledCode = ReturnType<typeof compile>;
+export declare function compile(code: string): {
+    code: string;
+    map: {
+        version: number;
+        sources: string[];
+        names: string[];
+        sourceRoot?: string | undefined;
+        sourcesContent?: string[] | undefined;
+        mappings: string;
+        file: string;
+    } | null | undefined;
+    variables: Set<string>;
+    toolCalls: Map<number, ToolCallEntry>;
+};

package/dist/compiler/index.d.ts

@@ -0,0 +1,2 @@
+export { Identifiers, compile } from './compiler.js';
+export type { CompiledCode } from './compiler.js';

package/dist/compiler/plugins/async-iterator.d.ts

@@ -0,0 +1,4 @@
+export declare const AsyncIterator: {
+    preProcessing: (code: string) => string;
+    postProcessing: (code: string) => string;
+};

package/dist/compiler/plugins/braces-tsx.d.ts

@@ -0,0 +1,3 @@
+export declare const JSXMarkdown: {
+    preProcessing: (code: string) => string;
+};

package/dist/compiler/plugins/jsx-preserve-newlines.d.ts

@@ -0,0 +1,5 @@
+import type { PluginObj } from '@babel/core';
+export declare const JSXNewLines: {
+    babelPlugin: PluginObj<import("@babel/core").PluginPass>;
+    postProcessing: (code: string) => string;
+};

package/dist/compiler/plugins/line-tracking.d.ts

@@ -0,0 +1,5 @@
+import type * as BabelCore from '@babel/core';
+export declare const LineTrackingFnIdentifier = "__track__";
+export declare const lineTrackingBabelPlugin: ({ types: t }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/replace-comment.d.ts

@@ -0,0 +1,5 @@
+import type * as BabelCore from '@babel/core';
+export declare const CommentFnIdentifier = "__comment__";
+export declare const replaceCommentBabelPlugin: ({ types: t, }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/return-async.d.ts

@@ -0,0 +1,4 @@
+import type * as BabelCore from '@babel/core';
+export declare const instrumentLastLinePlugin: ({ types: t, }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/track-tool-calls.d.ts

@@ -0,0 +1,16 @@
+import type * as BabelCore from '@babel/core';
+export declare const ToolCallTrackerFnIdentifier = "__toolc__";
+export declare const ToolTrackerRetIdentifier = "__ret__";
+export type Assignment = {
+    type: 'single' | 'object' | 'array' | 'unsupported';
+    left: string;
+    evalFn: string;
+};
+export type ToolCallEntry = {
+    object: string;
+    tool: string;
+    assignment: Assignment;
+};
+export declare const toolCallTrackingPlugin: (calls?: Map<number, ToolCallEntry>) => ({}: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/compiler/plugins/variable-extraction.d.ts

@@ -0,0 +1,5 @@
+import type * as BabelCore from '@babel/core';
+export declare const VariableTrackingFnIdentifier = "__var__";
+export declare const variableTrackingPlugin: (variables?: Set<string>) => ({ types: t }: {
+    types: typeof BabelCore.types;
+}) => BabelCore.PluginObj;

package/dist/component-R4WTW6DZ.cjs

@@ -0,0 +1,18 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+var _chunkZRCU35UVcjs = require('./chunk-ZRCU35UV.cjs');
+require('./chunk-KMZDFWYZ.cjs');
+require('./chunk-UQOBUJIQ.cjs');
+
+
+
+
+
+
+
+exports.Component = _chunkZRCU35UVcjs.Component; exports.assertValidComponent = _chunkZRCU35UVcjs.assertValidComponent; exports.getComponentReference = _chunkZRCU35UVcjs.getComponentReference; exports.isAnyComponent = _chunkZRCU35UVcjs.isAnyComponent; exports.isComponent = _chunkZRCU35UVcjs.isComponent; exports.renderToTsx = _chunkZRCU35UVcjs.renderToTsx;

package/dist/component-WFVDVSDK.js

@@ -0,0 +1,18 @@
+import {
+  Component,
+  assertValidComponent,
+  getComponentReference,
+  isAnyComponent,
+  isComponent,
+  renderToTsx
+} from "./chunk-GGWM6X2K.js";
+import "./chunk-ORQP26SZ.js";
+import "./chunk-7WRN4E42.js";
+export {
+  Component,
+  assertValidComponent,
+  getComponentReference,
+  isAnyComponent,
+  isComponent,
+  renderToTsx
+};

package/dist/component.d.ts

@@ -0,0 +1,66 @@
+import { z } from '@bpinternal/zui';
+export type ExampleUsage = {
+    name: string;
+    description: string;
+    code: string;
+};
+export type ComponentChild = {
+    description: string;
+    component: ComponentDefinition;
+};
+export declare function assertValidComponent(component: ComponentDefinition): asserts component is ComponentDefinition;
+export declare function getComponentReference(component: ComponentDefinition): string;
+export type DefaultComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
+    type: 'default';
+    name: string;
+    aliases: string[];
+    description: string;
+    examples: ExampleUsage[];
+    default: {
+        props: T;
+        children: Array<ComponentChild>;
+    };
+};
+export type LeafComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
+    type: 'leaf';
+    name: string;
+    description: string;
+    aliases?: string[];
+    examples: ExampleUsage[];
+    leaf: {
+        props: T;
+    };
+};
+export type ContainerComponentDefinition<T extends z.ZodObject<any> = z.ZodObject<any>> = {
+    type: 'container';
+    name: string;
+    description: string;
+    aliases?: string[];
+    examples: ExampleUsage[];
+    container: {
+        props: T;
+        children: Array<ComponentChild>;
+    };
+};
+export type ComponentDefinition = DefaultComponentDefinition | LeafComponentDefinition | ContainerComponentDefinition;
+type ExtractComponentProps<T extends ComponentDefinition> = T extends LeafComponentDefinition<infer P> ? z.infer<P> : T extends ContainerComponentDefinition<infer P> ? z.infer<P> : T extends DefaultComponentDefinition<infer P> ? z.infer<P> : never;
+export type RenderedComponent<TProps = Record<string, any>> = {
+    __jsx: true;
+    type: string;
+    children: any[];
+    props: TProps;
+};
+export declare class Component<T extends ComponentDefinition = ComponentDefinition> {
+    readonly definition: T;
+    readonly propsType: ExtractComponentProps<T>;
+    constructor(definition: T);
+}
+export declare function isComponent<T extends ComponentDefinition>(rendered: RenderedComponent<any>, component: Component<T>): rendered is RenderedComponent<ExtractComponentProps<T>>;
+export declare function isAnyComponent(message: unknown): message is RenderedComponent;
+/**
+ * Converts a RenderedComponent back to TSX code
+ * @param component The rendered component to convert
+ * @returns A string containing the TSX representation of the component
+ */
+export declare function renderToTsx(component: RenderedComponent): string;
+export {};