btca-server 1.0.63 → 1.0.71

package/src/collections/service.ts

@@ -1,13 +1,21 @@
-import { promises as fs } from 'node:fs';
 import path from 'node:path';
 
+import { Result } from 'better-result';
+
 import { Config } from '../config/index.ts';
 import { Transaction } from '../context/transaction.ts';
 import { CommonHints, getErrorHint, getErrorMessage } from '../errors.ts';
 import { Metrics } from '../metrics/index.ts';
 import { Resources } from '../resources/service.ts';
+import { isGitResource } from '../resources/schema.ts';
 import { FS_RESOURCE_SYSTEM_NOTE, type BtcaFsResource } from '../resources/types.ts';
 import { CollectionError, getCollectionKey, type CollectionResult } from './types.ts';
+import { VirtualFs } from '../vfs/virtual-fs.ts';
+import {
+	clearVirtualCollectionMetadata,
+	setVirtualCollectionMetadata,
+	type VirtualResourceMetadata
+} from './virtual-metadata.ts';
 
 export namespace Collections {
 	export type Service = {
@@ -32,6 +40,126 @@ export namespace Collections {
 		return lines.join('\n');
 	};
 
+	const ignoreErrors = async (action: () => Promise<unknown>) => {
+		const result = await Result.tryPromise(action);
+		result.match({
+			ok: () => undefined,
+			err: () => undefined
+		});
+	};
+
+	const initVirtualRoot = (collectionPath: string, vfsId: string) =>
+		Result.tryPromise({
+			try: () => VirtualFs.mkdir(collectionPath, { recursive: true }, vfsId),
+			catch: (cause) =>
+				new CollectionError({
+					message: `Failed to initialize virtual collection root: "${collectionPath}"`,
+					hint: 'Check that the virtual filesystem is available.',
+					cause
+				})
+		});
+
+	const loadResource = (resources: Resources.Service, name: string, quiet: boolean) =>
+		Result.tryPromise({
+			try: () => resources.load(name, { quiet }),
+			catch: (cause) => {
+				const underlyingHint = getErrorHint(cause);
+				const underlyingMessage = getErrorMessage(cause);
+				return new CollectionError({
+					message: `Failed to load resource "${name}": ${underlyingMessage}`,
+					hint:
+						underlyingHint ??
+						`${CommonHints.CLEAR_CACHE} Check that the resource "${name}" is correctly configured.`,
+					cause
+				});
+			}
+		});
+
+	const resolveResourcePath = (resource: BtcaFsResource) =>
+		Result.tryPromise({
+			try: () => resource.getAbsoluteDirectoryPath(),
+			catch: (cause) =>
+				new CollectionError({
+					message: `Failed to get path for resource "${resource.name}"`,
+					hint: CommonHints.CLEAR_CACHE,
+					cause
+				})
+		});
+
+	const virtualizeResource = (args: {
+		resource: BtcaFsResource;
+		resourcePath: string;
+		virtualResourcePath: string;
+		vfsId: string;
+	}) =>
+		Result.tryPromise({
+			try: () =>
+				VirtualFs.importDirectoryFromDisk({
+					sourcePath: args.resourcePath,
+					destinationPath: args.virtualResourcePath,
+					vfsId: args.vfsId,
+					ignore: (relativePath) => {
+						const normalized = relativePath.split(path.sep).join('/');
+						return (
+							normalized === '.git' ||
+							normalized.startsWith('.git/') ||
+							normalized.includes('/.git/')
+						);
+					}
+				}),
+			catch: (cause) =>
+				new CollectionError({
+					message: `Failed to virtualize resource "${args.resource.name}"`,
+					hint: CommonHints.CLEAR_CACHE,
+					cause
+				})
+		});
+
+	const getGitHeadHash = async (resourcePath: string) => {
+		const result = await Result.tryPromise(async () => {
+			const proc = Bun.spawn(['git', 'rev-parse', 'HEAD'], {
+				cwd: resourcePath,
+				stdout: 'pipe',
+				stderr: 'pipe'
+			});
+			const stdout = await new Response(proc.stdout).text();
+			const exitCode = await proc.exited;
+			if (exitCode !== 0) return undefined;
+			const trimmed = stdout.trim();
+			return trimmed.length > 0 ? trimmed : undefined;
+		});
+
+		return result.match({
+			ok: (value) => value,
+			err: () => undefined
+		});
+	};
+
+	const buildVirtualMetadata = async (args: {
+		resource: BtcaFsResource;
+		resourcePath: string;
+		loadedAt: string;
+		definition?: ReturnType<Config.Service['getResource']>;
+	}) => {
+		if (!args.definition) return null;
+		const base = {
+			name: args.resource.name,
+			fsName: args.resource.fsName,
+			type: args.resource.type,
+			path: args.resourcePath,
+			repoSubPaths: args.resource.repoSubPaths,
+			loadedAt: args.loadedAt
+		};
+		if (!isGitResource(args.definition)) return base;
+		const commit = await getGitHeadHash(args.resourcePath);
+		return {
+			...base,
+			url: args.definition.url,
+			branch: args.definition.branch,
+			commit
+		};
+	};
+
 	export const create = (args: {
 		config: Config.Service;
 		resources: Resources.Service;
@@ -50,72 +178,74 @@ export namespace Collections {
 
 					const sortedNames = [...uniqueNames].sort((a, b) => a.localeCompare(b));
 					const key = getCollectionKey(sortedNames);
-					const collectionPath = path.join(args.config.collectionsDirectory, key);
+					const collectionPath = '/';
+					const vfsId = VirtualFs.create();
+					const cleanupVirtual = () => {
+						VirtualFs.dispose(vfsId);
+						clearVirtualCollectionMetadata(vfsId);
+					};
 
-					try {
-						await fs.mkdir(collectionPath, { recursive: true });
-					} catch (cause) {
-						throw new CollectionError({
-							message: `Failed to create collection directory: "${collectionPath}"`,
-							hint: 'Check that you have write permissions to the btca data directory.',
-							cause
-						});
-					}
+					const result = await Result.gen(async function* () {
+						yield* Result.await(initVirtualRoot(collectionPath, vfsId));
 
-					const loadedResources: BtcaFsResource[] = [];
-					for (const name of sortedNames) {
-						try {
-							loadedResources.push(await args.resources.load(name, { quiet }));
-						} catch (cause) {
-							// Preserve the hint from the underlying error if available
-							const underlyingHint = getErrorHint(cause);
-							const underlyingMessage = getErrorMessage(cause);
-							throw new CollectionError({
-								message: `Failed to load resource "${name}": ${underlyingMessage}`,
-								hint:
-									underlyingHint ??
-									`${CommonHints.CLEAR_CACHE} Check that the resource "${name}" is correctly configured.`,
-								cause
-							});
+						const loadedResources: BtcaFsResource[] = [];
+						for (const name of sortedNames) {
+							const resource = yield* Result.await(loadResource(args.resources, name, quiet));
+							loadedResources.push(resource);
 						}
-					}
 
-					for (const resource of loadedResources) {
-						let resourcePath: string;
-						try {
-							resourcePath = await resource.getAbsoluteDirectoryPath();
-						} catch (cause) {
-							throw new CollectionError({
-								message: `Failed to get path for resource "${resource.name}"`,
-								hint: CommonHints.CLEAR_CACHE,
-								cause
-							});
-						}
+						const metadataResources: VirtualResourceMetadata[] = [];
+						const loadedAt = new Date().toISOString();
+						for (const resource of loadedResources) {
+							const resourcePath = yield* Result.await(resolveResourcePath(resource));
+							const virtualResourcePath = path.posix.join('/', resource.fsName);
 
-						const linkPath = path.join(collectionPath, resource.fsName);
-						try {
-							await fs.rm(linkPath, { recursive: true, force: true });
-						} catch {
-							// ignore
-						}
+							await ignoreErrors(() =>
+								VirtualFs.rm(virtualResourcePath, { recursive: true, force: true }, vfsId)
+							);
+
+							yield* Result.await(
+								virtualizeResource({
+									resource,
+									resourcePath,
+									virtualResourcePath,
+									vfsId
+								})
+							);
 
-						try {
-							await fs.symlink(resourcePath, linkPath, 'junction');
-						} catch (cause) {
-							throw new CollectionError({
-								message: `Failed to create symlink for resource "${resource.name}"`,
-								hint: 'This may be a filesystem permissions issue or the link already exists.',
-								cause
+							const definition = args.config.getResource(resource.name);
+							const metadata = await buildVirtualMetadata({
+								resource,
+								resourcePath,
+								loadedAt,
+								definition
 							});
+							if (metadata) metadataResources.push(metadata);
 						}
-					}
 
-					const instructionBlocks = loadedResources.map(createCollectionInstructionBlock);
+						setVirtualCollectionMetadata({
+							vfsId,
+							collectionKey: key,
+							createdAt: loadedAt,
+							resources: metadataResources
+						});
 
-					return {
-						path: collectionPath,
-						agentInstructions: instructionBlocks.join('\n\n')
-					};
+						const instructionBlocks = loadedResources.map(createCollectionInstructionBlock);
+
+						return Result.ok({
+							path: collectionPath,
+							agentInstructions: instructionBlocks.join('\n\n'),
+							vfsId
+						});
+					});
+
+					return result.match({
+						ok: (value) => value,
+						err: (error) => {
+							cleanupVirtual();
+							throw error;
+						}
+					});
 				})
 		};
 	};

package/src/collections/types.ts

@@ -4,6 +4,7 @@ import { resourceNameToKey } from '../resources/helpers.ts';
 export type CollectionResult = {
 	path: string;
 	agentInstructions: string;
+	vfsId?: string;
 };
 
 export class CollectionError extends Error {

package/src/collections/virtual-metadata.ts

@@ -0,0 +1,32 @@
+export type VirtualResourceMetadata = {
+	name: string;
+	fsName: string;
+	type: 'git' | 'local';
+	path: string;
+	repoSubPaths: readonly string[];
+	url?: string;
+	branch?: string;
+	commit?: string;
+	loadedAt: string;
+};
+
+export type VirtualCollectionMetadata = {
+	vfsId: string;
+	collectionKey: string;
+	createdAt: string;
+	resources: VirtualResourceMetadata[];
+};
+
+const metadataByVfsId = new Map<string, VirtualCollectionMetadata>();
+
+export const setVirtualCollectionMetadata = (metadata: VirtualCollectionMetadata) => {
+	metadataByVfsId.set(metadata.vfsId, metadata);
+};
+
+export const getVirtualCollectionMetadata = (vfsId: string) => metadataByVfsId.get(vfsId);
+
+export const clearVirtualCollectionMetadata = (vfsId: string) => metadataByVfsId.delete(vfsId);
+
+export const clearAllVirtualCollectionMetadata = () => {
+	metadataByVfsId.clear();
+};