@visual-z/xeno 0.8.3 → 0.9.0

package/src/store/trust.ts

@@ -1,82 +0,0 @@
-/**
- * Project trust: whether to load `.xeno/settings.json` for a directory.
- *
- * Trust does not affect tool execution. Path tools stay confined to the
- * workspace root regardless, and bash still goes through the permission
- * gate. This file only records which directories may contribute project
- * settings. AGENTS.md is loaded whether the project is trusted or not.
- */
-
-import { dirname, join, resolve } from "node:path";
-import { configDir, readJsonFile, writeJsonFile } from "./config.ts";
-import { parseSettings } from "../core/settings.ts";
-
-export type TrustFile = { readonly [dir: string]: boolean };
-
-export function trustPath(): string {
-  return join(configDir(), "trust.json");
-}
-
-export function projectSettingsPath(workspace: string): string {
-  return join(workspace, ".xeno", "settings.json");
-}
-
-/**
- * Closest saved decision on `dir` or a parent. Undefined if none.
- *
- * A parent applies to its children so trusting a repo root covers the
- * packages underneath; a closer entry wins so a single untrusted nested
- * project can opt out.
- */
-export function lookupTrust(decisions: TrustFile, dir: string): boolean | undefined {
-  let current = resolve(dir);
-  for (;;) {
-    const value = decisions[current];
-    if (value !== undefined) return value;
-    const parent = dirname(current);
-    if (parent === current) return undefined;
-    current = parent;
-  }
-}
-
-export async function projectTrust(workspace: string, temporary?: boolean): Promise<{ trusted: boolean; saved?: { path: string; trusted: boolean }; policy: "ask" | "always" | "never" }> {
-  const [saved, settings] = await Promise.all([readTrust(), readJsonFile<unknown>(join(configDir(), "settings.json"))]);
-  const policy = parseSettings(settings.value).settings.defaultProjectTrust ?? "ask";
-  let path = resolve(workspace);
-  for (;;) {
-    const decision = saved.value[path];
-    if (decision !== undefined) return { trusted: temporary ?? decision, saved: { path, trusted: decision }, policy };
-    const parent = dirname(path); if (parent === path) break; path = parent;
-  }
-  return { trusted: temporary ?? policy === "always", policy };
-}
-
-export async function readTrust(): Promise<{ value: TrustFile; error: string | null }> {
-  const { value, error } = await readJsonFile<unknown>(trustPath());
-  if (error) return { value: {}, error };
-  if (value === null) return { value: {}, error: null };
-  if (!isTrustFile(value)) {
-    return { value: {}, error: `${trustPath()} is not a directory-to-boolean map` };
-  }
-  return { value, error: null };
-}
-
-export async function writeTrust(decisions: TrustFile): Promise<void> {
-  await writeJsonFile(trustPath(), decisions, false);
-}
-
-export async function saveTrust(dir: string, trusted: boolean): Promise<void> {
-  const { value } = await readTrust();
-  const next: { [dir: string]: boolean } = { ...value };
-  next[resolve(dir)] = trusted;
-  await writeTrust(next);
-}
-
-function isTrustFile(value: unknown): value is TrustFile {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
-  const rec = value as { readonly [k: string]: unknown };
-  for (const key of Object.keys(rec)) {
-    if (typeof rec[key] !== "boolean") return false;
-  }
-  return true;
-}

package/src/store/update-cache.ts

@@ -1,36 +0,0 @@
-/**
- * The last update check, kept in the config directory (docs/tasks/feat-update-check.md).
- *
- * `{ checkedAt, latest? }` and nothing else: no identifiers, no history. A
- * missing or unreadable file means "never checked"; it is rewritten whole.
- */
-import { readFile } from "node:fs/promises";
-import { existsSync, realpathSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { UpdateCache } from "../core/update-check.ts";
-import { atomicWrite } from "./atomic.ts";
-import { configDir } from "./config.ts";
-
-export function updateCachePath(): string { return join(configDir(), "update-check.json"); }
-
-export async function readUpdateCache(): Promise<UpdateCache | null> {
-  try {
-    const value = JSON.parse(await readFile(updateCachePath(), "utf8")) as Record<string, unknown>;
-    if (typeof value["checkedAt"] !== "number") return null;
-    return { checkedAt: value["checkedAt"], ...(typeof value["latest"] === "string" ? { latest: value["latest"] } : {}) };
-  } catch { return null; }
-}
-
-export async function writeUpdateCache(cache: UpdateCache): Promise<void> {
-  try { await atomicWrite(updateCachePath(), JSON.stringify(cache) + "\n"); } catch { /* a read-only config dir only means checking again next time */ }
-}
-
-/** This copy's package root, resolved through symlinks, and whether it is a git checkout. */
-export function packageLocation(): { root: string; git: boolean } {
-  // src/store/update-cache.ts → the package root two directories up.
-  const here = dirname(fileURLToPath(import.meta.url));
-  let root = join(here, "..", "..");
-  try { root = realpathSync(root); } catch { /* keep the unresolved path */ }
-  return { root, git: existsSync(join(root, ".git")) };
-}

package/src/store/user-settings.ts

@@ -1,30 +0,0 @@
-/** One read/modify/replace owner prevents automatic selections from racing other settings (Q.25). */
-import { readFile } from "node:fs/promises";
-import { settingsPath } from "./config.ts";
-import { atomicWrite } from "./atomic.ts";
-import { serialized } from "./serial.ts";
-
-async function readSettings(path: string): Promise<Record<string, unknown>> {
-  let text: string;
-  try { text = await readFile(path, "utf8"); }
-  catch (error) {
-    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") return {};
-    throw error;
-  }
-  let value: unknown;
-  try { value = JSON.parse(text); }
-  catch { throw new Error(`${path} is not valid JSON; repair it before saving settings`); }
-  if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${path} must contain a settings object`);
-  return value as Record<string, unknown>;
-}
-
-export function editUserSettings(edit: (previous: Record<string, unknown>) => Record<string, unknown> | null): Promise<void> {
-  // Capture the destination before any await, including when another profile changes configDir().
-  const path = settingsPath();
-  // Packages and resource overrides already coordinate this file through serialized().
-  return serialized(path, async () => {
-    const next = edit(await readSettings(path));
-    if (next === null) return;
-    await atomicWrite(path, `${JSON.stringify(next, null, 2)}\n`);
-  });
-}

package/src/store/workspace-clone.ts

@@ -1,42 +0,0 @@
-/**
- * A disposable copy of a workspace, for running a check somewhere it cannot
- * touch the real files (feat-counter-check).
- *
- * Copy-on-write where the filesystem offers it -- APFS clonefile through
- * `cp -c`, reflinks through `cp --reflink=auto` -- so a workspace with large
- * dependency trees costs metadata, not bytes. Where it does not, cp falls back
- * to a real copy, bounded by the deadline below.
- */
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-/**
- * Assumed, not measured: a clone is metadata-only on APFS and reflink
- * filesystems; a full copy that takes longer than this is better reported as
- * unavailable than waited on.
- */
-export const CLONE_TIMEOUT_MS = 60_000;
-
-export type WorkspaceClone = { ok: true; path: string; dispose: () => Promise<void> } | { ok: false; reason: string };
-
-export async function cloneWorkspace(root: string, signal?: AbortSignal): Promise<WorkspaceClone> {
-  const parent = await mkdtemp(join(tmpdir(), "xeno-counter-check-")), path = join(parent, "workspace");
-  const dispose = () => rm(parent, { recursive: true, force: true });
-  const attempts = process.platform === "darwin" ? [["cp", "-cR", root, path], ["cp", "-R", root, path]] : [["cp", "-a", "--reflink=auto", root, path]];
-  let reason = "the workspace could not be copied";
-  for (const argv of attempts) {
-    if (signal?.aborted) { await dispose(); return { ok: false, reason: "cancelled" }; }
-    await rm(path, { recursive: true, force: true });
-    const child = Bun.spawn(argv, { stdout: "ignore", stderr: "pipe" });
-    const timer = setTimeout(() => child.kill(), CLONE_TIMEOUT_MS);
-    const abort = () => child.kill();
-    signal?.addEventListener("abort", abort, { once: true });
-    const [exit, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
-    clearTimeout(timer); signal?.removeEventListener("abort", abort);
-    if (exit === 0) return { ok: true, path, dispose };
-    reason = child.signalCode ? `copying the workspace exceeded ${CLONE_TIMEOUT_MS / 1000}s` : `the workspace could not be copied: ${stderr.trim().split("\n").at(-1) ?? `exit ${exit}`}`;
-  }
-  await dispose();
-  return { ok: false, reason };
-}

package/src/store/workspace-observation.ts

@@ -1,113 +0,0 @@
-/** P.3: explicit source inventory for verification and optional Git checkpoints. */
-import { readdir, lstat } from "node:fs/promises";
-import { join, relative, resolve } from "node:path";
-import { blobAddress, digestFile } from "./blobs.ts";
-
-// Conservative resource budgets, not measured performance targets. Exceeding them is unknown, never an empty workspace.
-const MAX_FILES = 20_000;
-const MAX_BYTES = 256 * 1024 * 1024;
-export const MAX_UNTRACKED_BYTES = 2 * 1024 * 1024;
-export const SOURCE_IGNORE = [".git", ".xeno", "node_modules", "target", ".venv", "venv", "__pycache__", ".pytest_cache", ".mypy_cache", ".ruff_cache", ".tox", ".gradle", ".next", ".turbo", ".cache"];
-const ignored = (path: string) => path.split("/").some(part => SOURCE_IGNORE.includes(part));
-
-/** Bounded subprocess; private-repository callers override only Git's storage, never the user's index. */
-export async function gitBytes(root: string, args: readonly string[], input?: Uint8Array, signal?: AbortSignal,
-  environment: Record<string, string> = {}): Promise<Uint8Array> {
-  if (signal?.aborted) throw new Error("Git observation cancelled");
-  const env: Record<string, string | undefined> = { ...process.env, GIT_OPTIONAL_LOCKS: "0", ...environment };
-  for (const key of ["GIT_INDEX_FILE", "GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_OBJECT_DIRECTORY", "GIT_ALTERNATE_OBJECT_DIRECTORIES"]) {
-    if (!(key in environment)) delete env[key];
-  }
-  const child = Bun.spawn(["git", "--no-optional-locks", ...args], { cwd: root, env, stdin: input ?? "ignore", stdout: "pipe", stderr: "pipe" });
-  const abort = () => child.kill();
-  const timer = setTimeout(abort, 10_000);
-  signal?.addEventListener("abort", abort, { once: true });
-  const read = async (stream: ReadableStream<Uint8Array>) => {
-    const reader = stream.getReader(), chunks: Uint8Array[] = [];
-    let bytes = 0;
-    for (;;) {
-      const item = await reader.read();
-      if (item.done) break;
-      bytes += item.value.length;
-      if (bytes > MAX_BYTES) { child.kill(); throw new Error("Git observation exceeds resource budget"); }
-      chunks.push(item.value);
-    }
-    return Buffer.concat(chunks);
-  };
-  try {
-    const [stdout, , code] = await Promise.all([read(child.stdout), read(child.stderr), child.exited]);
-    if (code !== 0 || signal?.aborted) throw new Error("Git observation unavailable or cancelled");
-    return stdout;
-  } finally { clearTimeout(timer); signal?.removeEventListener("abort", abort); }
-}
-const text = (bytes: Uint8Array) => new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-
-export async function sourceInventory(root: string, signal?: AbortSignal, requireGit = false, ownedPaths: readonly string[] = []): Promise<{ paths: string[]; git: boolean }> {
-  const owned = ownedPaths.map(path => relative(resolve(root), resolve(path))).filter(path => path && !path.startsWith("../"));
-  const excluded = (path: string) => ignored(path) || owned.some(directory => path === directory || path.startsWith(directory + "/"));
-  let git = false;
-  try { await gitBytes(root, ["rev-parse", "--show-toplevel"], undefined, signal); git = true; }
-  catch { if (requireGit || signal?.aborted) throw new Error("Git checkpoints require a Git working directory"); }
-  let candidates: { path: string; tracked: boolean }[] = [];
-  if (git) {
-    const tracked = text(await gitBytes(root, ["ls-files", "-z", "--cached"], undefined, signal)).split("\0").filter(Boolean);
-    const untracked = text(await gitBytes(root, ["ls-files", "-z", "--others", "--exclude-standard"], undefined, signal)).split("\0").filter(Boolean);
-    candidates = [...new Set(tracked)].map(path => ({ path, tracked: true }));
-    const known = new Set(tracked);
-    candidates.push(...untracked.filter(path => !known.has(path)).map(path => ({ path, tracked: false })));
-  } else {
-    let entries = 0;
-    const walk = async (directory: string, prefix: string): Promise<void> => {
-      if (signal?.aborted) throw new Error("workspace observation cancelled");
-      for (const entry of await readdir(directory, { withFileTypes: true })) {
-        if (++entries > MAX_FILES) throw new Error("source inventory exceeds file budget");
-        const path = prefix + entry.name;
-        if (excluded(path)) continue;
-        if (entry.isDirectory()) await walk(join(directory, entry.name), path + "/");
-        else if (entry.isFile()) candidates.push({ path, tracked: true });
-      }
-    };
-    await walk(root, "");
-  }
-  candidates = candidates.filter(candidate => !excluded(candidate.path));
-  if (candidates.length > MAX_FILES) throw new Error("source inventory exceeds file budget");
-  const paths: string[] = [];
-  let bytes = 0;
-  for (const candidate of candidates.sort((a, b) => a.path < b.path ? -1 : 1)) {
-    if (signal?.aborted) throw new Error("workspace observation cancelled");
-    const path = candidate.path;
-    if (excluded(path)) continue;
-    const parts = path.split("/");
-    if (parts.includes("..") || path.startsWith("/")) throw new Error("unsafe source inventory");
-    let safe = true;
-    for (let i = 1; i <= parts.length; i++) {
-      try {
-        const info = await lstat(join(root, ...parts.slice(0, i)));
-        if (info.isSymbolicLink() || i === parts.length && !info.isFile()) { safe = false; break; }
-        if (i === parts.length) {
-          if (!candidate.tracked && info.size > MAX_UNTRACKED_BYTES) { safe = false; break; }
-          bytes += info.size;
-        }
-      } catch (error) {
-        if ((error as { code?: string }).code !== "ENOENT") throw error;
-        safe = false; break;
-      }
-    }
-    if (bytes > MAX_BYTES) throw new Error("source inventory exceeds byte budget");
-    if (safe) paths.push(path);
-  }
-  return { paths, git };
-}
-
-export type WorkspaceObservation = { ok: true; fingerprint: string } | { ok: false; reason: string };
-export async function observeWorkspace(root: string, signal?: AbortSignal, ownedPaths: readonly string[] = []): Promise<WorkspaceObservation> {
-  try {
-    const inventory = await sourceInventory(root, signal, false, ownedPaths);
-    const entries: [string, string, number][] = [];
-    for (const path of inventory.paths) {
-      if (signal?.aborted) throw new Error("workspace observation cancelled");
-      entries.push([path, await digestFile(join(root, path)), (await lstat(join(root, path))).mode & 0o777]);
-    }
-    return { ok: true, fingerprint: blobAddress(JSON.stringify(["source-v1", inventory.git ? "git" : "files", entries])) };
-  } catch (error) { return { ok: false, reason: error instanceof Error ? error.message : "workspace observation unavailable" }; }
-}

package/src/store/workspace.ts

@@ -1,115 +0,0 @@
-/**
- * A bounded content scan of a workspace: relative path -> digest, and one
- * version digest over the whole set.
- *
- * Session file history no longer comes from per-turn scans. P.3 replaced them
- * with journaled checkpoints and source fingerprints (workspace-observation.ts,
- * WorkspaceLifecycle), and S.3 removed the compatibility mode that still
- * scanned. What remains is the scanner itself and the default ignore list the
- * search and file index share.
- */
-
-import { readdir, stat } from "node:fs/promises";
-import type { Dirent } from "node:fs";
-import { join, relative, sep } from "node:path";
-import { blobAddress, digestFile } from "./blobs.ts";
-
-export interface ScanLimits {
-  maxFiles: number;
-  maxFileBytes: number;
-  maxTotalBytes: number;
-}
-
-/**
- * Hashing and blob capture stream regular files, so file size has no default
- * product cap. Callers may impose explicit resource limits. Exceeding one,
- * losing a directory, or meeting an unsupported file type fails the whole scan;
- * a partial listing could make a restore delete files it never recorded.
- */
-export const DEFAULT_SCAN_LIMITS: ScanLimits = {
-  maxFiles: Infinity,
-  maxFileBytes: Infinity,
-  maxTotalBytes: Infinity,
-};
-
-/**
- * Directories never scanned, snapshotted or restored.
- *
- * One constant rather than a default repeated at each call site: the snapshot
- * and the restore have to agree exactly. A path the snapshot skipped is absent
- * from every target file set, and applyRestore deletes whatever is not in the
- * target -- so a restore using a shorter list than the snapshot would delete
- * the log, the git directory, or the user's dependencies.
- */
-export const DEFAULT_IGNORE: readonly string[] = [".xeno", ".git", "node_modules"];
-
-/** Relative path -> content digest. Same address space as the blob store. */
-export type FileSet = Record<string, string>;
-
-export function workspaceVersion(files: FileSet): string {
-  return blobAddress(JSON.stringify(Object.entries(files).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)));
-}
-
-export type ScanResult =
-  | { ok: true; files: FileSet }
-  | { ok: false; error: string };
-
-function isIgnored(rel: string, ignore: readonly string[]): boolean {
-  const parts = rel.split(sep);
-  return ignore.some((i) => parts.includes(i));
-}
-
-export async function scanWorkspace(
-  root: string,
-  ignore: readonly string[],
-  limits: ScanLimits = DEFAULT_SCAN_LIMITS,
-): Promise<ScanResult> {
-  const files: FileSet = {};
-  let count = 0;
-  let total = 0;
-
-  async function walk(dir: string): Promise<string | null> {
-    let entries: Dirent[];
-    try {
-      entries = await readdir(dir, { withFileTypes: true });
-    } catch (err) {
-      return `cannot scan ${dir}: ${String(err)}`;
-    }
-    for (const entry of entries.sort((a, b) => (a.name < b.name ? -1 : 1))) {
-      const abs = join(dir, entry.name);
-      const rel = relative(root, abs);
-      if (isIgnored(rel, ignore)) continue;
-      if (entry.isDirectory()) {
-        const err = await walk(abs);
-        if (err) return err;
-        continue;
-      }
-      // A symlink is not workspace content: it can point anywhere, and search
-      // and the file index already refuse to follow one. It is left out of the
-      // file set, so snapshots never read through it and a restore never
-      // deletes or replaces it (/back does not restore symlinks). Anything
-      // else that is not a regular file still fails the whole scan.
-      if (entry.isSymbolicLink()) continue;
-      if (!entry.isFile()) return `cannot snapshot unsupported file type: ${rel}`;
-
-      const info = await stat(abs);
-      if (info.size > limits.maxFileBytes) {
-        return `${rel} is ${info.size} bytes, over maxFileBytes (${limits.maxFileBytes})`;
-      }
-      if (++count > limits.maxFiles) {
-        return `workspace has more than maxFiles (${limits.maxFiles}) files`;
-      }
-      total += info.size;
-      if (total > limits.maxTotalBytes) {
-        return `workspace exceeds maxTotalBytes (${limits.maxTotalBytes})`;
-      }
-      files[rel.split(sep).join("/")] = await digestFile(abs);
-    }
-    return null;
-  }
-
-  try {
-    const error = await walk(root);
-    return error ? { ok: false, error } : { ok: true, files };
-  } catch (error) { return { ok: false, error: `incomplete workspace scan: ${String(error)}` }; }
-}