Skip to content

armgit / orca

Public Imported from GitHub
0

Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.

3.8 KB
Raw Blame
import type { Project } from './project-types'

export type ProjectIdentitySuccession = {
  /** Projected projects with user-set state carried forward from their predecessor row. */
  projects: readonly Project[]
  /** Predecessor project id -> surviving project id, for rows whose identity key changed. */
  remappedProjectIds: ReadonlyMap<string, string>
}

function carryUserState(projected: Project, previous: Project): Project {
  return previous.localWindowsRuntimePreference
    ? {
        ...projected,
        localWindowsRuntimePreference: previous.localWindowsRuntimePreference,
        updatedAt: Math.max(projected.updatedAt, previous.updatedAt)
      }
    : projected
}

function compareStrings(left: string, right: string): number {
  return left < right ? -1 : left > right ? 1 : 0
}

/** Carry user state/references through repo→git→github identity promotion and re-probes, preserving preferences without ghost rows.
 * Choose predecessors by shared source repos, newest updatedAt, then lowest prior/new IDs. Claim each prior once:
 * never merge distinct preferences; unmatched rows retain their own identity. */
export function carryProjectStateThroughIdentityChange(
  projectedProjects: readonly Project[],
  previousProjects: readonly Project[]
): ProjectIdentitySuccession {
  const previousById = new Map(previousProjects.map((project) => [project.id, project]))
  const projectedIds = new Set(projectedProjects.map((project) => project.id))
  // Why: a prior row that still exists under its own id is live, not a predecessor.
  const orphanedPrevious = previousProjects.filter((project) => !projectedIds.has(project.id))
  const unmatched = projectedProjects.filter((project) => !previousById.has(project.id))
  const previousIndicesByRepo = new Map<string, number[]>()
  if (unmatched.length > 0) {
    orphanedPrevious.forEach((previous, index) => {
      for (const repoId of previous.sourceRepoIds) {
        const indices = previousIndicesByRepo.get(repoId)
        if (indices) {
          indices.push(index)
        } else {
          previousIndicesByRepo.set(repoId, [index])
        }
      }
    })
  }
  const candidates = unmatched.flatMap((project) => {
    const overlaps = new Map<number, number>()
    for (const repoId of new Set(project.sourceRepoIds)) {
      for (const index of previousIndicesByRepo.get(repoId) ?? []) {
        overlaps.set(index, (overlaps.get(index) ?? 0) + 1)
      }
    }
    // Preserve input order when the candidate comparator ties on legacy duplicate IDs.
    return [...overlaps]
      .sort(([left], [right]) => left - right)
      .map(([index, shared]) => ({
        project,
        previous: orphanedPrevious[index],
        shared
      }))
  })
  candidates.sort(
    (left, right) =>
      right.shared - left.shared ||
      right.previous.updatedAt - left.previous.updatedAt ||
      compareStrings(left.previous.id, right.previous.id) ||
      compareStrings(left.project.id, right.project.id)
  )
  const claimedPreviousIds = new Set<string>()
  const predecessorByProjectId = new Map<string, Project>()
  for (const candidate of candidates) {
    if (
      claimedPreviousIds.has(candidate.previous.id) ||
      predecessorByProjectId.has(candidate.project.id)
    ) {
      continue
    }
    claimedPreviousIds.add(candidate.previous.id)
    predecessorByProjectId.set(candidate.project.id, candidate.previous)
  }
  const remappedProjectIds = new Map<string, string>()
  const projects = projectedProjects.map((project) => {
    const exact = previousById.get(project.id)
    if (exact) {
      return carryUserState(project, exact)
    }
    const predecessor = predecessorByProjectId.get(project.id)
    if (!predecessor) {
      return project
    }
    remappedProjectIds.set(predecessor.id, project.id)
    return carryUserState(project, predecessor)
  })
  return { projects, remappedProjectIds }
}