formatting

docs/architecture/url_semantic_search.md

···
 ```typescript
 export interface IVectorDatabase {
   indexUrl(params: IndexUrlParams): Promise<Result<void>>;
-  findSimilarUrls(params: FindSimilarUrlsParams): Promise<Result<UrlSearchResult[]>>;
+  findSimilarUrls(
+    params: FindSimilarUrlsParams,
+  ): Promise<Result<UrlSearchResult[]>>;
   deleteUrl(url: string): Promise<Result<void>>;
 }
 
···
 ```
 
 **Configuration:**
+
 - `USE_IN_MEMORY_EVENTS=false`
 - `VECTOR_DB_URL` configured (Pinecone, Weaviate, etc.)
 - Separate search worker process
···
 ```
 
 **Configuration:**
+
 - `USE_IN_MEMORY_EVENTS=false`
 - Local vector DB via Docker (Weaviate/Qdrant)
 - Both web app and search worker in same process
···
 ```
 
 **Configuration:**
+
 - `USE_IN_MEMORY_EVENTS=true`
 - `USE_MOCK_VECTOR_DB=true`
 - No external vector DB required
···
     }
 
     // 2. Enrich with library counts and user context
-    const enrichedUrls = await this.enrichUrlsWithContext(
-      similarResult.value,
-    );
+    const enrichedUrls = await this.enrichUrlsWithContext(similarResult.value);
 
     return ok(enrichedUrls);
   }
···
     // Generate embeddings and upsert to Pinecone
   }
 
-  async findSimilarUrls(params: FindSimilarUrlsParams): Promise<Result<UrlSearchResult[]>> {
+  async findSimilarUrls(
+    params: FindSimilarUrlsParams,
+  ): Promise<Result<UrlSearchResult[]>> {
     // Query Pinecone for similar vectors
   }
 }
···
     // Index in local Weaviate instance
   }
 
-  async findSimilarUrls(params: FindSimilarUrlsParams): Promise<Result<UrlSearchResult[]>> {
+  async findSimilarUrls(
+    params: FindSimilarUrlsParams,
+  ): Promise<Result<UrlSearchResult[]>> {
     // Query local Weaviate instance
   }
 }
···
     return ok(undefined);
   }
 
-  async findSimilarUrls(params: FindSimilarUrlsParams): Promise<Result<UrlSearchResult[]>> {
+  async findSimilarUrls(
+    params: FindSimilarUrlsParams,
+  ): Promise<Result<UrlSearchResult[]>> {
     // Simple text similarity using keyword matching
     const results = Array.from(this.urls.values())
-      .filter(indexed => this.calculateSimilarity(params.url, indexed.content) > 0.3)
-      .map(indexed => ({
+      .filter(
+        (indexed) =>
+          this.calculateSimilarity(params.url, indexed.content) > 0.3,
+      )
+      .map((indexed) => ({
         url: indexed.url,
         similarity: this.calculateSimilarity(params.url, indexed.content),
         metadata: indexed.metadata,
···
     // Simple keyword-based similarity for mocking
     const queryWords = query.toLowerCase().split(/\W+/);
     const contentWords = content.toLowerCase().split(/\W+/);
-    const intersection = queryWords.filter(word => contentWords.includes(word));
-    return intersection.length / Math.max(queryWords.length, contentWords.length);
+    const intersection = queryWords.filter((word) =>
+      contentWords.includes(word),
+    );
+    return (
+      intersection.length / Math.max(queryWords.length, contentWords.length)
+    );
   }
 }
 ```
···
     limit: parseInt(req.query.limit) || 10,
     page: parseInt(req.query.page) || 1,
   });
-  
+
   res.json(result);
 });
 ```

src/modules/atproto/tests/infrastructure/InMemoryAppPasswordSessionRepository.ts

···
 
   public static getInstance(): InMemoryAppPasswordSessionRepository {
     if (!InMemoryAppPasswordSessionRepository.instance) {
-      InMemoryAppPasswordSessionRepository.instance = new InMemoryAppPasswordSessionRepository();
+      InMemoryAppPasswordSessionRepository.instance =
+        new InMemoryAppPasswordSessionRepository();
     }
     return InMemoryAppPasswordSessionRepository.instance;
   }

src/modules/cards/tests/utils/InMemoryCollectionRepository.ts

···
 
   public static getInstance(): InMemoryCollectionRepository {
     if (!InMemoryCollectionRepository.instance) {
-      InMemoryCollectionRepository.instance = new InMemoryCollectionRepository();
+      InMemoryCollectionRepository.instance =
+        new InMemoryCollectionRepository();
     }
     return InMemoryCollectionRepository.instance;
   }

src/modules/search/application/eventHandlers/CardAddedToLibraryEventHandler.ts

···
     // Get card details to check if it's a URL card
     const cardResult = await this.cardRepository.findById(event.cardId);
     if (cardResult.isErr()) {
-      console.error('Failed to find card for search indexing:', cardResult.error);
+      console.error(
+        'Failed to find card for search indexing:',
+        cardResult.error,
+      );
       return ok(undefined); // Don't fail the event processing
     }
 
     const card = cardResult.value;
     if (!card) {
-      console.warn('Card not found for search indexing:', event.cardId.getStringValue());
+      console.warn(
+        'Card not found for search indexing:',
+        event.cardId.getStringValue(),
+      );
       return ok(undefined);
     }
 

src/modules/search/application/useCases/commands/IndexUrlForSearchUseCase.ts

···
   implements
     UseCase<
       IndexUrlForSearchDTO,
-      Result<IndexUrlForSearchResponseDTO, ValidationError | AppError.UnexpectedError>
+      Result<
+        IndexUrlForSearchResponseDTO,
+        ValidationError | AppError.UnexpectedError
+      >
     >
 {
   constructor(private searchService: SearchService) {}

src/modules/search/application/useCases/queries/GetSimilarUrlsForUrlUseCase.ts

···
 import { URL } from '../../../../cards/domain/value-objects/URL';
 import { SearchService } from '../../../domain/services/SearchService';
 import { GetSimilarUrlsForUrlParams } from '@semble/types/api/requests';
-import { GetSimilarUrlsForUrlResponse, UrlView } from '@semble/types/api/responses';
+import {
+  GetSimilarUrlsForUrlResponse,
+  UrlView,
+} from '@semble/types/api/responses';
 import { Pagination } from '@semble/types/api/common';
 
 export interface GetSimilarUrlsForUrlQuery extends GetSimilarUrlsForUrlParams {

src/modules/search/domain/IVectorDatabase.ts

···
   /**
    * Find URLs similar to the given URL
    */
-  findSimilarUrls(params: FindSimilarUrlsParams): Promise<Result<UrlSearchResult[]>>;
+  findSimilarUrls(
+    params: FindSimilarUrlsParams,
+  ): Promise<Result<UrlSearchResult[]>>;
 
   /**
    * Remove a URL from the search index

src/modules/search/domain/services/SearchService.ts

···
     const enrichedResults = await Promise.all(
       searchResults.map(async (result) => {
         // Get library information for this URL
-        const librariesResult = await this.cardQueryRepository.getLibrariesForUrl(
-          result.url,
-          {
+        const librariesResult =
+          await this.cardQueryRepository.getLibrariesForUrl(result.url, {
             page: 1,
             limit: 1000, // Get all libraries to count them
             sortBy: 'createdAt' as any, // Type assertion needed due to enum mismatch
             sortOrder: 'desc' as any,
-          },
-        );
+          });
 
         const urlLibraryCount = librariesResult.totalCount;
-        
+
         // Check if calling user has this URL in their library
         // Default to false if no calling user (unauthenticated request)
         const urlInLibrary = callingUserId

src/modules/search/infrastructure/InMemoryVectorDatabase.ts

···
   ): Promise<Result<UrlSearchResult[]>> {
     try {
       console.log('all urls to compare', this.urls);
-      const threshold = params.threshold || 0.1; // Lower default threshold for more matches
+      const threshold = params.threshold || 0; // Lower default threshold for more matches
       const results: UrlSearchResult[] = [];
 
       // Get the query URL's content for comparison
···
           indexed.content,
         );
 
-        console.log(`Similarity between "${queryContent}" and "${indexed.content}": ${similarity}`);
+        console.log(
+          `Similarity between "${queryContent}" and "${indexed.content}": ${similarity}`,
+        );
 
         if (similarity >= threshold) {
           results.push({
···
       results.sort((a, b) => b.similarity - a.similarity);
       const limitedResults = results.slice(0, params.limit);
 
-      console.log(`Found ${limitedResults.length} similar URLs above threshold ${threshold}`);
+      console.log(
+        `Found ${limitedResults.length} similar URLs above threshold ${threshold}`,
+      );
 
       return ok(limitedResults);
     } catch (error) {
···
     for (const word of new Set([...words1, ...words2])) {
       const count1 = freq1.get(word) || 0;
       const count2 = freq2.get(word) || 0;
-      
+
       if (count1 > 0 && count2 > 0) {
         sharedWords += Math.min(count1, count2);
       }

src/modules/search/infrastructure/http/controllers/GetSimilarUrlsForUrlController.ts

···
 import { AuthenticatedRequest } from '../../../../../shared/infrastructure/http/middleware/AuthMiddleware';
 
 export class GetSimilarUrlsForUrlController extends Controller {
-  constructor(private getSimilarUrlsForUrlUseCase: GetSimilarUrlsForUrlUseCase) {
+  constructor(
+    private getSimilarUrlsForUrlUseCase: GetSimilarUrlsForUrlUseCase,
+  ) {
     super();
   }
 

src/webapp/api-client/clients/QueryClient.ts

···
     if (params.limit) searchParams.set('limit', params.limit.toString());
     if (params.sortBy) searchParams.set('sortBy', params.sortBy);
     if (params.sortOrder) searchParams.set('sortOrder', params.sortOrder);
-    if (params.threshold) searchParams.set('threshold', params.threshold.toString());
+    if (params.threshold)
+      searchParams.set('threshold', params.threshold.toString());
 
     return this.request<GetSimilarUrlsForUrlResponse>(
       'GET',