fullstacked 0.12.0-1173 → 0.12.0-1184

package/fullstacked_modules/ai/index.ts

@@ -0,0 +1,14 @@
+import * as aiAgent from "@fullstacked/ai-agent";
+import { z as zod } from "zod";
+export * from "./tools/fs"; 
+import { createToolFS } from "./tools/fs";
+
+export * from "@fullstacked/ai-agent";
+
+export const z = zod;
+
+export default {
+    ...aiAgent,
+    createToolFS,
+    z: zod
+};

package/fullstacked_modules/ai/package.json

@@ -0,0 +1,5 @@
+{
+    "main": "./index.js",
+    "name": "ai",
+    "version": "0.0.0"
+}

package/fullstacked_modules/ai/tools/fs.ts

@@ -0,0 +1,60 @@
+import { createTool } from "@fullstacked/ai-agent";
+import { z } from "zod";
+import type fsType from "../../fs";
+import _fs from "fs";
+
+const fs: typeof fsType = _fs;
+
+type ToolFSOptions = {
+    baseDirectory: string
+}
+
+export function createToolFS(opts?: Partial<ToolFSOptions>) {
+    let basePath = opts?.baseDirectory || "";
+
+    if(basePath !== "" && !basePath.endsWith("/")) {
+        basePath += "/";
+    }
+
+    const fixPath = (path: string) => basePath + path;
+
+    return [
+        createTool({
+            name: "CreateDir",
+            description: "Create a directory.",
+            schema: z.object({
+                path: z.string()
+            }),
+            fn: ({ path }) => fs.mkdir(fixPath(path)),
+            message: ({ path }) => `Creating directory \`${path}\``
+        }),
+        createTool({
+            name: "ListFiles",
+            description: "List files in a directory.",
+            schema: z.object({
+                path: z.string()
+            }),
+            fn: ({ path }) => fs.readdir(fixPath(path)),
+            message: ({ path }) => `Listing files at \`${path}\``
+        }),
+        createTool({
+            name: "ReadFile",
+            description: "Read the content of a file.",
+            schema: z.object({
+                path: z.string()
+            }),
+            fn: ({ path }) => fs.readFile(fixPath(path), { encoding: "utf8" }),
+            message: ({ path }) => `Reading file at \`${path}\``
+        }),
+        createTool({
+            name: "WriteFile",
+            description: "Write content to file.",
+            schema: z.object({
+                path: z.string(),
+                contents: z.string()
+            }),
+            fn: ({ path, contents }) => fs.writeFile(fixPath(path), contents),
+            message: ({ path }) => `Writing to \`${path}\``
+        })
+    ];
+}

package/{lib → fullstacked_modules}/archive/archive.ts

@@ -1,140 +1,140 @@
-import { bridge } from "../bridge";
-import { serializeArgs } from "../bridge/serialization";
-
-type FileEntries<T extends string | Uint8Array> = {
-    [filePath: string]: {
-        isDir: boolean;
-        contents: T;
-    };
-};
-
-function unzipDataToFileEntries(data: any[]): FileEntries<Uint8Array> {
-    const entries: FileEntries<Uint8Array> = {};
-    for (let i = 0; i < data.length; i = i + 3) {
-        entries[data[i]] = {
-            isDir: data[i + 1],
-            contents: data[i + 2]
-        };
-    }
-    return entries;
-}
-
-export function unzip(
-    entry: string | Uint8Array
-): Promise<FileEntries<Uint8Array>>;
-export function unzip(
-    entry: string | Uint8Array,
-    out: string
-): Promise<boolean>;
-export function unzip(entry: string | Uint8Array, out?: string) {
-    let method: number;
-    let args: any[];
-    let transformer: (args: any) => any;
-
-    // BIN_TO
-    if (entry instanceof Uint8Array) {
-        // _FILE => 30
-        if (typeof out === "string") {
-            method = 30;
-            args = [entry, out];
-            transformer = ([success]) => success;
-        }
-        // _BIN => 31
-        else {
-            method = 31;
-            args = [entry];
-            transformer = (unzipData) => unzipDataToFileEntries(unzipData);
-        }
-    }
-    // FILE_TO
-    else {
-        // _FILE => 32
-        if (typeof out === "string") {
-            method = 32;
-            args = [entry, out];
-            transformer = ([success]) => success;
-        }
-        // _BIN => 33
-        else {
-            method = 33;
-            args = [entry];
-            transformer = (unzipData) => unzipDataToFileEntries(unzipData);
-        }
-    }
-
-    const payload = new Uint8Array([method, ...serializeArgs(args)]);
-    return bridge(payload, transformer);
-}
-
-const te = new TextEncoder();
-
-function fileEntriesToZipData(
-    entries: FileEntries<string | Uint8Array>
-): any[] {
-    return Object.entries(entries)
-        .map(([name, { isDir, contents }]) => [
-            name,
-            isDir,
-            contents instanceof Uint8Array ? contents : te.encode(contents)
-        ])
-        .flat();
-}
-
-export function zip(
-    entry: FileEntries<string | Uint8Array>
-): Promise<Uint8Array>;
-export function zip(
-    entry: string,
-    out?: null | undefined,
-    skip?: string[]
-): Promise<Uint8Array>;
-export function zip(
-    entry: FileEntries<string | Uint8Array> | string,
-    out: string,
-    skip?: string[]
-): Promise<boolean>;
-export function zip(
-    entry: FileEntries<string | Uint8Array> | string,
-    out?: string,
-    skip?: string[]
-) {
-    let method: number;
-    let args: any[];
-    let transformer: (args: any) => any;
-
-    // BIN_TO
-    if (typeof entry === "object") {
-        // _FILE => 34
-        if (typeof out === "string") {
-            method = 34;
-            args = fileEntriesToZipData(entry);
-            args.unshift(out);
-            transformer = ([success]) => success;
-        }
-        // _BIN => 35
-        else {
-            method = 35;
-            args = fileEntriesToZipData(entry);
-            transformer = ([zipData]) => zipData;
-        }
-    }
-    // FILE_TO
-    else {
-        // _FILE => 36
-        if (typeof out === "string") {
-            method = 36;
-            args = [entry, out, ...(skip || [])];
-            transformer = ([success]) => success;
-        }
-        // _BIN => 37
-        else {
-            method = 37;
-            args = [entry, ...(skip || [])];
-            transformer = ([zipData]) => zipData;
-        }
-    }
-
-    const payload = new Uint8Array([method, ...serializeArgs(args)]);
-
-    return bridge(payload, transformer);
-}
+import { bridge } from "../bridge";
+import { serializeArgs } from "../bridge/serialization";
+
+type FileEntries<T extends string | Uint8Array> = {
+    [filePath: string]: {
+        isDir: boolean;
+        contents: T;
+    };
+};
+
+function unzipDataToFileEntries(data: any[]): FileEntries<Uint8Array> {
+    const entries: FileEntries<Uint8Array> = {};
+    for (let i = 0; i < data.length; i = i + 3) {
+        entries[data[i]] = {
+            isDir: data[i + 1],
+            contents: data[i + 2]
+        };
+    }
+    return entries;
+}
+
+export function unzip(
+    entry: string | Uint8Array
+): Promise<FileEntries<Uint8Array>>;
+export function unzip(
+    entry: string | Uint8Array,
+    out: string
+): Promise<boolean>;
+export function unzip(entry: string | Uint8Array, out?: string) {
+    let method: number;
+    let args: any[];
+    let transformer: (args: any) => any;
+
+    // BIN_TO
+    if (entry instanceof Uint8Array) {
+        // _FILE => 30
+        if (typeof out === "string") {
+            method = 30;
+            args = [entry, out];
+            transformer = ([success]) => success;
+        }
+        // _BIN => 31
+        else {
+            method = 31;
+            args = [entry];
+            transformer = (unzipData) => unzipDataToFileEntries(unzipData);
+        }
+    }
+    // FILE_TO
+    else {
+        // _FILE => 32
+        if (typeof out === "string") {
+            method = 32;
+            args = [entry, out];
+            transformer = ([success]) => success;
+        }
+        // _BIN => 33
+        else {
+            method = 33;
+            args = [entry];
+            transformer = (unzipData) => unzipDataToFileEntries(unzipData);
+        }
+    }
+
+    const payload = new Uint8Array([method, ...serializeArgs(args)]);
+    return bridge(payload, transformer);
+}
+
+const te = new TextEncoder();
+
+function fileEntriesToZipData(
+    entries: FileEntries<string | Uint8Array>
+): any[] {
+    return Object.entries(entries)
+        .map(([name, { isDir, contents }]) => [
+            name,
+            isDir,
+            contents instanceof Uint8Array ? contents : te.encode(contents)
+        ])
+        .flat();
+}
+
+export function zip(
+    entry: FileEntries<string | Uint8Array>
+): Promise<Uint8Array>;
+export function zip(
+    entry: string,
+    out?: null | undefined,
+    skip?: string[]
+): Promise<Uint8Array>;
+export function zip(
+    entry: FileEntries<string | Uint8Array> | string,
+    out: string,
+    skip?: string[]
+): Promise<boolean>;
+export function zip(
+    entry: FileEntries<string | Uint8Array> | string,
+    out?: string,
+    skip?: string[]
+) {
+    let method: number;
+    let args: any[];
+    let transformer: (args: any) => any;
+
+    // BIN_TO
+    if (typeof entry === "object") {
+        // _FILE => 34
+        if (typeof out === "string") {
+            method = 34;
+            args = fileEntriesToZipData(entry);
+            args.unshift(out);
+            transformer = ([success]) => success;
+        }
+        // _BIN => 35
+        else {
+            method = 35;
+            args = fileEntriesToZipData(entry);
+            transformer = ([zipData]) => zipData;
+        }
+    }
+    // FILE_TO
+    else {
+        // _FILE => 36
+        if (typeof out === "string") {
+            method = 36;
+            args = [entry, out, ...(skip || [])];
+            transformer = ([success]) => success;
+        }
+        // _BIN => 37
+        else {
+            method = 37;
+            args = [entry, ...(skip || [])];
+            transformer = ([zipData]) => zipData;
+        }
+    }
+
+    const payload = new Uint8Array([method, ...serializeArgs(args)]);
+
+    return bridge(payload, transformer);
+}

package/fullstacked_modules/archive/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "archive" {}

package/{lib → fullstacked_modules}/archive/index.ts

@@ -1,4 +1,4 @@
-import * as archive from "./archive";
-
-export default archive;
-export * from "./archive";
+import * as archive from "./archive";
+
+export default archive;
+export * from "./archive";

package/{lib → fullstacked_modules}/base64.ts

@@ -1,144 +1,144 @@
-// source : https://github.com/beatgammit/base64-js/tree/master
-const lookup = [];
-const revLookup = [];
-
-var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-for (let i = 0, len = code.length; i < len; ++i) {
-    lookup[i] = code[i];
-    revLookup[code.charCodeAt(i)] = i;
-}
-
-// Support decoding URL-safe base64 strings, as Node.js does.
-// See: https://en.wikipedia.org/wiki/Base64#URL_applications
-revLookup["-".charCodeAt(0)] = 62;
-revLookup["_".charCodeAt(0)] = 63;
-
-function getLens(b64) {
-    var len = b64.length;
-
-    // if (len % 4 > 0) {
-    //     throw new Error("Invalid string. Length must be a multiple of 4");
-    // }
-
-    // Trim off extra bytes after placeholder bytes are found
-    // See: https://github.com/beatgammit/base64-js/issues/42
-    var validLen = b64.indexOf("=");
-    if (validLen === -1) validLen = len;
-
-    var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
-
-    return [validLen, placeHoldersLen];
-}
-
-// base64 is 4/3 + up to two characters of the original data
-function byteLength(b64) {
-    var lens = getLens(b64);
-    var validLen = lens[0];
-    var placeHoldersLen = lens[1];
-    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
-}
-
-function _byteLength(b64, validLen, placeHoldersLen) {
-    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
-}
-
-export function toByteArray(b64: string) {
-    let tmp: any;
-    const lens = getLens(b64);
-    const validLen = lens[0];
-    const placeHoldersLen = lens[1];
-
-    const arr = new Uint8Array(_byteLength(b64, validLen, placeHoldersLen));
-
-    let curByte = 0;
-
-    // if there are placeholders, only get up to the last complete 4 chars
-    const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
-
-    let i: number;
-    for (i = 0; i < len; i += 4) {
-        tmp =
-            (revLookup[b64.charCodeAt(i)] << 18) |
-            (revLookup[b64.charCodeAt(i + 1)] << 12) |
-            (revLookup[b64.charCodeAt(i + 2)] << 6) |
-            revLookup[b64.charCodeAt(i + 3)];
-        arr[curByte++] = (tmp >> 16) & 0xff;
-        arr[curByte++] = (tmp >> 8) & 0xff;
-        arr[curByte++] = tmp & 0xff;
-    }
-
-    if (placeHoldersLen === 2) {
-        tmp =
-            (revLookup[b64.charCodeAt(i)] << 2) |
-            (revLookup[b64.charCodeAt(i + 1)] >> 4);
-        arr[curByte++] = tmp & 0xff;
-    }
-
-    if (placeHoldersLen === 1) {
-        tmp =
-            (revLookup[b64.charCodeAt(i)] << 10) |
-            (revLookup[b64.charCodeAt(i + 1)] << 4) |
-            (revLookup[b64.charCodeAt(i + 2)] >> 2);
-        arr[curByte++] = (tmp >> 8) & 0xff;
-        arr[curByte++] = tmp & 0xff;
-    }
-
-    return arr;
-}
-
-function tripletToBase64(num) {
-    return (
-        lookup[(num >> 18) & 0x3f] +
-        lookup[(num >> 12) & 0x3f] +
-        lookup[(num >> 6) & 0x3f] +
-        lookup[num & 0x3f]
-    );
-}
-
-function encodeChunk(uint8, start, end) {
-    var tmp;
-    var output = [];
-    for (var i = start; i < end; i += 3) {
-        tmp =
-            ((uint8[i] << 16) & 0xff0000) +
-            ((uint8[i + 1] << 8) & 0xff00) +
-            (uint8[i + 2] & 0xff);
-        output.push(tripletToBase64(tmp));
-    }
-    return output.join("");
-}
-
-export function fromByteArray(uint8: Uint8Array) {
-    let tmp;
-    const len = uint8.length;
-    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
-    const parts = [];
-    const maxChunkLength = 16383; // must be multiple of 3
-
-    // go through the array every three bytes, we'll deal with trailing stuff later
-    for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-        parts.push(
-            encodeChunk(
-                uint8,
-                i,
-                i + maxChunkLength > len2 ? len2 : i + maxChunkLength
-            )
-        );
-    }
-
-    // pad the end with zeros, but make sure to not forget the extra bytes
-    if (extraBytes === 1) {
-        tmp = uint8[len - 1];
-        parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + "==");
-    } else if (extraBytes === 2) {
-        tmp = (uint8[len - 2] << 8) + uint8[len - 1];
-        parts.push(
-            lookup[tmp >> 10] +
-                lookup[(tmp >> 4) & 0x3f] +
-                lookup[(tmp << 2) & 0x3f] +
-                "="
-        );
-    }
-
-    return parts.join("");
-}
+// source : https://github.com/beatgammit/base64-js/tree/master
+const lookup = [];
+const revLookup = [];
+
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let i = 0, len = code.length; i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+
+function getLens(b64) {
+    var len = b64.length;
+
+    // if (len % 4 > 0) {
+    //     throw new Error("Invalid string. Length must be a multiple of 4");
+    // }
+
+    // Trim off extra bytes after placeholder bytes are found
+    // See: https://github.com/beatgammit/base64-js/issues/42
+    var validLen = b64.indexOf("=");
+    if (validLen === -1) validLen = len;
+
+    var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
+
+    return [validLen, placeHoldersLen];
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength(b64) {
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+
+function _byteLength(b64, validLen, placeHoldersLen) {
+    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+
+export function toByteArray(b64: string) {
+    let tmp: any;
+    const lens = getLens(b64);
+    const validLen = lens[0];
+    const placeHoldersLen = lens[1];
+
+    const arr = new Uint8Array(_byteLength(b64, validLen, placeHoldersLen));
+
+    let curByte = 0;
+
+    // if there are placeholders, only get up to the last complete 4 chars
+    const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+
+    let i: number;
+    for (i = 0; i < len; i += 4) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 18) |
+            (revLookup[b64.charCodeAt(i + 1)] << 12) |
+            (revLookup[b64.charCodeAt(i + 2)] << 6) |
+            revLookup[b64.charCodeAt(i + 3)];
+        arr[curByte++] = (tmp >> 16) & 0xff;
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+
+    if (placeHoldersLen === 2) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 2) |
+            (revLookup[b64.charCodeAt(i + 1)] >> 4);
+        arr[curByte++] = tmp & 0xff;
+    }
+
+    if (placeHoldersLen === 1) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 10) |
+            (revLookup[b64.charCodeAt(i + 1)] << 4) |
+            (revLookup[b64.charCodeAt(i + 2)] >> 2);
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+
+    return arr;
+}
+
+function tripletToBase64(num) {
+    return (
+        lookup[(num >> 18) & 0x3f] +
+        lookup[(num >> 12) & 0x3f] +
+        lookup[(num >> 6) & 0x3f] +
+        lookup[num & 0x3f]
+    );
+}
+
+function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i = start; i < end; i += 3) {
+        tmp =
+            ((uint8[i] << 16) & 0xff0000) +
+            ((uint8[i + 1] << 8) & 0xff00) +
+            (uint8[i + 2] & 0xff);
+        output.push(tripletToBase64(tmp));
+    }
+    return output.join("");
+}
+
+export function fromByteArray(uint8: Uint8Array) {
+    let tmp;
+    const len = uint8.length;
+    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    const parts = [];
+    const maxChunkLength = 16383; // must be multiple of 3
+
+    // go through the array every three bytes, we'll deal with trailing stuff later
+    for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+        parts.push(
+            encodeChunk(
+                uint8,
+                i,
+                i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+            )
+        );
+    }
+
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 1) {
+        tmp = uint8[len - 1];
+        parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + "==");
+    } else if (extraBytes === 2) {
+        tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+        parts.push(
+            lookup[tmp >> 10] +
+                lookup[(tmp >> 4) & 0x3f] +
+                lookup[(tmp << 2) & 0x3f] +
+                "="
+        );
+    }
+
+    return parts.join("");
+}