Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Predicate from "effect/Predicate";
import * as Data from "effect/Data";
import * as DateTime from "effect/DateTime";
import * as Duration from "effect/Duration";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as PlatformError from "effect/PlatformError";
import * as Ref from "effect/Ref";
import * as Result from "effect/Result";
import * as Schema from "effect/Schema";
import * as Scope from "effect/Scope";
import * as Semaphore from "effect/Semaphore";
import * as Stream from "effect/Stream";
import { GitCommandError, type VcsRef } from "@akeru/contracts";
import { compactTraceAttributes } from "@akeru/shared/observability";
import { decodeJsonResult } from "@akeru/shared/schemaJson";
import type * as GitVcsDriver from "./GitVcsDriver.ts";
import { parseRemoteRefWithRemoteNames } from "../git/remoteRefs.ts";
export const DEFAULT_TIMEOUT_MS = 30_000;
// `git worktree add` checks out the full tree, so on large repositories it can
// take well beyond the default 30s (e.g. a 375k-file repo takes ~40s on an idle
// machine). Give it generous headroom while still bounding a genuinely hung git.
export const WORKTREE_ADD_TIMEOUT_MS = 300_000;
export const DEFAULT_MAX_OUTPUT_BYTES = 1_000_000;
export const STATUS_UPSTREAM_REFRESH_INTERVAL = Duration.seconds(15);
export const STATUS_UPSTREAM_REFRESH_TIMEOUT = Duration.seconds(5);
export const STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN = Duration.seconds(30);
export const STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN = Duration.minutes(15);
export const STATUS_UPSTREAM_REFRESH_CACHE_CAPACITY = 2_048;
export const REPOSITORY_PATHS_CACHE_CAPACITY = 2_048;
export const REPOSITORY_PATHS_CACHE_TTL = Duration.minutes(10);
export const REPOSITORY_PATHS_REFRESH_COALESCE_TTL = Duration.seconds(5);
export const NON_REPOSITORY_PATHS_CACHE_TTL = Duration.seconds(1);
export const LIST_REFS_SNAPSHOT_CACHE_CAPACITY = 64;
export const LIST_REFS_SNAPSHOT_CACHE_TTL = Duration.minutes(2);
export const LIST_REFS_REFRESH_COALESCE_TTL = Duration.seconds(5);
export const LIST_REFS_REFRESH_FAILURE_COOLDOWN = Duration.seconds(30);
export const STATUS_DEFAULT_BRANCH_CACHE_TTL = Duration.minutes(5);
export const STATUS_ORIGIN_EXISTS_CACHE_TTL = Duration.minutes(5);
export const STATUS_UPSTREAM_REFRESH_ENV = Object.freeze({
GCM_INTERACTIVE: "never",
GIT_ASKPASS: "",
GIT_TERMINAL_PROMPT: "0",
SSH_ASKPASS: "",
SSH_ASKPASS_REQUIRE: "never",
} satisfies NodeJS.ProcessEnv);
export const DEFAULT_BASE_BRANCH_CANDIDATES = ["main", "master"] as const;
export const GIT_LIST_BRANCHES_DEFAULT_LIMIT = 100;
export const NON_REPOSITORY_STATUS_DETAILS = Object.freeze<GitVcsDriver.GitStatusDetails>({
isRepo: false,
hasOriginRemote: false,
isDefaultBranch: false,
branch: null,
upstreamRef: null,
hasWorkingTreeChanges: false,
workingTree: { files: [], insertions: 0, deletions: 0 },
hasUpstream: false,
aheadCount: 0,
behindCount: 0,
aheadOfDefaultCount: 0,
});
export const NON_REPOSITORY_REMOTE_STATUS_DETAILS =
Object.freeze<GitVcsDriver.GitRemoteStatusDetails>({
isRepo: false,
defaultBranch: null,
isDefaultBranch: false,
branch: null,
upstreamRef: null,
hasUpstream: false,
aheadCount: 0,
behindCount: 0,
aheadOfDefaultCount: 0,
});
export type TraceTailState = {
processedChars: number;
remainder: string;
};
export class StatusRemoteRefreshCacheKey extends Data.Class<{
gitCommonDir: string;
remoteName: string;
}> {}
export function statusUpstreamRefreshFailureCooldown(
consecutiveFailures: number,
): Duration.Duration {
const exponent = Math.max(0, consecutiveFailures - 1);
const cooldownMs =
Duration.toMillis(STATUS_UPSTREAM_REFRESH_FAILURE_BASE_COOLDOWN) * Math.pow(2, exponent);
return Duration.min(Duration.millis(cooldownMs), STATUS_UPSTREAM_REFRESH_FAILURE_MAX_COOLDOWN);
}
export class GitRefsSnapshotCacheKey extends Data.Class<{
gitCommonDir: string;
epoch: number;
}> {}
export class GitRefsRefreshCacheKey extends Data.Class<{
gitCommonDir: string;
generation: number;
}> {}
export interface GitRepositoryPaths {
readonly gitCommonDir: string;
readonly worktreeRoot: string | null;
readonly currentBranch: string | null;
}
export interface GitRefsSnapshot {
readonly localBranches: ReadonlyArray<VcsRef>;
readonly remoteBranches: ReadonlyArray<VcsRef>;
readonly hasPrimaryRemote: boolean;
}
export interface ExecuteGitOptions {
stdin?: string | undefined;
timeoutMs?: number | null | undefined;
allowNonZeroExit?: boolean | undefined;
fallbackErrorDetail?: string | undefined;
env?: NodeJS.ProcessEnv | undefined;
maxOutputBytes?: number | undefined;
appendTruncationMarker?: boolean | undefined;
progress?: GitVcsDriver.ExecuteGitProgress | undefined;
}
export function parseBranchAb(value: string) {
const match = value.match(/^\+(\d+)\s+-(\d+)$/);
if (!match) return { ahead: 0, behind: 0 };
return {
ahead: Number(match[1] ?? "0"),
behind: Number(match[2] ?? "0"),
};
}
export function parseNumstatEntries(
stdout: string,
): Array<{ path: string; insertions: number; deletions: number }> {
const entries: Array<{ path: string; insertions: number; deletions: number }> = [];
for (const line of stdout.split(/\r?\n/g)) {
if (line.trim().length === 0) continue;
const [addedRaw, deletedRaw, ...pathParts] = line.split("\t");
const rawPath =
pathParts.length > 1 ? (pathParts.at(-1) ?? "").trim() : pathParts.join("\t").trim();
if (rawPath.length === 0) continue;
const added = Number.parseInt(addedRaw ?? "0", 10);
const deleted = Number.parseInt(deletedRaw ?? "0", 10);
const renameArrowIndex = rawPath.indexOf(" => ");
const normalizedPath =
renameArrowIndex >= 0 ? rawPath.slice(renameArrowIndex + " => ".length).trim() : rawPath;
entries.push({
path: normalizedPath.length > 0 ? normalizedPath : rawPath,
insertions: Number.isFinite(added) ? added : 0,
deletions: Number.isFinite(deleted) ? deleted : 0,
});
}
return entries;
}
export function parsePorcelainPath(line: string): string | null {
if (line.startsWith("? ") || line.startsWith("! ")) {
const simple = line.slice(2).trim();
return simple.length > 0 ? simple : null;
}
if (!(line.startsWith("1 ") || line.startsWith("2 ") || line.startsWith("u "))) {
return null;
}
const tabIndex = line.indexOf("\t");
if (tabIndex >= 0) {
const fromTab = line.slice(tabIndex + 1);
const [filePath] = fromTab.split("\t");
return filePath?.trim().length ? filePath.trim() : null;
}
const parts = line.trim().split(/\s+/g);
const filePath = parts.at(-1) ?? "";
return filePath.length > 0 ? filePath : null;
}
export function filterBranchesForListQuery(
refs: ReadonlyArray<VcsRef>,
query?: string,
): ReadonlyArray<VcsRef> {
if (!query) {
return refs;
}
const normalizedQuery = query.toLowerCase();
return refs.filter((refName) => refName.name.toLowerCase().includes(normalizedQuery));
}
export function paginateBranches(input: {
refs: ReadonlyArray<VcsRef>;
cursor?: number | undefined;
limit?: number | undefined;
}) {
const cursor = input.cursor ?? 0;
const limit = input.limit ?? GIT_LIST_BRANCHES_DEFAULT_LIMIT;
const totalCount = input.refs.length;
const refs = input.refs.slice(cursor, cursor + limit);
const nextCursor = cursor + refs.length < totalCount ? cursor + refs.length : null;
return {
refs,
nextCursor,
totalCount,
};
}
export function parseWorktreeBranchPaths(stdout: string): ReadonlyMap<string, string> {
const worktreePaths = new Map<string, string>();
let currentPath: string | null = null;
let currentBranch: string | null = null;
let currentPrunable = false;
const flush = () => {
if (currentPath !== null && currentBranch !== null && !currentPrunable) {
worktreePaths.set(currentBranch, currentPath);
}
currentPath = null;
currentBranch = null;
currentPrunable = false;
};
for (const field of stdout.split("\0")) {
if (field === "") {
flush();
} else if (field.startsWith("worktree ")) {
currentPath = field.slice("worktree ".length);
} else if (field.startsWith("branch refs/heads/")) {
currentBranch = field.slice("branch refs/heads/".length);
} else if (field === "prunable" || field.startsWith("prunable ")) {
currentPrunable = true;
}
}
flush();
return worktreePaths;
}
export function splitNullSeparatedPaths(input: string, truncated: boolean): string[] {
const parts = input.split("\0");
if (parts.length === 0) return [];
if (truncated && parts[parts.length - 1]?.length) {
parts.pop();
}
return parts.filter((value) => value.length > 0);
}
export function splitNullSeparatedGitStdoutPaths(
result: Pick<GitVcsDriver.ExecuteGitResult, "stdout" | "stdoutTruncated">,
): string[] {
return splitNullSeparatedPaths(result.stdout, result.stdoutTruncated);
}
export function sanitizeRemoteName(value: string): string {
const sanitized = value
.trim()
.replace(/[^A-Za-z0-9._-]+/g, "-")
.replace(/^-+|-+$/g, "");
return sanitized.length > 0 ? sanitized : "fork";
}
export function parseUpstreamRefWithRemoteNames(
upstreamRef: string,
remoteNames: ReadonlyArray<string>,
): { upstreamRef: string; remoteName: string; branchName: string } | null {
const parsed = parseRemoteRefWithRemoteNames(upstreamRef, remoteNames);
if (!parsed) {
return null;
}
return {
upstreamRef,
remoteName: parsed.remoteName,
branchName: parsed.branchName,
};
}
export function parseUpstreamRefByFirstSeparator(
upstreamRef: string,
): { upstreamRef: string; remoteName: string; branchName: string } | null {
const separatorIndex = upstreamRef.indexOf("/");
if (separatorIndex <= 0 || separatorIndex === upstreamRef.length - 1) {
return null;
}
const remoteName = upstreamRef.slice(0, separatorIndex).trim();
const branchName = upstreamRef.slice(separatorIndex + 1).trim();
if (remoteName.length === 0 || branchName.length === 0) {
return null;
}
return {
upstreamRef,
remoteName,
branchName,
};
}
export function parseTrackingBranchByUpstreamRef(
stdout: string,
upstreamRef: string,
): string | null {
for (const line of stdout.split("\n")) {
const trimmedLine = line.trim();
if (trimmedLine.length === 0) {
continue;
}
const [branchNameRaw, upstreamBranchRaw = ""] = trimmedLine.split("\t");
const branchName = branchNameRaw?.trim() ?? "";
const candidateUpstreamRef = upstreamBranchRaw.trim();
if (branchName.length === 0 || candidateUpstreamRef.length === 0) {
continue;
}
if (candidateUpstreamRef === upstreamRef) {
return branchName;
}
}
return null;
}
export function deriveLocalBranchNameFromRemoteRef(branchName: string): string | null {
const separatorIndex = branchName.indexOf("/");
if (separatorIndex <= 0 || separatorIndex === branchName.length - 1) {
return null;
}
const localBranch = branchName.slice(separatorIndex + 1).trim();
return localBranch.length > 0 ? localBranch : null;
}
export function gitCommandContext(
input: Pick<GitVcsDriver.ExecuteGitInput, "operation" | "cwd" | "args">,
) {
return {
operation: input.operation,
command: "git",
cwd: input.cwd,
argumentCount: input.args.length,
} as const;
}
export function parseDefaultBranchFromRemoteHeadRef(
value: string,
remoteName: string,
): string | null {
const trimmed = value.trim();
const prefix = `refs/remotes/${remoteName}/`;
if (!trimmed.startsWith(prefix)) {
return null;
}
const refName = trimmed.slice(prefix.length).trim();
return refName.length > 0 ? refName : null;
}
export function isMissingGitCwdError(error: GitCommandError): boolean {
if (!(error.cause instanceof PlatformError.PlatformError)) {
return false;
}
const reason = error.cause.reason;
if (Predicate.isTagged(reason, "NotFound")) {
return reason.pathOrDescriptor === error.cwd;
}
return (
Predicate.isTagged(reason, "BadResource") &&
reason.pathOrDescriptor === error.cwd &&
Predicate.isObjectOrArray(reason.cause) &&
"code" in reason.cause &&
reason.cause.code === "ENOTDIR"
);
}
export function isNonRepositoryGitStderr(stderr: string): boolean {
return stderr.toLowerCase().includes("not a git repository");
}
export function isUnbornHeadStderr(stderr: string): boolean {
const normalized = stderr.toLowerCase();
return (
normalized.includes("bad revision 'head'") ||
(normalized.includes("unknown revision") && normalized.includes("path not in the working tree"))
);
}
// Matches `git worktree remove` on a path git no longer tracks: "is not a
// working tree" when the registration is gone, "cannot remove working tree"
// when older gits fail validation on a registered-but-deleted directory.
export function isMissingWorktreeStderr(stderr: string): boolean {
const normalized = stderr.toLowerCase();
return (
normalized.includes("is not a working tree") ||
normalized.includes("cannot remove working tree")
);
}
export interface Trace2Monitor {
readonly env: NodeJS.ProcessEnv;
readonly flush: Effect.Effect<void, never>;
}
export const nowUnixNano = DateTime.now.pipe(
Effect.map((now) => BigInt(DateTime.toEpochMillis(now)) * 1_000_000n),
);
export const addCurrentSpanEvent = (
name: string,
attributes: Record<string, string | number | boolean | null | undefined>,
) =>
Effect.gen(function* () {
const span = yield* Effect.currentSpan;
const timestamp = yield* nowUnixNano;
yield* Effect.sync(() => {
span.event(name, timestamp, compactTraceAttributes(attributes));
});
}).pipe(
Effect.catchTags({
NoSuchElementError: () => Effect.void,
}),
);
export function trace2ChildKey(record: typeof Trace2Record.Type): string | null {
const childId = record.child_id;
if (Predicate.isNumber(childId) || Predicate.isString(childId)) {
return String(childId);
}
const hookName = record.hook_name;
return Predicate.isString(hookName) && hookName.trim().length > 0 ? hookName.trim() : null;
}
export const Trace2Record = Schema.Record(Schema.String, Schema.Json);
export const createTrace2Monitor = Effect.fn("createTrace2Monitor")(function* (
input: Pick<GitVcsDriver.ExecuteGitInput, "operation" | "cwd" | "args">,
progress: GitVcsDriver.ExecuteGitProgress | undefined,
): Effect.fn.Return<
Trace2Monitor,
PlatformError.PlatformError,
Scope.Scope | FileSystem.FileSystem | Path.Path
> {
if (!progress?.onHookStarted && !progress?.onHookFinished) {
return {
env: {},
flush: Effect.void,
};
}
const fs = yield* FileSystem.FileSystem;
const path = yield* Path.Path;
const traceFilePath = yield* fs.makeTempFileScoped({
prefix: `t3code-git-trace2-${process.pid}-`,
suffix: ".json",
});
const hookStartByChildKey = new Map<string, { hookName: string; startedAtMs: number }>();
const traceTailState = yield* Ref.make<TraceTailState>({
processedChars: 0,
remainder: "",
});
const handleTraceLine = Effect.fn("handleTraceLine")(function* (line: string) {
const trimmedLine = line.trim();
if (trimmedLine.length === 0) {
return;
}
const traceRecord = decodeJsonResult(Trace2Record)(trimmedLine);
if (Result.isFailure(traceRecord)) {
yield* Effect.logDebug(
`GitVcsDriver.trace2: failed to parse trace line for ${input.operation} in ${input.cwd} (${input.args.length} arguments)`,
traceRecord.failure,
);
return;
}
if (traceRecord.success.child_class !== "hook") {
return;
}
const event = traceRecord.success.event;
const childKey = trace2ChildKey(traceRecord.success);
if (childKey === null) {
return;
}
const started = hookStartByChildKey.get(childKey);
const hookNameFromEvent = Predicate.isString(traceRecord.success.hook_name)
? traceRecord.success.hook_name.trim()
: "";
const hookName = hookNameFromEvent.length > 0 ? hookNameFromEvent : (started?.hookName ?? "");
if (hookName.length === 0) {
return;
}
if (event === "child_start") {
const now = yield* DateTime.now;
hookStartByChildKey.set(childKey, { hookName, startedAtMs: DateTime.toEpochMillis(now) });
yield* addCurrentSpanEvent("git.hook.started", {
hookName,
});
if (progress.onHookStarted) {
yield* progress.onHookStarted(hookName);
}
return;
}
if (event === "child_exit") {
hookStartByChildKey.delete(childKey);
const code = traceRecord.success.exitCode;
const exitCode = Predicate.isNumber(code) && Number.isInteger(code) ? code : null;
const now = yield* DateTime.now;
const durationMs = started
? Math.max(0, DateTime.toEpochMillis(now) - started.startedAtMs)
: null;
yield* addCurrentSpanEvent("git.hook.finished", {
hookName: started?.hookName ?? hookName,
exitCode,
durationMs,
});
if (progress.onHookFinished) {
yield* progress.onHookFinished({
hookName: started?.hookName ?? hookName,
exitCode,
durationMs,
});
}
}
});
const deltaMutex = yield* Semaphore.make(1);
const readTraceDelta = deltaMutex.withPermit(
fs.readFileString(traceFilePath).pipe(
Effect.flatMap((contents) =>
Effect.uninterruptible(
Ref.modify(traceTailState, ({ processedChars, remainder }) => {
if (contents.length <= processedChars) {
return [[], { processedChars, remainder }];
}
const appended = contents.slice(processedChars);
const combined = remainder + appended;
const lines = combined.split("\n");
const nextRemainder = lines.pop() ?? "";
return [
lines.map((line) => line.replace(/\r$/, "")),
{
processedChars: contents.length,
remainder: nextRemainder,
},
];
}).pipe(
Effect.flatMap((lines) => Effect.forEach(lines, handleTraceLine, { discard: true })),
),
),
),
Effect.ignore({ log: true }),
),
);
const traceFileName = path.basename(traceFilePath);
yield* Stream.runForEach(fs.watch(traceFilePath), (event) => {
const eventPath = event.path;
const isTargetTraceEvent =
eventPath === traceFilePath ||
eventPath === traceFileName ||
path.basename(eventPath) === traceFileName;
if (!isTargetTraceEvent) return Effect.void;
return readTraceDelta;
}).pipe(Effect.ignoreCause({ log: true }), Effect.forkScoped);
const finalizeTrace2Monitor = Effect.fn("finalizeTrace2Monitor")(function* () {
yield* readTraceDelta;
const finalLine = yield* Ref.modify(traceTailState, ({ processedChars, remainder }) => [
remainder.trim(),
{
processedChars,
remainder: "",
},
]);
if (finalLine.length > 0) {
yield* handleTraceLine(finalLine);
}
});
yield* Effect.addFinalizer(finalizeTrace2Monitor);
return {
env: {
GIT_TRACE2_EVENT: traceFilePath,
},
flush: readTraceDelta,
};
});
export const collectOutput = Effect.fnUntraced(function* (
input: Pick<GitVcsDriver.ExecuteGitInput, "operation" | "cwd" | "args">,
stream: Stream.Stream<Uint8Array, PlatformError.PlatformError>,
maxOutputBytes: number,
appendTruncationMarker: boolean,
onLine: ((line: string) => Effect.Effect<void, never>) | undefined,
): Effect.fn.Return<{ readonly text: string; readonly truncated: boolean }, GitCommandError> {
const decoder = new TextDecoder();
let bytes = 0;
let text = "";
let lineBuffer = "";
let truncated = false;
const emitCompleteLines = Effect.fnUntraced(function* (flush: boolean) {
let newlineIndex = lineBuffer.indexOf("\n");
while (newlineIndex >= 0) {
const line = lineBuffer.slice(0, newlineIndex).replace(/\r$/, "");
lineBuffer = lineBuffer.slice(newlineIndex + 1);
if (line.length > 0 && onLine) {
yield* onLine(line);
}
newlineIndex = lineBuffer.indexOf("\n");
}
if (flush) {
const trailing = lineBuffer.replace(/\r$/, "");
lineBuffer = "";
if (trailing.length > 0 && onLine) {
yield* onLine(trailing);
}
}
});
const processChunk = Effect.fnUntraced(function* (chunk: Uint8Array) {
if (appendTruncationMarker && truncated) {
return;
}
const nextBytes = bytes + chunk.byteLength;
if (!appendTruncationMarker && nextBytes > maxOutputBytes) {
return yield* new GitCommandError({
...gitCommandContext(input),
detail: `Git output exceeded ${maxOutputBytes} bytes and was truncated.`,
outputLength: nextBytes,
});
}
const chunkToDecode =
appendTruncationMarker && nextBytes > maxOutputBytes
? chunk.subarray(0, Math.max(0, maxOutputBytes - bytes))
: chunk;
bytes += chunkToDecode.byteLength;
truncated = appendTruncationMarker && nextBytes > maxOutputBytes;
const decoded = decoder.decode(chunkToDecode, { stream: !truncated });
text += decoded;
lineBuffer += decoded;
yield* emitCompleteLines(false);
});
yield* Stream.runForEach(stream, processChunk).pipe(
Effect.catchTags({
PlatformError: (cause) =>
new GitCommandError({
...gitCommandContext(input),
detail: "Failed to read Git process output.",
cause,
}),
}),
);
const remainder = truncated ? "" : decoder.decode();
text += remainder;
lineBuffer += remainder;
yield* emitCompleteLines(true);
return {
text,
truncated,
};
});