@schlenkr/ragents 0.1.5 → 0.1.6

package/packages/agent/src/core/slash-commands.ts

@@ -1,41 +0,0 @@
-import { APP_NAME } from "../config.ts";
-import type { SourceInfo } from "./source-info.ts";
-
-export type SlashCommandSource = "extension" | "prompt" | "skill";
-
-export interface SlashCommandInfo {
-	name: string;
-	description?: string;
-	source: SlashCommandSource;
-	sourceInfo: SourceInfo;
-}
-
-export interface BuiltinSlashCommand {
-	name: string;
-	description: string;
-	argumentHint?: string;
-}
-
-export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
-	{ name: "settings", description: "Open settings menu" },
-	{ name: "model", description: "Select model (opens selector UI)", argumentHint: "<provider/model>" },
-	{ name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
-	{ name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
-	{ name: "import", description: "Import and resume a session from a JSONL file" },
-	{ name: "share", description: "Share session as a secret GitHub gist" },
-	{ name: "copy", description: "Copy last agent message to clipboard" },
-	{ name: "name", description: "Set session display name" },
-	{ name: "session", description: "Show session info and stats" },
-	{ name: "hotkeys", description: "Show all keyboard shortcuts" },
-	{ name: "fork", description: "Create a new fork from a previous user message" },
-	{ name: "clone", description: "Duplicate the current session at the current position" },
-	{ name: "tree", description: "Navigate session tree (switch branches)" },
-	{ name: "trust", description: "Save project trust decision for future sessions" },
-	{ name: "login", description: "Configure provider authentication", argumentHint: "<provider>" },
-	{ name: "logout", description: "Remove provider authentication" },
-	{ name: "new", description: "Start a new session" },
-	{ name: "compact", description: "Manually compact the session context" },
-	{ name: "resume", description: "Resume a different session" },
-	{ name: "reload", description: "Reload keybindings, extensions, skills, prompts, themes, and context files" },
-	{ name: "quit", description: `Quit ${APP_NAME}` },
-];

package/packages/agent/src/core/timings.ts

@@ -1,50 +0,0 @@
-/**
- * Central timing instrumentation for startup profiling.
- * Enable with AGENT_TIMING=1 environment variable.
- */
-
-const ENABLED = process.env.AGENT_TIMING === "1";
-interface TimingNamespace {
-	timings: Array<{ label: string; ms: number }>;
-	lastTime: number;
-}
-
-type TimingLabel = "main" | "extensions";
-
-const timingNamespaces = new Map<TimingLabel, TimingNamespace>();
-
-export function resetTimings(namespace: TimingLabel = "main"): void {
-	if (!ENABLED) return;
-	timingNamespaces.set(namespace, { timings: [], lastTime: Date.now() });
-}
-
-export function time(label: string, namespace: TimingLabel = "main"): void {
-	if (!ENABLED) return;
-	const now = Date.now();
-
-	if (!timingNamespaces.has(namespace)) {
-		resetTimings(namespace);
-	}
-
-	const timingNamespace = timingNamespaces.get(namespace)!;
-	timingNamespace.timings.push({ label, ms: now - timingNamespace.lastTime });
-	timingNamespace.lastTime = now;
-}
-
-function printTimingGroup(title: string, timings: TimingNamespace["timings"]): void {
-	const printableTimings = timings.filter((timing) => timing.ms >= 0);
-	if (printableTimings.length === 0) return;
-	console.error(`\n--- ${title} ---`);
-	for (const t of printableTimings) {
-		console.error(`  ${t.label}: ${t.ms}ms`);
-	}
-	console.error(`  TOTAL: ${printableTimings.reduce((a, b) => a + b.ms, 0)}ms`);
-	console.error(`${"-".repeat(title.length + 8)}\n`);
-}
-
-export function printTimings(): void {
-	if (!ENABLED) return;
-	for (const [namespace, timingNamespace] of timingNamespaces) {
-		printTimingGroup(`Startup Timings: ${namespace}`, timingNamespace.timings);
-	}
-}

package/packages/agent/src/core/tools/tool-definition-wrapper.ts

@@ -1,45 +0,0 @@
-import type { AgentTool } from "@aicontainer/agent-core";
-import type { ExtensionContext, ToolDefinition } from "../extensions/types.ts";
-
-/** Wrap a ToolDefinition into an AgentTool for the core runtime. */
-export function wrapToolDefinition<TDetails = unknown>(
-	definition: ToolDefinition<any, TDetails>,
-	ctxFactory?: () => ExtensionContext,
-): AgentTool<any, TDetails> {
-	return {
-		name: definition.name,
-		label: definition.label,
-		description: definition.description,
-		parameters: definition.parameters,
-		prepareArguments: definition.prepareArguments,
-		executionMode: definition.executionMode,
-		execute: (toolCallId, params, signal, onUpdate) =>
-			definition.execute(toolCallId, params, signal, onUpdate, ctxFactory?.() as ExtensionContext),
-	};
-}
-
-/** Wrap multiple ToolDefinitions into AgentTools for the core runtime. */
-export function wrapToolDefinitions(
-	definitions: ToolDefinition<any, any>[],
-	ctxFactory?: () => ExtensionContext,
-): AgentTool<any>[] {
-	return definitions.map((definition) => wrapToolDefinition(definition, ctxFactory));
-}
-
-/**
- * Synthesize a minimal ToolDefinition from an AgentTool.
- *
- * This keeps AgentSession's internal registry definition-first even when a caller
- * provides plain AgentTool overrides that do not include prompt metadata or renderers.
- */
-export function createToolDefinitionFromAgentTool(tool: AgentTool<any>): ToolDefinition<any, unknown> {
-	return {
-		name: tool.name,
-		label: tool.label,
-		description: tool.description,
-		parameters: tool.parameters as any,
-		prepareArguments: tool.prepareArguments,
-		executionMode: tool.executionMode,
-		execute: async (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate),
-	};
-}

package/packages/agent/src/core/trust-manager.ts

@@ -1,244 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-import lockfile from "proper-lockfile";
-import { CONFIG_DIR_NAME } from "../config.ts";
-import { canonicalizePath, resolvePath } from "../utils/paths.ts";
-
-export type ProjectTrustDecision = boolean | null;
-
-export interface ProjectTrustStoreEntry {
-	path: string;
-	decision: boolean;
-}
-
-export interface ProjectTrustUpdate {
-	path: string;
-	decision: ProjectTrustDecision;
-}
-
-export interface ProjectTrustOption {
-	label: string;
-	trusted: boolean;
-	updates: ProjectTrustUpdate[];
-	savedPath?: string;
-}
-
-type TrustFile = Record<string, boolean | null | undefined>;
-
-const TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES = [
-	"settings.json",
-	"extensions",
-	"skills",
-	"prompts",
-	"themes",
-	"SYSTEM.md",
-	"APPEND_SYSTEM.md",
-] as const;
-
-function normalizeCwd(cwd: string): string {
-	return canonicalizePath(resolvePath(cwd));
-}
-
-function findNearestTrustEntry(data: TrustFile, cwd: string): ProjectTrustStoreEntry | null {
-	let currentDir = normalizeCwd(cwd);
-	while (true) {
-		const value = data[currentDir];
-		if (value === true || value === false) {
-			return { path: currentDir, decision: value };
-		}
-
-		const parentDir = dirname(currentDir);
-		if (parentDir === currentDir) {
-			return null;
-		}
-		currentDir = parentDir;
-	}
-}
-
-export function getProjectTrustParentPath(cwd: string): string | undefined {
-	const trustPath = normalizeCwd(cwd);
-	const parentDir = dirname(trustPath);
-	return parentDir === trustPath ? undefined : parentDir;
-}
-
-export function getProjectTrustOptions(cwd: string, options?: { includeSessionOnly?: boolean }): ProjectTrustOption[] {
-	const trustPath = normalizeCwd(cwd);
-	const trustOptions: ProjectTrustOption[] = [
-		{ label: "Trust", trusted: true, updates: [{ path: trustPath, decision: true }], savedPath: trustPath },
-	];
-	const parentPath = getProjectTrustParentPath(cwd);
-	if (parentPath !== undefined) {
-		trustOptions.push({
-			label: `Trust parent folder (${parentPath})`,
-			trusted: true,
-			updates: [
-				{ path: parentPath, decision: true },
-				{ path: trustPath, decision: null },
-			],
-			savedPath: parentPath,
-		});
-	}
-	if (options?.includeSessionOnly) {
-		trustOptions.push({ label: "Trust (this session only)", trusted: true, updates: [] });
-	}
-	trustOptions.push({
-		label: "Do not trust",
-		trusted: false,
-		updates: [{ path: trustPath, decision: false }],
-		savedPath: trustPath,
-	});
-	if (options?.includeSessionOnly) {
-		trustOptions.push({ label: "Do not trust (this session only)", trusted: false, updates: [] });
-	}
-	return trustOptions;
-}
-
-function readTrustFile(path: string): TrustFile {
-	if (!existsSync(path)) {
-		return {};
-	}
-
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(readFileSync(path, "utf-8"));
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`Failed to read trust store ${path}: ${message}`);
-	}
-
-	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-		throw new Error(`Invalid trust store ${path}: expected an object`);
-	}
-
-	const data: TrustFile = {};
-	for (const [key, value] of Object.entries(parsed)) {
-		if (value !== true && value !== false && value !== null) {
-			throw new Error(`Invalid trust store ${path}: value for ${JSON.stringify(key)} must be true, false, or null`);
-		}
-		data[key] = value;
-	}
-	return data;
-}
-
-function writeTrustFile(path: string, data: TrustFile): void {
-	const sorted: TrustFile = {};
-	for (const key of Object.keys(data).sort()) {
-		const value = data[key];
-		if (value === true || value === false || value === null) {
-			sorted[key] = value;
-		}
-	}
-	mkdirSync(dirname(path), { recursive: true });
-	writeFileSync(path, `${JSON.stringify(sorted, null, 2)}\n`, "utf-8");
-}
-
-function acquireTrustLockSync(path: string): () => void {
-	const trustDir = dirname(path);
-	mkdirSync(trustDir, { recursive: true });
-	const maxAttempts = 10;
-	const delayMs = 20;
-	let lastError: unknown;
-
-	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-		try {
-			return lockfile.lockSync(trustDir, { realpath: false, lockfilePath: `${path}.lock` });
-		} catch (error) {
-			const code =
-				typeof error === "object" && error !== null && "code" in error
-					? String((error as { code?: unknown }).code)
-					: undefined;
-			if (code !== "ELOCKED" || attempt === maxAttempts) {
-				throw error;
-			}
-			lastError = error;
-			const start = Date.now();
-			while (Date.now() - start < delayMs) {
-				// Sleep synchronously to avoid changing trust store callers to async.
-			}
-		}
-	}
-
-	if (lastError instanceof Error) {
-		throw lastError;
-	}
-	throw new Error("Failed to acquire trust store lock");
-}
-
-function withTrustFileLock<T>(path: string, fn: () => T): T {
-	const release = acquireTrustLockSync(path);
-	try {
-		return fn();
-	} finally {
-		release();
-	}
-}
-
-/**
- * Returns true when cwd has project-local resources that must be gated by
- * project trust: trust-requiring entries under the project config dir, or .agents/skills in
- * cwd or one of its ancestors. Returns false when no such project resources
- * exist. The user/global ~/.agents/skills directory is always treated as a
- * trusted user resource and is ignored here, even when cwd is $HOME.
- */
-export function hasTrustRequiringProjectResources(cwd: string): boolean {
-	const homeDir = canonicalizePath(resolvePath(process.env.HOME || homedir()));
-	const userAgentsSkillsDir = join(homeDir, ".agents", "skills");
-	let currentDir = canonicalizePath(resolvePath(cwd));
-
-	const configDir = join(currentDir, CONFIG_DIR_NAME);
-	if (TRUST_REQUIRING_PROJECT_CONFIG_RESOURCES.some((entry) => existsSync(join(configDir, entry)))) {
-		return true;
-	}
-
-	while (true) {
-		const agentsSkillsDir = join(currentDir, ".agents", "skills");
-		if (agentsSkillsDir !== userAgentsSkillsDir && existsSync(agentsSkillsDir)) {
-			return true;
-		}
-
-		const parentDir = dirname(currentDir);
-		if (parentDir === currentDir) {
-			return false;
-		}
-		currentDir = parentDir;
-	}
-}
-
-export class ProjectTrustStore {
-	private trustPath: string;
-
-	constructor(agentDir: string) {
-		this.trustPath = join(resolvePath(agentDir), "trust.json");
-	}
-
-	get(cwd: string): ProjectTrustDecision {
-		return this.getEntry(cwd)?.decision ?? null;
-	}
-
-	getEntry(cwd: string): ProjectTrustStoreEntry | null {
-		return withTrustFileLock(this.trustPath, () => {
-			const data = readTrustFile(this.trustPath);
-			return findNearestTrustEntry(data, cwd);
-		});
-	}
-
-	set(cwd: string, decision: ProjectTrustDecision): void {
-		this.setMany([{ path: cwd, decision }]);
-	}
-
-	setMany(decisions: ProjectTrustUpdate[]): void {
-		withTrustFileLock(this.trustPath, () => {
-			const data = readTrustFile(this.trustPath);
-			for (const { path, decision } of decisions) {
-				const key = normalizeCwd(path);
-				if (decision === null) {
-					delete data[key];
-				} else {
-					data[key] = decision;
-				}
-			}
-			writeTrustFile(this.trustPath, data);
-		});
-	}
-}

package/packages/agent/src/utils/ansi.ts

@@ -1,60 +0,0 @@
-/*
- * Portions of this file are derived from:
- * - ansi-regex (https://github.com/chalk/ansi-regex)
- * - strip-ansi (https://github.com/chalk/strip-ansi)
- *
- * MIT License
- *
- * Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-function ansiRegex({ onlyFirst = false }: { onlyFirst?: boolean } = {}): RegExp {
-	// Valid string terminator sequences are BEL, ESC\, and 0x9c
-	const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
-
-	// OSC sequences only: ESC ] ... ST (non-greedy until the first ST)
-	const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
-
-	// CSI and related: ESC/C1, optional intermediates, optional params (supports ; and :) then final byte
-	const csi = "[\\u001B\\u009B][[\\]()#;?]*(?:\\d{1,4}(?:[;:]\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]";
-
-	const pattern = `${osc}|${csi}`;
-
-	return new RegExp(pattern, onlyFirst ? undefined : "g");
-}
-
-const regex = ansiRegex();
-
-export function stripAnsi(value: string): string {
-	if (typeof value !== "string") {
-		throw new TypeError(`Expected a \`string\`, got \`${typeof value}\``);
-	}
-
-	// Fast path: ANSI codes require ESC (7-bit) or CSI (8-bit) introducer
-	if (!value.includes("\u001B") && !value.includes("\u009B")) {
-		return value;
-	}
-
-	// Even though the regex is global, we don't need to reset the `.lastIndex`
-	// because unlike `.exec()` and `.test()`, `.replace()` does it automatically
-	// and doing it manually has a performance penalty.
-	return value.replace(regex, "");
-}

package/packages/agent/src/utils/fs-watch.ts

@@ -1,30 +0,0 @@
-import { type FSWatcher, type WatchListener, watch } from "node:fs";
-
-export const FS_WATCH_RETRY_DELAY_MS = 5000;
-
-export function closeWatcher(watcher: FSWatcher | null | undefined): void {
-	if (!watcher) {
-		return;
-	}
-
-	try {
-		watcher.close();
-	} catch {
-		// Ignore watcher close errors
-	}
-}
-
-export function watchWithErrorHandler(
-	path: string,
-	listener: WatchListener<string>,
-	onError: () => void,
-): FSWatcher | null {
-	try {
-		const watcher = watch(path, listener);
-		watcher.on("error", onError);
-		return watcher;
-	} catch {
-		onError();
-		return null;
-	}
-}

package/packages/agent/src/utils/git.ts

@@ -1,226 +0,0 @@
-import hostedGitInfo from "hosted-git-info";
-
-/**
- * Parsed git URL information.
- */
-export type GitSource = {
-	/** Always "git" for git sources */
-	type: "git";
-	/** Clone URL (always valid for git clone, without ref suffix) */
-	repo: string;
-	/** Git host domain (e.g., "github.com") */
-	host: string;
-	/** Repository path (e.g., "user/repo") */
-	path: string;
-	/** Git ref (branch, tag, commit) if specified */
-	ref?: string;
-	/** True if ref was specified (package won't be auto-updated) */
-	pinned: boolean;
-};
-
-function splitRef(url: string): { repo: string; ref?: string } {
-	const scpLikeMatch = url.match(/^git@([^:]+):(.+)$/);
-	if (scpLikeMatch) {
-		const pathWithMaybeRef = scpLikeMatch[2] ?? "";
-		const refSeparator = pathWithMaybeRef.indexOf("@");
-		if (refSeparator < 0) return { repo: url };
-		const repoPath = pathWithMaybeRef.slice(0, refSeparator);
-		const ref = pathWithMaybeRef.slice(refSeparator + 1);
-		if (!repoPath || !ref) return { repo: url };
-		return {
-			repo: `git@${scpLikeMatch[1] ?? ""}:${repoPath}`,
-			ref,
-		};
-	}
-
-	if (url.includes("://")) {
-		try {
-			const parsed = new URL(url);
-			const pathWithMaybeRef = parsed.pathname.replace(/^\/+/, "");
-			const refSeparator = pathWithMaybeRef.indexOf("@");
-			if (refSeparator < 0) return { repo: url };
-			const repoPath = pathWithMaybeRef.slice(0, refSeparator);
-			const ref = pathWithMaybeRef.slice(refSeparator + 1);
-			if (!repoPath || !ref) return { repo: url };
-			parsed.pathname = `/${repoPath}`;
-			return {
-				repo: parsed.toString().replace(/\/$/, ""),
-				ref,
-			};
-		} catch {
-			return { repo: url };
-		}
-	}
-
-	const slashIndex = url.indexOf("/");
-	if (slashIndex < 0) {
-		return { repo: url };
-	}
-	const host = url.slice(0, slashIndex);
-	const pathWithMaybeRef = url.slice(slashIndex + 1);
-	const refSeparator = pathWithMaybeRef.indexOf("@");
-	if (refSeparator < 0) {
-		return { repo: url };
-	}
-	const repoPath = pathWithMaybeRef.slice(0, refSeparator);
-	const ref = pathWithMaybeRef.slice(refSeparator + 1);
-	if (!repoPath || !ref) {
-		return { repo: url };
-	}
-	return {
-		repo: `${host}/${repoPath}`,
-		ref,
-	};
-}
-
-function decodeForValidation(value: string): string | null {
-	try {
-		return decodeURIComponent(value);
-	} catch {
-		return null;
-	}
-}
-
-function hasUnsafeGitInstallPart(value: string, allowSlash: boolean): boolean {
-	const decoded = decodeForValidation(value);
-	if (decoded === null) {
-		return true;
-	}
-	const candidates = [value, decoded];
-	for (const candidate of candidates) {
-		if (candidate.includes("\0") || candidate.includes("\\") || candidate.startsWith("/")) {
-			return true;
-		}
-		if (!allowSlash && candidate.includes("/")) {
-			return true;
-		}
-		if (candidate.split("/").includes("..")) {
-			return true;
-		}
-	}
-	return false;
-}
-
-function buildGitSource(args: { repo: string; host: string; path: string; ref?: string }): GitSource | null {
-	if (args.path.startsWith("/")) {
-		return null;
-	}
-	const normalizedPath = args.path.replace(/\.git$/, "").replace(/^\/+/, "");
-	if (!args.host || !normalizedPath || normalizedPath.split("/").length < 2) {
-		return null;
-	}
-	if (hasUnsafeGitInstallPart(args.host, false) || hasUnsafeGitInstallPart(normalizedPath, true)) {
-		return null;
-	}
-
-	return {
-		type: "git",
-		repo: args.repo,
-		host: args.host,
-		path: normalizedPath,
-		ref: args.ref,
-		pinned: Boolean(args.ref),
-	};
-}
-
-function parseGenericGitUrl(url: string): GitSource | null {
-	const { repo: repoWithoutRef, ref } = splitRef(url);
-	let repo = repoWithoutRef;
-	let host = "";
-	let path = "";
-
-	const scpLikeMatch = repoWithoutRef.match(/^git@([^:]+):(.+)$/);
-	if (scpLikeMatch) {
-		host = scpLikeMatch[1] ?? "";
-		path = scpLikeMatch[2] ?? "";
-	} else if (
-		repoWithoutRef.startsWith("https://") ||
-		repoWithoutRef.startsWith("http://") ||
-		repoWithoutRef.startsWith("ssh://") ||
-		repoWithoutRef.startsWith("git://")
-	) {
-		try {
-			const parsed = new URL(repoWithoutRef);
-			host = parsed.hostname;
-			path = parsed.pathname.replace(/^\/+/, "");
-		} catch {
-			return null;
-		}
-	} else {
-		const slashIndex = repoWithoutRef.indexOf("/");
-		if (slashIndex < 0) {
-			return null;
-		}
-		host = repoWithoutRef.slice(0, slashIndex);
-		path = repoWithoutRef.slice(slashIndex + 1);
-		if (!host.includes(".") && host !== "localhost") {
-			return null;
-		}
-		repo = `https://${repoWithoutRef}`;
-	}
-
-	return buildGitSource({ repo, host, path, ref });
-}
-
-/**
- * Parse git source into a GitSource.
- *
- * Rules:
- * - With git: prefix, accept all historical shorthand forms.
- * - Without git: prefix, only accept explicit protocol URLs.
- */
-export function parseGitUrl(source: string): GitSource | null {
-	const trimmed = source.trim();
-	const hasGitPrefix = trimmed.startsWith("git:");
-	const url = hasGitPrefix ? trimmed.slice(4).trim() : trimmed;
-
-	if (!hasGitPrefix && !/^(https?|ssh|git):\/\//i.test(url)) {
-		return null;
-	}
-
-	const split = splitRef(url);
-
-	const hostedCandidates = [split.ref ? `${split.repo}#${split.ref}` : undefined, url].filter(
-		(value): value is string => Boolean(value),
-	);
-	for (const candidate of hostedCandidates) {
-		const info = hostedGitInfo.fromUrl(candidate);
-		if (info) {
-			if (split.ref && info.project?.includes("@")) {
-				continue;
-			}
-			const useHttpsPrefix =
-				!split.repo.startsWith("http://") &&
-				!split.repo.startsWith("https://") &&
-				!split.repo.startsWith("ssh://") &&
-				!split.repo.startsWith("git://") &&
-				!split.repo.startsWith("git@");
-			return buildGitSource({
-				repo: useHttpsPrefix ? `https://${split.repo}` : split.repo,
-				host: info.domain || "",
-				path: `${info.user}/${info.project}`,
-				ref: info.committish || split.ref || undefined,
-			});
-		}
-	}
-
-	const httpsCandidates = [split.ref ? `https://${split.repo}#${split.ref}` : undefined, `https://${url}`].filter(
-		(value): value is string => Boolean(value),
-	);
-	for (const candidate of httpsCandidates) {
-		const info = hostedGitInfo.fromUrl(candidate);
-		if (info) {
-			if (split.ref && info.project?.includes("@")) {
-				continue;
-			}
-			return buildGitSource({
-				repo: `https://${split.repo}`,
-				host: info.domain || "",
-				path: `${info.user}/${info.project}`,
-				ref: info.committish || split.ref || undefined,
-			});
-		}
-	}
-
-	return parseGenericGitUrl(url);
-}