btca-server 1.0.962 → 2.0.0

package/src/providers/model.ts

@@ -4,7 +4,12 @@
  */
 import type { LanguageModel } from 'ai';
 
-import { Auth } from './auth.ts';
+import {
+	getAuthStatus,
+	getAuthenticatedProviders,
+	getProviderAuthHint,
+	isAuthenticated
+} from './auth.ts';
 import {
 	getProviderFactory,
 	isProviderSupported,
@@ -12,162 +17,137 @@ import {
 	type ProviderOptions
 } from './registry.ts';
 
-export namespace Model {
-	export class ProviderNotFoundError extends Error {
-		readonly _tag = 'ProviderNotFoundError';
-		readonly providerId: string;
-		readonly hint: string;
-
-		constructor(providerId: string) {
-			super(`Provider "${providerId}" is not supported`);
-			this.providerId = providerId;
-			this.hint =
-				'Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.';
-		}
+export class ProviderNotFoundError extends Error {
+	readonly _tag = 'ProviderNotFoundError';
+	readonly providerId: string;
+	readonly hint: string;
+
+	constructor(providerId: string) {
+		super(`Provider "${providerId}" is not supported`);
+		this.providerId = providerId;
+		this.hint =
+			'Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.';
 	}
+}
 
-	export class ProviderNotAuthenticatedError extends Error {
-		readonly _tag = 'ProviderNotAuthenticatedError';
-		readonly providerId: string;
-		readonly hint: string;
+export class ProviderNotAuthenticatedError extends Error {
+	readonly _tag = 'ProviderNotAuthenticatedError';
+	readonly providerId: string;
+	readonly hint: string;
 
-		constructor(providerId: string) {
-			super(`Provider "${providerId}" is not authenticated.`);
-			this.providerId = providerId;
-			this.hint = Auth.getProviderAuthHint(providerId);
-		}
+	constructor(providerId: string) {
+		super(`Provider "${providerId}" is not authenticated.`);
+		this.providerId = providerId;
+		this.hint = getProviderAuthHint(providerId);
 	}
+}
 
-	export class ProviderAuthTypeError extends Error {
-		readonly _tag = 'ProviderAuthTypeError';
-		readonly providerId: string;
-		readonly authType: string;
-		readonly hint: string;
-
-		constructor(args: { providerId: string; authType: string }) {
-			super(`Provider "${args.providerId}" does not support "${args.authType}" auth.`);
-			this.providerId = args.providerId;
-			this.authType = args.authType;
-			this.hint = Auth.getProviderAuthHint(args.providerId);
-		}
+export class ProviderAuthTypeError extends Error {
+	readonly _tag = 'ProviderAuthTypeError';
+	readonly providerId: string;
+	readonly authType: string;
+	readonly hint: string;
+
+	constructor(args: { providerId: string; authType: string }) {
+		super(`Provider "${args.providerId}" does not support "${args.authType}" auth.`);
+		this.providerId = args.providerId;
+		this.authType = args.authType;
+		this.hint = getProviderAuthHint(args.providerId);
 	}
+}
 
-	export class ProviderOptionsError extends Error {
-		readonly _tag = 'ProviderOptionsError';
-		readonly providerId: string;
-		readonly hint: string;
+export class ProviderOptionsError extends Error {
+	readonly _tag = 'ProviderOptionsError';
+	readonly providerId: string;
+	readonly hint: string;
 
-		constructor(args: { providerId: string; message: string; hint: string }) {
-			super(args.message);
-			this.providerId = args.providerId;
-			this.hint = args.hint;
-		}
+	constructor(args: { providerId: string; message: string; hint: string }) {
+		super(args.message);
+		this.providerId = args.providerId;
+		this.hint = args.hint;
 	}
+}
 
-	export type ModelOptions = {
-		/** Additional provider options */
-		providerOptions?: Partial<ProviderOptions>;
-		/** Skip authentication check (useful for providers with wellknown auth) */
-		skipAuth?: boolean;
-		/** Allow missing auth for providers that can be used without credentials */
-		allowMissingAuth?: boolean;
-	};
-
-	/**
-	 * Create an AI SDK model with authentication
-	 *
-	 * @param providerId - The provider ID (e.g., 'anthropic', 'openai')
-	 * @param modelId - The model ID (e.g., 'claude-sonnet-4-20250514', 'gpt-4o')
-	 * @param options - Additional options
-	 * @returns The AI SDK language model
-	 */
-	export async function getModel(
-		providerId: string,
-		modelId: string,
-		options: ModelOptions = {}
-	): Promise<LanguageModel> {
-		const normalizedProviderId = normalizeProviderId(providerId);
-
-		// Check if provider is supported
-		if (!isProviderSupported(normalizedProviderId)) {
-			throw new ProviderNotFoundError(providerId);
-		}
+export type ModelOptions = {
+	providerOptions?: Partial<ProviderOptions>;
+	skipAuth?: boolean;
+	allowMissingAuth?: boolean;
+};
+
+export const getModel = async (
+	providerId: string,
+	modelId: string,
+	options: ModelOptions = {}
+): Promise<LanguageModel> => {
+	const normalizedProviderId = normalizeProviderId(providerId);
+
+	if (!isProviderSupported(normalizedProviderId)) {
+		throw new ProviderNotFoundError(providerId);
+	}
 
-		// Get the provider factory
-		const factory = getProviderFactory(normalizedProviderId);
-		if (!factory) {
-			throw new ProviderNotFoundError(providerId);
-		}
+	const factory = getProviderFactory(normalizedProviderId);
+	if (!factory) {
+		throw new ProviderNotFoundError(providerId);
+	}
 
-		// Get authentication
-		let apiKey: string | undefined;
-		let accountId: string | undefined;
+	let apiKey: string | undefined;
+	let accountId: string | undefined;
 
-		if (!options.skipAuth) {
-			const status = await Auth.getAuthStatus(normalizedProviderId);
-			if (status.status === 'missing') {
-				if (!options.allowMissingAuth) {
-					throw new ProviderNotAuthenticatedError(providerId);
-				}
-			}
-			if (status.status === 'invalid') {
-				throw new ProviderAuthTypeError({ providerId, authType: status.authType });
-			}
-			if (status.status === 'ok') {
-				apiKey = status.apiKey;
-				accountId = status.accountId;
+	if (!options.skipAuth) {
+		const status = await getAuthStatus(normalizedProviderId);
+		if (status.status === 'missing') {
+			if (!options.allowMissingAuth) {
+				throw new ProviderNotAuthenticatedError(providerId);
 			}
 		}
-
-		// Build provider options
-		const providerOptions: ProviderOptions = {
-			...options.providerOptions,
-			...(accountId ? { accountId } : {})
-		};
-
-		if (apiKey) {
-			providerOptions.apiKey = apiKey;
+		if (status.status === 'invalid') {
+			throw new ProviderAuthTypeError({ providerId, authType: status.authType });
 		}
-
-		if (normalizedProviderId === 'openai-compat') {
-			const baseURL = providerOptions.baseURL?.trim();
-			const name = providerOptions.name?.trim();
-			if (!baseURL || !name) {
-				throw new ProviderOptionsError({
-					providerId: normalizedProviderId,
-					message: 'openai-compat requires baseURL and name',
-					hint: 'Run "btca connect -p openai-compat" to configure baseURL and name.'
-				});
-			}
-			providerOptions.baseURL = baseURL;
-			providerOptions.name = name;
+		if (status.status === 'ok') {
+			apiKey = status.apiKey;
+			accountId = status.accountId;
 		}
+	}
 
-		// Create the provider and get the model
-		const provider = factory(providerOptions);
-		const model = provider(modelId);
+	const providerOptions: ProviderOptions = {
+		...options.providerOptions,
+		...(accountId ? { accountId } : {})
+	};
 
-		return model as LanguageModel;
+	if (apiKey) {
+		providerOptions.apiKey = apiKey;
 	}
 
-	/**
-	 * Check if a model can be used (provider is supported and authenticated)
-	 */
-	export async function canUseModel(providerId: string): Promise<boolean> {
-		const normalizedProviderId = normalizeProviderId(providerId);
-
-		if (!isProviderSupported(normalizedProviderId)) {
-			return false;
+	if (normalizedProviderId === 'openai-compat') {
+		const baseURL = providerOptions.baseURL?.trim();
+		const name = providerOptions.name?.trim();
+		if (!baseURL || !name) {
+			throw new ProviderOptionsError({
+				providerId: normalizedProviderId,
+				message: 'openai-compat requires baseURL and name',
+				hint: 'Run "btca connect -p openai-compat" to configure baseURL and name.'
+			});
 		}
-
-		return Auth.isAuthenticated(normalizedProviderId);
+		providerOptions.baseURL = baseURL;
+		providerOptions.name = name;
 	}
 
-	/**
-	 * Get all available providers (supported and authenticated)
-	 */
-	export async function getAvailableProviders(): Promise<string[]> {
-		const authenticatedProviders = await Auth.getAuthenticatedProviders();
-		return authenticatedProviders.filter((provider) => isProviderSupported(provider));
+	const provider = factory(providerOptions);
+	const model = provider(modelId);
+	return model as LanguageModel;
+};
+
+export const canUseModel = async (providerId: string): Promise<boolean> => {
+	const normalizedProviderId = normalizeProviderId(providerId);
+
+	if (!isProviderSupported(normalizedProviderId)) {
+		return false;
 	}
-}
+
+	return isAuthenticated(normalizedProviderId);
+};
+
+export const getAvailableProviders = async (): Promise<string[]> => {
+	const authenticatedProviders = await getAuthenticatedProviders();
+	return authenticatedProviders.filter((provider) => isProviderSupported(provider));
+};

package/src/providers/openai.ts

@@ -1,6 +1,6 @@
 import { createOpenAI } from '@ai-sdk/openai';
 import * as os from 'node:os';
-import { Auth } from './auth.ts';
+import { getCredentials, setCredentials } from './auth.ts';
 
 const CLIENT_ID = 'app_EMoamEEZ73f0CkXaXp7hrann';
 const ISSUER = 'https://auth.openai.com';
@@ -165,7 +165,7 @@ export function createOpenAICodex(
 	} = {}
 ) {
 	const customFetch = (async (requestInput, init) => {
-		const storedAuth = await Auth.getCredentials('openai');
+		const storedAuth = await getCredentials('openai');
 		let accessToken = options.apiKey;
 		let accountId = options.accountId;
 
@@ -178,7 +178,7 @@ export function createOpenAICodex(
 				const refreshedAccountId = extractAccountId(tokens) ?? accountId;
 				accessToken = tokens.access_token;
 				accountId = refreshedAccountId;
-				await Auth.setCredentials('openai', {
+				await setCredentials('openai', {
 					type: 'oauth',
 					refresh: tokens.refresh_token ?? storedAuth.refresh,
 					access: tokens.access_token,

package/src/resources/impls/git.ts

@@ -1,9 +1,7 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
-import { Result } from 'better-result';
-
-import { Metrics } from '../../metrics/index.ts';
+import { metricsInfo, withMetricsSpan } from '../../metrics/index.ts';
 import { CommonHints } from '../../errors.ts';
 import { ResourceError, resourceNameToKey } from '../helpers.ts';
 import { GitResourceSchema } from '../schema.ts';
@@ -26,7 +24,11 @@ const isBranchNotFoundError = (cause: unknown) => {
 };
 
 const cleanupDirectory = async (pathToRemove: string) => {
-	await Result.tryPromise(() => fs.rm(pathToRemove, { recursive: true, force: true }));
+	try {
+		await fs.rm(pathToRemove, { recursive: true, force: true });
+	} catch {
+		return;
+	}
 };
 
 const validateGitUrl = (url: string): { success: true } | { success: false; error: string } => {
@@ -50,11 +52,12 @@ const validateSearchPath = (
 };
 
 const directoryExists = async (path: string): Promise<boolean> => {
-	const result = await Result.tryPromise(() => fs.stat(path));
-	return result.match({
-		ok: (stat) => stat.isDirectory(),
-		err: () => false
-	});
+	try {
+		const stat = await fs.stat(path);
+		return stat.isDirectory();
+	} catch {
+		return false;
+	}
 };
 
 /**
@@ -172,10 +175,11 @@ const runGitChecked = async (
 	options: { cwd?: string; quiet: boolean },
 	buildError: (result: GitRunResult) => ResourceError
 ) => {
-	const result = await Result.tryPromise(() => runGit(args, options));
-	return result.andThen((runResult) =>
-		runResult.exitCode === 0 ? Result.ok(runResult) : Result.err(buildError(runResult))
-	);
+	const runResult = await runGit(args, options);
+	if (runResult.exitCode !== 0) {
+		throw buildError(runResult);
+	}
+	return runResult;
 };
 
 const runGit = async (
@@ -268,62 +272,50 @@ const gitClone = async (args: {
 			]
 		: ['clone', '--depth', '1', '-b', args.repoBranch, args.repoUrl, args.localAbsolutePath];
 
-	const result = await Result.gen(async function* () {
-		yield* Result.await(
-			runGitChecked(cloneArgs, { quiet: args.quiet }, (cloneResult) => {
-				const errorType = detectGitErrorType(cloneResult.stderr);
-				const { message, hint } = getGitErrorDetails(errorType, {
-					operation: 'clone',
-					branch: args.repoBranch,
-					url: args.repoUrl
-				});
+	await runGitChecked(cloneArgs, { quiet: args.quiet }, (cloneResult) => {
+		const errorType = detectGitErrorType(cloneResult.stderr);
+		const { message, hint } = getGitErrorDetails(errorType, {
+			operation: 'clone',
+			branch: args.repoBranch,
+			url: args.repoUrl
+		});
 
-				return new ResourceError({
-					message,
-					hint,
+		return new ResourceError({
+			message,
+			hint,
+			cause: new Error(
+				`git clone failed with exit code ${cloneResult.exitCode}: ${cloneResult.stderr}`
+			)
+		});
+	});
+
+	if (needsSparseCheckout) {
+		await runGitChecked(
+			['sparse-checkout', 'set', ...args.repoSubPaths],
+			{ cwd: args.localAbsolutePath, quiet: args.quiet },
+			(sparseResult) =>
+				new ResourceError({
+					message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
+					hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
 					cause: new Error(
-						`git clone failed with exit code ${cloneResult.exitCode}: ${cloneResult.stderr}`
+						`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
 					)
-				});
-			})
+				})
 		);
 
-		if (needsSparseCheckout) {
-			yield* Result.await(
-				runGitChecked(
-					['sparse-checkout', 'set', ...args.repoSubPaths],
-					{ cwd: args.localAbsolutePath, quiet: args.quiet },
-					(sparseResult) =>
-						new ResourceError({
-							message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
-							hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
-							cause: new Error(
-								`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
-							)
-						})
-				)
-			);
-
-			yield* Result.await(
-				runGitChecked(
-					['checkout'],
-					{ cwd: args.localAbsolutePath, quiet: args.quiet },
-					(checkout) =>
-						new ResourceError({
-							message: 'Failed to checkout repository',
-							hint: CommonHints.CLEAR_CACHE,
-							cause: new Error(
-								`git checkout failed with exit code ${checkout.exitCode}: ${checkout.stderr}`
-							)
-						})
-				)
-			);
-		}
-
-		return Result.ok(undefined);
-	});
-
-	if (!Result.isOk(result)) throw result.error;
+		await runGitChecked(
+			['checkout'],
+			{ cwd: args.localAbsolutePath, quiet: args.quiet },
+			(checkout) =>
+				new ResourceError({
+					message: 'Failed to checkout repository',
+					hint: CommonHints.CLEAR_CACHE,
+					cause: new Error(
+						`git checkout failed with exit code ${checkout.exitCode}: ${checkout.stderr}`
+					)
+				})
+		);
+	}
 };
 
 const gitUpdate = async (args: {
@@ -332,80 +324,66 @@ const gitUpdate = async (args: {
 	repoSubPaths: readonly string[];
 	quiet: boolean;
 }) => {
-	const result = await Result.gen(async function* () {
-		yield* Result.await(
-			runGitChecked(
-				['fetch', '--depth', '1', 'origin', args.branch],
-				{ cwd: args.localAbsolutePath, quiet: args.quiet },
-				(fetchResult) => {
-					const errorType = detectGitErrorType(fetchResult.stderr);
-					const { message, hint } = getGitErrorDetails(errorType, {
-						operation: 'fetch',
-						branch: args.branch
-					});
-
-					return new ResourceError({
-						message,
-						hint,
-						cause: new Error(
-							`git fetch failed with exit code ${fetchResult.exitCode}: ${fetchResult.stderr}`
-						)
-					});
-				}
-			)
-		);
-
-		yield* Result.await(
-			runGitChecked(
-				['reset', '--hard', `origin/${args.branch}`],
-				{ cwd: args.localAbsolutePath, quiet: args.quiet },
-				(resetResult) =>
-					new ResourceError({
-						message: 'Failed to update local repository',
-						hint: `${CommonHints.CLEAR_CACHE} This will re-clone the repository from scratch.`,
-						cause: new Error(
-							`git reset failed with exit code ${resetResult.exitCode}: ${resetResult.stderr}`
-						)
-					})
-			)
-		);
+	await runGitChecked(
+		['fetch', '--depth', '1', 'origin', args.branch],
+		{ cwd: args.localAbsolutePath, quiet: args.quiet },
+		(fetchResult) => {
+			const errorType = detectGitErrorType(fetchResult.stderr);
+			const { message, hint } = getGitErrorDetails(errorType, {
+				operation: 'fetch',
+				branch: args.branch
+			});
 
-		if (args.repoSubPaths.length > 0) {
-			yield* Result.await(
-				runGitChecked(
-					['sparse-checkout', 'set', ...args.repoSubPaths],
-					{ cwd: args.localAbsolutePath, quiet: args.quiet },
-					(sparseResult) =>
-						new ResourceError({
-							message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
-							hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
-							cause: new Error(
-								`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
-							)
-						})
-				)
-			);
-
-			yield* Result.await(
-				runGitChecked(
-					['checkout'],
-					{ cwd: args.localAbsolutePath, quiet: args.quiet },
-					(checkoutResult) =>
-						new ResourceError({
-							message: 'Failed to checkout repository',
-							hint: CommonHints.CLEAR_CACHE,
-							cause: new Error(
-								`git checkout failed with exit code ${checkoutResult.exitCode}: ${checkoutResult.stderr}`
-							)
-						})
+			return new ResourceError({
+				message,
+				hint,
+				cause: new Error(
+					`git fetch failed with exit code ${fetchResult.exitCode}: ${fetchResult.stderr}`
 				)
-			);
+			});
 		}
+	);
 
-		return Result.ok(undefined);
-	});
+	await runGitChecked(
+		['reset', '--hard', `origin/${args.branch}`],
+		{ cwd: args.localAbsolutePath, quiet: args.quiet },
+		(resetResult) =>
+			new ResourceError({
+				message: 'Failed to update local repository',
+				hint: `${CommonHints.CLEAR_CACHE} This will re-clone the repository from scratch.`,
+				cause: new Error(
+					`git reset failed with exit code ${resetResult.exitCode}: ${resetResult.stderr}`
+				)
+			})
+	);
+
+	if (args.repoSubPaths.length > 0) {
+		await runGitChecked(
+			['sparse-checkout', 'set', ...args.repoSubPaths],
+			{ cwd: args.localAbsolutePath, quiet: args.quiet },
+			(sparseResult) =>
+				new ResourceError({
+					message: `Failed to set sparse-checkout path(s): "${args.repoSubPaths.join(', ')}"`,
+					hint: 'Verify the search paths exist in the repository. Check the repository structure to find the correct path.',
+					cause: new Error(
+						`git sparse-checkout failed with exit code ${sparseResult.exitCode}: ${sparseResult.stderr}`
+					)
+				})
+		);
 
-	if (!Result.isOk(result)) throw result.error;
+		await runGitChecked(
+			['checkout'],
+			{ cwd: args.localAbsolutePath, quiet: args.quiet },
+			(checkoutResult) =>
+				new ResourceError({
+					message: 'Failed to checkout repository',
+					hint: CommonHints.CLEAR_CACHE,
+					cause: new Error(
+						`git checkout failed with exit code ${checkoutResult.exitCode}: ${checkoutResult.stderr}`
+					)
+				})
+		);
+	}
 };
 
 /**
@@ -459,28 +437,27 @@ const ensureGitResource = async (config: BtcaGitResourceArgs): Promise<string> =
 		: config.resourcesDirectoryPath;
 	const localPath = path.join(basePath, resourceKey);
 
-	const mkdirResult = await Result.tryPromise({
-		try: () => fs.mkdir(basePath, { recursive: true }),
-		catch: (cause) =>
-			new ResourceError({
-				message: 'Failed to create resources directory',
-				hint: 'Check that you have write permissions to the btca data directory.',
-				cause
-			})
-	});
-	if (!Result.isOk(mkdirResult)) throw mkdirResult.error;
+	try {
+		await fs.mkdir(basePath, { recursive: true });
+	} catch (cause) {
+		throw new ResourceError({
+			message: 'Failed to create resources directory',
+			hint: 'Check that you have write permissions to the btca data directory.',
+			cause
+		});
+	}
 
 	if (config.ephemeral) {
 		await cleanupDirectory(localPath);
 	}
 
-	return Metrics.span(
+	return withMetricsSpan(
 		'resource.git.ensure',
 		async () => {
 			const exists = await directoryExists(localPath);
 
 			if (exists && !config.ephemeral) {
-				Metrics.info('resource.git.update', {
+				metricsInfo('resource.git.update', {
 					name: config.name,
 					branch: config.branch,
 					repoSubPaths: config.repoSubPaths
@@ -497,7 +474,7 @@ const ensureGitResource = async (config: BtcaGitResourceArgs): Promise<string> =
 				return localPath;
 			}
 
-			Metrics.info('resource.git.clone', {
+			metricsInfo('resource.git.clone', {
 				name: config.name,
 				branch: config.ephemeral ? 'fallback' : config.branch,
 				repoSubPaths: config.repoSubPaths