feat: M0 monorepo skeleton with services, clients, deploy and CI

- api/openapi.yaml: contract with /healthz, /readyz, /api/v1/server-info
- services/api (Go): api with oapi-codegen strict server, goose migrations,
  readiness checks for Postgres/Redis; storage-agent stub with internal token
- services/recommender (Python, uv): FastAPI health/readiness/internal status,
  `pipu-rec serve` and `pipu-rec analyze` entrypoints
- packages: generated api-client, core (server URL + server check),
  i18n (ru/en + dictionary check), design-tokens (CSS vars + TS from tokens.json)
- apps/web: Vite + React shell showing server status, language switch
- apps/mobile: Expo (SDK 53) Android app with server connect screen
- deploy: Dockerfiles, compose (prod + dev), nginx template, install/update scripts
- .gitea/workflows: ci.yml and tag-based release.yml (images, signed APK, release)
- scripts/version.mjs: version and Android versionCode from git tag
- tests/fixtures/music/generate.sh: synthetic test library via ffmpeg
- docs: versionCode formula, OpenAPI 3.0.3, dev instructions in README

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

services/api/internal/platform/config/config.go

@@ -0,0 +1,39 @@
+// Package config читает конфигурацию сервиса из переменных окружения.
+package config
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/caarlos0/env/v11"
+)
+
+// API — конфигурация публичного сервиса api.
+type API struct {
+	HTTPAddr        string        `env:"HTTP_ADDR" envDefault:":8080"`
+	DatabaseURL     string        `env:"DATABASE_URL,required"`
+	RedisURL        string        `env:"REDIS_URL,required"`
+	LogLevel        string        `env:"LOG_LEVEL" envDefault:"info"`
+	MigrateOnStart  bool          `env:"MIGRATE_ON_START" envDefault:"true"`
+	ShutdownTimeout time.Duration `env:"SHUTDOWN_TIMEOUT" envDefault:"15s"`
+
+	SupportedLocales      []string `env:"SUPPORTED_LOCALES" envDefault:"ru,en" envSeparator:","`
+	MinAndroidVersionCode int      `env:"MIN_ANDROID_VERSION_CODE" envDefault:"0"`
+}
+
+// StorageAgent — конфигурация внутреннего сервиса storage-agent.
+type StorageAgent struct {
+	HTTPAddr      string `env:"HTTP_ADDR" envDefault:":8090"`
+	InternalToken string `env:"INTERNAL_TOKEN,required"`
+	LibraryRoot   string `env:"LIBRARY_ROOT" envDefault:"/library"`
+	LogLevel      string `env:"LOG_LEVEL" envDefault:"info"`
+}
+
+// Load заполняет структуру конфигурации T из окружения.
+func Load[T any]() (T, error) {
+	var cfg T
+	if err := env.Parse(&cfg); err != nil {
+		return cfg, fmt.Errorf("config: %w", err)
+	}
+	return cfg, nil
+}

services/api/internal/platform/config/config_test.go

@@ -0,0 +1,26 @@
+package config
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestLoadAPIDefaults(t *testing.T) {
+	t.Setenv("DATABASE_URL", "postgres://localhost/pipu")
+	t.Setenv("REDIS_URL", "redis://localhost:6379/0")
+
+	cfg, err := Load[API]()
+	require.NoError(t, err)
+	assert.Equal(t, ":8080", cfg.HTTPAddr)
+	assert.Equal(t, []string{"ru", "en"}, cfg.SupportedLocales)
+	assert.True(t, cfg.MigrateOnStart)
+}
+
+func TestLoadAPIRequiresDatabase(t *testing.T) {
+	t.Setenv("REDIS_URL", "redis://localhost:6379/0")
+
+	_, err := Load[API]()
+	assert.ErrorContains(t, err, "DATABASE_URL")
+}

services/api/internal/platform/db/db.go

@@ -0,0 +1,42 @@
+// Package db — подключение к PostgreSQL и применение миграций.
+package db
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+
+	"github.com/jackc/pgx/v5/pgxpool"
+	"github.com/jackc/pgx/v5/stdlib"
+	"github.com/pressly/goose/v3"
+
+	"pipu/api/migrations"
+)
+
+// Connect открывает пул соединений и проверяет доступность БД.
+func Connect(ctx context.Context, url string) (*pgxpool.Pool, error) {
+	pool, err := pgxpool.New(ctx, url)
+	if err != nil {
+		return nil, fmt.Errorf("db: open pool: %w", err)
+	}
+	if err := pool.Ping(ctx); err != nil {
+		pool.Close()
+		return nil, fmt.Errorf("db: ping: %w", err)
+	}
+	return pool, nil
+}
+
+// Migrate применяет встроенные миграции goose.
+func Migrate(ctx context.Context, pool *pgxpool.Pool) error {
+	sqlDB := stdlib.OpenDBFromPool(pool)
+	defer func(d *sql.DB) { _ = d.Close() }(sqlDB)
+
+	provider, err := goose.NewProvider(goose.DialectPostgres, sqlDB, migrations.FS)
+	if err != nil {
+		return fmt.Errorf("db: migrations: %w", err)
+	}
+	if _, err := provider.Up(ctx); err != nil {
+		return fmt.Errorf("db: migrate up: %w", err)
+	}
+	return nil
+}

services/api/internal/platform/httpx/logging.go

@@ -0,0 +1,43 @@
+package httpx
+
+import (
+	"log/slog"
+	"net/http"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/go-chi/chi/v5/middleware"
+)
+
+// NewLogger создаёт JSON-логгер с заданным уровнем (debug, info, warn, error).
+func NewLogger(level string) *slog.Logger {
+	var lvl slog.Level
+	if err := lvl.UnmarshalText([]byte(strings.ToUpper(level))); err != nil {
+		lvl = slog.LevelInfo
+	}
+	return slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: lvl}))
+}
+
+// AccessLog пишет строку лога на каждый запрос, кроме проб здоровья.
+func AccessLog(log *slog.Logger) func(http.Handler) http.Handler {
+	return func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			if r.URL.Path == "/healthz" || r.URL.Path == "/readyz" {
+				next.ServeHTTP(w, r)
+				return
+			}
+			ww := middleware.NewWrapResponseWriter(w, r.ProtoMajor)
+			start := time.Now()
+			next.ServeHTTP(ww, r)
+			log.InfoContext(r.Context(), "http",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"status", ww.Status(),
+				"bytes", ww.BytesWritten(),
+				"duration_ms", time.Since(start).Milliseconds(),
+				"request_id", middleware.GetReqID(r.Context()),
+			)
+		})
+	}
+}

services/api/internal/platform/httpx/problem.go

@@ -0,0 +1,47 @@
+// Package httpx — общие HTTP-утилиты: ответы об ошибках (RFC 9457), логирование, middleware.
+package httpx
+
+import (
+	"encoding/json"
+	"log/slog"
+	"net/http"
+)
+
+// Problem — тело ответа application/problem+json. Поле Code переводится клиентом через i18n.
+type Problem struct {
+	Type   string         `json:"type"`
+	Status int            `json:"status"`
+	Code   string         `json:"code"`
+	Detail string         `json:"detail,omitempty"`
+	Params map[string]any `json:"params,omitempty"`
+}
+
+// WriteProblem пишет ответ об ошибке.
+func WriteProblem(w http.ResponseWriter, status int, code, detail string) {
+	w.Header().Set("Content-Type", "application/problem+json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(Problem{Type: "about:blank", Status: status, Code: code, Detail: detail})
+}
+
+// NotFound — обработчик неизвестных путей.
+func NotFound(w http.ResponseWriter, _ *http.Request) {
+	WriteProblem(w, http.StatusNotFound, "common.not_found", "route not found")
+}
+
+// MethodNotAllowed — обработчик неподдерживаемых методов.
+func MethodNotAllowed(w http.ResponseWriter, _ *http.Request) {
+	WriteProblem(w, http.StatusMethodNotAllowed, "common.method_not_allowed", "method not allowed")
+}
+
+// RequestError — ошибка разбора запроса (strict-server).
+func RequestError(w http.ResponseWriter, _ *http.Request, err error) {
+	WriteProblem(w, http.StatusBadRequest, "common.bad_request", err.Error())
+}
+
+// ResponseError — непредвиденная ошибка обработчика: детали только в лог.
+func ResponseError(log *slog.Logger) func(http.ResponseWriter, *http.Request, error) {
+	return func(w http.ResponseWriter, r *http.Request, err error) {
+		log.ErrorContext(r.Context(), "handler failed", "path", r.URL.Path, "err", err)
+		WriteProblem(w, http.StatusInternalServerError, "common.internal", "internal error")
+	}
+}