@nyte-ai/host 0.0.0-stage → 0.0.19

package/dist/chunks/canvas-preview-e3vnkkc5.js

@@ -0,0 +1,134 @@
+import {
+  sha2562
+} from "./canvas-preview-0nq75h9k.js";
+import {
+  localFiles2
+} from "./canvas-preview-drctegz4.js";
+import {
+  localGit2
+} from "./canvas-preview-5ekjx6sw.js";
+import {
+  localGitHub2
+} from "./canvas-preview-8xc0vn7v.js";
+import {
+  folderIdentity2
+} from "./canvas-preview-1sq7z9jq.js";
+import {
+  localExec2
+} from "./canvas-preview-vm9zdp2t.js";
+import {
+  localSnapshots2
+} from "./canvas-preview-crmzxxt8.js";
+import {
+  localWorktrees2
+} from "./canvas-preview-2jwbe14k.js";
+
+// src/local/provider.ts
+import { constants, realpathSync } from "node:fs";
+import { access, readdir, realpath, stat } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, sep } from "node:path";
+import { asId, SdkError } from "@nyte-ai/schema";
+var PLUGIN_FILE = /\.(?:ts|mts|js|mjs)$/;
+var ROOT_SOURCES = [".nyte/SYSTEM.md", ".nyte/APPEND_SYSTEM.md", ".nyte/mcp.json"];
+function localProvider2(options) {
+  const home = options?.home ?? homedir();
+  const store = join(home, ".nyte", "snapshots");
+  let state;
+  const github = localGitHub2({ gh: options?.gh, git: options?.git });
+  return {
+    kind: "local",
+    async inspect(target) {
+      const path = readTargetPath(target);
+      if (path === null)
+        return {
+          identity: asId(sha2562(JSON.stringify(target))),
+          availability: { kind: "unavailable", reason: "unsupported" },
+          projectSources: []
+        };
+      const identity = await folderIdentity2(path);
+      if (!await readableDirectory(path))
+        return {
+          identity,
+          availability: { kind: "unavailable", reason: "unreachable" },
+          projectSources: []
+        };
+      return {
+        identity,
+        availability: { kind: "available" },
+        projectSources: await projectSources(path)
+      };
+    },
+    async attach(target) {
+      const path = readTargetPath(target);
+      if (path === null)
+        throw new SdkError("unavailable", "A local workspace needs a path.");
+      const real = await realpath(path).catch(() => null);
+      if (real === null || !await readableDirectory(real))
+        throw new SdkError("unavailable", `${path} is not a readable directory.`);
+      const detached = new AbortController;
+      const env = {
+        identity: await folderIdentity2(real),
+        cwd: real,
+        files: localFiles2(real, {
+          ripgrep: options?.ripgrep,
+          formatter: options?.formatter,
+          signal: detached.signal
+        }),
+        exec: localExec2(real, { shell: options?.shell, signal: detached.signal }),
+        close: async () => detached.abort()
+      };
+      return env;
+    },
+    git: (env) => localGit2(env, { git: options?.git }),
+    github,
+    snapshots(env) {
+      state ??= join(realpathOrSelf(home), ".nyte");
+      return nests(env.cwd, state) || nests(state, env.cwd) && !nests(join(state, "worktrees"), env.cwd) ? undefined : localSnapshots2(env, { store, git: options?.git });
+    },
+    worktrees: localWorktrees2({ home, git: options?.git }),
+    async destroy() {
+      throw new SdkError("unavailable", "A local folder is never torn down.");
+    }
+  };
+}
+function realpathOrSelf(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+function nests(outer, inner) {
+  const path = relative(outer, inner);
+  return path === "" || path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
+}
+function readTargetPath(target) {
+  return "path" in target && typeof target.path === "string" ? target.path : null;
+}
+async function readableDirectory(path) {
+  const stats = await stat(path).catch(() => null);
+  return stats !== null && stats.isDirectory() && await access(path, constants.R_OK | constants.X_OK).then(() => true, () => false);
+}
+async function projectSources(root) {
+  const names = async (directory) => (await readdir(join(root, directory)).catch(() => [])).sort((left, right) => left < right ? -1 : left > right ? 1 : 0);
+  const fileExists = async (path) => (await stat(join(root, path)).catch(() => null))?.isFile() === true;
+  const plugins = (await Promise.all((await names(".nyte/plugins")).map(async (name) => {
+    const path = `.nyte/plugins/${name}`;
+    if (PLUGIN_FILE.test(name) && await fileExists(path))
+      return [path];
+    for (const index of ["index.ts", "index.mts", "index.js", "index.mjs"])
+      if (await fileExists(`${path}/${index}`))
+        return [`${path}/${index}`];
+    return [];
+  }))).flat();
+  const skills = (await Promise.all([".nyte/skills", ".agents/skills"].map(async (directory) => (await Promise.all((await names(directory)).map(async (name) => {
+    const path = `${directory}/${name}/SKILL.md`;
+    return await fileExists(path) ? [path] : [];
+  }))).flat()))).flat();
+  const prompts = (await names(".nyte/prompts")).filter((name) => name.endsWith(".md")).map((name) => `.nyte/prompts/${name}`);
+  const present = await Promise.all(ROOT_SOURCES.map(async (path) => await fileExists(path) ? [path] : []));
+  return [...plugins, ...skills, ...prompts, ...present.flat()];
+}
+
+export { localProvider2 };

package/dist/chunks/canvas-preview-ec2mt7es.js

@@ -0,0 +1,108 @@
+import {
+  exifOrientation2
+} from "./canvas-preview-befkjea2.js";
+
+// src/images/photon.ts
+import {
+  PhotonImage,
+  SamplingFilter,
+  fliph,
+  flipv,
+  initSync,
+  resize
+} from "@silvia-odwyer/photon/photon_rs.js";
+var INLINE_IMAGE_TYPES = new Set([
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+]);
+var JPEG_QUALITIES = [80, 70, 55, 40];
+function photonImages2(wasm) {
+  initSync({ module: wasm });
+  return {
+    prepare: (bytes, mimeType, limits) => Promise.resolve(prepare(bytes, mimeType, limits))
+  };
+}
+function prepare(bytes, mimeType, limits) {
+  const orientation = exifOrientation2(bytes);
+  let image;
+  try {
+    image = PhotonImage.new_from_byteslice(bytes);
+    if (INLINE_IMAGE_TYPES.has(mimeType) && orientation === 1 && image.get_width() <= limits.maxWidth && image.get_height() <= limits.maxHeight && base64Length(bytes.byteLength) <= limits.maxBase64Bytes)
+      return { data: bytes.toBase64(), mimeType };
+    if (orientation >= 5) {
+      const upright = transposed(image, orientation);
+      image.free();
+      image = undefined;
+      image = new PhotonImage(upright.pixels, upright.width, upright.height);
+    } else if (orientation !== 1) {
+      if (orientation !== 4)
+        fliph(image);
+      if (orientation !== 2)
+        flipv(image);
+    }
+    const width = image.get_width();
+    const height = image.get_height();
+    const scale = Math.min(1, limits.maxWidth / width, limits.maxHeight / height);
+    let target = {
+      width: Math.max(1, Math.round(width * scale)),
+      height: Math.max(1, Math.round(height * scale))
+    };
+    for (;; ) {
+      const encoded = encodeWithin(image, target, limits.maxBase64Bytes, mimeType === "image/jpeg");
+      if (encoded !== undefined)
+        return target.width === width && target.height === height ? encoded : { ...encoded, resized: { from: { width, height }, to: target } };
+      if (target.width === 1 && target.height === 1)
+        return;
+      target = {
+        width: Math.max(1, Math.floor(target.width * 0.75)),
+        height: Math.max(1, Math.floor(target.height * 0.75))
+      };
+    }
+  } catch {
+    return;
+  } finally {
+    image?.free();
+  }
+}
+function encodeWithin(image, size, maxBase64Bytes, jpegFirst) {
+  const same = size.width === image.get_width() && size.height === image.get_height();
+  const scaled = same ? image : resize(image, size.width, size.height, SamplingFilter.Lanczos3);
+  try {
+    const png = { mimeType: "image/png", encode: () => scaled.get_bytes() };
+    const jpegs = JPEG_QUALITIES.map((quality) => ({
+      mimeType: "image/jpeg",
+      encode: () => scaled.get_bytes_jpeg(quality)
+    }));
+    for (const candidate of jpegFirst ? [...jpegs, png] : [png, ...jpegs]) {
+      const encoded = candidate.encode();
+      if (base64Length(encoded.byteLength) <= maxBase64Bytes)
+        return { data: encoded.toBase64(), mimeType: candidate.mimeType };
+    }
+    return;
+  } finally {
+    if (!same)
+      scaled.free();
+  }
+}
+function transposed(image, orientation) {
+  const width = image.get_width();
+  const height = image.get_height();
+  const source = image.get_raw_pixels();
+  const pixels = new Uint8Array(source.length);
+  for (let y = 0;y < height; y++) {
+    for (let x = 0;x < width; x++) {
+      const outX = orientation === 5 || orientation === 8 ? y : height - 1 - y;
+      const outY = orientation === 5 || orientation === 6 ? x : width - 1 - x;
+      const from = (y * width + x) * 4;
+      pixels.set(source.subarray(from, from + 4), (outY * height + outX) * 4);
+    }
+  }
+  return { pixels, width: height, height: width };
+}
+function base64Length(byteLength) {
+  return Math.ceil(byteLength / 3) * 4;
+}
+
+export { photonImages2 };

package/dist/chunks/canvas-preview-fxa0rfb0.js

@@ -0,0 +1,61 @@
+import {
+  readNyteUsage2
+} from "./canvas-preview-11nadadc.js";
+import {
+  loadUsageScanCaches2,
+  saveUsageScanCaches2,
+  readLocalUsage2
+} from "./canvas-preview-k1yg4fgp.js";
+
+// src/usage-service.ts
+import { join } from "node:path";
+import { FileModelsStore, nyteProviders } from "@nyte-ai/ai";
+import { createModels } from "@nyte-ai/ai/models";
+import { serial } from "@nyte-ai/schema/serial";
+function catalogForUsage2(models) {
+  return [...models.getModels("anthropic"), ...models.getModels("openai-codex")];
+}
+
+class UsageScanner2 {
+  home;
+  cachePath;
+  caches;
+  models;
+  scans = serial();
+  constructor(home) {
+    this.home = home;
+    this.cachePath = join(home, ".nyte", "usage-scan-cache.json");
+    this.models = createModels({
+      modelsStore: new FileModelsStore(join(home, ".nyte", "models-store.json"))
+    });
+    for (const provider of nyteProviders())
+      this.models.setProvider(provider);
+  }
+  scan(request) {
+    return this.scans.run(async () => {
+      if (request.catalog === undefined)
+        await this.models.refresh({
+          providers: ["anthropic", "openai-codex"],
+          allowNetwork: false
+        });
+      const catalog = request.catalog;
+      const models = catalog === undefined ? this.models : {
+        getModels: (provider) => catalog.filter((model) => provider === undefined || model.provider === provider)
+      };
+      const caches = this.caches ??= await loadUsageScanCaches2(this.cachePath);
+      const local = await readLocalUsage2({ models, window: request.window, caches });
+      const report = readNyteUsage2(this.home, request.window);
+      this.scans.run(() => saveUsageScanCaches2(this.cachePath, caches));
+      return {
+        ...report,
+        ...local,
+        nyteError: report.sources.find((source) => source.status === "failed")?.message ?? null
+      };
+    });
+  }
+  close() {
+    return this.scans.settled();
+  }
+}
+
+export { catalogForUsage2, UsageScanner2 };