파운데이션 모델은 어떻게 Bash를 초인적으로 다루게 됐나

python3 <<'PY'
from pathlib import Path
 
changes = {
    "src/services/billing.py": [
        (
            "def charge_customer(customer_id: str, amount: int):",
            "def charge_customer(customer_id: str, amount_cents: int):",
            1,
        ),
        (
            "client.charge(token, amount)",
            "client.charge(token, amount_cents)",
            1,
        ),
    ],
    "src/api/checkout.py": [
        (
            "charge_customer(order.customer_id, order.total)",
            "charge_customer(order.customer_id, order.total_cents)",
            1,
        ),
    ],
    "src/jobs/retry_payment.py": [
        (
            "charge_customer(job.customer_id, job.amount)",
            "charge_customer(job.customer_id, job.amount_cents)",
            1,
        ),
    ],
    "tests/test_billing.py": [
        (
            "charge_customer(customer.id, 1200)",
            "charge_customer(customer.id, amount_cents=1200)",
            2,
        ),
    ],
}
 
prepared = {}
for filename, replacements in changes.items():
    path = Path(filename)
    text = path.read_text()
    for old, new, expected in replacements:
        found = text.count(old)
        if found != expected:
            raise SystemExit(
                f"{filename}: expected {expected} occurrences of {old!r}, found {found}"
            )
        text = text.replace(old, new)
    prepared[path] = text
 
for path, text in prepared.items():
    path.write_text(text)
PY
 
ruff format src/services/billing.py src/api/checkout.py src/jobs/retry_payment.py tests/test_billing.py
ruff check src/services/billing.py src/api/checkout.py src/jobs/retry_payment.py tests/test_billing.py
pyright src/services/billing.py src/api/checkout.py src/jobs/retry_payment.py
pytest -q tests/test_billing.py tests/test_checkout.py tests/test_retry_payment.py
git diff --check
git diff --stat -- src/services/billing.py src/api/checkout.py src/jobs/retry_payment.py tests/test_billing.py

set -euo pipefail
 
test -n "${GOOD_REV:-}"
repo=$(pwd -P)
scratch=$(mktemp -d)
 
cleanup() {
  git -C "$repo" worktree remove --force "$scratch/repo" >/dev/null 2>&1 || true
  rm -rf "$scratch"
}
trap cleanup EXIT
 
git worktree add --detach "$scratch/repo" HEAD >/dev/null
cd "$scratch/repo"
git bisect start HEAD "$GOOD_REV"
 
git bisect run bash -c '
  failures=0
  for seed in 11 29 47 71 101; do
    if ! TEST_SEED=$seed pytest -q tests/test_checkout_race.py; then
      failures=$((failures + 1))
    fi
  done
  test "$failures" -lt 3
' >"$scratch/bisect.log" 2>&1
 
bad=$(git rev-parse HEAD)
git bisect reset >/dev/null
 
printf 'first bad commit: %s\n' "$bad"
git show --no-ext-diff --format=fuller --stat "$bad"
git diff --no-ext-diff "$bad^" "$bad" -- src/checkout tests/test_checkout_race.py | sed -n '1,220p'
printf '\nlast bisect events:\n'
tail -n 40 "$scratch/bisect.log"

python3 <<'PY'
import gzip
import glob
import json
import sqlite3
import tempfile
from pathlib import Path
 
def records(pattern):
    for name in sorted(glob.glob(pattern)):
        path = Path(name)
        opener = gzip.open if path.suffix == ".gz" else open
        with opener(path, "rt", encoding="utf-8") as stream:
            for line in stream:
                try:
                    yield json.loads(line)
                except json.JSONDecodeError:
                    continue
 
with tempfile.TemporaryDirectory() as directory:
    db = sqlite3.connect(Path(directory) / "logs.sqlite")
    db.executescript("""
        PRAGMA journal_mode = OFF;
        PRAGMA synchronous = OFF;
        PRAGMA temp_store = FILE;
 
        CREATE TABLE access (
            req_id TEXT PRIMARY KEY,
            path TEXT NOT NULL,
            status INTEGER NOT NULL,
            latency_ms REAL NOT NULL
        );
 
        CREATE TABLE errors (
            req_id TEXT PRIMARY KEY,
            kind TEXT NOT NULL
        );
    """)
 
    access_batch = []
    for row in records("logs/access.jsonl*"):
        access_batch.append((
            row["req_id"],
            row["path"],
            int(row["status"]),
            float(row["latency_ms"]),
        ))
        if len(access_batch) == 10_000:
            db.executemany("INSERT OR REPLACE INTO access VALUES (?, ?, ?, ?)", access_batch)
            access_batch.clear()
    db.executemany("INSERT OR REPLACE INTO access VALUES (?, ?, ?, ?)", access_batch)
 
    error_batch = []
    for row in records("logs/error.jsonl*"):
        error_batch.append((row["req_id"], row["error_class"]))
        if len(error_batch) == 10_000:
            db.executemany("INSERT OR REPLACE INTO errors VALUES (?, ?)", error_batch)
            error_batch.clear()
    db.executemany("INSERT OR REPLACE INTO errors VALUES (?, ?)", error_batch)
 
    db.executescript("""
        CREATE INDEX access_status_req ON access(status, req_id);
        CREATE INDEX errors_req ON errors(req_id);
    """)
 
    rows = db.execute("""
        WITH matched AS (
            SELECT a.path, a.latency_ms, e.kind
            FROM access AS a
            JOIN errors AS e USING (req_id)
            WHERE a.status >= 500
        ),
        ranked AS (
            SELECT
                path,
                kind,
                latency_ms,
                row_number() OVER (
                    PARTITION BY path ORDER BY latency_ms
                ) AS position,
                count(*) OVER (
                    PARTITION BY path
                ) AS samples
            FROM matched
        )
        SELECT
            path,
            count(*) AS failures,
            round(avg(latency_ms), 1) AS average_ms,
            max(
                CASE
                    WHEN position = CAST((samples * 95 + 99) / 100 AS INTEGER)
                    THEN latency_ms
                END
            ) AS p95_ms,
            group_concat(DISTINCT kind) AS error_classes
        FROM ranked
        GROUP BY path
        ORDER BY failures DESC
        LIMIT 5
    """).fetchall()
 
    print(json.dumps([
        {
            "endpoint": path,
            "failures": failures,
            "average_ms": average,
            "p95_ms": p95,
            "error_classes": kinds.split(","),
        }
        for path, failures, average, p95, kinds in rows
    ], indent=2))
PY