The Last AI Model You'll Ever Need to Install

// Chrome Extension with Gemma Integration
import { GemmaWebGPU } from '@google-ai/gemma-web';

interface GemmaWebExtension {
  analyzeCurrentPage(): Promise<PageAnalysis>;
  translateSelection(targetLang: string): Promise<string>;
  generateSummary(content: string): Promise<string>;
}

class ChromeGemmaExtension implements GemmaWebExtension {
  private gemma: GemmaWebGPU;
  private contextHistory: Array<{url: string, analysis: any}> = [];

  constructor() {
    this.initializeGemma();
  }

  private async initializeGemma() {
    this.gemma = new GemmaWebGPU({
      modelPath: chrome.runtime.getURL('models/gemma-7b-web.bin'),
      device: 'webgpu',
      maxTokens: 4096,
      contextWindow: 8192
    });

    await this.gemma.initialize();
  }

  async analyzeCurrentPage(): Promise<PageAnalysis> {
    const [tab] = await chrome.tabs.query({
      active: true,
      currentWindow: true
    });

    if (!tab.id) throw new Error('No active tab');

    // Extract page content
    const results = await chrome.scripting.executeScript({
      target: { tabId: tab.id },
      function: () => {
        return {
          title: document.title,
          content: document.body.innerText.slice(0, 5000),
          url: window.location.href,
          language: document.documentElement.lang || 'en',
          metadata: {
            description: document.querySelector('meta[name="description"]')?.getAttribute('content'),
            keywords: document.querySelector('meta[name="keywords"]')?.getAttribute('content')
          }
        };
      }
    });

    const pageData = results[0].result;

    // Analyze with Gemma
    const analysis = await this.gemma.generate({
      prompt: `Analyze this web page:

Title: ${pageData.title}
URL: ${pageData.url}
Content: ${pageData.content}

Provide:
1. Main topic and key themes
2. Reading difficulty level
3. Estimated reading time
4. Key insights and takeaways
5. Related topics for further exploration
6. Action items or next steps mentioned

Format as JSON.`,
      temperature: 0.3,
      maxTokens: 1000
    });

    const parsedAnalysis = JSON.parse(analysis);

    // Store in context history
    this.contextHistory.push({
      url: pageData.url,
      analysis: parsedAnalysis
    });

    // Save to Chrome storage
    await chrome.storage.local.set({
      [`analysis_${tab.id}`]: parsedAnalysis,
      contextHistory: this.contextHistory.slice(-50) // Keep last 50
    });

    return parsedAnalysis;
  }

  async translateSelection(targetLang: string): Promise<string> {
    const [tab] = await chrome.tabs.query({
      active: true,
      currentWindow: true
    });

    if (!tab.id) throw new Error('No active tab');

    // Get selected text
    const selection = await chrome.scripting.executeScript({
      target: { tabId: tab.id },
      function: () => window.getSelection()?.toString() || ''
    });

    const selectedText = selection[0].result;
    if (!selectedText) throw new Error('No text selected');

    const translation = await this.gemma.generate({
      prompt: `Translate the following text to ${targetLang}. Maintain the original meaning and tone:

${selectedText}

Translation:`,
      temperature: 0.2,
      maxTokens: 500
    });

    return translation.replace('Translation:', '').trim();
  }

  async generateSummary(content: string): Promise<string> {
    const contextualPrompt = this.buildContextualPrompt(content);

    const summary = await this.gemma.generate({
      prompt: contextualPrompt,
      temperature: 0.4,
      maxTokens: 300
    });

    return summary;
  }

  private buildContextualPrompt(content: string): string {
    const recentContext = this.contextHistory
      .slice(-3)
      .map(item => `- ${new URL(item.url).hostname}: ${item.analysis.mainTopic}`)
      .join('\n');

    return `Based on recent browsing context:
${recentContext}

Summarize the following content in 2-3 sentences, highlighting the most important points:

${content}`;
  }
}

// Background script initialization
chrome.runtime.onInstalled.addListener(() => {
  const extension = new ChromeGemmaExtension();

  chrome.action.onClicked.addListener(async (tab) => {
    const analysis = await extension.analyzeCurrentPage();
    chrome.tabs.sendMessage(tab.id!, {
      type: 'SHOW_ANALYSIS',
      data: analysis
    });
  });
});

export { ChromeGemmaExtension };