bantou 0.1.0 → 0.2.0

package/.output/server/node_modules/@modelcontextprotocol/sdk/dist/esm/validation/ajv-provider.js

@@ -0,0 +1,87 @@
+/**
+ * AJV-based JSON Schema validator provider
+ */
+import Ajv from 'ajv';
+import _addFormats from 'ajv-formats';
+function createDefaultAjvInstance() {
+    const ajv = new Ajv({
+        strict: false,
+        validateFormats: true,
+        validateSchema: false,
+        allErrors: true
+    });
+    const addFormats = _addFormats;
+    addFormats(ajv);
+    return ajv;
+}
+/**
+ * @example
+ * ```typescript
+ * // Use with default AJV instance (recommended)
+ * import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+ * const validator = new AjvJsonSchemaValidator();
+ *
+ * // Use with custom AJV instance
+ * import { Ajv } from 'ajv';
+ * const ajv = new Ajv({ strict: true, allErrors: true });
+ * const validator = new AjvJsonSchemaValidator(ajv);
+ * ```
+ */
+export class AjvJsonSchemaValidator {
+    /**
+     * Create an AJV validator
+     *
+     * @param ajv - Optional pre-configured AJV instance. If not provided, a default instance will be created.
+     *
+     * @example
+     * ```typescript
+     * // Use default configuration (recommended for most cases)
+     * import { AjvJsonSchemaValidator } from '@modelcontextprotocol/sdk/validation/ajv';
+     * const validator = new AjvJsonSchemaValidator();
+     *
+     * // Or provide custom AJV instance for advanced configuration
+     * import { Ajv } from 'ajv';
+     * import addFormats from 'ajv-formats';
+     *
+     * const ajv = new Ajv({ validateFormats: true });
+     * addFormats(ajv);
+     * const validator = new AjvJsonSchemaValidator(ajv);
+     * ```
+     */
+    constructor(ajv) {
+        this._ajv = ajv ?? createDefaultAjvInstance();
+    }
+    /**
+     * Create a validator for the given JSON Schema
+     *
+     * The validator is compiled once and can be reused multiple times.
+     * If the schema has an $id, it will be cached by AJV automatically.
+     *
+     * @param schema - Standard JSON Schema object
+     * @returns A validator function that validates input data
+     */
+    getValidator(schema) {
+        // Check if schema has $id and is already compiled/cached
+        const ajvValidator = '$id' in schema && typeof schema.$id === 'string'
+            ? (this._ajv.getSchema(schema.$id) ?? this._ajv.compile(schema))
+            : this._ajv.compile(schema);
+        return (input) => {
+            const valid = ajvValidator(input);
+            if (valid) {
+                return {
+                    valid: true,
+                    data: input,
+                    errorMessage: undefined
+                };
+            }
+            else {
+                return {
+                    valid: false,
+                    data: undefined,
+                    errorMessage: this._ajv.errorsText(ajvValidator.errors)
+                };
+            }
+        };
+    }
+}
+//# sourceMappingURL=ajv-provider.js.map

package/.output/server/node_modules/@modelcontextprotocol/sdk/package.json

@@ -0,0 +1,165 @@
+{
+  "name": "@modelcontextprotocol/sdk",
+  "version": "1.32.2",
+  "description": "Model Context Protocol implementation for TypeScript",
+  "license": "MIT",
+  "author": "Anthropic, PBC (https://anthropic.com)",
+  "homepage": "https://modelcontextprotocol.io",
+  "bugs": "https://github.com/modelcontextprotocol/typescript-sdk/issues",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/modelcontextprotocol/typescript-sdk.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "modelcontextprotocol",
+    "mcp"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/esm/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js"
+    },
+    "./client": {
+      "types": "./dist/esm/client/index.d.ts",
+      "import": "./dist/esm/client/index.js",
+      "require": "./dist/cjs/client/index.js"
+    },
+    "./server": {
+      "types": "./dist/esm/server/index.d.ts",
+      "import": "./dist/esm/server/index.js",
+      "require": "./dist/cjs/server/index.js"
+    },
+    "./validation": {
+      "types": "./dist/esm/validation/index.d.ts",
+      "import": "./dist/esm/validation/index.js",
+      "require": "./dist/cjs/validation/index.js"
+    },
+    "./validation/ajv": {
+      "types": "./dist/esm/validation/ajv-provider.d.ts",
+      "import": "./dist/esm/validation/ajv-provider.js",
+      "require": "./dist/cjs/validation/ajv-provider.js"
+    },
+    "./validation/cfworker": {
+      "types": "./dist/esm/validation/cfworker-provider.d.ts",
+      "import": "./dist/esm/validation/cfworker-provider.js",
+      "require": "./dist/cjs/validation/cfworker-provider.js"
+    },
+    "./experimental": {
+      "types": "./dist/esm/experimental/index.d.ts",
+      "import": "./dist/esm/experimental/index.js",
+      "require": "./dist/cjs/experimental/index.js"
+    },
+    "./experimental/tasks": {
+      "types": "./dist/esm/experimental/tasks/index.d.ts",
+      "import": "./dist/esm/experimental/tasks/index.js",
+      "require": "./dist/cjs/experimental/tasks/index.js"
+    },
+    "./*": {
+      "types": "./dist/esm/*.d.ts",
+      "import": "./dist/esm/*",
+      "require": "./dist/cjs/*"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./dist/esm/*"
+      ]
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "fetch:spec-types": "tsx scripts/fetch-spec-types.ts",
+    "typecheck": "tsgo --noEmit",
+    "build": "npm run build:esm && npm run build:cjs",
+    "build:esm": "mkdir -p dist/esm && echo '{\"type\": \"module\"}' > dist/esm/package.json && tsc -p tsconfig.prod.json",
+    "build:esm:w": "npm run build:esm -- -w",
+    "build:cjs": "mkdir -p dist/cjs && echo '{\"type\": \"commonjs\"}' > dist/cjs/package.json && tsc -p tsconfig.cjs.json",
+    "build:cjs:w": "npm run build:cjs -- -w",
+    "examples:simple-server:w": "tsx --watch src/examples/server/simpleStreamableHttp.ts --oauth",
+    "prepack": "npm run build:esm && npm run build:cjs",
+    "lint": "eslint src/ && prettier --check .",
+    "lint:fix": "eslint src/ --fix && prettier --write .",
+    "check": "npm run typecheck && npm run lint",
+    "test": "vitest run --exclude \"test/e2e/**\"",
+    "test:e2e": "vitest run test/e2e",
+    "test:watch": "vitest",
+    "start": "npm run server",
+    "server": "tsx watch --clear-screen=false scripts/cli.ts server",
+    "client": "tsx scripts/cli.ts client",
+    "test:conformance:server": "test/conformance/scripts/run-server-conformance.sh --expected-failures test/conformance/conformance-baseline.yml",
+    "test:conformance:server:all": "test/conformance/scripts/run-server-conformance.sh --suite all --expected-failures test/conformance/conformance-baseline.yml",
+    "test:conformance:server:run": "npx tsx test/conformance/src/everythingServer.ts",
+    "test:conformance:client": "npx @modelcontextprotocol/conformance client --command 'npx tsx test/conformance/src/everythingClient.ts' --expected-failures test/conformance/conformance-baseline.yml",
+    "test:conformance:client:all": "npx @modelcontextprotocol/conformance client --command 'npx tsx test/conformance/src/everythingClient.ts' --suite all --expected-failures test/conformance/conformance-baseline.yml"
+  },
+  "dependencies": {
+    "@hono/node-server": "^1.19.9 || ^2.0.5",
+    "ajv": "^8.17.1",
+    "ajv-formats": "^3.0.1",
+    "content-type": "^1.0.5",
+    "cors": "^2.8.5",
+    "cross-spawn": "^7.0.5",
+    "eventsource": "^3.0.2",
+    "eventsource-parser": "^3.0.0",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.2.1",
+    "hono": "^4.11.4",
+    "jose": "^6.1.3",
+    "json-schema-typed": "^8.0.2",
+    "pkce-challenge": "^5.0.0",
+    "raw-body": "^3.0.0",
+    "zod": "^3.25 || ^4.0",
+    "zod-to-json-schema": "^3.25.1"
+  },
+  "peerDependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "zod": "^3.25 || ^4.0"
+  },
+  "peerDependenciesMeta": {
+    "@cfworker/json-schema": {
+      "optional": true
+    },
+    "zod": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@cfworker/json-schema": "^4.1.1",
+    "@eslint/js": "^9.39.1",
+    "@modelcontextprotocol/conformance": "^0.1.14",
+    "@types/content-type": "^1.1.8",
+    "@types/cors": "^2.8.17",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/eventsource": "^1.1.15",
+    "@types/express": "^5.0.0",
+    "@types/express-serve-static-core": "^5.1.0",
+    "@types/node": "^22.12.0",
+    "@types/supertest": "^6.0.2",
+    "@types/ws": "^8.5.12",
+    "@typescript/native-preview": "^7.0.0-dev.20251103.1",
+    "eslint": "^9.8.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-n": "^17.23.1",
+    "prettier": "3.6.2",
+    "supertest": "^7.0.0",
+    "tsx": "^4.16.5",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.48.1",
+    "vitest": "^4.0.8",
+    "ws": "^8.18.0"
+  },
+  "resolutions": {
+    "strip-ansi": "6.0.1"
+  },
+  "overrides": {
+    "qs": "6.14.1"
+  }
+}

package/.output/server/node_modules/@parcel/watcher-wasm/index.mjs

@@ -0,0 +1,349 @@
+import {Environment, napi} from 'napi-wasm';
+import fs from 'fs';
+import Path from 'path';
+import {createWrapper} from './wrapper.js';
+
+let env;
+let encoder = new TextEncoder();
+
+let constants = {
+  O_ACCMODE: 0o00000003,
+  O_RDONLY: 0,
+  O_WRONLY: 0o00000001,
+  O_RDWR: 0o00000002,
+  O_CREAT: 0o00000100,
+  O_EXCL: 0o00000200,
+  O_NOCTTY: 0o00000400,
+  O_TRUNC: 0o00001000,
+  O_APPEND: 0o00002000,
+  O_NONBLOCK: 0o00004000,
+  O_SYNC: 0o00010000,
+  FASYNC: 0o00020000,
+  O_DIRECT: 0o00040000,
+  O_LARGEFILE: 0o00100000,
+  O_DIRECTORY: 0o00200000,
+  O_NOFOLLOW: 0o00400000,
+  O_NOATIME: 0o01000000,
+  O_CLOEXEC: 0o02000000,
+};
+
+napi.napi_get_last_error_info = () => {};
+
+const fds = new Map();
+const dirs = new Map();
+const regexCache = new Map();
+const watches = [null];
+
+const wasm_env = {
+  __syscall_newfstatat(dirfd, path, buf, flags) {
+    let dir = dirfd === -100 ? process.cwd() : fds.get(dirfd).path;
+    let p = Path.resolve(dir, env.getString(path));
+    let nofollow = flags & 256;
+    try {
+      let stat = nofollow
+        ? fs.lstatSync(p, {bigint: true})
+        : fs.statSync(p, {bigint: true});
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_lstat64(path, buf) {
+    let p = env.getString(path);
+    try {
+      let stat = fs.lstatSync(p, {bigint: true});
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_fstat64(fd, buf) {
+    try {
+      let stat = fs.fstatSync(fd, {bigint: true});
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_stat64(path, buf) {
+    let p = env.getString(path);
+    try {
+      let stat = fs.statSync(p, {bigint: true});
+      return writeStat(stat, buf);
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_getdents64(fd, dirp, count) {
+    let p = fds.get(fd).path;
+    let dir = dirs.get(fd);
+    let entries = dir?.entries;
+    if (!entries) {
+      try {
+        entries = fs.readdirSync(p, {withFileTypes: true});
+      } catch (err) {
+        env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+        return -1;
+      }
+    }
+
+    let start = dirp;
+    let i = dir?.index || 0;
+    for (; i < entries.length; i++) {
+      let entry = entries[i];
+      let type = entry.isFIFO()
+        ? 1
+        : entry.isCharacterDevice()
+        ? 2
+        : entry.isDirectory()
+        ? 4
+        : entry.isBlockDevice()
+        ? 6
+        : entry.isFile()
+        ? 8
+        : entry.isSymbolicLink()
+        ? 10
+        : entry.isSocket()
+        ? 12
+        : 0;
+      let len = align(utf8Length(entry.name) + 20, 8);
+      if (dirp - start + len > count) {
+        break;
+      }
+
+      // Write a linux_dirent64 struct into wasm memory.
+      env.u64[dirp >> 3] = 1n; // ino
+      env.u64[(dirp + 8) >> 3] = BigInt(dirp - start + len); // offset
+      env.u16[(dirp + 16) >> 1] = len;
+      env.memory[dirp + 18] = type;
+      let {written} = encoder.encodeInto(
+        entry.name,
+        env.memory.subarray(dirp + 19),
+      );
+      env.memory[dirp + 19 + written] = 0; // null terminate
+      dirp += len;
+    }
+
+    dirs.set(fd, {index: i, entries});
+    return dirp - start;
+  },
+  __syscall_openat(dirfd, path, flags, mode) {
+    // Convert flags to Node values.
+    let f = 0;
+    for (let c in constants) {
+      if (flags & constants[c]) {
+        f |= fs.constants[c] || 0;
+      }
+    }
+    let dir = dirfd === -100 ? process.cwd() : fds.get(dirfd)?.path;
+    if (!dir) {
+      env.i32[env.instance.exports.__errno_location >> 2] = 9970; // ENOTDIR
+      return -1;
+    }
+    let p = Path.resolve(dir, env.getString(path));
+    try {
+      let fd = fs.openSync(p, f);
+      fds.set(fd, {path: p, flags});
+      return fd;
+    } catch (err) {
+      env.i32[env.instance.exports.__errno_location >> 2] = err.errno;
+      return -1;
+    }
+  },
+  __syscall_fcntl64(fd, cmd) {
+    switch (cmd) {
+      case 3:
+        return fds.get(fd).flags;
+      case 2:
+        return 0;
+      default:
+        throw new Error('Unknown fcntl64 call: ' + cmd);
+    }
+  },
+  __syscall_ioctl() {},
+  emscripten_resize_heap() {
+    return 0;
+  },
+  _abort_js() {},
+  wasm_backend_add_watch(filename, backend) {
+    let path = env.getString(filename);
+    let watch = fs.watch(path, {encoding: 'buffer'}, (eventType, filename) => {
+      if (filename) {
+        let type = eventType === 'change' ? 1 : 2;
+        let fptr = env.instance.exports.malloc(filename.byteLength + 1);
+        env.memory.set(filename, fptr);
+        env.memory[fptr + filename.byteLength] = 0;
+        env.instance.exports.wasm_backend_event_handler(
+          backend,
+          wd,
+          type,
+          fptr,
+        );
+        env.instance.exports.free(fptr);
+      }
+    });
+
+    let wd = watches.length;
+    watches.push(watch);
+    return wd;
+  },
+  wasm_backend_remove_watch(wd) {
+    watches[wd].close();
+    watches[wd] = undefined;
+  },
+  set_timeout(ms, ctx) {
+    return setTimeout(() => {
+      env.instance.exports.on_timeout(ctx);
+    }, ms);
+  },
+  clear_timeout(t) {
+    clearTimeout(t);
+  },
+  _setitimer_js() {},
+  emscripten_date_now() {
+    return Date.now();
+  },
+  _emscripten_get_now_is_monotonic() {
+    return true;
+  },
+  _emscripten_runtime_keepalive_clear() {},
+  emscripten_get_now() {
+    return performance.now();
+  },
+  wasm_regex_match(string, regex) {
+    let re = regexCache.get(regex);
+    if (!re) {
+      re = new RegExp(env.getString(regex));
+      regexCache.set(regex, re);
+    }
+    return re.test(env.getString(string)) ? 1 : 0;
+  },
+};
+
+const wasi = {
+  fd_close(fd) {
+    fs.closeSync(fd);
+    fds.delete(fd);
+    dirs.delete(fd);
+    return 0;
+  },
+  fd_seek(fd, offset_low, offset_high, whence, newOffset) {
+    return 0;
+  },
+  fd_write(fd, iov, iovcnt, pnum) {
+    let buffers = [];
+    for (let i = 0; i < iovcnt; i++) {
+      let ptr = env.u32[iov >> 2];
+      let len = env.u32[(iov + 4) >> 2];
+      iov += 8;
+      if (len > 0) {
+        buffers.push(env.memory.subarray(ptr, ptr + len));
+      }
+    }
+    let wrote = fs.writevSync(fd, buffers);
+    env.u32[pnum >> 2] = wrote;
+    return 0;
+  },
+  fd_read(fd, iov, iovcnt, pnum) {
+    let buffers = [];
+    for (let i = 0; i < iovcnt; i++) {
+      let ptr = env.u32[iov >> 2];
+      let len = env.u32[(iov + 4) >> 2];
+      iov += 8;
+      if (len > 0) {
+        buffers.push(env.memory.subarray(ptr, ptr + len));
+      }
+    }
+
+    let read = fs.readvSync(fd, buffers);
+    env.u32[pnum >> 2] = read;
+    return 0;
+  },
+  proc_exit() {},
+  clock_time_get() {},
+};
+
+function writeStat(stat, buf) {
+  env.i32[buf >> 2] = Number(stat.dev);
+  env.i32[(buf + 4) >> 2] = Number(stat.mode);
+  env.u32[(buf + 8) >> 2] = Number(stat.nlink);
+  env.i32[(buf + 12) >> 2] = Number(stat.uid);
+  env.i32[(buf + 16) >> 2] = Number(stat.gid);
+  env.i32[(buf + 20) >> 2] = Number(stat.rdev);
+  env.u64[(buf + 24) >> 3] = stat.size;
+  env.i32[(buf + 32) >> 2] = Number(stat.blksize);
+  env.i32[(buf + 36) >> 2] = Number(stat.blocks);
+  env.u64[(buf + 40) >> 3] = stat.atimeMs;
+  env.u32[(buf + 48) >> 2] = Number(stat.atimeNs);
+  env.u64[(buf + 56) >> 3] = stat.mtimeMs;
+  env.u32[(buf + 64) >> 2] = Number(stat.mtimeNs);
+  env.u64[(buf + 72) >> 3] = stat.ctimeMs;
+  env.u32[(buf + 80) >> 2] = Number(stat.ctimeNs);
+  env.u64[(buf + 88) >> 3] = stat.ino;
+  return 0;
+}
+
+function utf8Length(string) {
+  let len = 0;
+  for (let i = 0; i < string.length; i++) {
+    let c = string.charCodeAt(i);
+
+    if (c >= 0xd800 && c <= 0xdbff && i < string.length - 1) {
+      let c2 = string.charCodeAt(++i);
+      if ((c2 & 0xfc00) === 0xdc00) {
+        c = ((c & 0x3ff) << 10) + (c2 & 0x3ff) + 0x10000;
+      } else {
+        // unmatched surrogate.
+        i--;
+      }
+    }
+
+    if ((c & 0xffffff80) === 0) {
+      len++;
+    } else if ((c & 0xfffff800) === 0) {
+      len += 2;
+    } else if ((c & 0xffff0000) === 0) {
+      len += 3;
+    } else if ((c & 0xffe00000) === 0) {
+      len += 4;
+    }
+  }
+  return len;
+}
+
+function align(len, p) {
+  return Math.ceil(len / p) * p;
+}
+
+let wasmBytes = fs.readFileSync(
+  new URL('watcher.wasm', import.meta.url),
+);
+let wasmModule = new WebAssembly.Module(wasmBytes);
+let instance = new WebAssembly.Instance(wasmModule, {
+  napi,
+  env: wasm_env,
+  wasi_snapshot_preview1: wasi,
+});
+
+env = new Environment(instance);
+let wrapper = createWrapper(env.exports);
+
+export function writeSnapshot(dir, snapshot, opts) {
+  return wrapper.writeSnapshot(dir, snapshot, opts);
+}
+
+export function getEventsSince(dir, snapshot, opts) {
+  return wrapper.getEventsSince(dir, snapshot, opts);
+}
+
+export function subscribe(dir, fn, opts) {
+  return wrapper.subscribe(dir, fn, opts);
+}
+
+export function unsubscribe(dir, fn, opts) {
+  return wrapper.unsubscribe(dir, fn, opts);
+}

package/.output/server/node_modules/@parcel/watcher-wasm/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@parcel/watcher-wasm",
+  "version": "2.6.0",
+  "main": "index.mjs",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/parcel-bundler/watcher.git"
+  },
+  "description": "A native C++ Node module for querying and subscribing to filesystem events. Used by Parcel 2.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "funding": {
+    "type": "opencollective",
+    "url": "https://opencollective.com/parcel"
+  },
+  "files": [
+    "*.js",
+    "*.cjs",
+    "*.mjs",
+    "*.d.ts",
+    "*.wasm"
+  ],
+  "engines": {
+    "node": ">= 10.0.0"
+  },
+  "dependencies": {
+    "napi-wasm": "^1.1.0",
+    "is-glob": "^4.0.3",
+    "picomatch": "^4.0.4"
+  },
+  "module": "index.mjs",
+  "sideEffects": false,
+  "exports": {
+    "types": "./index.d.ts",
+    "import": "./index.mjs",
+    "require": "./index.cjs"
+  },
+  "bundledDependencies": [
+    "napi-wasm"
+  ]
+}