Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import {
credentialHostFromRemoteUrl,
declaredGitHubHostsFrom,
isGitHubHost,
normalizeGitHostname,
} from '@inkeep/open-knowledge-core';
import {
type GitRepository,
inspectGitRepository,
} from '@inkeep/open-knowledge-core/git-repository';
import { readConfigSafely, resolveConfigPath } from '@inkeep/open-knowledge-core/server';
import { buildSyncCredentialConfig } from '../git-handle.ts';
import { getLogger } from '../logger.ts';
const log = getLogger('git-context');
export type OriginTransport = 'https' | 'http' | 'ssh' | 'git';
export type ParsedOriginTransport = Exclude<OriginTransport, 'http'>;
export type OriginResult =
| {
kind: 'ok';
host: string;
owner: string;
repo: string;
transport: ParsedOriginTransport;
}
| { kind: 'no-remote' }
| { kind: 'non-github'; host: string | null };
function readRepository(projectDir: string): GitRepository | null {
const result = inspectGitRepository(projectDir);
return result.kind === 'repository' ? result.repository : null;
}
export function readGitHeadBranch(projectDir: string): string | null {
const head = readRepository(projectDir)?.readHead();
return head?.kind === 'branch' ? head.branch : null;
}
export interface ParsedOriginRepo {
host: string;
owner: string;
repo: string;
transport: ParsedOriginTransport;
login?: string;
}
const USERINFO_PLACEHOLDER_USERS = new Set([
'git',
'x-access-token',
'x-oauth-basic',
'oauth2',
'token',
]);
const GITHUB_TOKEN_PREFIX = /^(?:gh[opsur]_|github_pat_)/;
const GITHUB_LOGIN = /^[A-Za-z0-9](?:[A-Za-z0-9]|[-_](?=[A-Za-z0-9])){0,38}$/;
function isGitHubLoginShaped(value: string): boolean {
return !GITHUB_TOKEN_PREFIX.test(value) && GITHUB_LOGIN.test(value);
}
export function sameGitHubLogin(a: string | undefined, b: string | undefined): boolean {
return a !== undefined && b !== undefined && a.toLowerCase() === b.toLowerCase();
}
function loginFromUserinfo(userinfo: string | undefined): string | undefined {
if (!userinfo) return undefined;
const colon = userinfo.indexOf(':');
const user = colon === -1 ? userinfo : userinfo.slice(0, colon);
if (!user) return undefined;
return asDeclaredGitHubLogin(decodeUserinfo(user));
}
export function asDeclaredGitHubLogin(raw: string | undefined): string | undefined {
if (!raw) return undefined;
if (USERINFO_PLACEHOLDER_USERS.has(raw)) return undefined;
return isGitHubLoginShaped(raw) ? raw : undefined;
}
export function loginShapedUserinfoUser(user: string): string | undefined {
if (!user) return undefined;
const decoded = decodeUserinfo(user);
return isGitHubLoginShaped(decoded) ? decoded : undefined;
}
function decodeUserinfo(user: string): string {
if (!user.includes('%')) return user;
try {
return decodeURIComponent(user);
} catch {
return user;
}
}
export function readDeclaredGitHubHosts(homedirOverride?: string): ReadonlySet<string> {
return declaredGitHubHostsFrom(
readConfigSafely({
absPath: resolveConfigPath('user', '', homedirOverride),
sideline: false,
warn: (message) => log.warn({ message }, 'Git host declaration configuration diagnostic'),
}).value.git?.hosts,
);
}
export function parseGitRemoteUrl(originUrl: string): ParsedOriginRepo | null {
const raw = originUrl.trim();
if (!raw) return null;
const classify = (
host: string,
owner: string,
repo: string,
transport: ParsedOriginTransport,
userinfo?: string,
): ParsedOriginRepo | null => {
const normalized = normalizeGitHostname(host);
const login = loginFromUserinfo(userinfo);
return login === undefined
? { host: normalized, owner, repo, transport }
: { host: normalized, owner, repo, transport, login };
};
let m =
/^https?:\/\/(?:([^/]*)@)?([\w.-]+(?::\d+)?)\/([\w.\-~%]+)\/([\w.\-~%]+?)(?:\.git)?\/?$/.exec(
raw,
);
if (m) return classify(m[2], m[3], m[4], 'https', m[1]);
m = /^ssh:\/\/(?:([^/]*)@)?([\w.-]+)(?::\d+)?\/([\w.\-~%]+)\/([\w.\-~%]+?)(?:\.git)?\/?$/.exec(
raw,
);
if (m) return classify(m[2], m[3], m[4], 'ssh', m[1]);
m = /^([\w.\-~%]+)@([\w.-]+):([\w.\-~%]+)\/([\w.\-~%]+?)(?:\.git)?$/.exec(raw);
if (m) return classify(m[2], m[3], m[4], 'ssh', m[1]);
m = /^git:\/\/([\w.-]+(?::\d+)?)\/([\w.\-~%]+)\/([\w.\-~%]+?)(?:\.git)?\/?$/.exec(raw);
if (m) return classify(m[1], m[2], m[3], 'git');
return null;
}
export function parseGitHubOriginUrl(
originUrl: string,
declaredGitHubHosts?: ReadonlySet<string>,
): ParsedOriginRepo | null {
const parsed = parseGitRemoteUrl(originUrl);
if (parsed === null) return null;
return isGitHubHost(parsed.host, declaredGitHubHosts) ? parsed : null;
}
export function readOriginRemoteUrl(projectDir: string): string | null {
const origin = readRepository(projectDir)?.readRemoteUrl('origin');
return origin?.kind === 'configured' ? origin.url : null;
}
export function readOriginCredentialHost(projectDir: string): string | null {
const originUrl = readOriginRemoteUrl(projectDir);
return originUrl === null ? null : credentialHostFromRemoteUrl(originUrl);
}
function readParsedOrigin(
projectDir: string,
declaredGitHubHosts: ReadonlySet<string>,
): { originUrl: string; remote: ParsedOriginRepo | null; github: ParsedOriginRepo | null } | null {
const origin = readRepository(projectDir)?.readRemoteUrl('origin');
if (origin?.kind !== 'configured') return null;
const originUrl = origin.url;
const remote = parseGitRemoteUrl(originUrl);
return {
originUrl,
remote,
github: remote && isGitHubHost(remote.host, declaredGitHubHosts) ? remote : null,
};
}
export function readOriginGitHubRepo(
projectDir: string,
declaredGitHubHosts: ReadonlySet<string> = readDeclaredGitHubHosts(),
): OriginResult {
const parsed = readParsedOrigin(projectDir, declaredGitHubHosts);
if (!parsed) return { kind: 'no-remote' };
if (parsed.github) {
const { host, owner, repo, transport } = parsed.github;
return { kind: 'ok', host, owner, repo, transport };
}
return { kind: 'non-github', host: parsed.remote?.host ?? null };
}
export type GitHubAuthHostResult =
| { kind: 'ok'; host: string }
| { kind: 'rejected-explicit'; host: string }
| { kind: 'rejected-origin'; host: string | null };
export function resolveGitHubAuthHost(
projectDir: string,
explicitHost?: string,
declaredGitHubHosts: ReadonlySet<string> = readDeclaredGitHubHosts(),
): GitHubAuthHostResult {
if (explicitHost !== undefined) {
return isGitHubHost(explicitHost, declaredGitHubHosts)
? { kind: 'ok', host: explicitHost }
: { kind: 'rejected-explicit', host: normalizeGitHostname(explicitHost) };
}
const origin = readOriginGitHubRepo(projectDir, declaredGitHubHosts);
if (origin.kind === 'ok') return { kind: 'ok', host: origin.host };
if (origin.kind === 'no-remote') return { kind: 'ok', host: 'github.com' };
return { kind: 'rejected-origin', host: origin.host };
}
export function shouldResetAmbientCredentials(
projectDir: string,
declaredGitHubHosts: ReadonlySet<string> = readDeclaredGitHubHosts(),
): boolean {
return readOriginGitHubRepo(projectDir, declaredGitHubHosts).kind !== 'non-github';
}
export interface CredentialPresenceStore {
get(host: string): Promise<unknown>;
}
export async function resolveAmbientCredentialReset(
projectDir: string,
tokenStore: CredentialPresenceStore | null | undefined,
declaredGitHubHosts: ReadonlySet<string> = readDeclaredGitHubHosts(),
): Promise<boolean> {
const originUrl = readOriginRemoteUrl(projectDir);
const transport = originUrl === null ? undefined : originTransport(originUrl);
if (transport === 'http') return false;
if (shouldResetAmbientCredentials(projectDir, declaredGitHubHosts)) return true;
if (originUrl === null || transport !== 'https' || !tokenStore) return false;
const host = credentialHostFromRemoteUrl(originUrl);
if (host === null) return false;
try {
return (await tokenStore.get(host)) != null;
} catch (err) {
log.warn({ err, host }, '[sync] stored-token lookup for the credential reset decision failed');
throw err;
}
}
export function createSyncCredentialConfigResolver(deps: {
projectDir: string;
tokenStore: CredentialPresenceStore | null | undefined;
localOpCliArgs: string[] | undefined;
declaredGitHubHosts?: ReadonlySet<string>;
}): () => Promise<string[]> {
const declaredGitHubHosts = deps.declaredGitHubHosts ?? readDeclaredGitHubHosts();
let lastConfig: string[] | null = null;
return async () => {
let resetAmbient: boolean;
try {
resetAmbient = await resolveAmbientCredentialReset(
deps.projectDir,
deps.tokenStore,
declaredGitHubHosts,
);
} catch {
if (lastConfig !== null) return lastConfig;
resetAmbient = false;
}
log.debug(
{
resetAmbient,
originKind: readOriginGitHubRepo(deps.projectDir, declaredGitHubHosts).kind,
},
'[sync] ambient credential-chain reset decision',
);
lastConfig = buildSyncCredentialConfig(deps.localOpCliArgs, { resetAmbient });
return lastConfig;
};
}
export interface SyncRemoteInfo {
label: string;
webUrl: string | null;
transport?: OriginTransport;
}
function originTransport(url: string): OriginTransport | undefined {
const trimmed = url.trim();
if (/^https:\/\//i.test(trimmed)) return 'https';
if (/^http:\/\//i.test(trimmed)) return 'http';
if (/^ssh:\/\//i.test(trimmed) || /^[\w.-]+@[^:/]+:/.test(trimmed)) return 'ssh';
if (/^git:\/\//i.test(trimmed)) return 'git';
return undefined;
}
export function readSyncRemoteInfo(
projectDir: string,
declaredGitHubHosts: ReadonlySet<string> = readDeclaredGitHubHosts(),
): SyncRemoteInfo | null {
const parsed = readParsedOrigin(projectDir, declaredGitHubHosts);
if (!parsed) return null;
const transport = originTransport(parsed.originUrl);
const withTransport = transport === undefined ? {} : { transport };
if (parsed.github) {
const { host, owner, repo } = parsed.github;
return {
label: host === 'github.com' ? `${owner}/${repo}` : `${host}/${owner}/${repo}`,
webUrl: `https://${host}/${owner}/${repo}`,
...withTransport,
};
}
return { label: labelFromNonGitHubUrl(parsed.originUrl), webUrl: null, ...withTransport };
}
function labelFromNonGitHubUrl(url: string): string {
const trimmed = url.trim().replace(/\.git$/, '');
const scp = /^[\w.-]+@([^:/]+):(.+)$/.exec(trimmed);
if (scp) return `${scp[1]}/${scp[2]}`;
const scheme = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)*(.+)$/i.exec(trimmed);
if (scheme) return scheme[1];
return trimmed;
}
export function branchExistsOnOrigin(projectDir: string, branch: string): boolean {
return readRepository(projectDir)?.readRef(`refs/remotes/origin/${branch}`).kind === 'present';
}