@evo-dev/core 0.0.1-alpha.2 → 0.0.1-alpha.20

package/src/runtime-logs/index.ts

@@ -1,7 +1,8 @@
-import { createHash } from "node:crypto";
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
 import { appendFile, mkdir } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative } from "node:path";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { resolveEvoDevPaths } from "../config/paths.ts";
+import { normalizeTimestamp, sha256Short } from "../utils/index.ts";
 
 export type EvoDevLogPhase = "started" | "completed" | "failed";
 export type EvoDevDebugLogLevel = "verbose" | "debug" | "info" | "warn" | "error";
@@ -109,6 +110,15 @@ export interface TraceLogTeamContext {
   projectKey: string;
 }
 
+export interface ProjectLogIdentity {
+  projectKey: string;
+  workspaceKey: string;
+  projectRoot: string;
+  workspaceRoot: string;
+  gitCommonDir: string | null;
+  linkedWorktree: boolean;
+}
+
 export interface CliLogInput {
   phase: EvoDevLogPhase;
   argv: string[];
@@ -538,6 +548,39 @@ export function resolveTraceTeamContext(input: {
 }
 
 export function resolveProjectLogKey(homeDir: string, repoRoot: string): string {
+  return resolveProjectLogIdentity(homeDir, repoRoot).projectKey;
+}
+
+export function resolveProjectLogIdentity(homeDir: string, repoRoot: string): ProjectLogIdentity {
+  const identityHomeDir = realpathDirectoryOrFallback(homeDir);
+  const workspaceRoot = realpathDirectoryOrFallback(repoRoot);
+  const workspaceKey = resolvePathProjectLogKey(identityHomeDir, workspaceRoot);
+  const gitCommonDir = resolveGitCommonDir(workspaceRoot);
+  if (gitCommonDir === null) {
+    return {
+      projectKey: workspaceKey,
+      workspaceKey,
+      projectRoot: workspaceRoot,
+      workspaceRoot,
+      gitCommonDir: null,
+      linkedWorktree: false,
+    };
+  }
+
+  const commonDirOwnsWorktree = basename(gitCommonDir) === ".git";
+  const projectIdentityPath = commonDirOwnsWorktree ? dirname(gitCommonDir) : gitCommonDir;
+  const projectRoot = commonDirOwnsWorktree ? projectIdentityPath : workspaceRoot;
+  return {
+    projectKey: resolvePathProjectLogKey(identityHomeDir, projectIdentityPath),
+    workspaceKey,
+    projectRoot,
+    workspaceRoot,
+    gitCommonDir,
+    linkedWorktree: workspaceKey !== resolvePathProjectLogKey(identityHomeDir, projectIdentityPath),
+  };
+}
+
+export function resolvePathProjectLogKey(homeDir: string, repoRoot: string): string {
   const trimmedHome = stripTrailingSlash(homeDir);
   const trimmedRepo = stripTrailingSlash(repoRoot);
   const relativePath = relative(trimmedHome, trimmedRepo);
@@ -554,12 +597,64 @@ export function resolveProjectLogKey(homeDir: string, repoRoot: string): string
   return sanitizePersistentIdentifier(projectKey, "project");
 }
 
+function realpathDirectoryOrFallback(path: string): string {
+  try {
+    return realpathSync(path);
+  } catch {
+    if (!isAbsolute(path)) return stripTrailingSlash(path);
+    const missingSegments: string[] = [];
+    let current = stripTrailingSlash(path);
+    for (;;) {
+      const parent = dirname(current);
+      if (parent === current) return stripTrailingSlash(path);
+      missingSegments.unshift(basename(current));
+      current = parent;
+      try {
+        return join(realpathSync(current), ...missingSegments);
+      } catch {
+        // Continue toward the nearest existing ancestor so deleted worktrees
+        // retain the same path identity across symlinked filesystem prefixes.
+      }
+    }
+  }
+}
+
+function resolveGitCommonDir(workspaceRoot: string): string | null {
+  const markerPath = join(workspaceRoot, ".git");
+  let gitDir: string;
+  try {
+    const marker = lstatSync(markerPath);
+    if (marker.isDirectory()) {
+      gitDir = realpathSync(markerPath);
+    } else if (marker.isFile()) {
+      const value = readFileSync(markerPath, "utf8").trim();
+      const match = value.match(/^gitdir:\s*(.+)$/u);
+      if (match?.[1] === undefined || match[1].includes("\0")) return null;
+      gitDir = realpathSync(isAbsolute(match[1]) ? match[1] : resolve(workspaceRoot, match[1]));
+    } else {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+
+  try {
+    const commonDirValue = readFileSync(join(gitDir, "commondir"), "utf8").trim();
+    if (commonDirValue === "" || commonDirValue.includes("\0")) return gitDir;
+    return realpathSync(
+      isAbsolute(commonDirValue) ? commonDirValue : resolve(gitDir, commonDirValue),
+    );
+  } catch {
+    return gitDir;
+  }
+}
+
 export function resolveTraceSessionKey(payload: unknown): string {
   const record = isRecord(payload) ? payload : {};
   const sessionId = optionalString(record.session_id ?? record.sessionId);
   const cwd = optionalString(record.cwd);
   const source = sessionId ?? cwd ?? "local";
-  return `session-${createHash("sha256").update(source).digest("hex").slice(0, 16)}`;
+  return `session-${sha256Short(source)}`;
 }
 
 function sanitizeTraceLogEntryForAppend(entry: TraceLogEntryV1): TraceLogEntryV1 {
@@ -644,12 +739,6 @@ async function appendJsonLine(path: string, value: unknown): Promise<void> {
   await appendFile(path, `${JSON.stringify(value)}\n`, "utf8");
 }
 
-function normalizeTimestamp(value?: Date | string): string {
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string" && value.trim() !== "") return new Date(value).toISOString();
-  return new Date().toISOString();
-}
-
 function formatLocalDateKey(timestamp: string): string {
   const date = new Date(timestamp);
   const year = date.getFullYear();
@@ -727,8 +816,7 @@ function createExecutionEventId(input: {
   summary: string;
   metadata: Record<string, EvoDevExecutionEventMetadataValue>;
 }): string {
-  const hash = createHash("sha256").update(JSON.stringify(input)).digest("hex").slice(0, 16);
-  return `exec-${hash}`;
+  return `exec-${sha256Short(JSON.stringify(input))}`;
 }
 
 function sanitizeDebugValue(value: unknown, depth = 0): unknown {
@@ -775,8 +863,7 @@ function sanitizePersistentIdentifier(value: string, prefix: string): string {
   if (!SENSITIVE_EVENT_TEXT_PATTERN.test(value) && !SENSITIVE_EVENT_TEXT_PATTERN.test(pathSafe)) {
     return pathSafe;
   }
-  const hash = createHash("sha256").update(value).digest("hex").slice(0, 16);
-  return `${prefix}-${hash}`;
+  return `${prefix}-${sha256Short(value)}`;
 }
 
 function stripTrailingSlash(path: string): string {