@nyte-ai/host 0.0.0-stage → 0.0.19

package/src/local/patch.ts

@@ -0,0 +1,334 @@
+import { lineDiff } from "@nyte-ai/core";
+import { writePatch } from "@nyte-ai/schema";
+import type { FileStatus, LineStat, PatchEntry } from "@nyte-ai/schema";
+import { sha256 } from "../hash.ts";
+import type { Ran } from "./command.ts";
+
+/** One file's section of `git diff` output: its paths, whether git called it binary, whether it has a hunk, its line counts and its text. */
+type DiffSection = {
+  readonly oldPath: string | null;
+  readonly newPath: string | null;
+  readonly binary: boolean;
+  readonly hunked: boolean;
+  readonly added: number;
+  readonly removed: number;
+  readonly text: string;
+};
+
+export const PATCH_LIMIT = 1024 * 1024;
+
+const ESCAPES = new Map([
+  ["a", 7],
+  ["b", 8],
+  ["f", 12],
+  ["n", 10],
+  ["r", 13],
+  ["t", 9],
+  ["v", 11],
+  ['"', 34],
+  ["\\", 92],
+]);
+
+export type Changed = {
+  readonly path: string;
+  readonly status: FileStatus;
+  readonly from?: string;
+};
+
+function splitDiff(output: string): readonly DiffSection[] {
+  const lines = output.split("\n");
+
+  if (lines.at(-1) === "") lines.pop();
+  const sections: DiffSection[] = [];
+  let index = 0;
+
+  while (index < lines.length) {
+    const header = lines[index] ?? "";
+
+    if (!header.startsWith("diff --git ")) {
+      index += 1;
+      continue;
+    }
+
+    const start = index;
+    const named = headerPaths(header.slice("diff --git ".length));
+    let oldPath: string | null = named?.old ?? null;
+    let newPath: string | null = named?.new ?? null;
+    let binary = false;
+    let hunked = false;
+    let added = 0;
+    let removed = 0;
+    index += 1;
+
+    while (index < lines.length && !(lines[index] ?? "").startsWith("diff --git ")) {
+      const line = lines[index] ?? "";
+      index += 1;
+
+      if (line.startsWith("@@ ")) hunked = true;
+      else if (hunked && line.startsWith("+")) added += 1;
+      else if (hunked && line.startsWith("-")) removed += 1;
+      else if (hunked) continue;
+      else if (line.startsWith("--- ")) oldPath = sidePath(line.slice(4), "a/");
+      else if (line.startsWith("+++ ")) newPath = sidePath(line.slice(4), "b/");
+      else if (/^(?:rename|copy) from /u.test(line))
+        oldPath = unquote(line.replace(/^(?:rename|copy) from /u, ""));
+      else if (/^(?:rename|copy) to /u.test(line))
+        newPath = unquote(line.replace(/^(?:rename|copy) to /u, ""));
+      else if (line.startsWith("new file mode ")) oldPath = null;
+      else if (line.startsWith("deleted file mode ")) newPath = null;
+      else if (line.startsWith("Binary files ") || line === "GIT binary patch") binary = true;
+    }
+
+    sections.push({
+      oldPath,
+      newPath,
+      binary,
+      hunked,
+      added,
+      removed,
+      text: `${lines.slice(start, index).join("\n")}\n`,
+    });
+  }
+
+  return sections;
+}
+
+function sectionEntry(path: string, status: FileStatus, section: DiffSection): PatchEntry {
+  const digest = sha256(section.text);
+
+  if (section.binary) return { path, status, digest, kind: "binary" };
+
+  if (section.text.length > PATCH_LIMIT)
+    return { path, status, digest, kind: "too-large", limit: PATCH_LIMIT };
+
+  if (!section.hunked) return { path, status, digest, kind: "empty" };
+
+  return {
+    path,
+    status,
+    digest,
+    kind: "text",
+    added: section.added,
+    removed: section.removed,
+    patch: section.text,
+  };
+}
+
+/** The entry for two texts diffed on the host: a text entry's digest is its patch's, so it moves with the whitespace mode; an empty one digests both sides and the mode. */
+export function textEntry(
+  path: string,
+  status: FileStatus,
+  before: string | null,
+  after: string | null,
+  options?: { readonly ignoreWhitespace?: boolean },
+): PatchEntry {
+  const { hunks, added, removed } = lineDiff(before ?? "", after ?? "", options);
+
+  if (hunks.length === 0) {
+    const mode = options?.ignoreWhitespace === true ? "ignore-whitespace" : "";
+
+    return {
+      path,
+      status,
+      digest: sha256(`${mode}\u0000${before ?? ""}\u0000${after ?? ""}`),
+      kind: "empty",
+    };
+  }
+
+  const patch = writePatch(path, status, hunks);
+
+  return { path, status, digest: sha256(patch), kind: "text", added, removed, patch };
+}
+
+export async function readPatches(
+  files: readonly Changed[],
+  read: (files: readonly Changed[], limit: number) => Promise<Ran>,
+  emptyDigest: (file: Changed) => string,
+): Promise<readonly PatchEntry[]> {
+  const settle = (batch: readonly Changed[], ran: Ran): readonly PatchEntry[] => {
+    const sections = splitDiff(ran.stdout.toString("utf8"));
+
+    return batch.map((file) => {
+      const section = sections.find(
+        (candidate) => (candidate.newPath ?? candidate.oldPath) === file.path,
+      );
+
+      return section === undefined
+        ? { path: file.path, status: file.status, digest: emptyDigest(file), kind: "empty" }
+        : sectionEntry(file.path, file.status, section);
+    });
+  };
+
+  const together = await read(files, PATCH_LIMIT * files.length + 4096).catch(() => null);
+
+  if (together !== null && !together.truncated && (together.code === 0 || together.code === 1))
+    return settle(files, together);
+  const entries: PatchEntry[] = [];
+
+  for (const file of files) {
+    const failed = (reason: string): PatchEntry => ({
+      path: file.path,
+      status: file.status,
+      digest: "",
+      kind: "failed",
+      reason,
+    });
+
+    const alone = await read([file], PATCH_LIMIT + 1).catch((error: unknown) =>
+      error instanceof Error ? error.message : String(error),
+    );
+
+    if (typeof alone === "string") entries.push(failed(alone));
+    else if (alone.truncated)
+      entries.push({
+        path: file.path,
+        status: file.status,
+        digest: sha256(alone.stdout),
+        kind: "too-large",
+        limit: PATCH_LIMIT,
+      });
+    else if (alone.code !== 0 && alone.code !== 1)
+      entries.push(failed(alone.stderr.trim() || "git diff failed"));
+    else entries.push(...settle([file], alone));
+  }
+
+  return entries;
+}
+
+export function lineStat(before: string, after: string): LineStat {
+  const { added, removed } = lineDiff(before, after);
+
+  return { kind: "text", added, removed };
+}
+
+function headerPaths(rest: string): { readonly old: string; readonly new: string } | null {
+  if (rest.startsWith('"')) {
+    const end = quotedEnd(rest);
+    const old = unquote(rest.slice(0, end + 1));
+    const next = unquote(rest.slice(end + 2));
+
+    return { old: old.replace(/^a\//, ""), new: next.replace(/^b\//, "") };
+  }
+
+  const half = (rest.length - 5) / 2;
+
+  if (Number.isInteger(half) && rest.startsWith("a/") && rest.slice(half + 2, half + 5) === " b/") {
+    const path = rest.slice(2, half + 2);
+
+    if (rest.slice(half + 5) === path) return { old: path, new: path };
+  }
+
+  const split = /^.{2}(.*?) b\/(.*)$/su.exec(rest);
+
+  return split === null ? null : { old: split[1] ?? "", new: unquote(split[2] ?? "") };
+}
+
+function quotedEnd(text: string): number {
+  for (let index = 1; index < text.length; index += 1) {
+    if (text[index] === "\\") index += 1;
+    else if (text[index] === '"') return index;
+  }
+
+  return text.length - 1;
+}
+
+function sidePath(text: string, prefix: string): string | null {
+  const name = unquote(text.replace(/\t$/, ""));
+
+  if (name === "/dev/null") return null;
+
+  return name.startsWith(prefix) ? name.slice(prefix.length) : name;
+}
+
+function unquote(text: string): string {
+  if (!text.startsWith('"') || !text.endsWith('"') || text.length < 2) return text;
+  const bytes: number[] = [];
+  const encoder = new TextEncoder();
+
+  for (let index = 1; index < text.length - 1; index += 1) {
+    const char = text[index] ?? "";
+
+    if (char !== "\\") {
+      bytes.push(...encoder.encode(char));
+      continue;
+    }
+
+    const next = text[index + 1] ?? "";
+    const octal = /^[0-7]{3}$/.exec(text.slice(index + 1, index + 4));
+
+    if (octal !== null) {
+      bytes.push(Number.parseInt(octal[0], 8));
+      index += 3;
+      continue;
+    }
+
+    bytes.push(ESCAPES.get(next) ?? next.charCodeAt(0));
+    index += 1;
+  }
+
+  return new TextDecoder().decode(new Uint8Array(bytes));
+}
+
+export function parseNumstat(output: string): ReadonlyMap<string, LineStat> {
+  const tokens = output.split("\u0000");
+  const stats = new Map<string, LineStat>();
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index] ?? "";
+
+    if (token === "") continue;
+    const [added = "", removed = "", path = ""] = token.split("\t");
+    let name = path;
+
+    if (path === "") {
+      name = tokens[index + 2] ?? "";
+      index += 2;
+    }
+
+    stats.set(
+      name,
+      added === "-" || removed === "-"
+        ? { kind: "binary" }
+        : { kind: "text", added: Number(added) || 0, removed: Number(removed) || 0 },
+    );
+  }
+
+  return stats;
+}
+
+export function parseNameStatus(output: string): readonly Changed[] {
+  const tokens = output.split("\u0000");
+  const changed: Changed[] = [];
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const code = tokens[index] ?? "";
+
+    if (code === "") continue;
+    const letter = code[0];
+
+    if (letter === "R" || letter === "C") {
+      const from = tokens[index + 1] ?? "";
+      const path = tokens[index + 2] ?? "";
+      index += 2;
+      changed.push(letter === "R" ? { path, status: "renamed", from } : { path, status: "added" });
+      continue;
+    }
+
+    const path = tokens[index + 1] ?? "";
+    index += 1;
+
+    changed.push({
+      path,
+      status:
+        letter === "A"
+          ? "added"
+          : letter === "D"
+            ? "deleted"
+            : letter === "U"
+              ? "conflicted"
+              : "modified",
+    });
+  }
+
+  return changed;
+}

package/src/local/provider.ts

@@ -0,0 +1,184 @@
+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";
+import type { WorkspaceTarget } from "@nyte-ai/schema";
+import type { EnvironmentProvider, ExecutionEnv } from "@nyte-ai/core";
+import { sha256 } from "../hash.ts";
+import { localFiles } from "./files.ts";
+import { localGit } from "./git.ts";
+import { localGitHub } from "./github.ts";
+import { folderIdentity } from "./identity.ts";
+import { localExec } from "./jobs.ts";
+import { localSnapshots } from "./snapshots.ts";
+import { localWorktrees } from "./worktrees.ts";
+
+const PLUGIN_FILE = /\.(?:ts|mts|js|mjs)$/;
+
+const ROOT_SOURCES = [".nyte/SYSTEM.md", ".nyte/APPEND_SYSTEM.md", ".nyte/mcp.json"];
+
+/** Returns the local environment provider (`kind: "local"`): a folder on this machine. `inspect` answers a `{ kind: "local", path }` target's `folderIdentity` (§41d), `available` when the path is a readable directory (else `unavailable { unreachable }`; a target without a path `unavailable { unsupported }`, identified by the hash of its locator), and the project sources present under it, relative to it, in this order: the plugin files `.nyte/plugins/<name>.{ts,mts,js,mjs}` and `.nyte/plugins/<name>/index.<ext>`, the skills `.nyte/skills/<name>/SKILL.md` and `.agents/skills/<name>/SKILL.md`, the prompts `.nyte/prompts/<name>.md`, then `.nyte/SYSTEM.md`, `.nyte/APPEND_SYSTEM.md` and `.nyte/mcp.json`: the files project trust gates. Context files such as `AGENTS.md` load without trust and are not listed. `attach` resolves the real path (a target that is not a directory throws `SdkError("unavailable")`) and returns an `ExecutionEnv` with that identity, `cwd` the real path, `files` from `localFiles` (with `ripgrep` and `formatter`), `exec` from `localExec`, and a `close` that ends its file watches and the jobs' readers, leaving running jobs alone. `git` is `localGit` (with `git`), `github` is `localGitHub` (with `gh` and `git`; the login is the machine's, `localGitHubAccount`), `snapshots` is `localSnapshots` storing tree walks under `<home>/.nyte/snapshots` (`home` default `os.homedir()`), and absent for a folder that contains `<home>/.nyte` or lies inside it outside `<home>/.nyte/worktrees` (the home folder itself, its ancestors, Nyte's own state): there a snapshot would walk or stage everything under home, the store and secrets included, to report changes in the store it just wrote; `worktrees` is `localWorktrees` (with `home` and `git`); no `browser` (the desktop wraps one in); `destroy` rejects with `SdkError("unavailable")`: a local folder is never torn down. */
+export function localProvider(options?: {
+  readonly home?: string;
+  readonly git?: string;
+  readonly gh?: string;
+  readonly ripgrep?: string;
+  readonly formatter?: string;
+  /** The login shell a pty job without a command runs, read at each start; null or absent is `$SHELL`. */
+  readonly shell?: () => string | null;
+}): EnvironmentProvider {
+  const home = options?.home ?? homedir();
+  const store = join(home, ".nyte", "snapshots");
+  let state: string | undefined;
+  const github = localGitHub({ gh: options?.gh, git: options?.git });
+
+  return {
+    kind: "local",
+    async inspect(target) {
+      const path = readTargetPath(target);
+
+      if (path === null)
+        return {
+          identity: asId<"environment-identity">(sha256(JSON.stringify(target))),
+          availability: { kind: "unavailable", reason: "unsupported" },
+          projectSources: [],
+        };
+
+      const identity = await folderIdentity(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: ExecutionEnv = {
+        identity: await folderIdentity(real),
+        cwd: real,
+        files: localFiles(real, {
+          ripgrep: options?.ripgrep,
+          formatter: options?.formatter,
+          signal: detached.signal,
+        }),
+        exec: localExec(real, { shell: options?.shell, signal: detached.signal }),
+        close: async () => detached.abort(),
+      };
+
+      return env;
+    },
+    git: (env) => localGit(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
+        : localSnapshots(env, { store, git: options?.git });
+    },
+    worktrees: localWorktrees({ home, git: options?.git }),
+    async destroy() {
+      throw new SdkError("unavailable", "A local folder is never torn down.");
+    },
+  };
+}
+
+function realpathOrSelf(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+}
+
+function nests(outer: string, inner: string): boolean {
+  const path = relative(outer, inner);
+
+  return path === "" || (path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path));
+}
+
+function readTargetPath(target: WorkspaceTarget): string | null {
+  return "path" in target && typeof target.path === "string" ? target.path : null;
+}
+
+async function readableDirectory(path: string): Promise<boolean> {
+  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: string): Promise<readonly string[]> {
+  const names = async (directory: string): Promise<readonly string[]> =>
+    (await readdir(join(root, directory)).catch(() => [])).sort((left, right) =>
+      left < right ? -1 : left > right ? 1 : 0,
+    );
+
+  const fileExists = async (path: string): Promise<boolean> =>
+    (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()];
+}