@smithers-orchestrator/vcs 0.24.2 → 0.25.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithers-orchestrator/vcs",
-  "version": "0.24.2",
+  "version": "0.25.1",
   "description": "VCS discovery and jj workspace operations for Smithers",
   "type": "module",
   "sideEffects": false,
@@ -22,7 +22,7 @@
   "dependencies": {
     "@effect/platform": "^0.96.0",
     "effect": "^3.21.1",
-    "@smithers-orchestrator/observability": "0.24.2"
+    "@smithers-orchestrator/observability": "0.25.1"
   },
   "devDependencies": {
     "@effect/platform-bun": "^0.89.0",
@@ -30,11 +30,11 @@
     "typescript": "~5.9.3"
   },
   "optionalDependencies": {
-    "@smithers-orchestrator/jj-darwin-arm64": "0.24.2",
-    "@smithers-orchestrator/jj-darwin-x64": "0.24.2",
-    "@smithers-orchestrator/jj-linux-arm64": "0.24.2",
-    "@smithers-orchestrator/jj-linux-x64": "0.24.2",
-    "@smithers-orchestrator/jj-win32-x64": "0.24.2"
+    "@smithers-orchestrator/jj-darwin-arm64": "0.25.1",
+    "@smithers-orchestrator/jj-darwin-x64": "0.25.1",
+    "@smithers-orchestrator/jj-linux-arm64": "0.25.1",
+    "@smithers-orchestrator/jj-linux-x64": "0.25.1",
+    "@smithers-orchestrator/jj-win32-x64": "0.25.1"
   },
   "scripts": {
     "build": "rm -f src/index.d.ts && tsup --dts-only",

package/src/find-root.js

@@ -1,29 +1,26 @@
 import { existsSync } from "node:fs";
 import { resolve, dirname, parse } from "node:path";
-import { Effect } from "effect";
 /**
  * Walk up from `startDir` to find the nearest directory containing `.jj` or `.git`.
  * Prefers `.jj` over `.git` so colocated repos (both exist) use jj semantics.
  * Returns the VCS type and root path, or null if neither is found.
  *
  * @param {string} startDir
- * @returns {Effect.Effect<{ type: "jj"; root: string } | { type: "git"; root: string } | null, never, never>}
+ * @returns {{ type: "jj"; root: string } | { type: "git"; root: string } | null}
  */
 export function findVcsRoot(startDir) {
-    return Effect.sync(() => {
-        let dir = resolve(startDir);
-        const { root: fsRoot } = parse(dir);
-        while (dir !== fsRoot) {
-            if (existsSync(resolve(dir, ".jj")))
-                return /** @type {{ type: "jj"; root: string }} */ ({ type: "jj", root: dir });
-            if (existsSync(resolve(dir, ".git")))
-                return /** @type {{ type: "git"; root: string }} */ ({ type: "git", root: dir });
-            dir = dirname(dir);
-        }
+    let dir = resolve(startDir);
+    const { root: fsRoot } = parse(dir);
+    while (dir !== fsRoot) {
         if (existsSync(resolve(dir, ".jj")))
             return /** @type {{ type: "jj"; root: string }} */ ({ type: "jj", root: dir });
         if (existsSync(resolve(dir, ".git")))
             return /** @type {{ type: "git"; root: string }} */ ({ type: "git", root: dir });
-        return null;
-    });
+        dir = dirname(dir);
+    }
+    if (existsSync(resolve(dir, ".jj")))
+        return /** @type {{ type: "jj"; root: string }} */ ({ type: "jj", root: dir });
+    if (existsSync(resolve(dir, ".git")))
+        return /** @type {{ type: "git"; root: string }} */ ({ type: "git", root: dir });
+    return null;
 }

package/src/index.d.ts

@@ -1,5 +1,6 @@
-import { Effect } from 'effect';
 import * as _effect_platform_CommandExecutor from '@effect/platform/CommandExecutor';
+import { Effect } from 'effect';
+import { existsSync } from 'node:fs';
 
 /**
  * Walk up from `startDir` to find the nearest directory containing `.jj` or `.git`.
@@ -7,15 +8,15 @@ import * as _effect_platform_CommandExecutor from '@effect/platform/CommandExecu
  * Returns the VCS type and root path, or null if neither is found.
  *
  * @param {string} startDir
- * @returns {Effect.Effect<{ type: "jj"; root: string } | { type: "git"; root: string } | null, never, never>}
+ * @returns {{ type: "jj"; root: string } | { type: "git"; root: string } | null}
  */
-declare function findVcsRoot(startDir: string): Effect.Effect<{
+declare function findVcsRoot(startDir: string): {
     type: "jj";
     root: string;
 } | {
     type: "git";
     root: string;
-} | null, never, never>;
+} | null;
 
 type WorkspaceResult$1 = {
     success: boolean;
@@ -65,6 +66,15 @@ declare function runJj(args: string[], opts?: RunJjOptions): Effect.Effect<RunJj
  * @returns {Effect.Effect<string | null, never, import("@effect/platform/CommandExecutor").CommandExecutor>}
  */
 declare function getJjPointer(cwd?: string): Effect.Effect<string | null, never, _effect_platform_CommandExecutor.CommandExecutor>;
+/**
+ * Parse the snapshot values returned by the two jj commands in
+ * {@link captureWorkspaceSnapshot}.
+ *
+ * @param {string} logStdout stdout from `jj log -r @ ...`
+ * @param {string} opStdout stdout from `jj operation log ...`
+ * @returns {WorkspaceSnapshot | null}
+ */
+declare function parseWorkspaceSnapshot(logStdout: string, opStdout: string): WorkspaceSnapshot | null;
 /**
  * Capture the current working-copy state as a restorable handle.
  *
@@ -169,6 +179,20 @@ type ResolvedBinary = {
  */
 declare function resolveGitBinary(): ResolvedBinary;
 
+/**
+ * Locate the bundled `jj` binary for the current host, or null when no platform
+ * package is installed (unsupported target, `--no-optional` install, or not yet
+ * published). Resolution goes through the package's `package.json` so it works
+ * regardless of hoisting layout.
+ *
+ * @returns {string | null}
+ */
+declare function resolveBundledJjPath({ platform, arch, resolvePackage, fileExists, }?: {
+    platform?: NodeJS.Platform | undefined;
+    arch?: NodeJS.Architecture | undefined;
+    resolvePackage?: NodeJS.RequireResolve | undefined;
+    fileExists?: typeof existsSync | undefined;
+}): string | null;
 /**
  * Resolve the `jj` executable Smithers should spawn.
  *
@@ -185,6 +209,14 @@ declare function resolveGitBinary(): ResolvedBinary;
  */
 declare function resolveJjBinary(): ResolvedBinary;
 
+/**
+ * Whether `<bin> --version` exits 0. Best-effort: a missing binary, a non-zero
+ * exit, or a spawn error all read as "not usable".
+ *
+ * @param {import("./ResolvedBinary.js").ResolvedBinary} bin
+ * @returns {boolean}
+ */
+declare function runsVersion(bin: ResolvedBinary): boolean;
 /**
  * Probe whether a usable `jj` and/or `git` exists for the current host, using
  * the override → bundled → PATH resolution for jj and override → PATH for git.
@@ -216,4 +248,4 @@ type VcsToolingStatus = {
     ok: boolean;
 };
 
-export { type JjRevertResult, type RunJjOptions, type RunJjResult, type VcsToolingStatus, type WorkspaceAddOptions, type WorkspaceInfo, type WorkspaceResult, type WorkspaceSnapshot, captureWorkspaceSnapshot, findVcsRoot, getJjPointer, isJjRepo, resolveGitBinary, resolveJjBinary, revertToJjPointer, runJj, vcsToolingStatus, workspaceAdd, workspaceClose, workspaceList };
+export { type JjRevertResult, type RunJjOptions, type RunJjResult, type VcsToolingStatus, type WorkspaceAddOptions, type WorkspaceInfo, type WorkspaceResult, type WorkspaceSnapshot, captureWorkspaceSnapshot, findVcsRoot, getJjPointer, isJjRepo, parseWorkspaceSnapshot, resolveBundledJjPath, resolveGitBinary, resolveJjBinary, revertToJjPointer, runJj, runsVersion, vcsToolingStatus, workspaceAdd, workspaceClose, workspaceList };

package/src/jj.js

@@ -14,6 +14,8 @@
 // @smithers-type-exports-end
 
 import * as Command from "@effect/platform/Command";
+import * as fs from "node:fs";
+import * as nodePath from "node:path";
 import { Duration, Effect, Fiber, Metric, Stream } from "effect";
 import { vcsDuration } from "@smithers-orchestrator/observability/metrics";
 import { resolveJjBinary } from "./resolveJjBinary.js";
@@ -43,19 +45,20 @@ export function runJj(args, opts = {}) {
     }
     return Effect.scoped(Effect.gen(function* () {
         const start = performance.now();
-        yield* Effect.logDebug(`jj ${args.join(" ")}`);
-        const process = yield* Command.start(command);
-        const stdoutFiber = yield* Effect.fork(collectUtf8(process.stdout));
-        const stderrFiber = yield* Effect.fork(collectUtf8(process.stderr));
-        const exitCode = yield* process.exitCode;
-        const stdout = yield* Fiber.join(stdoutFiber);
-        const stderr = yield* Fiber.join(stderrFiber);
-        yield* Metric.update(vcsDuration, performance.now() - start);
-        return {
-            code: Number(exitCode),
-            stdout,
-            stderr,
-        };
+        return yield* Effect.gen(function* () {
+            yield* Effect.logDebug(`jj ${args.join(" ")}`);
+            const process = yield* Command.start(command);
+            const stdoutFiber = yield* Effect.fork(collectUtf8(process.stdout));
+            const stderrFiber = yield* Effect.fork(collectUtf8(process.stderr));
+            const exitCode = yield* process.exitCode;
+            const stdout = yield* Fiber.join(stdoutFiber);
+            const stderr = yield* Fiber.join(stderrFiber);
+            return {
+                code: Number(exitCode),
+                stdout,
+                stderr,
+            };
+        }).pipe(Effect.ensuring(Effect.suspend(() => Metric.update(vcsDuration, performance.now() - start))));
     })).pipe(Effect.annotateLogs({
         vcs: "jj",
         cwd: opts.cwd ?? "",
@@ -116,6 +119,26 @@ function withSnapshotTimeout(effect, label) {
         }),
     }));
 }
+/**
+ * Parse the snapshot values returned by the two jj commands in
+ * {@link captureWorkspaceSnapshot}.
+ *
+ * @param {string} logStdout stdout from `jj log -r @ ...`
+ * @param {string} opStdout stdout from `jj operation log ...`
+ * @returns {WorkspaceSnapshot | null}
+ */
+export function parseWorkspaceSnapshot(logStdout, opStdout) {
+    const [commitId, changeId] = logStdout.split("\n").map((part) => part.trim());
+    if (!commitId)
+        return null;
+    const operationId = opStdout
+        .split(/\r?\n/)
+        .map((part) => part.trim())
+        .find(Boolean);
+    if (!operationId)
+        return null;
+    return { commitId, changeId: changeId ?? "", operationId };
+}
 /**
  * Capture the current working-copy state as a restorable handle.
  *
@@ -133,16 +156,10 @@ export function captureWorkspaceSnapshot(cwd) {
         const logRes = yield* withSnapshotTimeout(runJj(["log", "-r", "@", "--no-graph", "-T", 'commit_id ++ "\\n" ++ change_id'], { cwd }), "jj snapshot log");
         if (logRes.code !== 0)
             return null;
-        const [commitId, changeId] = logRes.stdout.split("\n").map((part) => part.trim());
-        if (!commitId)
-            return null;
         const opRes = yield* withSnapshotTimeout(runJj(["--ignore-working-copy", "operation", "log", "--no-graph", "--limit", "1", "-T", "self.id()"], { cwd }), "jj snapshot op");
         if (opRes.code !== 0)
             return null;
-        const operationId = opRes.stdout.trim();
-        if (!operationId)
-            return null;
-        return { commitId, changeId: changeId ?? "", operationId };
+        return parseWorkspaceSnapshot(logRes.stdout, opRes.stdout);
     }).pipe(Effect.annotateLogs({ cwd: cwd ?? "" }), Effect.withLogSpan("vcs:jj-snapshot"));
 }
 /**
@@ -194,8 +211,6 @@ export function workspaceAdd(name, path, opts = {}) {
             yield* runJj(["workspace", "forget", name], { cwd: opts.cwd });
         }
         try {
-            const fs = require("node:fs");
-            const nodePath = require("node:path");
             if (fs.existsSync(path)) {
                 fs.rmSync(path, { recursive: true, force: true });
             }

package/src/resolveJjBinary.js

@@ -31,14 +31,19 @@ const BUNDLED_PACKAGES = {
  *
  * @returns {string | null}
  */
-function bundledJjPath() {
-	const pkg = BUNDLED_PACKAGES[`${process.platform}-${process.arch}`];
+export function resolveBundledJjPath({
+	platform = process.platform,
+	arch = process.arch,
+	resolvePackage = require.resolve,
+	fileExists = existsSync,
+} = {}) {
+	const pkg = BUNDLED_PACKAGES[`${platform}-${arch}`];
 	if (!pkg) return null;
-	const binary = process.platform === "win32" ? "jj.exe" : "jj";
+	const binary = platform === "win32" ? "jj.exe" : "jj";
 	try {
-		const manifest = require.resolve(`${pkg}/package.json`);
+		const manifest = resolvePackage(`${pkg}/package.json`);
 		const candidate = join(manifest, "..", "bin", binary);
-		return existsSync(candidate) ? candidate : null;
+		return fileExists(candidate) ? candidate : null;
 	} catch {
 		return null;
 	}
@@ -61,7 +66,7 @@ function bundledJjPath() {
 export function resolveJjBinary() {
 	const override = process.env.SMITHERS_JJ_PATH;
 	if (override && existsSync(override)) return { path: override, source: "env" };
-	const bundled = bundledJjPath();
+	const bundled = resolveBundledJjPath();
 	if (bundled) return { path: bundled, source: "bundled" };
 	return { path: "jj", source: "path" };
 }

package/src/vcsToolingStatus.js

@@ -21,7 +21,7 @@ const VERSION_PROBE_TIMEOUT_MS = 2_000;
  * @param {import("./ResolvedBinary.js").ResolvedBinary} bin
  * @returns {boolean}
  */
-function runsVersion(bin) {
+export function runsVersion(bin) {
 	try {
 		const res = spawnSync(bin.path, ["--version"], {
 			stdio: "ignore",

package/src/WorkspaceSnapshot.ts

@@ -1,16 +0,0 @@
-export type WorkspaceSnapshot = {
-  /**
-   * Working-copy commit id at this snapshot. Advances on every snapshot, so it
-   * addresses an individual working-copy state (unlike `changeId`, which is
-   * stable across edits to the same working copy).
-   */
-  commitId: string;
-  /** Change id of `@`. Stable across edits to one working copy; grouping metadata only. */
-  changeId: string;
-  /**
-   * jj operation id for this snapshot. The durable restore handle: the commit id
-   * of an abandoned working-copy commit can be garbage-collected, while the
-   * operation log is retained under the configured gc policy.
-   */
-  operationId: string;
-};