Bouncer Feed Filter

// src/content/feedObserver.tsconst observer = new MutationObserver((mutations) => {  for (const mutation of mutations) {    for (const node of mutation.addedNodes) {      if (node instanceof HTMLElement) {        const post = extractPost(node);        if (post) classifyAndFilter(post);      }    }  }});
observer.observe(document.body, { childList: true, subtree: true });

// src/adapters/twitter.tsexport interface ExtractedPost {  id: string;  text: string;  authorHandle: string;  imageUrls: string[];  element: HTMLElement;}
export function extractPost(element: HTMLElement): ExtractedPost | null {  const article = element.querySelector('article[data-testid="tweet"]');  if (!article) return null;
  const tweetText = article.querySelector('[data-testid="tweetText"]')?.textContent ?? '';  const handle = article.querySelector('[data-testid="User-Name"] a')?.getAttribute('href') ?? '';  const images = [...article.querySelectorAll('img[src*="pbs.twimg.com/media"]')]    .map(img => (img as HTMLImageElement).src);
  return {    id: article.closest('[data-testid]')?.getAttribute('data-testid') ?? crypto.randomUUID(),    text: tweetText,    authorHandle: handle.replace('/', ''),    imageUrls: images,    element: article as HTMLElement,  };}

// src/models/classify.tsexport interface ClassificationResult {  filtered: boolean;  matchedCategory: string | null;  reasoning: string;}
export async function classifyPost(  post: ExtractedPost,  filters: string[],  model: ModelConfig): Promise<ClassificationResult> {  const prompt = buildClassificationPrompt(post.text, filters, post.imageUrls);  const response = await model.provider.complete(prompt);  return parseClassificationResponse(response);}
function buildClassificationPrompt(  text: string,  filters: string[],  imageUrls: string[]): string {  return `You are a content filter. Given a social media post, determine if it matches any of the user's filter categories.
Filter categories: ${filters.map(f => `"${f}"`).join(', ')}
Post text:${text}
${imageUrls.length > 0 ? `The post contains ${imageUrls.length} image(s).` : ''}
Respond with JSON:{  "filtered": boolean,  "matchedCategory": "category name or null",  "reasoning": "brief explanation"}`;}

// src/content/filterUI.tsexport function hidePost(element: HTMLElement, reason: string): void {  element.style.transition = 'opacity 0.3s ease-out';  element.style.opacity = '0';  setTimeout(() => {    element.style.display = 'none';    element.dataset.bouncerFiltered = 'true';    element.dataset.bouncerReason = reason;  }, 300);}
export function showFilteredIndicator(count: number): void {  const indicator = document.getElementById('bouncer-filtered-count');  if (indicator) indicator.textContent = `${count} filtered`;}

// src/models/providers/myProvider.tsimport type { ModelProvider, CompletionRequest, CompletionResponse } from '../types';
export class MyProvider implements ModelProvider {  private apiKey: string;  private endpoint = 'https://api.myprovider.com/v1/chat/completions';
  constructor(apiKey: string) {    this.apiKey = apiKey;  }
  async complete(request: CompletionRequest): Promise<CompletionResponse> {    const response = await fetch(this.endpoint, {      method: 'POST',      headers: {        'Authorization': `Bearer ${this.apiKey}`,        'Content-Type': 'application/json',      },      body: JSON.stringify({        model: request.model,        messages: [{ role: 'user', content: request.prompt }],        max_tokens: 256,      }),    });
    const data = await response.json();    return {      text: data.choices[0].message.content,      usage: data.usage,    };  }}

// src/models/registry.tsimport { MyProvider } from './providers/myProvider';
export function createProvider(config: StoredConfig): ModelProvider {  switch (config.provider) {    case 'my-provider':      return new MyProvider(config.apiKey);    // ... other cases  }}

// src/utils/cache.tsconst CACHE_KEY = 'bouncer-post-cache';
export async function getCachedResult(postId: string): Promise<ClassificationResult | null> {  const stored = await chrome.storage.local.get(CACHE_KEY);  const cache = stored[CACHE_KEY] ?? {};  return cache[postId] ?? null;}
export async function cacheResult(postId: string, result: ClassificationResult): Promise<void> {  const stored = await chrome.storage.local.get(CACHE_KEY);  const cache = stored[CACHE_KEY] ?? {};  cache[postId] = result;  // Limit cache size  const keys = Object.keys(cache);  if (keys.length > 1000) delete cache[keys[0]];  await chrome.storage.local.set({ [CACHE_KEY]: cache });}

// src/utils/filters.tsexport async function getFilters(): Promise<string[]> {  const result = await chrome.storage.sync.get('bouncerFilters');  return result.bouncerFilters ?? [];}
export async function addFilter(topic: string): Promise<void> {  const filters = await getFilters();  if (!filters.includes(topic)) {    await chrome.storage.sync.set({ bouncerFilters: [...filters, topic] });  }}
export async function removeFilter(topic: string): Promise<void> {  const filters = await getFilters();  await chrome.storage.sync.set({    bouncerFilters: filters.filter(f => f !== topic),  });}

// src/models/providers/webllm.tsimport { CreateMLCEngine, type MLCEngine } from '@mlc-ai/web-llm';
let engine: MLCEngine | null = null;
export async function loadLocalModel(modelId: string, onProgress?: (p: number) => void): Promise<void> {  engine = await CreateMLCEngine(modelId, {    initProgressCallback: (report) => onProgress?.(report.progress),  });}
export async function localComplete(prompt: string): Promise<string> {  if (!engine) throw new Error('Local model not loaded');  const response = await engine.chat.completions.create({    messages: [{ role: 'user', content: prompt }],    max_tokens: 256,  });  return response.choices[0].message.content ?? '';}

async function classifyAndFilter(post: ExtractedPost): Promise<void> {  // Skip if already processed  if (post.element.dataset.bouncerProcessed) return;  post.element.dataset.bouncerProcessed = 'true';
  // Check cache first  const cached = await getCachedResult(post.id);  if (cached) {    if (cached.filtered) hidePost(post.element, cached.reasoning);    return;  }
  const filters = await getFilters();  if (filters.length === 0) return;
  const config = await getModelConfig();  const result = await classifyPost(post, filters, config);
  await cacheResult(post.id, result);  if (result.filtered) hidePost(post.element, result.reasoning);}

// Never log or expose the key — store only via chrome.storage.localasync function saveApiKey(provider: string, key: string): Promise<void> {  await chrome.storage.local.set({ [`${provider}_api_key`]: key });}
async function getApiKey(provider: string): Promise<string> {  const result = await chrome.storage.local.get(`${provider}_api_key`);  return result[`${provider}_api_key`] ?? '';}