@valni/cli-darwin-x64 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@valni/cli-darwin-x64",
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"license": "SEE LICENSE IN LICENSE",
 	"publishConfig": {
 		"access": "public"

package/runtime/extensions/switchboard-local/node_modules/partial-json/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Promplate Dev Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/runtime/extensions/switchboard-local/node_modules/partial-json/README.md

@@ -0,0 +1,131 @@
+# Partial JSON Parser
+
+Sometimes we need **LLM (Large Language Models)** to produce **structural information** instead of natural language. The easiest way is to use JSON.
+
+But before receiving the last token of response, the JSON is broken, which means you can't use `JSON.parse` to decode it. But we still want to stream the data to the user.
+
+Here comes `partial-json`, a lightweight and customizable library for parsing partial JSON strings. Here is a [demo](https://promplate.dev/partial-json-parser).
+
+(Note that there is [a Python implementation](https://github.com/promplate/partial-json-parser) too)
+
+## Installation
+
+```sh
+npm i partial-json # or pnpm / bun / yarn
+```
+
+`partial-json` is implemented purely in JavaScript, and have both `commonjs` and `esm` builds.
+
+## Usage
+
+### Importing the library
+
+You can import the `parse` function and the `Allow` object from the library like this:
+
+```js
+import { parse, Allow } from "partial-json";
+```
+
+The `Allow` object is just an Enum for options. It determines what types can be partial. types not included in `allow` only appears after its completion can be ensured.
+
+### Parsing complete / partial JSON strings
+
+The `parse` function works just like the built-in `JSON.parse` when parsing a complete JSON string:
+
+```js
+let result = parse('{"key":"value"}');
+console.log(result); // Outputs: { key: 'value' }
+```
+
+You can parse a partial JSON string by passing an additional parameter to the `parse` function. This parameter is a **bitwise OR** of the constants from the `Allow` object:
+
+(Note that you can directly import the constants you need from `partial-json`)
+
+```js
+import { parse, STR, OBJ } from "partial-json";
+
+result = parse('{"key": "v', STR | OBJ);
+console.log(result); // Outputs: { key: 'v' }
+```
+
+In this example, `Allow.STR` tells the parser that it's okay if a string is incomplete, and `Allow.OBJ` tells the parser so as an object. The parser then try to return as much data as it can.
+
+If you don't allow partial strings, then it will not add `"key"` to the object because `"v` is not close:
+
+```js
+result = parse('{"key": "v', OBJ);
+console.log(result); // Outputs: {}
+
+result = parse('{"key": "value"', OBJ);
+console.log(result); // Outputs: { key: 'value' }
+```
+
+Similarity, you can parse partial arrays or even partial special values if you allow it:
+
+(Note that `allow` defaults to `Allow.ALL`)
+
+```js
+result = parse('[ {"key1": "value1", "key2": [ "value2');
+console.log(result); // Outputs: [ { key1: 'value1', key2: [ 'value2' ] } ]
+
+result = parse("-Inf");
+console.log(result); // Outputs: -Infinity
+```
+
+### Handling malformed JSON
+
+If the JSON string is malformed, the `parse` function will throw an error:
+
+```js
+parse("wrong"); // MalformedJSON [Error]: SyntaxError: Unexpected token 'w', "wrong" is not valid JSON at position 0
+```
+
+## API Reference
+
+### parse(jsonString, [allowPartial])
+
+- `jsonString` `<string>`: The JSON string to parse.
+- `allowPartial` `<number>`: Specify what kind of partialness is allowed during JSON parsing (default: `Allow.ALL`).
+
+Returns the parsed JavaScript value.
+
+### Allow
+
+An object that specifies what kind of partialness is allowed during JSON parsing. It has the following properties:
+
+- `STR`: Allow partial string.
+- `NUM`: Allow partial number.
+- `ARR`: Allow partial array.
+- `OBJ`: Allow partial object.
+- `NULL`: Allow partial null.
+- `BOOL`: Allow partial boolean.
+- `NAN`: Allow partial NaN.
+- `INFINITY`: Allow partial Infinity.
+- `_INFINITY`: Allow partial -Infinity.
+- `INF`: Allow both partial Infinity and -Infinity.
+- `SPECIAL`: Allow all special values.
+- `ATOM`: Allow all atomic values.
+- `COLLECTION`: Allow all collection values.
+- `ALL`: Allow all values.
+
+## Testing
+
+To run the tests for this library, you should clone the repository and install the dependencies:
+
+```sh
+git clone https://github.com/promplate/partial-json-parser-js.git
+cd partial-json-parser-js
+npm i
+```
+
+Then, you can run the tests using [Vitest](https://vitest.dev/):
+
+```sh
+npm run test
+```
+
+Please note that while we strive to cover as many edge cases as possible, it's always possible that some cases might not be covered.
+
+## License
+
+This project is licensed under the MIT License.

package/runtime/extensions/switchboard-local/node_modules/partial-json/dist/index.js

@@ -0,0 +1,220 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+const options_1 = require("./options");
+Object.defineProperty(exports, "Allow", { enumerable: true, get: function () { return options_1.Allow; } });
+__exportStar(require("./options"), exports);
+class PartialJSON extends Error {
+}
+exports.PartialJSON = PartialJSON;
+class MalformedJSON extends Error {
+}
+exports.MalformedJSON = MalformedJSON;
+/**
+ * Parse incomplete JSON
+ * @param {string} jsonString Partial JSON to be parsed
+ * @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details
+ * @returns The parsed JSON
+ * @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter)
+ * @throws {MalformedJSON} If the JSON is malformed
+ */
+function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+    if (typeof jsonString !== "string") {
+        throw new TypeError(`expecting str, got ${typeof jsonString}`);
+    }
+    if (!jsonString.trim()) {
+        throw new Error(`${jsonString} is empty`);
+    }
+    return _parseJSON(jsonString.trim(), allowPartial);
+}
+exports.parseJSON = parseJSON;
+;
+const _parseJSON = (jsonString, allow) => {
+    const length = jsonString.length;
+    let index = 0;
+    const markPartialJSON = (msg) => {
+        throw new PartialJSON(`${msg} at position ${index}`);
+    };
+    const throwMalformedError = (msg) => {
+        throw new MalformedJSON(`${msg} at position ${index}`);
+    };
+    const parseAny = () => {
+        skipBlank();
+        if (index >= length)
+            markPartialJSON("Unexpected end of input");
+        if (jsonString[index] === '"')
+            return parseStr();
+        if (jsonString[index] === "{")
+            return parseObj();
+        if (jsonString[index] === "[")
+            return parseArr();
+        if (jsonString.substring(index, index + 4) === "null" || (options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return null;
+        }
+        if (jsonString.substring(index, index + 4) === "true" || (options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index)))) {
+            index += 4;
+            return true;
+        }
+        if (jsonString.substring(index, index + 5) === "false" || (options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index)))) {
+            index += 5;
+            return false;
+        }
+        if (jsonString.substring(index, index + 8) === "Infinity" || (options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index)))) {
+            index += 8;
+            return Infinity;
+        }
+        if (jsonString.substring(index, index + 9) === "-Infinity" || (options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index)))) {
+            index += 9;
+            return -Infinity;
+        }
+        if (jsonString.substring(index, index + 3) === "NaN" || (options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index)))) {
+            index += 3;
+            return NaN;
+        }
+        return parseNum();
+    };
+    const parseStr = () => {
+        const start = index;
+        let escape = false;
+        index++; // skip initial quote
+        while (index < length && (jsonString[index] !== '"' || (escape && jsonString[index - 1] === "\\"))) {
+            escape = jsonString[index] === "\\" ? !escape : false;
+            index++;
+        }
+        if (jsonString.charAt(index) == '"') {
+            try {
+                return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
+            }
+            catch (e) {
+                throwMalformedError(String(e));
+            }
+        }
+        else if (options_1.Allow.STR & allow) {
+            try {
+                return JSON.parse(jsonString.substring(start, index - Number(escape)) + '"');
+            }
+            catch (e) {
+                // SyntaxError: Invalid escape sequence
+                return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + '"');
+            }
+        }
+        markPartialJSON("Unterminated string literal");
+    };
+    const parseObj = () => {
+        index++; // skip initial brace
+        skipBlank();
+        const obj = {};
+        try {
+            while (jsonString[index] !== "}") {
+                skipBlank();
+                if (index >= length && options_1.Allow.OBJ & allow)
+                    return obj;
+                const key = parseStr();
+                skipBlank();
+                index++; // skip colon
+                try {
+                    const value = parseAny();
+                    obj[key] = value;
+                }
+                catch (e) {
+                    if (options_1.Allow.OBJ & allow)
+                        return obj;
+                    else
+                        throw e;
+                }
+                skipBlank();
+                if (jsonString[index] === ",")
+                    index++; // skip comma
+            }
+        }
+        catch (e) {
+            if (options_1.Allow.OBJ & allow)
+                return obj;
+            else
+                markPartialJSON("Expected '}' at end of object");
+        }
+        index++; // skip final brace
+        return obj;
+    };
+    const parseArr = () => {
+        index++; // skip initial bracket
+        const arr = [];
+        try {
+            while (jsonString[index] !== "]") {
+                arr.push(parseAny());
+                skipBlank();
+                if (jsonString[index] === ",") {
+                    index++; // skip comma
+                }
+            }
+        }
+        catch (e) {
+            if (options_1.Allow.ARR & allow) {
+                return arr;
+            }
+            markPartialJSON("Expected ']' at end of array");
+        }
+        index++; // skip final bracket
+        return arr;
+    };
+    const parseNum = () => {
+        if (index === 0) {
+            if (jsonString === "-")
+                throwMalformedError("Not sure what '-' is");
+            try {
+                return JSON.parse(jsonString);
+            }
+            catch (e) {
+                if (options_1.Allow.NUM & allow)
+                    try {
+                        return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+                    }
+                    catch (e) { }
+                throwMalformedError(String(e));
+            }
+        }
+        const start = index;
+        if (jsonString[index] === "-")
+            index++;
+        while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1)
+            index++;
+        if (index == length && !(options_1.Allow.NUM & allow))
+            markPartialJSON("Unterminated number literal");
+        try {
+            return JSON.parse(jsonString.substring(start, index));
+        }
+        catch (e) {
+            if (jsonString.substring(start, index) === "-")
+                markPartialJSON("Not sure what '-' is");
+            try {
+                return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
+            }
+            catch (e) {
+                throwMalformedError(String(e));
+            }
+        }
+    };
+    const skipBlank = () => {
+        while (index < length && " \n\r\t".includes(jsonString[index])) {
+            index++;
+        }
+    };
+    return parseAny();
+};
+const parse = parseJSON;
+exports.parse = parse;

package/runtime/extensions/switchboard-local/node_modules/partial-json/dist/options.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * Sometimes you don't allow every type to be partially parsed.
+ * For example, you may not want a partial number because it may increase its size gradually before it's complete.
+ * In this case, you can use the `Allow` object to control what types you allow to be partially parsed.
+ * @module
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+/**
+ * allow partial strings like `"hello \u12` to be parsed as `"hello "`
+ */
+exports.STR = 0b000000001;
+/**
+ * allow partial numbers like `123.` to be parsed as `123`
+ */
+exports.NUM = 0b000000010;
+/**
+ * allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+ */
+exports.ARR = 0b000000100;
+/**
+ * allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+ */
+exports.OBJ = 0b000001000;
+/**
+ * allow `nu` to be parsed as `null`
+ */
+exports.NULL = 0b000010000;
+/**
+ * allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+ */
+exports.BOOL = 0b000100000;
+/**
+ * allow `Na` to be parsed as `NaN`
+ */
+exports.NAN = 0b001000000;
+/**
+ * allow `Inf` to be parsed as `Infinity`
+ */
+exports.INFINITY = 0b010000000;
+/**
+ * allow `-Inf` to be parsed as `-Infinity`
+ */
+exports._INFINITY = 0b100000000;
+exports.INF = exports.INFINITY | exports._INFINITY;
+exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+exports.COLLECTION = exports.ARR | exports.OBJ;
+exports.ALL = exports.ATOM | exports.COLLECTION;
+/**
+ * Control what types you allow to be partially parsed.
+ * The default is to allow all types to be partially parsed, which in most casees is the best option.
+ * @example
+ * If you don't want to allow partial objects, you can use the following code:
+ * ```ts
+ * import { Allow, parse } from "partial-json";
+ * parse(`[{"a": 1, "b": 2}, {"a": 3,`, Allow.ARR); // [ { a: 1, b: 2 } ]
+ * ```
+ * Or you can use `~` to disallow a type:
+ * ```ts
+ * parse(`[{"a": 1, "b": 2}, {"a": 3,`, ~Allow.OBJ); // [ { a: 1, b: 2 } ]
+ * ```
+ * @example
+ * If you don't want to allow partial strings, you can use the following code:
+ * ```ts
+ * import { Allow, parse } from "partial-json";
+ * parse(`["complete string", "incompl`, ~Allow.STR); // [ 'complete string' ]
+ * ```
+ */
+exports.Allow = { STR: exports.STR, NUM: exports.NUM, ARR: exports.ARR, OBJ: exports.OBJ, NULL: exports.NULL, BOOL: exports.BOOL, NAN: exports.NAN, INFINITY: exports.INFINITY, _INFINITY: exports._INFINITY, INF: exports.INF, SPECIAL: exports.SPECIAL, ATOM: exports.ATOM, COLLECTION: exports.COLLECTION, ALL: exports.ALL };
+exports.default = exports.Allow;

package/runtime/extensions/switchboard-local/node_modules/partial-json/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "partial-json",
+  "version": "0.1.7",
+  "description": "Parse partial JSON generated by LLM",
+  "keywords": [
+    "JSON",
+    "parser",
+    "LLM",
+    "nlp"
+  ],
+  "homepage": "https://promplate.dev/partial-json-parser",
+  "repository": "https://github.com/promplate/partial-json-parser-js",
+  "license": "MIT",
+  "author": "Muspi Merol <me@promplate.dev>",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./options": {
+      "types": "./dist/options.d.ts",
+      "default": "./dist/options.js"
+    }
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "coverage": "vitest run --coverage",
+    "test": "vitest",
+    "test:ui": "vitest --ui"
+  },
+  "devDependencies": {
+    "@vitest/coverage-istanbul": "^1.2.2",
+    "@vitest/ui": "^1.2.2",
+    "typescript": "^5.3.3",
+    "vitest": "^1.2.2"
+  }
+}

package/runtime/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@valni/cli",
 	"private": true,
-	"version": "0.1.6",
+	"version": "0.1.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"valniConfig": {
@@ -38,9 +38,9 @@
 		"prepublishOnly": "npm run clean && npm run build && npm run shrinkwrap"
 	},
 	"dependencies": {
-		"@valni/agent-core": "^0.1.6",
-		"@valni/ai": "^0.1.6",
-		"@valni/tui": "^0.1.6",
+		"@valni/agent-core": "^0.1.7",
+		"@valni/ai": "^0.1.7",
+		"@valni/tui": "^0.1.7",
 		"pi-switchboard": "git+https://github.com/Valni-Labs/pi-switchboard.git#774f1a7985a755fcd483313b729864aa8a9418c3",
 		"switchboard-local": "git+https://github.com/Valni-Labs/switchboard-local.git#4ec07263591a4f329fd12eab04d62d6c455be666",
 		"@silvia-odwyer/photon-node": "0.3.4",

package/runtime/valni

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/runtime/valni
 size: 76058832 bytes
-sha256: e2d416ce62acfeec49e80bdf551316c4807ffbb0a37d09d90a096919a4284b54
+sha256: 270e1c1d383b4800d98c432e23186cd63690ca5c8387a97cbcd4bd8057343ad1