mirror of
https://github.com/stablyai/orca.git
synced 2026-11-16 19:07:41 +00:00
143 lines
4.2 KiB
TypeScript
143 lines
4.2 KiB
TypeScript
import type { GlobalSettings } from '../../global-settings-types'
|
|
import {
|
|
LOCAL_EXECUTION_HOST_ID,
|
|
normalizeExecutionHostId,
|
|
toSshExecutionHostId,
|
|
type ExecutionHostId
|
|
} from '../../execution-host'
|
|
import { taskSourceCacheScopeHostId } from '../../work-items/task-source-context'
|
|
|
|
export type RuntimeFocusSettings =
|
|
| Pick<GlobalSettings, 'activeRuntimeEnvironmentId'>
|
|
| null
|
|
| undefined
|
|
|
|
export function getGitHubRepoCacheKey(
|
|
repoPath: string,
|
|
repoId: string | undefined,
|
|
suffix: string,
|
|
settings?: RuntimeFocusSettings,
|
|
connectionId?: string | null,
|
|
executionHostId?: string | null,
|
|
hasRepoOwner = false
|
|
): string {
|
|
// Scope caches by execution owner: runtime/SSH hosts may observe different remotes at the same repo path.
|
|
return composeRepoCacheKey(
|
|
getGitHubCacheHostScope(settings, connectionId, executionHostId, hasRepoOwner),
|
|
repoId ?? repoPath,
|
|
suffix
|
|
)
|
|
}
|
|
|
|
/** Repo cache keys use [scope::]owner::suffix; absent scope means this computer. repoCacheKeyHostId reads the shape back. */
|
|
export function composeRepoCacheKey(
|
|
scope: string | null | undefined,
|
|
owner: string,
|
|
suffix: string
|
|
): string {
|
|
return scope ? `${scope}::${owner}::${suffix}` : `${owner}::${suffix}`
|
|
}
|
|
|
|
/** Which host's bucket `key` is when one of `owners` (repo id or path) owns it; null when none does. */
|
|
export function repoCacheKeyHostId(key: string, owners: readonly string[]): ExecutionHostId | null {
|
|
if (owners.some((owner) => key.startsWith(`${owner}::`))) {
|
|
return LOCAL_EXECUTION_HOST_ID
|
|
}
|
|
// Why not the first `::`: a task-source scope with empty parts contains `::` itself.
|
|
for (const owner of owners) {
|
|
const marker = `::${owner}::`
|
|
for (let at = key.indexOf(marker); at !== -1; at = key.indexOf(marker, at + 1)) {
|
|
const scope = key.slice(0, at)
|
|
// Why the `::` check: a composed host id is encoded, so a candidate spanning `::` is owner + suffix.
|
|
const hostId =
|
|
(scope.includes('::') ? null : normalizeExecutionHostId(scope)) ??
|
|
taskSourceCacheScopeHostId(scope)
|
|
if (hostId) {
|
|
return hostId
|
|
}
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
function getGitHubCacheHostScope(
|
|
settings?: RuntimeFocusSettings,
|
|
connectionId?: string | null,
|
|
executionHostId?: string | null,
|
|
hasRepoOwner = false
|
|
): string | null {
|
|
const hostId = normalizeExecutionHostId(executionHostId)
|
|
if (hostId) {
|
|
return hostId === LOCAL_EXECUTION_HOST_ID ? null : hostId
|
|
}
|
|
const sshConnectionId = connectionId?.trim()
|
|
if (sshConnectionId) {
|
|
return toSshExecutionHostId(sshConnectionId)
|
|
}
|
|
// Known repos without remote/runtime ownership are local; only missing owner context inherits focused runtime scope.
|
|
if (hasRepoOwner) {
|
|
return null
|
|
}
|
|
const runtimeEnvironmentId = settings?.activeRuntimeEnvironmentId?.trim()
|
|
if (runtimeEnvironmentId) {
|
|
return `runtime:${encodeURIComponent(runtimeEnvironmentId)}`
|
|
}
|
|
return null
|
|
}
|
|
|
|
export function getLegacyGitHubRepoCacheKey(
|
|
repoPath: string,
|
|
repoId: string | undefined,
|
|
suffix: string
|
|
): string {
|
|
return composeRepoCacheKey(null, repoId ?? repoPath, suffix)
|
|
}
|
|
|
|
export function getGitHubPRCacheKey(
|
|
repoPath: string,
|
|
repoId: string | undefined,
|
|
branch: string,
|
|
settings?: RuntimeFocusSettings,
|
|
connectionId?: string | null,
|
|
executionHostId?: string | null,
|
|
hasRepoOwner = false
|
|
): string {
|
|
return getGitHubRepoCacheKey(
|
|
repoPath,
|
|
repoId,
|
|
branch,
|
|
settings,
|
|
connectionId,
|
|
executionHostId,
|
|
hasRepoOwner
|
|
)
|
|
}
|
|
|
|
export function getLegacyGitHubPRCacheKey(
|
|
repoPath: string,
|
|
repoId: string | undefined,
|
|
branch: string
|
|
): string {
|
|
return getLegacyGitHubRepoCacheKey(repoPath, repoId, branch)
|
|
}
|
|
|
|
/** Every key a repo's branch PR may sit under in the cache, the repo-scoped one first. */
|
|
export function getGitHubPRCacheKeyCandidates(
|
|
repo: { path: string; id: string; connectionId?: string | null; executionHostId?: string | null },
|
|
branch: string
|
|
): string[] {
|
|
return [
|
|
getGitHubPRCacheKey(
|
|
repo.path,
|
|
repo.id,
|
|
branch,
|
|
null,
|
|
repo.connectionId,
|
|
repo.executionHostId,
|
|
true
|
|
),
|
|
getLegacyGitHubPRCacheKey(repo.path, repo.id, branch),
|
|
getLegacyGitHubPRCacheKey(repo.path, undefined, branch)
|
|
]
|
|
}
|