Tabnine

┌─────────────────────────────────────────────────────────┐
│                    TABNINE PRIVACY                       │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   [Your Code] ──→ [Local Analysis] ──→ [Suggestions]   │
│        │                                     │          │
│        └────────────── NIE ─────────────────┘          │
│                 wysyłane do chmury                      │
│                                                         │
│   ✓ Kod pozostaje na Twoim urządzeniu                  │
│   ✓ Żadne snippety nie są przechowywane                │
│   ✓ Żadne dane treningowe z Twojego kodu               │
│   ✓ Pełna zgodność z GDPR/HIPAA/SOC2                   │
│                                                         │
└─────────────────────────────────────────────────────────┘

Twój IDE ──→ TLS 1.3 ──→ Tabnine Cloud ──→ Sugestie
              │
              └─ Zero data retention
              └─ Dane nie są używane do treningu

Twój IDE ──→ VPC ──→ Twoja infrastruktura ──→ Tabnine Server
              │              │
              └─ Prywatna sieć
                             └─ Model AI na Twoich serwerach

Twój IDE ──→ [BRAK INTERNETU] ──→ Lokalny Server Tabnine
                                        │
                                        └─ Całkowicie offline
                                        └─ Zero zewnętrznych połączeń

# 1. Otwórz VS Code
# 2. Extensions (Ctrl+Shift+X)
# 3. Szukaj "Tabnine"
# 4. Zainstaluj "Tabnine AI Autocomplete"

# Lub z terminala:
code --install-extension TabNine.tabnine-vscode

# 1. File → Settings → Plugins
# 2. Marketplace → Szukaj "Tabnine"
# 3. Install → Restart IDE

# Lub z CLI:
# Download plugin z JetBrains Marketplace

-- lazy.nvim
{
  "codota/tabnine-nvim",
  build = "./dl_binaries.sh",
  config = function()
    require('tabnine').setup({
      disable_auto_comment = true,
      accept_keymap = "<Tab>",
      dismiss_keymap = "<C-]>",
      debounce_ms = 800,
      suggestion_color = { gui = "#808080", cterm = 244 },
      exclude_filetypes = { "TelescopePrompt", "NvimTree" },
      log_file_path = nil,
    })
  end
}

" vim-plug
Plug 'codota/tabnine-vim'

" Po instalacji
:TabnineStatus
:TabnineEnable
:TabnineDisable

1. Help → Eclipse Marketplace
2. Szukaj "Tabnine"
3. Install → Accept license → Restart

1. Extensions → Manage Extensions
2. Online → Szukaj "Tabnine"
3. Download → Restart VS

// Tabnine rozumie kontekst i przewiduje następny kod

// Zaczynam pisać:
interface User {
  id: string
  email: string
  name: string
  createdAt: Date
}

async function getUserById(|
// Tabnine sugeruje:
// → id: string): Promise<User | null> {
//     return await prisma.user.findUnique({ where: { id } })
//   }

// Po zaakceptowaniu i rozpoczęciu nowej funkcji:
async function createUser(|
// Tabnine sugeruje całą funkcję:
// → data: Omit<User, 'id' | 'createdAt'>): Promise<User> {
//     return await prisma.user.create({ data })
//   }

# Tabnine potrafi sugerować całe bloki kodu

class UserRepository:
    def __init__(self, db):
        self.db = db

    def find_by_email(self|
    # Tabnine sugeruje:
    # → , email: str) -> Optional[User]:
    #       """Find user by email address."""
    #       return self.db.query(User).filter(User.email == email).first()

    def create(self|
    # Tabnine kontynuuje wzorzec:
    # → , user_data: UserCreate) -> User:
    #       """Create a new user."""
    #       user = User(**user_data.dict())
    #       self.db.add(user)
    #       self.db.commit()
    #       self.db.refresh(user)
    #       return user

// Tabnine uczy się konwencji Twojego projektu

// Jeśli w projekcie zawsze używasz:
const fetchUsers = async () => {
  const response = await api.get('/users')
  return response.data
}

// To przy nowej funkcji:
const fetchPosts = |
// Tabnine sugeruje zgodnie z Twoim wzorcem:
// → async () => {
//     const response = await api.get('/posts')
//     return response.data
//   }

┌─────────────────────────────────────────────────────────┐
│              TABNINE PERSONALIZATION                     │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   1. Analiza struktury projektu                         │
│      └─ Foldery, pliki, moduły                         │
│                                                         │
│   2. Uczenie konwencji nazewnictwa                     │
│      └─ camelCase, snake_case, prefixes               │
│                                                         │
│   3. Rozpoznawanie wzorców                             │
│      └─ Error handling, logging, API calls            │
│                                                         │
│   4. Adaptacja do bibliotek                            │
│      └─ React, Vue, Django, Spring, etc.              │
│                                                         │
│   5. Personalizacja stylu                              │
│      └─ Formatowanie, komentarze, struktura           │
│                                                         │
└─────────────────────────────────────────────────────────┘

# Tabnine może uczyć się z kodu całego zespołu
# (tylko w Enterprise, z pełną kontrolą administratora)

team_learning:
  enabled: true
  repositories:
    - company/frontend-app
    - company/backend-api
    - company/shared-utils

  excluded_patterns:
    - "**/.env*"
    - "**/secrets/**"
    - "**/*credentials*"

  sync_frequency: "daily"
  retention_period: "90_days"

// .tabnine.json w katalogu projektu
{
  "version": "1.0.0",
  "suggestions": {
    "enabled": true,
    "debounce_ms": 150,
    "min_confidence": 0.8
  },
  "context": {
    "include_imports": true,
    "max_context_lines": 500,
    "include_similar_files": true
  },
  "preferences": {
    "prefer_single_line": false,
    "include_docstrings": true,
    "language_specific": {
      "typescript": {
        "prefer_interfaces": true,
        "use_arrow_functions": true
      },
      "python": {
        "prefer_type_hints": true,
        "use_dataclasses": true
      }
    }
  }
}

// Cmd+Shift+T otwiera Tabnine Chat w VS Code

// Zaznacz kod i zapytaj o wyjaśnienie:
// "Wyjaśnij ten kod"

function memoize<T extends (...args: any[]) => any>(
  fn: T,
  keyFn?: (...args: Parameters<T>) => string
): T {
  const cache = new Map<string, ReturnType<T>>()

  return ((...args: Parameters<T>): ReturnType<T> => {
    const key = keyFn ? keyFn(...args) : JSON.stringify(args)

    if (cache.has(key)) {
      return cache.get(key)!
    }

    const result = fn(...args)
    cache.set(key, result)
    return result
  }) as T
}

// Tabnine Chat wyjaśni:
// "Ta funkcja implementuje memoizację - technikę cache'owania
// wyników funkcji. Gdy funkcja jest wywołana z tymi samymi
// argumentami, zwraca zapamiętany wynik zamiast ponownie
// obliczać..."

User: Stwórz React hook do debounce'owania wartości

Tabnine Chat:

import { useState, useEffect } from 'react'

function useDebounce<T>(value: T, delay: number): T {
  const [debouncedValue, setDebouncedValue] = useState<T>(value)

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value)
    }, delay)

    return () => {
      clearTimeout(timer)
    }
  }, [value, delay])

  return debouncedValue
}

// Użycie:
function SearchComponent() {
  const [search, setSearch] = useState('')
  const debouncedSearch = useDebounce(search, 300)

  useEffect(() => {
    if (debouncedSearch) {
      // Wykonaj wyszukiwanie
      fetchResults(debouncedSearch)
    }
  }, [debouncedSearch])

  return (
    <input
      value={search}
      onChange={(e) => setSearch(e.target.value)}
      placeholder="Szukaj..."
    />
  )
}

User: Zrefaktoruj ten kod do wzorca Repository

Tabnine Chat analizuje kod i proponuje:

// Przed refaktoringiem:
async function getUser(id: string) {
  const user = await db.query('SELECT * FROM users WHERE id = ?', [id])
  return user
}

async function createUser(data: UserData) {
  await db.query('INSERT INTO users ...', [data])
}

// Po refaktoringu (Tabnine Chat):
interface IUserRepository {
  findById(id: string): Promise<User | null>
  create(data: CreateUserDTO): Promise<User>
  update(id: string, data: UpdateUserDTO): Promise<User>
  delete(id: string): Promise<void>
}

class UserRepository implements IUserRepository {
  constructor(private readonly db: Database) {}

  async findById(id: string): Promise<User | null> {
    const result = await this.db.query<User>(
      'SELECT * FROM users WHERE id = ?',
      [id]
    )
    return result[0] || null
  }

  async create(data: CreateUserDTO): Promise<User> {
    const id = generateId()
    await this.db.query(
      'INSERT INTO users (id, email, name) VALUES (?, ?, ?)',
      [id, data.email, data.name]
    )
    return this.findById(id) as Promise<User>
  }

  async update(id: string, data: UpdateUserDTO): Promise<User> {
    const fields = Object.entries(data)
      .map(([key]) => `${key} = ?`)
      .join(', ')
    const values = Object.values(data)

    await this.db.query(
      `UPDATE users SET ${fields} WHERE id = ?`,
      [...values, id]
    )
    return this.findById(id) as Promise<User>
  }

  async delete(id: string): Promise<void> {
    await this.db.query('DELETE FROM users WHERE id = ?', [id])
  }
}

# docker-compose.yml dla Tabnine Enterprise
version: '3.8'

services:
  tabnine-server:
    image: tabnine/enterprise-server:latest
    ports:
      - "8080:8080"
      - "8443:8443"
    environment:
      - LICENSE_KEY=${TABNINE_LICENSE}
      - ADMIN_EMAIL=${ADMIN_EMAIL}
      - SSL_ENABLED=true
    volumes:
      - tabnine-data:/var/lib/tabnine
      - ./certs:/etc/tabnine/certs
    deploy:
      resources:
        limits:
          memory: 16G
        reservations:
          memory: 8G

  tabnine-model:
    image: tabnine/model-server:latest
    environment:
      - MODEL_SIZE=large
      - GPU_ENABLED=true
    deploy:
      resources:
        reservations:
          devices:
            - capabilities: [gpu]

volumes:
  tabnine-data:

# tabnine-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: tabnine-enterprise
  namespace: devtools
spec:
  replicas: 3
  selector:
    matchLabels:
      app: tabnine
  template:
    metadata:
      labels:
        app: tabnine
    spec:
      containers:
        - name: tabnine-server
          image: tabnine/enterprise-server:latest
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: "8Gi"
              cpu: "4"
            limits:
              memory: "16Gi"
              cpu: "8"
          envFrom:
            - secretRef:
                name: tabnine-secrets
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
---
apiVersion: v1
kind: Service
metadata:
  name: tabnine-service
spec:
  selector:
    app: tabnine
  ports:
    - port: 443
      targetPort: 8080
  type: LoadBalancer

// Tabnine Enterprise Admin API

// Zarządzanie użytkownikami
const adminApi = new TabnineAdminAPI({
  baseUrl: 'https://tabnine.company.com',
  apiKey: process.env.TABNINE_ADMIN_KEY
})

// Dodawanie użytkowników
await adminApi.users.create({
  email: 'developer@company.com',
  team: 'frontend',
  role: 'developer'
})

// Statystyki użycia
const stats = await adminApi.analytics.getUsageStats({
  from: '2024-01-01',
  to: '2024-01-31',
  groupBy: 'team'
})

console.log(stats)
// {
//   teams: {
//     frontend: { suggestions_accepted: 15420, time_saved_hours: 230 },
//     backend: { suggestions_accepted: 12350, time_saved_hours: 185 },
//   },
//   total_suggestions: 27770,
//   acceptance_rate: 0.34
// }

// Zarządzanie politykami
await adminApi.policies.update({
  team: 'security',
  settings: {
    allow_cloud_suggestions: false,
    require_local_model: true,
    audit_all_suggestions: true
  }
})

# config/auth.yaml
authentication:
  type: saml
  saml:
    idp_metadata_url: https://idp.company.com/metadata.xml
    sp_entity_id: https://tabnine.company.com
    assertion_consumer_service_url: https://tabnine.company.com/saml/acs
    name_id_format: emailAddress

  attribute_mapping:
    email: http://schemas.xmlsoap.org/ws/2005/05/identity/claims/emailaddress
    name: http://schemas.xmlsoap.org/ws/2005/05/identity/claims/name
    groups: http://schemas.microsoft.com/ws/2008/06/identity/claims/groups

  group_sync:
    enabled: true
    admin_groups:
      - CN=Tabnine-Admins,OU=Groups,DC=company,DC=com
    user_groups:
      - CN=Developers,OU=Groups,DC=company,DC=com

┌─────────────────────────────────────────────────────────┐
│              TABNINE CERTIFICATIONS                      │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   ✓ SOC 2 Type II                                      │
│     └─ Audytowane kontrole bezpieczeństwa              │
│                                                         │
│   ✓ GDPR Compliant                                     │
│     └─ Pełna zgodność z przepisami EU                  │
│                                                         │
│   ✓ HIPAA Ready                                        │
│     └─ Dla sektora healthcare                          │
│                                                         │
│   ✓ ISO 27001                                          │
│     └─ System zarządzania bezpieczeństwem              │
│                                                         │
│   ✓ CCPA Compliant                                     │
│     └─ California Consumer Privacy Act                 │
│                                                         │
└─────────────────────────────────────────────────────────┘

# Polityka danych Tabnine
data_policy:
  code_snippets:
    storage: none  # Nigdy nie przechowywane
    transmission: encrypted_tls_1.3
    training: never  # Nigdy nie używane do treningu

  telemetry:
    collected:
      - suggestion_acceptance_rate
      - feature_usage
      - error_reports
    not_collected:
      - code_content
      - file_names
      - project_structure

  retention:
    session_data: 0_days  # Natychmiast usuwane
    analytics: 90_days
    audit_logs: 1_year

// Tabnine nie sugeruje kodu z potencjalnymi lukami

// ❌ Tabnine NIE zasugeruje:
const query = `SELECT * FROM users WHERE id = '${userId}'` // SQL Injection

// ✅ Tabnine zasugeruje:
const user = await prisma.user.findUnique({
  where: { id: userId }
})

// ❌ Tabnine NIE zasugeruje:
res.send(`<div>${userInput}</div>`) // XSS

// ✅ Tabnine zasugeruje:
import { escape } from 'html-escaper'
res.send(`<div>${escape(userInput)}</div>`)

// ❌ Tabnine NIE zasugeruje:
const password = "admin123" // Hardcoded credentials

// ✅ Tabnine zasugeruje:
const password = process.env.DB_PASSWORD

# Tabnine może analizować historię git dla lepszych sugestii

# Konfiguracja w settings:
{
  "tabnine.gitContext": {
    "enabled": true,
    "includeCommitHistory": true,
    "includeBranchInfo": true,
    "maxCommits": 100
  }
}

# .github/workflows/tabnine-metrics.yml
name: Tabnine Metrics

on:
  schedule:
    - cron: '0 0 * * 1'  # Co tydzień

jobs:
  collect-metrics:
    runs-on: ubuntu-latest
    steps:
      - name: Collect Tabnine Usage
        uses: tabnine/metrics-action@v1
        with:
          api-key: ${{ secrets.TABNINE_API_KEY }}
          output-format: json

      - name: Post to Slack
        uses: slackapi/slack-github-action@v1
        with:
          payload: |
            {
              "text": "Weekly Tabnine Report",
              "blocks": [
                {
                  "type": "section",
                  "text": {
                    "type": "mrkdwn",
                    "text": "Suggestions accepted: ${{ steps.metrics.outputs.accepted }}\nTime saved: ${{ steps.metrics.outputs.hours_saved }} hours"
                  }
                }
              ]
            }

// Tabnine Enterprise może wysyłać raporty do Slack

// Webhook configuration
const slackWebhook = new TabnineSlackIntegration({
  webhookUrl: process.env.SLACK_WEBHOOK,
  channel: '#dev-metrics'
})

// Weekly report
slackWebhook.scheduleReport({
  frequency: 'weekly',
  metrics: ['acceptance_rate', 'time_saved', 'top_users'],
  format: 'detailed'
})

// 1. Pisz dobre docstrings/komentarze
/**
 * Calculates the total price including tax and discounts
 * @param items - Array of cart items
 * @param taxRate - Tax rate as decimal (e.g., 0.23 for 23%)
 * @param discountCode - Optional discount code
 * @returns Total price after all calculations
 */
function calculateTotal(items: CartItem[], taxRate: number, discountCode?: string) {
  // Tabnine rozumie kontekst z docstring i sugeruje lepiej
}

// 2. Używaj opisowych nazw
// ❌
const d = getData()

// ✅
const userProfileData = fetchUserProfile()

// 3. Zachowuj spójne wzorce
// Jeśli zawsze używasz async/await:
const user = await getUser(id)
const posts = await getPosts(userId)
// Tabnine będzie kontynuował ten wzorzec

// 4. Definiuj typy
interface Product {
  id: string
  name: string
  price: number
  category: string
}
// Tabnine używa typów do lepszych sugestii

// .vscode/settings.json (współdzielone w repo)
{
  "tabnine.experimentalAutoImports": true,
  "tabnine.debounceMilliseconds": 200,
  "tabnine.useProperIdentifiers": true,

  // Zespołowe preferencje
  "tabnine.preferences": {
    "preferArrowFunctions": true,
    "preferConstOverLet": true,
    "includeTypeAnnotations": true
  }
}

# 1. Sprawdź status Tabnine
# VS Code: Ctrl+Shift+P → "Tabnine: Status"

# 2. Zrestartuj Tabnine
# VS Code: Ctrl+Shift+P → "Tabnine: Restart"

# 3. Sprawdź zużycie pamięci
ps aux | grep -i tabnine

# 4. Zwiększ pamięć (settings.json)
{
  "tabnine.maxMemory": 4096
}

# 1. Sprawdź czy plik jest obsługiwany
# Tabnine wspiera: JS, TS, Python, Java, C++, Go, Ruby, Rust, etc.

# 2. Sprawdź ustawienia
{
  "tabnine.disable_file_patterns": []  # Upewnij się, że nie blokujesz
}

# 3. Sprawdź licencję
# VS Code: Ctrl+Shift+P → "Tabnine: Open Hub"

// Wyłącz konkurujące autouzupełnianie
{
  "editor.suggest.showSnippets": false,
  "javascript.suggest.enabled": false,
  "typescript.suggest.enabled": false,

  // Priorytet dla Tabnine
  "editor.quickSuggestions": {
    "other": true,
    "comments": false,
    "strings": true
  }
}