@mnemonik/shared 7.140.1 → 7.140.2

package/src/repositoryRoot.ts

@@ -1,4 +1,4 @@
-import { lstat, readFile } from 'node:fs/promises';
+import { lstat, readFile, realpath } from 'node:fs/promises';
 import { execFile } from 'node:child_process';
 import { homedir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
@@ -33,12 +33,6 @@ export type ProjectIdentityResolution =
   | (ResolvedBase & { kind: 'absent' })
   | (ResolvedBase & { kind: 'unknown_version'; version: unknown; path: string })
   | (ResolvedBase & { kind: 'malformed'; detail: string; path: string })
-  | (ResolvedBase & { kind: 'nested'; parentIdentity?: ProjectIdentityFile })
-  | (ResolvedBase & {
-      kind: 'conflict';
-      rootIdentity: ProjectIdentityFile;
-      nestedIdentity: ProjectIdentityFile;
-    })
   | { kind: 'git_unavailable'; detail: string };
 
 const GIT_TIMEOUT_MS = 2_000;
@@ -102,7 +96,7 @@ async function confirmedBoundaryAt(path: string): Promise<RepositoryBoundary | u
 async function boundariesBetween(cwd: string, root: string): Promise<RepositoryBoundary[]> {
   const boundaries: RepositoryBoundary[] = [];
   let directory = cwd;
-  while (directory !== root) {
+  while (!samePath(directory, root)) {
     const boundary = await confirmedBoundaryAt(directory);
     if (boundary) boundaries.push(boundary);
     const parent = dirname(directory);
@@ -123,37 +117,45 @@ async function containingRepository(root: string): Promise<RepositoryBoundary |
   }
 }
 
-async function canonicalBoundaryRoot(boundary: RepositoryBoundary): Promise<string> {
-  if (boundary.kind === 'directory') return boundary.path;
-  const pointer = /^gitdir:\s*(.+)\s*$/im.exec(
-    await readFile(join(boundary.path, '.git'), 'utf8')
-  )?.[1];
-  if (!pointer) return boundary.path;
-  const gitDir = resolve(boundary.path, pointer);
-  try {
-    const commonDir = resolve(gitDir, (await readFile(join(gitDir, 'commondir'), 'utf8')).trim());
-    return dirname(commonDir);
-  } catch (error) {
-    if ((error as NodeJS.ErrnoException).code === 'ENOENT') return boundary.path;
-    throw error;
-  }
+/**
+ * A path as the file system knows it, symlinks resolved, so it compares equal
+ * with the real paths of git's answers. A path that does not exist stays as given.
+ */
+async function canonicalPath(path: string): Promise<string> {
+  const absolute = resolve(path);
+  return realpath(absolute).catch(() => absolute);
+}
+
+/** Path equality; Windows paths compare without regard to case. */
+function samePath(left: string, right: string): boolean {
+  return process.platform === 'win32' ? left.toLowerCase() === right.toLowerCase() : left === right;
 }
 
 export async function resolveRepositoryRoot(cwd: string): Promise<RepositoryRootResult> {
-  const absoluteCwd = resolve(cwd);
+  const absoluteCwd = await canonicalPath(cwd);
   try {
     const { stdout } = await runGit(absoluteCwd, [
       'rev-parse',
       '--show-toplevel',
+      '--git-dir',
       '--git-common-dir',
     ]);
-    const [rootLine, commonLine, ...extra] = stdout.trim().split(/\r?\n/);
-    if (!rootLine || !commonLine || extra.length) {
+    const [rootLine, gitDirLine, commonLine, ...extra] = stdout.trim().split(/\r?\n/);
+    if (!rootLine || !gitDirLine || !commonLine || extra.length) {
       return { kind: 'git_unavailable', detail: 'git rev-parse returned an unexpected response' };
     }
-    const root = resolve(rootLine);
-    const commonDir = resolve(root, commonLine);
-    const isLinkedWorktree = commonDir !== join(root, '.git');
+    // git prints --git-dir and --git-common-dir relative to the directory it
+    // ran in (`../.git` from a subfolder) or absolute; every git version
+    // agrees on that. Real paths make them comparable with each other and
+    // with real paths from the file system.
+    const fromGit = (line: string) => canonicalPath(resolve(absoluteCwd, line));
+    const root = await fromGit(rootLine);
+    const gitDir = await fromGit(gitDirLine);
+    const commonDir = await fromGit(commonLine);
+    // Only a linked worktree keeps its own git directory apart from the common
+    // one. A submodule (`.git/modules/<name>`) and a `--separate-git-dir`
+    // checkout keep both in one place, wherever that is.
+    const isLinkedWorktree = !samePath(gitDir, commonDir);
     const nested = await boundariesBetween(absoluteCwd, root);
     if (!isLinkedWorktree && (await containingRepository(root))) {
       const boundary = await boundaryAt(root);
@@ -175,16 +177,56 @@ export async function resolveRepositoryRoot(cwd: string): Promise<RepositoryRoot
   }
 }
 
-async function readPlainIdentity(start: string): Promise<{
-  root: string;
-  result: Awaited<ReturnType<typeof readIdentityFile>>;
-}> {
-  const home = resolve(homedir());
+/**
+ * The common git directory when `dir` is the top of a linked worktree: its
+ * `.git` is a file pointing at a git directory that has a `commondir`. A
+ * submodule's `.git` file points at `.git/modules/<name>`, which has none.
+ * Read from the files git writes, so it holds without a git command.
+ */
+async function linkedWorktreeCommonDir(dir: string): Promise<string | undefined> {
+  try {
+    if (!(await lstat(join(dir, '.git'))).isFile()) return undefined;
+    const pointer = /^gitdir:\s*(.+?)\s*$/im.exec(await readFile(join(dir, '.git'), 'utf8'))?.[1];
+    if (!pointer) return undefined;
+    const gitDir = resolve(dir, pointer);
+    const common = (await readFile(join(gitDir, 'commondir'), 'utf8')).trim();
+    return common ? await canonicalPath(resolve(gitDir, common)) : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * The project folder of a linked worktree's main checkout: the first entry of
+ * `git worktree list --porcelain`. When that entry is a bare repository
+ * (`proj/.bare` with worktrees beside it), the project folder is the folder
+ * holding it, never the git directory itself. Without git, the folder holding
+ * the common git directory, which is the same answer for both layouts.
+ */
+async function mainCheckout(worktreeTop: string, commonDir: string): Promise<string> {
+  try {
+    const { stdout } = await runGit(worktreeTop, ['worktree', 'list', '--porcelain']);
+    const first = stdout.split(/\r?\n\r?\n/)[0] ?? '';
+    const path = /^worktree (.+)$/m.exec(first)?.[1];
+    if (path) {
+      const main = await canonicalPath(resolve(worktreeTop, path));
+      return /^bare$/m.test(first) ? dirname(main) : main;
+    }
+  } catch {
+    /* fall through */
+  }
+  return dirname(commonDir);
+}
+
+type FoundIdentity = { root: string; result: Awaited<ReturnType<typeof readIdentityFile>> };
+
+async function readPlainIdentity(start: string): Promise<FoundIdentity> {
+  const home = await canonicalPath(homedir());
   let directory = start;
   while (true) {
-    const result = await readIdentityFile(directory);
+    const result = await readIdentityFile(directory, { configurationOnlyAbsent: true });
     if (result.kind !== 'absent') return { root: directory, result };
-    if (directory === home) break;
+    if (samePath(directory, home)) break;
     const parent = dirname(directory);
     if (parent === directory) break;
     directory = parent;
@@ -192,6 +234,105 @@ async function readPlainIdentity(start: string): Promise<{
   return { root: start, result: { kind: 'absent' } };
 }
 
+/**
+ * Walk up from `start` to the nearest identity file, stopping at the home
+ * folder (whose own file still counts). A configuration-only file (no
+ * `projectId`) is not an identity and the walk passes it. Reaching the top of a linked worktree
+ * first ends the walk there: the worktree belongs to its main checkout, and
+ * the copy of the identity file at its top does not count.
+ */
+async function nearestIdentity(
+  start: string
+): Promise<FoundIdentity | { worktreeTop: string; commonDir: string } | undefined> {
+  const home = await canonicalPath(homedir());
+  let directory = start;
+  while (true) {
+    const commonDir = await linkedWorktreeCommonDir(directory);
+    if (commonDir) return { worktreeTop: directory, commonDir };
+    const result = await readIdentityFile(directory, { configurationOnlyAbsent: true });
+    if (result.kind !== 'absent') return { root: directory, result };
+    if (samePath(directory, home)) return undefined;
+    const parent = dirname(directory);
+    if (parent === directory) return undefined;
+    directory = parent;
+  }
+}
+
+/**
+ * The project a working folder belongs to: the nearest `.mnemonik.json` above
+ * it. Git repositories are not project boundaries; a clone, submodule,
+ * subsystem or subproject inside a project belongs to that project unless it
+ * has its own identity file. Git has one part in identity: a linked worktree
+ * (and anything inside it without an identity file of its own below the
+ * worktree's top, nested clones and submodules included) belongs to the
+ * project of its main checkout; the worktree's own top-level copy of the
+ * identity file does not count.
+ */
+export async function resolveNearestProjectIdentity(
+  cwd: string
+): Promise<ProjectIdentityResolution> {
+  const start = await canonicalPath(cwd);
+  const resolved = await resolveRepositoryRoot(start);
+  const repository: ResolvedRepository =
+    resolved.kind === 'git_unavailable' ? { kind: 'plain', root: start } : resolved;
+  const nested = repository.kind === 'git' ? repository.nested : [];
+
+  let found = await nearestIdentity(start);
+  if (found && 'worktreeTop' in found) {
+    found = await readPlainIdentity(await mainCheckout(found.worktreeTop, found.commonDir));
+  }
+  if (found) {
+    return shapedIdentity(found, await projectFolderRepository(found.root, repository), nested);
+  }
+  return { ...withBase(repository, repository.root, nested), kind: 'absent' };
+}
+
+/**
+ * The identity of exactly the folder named, for commands that create or link
+ * a project there on purpose, even inside another project. The top of a
+ * linked worktree stands for its main checkout.
+ */
+async function resolveNamedProjectIdentity(
+  cwd: string,
+  options: { selectedRoot?: boolean }
+): Promise<ProjectIdentityResolution> {
+  const start = await canonicalPath(cwd);
+  const resolved = await resolveRepositoryRoot(start);
+  const repository: ResolvedRepository =
+    resolved.kind === 'git_unavailable' ? { kind: 'plain', root: start } : resolved;
+  const commonDir = await linkedWorktreeCommonDir(start);
+  const root = commonDir ? await mainCheckout(start, commonDir) : start;
+  return shapedIdentity(
+    { root, result: await readIdentityFile(root, options) },
+    await projectFolderRepository(root, repository),
+    repository.kind === 'git' ? repository.nested : []
+  );
+}
+
+function shapedIdentity(
+  found: FoundIdentity,
+  repository: ResolvedRepository,
+  nested: RepositoryBoundary[]
+): ProjectIdentityResolution {
+  const base = withBase(repository, found.root, nested);
+  if (found.result.kind === 'ok') return { ...base, ...found.result };
+  if (found.result.kind === 'unknown_version')
+    return { ...base, ...found.result, path: found.root };
+  if (found.result.kind === 'malformed') return { ...base, ...found.result, path: found.root };
+  return { ...base, kind: 'absent' };
+}
+
+/** The project folder counts as a git repository only when it is the repository's top. */
+async function projectFolderRepository(
+  projectRoot: string,
+  known: ResolvedRepository
+): Promise<ResolvedRepository> {
+  if (known.kind === 'git' && samePath(known.root, projectRoot)) return known;
+  const repository = await resolveRepositoryRoot(projectRoot);
+  if (repository.kind === 'git' && samePath(repository.root, projectRoot)) return repository;
+  return { kind: 'plain', root: projectRoot };
+}
+
 function withBase(
   repository: ResolvedRepository,
   root: string,
@@ -200,55 +341,20 @@ function withBase(
   return { root, repository, nested };
 }
 
+/**
+ * Which project a folder is in. By default this is the rule every reader
+ * shares with the hooks (resolveNearestProjectIdentity). `namedRoot` and
+ * `selectedRoot` read exactly the folder given instead, for commands that make
+ * that folder a project on purpose; `selectedRoot` (folders ticked during
+ * install) also treats a configuration-only file as no identity, as the
+ * nearest-file walk always does.
+ */
 export async function resolveProjectIdentity(
   cwd: string,
-  options: { allowNestedInherit?: boolean; selectedRoot?: boolean } = {}
+  options: { selectedRoot?: boolean; namedRoot?: boolean } = {}
 ): Promise<ProjectIdentityResolution> {
-  const resolved = await resolveRepositoryRoot(cwd);
-  // Git is optional. When the git command cannot answer, the folder is still a folder.
-  const repository: ResolvedRepository =
-    resolved.kind === 'git_unavailable' ? { kind: 'plain', root: resolve(cwd) } : resolved;
-
-  if (repository.kind === 'plain') {
-    const { root, result } = options.selectedRoot
-      ? { root: repository.root, result: await readIdentityFile(repository.root, options) }
-      : await readPlainIdentity(repository.root);
-    const base = withBase(repository, root, []);
-    if (result.kind === 'ok') return { ...base, ...result };
-    if (result.kind === 'unknown_version') return { ...base, ...result, path: root };
-    if (result.kind === 'malformed') return { ...base, ...result, path: root };
-    return { ...base, kind: 'absent' };
-  }
-
-  const ownRoot = repository.isLinkedWorktree ? dirname(repository.commonDir) : repository.root;
-  const outer = repository.isLinkedWorktree
-    ? undefined
-    : await containingRepository(repository.root);
-  const own = await readIdentityFile(ownRoot, options);
-  if (!outer || options.selectedRoot || own.kind === 'ok') {
-    const base = withBase(repository, ownRoot, repository.nested);
-    if (own.kind === 'ok') return { ...base, ...own };
-    if (own.kind === 'unknown_version') return { ...base, ...own, path: ownRoot };
-    if (own.kind === 'malformed') return { ...base, ...own, path: ownRoot };
-    return { ...base, kind: 'absent' };
+  if (options.selectedRoot || options.namedRoot) {
+    return resolveNamedProjectIdentity(cwd, { selectedRoot: options.selectedRoot });
   }
-
-  const nested = repository.nested;
-  const parentRoot = await canonicalBoundaryRoot(outer);
-  const parent = await readIdentityFile(parentRoot);
-  const base = withBase(repository, parentRoot, nested);
-
-  if (own.kind === 'unknown_version') return { ...base, ...own, path: ownRoot };
-  if (own.kind === 'malformed') return { ...base, ...own, path: ownRoot };
-  if (parent.kind === 'unknown_version') return { ...base, ...parent, path: parentRoot };
-  if (parent.kind === 'malformed') return { ...base, ...parent, path: parentRoot };
-  if (!options.allowNestedInherit) {
-    return {
-      ...base,
-      kind: 'nested',
-      ...(parent.kind === 'ok' ? { parentIdentity: parent.identity } : {}),
-    };
-  }
-  if (parent.kind === 'ok') return { ...base, kind: 'ok', identity: parent.identity };
-  return { ...base, kind: 'absent' };
+  return resolveNearestProjectIdentity(cwd);
 }

package/test-fixtures/identity/runner.d.mts

@@ -2,7 +2,7 @@ export interface IdentityFixtureAdapter {
   parse(text: string): unknown;
   read(dir: string): Promise<unknown>;
   resolveRoot(cwd: string): Promise<unknown>;
-  resolve(cwd: string, options?: { allowNestedInherit?: boolean }): Promise<unknown>;
+  resolve(cwd: string, options?: { namedRoot?: boolean }): Promise<unknown>;
   find?(cwd: string): Promise<unknown>;
 }