perttool 0.10.2 → 0.10.4

package/dist/history/git-probe.js

@@ -21,9 +21,21 @@ const availabilityOrder = new Map([
     ["ambiguous_path", 4],
     ["shallow_boundary", 5],
     ["unsupported_rename", 6],
-    ["head_changed", 7],
-    ["target_changed", 8],
+    ["provenance_unavailable", 7],
+    ["head_changed", 8],
+    ["target_changed", 9],
 ]);
+function emptyProvenance(requestedMode) {
+    return Object.freeze({
+        modelVersion: 1,
+        requestedMode,
+        effectiveMode: "automatic",
+        overrideApplied: false,
+        rootCommitId: null,
+        rootSourceDigest: null,
+        excludedPredecessors: Object.freeze([]),
+    });
+}
 function errorCode(error) {
     return typeof error === "object" && error !== null && "code" in error
         ? String(error.code)
@@ -200,29 +212,197 @@ function availability(causes) {
         return (left.commitId ?? "").localeCompare(right.commitId ?? "", "en");
     }));
 }
-function unavailable(requestedRevision, cause, fields = {}) {
+function unavailable(requestedRevision, cause, fields) {
     return {
         ok: true,
         modelVersion: GIT_HISTORY_PROBE_MODEL_VERSION,
         status: "unavailable",
         traversal: "first_parent",
-        objectFormat: fields.objectFormat ?? null,
-        repositorySnapshotId: fields.repositorySnapshotId ?? null,
-        repositoryRelativePath: fields.repositoryRelativePath ?? null,
+        objectFormat: nullable(fields.objectFormat),
+        repositorySnapshotId: nullable(fields.repositorySnapshotId),
+        repositoryRelativePath: nullable(fields.repositoryRelativePath),
         requestedRevision,
-        resolvedRevision: fields.resolvedRevision ?? null,
-        headCommitId: fields.headCommitId ?? null,
-        currentSourceDigest: fields.currentSourceDigest ?? null,
-        selectedSourceDigest: fields.selectedSourceDigest ?? null,
-        inspectedCommitIds: fields.inspectedCommitIds ?? [],
-        snapshots: fields.snapshots ?? [],
+        resolvedRevision: nullable(fields.resolvedRevision),
+        headCommitId: nullable(fields.headCommitId),
+        currentSourceDigest: nullable(fields.currentSourceDigest),
+        selectedSourceDigest: nullable(fields.selectedSourceDigest),
+        inspectedCommitIds: arrayValue(fields.inspectedCommitIds),
+        snapshots: arrayValue(fields.snapshots),
         availability: availability([{ cause, commitId: null }]),
+        provenance: fields.provenance ?? emptyProvenance("automatic"),
     };
 }
+function nullable(value) {
+    return value === undefined ? null : value;
+}
+function arrayValue(value) {
+    return value === undefined ? [] : value;
+}
 function commitId(value, objectFormat) {
     const length = objectFormat === "sha1" ? 40 : 64;
     return new RegExp(`^[0-9a-f]{${length}}$`).test(value);
 }
+function decodeGitPath(value) {
+    try {
+        const path = new TextDecoder("utf-8", { fatal: true }).decode(value);
+        return path === "" || /[\u0000\r\n]/.test(path) ? null : path;
+    }
+    catch {
+        return null;
+    }
+}
+function renameCandidates(value, selectedPath) {
+    if (value.length === 0)
+        return Object.freeze([]);
+    const fields = value.subarray(0, value.at(-1) === 0 ? -1 : value.length)
+        .toString("latin1").split("\u0000").map((field) => Buffer.from(field, "latin1"));
+    const result = [];
+    for (let index = 0; index < fields.length;) {
+        const record = consumeDiffRecord(fields, index, selectedPath);
+        if (record === null)
+            return null;
+        index = record.nextIndex;
+        if (record.candidate !== null)
+            result.push(record.candidate);
+    }
+    return Object.freeze(result);
+}
+function consumeDiffRecord(fields, index, selectedPath) {
+    const statusField = fields[index];
+    if (statusField === undefined)
+        return null;
+    const status = statusField.toString("ascii");
+    if (!/^[A-Z][0-9]*$/.test(status))
+        return null;
+    if (!status.startsWith("R") && !status.startsWith("C")) {
+        const path = fields[index + 1];
+        return path !== undefined && decodeGitPath(path) !== null
+            ? { nextIndex: index + 2, candidate: null }
+            : null;
+    }
+    const oldPath = fields[index + 1];
+    const newPath = fields[index + 2];
+    if (oldPath === undefined || newPath === undefined)
+        return null;
+    const oldText = decodeGitPath(oldPath);
+    const newText = decodeGitPath(newPath);
+    if (oldText === null || newText === null)
+        return null;
+    const candidate = status.startsWith("R") && newText === selectedPath
+        ? { oldPath: oldText, newPath: newText }
+        : null;
+    return { nextIndex: index + 3, candidate };
+}
+function collectHistorySnapshots(request) {
+    const snapshots = [];
+    for (const inspectedCommitId of request.inspectedCommitIds) {
+        const metadataCommand = runGit(request.executable, request.repositoryRoot, "commit_metadata", ["show", "-s", "--format=%P%x00%cI", inspectedCommitId]);
+        if (!metadataCommand.ok) {
+            return metadataCommand.kind === "failure"
+                ? metadataCommand.failure
+                : commandFailure("commit_metadata");
+        }
+        const metadataText = stdoutText(metadataCommand, "commit_metadata");
+        if (typeof metadataText !== "string")
+            return metadataText;
+        const metadata = parseGitCommitMetadata(metadataText, request.objectFormat);
+        if (metadata === null)
+            return malformed("commit_metadata");
+        const exists = runGit(request.executable, request.repositoryRoot, "snapshot_exists", ["ls-tree", "-z", "--name-only", inspectedCommitId, "--", request.relativePath]);
+        if (!exists.ok) {
+            return exists.kind === "failure"
+                ? exists.failure
+                : commandFailure("snapshot_exists");
+        }
+        let source = null;
+        let sourceDigest = null;
+        if (exists.stdout.length > 0) {
+            if (!exists.stdout.equals(Buffer.from(`${request.relativePath}\0`, "utf8"))) {
+                return malformed("snapshot_exists");
+            }
+            const sourceCommand = runGit(request.executable, request.repositoryRoot, "snapshot_source", ["cat-file", "blob", `${inspectedCommitId}:${request.relativePath}`]);
+            if (!sourceCommand.ok) {
+                return sourceCommand.kind === "failure"
+                    ? sourceCommand.failure
+                    : commandFailure("snapshot_source");
+            }
+            source = new Uint8Array(sourceCommand.stdout);
+            sourceDigest = digestDocumentBytes(source);
+        }
+        snapshots.push({
+            repositorySnapshotId: request.repositorySnapshotId,
+            relativePath: request.relativePath,
+            commitId: inspectedCommitId,
+            parentCommitIds: metadata.parentCommitIds,
+            recordedAt: metadata.recordedAt,
+            sourceDigest,
+            source,
+        });
+    }
+    return { ok: true, snapshots: Object.freeze(snapshots) };
+}
+function treeBlobId(value, expectedPath, objectFormat) {
+    const fields = value.subarray(0, value.at(-1) === 0 ? -1 : value.length)
+        .toString("latin1").split("\u0000").map((field) => Buffer.from(field, "latin1"));
+    if (fields.length !== 1)
+        return null;
+    const separator = fields[0].indexOf(0x09);
+    if (separator < 0)
+        return null;
+    const metadata = fields[0].subarray(0, separator).toString("ascii");
+    const path = decodeGitPath(fields[0].subarray(separator + 1));
+    const match = /^[0-7]{6} blob ([0-9a-f]+)$/.exec(metadata);
+    return path === expectedPath && match !== null && commitId(match[1], objectFormat)
+        ? match[1]
+        : null;
+}
+function probeNewRootProvenance(executable, repositoryRoot, relativePath, objectFormat, snapshots) {
+    const root = snapshots[0];
+    if (root === undefined || root.source === null || root.sourceDigest === null) {
+        return null;
+    }
+    if (root.parentCommitIds.length !== 1)
+        return null;
+    const parentCommitId = root.parentCommitIds[0];
+    const diff = runGit(executable, repositoryRoot, "provenance_root_diff", [
+        "diff-tree", "-r", "--name-status", "-z", "-M",
+        parentCommitId, root.commitId,
+    ]);
+    if (!diff.ok)
+        return null;
+    const candidates = renameCandidates(diff.stdout, relativePath);
+    if (candidates === null || candidates.length !== 1)
+        return null;
+    const predecessorPath = candidates[0].oldPath;
+    const tree = runGit(executable, repositoryRoot, "provenance_predecessor_tree", [
+        "ls-tree", "-z", parentCommitId, "--", predecessorPath,
+    ]);
+    if (!tree.ok)
+        return null;
+    const blobId = treeBlobId(tree.stdout, predecessorPath, objectFormat);
+    if (blobId === null)
+        return null;
+    const source = runGit(executable, repositoryRoot, "provenance_predecessor_source", [
+        "cat-file", "blob", blobId,
+    ]);
+    if (!source.ok)
+        return null;
+    const predecessorSource = new Uint8Array(source.stdout);
+    return Object.freeze({
+        modelVersion: 1,
+        requestedMode: "new_root",
+        effectiveMode: "new_root",
+        overrideApplied: true,
+        rootCommitId: root.commitId,
+        rootSourceDigest: root.sourceDigest,
+        excludedPredecessors: Object.freeze([Object.freeze({
+                path: predecessorPath,
+                commitId: parentCommitId,
+                sourceDigest: digestDocumentBytes(predecessorSource),
+                source: predecessorSource,
+            })]),
+    });
+}
 export function parseGitCommitMetadata(value, objectFormat) {
     const separatorIndex = value.indexOf("\0");
     if (separatorIndex === -1)
@@ -266,12 +446,16 @@ function sameTarget(left, right) {
 }
 export async function probeGitHistory(request, dependencies = {}) {
     const requestedRevision = request.revision ?? "HEAD";
+    const requestedProvenanceMode = request.provenanceMode ?? "automatic";
+    const initialProvenance = emptyProvenance(requestedProvenanceMode);
     const executable = dependencies.gitExecutable ?? "git";
     const targetPath = resolve(request.targetPath);
     const initialTarget = await captureTarget(targetPath);
     if (!initialTarget.ok) {
         if ("ambiguous" in initialTarget) {
-            return unavailable(requestedRevision, "ambiguous_path");
+            return unavailable(requestedRevision, "ambiguous_path", {
+                provenance: initialProvenance,
+            });
         }
         return initialTarget.failure;
     }
@@ -282,6 +466,7 @@ export async function probeGitHistory(request, dependencies = {}) {
         }
         return unavailable(requestedRevision, "no_repository", {
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     const repositoryText = stdoutText(repositoryCommand, "repository_root");
@@ -298,6 +483,7 @@ export async function probeGitHistory(request, dependencies = {}) {
     if (relativePath === null) {
         return unavailable(requestedRevision, "ambiguous_path", {
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     const headCommand = runGit(executable, repositoryRoot, "resolve_head", ["rev-parse", "--verify", "--end-of-options", "HEAD^{commit}"]);
@@ -307,6 +493,7 @@ export async function probeGitHistory(request, dependencies = {}) {
         return unavailable(requestedRevision, "no_head", {
             repositoryRelativePath: relativePath,
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     const formatCommand = runGit(executable, repositoryRoot, "object_format", ["rev-parse", "--show-object-format=storage"]);
@@ -342,6 +529,7 @@ export async function probeGitHistory(request, dependencies = {}) {
             repositoryRelativePath: relativePath,
             headCommitId: initialHead,
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     const revisionText = stdoutText(revisionCommand, "resolve_revision");
@@ -361,6 +549,7 @@ export async function probeGitHistory(request, dependencies = {}) {
             resolvedRevision,
             headCommitId: initialHead,
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     const trackedCommand = runGit(executable, repositoryRoot, "selected_target", [
@@ -384,6 +573,7 @@ export async function probeGitHistory(request, dependencies = {}) {
             resolvedRevision,
             headCommitId: initialHead,
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     if (!trackedCommand.stdout.equals(Buffer.from(`${relativePath}\0`, "utf8"))) {
@@ -394,6 +584,7 @@ export async function probeGitHistory(request, dependencies = {}) {
             resolvedRevision,
             headCommitId: initialHead,
             currentSourceDigest: initialTarget.capture.digest,
+            provenance: initialProvenance,
         });
     }
     const commitsCommand = runGit(executable, repositoryRoot, "first_parent_commits", [
@@ -420,61 +611,32 @@ export async function probeGitHistory(request, dependencies = {}) {
         new Set(inspectedCommitIds).size !== inspectedCommitIds.length) {
         return malformed("first_parent_commits");
     }
-    const snapshots = [];
-    for (const inspectedCommitId of inspectedCommitIds) {
-        const metadataCommand = runGit(executable, repositoryRoot, "commit_metadata", [
-            "show",
-            "-s",
-            "--format=%P%x00%cI",
-            inspectedCommitId,
-        ]);
-        if (!metadataCommand.ok) {
-            return metadataCommand.kind === "failure"
-                ? metadataCommand.failure
-                : commandFailure("commit_metadata");
-        }
-        const metadataText = stdoutText(metadataCommand, "commit_metadata");
-        if (typeof metadataText !== "string")
-            return metadataText;
-        const metadata = parseGitCommitMetadata(metadataText, objectFormat);
-        if (metadata === null)
-            return malformed("commit_metadata");
-        const existsCommand = runGit(executable, repositoryRoot, "snapshot_exists", [
-            "ls-tree",
-            "-z",
-            "--name-only",
-            inspectedCommitId,
-            "--",
-            relativePath,
-        ]);
-        if (!existsCommand.ok) {
-            return existsCommand.kind === "failure"
-                ? existsCommand.failure
-                : commandFailure("snapshot_exists");
-        }
-        let source = null;
-        let sourceDigest = null;
-        if (existsCommand.stdout.length > 0) {
-            if (!existsCommand.stdout.equals(Buffer.from(`${relativePath}\0`, "utf8"))) {
-                return malformed("snapshot_exists");
-            }
-            const sourceCommand = runGit(executable, repositoryRoot, "snapshot_source", ["cat-file", "blob", `${inspectedCommitId}:${relativePath}`]);
-            if (!sourceCommand.ok) {
-                return sourceCommand.kind === "failure"
-                    ? sourceCommand.failure
-                    : commandFailure("snapshot_source");
-            }
-            source = new Uint8Array(sourceCommand.stdout);
-            sourceDigest = digestDocumentBytes(source);
-        }
-        snapshots.push({
+    const snapshotCollection = collectHistorySnapshots({
+        executable,
+        repositoryRoot,
+        repositorySnapshotId,
+        relativePath,
+        objectFormat,
+        inspectedCommitIds,
+    });
+    if (!snapshotCollection.ok)
+        return snapshotCollection;
+    const snapshots = snapshotCollection.snapshots;
+    const provenance = requestedProvenanceMode === "new_root"
+        ? probeNewRootProvenance(executable, repositoryRoot, relativePath, objectFormat, snapshots)
+        : initialProvenance;
+    if (provenance === null) {
+        return unavailable(requestedRevision, "provenance_unavailable", {
+            objectFormat,
             repositorySnapshotId,
-            relativePath,
-            commitId: inspectedCommitId,
-            parentCommitIds: metadata.parentCommitIds,
-            recordedAt: metadata.recordedAt,
-            sourceDigest,
-            source,
+            repositoryRelativePath: relativePath,
+            resolvedRevision,
+            headCommitId: initialHead,
+            currentSourceDigest: initialTarget.capture.digest,
+            selectedSourceDigest: snapshots.at(-1)?.sourceDigest ?? null,
+            inspectedCommitIds,
+            snapshots,
+            provenance: initialProvenance,
         });
     }
     const renameCommand = runGit(executable, repositoryRoot, "rename_detection", [
@@ -523,6 +685,7 @@ export async function probeGitHistory(request, dependencies = {}) {
             selectedSourceDigest: snapshots.at(-1)?.sourceDigest ?? null,
             inspectedCommitIds,
             snapshots,
+            provenance,
         });
     }
     const finalHeadText = stdoutText(finalHeadCommand, "recheck_head");
@@ -547,7 +710,8 @@ export async function probeGitHistory(request, dependencies = {}) {
             commitId: inspectedCommitIds[0] ?? null,
         });
     }
-    if (/(?:^|\n)R\d+\t/.test(renameText)) {
+    if (requestedProvenanceMode === "automatic" &&
+        /(?:^|\n)R\d+\t/.test(renameText)) {
         incompleteCauses.push({
             cause: "unsupported_rename",
             commitId: null,
@@ -578,6 +742,7 @@ export async function probeGitHistory(request, dependencies = {}) {
         inspectedCommitIds: Object.freeze(inspectedCommitIds),
         snapshots: Object.freeze(snapshots),
         availability: allCauses,
+        provenance,
     };
 }
 function historicalLimits(overrides) {