Replit

// Tworzenie nowego Repl:
1. Kliknij "+ Create Repl"
2. Wybierz język/template:
   - Python
   - Node.js
   - React
   - Next.js
   - Flask
   - Django
   - Express
   - Go
   - Rust
   - ... i 40+ innych
3. Nazwij projekt
4. Kliknij "Create Repl"

// Środowisko uruchamia się automatycznie!

my-project/
├── .replit              # Konfiguracja Replit
├── replit.nix           # Nix environment config
├── main.py              # Główny plik (lub main.js, etc.)
├── requirements.txt     # Python dependencies
├── package.json         # Node.js dependencies
└── ... twoje pliki ...

# .replit - konfiguracja projektu
run = "python main.py"
entrypoint = "main.py"
language = "python3"

[nix]
channel = "stable-23_05"

[env]
PYTHONPATH = "${PYTHONPATH}:${REPL_HOME}"

[deployment]
run = ["sh", "-c", "python main.py"]
deploymentTarget = "cloudrun"

[[ports]]
localPort = 8080
externalPort = 80

# replit.nix
{ pkgs }: {
  deps = [
    pkgs.python310
    pkgs.python310Packages.pip
    pkgs.python310Packages.flask
    pkgs.nodejs-18_x
    pkgs.postgresql
    pkgs.redis
  ];

  env = {
    PYTHONPATH = "${pkgs.python310Packages.flask}/lib/python3.10/site-packages";
    LD_LIBRARY_PATH = "${pkgs.lib.makeLibraryPath [
      pkgs.stdenv.cc.cc.lib
    ]}";
  };
}

// Co Agent może zrobić:

1. UTWORZYĆ PROJEKT
   "Build a todo app with React and Express"
   → Agent tworzy strukturę, instaluje dependencies, pisze kod

2. SKONFIGUROWAĆ BACKEND
   "Set up a PostgreSQL database with user authentication"
   → Agent konfiguruje bazę, tworzy tabele, implementuje auth

3. DEBUGOWAĆ
   "Fix the bug where tasks don't save to the database"
   → Agent analizuje kod, identyfikuje problem, naprawia

4. REFAKTOROWAĆ
   "Refactor the API to use proper error handling"
   → Agent przepisuje kod zgodnie z best practices

5. DEPLOYOWAĆ
   "Deploy this app with HTTPS and a custom domain"
   → Agent konfiguruje deployment

// Sesja budowania aplikacji

You: Build a blog platform with:
- User registration and login
- Create, edit, delete posts
- Categories and tags
- Comment system
- Admin dashboard
Use Python Flask with SQLite.

Agent: I'll build this blog platform for you. Let me start by:

1. Setting up the Flask project structure
2. Creating the database models
3. Implementing user authentication
4. Building the blog post CRUD
5. Adding comments functionality
6. Creating the admin dashboard

[Agent tworzy pliki...]

/main.py
/models.py
/routes/
  auth.py
  posts.py
  comments.py
  admin.py
/templates/
  base.html
  index.html
  post.html
  login.html
  register.html
  admin/
    dashboard.html
    posts.html
/static/
  style.css
/requirements.txt

Agent: I've created the basic structure. Let me now implement
the user authentication system...

[Agent pisze kod autentykacji...]

Agent: User auth is ready. Now implementing the blog posts...

[Agent kontynuuje budowanie...]

Agent: The blog platform is ready! Here's what I've built:

✅ User registration and login with Flask-Login
✅ Blog posts with CRUD operations
✅ Categories and tags system
✅ Comment system with replies
✅ Admin dashboard with analytics

You can test it by clicking the "Run" button.
Would you like me to add any additional features?

// ✅ Dobre prompty

"Build an e-commerce API with Node.js and Express.
Include:
- Product catalog with categories
- User accounts
- Shopping cart
- Order processing
Use MongoDB for the database."

"Create a real-time chat application using Python Flask
and Socket.IO. Support multiple chat rooms, private messages,
and typing indicators. Store messages in SQLite."

"Build a REST API for a task management app.
Include:
- JWT authentication
- Tasks with priorities and due dates
- Projects to organize tasks
- Tags system
Use PostgreSQL and include API documentation."

// ❌ Słabe prompty

"Make me an app"  // Zbyt ogólne
"Build Twitter clone"  // Zbyt ambitne
"Write some code"  // Brak kontekstu

# 1. COMPLETE CODE - Automatyczne uzupełnianie

def calculate_total(items):
    # Ghostwriter podpowiada:
    total = 0
    for item in items:
        total += item.price * item.quantity
    return total

# 2. GENERATE CODE - Generowanie z komentarzy

# Function to validate email address using regex
def validate_email(email):
    # Ghostwriter generuje implementację:
    import re
    pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
    return bool(re.match(pattern, email))

# 3. EXPLAIN CODE - Wyjaśnienia

# Zaznacz kod i kliknij "Explain" - Ghostwriter wyjaśni co robi

# 4. TRANSFORM CODE - Transformacje

# Ghostwriter może:
# - Dodać type hints
# - Przekształcić na async
# - Dodać error handling
# - Zrefaktorować

// Interaktywny chat z AI w IDE

You: How do I connect to PostgreSQL in this Flask app?

Ghostwriter: Here's how to set up PostgreSQL with Flask:

1. First, install the required packages:
```python
# requirements.txt
psycopg2-binary==2.9.9
Flask-SQLAlchemy==3.1.1

# config.py
import os

class Config:
    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL') or \
        'postgresql://user:password@localhost/dbname'
    SQLALCHEMY_TRACK_MODIFICATIONS = False

# app.py
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config.from_object('config.Config')
db = SQLAlchemy(app)

## Multiplayer Coding

Replit pozwala na kodowanie w czasie rzeczywistym z innymi osobami - jak Google Docs dla kodu.

### Funkcje Multiplayer

### Use cases Multiplayer

## Bazy danych w Replit

### Replit Database (Key-Value)

```python
# Wbudowana prosta baza danych key-value
from replit import db

# Zapisywanie
db["user_123"] = {"name": "Jan", "email": "jan@example.com"}
db["count"] = 42

# Odczytywanie
user = db["user_123"]
print(user["name"])  # "Jan"

# Sprawdzanie klucza
if "user_123" in db:
    print("User exists")

# Usuwanie
del db["user_123"]

# Iterowanie po kluczach
for key in db.keys():
    print(f"{key}: {db[key]}")

# Prefiksy
user_keys = db.prefix("user_")
for key in user_keys:
    print(db[key])

# Konfiguracja PostgreSQL w Replit

# 1. Dodaj PostgreSQL w replit.nix:
# deps = [ pkgs.postgresql ];

# 2. Ustaw zmienne środowiskowe w Secrets:
# DATABASE_URL = postgresql://...

# 3. Użyj w kodzie:
import os
import psycopg2
from psycopg2.extras import RealDictCursor

def get_db():
    return psycopg2.connect(
        os.environ['DATABASE_URL'],
        cursor_factory=RealDictCursor
    )

# Przykład użycia
def get_users():
    conn = get_db()
    cur = conn.cursor()
    cur.execute("SELECT * FROM users")
    users = cur.fetchall()
    cur.close()
    conn.close()
    return users

def create_user(name, email):
    conn = get_db()
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO users (name, email) VALUES (%s, %s) RETURNING id",
        (name, email)
    )
    user_id = cur.fetchone()['id']
    conn.commit()
    cur.close()
    conn.close()
    return user_id

# SQLite - najprostsza opcja dla małych projektów
import sqlite3
from contextlib import contextmanager

DATABASE = 'app.db'

@contextmanager
def get_db():
    conn = sqlite3.connect(DATABASE)
    conn.row_factory = sqlite3.Row
    try:
        yield conn
    finally:
        conn.close()

def init_db():
    with get_db() as conn:
        conn.execute('''
            CREATE TABLE IF NOT EXISTS tasks (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                title TEXT NOT NULL,
                completed BOOLEAN DEFAULT FALSE,
                created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        conn.commit()

def get_tasks():
    with get_db() as conn:
        cursor = conn.execute('SELECT * FROM tasks ORDER BY created_at DESC')
        return [dict(row) for row in cursor.fetchall()]

def create_task(title):
    with get_db() as conn:
        cursor = conn.execute(
            'INSERT INTO tasks (title) VALUES (?)',
            (title,)
        )
        conn.commit()
        return cursor.lastrowid

// TYPY DEPLOYMENTU

1. AUTOSCALE
   - Skaluje się automatycznie z ruchem
   - Płacisz za faktyczne użycie
   - Idealne dla aplikacji produkcyjnych
   - Cold starts mogą występować

2. RESERVED VM
   - Dedykowana maszyna wirtualna
   - Stałe zasoby (CPU, RAM)
   - Zawsze włączona
   - Przewidywalne koszty

3. STATIC
   - Dla stron statycznych
   - Hosting plików HTML/CSS/JS
   - CDN included
   - Najtańsza opcja

# .replit - deployment config
[deployment]
run = ["sh", "-c", "python main.py"]
deploymentTarget = "cloudrun"
ignorePorts = false

# Lub dla Node.js:
[deployment]
run = ["sh", "-c", "npm start"]
build = ["sh", "-c", "npm run build"]
deploymentTarget = "cloudrun"

// Dodawanie własnej domeny:

1. W panelu deployment → "Custom Domains"
2. Wpisz swoją domenę (np. myapp.com)
3. Dodaj rekordy DNS:
   - CNAME: myapp.com → your-repl.replit.app
   - lub A record dla apex domain
4. Poczekaj na propagację DNS
5. SSL certyfikat generowany automatycznie

# Przechowywanie poufnych danych

# 1. W panelu Tools → Secrets
# 2. Dodaj klucz-wartość:
#    API_KEY = your-secret-key
#    DATABASE_URL = postgresql://...

# 3. Użyj w kodzie:
import os

api_key = os.environ['API_KEY']
db_url = os.environ['DATABASE_URL']

# WAŻNE: Nigdy nie commituj secretów do kodu!

# main.py - REST API
from flask import Flask, jsonify, request
from flask_cors import CORS
import os

app = Flask(__name__)
CORS(app)

# In-memory storage (use DB in production)
tasks = []
task_id_counter = 1

@app.route('/api/tasks', methods=['GET'])
def get_tasks():
    return jsonify(tasks)

@app.route('/api/tasks', methods=['POST'])
def create_task():
    global task_id_counter
    data = request.json

    task = {
        'id': task_id_counter,
        'title': data['title'],
        'completed': False
    }
    task_id_counter += 1
    tasks.append(task)

    return jsonify(task), 201

@app.route('/api/tasks/<int:task_id>', methods=['PUT'])
def update_task(task_id):
    data = request.json
    for task in tasks:
        if task['id'] == task_id:
            task.update(data)
            return jsonify(task)
    return jsonify({'error': 'Task not found'}), 404

@app.route('/api/tasks/<int:task_id>', methods=['DELETE'])
def delete_task(task_id):
    global tasks
    tasks = [t for t in tasks if t['id'] != task_id]
    return '', 204

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

// server/index.js
const express = require('express');
const cors = require('cors');
const path = require('path');

const app = express();
app.use(cors());
app.use(express.json());

// Serve static files from React build
app.use(express.static(path.join(__dirname, '../client/build')));

// API routes
let todos = [];
let idCounter = 1;

app.get('/api/todos', (req, res) => {
  res.json(todos);
});

app.post('/api/todos', (req, res) => {
  const todo = {
    id: idCounter++,
    text: req.body.text,
    completed: false,
    createdAt: new Date().toISOString()
  };
  todos.push(todo);
  res.status(201).json(todo);
});

app.patch('/api/todos/:id', (req, res) => {
  const todo = todos.find(t => t.id === parseInt(req.params.id));
  if (!todo) return res.status(404).json({ error: 'Not found' });

  Object.assign(todo, req.body);
  res.json(todo);
});

app.delete('/api/todos/:id', (req, res) => {
  todos = todos.filter(t => t.id !== parseInt(req.params.id));
  res.status(204).send();
});

// Handle React routing
app.get('*', (req, res) => {
  res.sendFile(path.join(__dirname, '../client/build/index.html'));
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, '0.0.0.0', () => {
  console.log(`Server running on port ${PORT}`);
});

// client/src/App.jsx
import { useState, useEffect } from 'react';
import './App.css';

function App() {
  const [todos, setTodos] = useState([]);
  const [newTodo, setNewTodo] = useState('');
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    fetchTodos();
  }, []);

  const fetchTodos = async () => {
    const res = await fetch('/api/todos');
    const data = await res.json();
    setTodos(data);
    setLoading(false);
  };

  const addTodo = async (e) => {
    e.preventDefault();
    if (!newTodo.trim()) return;

    const res = await fetch('/api/todos', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ text: newTodo })
    });
    const todo = await res.json();
    setTodos([...todos, todo]);
    setNewTodo('');
  };

  const toggleTodo = async (id) => {
    const todo = todos.find(t => t.id === id);
    const res = await fetch(`/api/todos/${id}`, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ completed: !todo.completed })
    });
    const updated = await res.json();
    setTodos(todos.map(t => t.id === id ? updated : t));
  };

  const deleteTodo = async (id) => {
    await fetch(`/api/todos/${id}`, { method: 'DELETE' });
    setTodos(todos.filter(t => t.id !== id));
  };

  if (loading) return <div className="loading">Loading...</div>;

  return (
    <div className="app">
      <h1>Todo App</h1>

      <form onSubmit={addTodo} className="add-form">
        <input
          type="text"
          value={newTodo}
          onChange={(e) => setNewTodo(e.target.value)}
          placeholder="Add a new task..."
        />
        <button type="submit">Add</button>
      </form>

      <ul className="todo-list">
        {todos.map(todo => (
          <li key={todo.id} className={todo.completed ? 'completed' : ''}>
            <span onClick={() => toggleTodo(todo.id)}>
              {todo.text}
            </span>
            <button onClick={() => deleteTodo(todo.id)}>Delete</button>
          </li>
        ))}
      </ul>

      <p className="count">
        {todos.filter(t => !t.completed).length} tasks remaining
      </p>
    </div>
  );
}

export default App;

# main.py - Discord bot
import discord
from discord.ext import commands
import os

intents = discord.Intents.default()
intents.message_content = True

bot = commands.Bot(command_prefix='!', intents=intents)

@bot.event
async def on_ready():
    print(f'{bot.user} is now running!')

@bot.command(name='hello')
async def hello(ctx):
    await ctx.send(f'Hello, {ctx.author.name}! 👋')

@bot.command(name='ping')
async def ping(ctx):
    latency = round(bot.latency * 1000)
    await ctx.send(f'Pong! Latency: {latency}ms')

@bot.command(name='poll')
async def poll(ctx, *, question):
    embed = discord.Embed(
        title='📊 Poll',
        description=question,
        color=discord.Color.blue()
    )
    message = await ctx.send(embed=embed)
    await message.add_reaction('👍')
    await message.add_reaction('👎')

@bot.command(name='clear')
@commands.has_permissions(manage_messages=True)
async def clear(ctx, amount: int = 5):
    await ctx.channel.purge(limit=amount + 1)
    await ctx.send(f'Cleared {amount} messages! 🧹', delete_after=3)

@bot.event
async def on_command_error(ctx, error):
    if isinstance(error, commands.MissingPermissions):
        await ctx.send('You do not have permission to use this command.')
    elif isinstance(error, commands.MissingRequiredArgument):
        await ctx.send(f'Missing argument: {error.param.name}')

# Keep bot alive (for Replit)
from flask import Flask
from threading import Thread

app = Flask('')

@app.route('/')
def home():
    return 'Bot is running!'

def run():
    app.run(host='0.0.0.0', port=8080)

Thread(target=run).start()

# Run bot
bot.run(os.environ['DISCORD_TOKEN'])

# main.py - ML prediction API
from flask import Flask, jsonify, request
import numpy as np
from sklearn.linear_model import LinearRegression
import joblib
import os

app = Flask(__name__)

# Train a simple model (in production, load pre-trained)
def train_model():
    # Example: predict house price based on size
    X = np.array([[1000], [1500], [2000], [2500], [3000]])
    y = np.array([150000, 200000, 250000, 300000, 350000])

    model = LinearRegression()
    model.fit(X, y)

    joblib.dump(model, 'model.pkl')
    return model

# Load or train model
if os.path.exists('model.pkl'):
    model = joblib.load('model.pkl')
else:
    model = train_model()

@app.route('/api/predict', methods=['POST'])
def predict():
    data = request.json

    if 'size' not in data:
        return jsonify({'error': 'size is required'}), 400

    size = float(data['size'])
    prediction = model.predict([[size]])[0]

    return jsonify({
        'input': {'size': size},
        'predicted_price': round(prediction, 2)
    })

@app.route('/api/health', methods=['GET'])
def health():
    return jsonify({'status': 'healthy', 'model_loaded': model is not None})

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

// FUNKCJE DLA NAUCZYCIELI

1. CLASSROOM MANAGEMENT
   - Tworzenie zespołów klasowych
   - Zapraszanie studentów
   - Przypisywanie zadań

2. ASSIGNMENTS
   - Tworzenie projektów startowych
   - Automatyczne testowanie
   - Due dates i grading
   - Plagiarism detection

3. CURRICULUM
   - Gotowe kursy programowania
   - Interaktywne tutoriale
   - Certyfikaty ukończenia

4. MONITORING
   - Podgląd pracy studentów w czasie rzeczywistym
   - Historia edycji
   - Analityki postępów

# Przykład: Interactive Python Tutorial

def lesson_1_variables():
    """
    LEKCJA 1: Zmienne w Pythonie

    Zmienne to 'pudełka' na dane. Możesz przechowywać
    w nich liczby, tekst i inne wartości.
    """

    # Przykład - odkomentuj i uruchom:
    name = "Anna"
    age = 25
    height = 1.65

    print(f"Imię: {name}")
    print(f"Wiek: {age}")
    print(f"Wzrost: {height}m")

    # ZADANIE 1: Utwórz zmienne opisujące Twojego ulubionego bohatera
    # hero_name = ???
    # hero_power = ???
    # hero_strength = ???

    # Odkomentuj poniżej gdy skończysz:
    # print(f"{hero_name} ma moc {hero_power} i siłę {hero_strength}")

def lesson_2_conditionals():
    """
    LEKCJA 2: Instrukcje warunkowe

    if-else pozwala podejmować decyzje w kodzie.
    """

    age = 18

    if age >= 18:
        print("Jesteś pełnoletni!")
    else:
        print("Jesteś niepełnoletni.")

    # ZADANIE 2: Napisz program sprawdzający czy liczba jest parzysta
    # number = int(input("Podaj liczbę: "))
    # if ???:
    #     print("Parzysta")
    # else:
    #     print("Nieparzysta")

# Uruchom lekcję:
lesson_1_variables()

// ✅ Dobra struktura
my-project/
├── src/              # Kod źródłowy
│   ├── routes/       # API routes
│   ├── models/       # Data models
│   ├── utils/        # Utilities
│   └── main.py       # Entry point
├── tests/            # Testy
├── static/           # Static files
├── templates/        # HTML templates
├── .replit           # Replit config
├── replit.nix        # Nix config
├── requirements.txt  # Dependencies
└── README.md         # Dokumentacja

# Tips dla lepszej wydajności:

# 1. Używaj lightweight frameworks
# Flask zamiast Django dla małych API
# Fastify zamiast Express dla Node.js

# 2. Lazy loading
from functools import lru_cache

@lru_cache(maxsize=100)
def expensive_operation(arg):
    # Wynik będzie cache'owany
    return compute(arg)

# 3. Asynchroniczność gdzie możliwe
import asyncio
import aiohttp

async def fetch_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

# 4. Optymalizacja dependencies
# Nie instaluj pakietów których nie używasz
# Używaj slim versions gdzie dostępne

# Security best practices

# 1. Secrets w Environment Variables
import os
api_key = os.environ.get('API_KEY')
# NIGDY: api_key = "hardcoded-key"

# 2. Input validation
from flask import request
from werkzeug.utils import secure_filename

@app.route('/upload', methods=['POST'])
def upload():
    file = request.files['file']
    filename = secure_filename(file.filename)  # Sanitize!
    # ...

# 3. CORS properly configured
from flask_cors import CORS
CORS(app, origins=['https://yourdomain.com'])

# 4. Rate limiting
from flask_limiter import Limiter
limiter = Limiter(app, key_func=get_remote_address)

@app.route('/api/resource')
@limiter.limit("100/hour")
def resource():
    return data