@cueloop/daemon 0.1.0-alpha.9 → 0.1.0-alpha.91

package/src/vcs-source.test.ts

@@ -0,0 +1,180 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  createTestVcsDirectory,
+  createTestVcsGitRepo,
+  runTestVcsCommand,
+} from "../../../test/helpers/vcs-repo";
+import { VcsSourceManager } from "./vcs-source";
+import { workingTreeDiff } from "./working-tree";
+
+const created: string[] = [];
+
+afterEach(() => {
+  for (const path of created.splice(0)) rmSync(path, { recursive: true, force: true });
+});
+
+describe("VcsSourceManager", () => {
+  test("a directory without a VCS keeps the empty Git workbench behavior", async () => {
+    const plain = createTestVcsDirectory(created);
+    const config = join(createTestVcsDirectory(created), "config.toml");
+    const source = new VcsSourceManager(config);
+
+    expect((await source.select(plain)).adapter.id).toBe("git");
+    expect(await source.capture(plain)).toMatchObject({ patch: "", files: [] });
+  });
+
+  test("Git auto capture preserves the existing patch and curatable files", async () => {
+    const repo = createTestVcsGitRepo(created);
+    const config = join(createTestVcsDirectory(created), "config.toml");
+
+    writeFileSync(join(repo, "a.txt"), "after\n");
+    writeFileSync(join(repo, "new.txt"), "new\n");
+    writeFileSync(join(repo, "space name.txt"), "space\n");
+    const baseline = await workingTreeDiff(repo);
+    const source = new VcsSourceManager(config);
+    const selected = await source.select(repo);
+    const captured = await source.capture(repo);
+
+    expect(selected.adapter.id).toBe("git");
+    expect({ patch: captured.patch, files: captured.files }).toEqual(baseline);
+  });
+
+  test("JJ wins a colocated checkout and captures its native working-copy revision", async () => {
+    const repo = createTestVcsGitRepo(created);
+    const config = join(createTestVcsDirectory(created), "config.toml");
+
+    runTestVcsCommand(repo, "jj", "git", "init", "--colocate", repo);
+    writeFileSync(join(repo, "a.txt"), "after\n");
+    writeFileSync(join(repo, "new.txt"), "new\n");
+    writeFileSync(join(repo, "space name.txt"), "space\n");
+    const source = new VcsSourceManager(config);
+    const selected = await source.select(repo);
+    const captured = await source.capture(repo);
+
+    expect(selected.adapter.id).toBe("jj");
+    expect(captured.patch).toContain("+after");
+    expect(captured.patch).toContain("+new");
+    expect(captured.files).toContainEqual({
+      path: "a.txt",
+      oldContents: "before\n",
+      newContents: "after\n",
+      status: "modified",
+    });
+    expect(captured.files).toContainEqual({
+      path: "new.txt",
+      oldContents: "",
+      newContents: "new\n",
+      status: "added",
+    });
+    expect(captured.files).toContainEqual({
+      path: "space name.txt",
+      oldContents: "",
+      newContents: "space\n",
+      status: "added",
+    });
+    expect(await selected.adapter.listFiles(repo)).toContain("space name.txt");
+    expect(captured.source?.changeId).toBeTruthy();
+    expect(captured.source?.revisionId).toMatch(/^[0-9a-f]{40}$/);
+  });
+
+  test("repo config can select Git in a colocated checkout", async () => {
+    const repo = createTestVcsGitRepo(created);
+    const config = join(createTestVcsDirectory(created), "config.toml");
+
+    runTestVcsCommand(repo, "jj", "git", "init", "--colocate", repo);
+    mkdirSync(join(repo, ".cueloop"));
+    writeFileSync(join(repo, ".cueloop", "config.toml"), '[vcs]\nprovider = "git"\n');
+    const source = new VcsSourceManager(config);
+
+    expect((await source.select(repo)).adapter.id).toBe("git");
+    expect((await source.select(repo, "jj")).adapter.id).toBe("jj");
+  });
+
+  test("a personal extension can register a custom adapter", async () => {
+    const root = createTestVcsDirectory(created);
+    const repo = join(root, "repo");
+    const extension = join(root, "adapter.ts");
+    const config = join(root, "config.toml");
+
+    mkdirSync(repo);
+    writeFileSync(
+      extension,
+      `export default (api) => api.registerVcsAdapter({
+      apiVersion: 1,
+      id: "example.sapling",
+      detect: async (cwd) => cwd,
+      captureWorkingDiff: async () => ({ patch: "custom patch", files: [] }),
+      listChanges: async () => [],
+      listFiles: async () => ["readme.md"],
+    });\n`,
+    );
+    writeFileSync(config, `[vcs]\nprovider = "example.sapling"\nextensions = ["${extension}"]\n`);
+    const source = new VcsSourceManager(config);
+
+    expect((await source.select(repo)).adapter.id).toBe("example.sapling");
+    expect((await source.capture(repo)).patch).toBe("custom patch");
+  });
+
+  test("an installed package loads its daemon adapter entry", async () => {
+    const root = createTestVcsDirectory(created);
+    const repo = join(root, "repo");
+    const installRoot = join(root, "extensions");
+    const packageRoot = join(installRoot, "node_modules", "example-vcs");
+
+    mkdirSync(repo);
+    mkdirSync(packageRoot, { recursive: true });
+    writeFileSync(
+      join(installRoot, "package.json"),
+      JSON.stringify({ dependencies: { "example-vcs": "1.0.0" } }),
+    );
+    writeFileSync(
+      join(packageRoot, "package.json"),
+      JSON.stringify({ cueloop: { daemon: "./daemon.ts" } }),
+    );
+    writeFileSync(
+      join(packageRoot, "daemon.ts"),
+      `export default (api) => api.registerVcsAdapter({
+      apiVersion: 1,
+      id: "example.installed",
+      detect: async (cwd) => cwd,
+      captureWorkingDiff: async () => ({ patch: "installed patch", files: [] }),
+      listChanges: async () => [],
+      listFiles: async () => [],
+    });`,
+    );
+    writeFileSync(join(root, "config.toml"), '[vcs]\nprovider = "example.installed"\n');
+    const source = new VcsSourceManager(join(root, "config.toml"), installRoot);
+
+    expect((await source.select(repo)).adapter.id).toBe("example.installed");
+    expect((await source.capture(repo)).patch).toBe("installed patch");
+  });
+
+  test("a failing extension detection leaves the built-in Git source usable", async () => {
+    const root = createTestVcsDirectory(created);
+    const repo = createTestVcsGitRepo(created);
+    const extension = join(root, "broken.ts");
+    const config = join(root, "config.toml");
+
+    writeFileSync(
+      extension,
+      `export default (api) => api.registerVcsAdapter({
+        apiVersion: 1,
+        id: "example.broken",
+        detect: async () => { throw new Error("broken checkout probe"); },
+        captureWorkingDiff: async () => ({ patch: "", files: [] }),
+        listChanges: async () => [],
+        listFiles: async () => [],
+      });\n`,
+    );
+    writeFileSync(config, `[vcs]\nextensions = ["${extension}"]\n`);
+    const source = new VcsSourceManager(config);
+
+    expect((await source.select(repo)).adapter.id).toBe("git");
+    expect((await source.capture(repo)).vcs).toBe("git");
+    expect(source.extensionErrors).toContain(
+      "VCS adapter example.broken detection failed: Error: broken checkout probe",
+    );
+  });
+});

package/src/vcs-source.ts

@@ -0,0 +1,228 @@
+/** Select and run VCS diff adapters without exposing daemon state to extensions. */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import type { VcsAdapter, VcsDiffSnapshot, ExtensionFactory } from "@cueloop/extension-api";
+import { Registry } from "@cueloop/extension-api";
+import {
+  discoverInstalledExtensionPackages,
+  extensionInstallRoot,
+} from "@cueloop/extension-api/installed-packages";
+import { parse as parseToml } from "smol-toml";
+import * as v from "valibot";
+import { jjVcsAdapter } from "./jj-working-tree";
+import { workingChangeList, workingTreeDiff } from "./working-tree";
+import { listProjectFiles } from "./project-files";
+import { DiffFileContentsSchema } from "./validate";
+
+const VcsDiffSnapshotSchema = v.object({
+  patch: v.string(),
+  files: v.array(DiffFileContentsSchema),
+  source: v.optional(
+    v.object({
+      changeId: v.optional(v.pipe(v.string(), v.minLength(1))),
+      revisionId: v.pipe(v.string(), v.minLength(1)),
+    }),
+  ),
+});
+
+async function gitRoot(cwd: string): Promise<string | null> {
+  try {
+    const child = Bun.spawn(["git", "rev-parse", "--show-toplevel"], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const output = await new Response(child.stdout).text();
+
+    return (await child.exited) === 0 ? output.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The Git adapter retains the established HEAD-to-working-tree capture path. */
+export const gitVcsAdapter: VcsAdapter = {
+  apiVersion: 1,
+  id: "git",
+  detect: gitRoot,
+  captureWorkingDiff: workingTreeDiff,
+  listChanges: workingChangeList,
+  listFiles: async (root) => listProjectFiles(root),
+};
+
+interface VcsConfig {
+  provider: string;
+  extensions: string[];
+}
+
+const VcsConfigSchema = v.object({
+  vcs: v.optional(
+    v.object({
+      provider: v.optional(v.string()),
+      extensions: v.optional(v.array(v.string())),
+    }),
+  ),
+});
+
+const ExtensionModuleSchema = v.object({ default: v.function() });
+
+function readVcsToml(path: string): Partial<VcsConfig> {
+  if (!existsSync(path)) return {};
+  try {
+    const parsed = v.safeParse(VcsConfigSchema, parseToml(readFileSync(path, "utf8")));
+
+    return parsed.success ? (parsed.output.vcs ?? {}) : {};
+  } catch {
+    return {};
+  }
+}
+
+/** A selected adapter and the checkout root it owns. */
+export interface SelectedVcsSource {
+  adapter: VcsAdapter;
+  repoRoot: string;
+}
+
+/** VCS extensions load only from personal config; repo config may select an installed adapter. */
+export class VcsSourceManager {
+  private readonly registry = new Registry();
+  private loaded: Promise<void> | null = null;
+  readonly extensionErrors: string[] = [];
+
+  constructor(
+    private readonly userConfigPath = process.env.CUELOOP_CONFIG ??
+      join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "cueloop", "config.toml"),
+    private readonly installRoot = extensionInstallRoot(),
+  ) {}
+
+  private async adapters(): Promise<VcsAdapter[]> {
+    if (!this.loaded) this.loaded = this.loadExtensions();
+    await this.loaded;
+
+    return [
+      gitVcsAdapter,
+      jjVcsAdapter,
+      ...this.registry.extensions.flatMap((record) => [...record.vcsAdapters.values()]),
+    ];
+  }
+
+  private async loadExtensions(): Promise<void> {
+    const paths = readVcsToml(this.userConfigPath).extensions ?? [];
+
+    for (const path of paths) {
+      const absolute = isAbsolute(path) ? path : resolve(dirname(this.userConfigPath), path);
+      await this.loadAdapterExtension(absolute);
+    }
+    const discovery = discoverInstalledExtensionPackages(this.installRoot);
+
+    this.extensionErrors.push(...discovery.errors);
+    for (const extension of discovery.packages) {
+      if (extension.daemonEntry) await this.loadAdapterExtension(extension.daemonEntry);
+    }
+  }
+
+  private async loadAdapterExtension(absolute: string): Promise<void> {
+    try {
+      const module: unknown = await import(pathToFileURL(absolute).href);
+      const parsed = v.safeParse(ExtensionModuleSchema, module);
+
+      if (!parsed.success) throw new Error("VCS extension must export a default factory");
+      const factory: ExtensionFactory = async (api) => {
+        await parsed.output.default(api);
+      };
+      const record = await this.registry.load(absolute, factory);
+
+      for (const error of record.errors)
+        this.extensionErrors.push(`VCS extension ${absolute}: ${error}`);
+    } catch (error) {
+      this.extensionErrors.push(`VCS extension load failed: ${absolute}: ${String(error)}`);
+    }
+  }
+
+  /** Auto chooses the nearest checkout, preferring jj over Git at one root. */
+  async select(cwd: string, pinnedProvider?: string): Promise<SelectedVcsSource> {
+    const adapters = await this.adapters();
+    const detected = (
+      await Promise.all(
+        adapters.map(async (adapter) => {
+          try {
+            return { adapter, repoRoot: await adapter.detect(cwd) };
+          } catch (error) {
+            const message = `VCS adapter ${adapter.id} detection failed: ${String(error)}`;
+
+            if (!this.extensionErrors.includes(message)) this.extensionErrors.push(message);
+
+            return { adapter, repoRoot: null };
+          }
+        }),
+      )
+    ).filter((item): item is SelectedVcsSource => item.repoRoot !== null);
+    const nearest = detected.toSorted((a, b) => b.repoRoot.length - a.repoRoot.length)[0];
+    const repoConfig = nearest
+      ? readVcsToml(join(nearest.repoRoot, ".cueloop", "config.toml"))
+      : {};
+    const requested =
+      pinnedProvider ??
+      process.env.CUELOOP_VCS ??
+      repoConfig.provider ??
+      readVcsToml(this.userConfigPath).provider ??
+      "auto";
+
+    if (requested !== "auto") {
+      const selected = detected.find(({ adapter }) => adapter.id === requested);
+
+      if (!selected && requested === "git" && detected.length === 0)
+        return { adapter: gitVcsAdapter, repoRoot: cwd };
+      if (!selected)
+        throw new Error(
+          `VCS adapter unavailable: ${requested}${this.extensionErrors.length > 0 ? ` (${this.extensionErrors.join("; ")})` : ""}`,
+        );
+
+      return selected;
+    }
+    detected.sort((a, b) => {
+      const rootDistance = b.repoRoot.length - a.repoRoot.length;
+
+      if (rootDistance !== 0) return rootDistance;
+
+      return (b.adapter.id === "jj" ? 1 : 0) - (a.adapter.id === "jj" ? 1 : 0);
+    });
+    const selected = detected[0];
+
+    if (!selected) return { adapter: gitVcsAdapter, repoRoot: cwd };
+
+    return selected;
+  }
+
+  /** Capture with the selected source and preserve its identity alongside the diff. */
+  async capture(cwd: string, pinnedProvider?: string): Promise<VcsDiffSnapshot & { vcs: string }> {
+    const selected = await this.select(cwd, pinnedProvider);
+    const snapshot = v.parse(
+      VcsDiffSnapshotSchema,
+      await selected.adapter.captureWorkingDiff(selected.repoRoot),
+    );
+
+    return { ...snapshot, vcs: selected.adapter.id };
+  }
+
+  /** Resolve one logical change; ambiguous or unsupported identities fail explicitly. */
+  async captureChange(
+    cwd: string,
+    provider: string,
+    changeId: string,
+  ): Promise<VcsDiffSnapshot & { vcs: string }> {
+    const selected = await this.select(cwd, provider);
+
+    if (!selected.adapter.captureChange)
+      throw new Error(`VCS adapter ${provider} cannot follow a change ID`);
+    const snapshot = v.parse(
+      VcsDiffSnapshotSchema,
+      await selected.adapter.captureChange(selected.repoRoot, changeId),
+    );
+
+    return { ...snapshot, vcs: selected.adapter.id };
+  }
+}

package/src/version.ts

@@ -0,0 +1,6 @@
+/** The daemon's build version, read from the package manifest - the handshake
+ *  uses it so a client never keeps talking to a daemon from an earlier build. */
+
+import manifest from "../package.json" with { type: "json" };
+
+export const DAEMON_VERSION: string = manifest.version;

package/src/working-tree.ts

@@ -0,0 +1,149 @@
+/** Working-tree diff capture for `cueloop diff`, untracked files included. */
+
+import { join } from "node:path";
+import type { DiffFileContents, DiffFileStatus } from "@cueloop/schema";
+
+async function git(args: string[], cwd: string): Promise<string | null> {
+  const gitProcess = Bun.spawn(["git", ...args], { cwd, stdout: "pipe", stderr: "ignore" });
+  const stdout = await new Response(gitProcess.stdout).text();
+
+  if ((await gitProcess.exited) !== 0) return null;
+
+  return stdout.trim();
+}
+
+/** Map a `git diff --name-status` letter to a diff status; renames/copies read as modified. */
+function statusFromCode(code: string): DiffFileStatus {
+  const letter = code.charAt(0);
+  if (letter === "D") return "deleted";
+  if (letter === "A") return "added";
+
+  return "modified";
+}
+
+/**
+ * The working tree's changed files as repo-relative path plus status - a fast listing for the changes
+ * navigator that never reads file contents (unlike workingTreeDiff, which captures full curation copies).
+ * Uses tab-separated name-status so a trimmed leading column can never shift the parse.
+ */
+export async function workingChangeList(
+  cwd = process.cwd(),
+): Promise<{ path: string; status: DiffFileStatus }[]> {
+  const changes: { path: string; status: DiffFileStatus }[] = [];
+  const tracked = (await git(["diff", "--name-status", "HEAD"], cwd)) ?? "";
+
+  for (const line of tracked.split("\n")) {
+    if (line.trim().length === 0) continue;
+    const parts = line.split("\t");
+    // a rename is "R100<tab>old<tab>new"; the new path (last field) is what the reviewer opens
+    changes.push({ path: parts[parts.length - 1]!, status: statusFromCode(parts[0]!) });
+  }
+
+  const untracked = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
+
+  for (const path of untracked.split("\n")) {
+    if (path.trim().length > 0) changes.push({ path, status: "added" });
+  }
+
+  return changes;
+}
+
+/** The blob at HEAD for a path, or "" when the path is not in HEAD (new file). */
+async function headContents(path: string, cwd: string): Promise<string> {
+  const gitProcess = Bun.spawn(["git", "show", `HEAD:${path}`], {
+    cwd,
+    stdout: "pipe",
+    stderr: "ignore",
+  });
+  const stdout = await new Response(gitProcess.stdout).text();
+
+  return (await gitProcess.exited) === 0 ? stdout : "";
+}
+
+/** The working-tree file, or "" when it is gone (deleted). */
+async function workingContents(path: string, cwd: string): Promise<string> {
+  try {
+    return await Bun.file(join(cwd, path)).text();
+  } catch {
+    return "";
+  }
+}
+
+/** A NUL byte marks content git would treat as binary - not text-curatable. */
+function looksBinary(text: string): boolean {
+  for (let index = 0; index < text.length; index++) {
+    if (text.charCodeAt(index) === 0) return true;
+  }
+
+  return false;
+}
+
+/**
+ * Full old/new contents for every tracked change against HEAD, classified by
+ * git's own status letter. Renames/copies and binary files are omitted: a
+ * path+text pair cannot express a rename header or a binary blob, so curation
+ * would emit a patch that drops the old path or corrupts the file - leaving them
+ * out keeps those changes in the patch but simply not curatable. The
+ * NUL-delimited stream survives paths with spaces or unicode.
+ */
+async function trackedFileContents(cwd: string): Promise<DiffFileContents[]> {
+  const nameStatus = (await git(["diff", "HEAD", "--name-status", "-z"], cwd)) ?? "";
+  const tokens = nameStatus.split("\0").filter((token) => token.length > 0);
+  const files: DiffFileContents[] = [];
+  let cursor = 0;
+
+  while (cursor < tokens.length) {
+    const code = tokens[cursor++]![0];
+
+    if (code === "R" || code === "C") {
+      cursor += 2;
+      continue;
+    }
+    const path = tokens[cursor++]!;
+    const oldContents = code === "A" ? "" : await headContents(path, cwd);
+    const newContents = code === "D" ? "" : await workingContents(path, cwd);
+
+    if (looksBinary(oldContents) || looksBinary(newContents)) continue;
+    const status = code === "A" ? "added" : code === "D" ? "deleted" : "modified";
+
+    files.push({ path, oldContents, newContents, status });
+  }
+
+  return files;
+}
+
+export interface WorkingTreeDiff {
+  patch: string;
+  /** Full file contents per curatable changed file, keeping curation applyable. */
+  files: DiffFileContents[];
+}
+
+export async function workingTreeDiff(cwd = process.cwd()): Promise<WorkingTreeDiff> {
+  const tracked = (await git(["diff", "HEAD"], cwd)) ?? "";
+  const files = await trackedFileContents(cwd);
+  // untracked files included by default
+  const untrackedList = (await git(["ls-files", "--others", "--exclude-standard"], cwd)) ?? "";
+  let untracked = "";
+
+  for (const file of untrackedList.split("\n").filter(Boolean)) {
+    // `git diff --no-index` exits 1 when the files differ - that is success here
+    const gitProcess = Bun.spawn(["git", "diff", "--no-index", "--", "/dev/null", file], {
+      cwd,
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const stdout = await new Response(gitProcess.stdout).text();
+    const code = await gitProcess.exited;
+
+    if ((code === 0 || code === 1) && stdout.trim()) {
+      untracked += stdout.trim() + "\n";
+      const newContents = await workingContents(file, cwd);
+
+      if (!looksBinary(newContents)) {
+        files.push({ path: file, oldContents: "", newContents, status: "added" });
+      }
+    }
+  }
+
+  return { patch: [tracked, untracked].filter(Boolean).join("\n"), files };
+}