Совместимость кода — гарантия исполнения

КОД ПИШЕТСЯ ПОД МИНИМУМ, А НЕ ПОД ТЕКУЩУЮ МАШИНУ.

Каждый файл декларирует свои требования.
Каждый автор знает границы совместимости.
Каждый CI проверяет соответствие.

#!/usr/bin/env python3

# ПРАВИЛЬНО
with open("file.txt", encoding="utf-8") as f:
    data = f.read()

# ПРАВИЛЬНО — subprocess
result = subprocess.run(cmd, capture_output=True, text=True, encoding="utf-8")

# ПРАВИЛЬНО (3.10+)
def process(items: list[str], cache: dict[str, int]) -> tuple[bool, str | None]:
    ...

# ДОПУСТИМО — для сложных типов
from typing import TypeVar, Generic, Protocol, TypeAlias

[project]
requires-python = ">=3.10"

from pathlib import Path

config = Path(__file__).parent / "config.json"
# НЕ: config = __file__.replace("module.py", "config.json")

# ПРАВИЛЬНО
name = f"Товар: {product.name}"
formatted = f"Цена: {price:,.2f}"

# ЗАПРЕЩЕНО (3.12+ only)
formatted = f"Цена: {price:{width}.{precision}f}"

# ПРАВИЛЬНО — альтернатива
fmt = f"{width}.{precision}f"
formatted = f"Цена: {format(price, fmt)}"

# ПРАВИЛЬНО
from library.primitives.types import Money
from library.functions.format.money import format_money

# ЗАПРЕЩЕНО для library/*
from ..primitives.types import Money

# ПРАВИЛЬНО
subprocess.run(["ls", "-la", path], check=True)

# ЗАПРЕЩЕНО (shell injection)
subprocess.run(f"ls -la {path}", shell=True)

#!/usr/bin/env python3
"""
Описание модуля.

Requires: Python >= 3.10
Dependencies: httpx, pydantic
"""

[project]
requires-python = ">=3.10"
dependencies = [
    "pydantic>=2.0",
    "httpx>=0.25",
]

// package.json
{
  "type": "module",
  "engines": {
    "node": ">=20"
  }
}

// tsconfig.json
{
  "compilerOptions": {
    "strict": true,
    "target": "ES2022",
    "module": "node16",
    "moduleResolution": "node16",
    "esModuleInterop": true,
    "skipLibCheck": true,
    "outDir": "dist",
    "declaration": true,
    "isolatedModules": true,
    "experimentalDecorators": false
  }
}

// ПРАВИЛЬНО
import { handler } from "./handler.js";
import { Config } from "../types/config.js";

// ЗАПРЕЩЕНО (не резолвится в node16)
import { handler } from "./handler";

import { join, resolve } from "node:path";

const configPath = join(import.meta.dirname, "config.json");
// НЕ: const configPath = __dirname + "/config.json"  // __dirname не существует в ESM

// ПРАВИЛЬНО
import { readFile } from "node:fs/promises";
import { createServer } from "node:http";

// ДОПУСТИМО, но не рекомендуется
import { readFile } from "fs/promises";

// ПРАВИЛЬНО
try {
  await operation();
} catch (error) {
  if (error instanceof CustomError) {
    // обработка
  }
  throw error;
}

// ЗАПРЕЩЕНО
try {
  await operation();
} catch (e: any) {
  console.log(e.message); // unsafe
}

// package.json
{
  "name": "@platform/service-name",
  "version": "1.0.0",
  "type": "module",
  "engines": {
    "node": ">=20"
  },
  "files": ["dist"],
  "exports": {
    ".": {
      "types": "./dist/index.d.ts",
      "default": "./dist/index.js"
    }
  }
}

module github.com/platform/service

go 1.21

// ПРАВИЛЬНО
configPath := filepath.Join(baseDir, "config", "app.json")

// ЗАПРЕЩЕНО (UNIX only)
configPath := path.Join(baseDir, "config", "app.json")

// ЗАПРЕЩЕНО (hardcoded separator)
configPath := baseDir + "/" + "config" + "/" + "app.json"

// ПРАВИЛЬНО
if err != nil {
    return fmt.Errorf("load config %s: %w", path, err)
}

// ЗАПРЕЩЕНО
if err != nil {
    return err  // потеря контекста
}

// ЗАПРЕЩЕНО
if err != nil {
    return fmt.Errorf("error: %v", err)  // %v теряет unwrap цепочку
}

go func() {
    defer func() {
        if r := recover(); r != nil {
            log.Printf("panic in goroutine: %v\n%s", r, debug.Stack())
        }
    }()
    doWork()
}()

func FetchData(ctx context.Context, url string) ([]byte, error) {
    req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
    // ...
}

// ПРАВИЛЬНО — для бизнес-данных, протоколов, файлов
type Order struct {
    ID        int64   // явный размер
    Amount    int64   // копейки
    Quantity  int32   // не превысит 2B
}

// ДОПУСТИМО — для индексов, счётчиков, длин
for i := 0; i < len(items); i++ {  // int ОК

# Сборка для Linux (с сервера — стандартный случай)
go build -o bin/service ./cmd/service

# Кросс-компиляция (для ПК оператора)
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/service-linux ./cmd/service
CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o bin/service.exe ./cmd/service

// go.mod
module github.com/platform/service

go 1.21

require (
    // зависимости с точными версиями
)

//go:build linux
// +build linux

package main

#!/usr/bin/env bash
set -euo pipefail

# ПРАВИЛЬНО
echo "${name}"
rm -rf "${target_dir:?}"  # :? — ошибка если пустая (защита от rm -rf /)
cp "${source}" "${dest}"

# ЗАПРЕЩЕНО
echo $name       # word splitting + globbing
rm -rf $dir/     # если $dir пустой → rm -rf /

# ПРАВИЛЬНО
cd "${workdir}" || { echo "FATAL: cannot cd to ${workdir}"; exit 1; }

# ЗАПРЕЩЕНО
cd $dir
rm -rf *

# ПРАВИЛЬНО
tmpfile=$(mktemp)
trap 'rm -f "${tmpfile}"' EXIT

# ЗАПРЕЩЕНО
tmpfile="/tmp/my_script_temp"  # race condition, collision

do_backup() {
    local source="${1:?source required}"
    local dest="${2:?dest required}"
    local timestamp
    timestamp=$(date '+%Y%m%d_%H%M%S')

    cp -r "${source}" "${dest}/${timestamp}"
}

# ПРАВИЛЬНО (bash)
if [[ -f "${config}" ]]; then
    source "${config}"
fi

if [[ "${status}" == "active" ]]; then
    echo "running"
fi

# ПРАВИЛЬНО — числовое сравнение
if (( count > 10 )); then
    echo "too many"
fi

log() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"; }
err() { echo "[$(date '+%Y-%m-%d %H:%M:%S')] ERROR: $1" >&2; }

log "Starting backup"
err "Failed to connect" && exit 1

# В начале скрипта
for cmd in curl jq rsync; do
    command -v "${cmd}" >/dev/null 2>&1 || {
        err "Required command not found: ${cmd}"
        exit 1
    }
done

#!/usr/bin/env bash
# ═══════════════════════════════════════════
# НАЗВАНИЕ: описание
# REQUIRES: bash >= 5.0, curl, jq
# PLATFORM: Linux (Ubuntu 22.04+)
# ═══════════════════════════════════════════
set -euo pipefail

# .editorconfig
root = true

[*]
charset = utf-8
end_of_line = lf
insert_final_newline = true
trim_trailing_whitespace = true
indent_style = space
indent_size = 4

[*.{js,ts,json,yml,yaml}]
indent_size = 2

[*.go]
indent_style = tab

[Makefile]
indent_style = tab

# .gitattributes
* text=auto eol=lf
*.sh text eol=lf
*.py text eol=lf
*.go text eol=lf
*.js text eol=lf
*.ts text eol=lf

# Python
from pathlib import Path
SCRIPT_DIR = Path(__file__).resolve().parent

// TypeScript (ESM, Node.js 20+)
import { fileURLToPath } from "node:url";
import { dirname, join } from "node:path";
const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Go — compile-time, не нужно
// Конфиги через флаги или embed
//go:embed config.json
var configData []byte

# Bash
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Линтинг + совместимость
ruff check --target-version py310 .

# Проверка типов
mypy --python-version 3.10 --strict .

# Проверка зависимостей
pip-audit

# Проверка encoding
grep -rn "open(" --include="*.py" | grep -v "encoding="
# ^ все вхождения без encoding — WARNING

# TypeScript — строгая компиляция
tsc --noEmit

# Линтинг
eslint --max-warnings 0 .

# Проверка ESM
# package.json должен содержать "type": "module"
node -e "import('./src/index.js')"

# Проверка зависимостей
npm audit

# Vet — стандартные проверки
go vet ./...

# Staticcheck — расширенные проверки
staticcheck ./...

# Тесты с race detector
go test -race ./...

# Проверка кросс-компиляции
CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build ./...
CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build ./...

# Уязвимости
govulncheck ./...

# ShellCheck — статический анализ
shellcheck -s bash scripts/*.sh

# Обязательные проверки ShellCheck:
# SC2086 — переменные без кавычек
# SC2046 — word splitting в подстановке
# SC2006 — backticks вместо $()
# SC2064 — trap с раскрытием переменных
# SC2155 — local + подстановка в одной строке

# Проверка shebang
head -1 scripts/*.sh | grep -v "#!/usr/bin/env bash"
# ^ все несоответствия — ERROR

# Encoding — все файлы UTF-8
file --mime-encoding $(find . -name "*.py" -o -name "*.sh" -o -name "*.go" -o -name "*.ts") \
    | grep -v "utf-8\|us-ascii"
# ^ любые результаты — ERROR

# Line endings — только LF
grep -rlP "\r\n" --include="*.py" --include="*.sh" --include="*.go" --include="*.ts" .
# ^ любые результаты — ERROR

# Secrets в коде
grep -rn "password\s*=\s*['\"]" --include="*.py" --include="*.ts" --include="*.go" .
grep -rn "api_key\s*=\s*['\"]" --include="*.py" --include="*.ts" --include="*.go" .
# ^ любые результаты — CRITICAL

Открыл файл → Исправил задачу → Привёл к стандарту → Коммит