@cueloop/daemon 0.1.0-alpha.89 → 0.1.0-alpha.90

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 };
+  }
+}