@evo-dev/core 0.0.1-alpha.13 → 0.0.1-alpha.15

package/src/projects/index.ts

@@ -1,7 +1,7 @@
 import { lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, parse } from "node:path";
 import { resolveEvoDevPaths } from "../config/paths.ts";
-import { resolveProjectLogKey } from "../runtime-logs/index.ts";
+import { resolvePathProjectLogKey, resolveProjectLogIdentity } from "../runtime-logs/index.ts";
 import {
   isFileExistsError,
   isNotFoundError,
@@ -16,9 +16,13 @@ export type ProjectDiscoveryTarget = "claude" | "codex";
 
 export interface ResolvedProjectWorkspace {
   projectKey: string;
+  workspaceKey: string;
   displayName: string;
+  projectRoot: string;
   workspaceRoot: string;
   workspaceKind: ProjectWorkspaceKind;
+  gitCommonDir: string | null;
+  linkedWorktree: boolean;
   cwd: string;
 }
 
@@ -51,6 +55,40 @@ export interface RegisteredProjectRecordV1 {
   sourceContentStored: false;
 }
 
+export interface ProjectWorkspaceRecordV1 {
+  schemaVersion: 1;
+  kind: "project-workspace";
+  workspaceKey: string;
+  projectKey: string;
+  displayName: string;
+  workspaceRoot: string;
+  workspaceKind: ProjectWorkspaceKind;
+  gitCommonDir: string | null;
+  sourceTargets: ProjectDiscoveryTarget[];
+  firstSeenAt: string;
+  lastSeenAt: string;
+  localOnly: true;
+  sourceContentStored: false;
+}
+
+export interface ProjectWorkspaceSummary extends ProjectWorkspaceRecordV1 {
+  available: boolean;
+}
+
+export interface ProjectAliasRecordV1 {
+  schemaVersion: 1;
+  kind: "project-alias";
+  aliasProjectKey: string;
+  canonicalProjectKey: string;
+  workspaceRoot: string;
+  createdAt: string;
+  updatedAt: string;
+  localOnly: true;
+  sourceContentStored: false;
+}
+
+export type ProjectAliasMap = Record<string, string>;
+
 export class ProjectRegistrationError extends Error {
   readonly code: "invalid" | "not-found" | "conflict";
 
@@ -64,17 +102,27 @@ export class ProjectRegistrationError extends Error {
 export function resolveProjectRegistryPaths(homeDir: string): {
   discoveredDir: string;
   registeredDir: string;
+  workspaceDir: string;
+  aliasDir: string;
   discoveredPath: (projectKey: string) => string;
   registeredPath: (projectKey: string) => string;
+  workspacePath: (workspaceKey: string) => string;
+  aliasPath: (aliasProjectKey: string) => string;
 } {
   const paths = resolveEvoDevPaths(homeDir);
   const discoveredDir = join(paths.stateDir, "projects", "discovered");
   const registeredDir = join(paths.rootDir, "projects");
+  const workspaceDir = join(paths.stateDir, "projects", "workspaces");
+  const aliasDir = join(paths.stateDir, "projects", "aliases");
   return {
     discoveredDir,
     registeredDir,
+    workspaceDir,
+    aliasDir,
     discoveredPath: (projectKey) => join(discoveredDir, `${projectKey}.json`),
     registeredPath: (projectKey) => join(registeredDir, projectKey, "workspace.json"),
+    workspacePath: (workspaceKey) => join(workspaceDir, `${workspaceKey}.json`),
+    aliasPath: (aliasProjectKey) => join(aliasDir, `${aliasProjectKey}.json`),
   };
 }
 
@@ -96,11 +144,16 @@ export async function resolveProjectWorkspaceFromCwd(input: {
 
   const gitRoot = await findNearestGitRoot(cwd);
   const workspaceRoot = gitRoot ?? cwd;
+  const identity = resolveProjectLogIdentity(input.homeDir, workspaceRoot);
   return {
-    projectKey: sanitizeStorageId(resolveProjectLogKey(input.homeDir, workspaceRoot), "project"),
-    displayName: basename(workspaceRoot) || parse(workspaceRoot).root,
+    projectKey: sanitizeStorageId(identity.projectKey, "project"),
+    workspaceKey: sanitizeStorageId(identity.workspaceKey, "workspace"),
+    displayName: basename(identity.projectRoot) || parse(identity.projectRoot).root,
+    projectRoot: identity.projectRoot,
     workspaceRoot,
     workspaceKind: gitRoot === null ? "directory" : "git",
+    gitCommonDir: identity.gitCommonDir,
+    linkedWorktree: identity.linkedWorktree,
     cwd,
   };
 }
@@ -119,12 +172,27 @@ export async function recordDiscoveredProject(input: {
   const paths = resolveProjectRegistryPaths(input.homeDir);
   const path = paths.discoveredPath(workspace.projectKey);
   const existing = await readDiscoveredProject(path);
+  await writeProjectWorkspaceRecord({
+    paths,
+    workspace,
+    target: input.target,
+    now,
+  });
+  if (workspace.workspaceKey !== workspace.projectKey) {
+    await writeProjectAliasRecord({
+      paths,
+      aliasProjectKey: workspace.workspaceKey,
+      canonicalProjectKey: workspace.projectKey,
+      workspaceRoot: workspace.workspaceRoot,
+      now,
+    });
+  }
   const record: DiscoveredProjectRecordV1 = {
     schemaVersion: 1,
     kind: "discovered-project",
     projectKey: workspace.projectKey,
     displayName: workspace.displayName,
-    workspaceRoot: workspace.workspaceRoot,
+    workspaceRoot: workspace.projectRoot,
     lastCwd: workspace.cwd,
     workspaceKind: workspace.workspaceKind,
     sourceTargets: mergeTargets(existing?.sourceTargets ?? [], [input.target]),
@@ -143,10 +211,16 @@ export async function listDiscoveredProjects(input: {
 }): Promise<DiscoveredProjectRecordV1[]> {
   const paths = resolveProjectRegistryPaths(input.homeDir);
   const records = new Map<string, DiscoveredProjectRecordV1>();
+  const aliases = await listProjectAliases(input);
 
   for (const path of await listJsonFilePaths(paths.discoveredDir)) {
     const record = await readDiscoveredProject(path);
-    if (record !== null) mergeDiscoveredRecord(records, record);
+    if (record !== null) {
+      mergeDiscoveredRecord(
+        records,
+        await canonicalizeDiscoveredRecord(input.homeDir, record, aliases),
+      );
+    }
   }
 
   for (const binding of await listLegacyHookBindings(input.homeDir)) {
@@ -161,7 +235,7 @@ export async function listDiscoveredProjects(input: {
       kind: "discovered-project",
       projectKey: workspace.projectKey,
       displayName: workspace.displayName,
-      workspaceRoot: workspace.workspaceRoot,
+      workspaceRoot: workspace.projectRoot,
       lastCwd: workspace.cwd,
       workspaceKind: workspace.workspaceKind,
       sourceTargets: [binding.target],
@@ -184,18 +258,125 @@ export async function listRegisteredProjects(input: {
   homeDir: string;
 }): Promise<RegisteredProjectRecordV1[]> {
   const { registeredDir } = resolveProjectRegistryPaths(input.homeDir);
-  const records: RegisteredProjectRecordV1[] = [];
+  const aliases = await listProjectAliases(input);
+  const records = new Map<string, RegisteredProjectRecordV1>();
   for (const projectKey of await listDirectoryNames(registeredDir)) {
     const record = await readRegisteredProject(join(registeredDir, projectKey, "workspace.json"));
-    if (record !== null && record.projectKey === projectKey) records.push(record);
+    if (record === null || record.projectKey !== projectKey) continue;
+    mergeRegisteredRecord(
+      records,
+      await canonicalizeRegisteredRecord(input.homeDir, record, aliases),
+    );
   }
-  return records.sort(
+  return [...records.values()].sort(
     (left, right) =>
       right.lastSeenAt.localeCompare(left.lastSeenAt) ||
       left.projectKey.localeCompare(right.projectKey),
   );
 }
 
+export async function listProjectAliases(input: {
+  homeDir: string;
+}): Promise<ProjectAliasMap> {
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const aliases: ProjectAliasMap = {};
+  for (const path of await listJsonFilePaths(paths.aliasDir)) {
+    const record = await readProjectAlias(path);
+    if (record !== null) aliases[record.aliasProjectKey] = record.canonicalProjectKey;
+  }
+
+  for (const path of await listJsonFilePaths(paths.discoveredDir)) {
+    const record = await readDiscoveredProject(path);
+    if (record !== null) {
+      await collectAvailableProjectAlias(input.homeDir, record, aliases);
+    }
+  }
+  for (const projectKey of await listDirectoryNames(paths.registeredDir)) {
+    const record = await readRegisteredProject(
+      join(paths.registeredDir, projectKey, "workspace.json"),
+    );
+    if (record !== null) {
+      await collectAvailableProjectAlias(input.homeDir, record, aliases);
+    }
+  }
+  return normalizeProjectAliases(aliases);
+}
+
+export function canonicalizeProjectKey(projectKey: string, aliases: ProjectAliasMap): string {
+  let current = projectKey;
+  const seen = new Set<string>();
+  while (!seen.has(current)) {
+    seen.add(current);
+    const next = aliases[current];
+    if (next === undefined || next === current) return current;
+    current = next;
+  }
+  return projectKey;
+}
+
+export async function listEquivalentProjectKeys(input: {
+  homeDir: string;
+  projectKey: string;
+}): Promise<string[]> {
+  const aliases = await listProjectAliases({ homeDir: input.homeDir });
+  const canonical = canonicalizeProjectKey(input.projectKey, aliases);
+  return [
+    ...new Set([
+      canonical,
+      input.projectKey,
+      ...Object.keys(aliases).filter(
+        (alias) => canonicalizeProjectKey(alias, aliases) === canonical,
+      ),
+    ]),
+  ].sort();
+}
+
+export async function listProjectWorkspaces(input: {
+  homeDir: string;
+}): Promise<ProjectWorkspaceSummary[]> {
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const aliases = await listProjectAliases(input);
+  const records = new Map<string, ProjectWorkspaceSummary>();
+
+  for (const path of await listJsonFilePaths(paths.workspaceDir)) {
+    const record = await readProjectWorkspace(path);
+    if (record !== null) {
+      mergeProjectWorkspaceSummary(
+        records,
+        await summarizeProjectWorkspace(input.homeDir, record, aliases),
+      );
+    }
+  }
+  for (const path of await listJsonFilePaths(paths.discoveredDir)) {
+    const record = await readDiscoveredProject(path);
+    if (record !== null) {
+      mergeProjectWorkspaceSummary(
+        records,
+        await summarizeLegacyWorkspace(input.homeDir, record, aliases),
+      );
+    }
+  }
+  for (const projectKey of await listDirectoryNames(paths.registeredDir)) {
+    const record = await readRegisteredProject(
+      join(paths.registeredDir, projectKey, "workspace.json"),
+    );
+    if (record !== null) {
+      mergeProjectWorkspaceSummary(
+        records,
+        await summarizeLegacyWorkspace(input.homeDir, record, aliases),
+      );
+    }
+  }
+
+  return [...records.values()].sort(
+    (left, right) =>
+      left.projectKey.localeCompare(right.projectKey) ||
+      Number(right.available) - Number(left.available) ||
+      right.lastSeenAt.localeCompare(left.lastSeenAt) ||
+      left.workspaceKey.localeCompare(right.workspaceKey),
+  );
+}
+
 export async function registerDiscoveredProject(input: {
   homeDir: string;
   projectKey: string;
@@ -240,6 +421,229 @@ export async function registerDiscoveredProject(input: {
   }
 }
 
+async function writeProjectWorkspaceRecord(input: {
+  paths: ReturnType<typeof resolveProjectRegistryPaths>;
+  workspace: ResolvedProjectWorkspace;
+  target: ProjectDiscoveryTarget;
+  now: string;
+}): Promise<void> {
+  const path = input.paths.workspacePath(input.workspace.workspaceKey);
+  const existing = await readProjectWorkspace(path);
+  const record: ProjectWorkspaceRecordV1 = {
+    schemaVersion: 1,
+    kind: "project-workspace",
+    workspaceKey: input.workspace.workspaceKey,
+    projectKey: input.workspace.projectKey,
+    displayName:
+      basename(input.workspace.workspaceRoot) || parse(input.workspace.workspaceRoot).root,
+    workspaceRoot: input.workspace.workspaceRoot,
+    workspaceKind: input.workspace.workspaceKind,
+    gitCommonDir: input.workspace.gitCommonDir,
+    sourceTargets: mergeTargets(existing?.sourceTargets ?? [], [input.target]),
+    firstSeenAt: existing?.firstSeenAt ?? input.now,
+    lastSeenAt: input.now,
+    localOnly: true,
+    sourceContentStored: false,
+  };
+  await writeJsonFile(path, record);
+}
+
+async function writeProjectAliasRecord(input: {
+  paths: ReturnType<typeof resolveProjectRegistryPaths>;
+  aliasProjectKey: string;
+  canonicalProjectKey: string;
+  workspaceRoot: string;
+  now: string;
+}): Promise<void> {
+  const path = input.paths.aliasPath(input.aliasProjectKey);
+  const existing = await readProjectAlias(path);
+  const record: ProjectAliasRecordV1 = {
+    schemaVersion: 1,
+    kind: "project-alias",
+    aliasProjectKey: input.aliasProjectKey,
+    canonicalProjectKey: input.canonicalProjectKey,
+    workspaceRoot: input.workspaceRoot,
+    createdAt: existing?.createdAt ?? input.now,
+    updatedAt: input.now,
+    localOnly: true,
+    sourceContentStored: false,
+  };
+  await writeJsonFile(path, record);
+}
+
+async function canonicalizeDiscoveredRecord(
+  homeDir: string,
+  record: DiscoveredProjectRecordV1,
+  aliases: ProjectAliasMap,
+): Promise<DiscoveredProjectRecordV1> {
+  const workspace = await resolveProjectWorkspaceFromCwd({
+    homeDir,
+    cwd: record.workspaceRoot,
+  }).catch(() => null);
+  if (workspace === null) {
+    return {
+      ...record,
+      projectKey: canonicalizeProjectKey(record.projectKey, aliases),
+    };
+  }
+  return {
+    ...record,
+    projectKey: workspace.projectKey,
+    displayName: workspace.displayName,
+    workspaceRoot: workspace.projectRoot,
+    workspaceKind: workspace.workspaceKind,
+  };
+}
+
+async function canonicalizeRegisteredRecord(
+  homeDir: string,
+  record: RegisteredProjectRecordV1,
+  aliases: ProjectAliasMap,
+): Promise<RegisteredProjectRecordV1> {
+  const workspace = await resolveProjectWorkspaceFromCwd({
+    homeDir,
+    cwd: record.workspaceRoot,
+  }).catch(() => null);
+  if (workspace === null) {
+    return {
+      ...record,
+      projectKey: canonicalizeProjectKey(record.projectKey, aliases),
+    };
+  }
+  return {
+    ...record,
+    projectKey: workspace.projectKey,
+    displayName: workspace.displayName,
+    workspaceRoot: workspace.projectRoot,
+    workspaceKind: workspace.workspaceKind,
+  };
+}
+
+async function collectAvailableProjectAlias(
+  homeDir: string,
+  record: Pick<DiscoveredProjectRecordV1, "projectKey" | "workspaceRoot">,
+  aliases: ProjectAliasMap,
+): Promise<void> {
+  const workspace = await resolveProjectWorkspaceFromCwd({
+    homeDir,
+    cwd: record.workspaceRoot,
+  }).catch(() => null);
+  if (workspace === null) return;
+  if (record.projectKey !== workspace.projectKey) {
+    aliases[record.projectKey] = workspace.projectKey;
+  }
+  if (workspace.workspaceKey !== workspace.projectKey) {
+    aliases[workspace.workspaceKey] = workspace.projectKey;
+  }
+}
+
+function normalizeProjectAliases(aliases: ProjectAliasMap): ProjectAliasMap {
+  return Object.fromEntries(
+    Object.keys(aliases)
+      .sort()
+      .flatMap((alias) => {
+        const canonical = canonicalizeProjectKey(alias, aliases);
+        return canonical === alias ? [] : [[alias, canonical]];
+      }),
+  );
+}
+
+async function summarizeProjectWorkspace(
+  homeDir: string,
+  record: ProjectWorkspaceRecordV1,
+  aliases: ProjectAliasMap,
+): Promise<ProjectWorkspaceSummary> {
+  const workspace = await resolveProjectWorkspaceFromCwd({
+    homeDir,
+    cwd: record.workspaceRoot,
+  }).catch(() => null);
+  if (workspace === null) {
+    return {
+      ...record,
+      projectKey: canonicalizeProjectKey(record.projectKey, aliases),
+      available: false,
+    };
+  }
+  return {
+    ...record,
+    workspaceKey: workspace.workspaceKey,
+    projectKey: workspace.projectKey,
+    displayName: basename(workspace.workspaceRoot) || parse(workspace.workspaceRoot).root,
+    workspaceRoot: workspace.workspaceRoot,
+    workspaceKind: workspace.workspaceKind,
+    gitCommonDir: workspace.gitCommonDir,
+    available: true,
+  };
+}
+
+async function summarizeLegacyWorkspace(
+  homeDir: string,
+  record: DiscoveredProjectRecordV1 | RegisteredProjectRecordV1,
+  aliases: ProjectAliasMap,
+): Promise<ProjectWorkspaceSummary> {
+  const workspace = await resolveProjectWorkspaceFromCwd({
+    homeDir,
+    cwd: record.workspaceRoot,
+  }).catch(() => null);
+  const sourceTargets = record.kind === "discovered-project" ? record.sourceTargets : [];
+  const firstSeenAt =
+    record.kind === "discovered-project" ? record.firstSeenAt : record.registeredAt;
+  if (workspace === null) {
+    return {
+      schemaVersion: 1,
+      kind: "project-workspace",
+      workspaceKey: resolvePathProjectLogKey(homeDir, record.workspaceRoot),
+      projectKey: canonicalizeProjectKey(record.projectKey, aliases),
+      displayName: record.displayName,
+      workspaceRoot: record.workspaceRoot,
+      workspaceKind: record.workspaceKind,
+      gitCommonDir: null,
+      sourceTargets,
+      firstSeenAt,
+      lastSeenAt: record.lastSeenAt,
+      localOnly: true,
+      sourceContentStored: false,
+      available: false,
+    };
+  }
+  return {
+    schemaVersion: 1,
+    kind: "project-workspace",
+    workspaceKey: workspace.workspaceKey,
+    projectKey: workspace.projectKey,
+    displayName: basename(workspace.workspaceRoot) || parse(workspace.workspaceRoot).root,
+    workspaceRoot: workspace.workspaceRoot,
+    workspaceKind: workspace.workspaceKind,
+    gitCommonDir: workspace.gitCommonDir,
+    sourceTargets,
+    firstSeenAt,
+    lastSeenAt: record.lastSeenAt,
+    localOnly: true,
+    sourceContentStored: false,
+    available: true,
+  };
+}
+
+function mergeProjectWorkspaceSummary(
+  records: Map<string, ProjectWorkspaceSummary>,
+  next: ProjectWorkspaceSummary,
+): void {
+  const previous = records.get(next.workspaceKey);
+  if (previous === undefined) {
+    records.set(next.workspaceKey, next);
+    return;
+  }
+  const newer = next.lastSeenAt >= previous.lastSeenAt ? next : previous;
+  records.set(next.workspaceKey, {
+    ...newer,
+    projectKey: next.projectKey,
+    available: previous.available || next.available,
+    sourceTargets: mergeTargets(previous.sourceTargets, next.sourceTargets),
+    firstSeenAt: previous.firstSeenAt <= next.firstSeenAt ? previous.firstSeenAt : next.firstSeenAt,
+    lastSeenAt: previous.lastSeenAt >= next.lastSeenAt ? previous.lastSeenAt : next.lastSeenAt,
+  });
+}
+
 async function findNearestGitRoot(cwd: string): Promise<string | null> {
   let current = cwd;
   for (;;) {
@@ -273,6 +677,24 @@ async function readRegisteredProject(path: string): Promise<RegisteredProjectRec
   }
 }
 
+async function readProjectWorkspace(path: string): Promise<ProjectWorkspaceRecordV1 | null> {
+  try {
+    return parseProjectWorkspace(JSON.parse(await readFile(path, "utf8")) as unknown);
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError) return null;
+    throw error;
+  }
+}
+
+async function readProjectAlias(path: string): Promise<ProjectAliasRecordV1 | null> {
+  try {
+    return parseProjectAlias(JSON.parse(await readFile(path, "utf8")) as unknown);
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError) return null;
+    throw error;
+  }
+}
+
 function parseDiscoveredProject(value: unknown): DiscoveredProjectRecordV1 {
   const record = requireRecord(value);
   if (
@@ -314,6 +736,47 @@ function parseRegisteredProject(value: unknown): RegisteredProjectRecordV1 {
   return record as unknown as RegisteredProjectRecordV1;
 }
 
+function parseProjectWorkspace(value: unknown): ProjectWorkspaceRecordV1 {
+  const record = requireRecord(value);
+  if (
+    record.schemaVersion !== 1 ||
+    record.kind !== "project-workspace" ||
+    !isProjectKey(record.workspaceKey) ||
+    !isProjectKey(record.projectKey) ||
+    !isNonEmptyString(record.displayName) ||
+    !isAbsoluteString(record.workspaceRoot) ||
+    !isWorkspaceKind(record.workspaceKind) ||
+    !(record.gitCommonDir === null || isAbsoluteString(record.gitCommonDir)) ||
+    !isDiscoveryTargetArray(record.sourceTargets) ||
+    !isNonEmptyString(record.firstSeenAt) ||
+    !isNonEmptyString(record.lastSeenAt) ||
+    record.localOnly !== true ||
+    record.sourceContentStored !== false
+  ) {
+    throw new ProjectRegistrationError("invalid", "Project workspace record is invalid.");
+  }
+  return record as unknown as ProjectWorkspaceRecordV1;
+}
+
+function parseProjectAlias(value: unknown): ProjectAliasRecordV1 {
+  const record = requireRecord(value);
+  if (
+    record.schemaVersion !== 1 ||
+    record.kind !== "project-alias" ||
+    !isProjectKey(record.aliasProjectKey) ||
+    !isProjectKey(record.canonicalProjectKey) ||
+    record.aliasProjectKey === record.canonicalProjectKey ||
+    !isAbsoluteString(record.workspaceRoot) ||
+    !isNonEmptyString(record.createdAt) ||
+    !isNonEmptyString(record.updatedAt) ||
+    record.localOnly !== true ||
+    record.sourceContentStored !== false
+  ) {
+    throw new ProjectRegistrationError("invalid", "Project alias record is invalid.");
+  }
+  return record as unknown as ProjectAliasRecordV1;
+}
+
 function mergeDiscoveredRecord(
   records: Map<string, DiscoveredProjectRecordV1>,
   next: DiscoveredProjectRecordV1,
@@ -332,6 +795,24 @@ function mergeDiscoveredRecord(
   });
 }
 
+function mergeRegisteredRecord(
+  records: Map<string, RegisteredProjectRecordV1>,
+  next: RegisteredProjectRecordV1,
+): void {
+  const previous = records.get(next.projectKey);
+  if (previous === undefined) {
+    records.set(next.projectKey, next);
+    return;
+  }
+  const newer = next.lastSeenAt >= previous.lastSeenAt ? next : previous;
+  records.set(next.projectKey, {
+    ...newer,
+    registeredAt:
+      previous.registeredAt <= next.registeredAt ? previous.registeredAt : next.registeredAt,
+    lastSeenAt: previous.lastSeenAt >= next.lastSeenAt ? previous.lastSeenAt : next.lastSeenAt,
+  });
+}
+
 function mergeTargets(
   left: ProjectDiscoveryTarget[],
   right: ProjectDiscoveryTarget[],