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.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
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 }
}