Compare commits
41 Commits
6de2fcc1bd
...
dev
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e1f06e3405 | ||
|
|
f4ebd33329 | ||
|
|
beeace231d | ||
|
|
79e7a4f61f | ||
|
|
618cd4a61c | ||
|
|
66d3cc4da3 | ||
|
|
35138bdc22 | ||
|
|
08f945a029 | ||
|
|
2160ba6ce8 | ||
|
|
a1455aade4 | ||
|
|
0d2e5a592f | ||
|
|
98d345ceee | ||
|
|
ac613e680a | ||
|
|
e67f8a0cda | ||
|
|
7a1d14f23a | ||
|
|
829d43851b | ||
|
|
381b6c8a9c | ||
|
|
7e4c41cffd | ||
|
|
d1c3adddff | ||
|
|
085b2bc2ce | ||
|
|
e77ed38ebf | ||
|
|
eff1ae313f | ||
|
|
47cecbc28b | ||
|
|
d4cb6bc2e8 | ||
|
|
e1db51c461 | ||
|
|
6ed8eb5f06 | ||
|
|
d663f1eeb5 | ||
|
|
2d9cae2624 | ||
|
|
8a0c566a68 | ||
|
|
5226ec4819 | ||
|
|
44202c3679 | ||
|
|
a50ed1e593 | ||
|
|
7441f0550b | ||
|
|
036a5116b8 | ||
|
|
4630813644 | ||
|
|
38271d0d88 | ||
|
|
fff9f05bae | ||
|
|
049b4fd280 | ||
|
|
604b983a51 | ||
|
|
4ca4cacda0 | ||
|
|
3b64635339 |
4
.gitignore
vendored
4
.gitignore
vendored
@@ -4,6 +4,10 @@ data/
|
||||
*.sqlite3-wal
|
||||
*.sqlite3-shm
|
||||
|
||||
# deploy state (stack-local, never committed)
|
||||
.env
|
||||
tailscale-state/
|
||||
|
||||
# python
|
||||
__pycache__/
|
||||
*.pyc
|
||||
|
||||
101
README.md
101
README.md
@@ -1,98 +1,19 @@
|
||||
# Bike-Tinder
|
||||
|
||||
A private, Tinder-style web app for browsing the motorcycle market: swipe real listings (like / nope / maybe), see everything on one editable list, and let the deck learn your taste. Built for Glenn; runs on the Rotarran, published to the tailnet only.
|
||||
Find your next motorcycle without sorting through the same classifieds every night. Bike-Tinder is a private, self-hosted web app that puts motorcycle listings from Kijiji in Nova Scotia and New Brunswick into a photo-first swipe deck.
|
||||
|
||||
**Status:** Phase 3 (personalization) built on `dev` (2026-11-11): sections of 25 (wildcards + second looks + new), taste engine with match points, tank gauges, dossier "Why this rank", real Trends tab, agent pass (mock / live / fallback). Phase 2 remains shipped as-is; deployment (podman stack) is Phase 4 — not started.
|
||||
Swipe right to like a bike, left to pass, or up if you're on the fence. Open a card to check the price, mileage, and photos. The searchable List lets you revisit a bike or change your mind later. As you swipe, the deck learns what you tend to like and brings more of those bikes forward.
|
||||
|
||||
## How it works
|
||||
## A look at the app
|
||||
|
||||
```
|
||||
[single-source crawler] → [nightly importer] → [app DB] → [API + PWA deck] → Glenn's thumb
|
||||
↓
|
||||
[swipe history] → [ranking]
|
||||
```
|
||||
| Swipe deck | Bike details |
|
||||
| :---: | :---: |
|
||||
|  |  |
|
||||
|
||||
- **Crawl** — **Kijiji** (NS + NB; decided 2026-11-10 — see `docs/SOURCES.md`) is swept nightly by the existing hunt crawler; a script-only importer folds the results in. No LLM involved, zero token cost.
|
||||
- **Import** — the importer upserts the source's catalog into the app database: new listings appear, changes update, vanished listings retire after repeated misses (never a blocked page, never a guess).
|
||||
- **Deck** — a Tinder-like PWA: card stack, drag to swipe, big buttons. Like / Nope / Maybe. "It's a match" moment when you like something.
|
||||
- **List & edit** — every entry in one table; re-file any call later (a nope can become a like).
|
||||
- **Ranking** — cold start uses the hunt's rubric score; a cheap, fully explainable swipe-boost lands first (v1.x), then a small learned model (Phase 3, retrained nightly) orders the deck by *your* taste. "Because you liked X" chips, never a black box.
|
||||
*Screenshots from the app with demo listings.*
|
||||
|
||||
## Docs
|
||||
## Documentation
|
||||
|
||||
- [`docs/SOURCES.md`](docs/SOURCES.md) — the v1 source decision (candidates, evidence, choice)
|
||||
- [`docs/DESIGN.md`](docs/DESIGN.md) — architecture, components, data flow, deployment
|
||||
- [`docs/DATA-MODEL.md`](docs/DATA-MODEL.md) — database schema + sync semantics
|
||||
- [`docs/RANKING.md`](docs/RANKING.md) — cold-start + learned ranking design
|
||||
- [`docs/UI-SPEC.md`](docs/UI-SPEC.md) — screens, gestures, Tinder-fidelity goals
|
||||
- [`docs/PLAN.md`](docs/PLAN.md) — phases, acceptance criteria, status
|
||||
|
||||
## Branches
|
||||
|
||||
- `main` — stable trunk (docs + verified code); the default branch.
|
||||
- `dev` — active development; build work lands here first.
|
||||
- `release` — deployable cuts; the Rotarran stack tracks this branch.
|
||||
|
||||
## Run & develop
|
||||
|
||||
Everything runs from the repo root (Python 3.13+, stdlib where possible).
|
||||
|
||||
```sh
|
||||
# one-time setup
|
||||
python3 -m venv .venv
|
||||
.venv/bin/pip install -r requirements.txt # fastapi + uvicorn (+ httpx for tests)
|
||||
|
||||
# import the hunt state into the DB (idempotent; safe to re-run any time)
|
||||
python3 -m app.importer --state-dir ~/.hermes/scripts/motorcycle-hunt.d --db data/bike-tinder.sqlite3
|
||||
|
||||
# mirror card images into data/img/ (polite: ~1 req/s, skip-existing, resumable)
|
||||
.venv/bin/python -m app.imgfetch --db data/bike-tinder.sqlite3
|
||||
.venv/bin/python -m app.imgfetch --limit 15 # small test runs
|
||||
|
||||
# serve the app (127.0.0.1:9453 by default)
|
||||
.venv/bin/python -m app.serve --db data/bike-tinder.sqlite3 --port 9453
|
||||
|
||||
# self-check: P1 + P2 + P3 (25 checks, temp DB copies only)
|
||||
.venv/bin/python -m app.selfcheck
|
||||
|
||||
# P3: agent pass — mock is deterministic + offline (tests, offline forge);
|
||||
# --live needs OPENROUTER_API_KEY (+ optional BT_AGENT_MODEL); --dry-run
|
||||
# validates the payload and writes nothing; --print-summary prints exactly
|
||||
# the strike summary a live pass would be sent.
|
||||
.venv/bin/python -m app.agentpass --db /tmp/bt-copy.sqlite3 --mock
|
||||
.venv/bin/python -m app.agentpass --db /tmp/bt-copy.sqlite3 --print-summary --dry-run
|
||||
|
||||
# P3: run a scratch server against a COPY (NEVER point a dev server at
|
||||
# data/bike-tinder.sqlite3 while the live service owns it — use port 9454).
|
||||
cp data/bike-tinder.sqlite3 /tmp/bt-copy.sqlite3
|
||||
.venv/bin/python -m app.serve --db /tmp/bt-copy.sqlite3 --img-dir data/img --port 9454
|
||||
curl -s http://127.0.0.1:9454/api/section # first read composes a section
|
||||
curl -s -X POST http://127.0.0.1:9454/api/section/forge \
|
||||
-H 'Content-Type: application/json' -d '{"size": 8}' # mock pass + compose
|
||||
|
||||
# proof CLI: ranked deck + counts (read-only)
|
||||
python3 -m app.deck --db data/bike-tinder.sqlite3 --top 15
|
||||
```
|
||||
|
||||
Key routes: `/` (PWA), `/api/health`, `/api/stats`, `/api/deck?limit=&cursor=` (read-only
|
||||
legacy fallback), `POST /api/swipe` / `DELETE /api/swipe/{id}`, `/api/list?decision=&sort=&q=&limit=&offset=`,
|
||||
`/api/listing/{id}`, `POST /api/import`, `POST /api/badge/seen`, `/img/{id}`
|
||||
(cached file → 302 source CDN → 404 placeholder).
|
||||
P3 (Phase 3): `GET /api/section`, `POST /api/section/forge` `{size}`,
|
||||
`GET /api/trends`, `POST /api/agent/run` `{source: mock|live}`,
|
||||
`POST /api/prefs` `{key: forge_mode, value: ondemand|strict}`. Listing
|
||||
payloads carry `points`, `tank {value, band}`, `slot`, `round_next`,
|
||||
`points_breakdown`. Full contract: `docs/UI-SPEC.md` §10 + `docs/RANKING.md`
|
||||
Stage 2 + the task brief.
|
||||
|
||||
`data/` and `.venv/` are gitignored — the DB, image mirror and venv are local state.
|
||||
|
||||
## Deployment (planned)
|
||||
|
||||
A small podman compose stack on the Rotarran under `/var/mnt/DATA/podman-stacks/bike-tinder/`, its own systemd user unit (`Delegate=yes`), SQLite database. The stack ships its own Tailscale node (sidecar container — no host-tailnet coupling) and serves the app privately at `https://biketinder.tailf35a34.ts.net`. Single user; reachable only from Glenn's own devices.
|
||||
|
||||
## Crew
|
||||
|
||||
- **Glenn** — owner; the thumb that swipes.
|
||||
- **Alex** — resident agent; architecture, orchestration, docs.
|
||||
- **Torres** — engineer; builds and maintains this repo.
|
||||
- [How it works](docs/HOW-IT-WORKS.md) — catalog, swipe history, and ranking
|
||||
- [Development and deployment](docs/DEVELOPMENT.md) — local setup, tests, and operations
|
||||
- [Interface and gestures](docs/UI-SPEC.md) · [Roadmap](docs/PLAN.md)
|
||||
|
||||
154
app/api.py
154
app/api.py
@@ -12,6 +12,9 @@ on; frozen in the task brief):
|
||||
url, img ("/img/{id}" if img_url or cached file exists else null), desc,
|
||||
family, score, year, seller_type, extras (array of strings),
|
||||
decision (null|'like'|'maybe'|'nope'), first_seen}
|
||||
B1 additions (UI-SPEC §11 / DATA-MODEL "B1 additions"):
|
||||
n_photos (int), last_photo_idx (int|null); GET /img/{id}?i=n serves
|
||||
gallery photo n.
|
||||
"""
|
||||
import datetime
|
||||
import json
|
||||
@@ -42,7 +45,7 @@ DECK_WHERE = (
|
||||
)
|
||||
|
||||
DECK_SELECT = (
|
||||
"SELECT l.*, s.action AS decision"
|
||||
"SELECT l.*, s.action AS decision, s.last_photo_idx AS last_photo_idx"
|
||||
" FROM listings l LEFT JOIN swipes s ON s.listing_id = l.id"
|
||||
" WHERE " + DECK_WHERE
|
||||
)
|
||||
@@ -128,10 +131,21 @@ def count_deck_after(app, score, first_seen, listing_id):
|
||||
|
||||
def build_payload(img_dir):
|
||||
def _payload(conn, row):
|
||||
img = None
|
||||
if row['img_url'] or os.path.exists(
|
||||
os.path.join(img_dir, '%d.webp' % row['id'])):
|
||||
img = '/img/%d' % row['id']
|
||||
leg = os.path.join(img_dir, '%d.webp' % row['id'])
|
||||
b1 = os.path.join(img_dir, '%d_0.webp' % row['id'])
|
||||
has_photo = (bool(row['img_url']) or os.path.exists(leg)
|
||||
or os.path.exists(b1))
|
||||
img = '/img/%d' % row['id'] if has_photo else None
|
||||
# B1: gallery size + swipe-time photo index (UI-SPEC §11 / DATA-MODEL B1)
|
||||
imgs = []
|
||||
if isinstance(row['imgs'], str) and row['imgs']:
|
||||
try:
|
||||
imgs = json.loads(row['imgs'])
|
||||
except ValueError:
|
||||
imgs = []
|
||||
if not isinstance(imgs, list):
|
||||
imgs = []
|
||||
n_photos = len(imgs) if imgs else (1 if has_photo else 0)
|
||||
extras = row['extras']
|
||||
if isinstance(extras, str):
|
||||
try:
|
||||
@@ -148,6 +162,9 @@ def build_payload(img_dir):
|
||||
'region': row['region'],
|
||||
'url': row['url'],
|
||||
'img': img,
|
||||
'n_photos': n_photos,
|
||||
'last_photo_idx': (row['last_photo_idx']
|
||||
if 'last_photo_idx' in row.keys() else None),
|
||||
'desc': row['desc'],
|
||||
'family': row['family'],
|
||||
'score': row['score'],
|
||||
@@ -221,6 +238,14 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
live = conn.execute(
|
||||
"SELECT COUNT(*) AS n FROM listings WHERE status='active'"
|
||||
).fetchone()['n']
|
||||
# item 7: fresh = active with no swipe row (the deck's new-pool
|
||||
# predicate, verbatim). A swipe of ANY age removes freshness.
|
||||
fresh = conn.execute(
|
||||
"SELECT COUNT(*) AS n FROM listings l"
|
||||
" WHERE l.status='active'"
|
||||
" AND NOT EXISTS (SELECT 1 FROM swipes s"
|
||||
" WHERE s.listing_id = l.id)"
|
||||
).fetchone()['n']
|
||||
badge = get_pref(conn, 'badge_seen_at') or ''
|
||||
new = conn.execute(
|
||||
"SELECT COUNT(*) AS n FROM listings"
|
||||
@@ -236,6 +261,7 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
' ORDER BY id DESC LIMIT 1').fetchone()
|
||||
return {
|
||||
'live': live,
|
||||
'fresh': fresh,
|
||||
'new': new,
|
||||
'likes': per['like'],
|
||||
'maybes': per['maybe'],
|
||||
@@ -290,6 +316,15 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
section_id = body.get('section_id')
|
||||
if not isinstance(section_id, int):
|
||||
section_id = None
|
||||
# B1: optional photo index on screen at swipe time (§11.5 rotation).
|
||||
has_photo_idx = 'photo_idx' in body
|
||||
photo_idx = body.get('photo_idx')
|
||||
if has_photo_idx and photo_idx is not None:
|
||||
if (isinstance(photo_idx, bool) or not isinstance(photo_idx, int)
|
||||
or photo_idx < 0):
|
||||
raise HTTPException(
|
||||
status_code=400,
|
||||
detail='photo_idx must be a non-negative int (or null)')
|
||||
conn = get_conn(app)
|
||||
try:
|
||||
row = conn.execute('SELECT id FROM listings WHERE id=?',
|
||||
@@ -297,19 +332,32 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
if not row:
|
||||
raise HTTPException(status_code=404, detail='unknown listing')
|
||||
now = imp.now_iso()
|
||||
conn.execute(
|
||||
'''INSERT INTO swipes (listing_id, action, created_at, updated_at)
|
||||
VALUES (?,?,?,?)
|
||||
ON CONFLICT(listing_id) DO UPDATE SET
|
||||
action=excluded.action, updated_at=excluded.updated_at''',
|
||||
(listing_id, action, now, now))
|
||||
if has_photo_idx:
|
||||
# explicit photo_idx (int or null) overwrites; an absent key
|
||||
# preserves the stored index (list edits etc.)
|
||||
conn.execute(
|
||||
'''INSERT INTO swipes (listing_id, action, created_at,
|
||||
updated_at, last_photo_idx)
|
||||
VALUES (?,?,?,?,?)
|
||||
ON CONFLICT(listing_id) DO UPDATE SET
|
||||
action=excluded.action, updated_at=excluded.updated_at,
|
||||
last_photo_idx=excluded.last_photo_idx''',
|
||||
(listing_id, action, now, now, photo_idx))
|
||||
else:
|
||||
conn.execute(
|
||||
'''INSERT INTO swipes (listing_id, action, created_at, updated_at)
|
||||
VALUES (?,?,?,?)
|
||||
ON CONFLICT(listing_id) DO UPDATE SET
|
||||
action=excluded.action, updated_at=excluded.updated_at''',
|
||||
(listing_id, action, now, now))
|
||||
# P3: append the learning event (round = prior events + 1)
|
||||
round_ = dbmod.append_event(conn, listing_id, action, section_id,
|
||||
now)
|
||||
conn.commit()
|
||||
stored = conn.execute(
|
||||
'SELECT listing_id, action, created_at, updated_at'
|
||||
' FROM swipes WHERE listing_id=?', (listing_id,)).fetchone()
|
||||
'SELECT listing_id, action, created_at, updated_at,'
|
||||
' last_photo_idx FROM swipes WHERE listing_id=?',
|
||||
(listing_id,)).fetchone()
|
||||
result = dict(stored)
|
||||
result['round'] = round_
|
||||
result['section_id'] = section_id
|
||||
@@ -353,7 +401,8 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
' LEFT JOIN swipes s ON s.listing_id = l.id'
|
||||
' WHERE ' + where, params).fetchone()['n']
|
||||
rows = conn.execute(
|
||||
'SELECT l.*, s.action AS decision FROM listings l'
|
||||
'SELECT l.*, s.action AS decision,'
|
||||
' s.last_photo_idx AS last_photo_idx FROM listings l'
|
||||
' LEFT JOIN swipes s ON s.listing_id = l.id'
|
||||
' WHERE ' + where + ' ORDER BY ' + LIST_SORTS[sort] +
|
||||
' LIMIT ? OFFSET ?', params + [limit, offset]).fetchall()
|
||||
@@ -368,7 +417,8 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
try:
|
||||
engine = secmod.build_engine(conn, now=utcnow())
|
||||
row = conn.execute(
|
||||
'SELECT l.*, s.action AS decision FROM listings l'
|
||||
'SELECT l.*, s.action AS decision,'
|
||||
' s.last_photo_idx AS last_photo_idx FROM listings l'
|
||||
' LEFT JOIN swipes s ON s.listing_id = l.id'
|
||||
' WHERE l.id=?', (listing_id,)).fetchone()
|
||||
if not row:
|
||||
@@ -410,11 +460,20 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
sec = conn.execute('SELECT * FROM sections WHERE id=?',
|
||||
(sec['id'],)).fetchone()
|
||||
mode = get_pref(conn, 'forge_mode', 'ondemand')
|
||||
decided_ids = secmod.section_decided_ids(conn, sec)
|
||||
items = [p3_payload(conn, engine, r, slot=r['slot'],
|
||||
include_breakdown=True)
|
||||
for r in data['items']]
|
||||
for p in items:
|
||||
# item 5: decided IN this section (real verdict), not the joined
|
||||
# lifetime swipes decision — present on EVERY item so the FE's
|
||||
# local-intent branch can't misfire
|
||||
p['decided_this_section'] = p['id'] in decided_ids
|
||||
data['items'] = items
|
||||
data['mode'] = mode
|
||||
data['recipe'] = (json.loads(sec['recipe']) if sec['recipe'] else {})
|
||||
data['pool'] = secmod.pool_counts(conn)
|
||||
data['prefs'] = {'rubric_debug': get_pref(conn, 'rubric_debug', 'off')}
|
||||
data['can_forge'] = (mode != 'strict'
|
||||
or secmod.fresh_profile_exists(conn, sec))
|
||||
data['counts'] = secmod.section_counts(conn, sec)
|
||||
@@ -442,6 +501,22 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
conn, engine, size=25,
|
||||
profile_version=prof['version'] if prof else None,
|
||||
note='cold compose (first read)')
|
||||
else:
|
||||
# item 8: an empty composed section (the catalog was fully
|
||||
# drained) recomposes on the read once stock exists — the
|
||||
# nightly-import recovery path. Zero items + zero pool
|
||||
# keeps serving the empty section (loud empty2).
|
||||
n_items = conn.execute(
|
||||
'SELECT COUNT(*) AS n FROM section_items'
|
||||
' WHERE section_id=?', (sec['id'],)).fetchone()['n']
|
||||
if n_items == 0 and any(secmod.pool_counts(conn).values()):
|
||||
prof = secmod.latest_profile(conn)
|
||||
engine = secmod.build_engine(conn, prof, now=utcnow())
|
||||
secmod.close_section(conn, sec, utcnow(), status='closed')
|
||||
sec = secmod.compose_section(
|
||||
conn, engine, size=25,
|
||||
profile_version=prof['version'] if prof else None,
|
||||
note='refill compose (stock returned)')
|
||||
return section_state(conn, sec)
|
||||
finally:
|
||||
conn.close()
|
||||
@@ -481,6 +556,11 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
conn, engine, size=size,
|
||||
profile_version=prof['version'] if prof else None,
|
||||
note=note)
|
||||
# v1.1 item 6: label the dry-catalog state on the forge note
|
||||
recipe = (json.loads(newsec['recipe'])
|
||||
if newsec['recipe'] else {})
|
||||
if recipe.get('new') == 0:
|
||||
note = '%s · catalog fully reviewed' % (note or '')
|
||||
return section_state(conn, newsec, note=note)
|
||||
finally:
|
||||
conn.close()
|
||||
@@ -592,7 +672,9 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
|
||||
@app.post('/api/agent/run')
|
||||
def agent_run(body: dict):
|
||||
source = body.get('source', 'mock') if isinstance(body, dict) else 'mock'
|
||||
source = body.get('source') if isinstance(body, dict) else None
|
||||
if source is None:
|
||||
source = 'live' if live_configured() else 'mock'
|
||||
if source not in ('mock', 'live'):
|
||||
raise HTTPException(status_code=400,
|
||||
detail='source must be mock|live')
|
||||
@@ -610,7 +692,8 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
def set_pref_endpoint(body: dict):
|
||||
key = body.get('key')
|
||||
value = body.get('value')
|
||||
allowed = {'forge_mode': ('ondemand', 'strict')}
|
||||
allowed = {'forge_mode': ('ondemand', 'strict'),
|
||||
'rubric_debug': ('off', 'on')}
|
||||
if key not in allowed or value not in allowed[key]:
|
||||
raise HTTPException(status_code=400,
|
||||
detail='unknown or invalid pref')
|
||||
@@ -625,18 +708,43 @@ def create_app(db_path, img_dir, state_dir=None):
|
||||
# -- images + static -------------------------------------------------
|
||||
|
||||
@app.get('/img/{listing_id}')
|
||||
def img(listing_id: int):
|
||||
fpath = os.path.join(app.state.img_dir, '%d.webp' % listing_id)
|
||||
def img(listing_id: int, i: int = Query(0, ge=0)):
|
||||
"""Photo n of a gallery (B1 §11.1): mirrored file -> CDN 302 -> 404.
|
||||
|
||||
i=0 keeps the legacy chain ({id}.webp, with {id}_0.webp accepted as
|
||||
the gallery-mirror name for the primary); i>0 serves {id}_{n}.webp
|
||||
with the CDN fallback taken from imgs[n].
|
||||
"""
|
||||
fpath = os.path.join(
|
||||
app.state.img_dir,
|
||||
'%d.webp' % listing_id if i == 0 else
|
||||
'%d_%d.webp' % (listing_id, i))
|
||||
if i == 0 and not os.path.exists(fpath):
|
||||
alt = os.path.join(app.state.img_dir, '%d_0.webp' % listing_id)
|
||||
if os.path.exists(alt):
|
||||
fpath = alt
|
||||
if os.path.exists(fpath):
|
||||
return FileResponse(fpath, media_type='image/webp')
|
||||
conn = get_conn(app)
|
||||
try:
|
||||
row = conn.execute('SELECT img_url FROM listings WHERE id=?',
|
||||
(listing_id,)).fetchone()
|
||||
row = conn.execute(
|
||||
'SELECT img_url, imgs FROM listings WHERE id=?',
|
||||
(listing_id,)).fetchone()
|
||||
finally:
|
||||
conn.close()
|
||||
if row and row['img_url']:
|
||||
return RedirectResponse(url=row['img_url'], status_code=302)
|
||||
url = None
|
||||
if row:
|
||||
if i == 0 and row['img_url']:
|
||||
url = row['img_url']
|
||||
elif row['imgs']:
|
||||
try:
|
||||
arr = json.loads(row['imgs'])
|
||||
except ValueError:
|
||||
arr = []
|
||||
if isinstance(arr, list) and len(arr) > i and arr[i]:
|
||||
url = arr[i]
|
||||
if url:
|
||||
return RedirectResponse(url=url, status_code=302)
|
||||
raise HTTPException(status_code=404, detail='no image')
|
||||
|
||||
@app.get('/')
|
||||
|
||||
@@ -95,6 +95,13 @@ def init_db(conn):
|
||||
conn.execute('ALTER TABLE listings ADD COLUMN seller_type TEXT')
|
||||
if 'extras' not in cols:
|
||||
conn.execute('ALTER TABLE listings ADD COLUMN extras TEXT')
|
||||
# B1 (photo experience v2): gallery URLs + swipe-time photo index.
|
||||
if 'imgs' not in cols:
|
||||
conn.execute('ALTER TABLE listings ADD COLUMN imgs TEXT')
|
||||
sw_cols = {r['name'] for r in conn.execute(
|
||||
"PRAGMA table_info('swipes')")}
|
||||
if 'last_photo_idx' not in sw_cols:
|
||||
conn.execute('ALTER TABLE swipes ADD COLUMN last_photo_idx INTEGER')
|
||||
# P3 tables (idempotent on every call)
|
||||
conn.executescript(P3_SCHEMA)
|
||||
# P3 event seeding: one round-1 event per existing swipe, copied
|
||||
|
||||
519
app/fe_walk_b1.py
Normal file
519
app/fe_walk_b1.py
Normal file
@@ -0,0 +1,519 @@
|
||||
"""B1 FE walk — headless-chromium proof of UI-SPEC §11 on the real page.
|
||||
|
||||
Not part of `app.selfcheck` (needs playwright + a live server); run it after
|
||||
starting the scratch server (the brief's isolation recipe):
|
||||
|
||||
.venv/bin/python -m app.fe_walk_b1 setup # optional — auto at start
|
||||
|
||||
env -u OPENROUTER_API_KEY .venv/bin/python -m app.serve \
|
||||
--db /var/home/admin/dev/bike-tinder-b1/test-walk.sqlite3 \
|
||||
--img-dir /var/home/admin/dev/bike-tinder-b1/test-img \
|
||||
--host 127.0.0.1 --port 9454 # in another shell (mock forge)
|
||||
|
||||
.venv/bin/python -m app.fe_walk_b1 # walk (this file)
|
||||
|
||||
Setup is deterministic and idempotent: a fresh copy of the pristine B1 copy
|
||||
DB (test-copy.sqlite3) each run, synthetic multi-photo listings (ids 701+)
|
||||
with local image files staged into test-img from media-sample/, and one
|
||||
swiped return listing (705) whose stored last_photo_idx drives §11.5
|
||||
rotation. Everything walks the REAL page: real pointers, real DOM, no
|
||||
stubbed APIs.
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import sqlite3
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
ARENA = '/var/home/admin/dev/bike-tinder-b1'
|
||||
PRISTINE = os.path.join(ARENA, 'test-copy.sqlite3')
|
||||
WALK_DB = os.path.join(ARENA, 'test-walk.sqlite3')
|
||||
IMG_DIR = os.path.join(ARENA, 'test-img')
|
||||
MEDIA = os.path.join(ARENA, 'media-sample')
|
||||
BASE_URL = 'http://127.0.0.1:9454'
|
||||
|
||||
CDN = ('https://media.kijiji.ca/api/v1/ca-prod-dealer-ads/images/x/%s'
|
||||
'?rule=kijijica-640-webp')
|
||||
|
||||
# synthetic fixtures: listing_id -> (n_photos, label)
|
||||
FIX = {
|
||||
701: (8, 'gallery-8'),
|
||||
702: (3, 'gallery-3'),
|
||||
703: (2, 'gallery-2'),
|
||||
704: (1, 'single-photo'),
|
||||
705: (8, 'return-rotation'), # pre-swiped: last_photo_idx=0 -> lead 1
|
||||
706: (0, 'zero-photo'),
|
||||
}
|
||||
SCORE_BASE = 2000
|
||||
|
||||
|
||||
def stage_img_files():
|
||||
"""{id}_0..{id}_{n-1}.webp (and {id}.webp for the legacy single) from
|
||||
media-sample's real webp files — no network needed."""
|
||||
os.makedirs(IMG_DIR, exist_ok=True)
|
||||
names = sorted(m for m in os.listdir(MEDIA) if m.endswith('.webp'))
|
||||
assert len(names) == 12, names
|
||||
k = 0 # cycle through the 12 real files
|
||||
for lid in sorted(FIX):
|
||||
n = FIX[lid][0]
|
||||
if n == 0:
|
||||
continue
|
||||
if n == 1:
|
||||
shutil.copy2(os.path.join(MEDIA, names[k % len(names)]),
|
||||
os.path.join(IMG_DIR, '%d.webp' % lid))
|
||||
k += 1
|
||||
continue
|
||||
for i in range(n):
|
||||
shutil.copy2(os.path.join(MEDIA, names[k % len(names)]),
|
||||
os.path.join(IMG_DIR, '%d_%d.webp' % (lid, i)))
|
||||
k += 1
|
||||
|
||||
|
||||
def setup_db():
|
||||
shutil.copy2(PRISTINE, WALK_DB)
|
||||
from app import db as dbmod
|
||||
conn = dbmod.connect(WALK_DB)
|
||||
dbmod.init_db(conn) # B1 migrations
|
||||
for lid in sorted(FIX):
|
||||
n = FIX[lid][0]
|
||||
imgs = [CDN % ('x%d-%d' % (lid, i)) for i in range(n)]
|
||||
img = imgs[0] if imgs else None
|
||||
score = SCORE_BASE + (750 - lid) # 701 highest -> top of the deck
|
||||
conn.execute(
|
||||
"DELETE FROM listings WHERE id=?", (lid,))
|
||||
conn.execute(
|
||||
"INSERT INTO listings (id, region, src_id, title, url, status,"
|
||||
" img_url, imgs, score, first_seen, desc) VALUES"
|
||||
" (?, 'ns', ?, ?, ?, 'active', ?, ?, ?,"
|
||||
" '2026-11-11T00:00:00Z', ?)",
|
||||
(lid, 'b1fix%d' % lid, 'B1 test %s' % FIX[lid][1],
|
||||
'https://www.kijiji.ca/v-motorcycles/b1/%d' % lid,
|
||||
img, json.dumps(imgs) if imgs else None, score, 'B1 fixture'))
|
||||
conn.execute(
|
||||
"INSERT OR REPLACE INTO swipes (listing_id, action, created_at,"
|
||||
" last_photo_idx) VALUES (705, 'like', '2026-11-08T00:00:00Z', 0)")
|
||||
# Close live-copied sections: the first /api/section read then composes
|
||||
# a fresh 25 on the walk DB (deterministic fixture ordering).
|
||||
conn.execute(
|
||||
"UPDATE sections SET status='closed' WHERE status != 'closed'")
|
||||
# A round-1 event per fixture keeps synthetics out of the wildcard
|
||||
# pool (wildcards must be unseen); new-pool eligibility is unaffected.
|
||||
# 705's event matches its stored verdict (round 1, like).
|
||||
for lid in FIX:
|
||||
conn.execute(
|
||||
"INSERT INTO swipe_events (listing_id, action, round,"
|
||||
" section_id) VALUES (?, ?, 1, NULL)",
|
||||
(lid, 'like' if lid == 705 else 'maybe'))
|
||||
conn.commit()
|
||||
n = conn.execute('SELECT COUNT(*) AS n FROM listings').fetchone()['n']
|
||||
conn.close()
|
||||
print('setup: walk DB at %s (%s listings; 701-706 synthetic, 705 = liked'
|
||||
' return w/ last_photo_idx=0)' % (WALK_DB, n))
|
||||
|
||||
|
||||
def need_server():
|
||||
try:
|
||||
with urllib.request.urlopen(BASE_URL + '/api/health',
|
||||
timeout=3) as r:
|
||||
return r.status == 200
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
# --- walk helpers (module-level `page` assigned inside walk) ----------------
|
||||
|
||||
def wait(selector, timeout=8000):
|
||||
page.wait_for_selector(selector, timeout=timeout)
|
||||
|
||||
|
||||
def card_box():
|
||||
b = page.evaluate("""() => { const el=document.querySelector('.topcard');
|
||||
if(!el) return null; const r=el.getBoundingClientRect();
|
||||
return {x:r.x,y:r.y,w:r.width,h:r.height}; }""")
|
||||
assert b, 'no .topcard in DOM'
|
||||
return b
|
||||
|
||||
|
||||
def top_state():
|
||||
return page.evaluate("""() => {
|
||||
const t=document.querySelector('.topcard');
|
||||
const r={topcards:document.querySelectorAll('.topcard').length,
|
||||
hasSegs:!!t.classList.contains('hasSegs'), segs:0, segOn:-1,
|
||||
photo:null, nophoto:false, band:null,
|
||||
stampLike:0, stampNope:0, stampMaybe:0};
|
||||
const s=t.querySelector('.segments');
|
||||
if(s){ r.segs=s.children.length;
|
||||
[...s.children].forEach((x,k)=>{ if(x.classList.contains('on'))
|
||||
r.segOn=k; }); }
|
||||
const p=t.querySelector('.phwrap img.photo');
|
||||
if(p) r.photo=p.getAttribute('src');
|
||||
else if(t.querySelector('.nophoto')) r.nophoto=true;
|
||||
const b=t.querySelector('.band'); if(b) r.band=b.textContent;
|
||||
const sl=t.querySelector('.stamp.like');
|
||||
if(sl) r.stampLike=sl.style.opacity;
|
||||
const sn=t.querySelector('.stamp.nope');
|
||||
if(sn) r.stampNope=sn.style.opacity;
|
||||
const sm=t.querySelector('.stamp.maybe');
|
||||
if(sm) r.stampMaybe=sm.style.opacity;
|
||||
return r; }""")
|
||||
|
||||
|
||||
def tap_third(which):
|
||||
b = card_box()
|
||||
y = b['y'] + b['h'] * 0.72
|
||||
x = b['x'] + b['w'] * (0.16 if which == 'left'
|
||||
else (0.84 if which == 'right' else 0.5))
|
||||
page.mouse.click(x, y)
|
||||
time.sleep(0.08)
|
||||
|
||||
|
||||
def assert_item(cond, msg):
|
||||
if not cond:
|
||||
print('FAIL ' + msg)
|
||||
sys.exit(1)
|
||||
print('ok ' + msg)
|
||||
|
||||
|
||||
def lead_of(item):
|
||||
n = item.get('n_photos') or 0
|
||||
li = item.get('last_photo_idx')
|
||||
if not n or n < 2 or li is None:
|
||||
return 0
|
||||
return (li + 1) % n
|
||||
|
||||
|
||||
def photo_url(item, i):
|
||||
if not item.get('img'):
|
||||
return None
|
||||
return item['img'] if i == 0 else '/img/%s?i=%s' % (item['id'], i)
|
||||
|
||||
|
||||
def viewer_on():
|
||||
return page.evaluate(
|
||||
"() => document.getElementById('viewer').classList.contains('on')")
|
||||
|
||||
|
||||
def vimg_src():
|
||||
return page.evaluate(
|
||||
"() => document.getElementById('vimg').getAttribute('src')")
|
||||
|
||||
|
||||
def vimg_transform():
|
||||
return page.evaluate(
|
||||
"() => document.getElementById('vimg').style.transform")
|
||||
|
||||
|
||||
# --- the walk ---------------------------------------------------------------
|
||||
|
||||
def walk():
|
||||
from playwright.sync_api import sync_playwright
|
||||
with sync_playwright() as pw:
|
||||
exe = os.path.expanduser(
|
||||
'~/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome')
|
||||
if not os.path.exists(exe):
|
||||
exe = None
|
||||
browser = pw.chromium.launch(headless=True, executable_path=exe,
|
||||
args=['--no-sandbox'])
|
||||
ctx = browser.new_context(viewport={'width': 390, 'height': 844},
|
||||
has_touch=True, is_mobile=True)
|
||||
global page
|
||||
page = ctx.new_page()
|
||||
page.goto(BASE_URL + '/', wait_until='networkidle')
|
||||
wait('.topcard')
|
||||
time.sleep(0.6)
|
||||
|
||||
section = None
|
||||
for _ in range(40):
|
||||
body = page.evaluate(
|
||||
"() => fetch('/api/section').then(r=>r.json())")
|
||||
if body and body.get('items'):
|
||||
section = body
|
||||
break
|
||||
time.sleep(0.5)
|
||||
assert section, 'no section payload'
|
||||
items = list(section['items'])
|
||||
print('section: %d items — recipe %s' % (len(items), json.dumps(
|
||||
section['section']['recipe'], sort_keys=True)))
|
||||
by_id = {i['id']: i for i in items}
|
||||
for lid in (701, 702, 703, 704, 706):
|
||||
assert lid in by_id, 'fixture %s missing from section' % lid
|
||||
assert by_id[lid]['slot'] == 'new', (lid, by_id[lid]['slot'])
|
||||
assert by_id[705]['slot'] == 'return', by_id[705]['slot']
|
||||
|
||||
seen = []
|
||||
round_no = 0
|
||||
while True:
|
||||
remaining = [i['id'] for i in items if i['id'] not in seen]
|
||||
if not remaining:
|
||||
break
|
||||
t = top_state()
|
||||
top_id = None
|
||||
m = re.search(r'/img/(\d+)(?:\?i=\d+)?$', t['photo'] or '')
|
||||
if m:
|
||||
top_id = int(m.group(1))
|
||||
else:
|
||||
for i in items: # zero-photo card: no src to match
|
||||
if i['id'] not in seen and not i.get('img'):
|
||||
top_id = i['id']
|
||||
break
|
||||
assert top_id in by_id, 'cannot identify top card'
|
||||
item = by_id[top_id]
|
||||
seen.append(top_id)
|
||||
round_no += 1
|
||||
n = item.get('n_photos') or 0
|
||||
exp_lead = lead_of(item)
|
||||
exp_src = photo_url(item, exp_lead)
|
||||
print('-- top id=%s [%s] n=%d lead=%d slot=%s --'
|
||||
% (top_id, item['title'][:26], n, exp_lead, item['slot']))
|
||||
assert_item(t['topcards'] == 1,
|
||||
'exactly one .topcard before gestures')
|
||||
if n >= 2:
|
||||
assert_item(t['hasSegs'] and t['segs'] == n,
|
||||
'segments count == n (%d)' % n)
|
||||
assert_item(t['segOn'] == exp_lead,
|
||||
'segment idx == rotation lead (%d)' % exp_lead)
|
||||
assert_item(t['photo'] == exp_src,
|
||||
'photo src == expected lead url')
|
||||
else:
|
||||
assert_item(not t['hasSegs'] and t['segs'] == 0,
|
||||
'no segments for n=%d' % n)
|
||||
if n == 1:
|
||||
assert_item(t['photo'] == photo_url(item, 0),
|
||||
'single photo shows the primary')
|
||||
else:
|
||||
assert_item(t['nophoto'],
|
||||
'zero-photo card shows the placeholder')
|
||||
if item['slot'] == 'return' and item['id'] == 705:
|
||||
assert_item(exp_lead == 1, 'rotation lead: (0+1)%%8 = 1')
|
||||
assert_item(t['band'] and 'SECOND LOOK' in t['band'],
|
||||
'return card carries the SECOND LOOK band '
|
||||
'(with segments)')
|
||||
|
||||
if n >= 2:
|
||||
# --- flip: advance + clamp both ends (no wrap) ----------
|
||||
for i in range(n + 2):
|
||||
tap_third('right')
|
||||
st = top_state()
|
||||
assert_item(st['topcards'] == 1,
|
||||
'tap kept the one-.topcard invariant')
|
||||
want = min(exp_lead + i + 1, n - 1)
|
||||
assert_item(st['segOn'] == want,
|
||||
'right-tap %d -> idx %d (clamp)' % (i + 1,
|
||||
want))
|
||||
for i in range(n + 2):
|
||||
tap_third('left')
|
||||
st = top_state()
|
||||
assert_item(st['topcards'] == 1,
|
||||
'tap kept the one-.topcard invariant')
|
||||
want = max(n - 1 - (i + 1), 0)
|
||||
assert_item(st['segOn'] == want,
|
||||
'left-tap %d -> idx %d (clamp)' % (i + 1,
|
||||
want))
|
||||
st = top_state()
|
||||
assert_item(st['topcards'] == 1
|
||||
and st['stampLike'] in ('0', '')
|
||||
and st['stampNope'] in ('0', '')
|
||||
and st['stampMaybe'] in ('0', ''),
|
||||
'taps never commit: no stamps, no flight')
|
||||
# --- viewer: open on current photo, nav + clamp, zoom,
|
||||
# pull-close restores the same card+photo ------------
|
||||
want_idx = 1
|
||||
while st['segOn'] > want_idx:
|
||||
tap_third('left')
|
||||
st = top_state()
|
||||
if st['segOn'] < want_idx:
|
||||
tap_third('right')
|
||||
st = top_state()
|
||||
before_src = st['photo']
|
||||
tap_third('center')
|
||||
assert_item(viewer_on(), 'center tap opens the viewer')
|
||||
vsegs = page.evaluate(
|
||||
"() => document.getElementById('vsegs')"
|
||||
".querySelectorAll('i').length")
|
||||
assert_item(vsegs == n, 'viewer segments == n (%d)' % n)
|
||||
assert_item(vimg_src() == before_src,
|
||||
'viewer opens on the current photo')
|
||||
vp = page.locator('#vphoto')
|
||||
vb = vp.bounding_box()
|
||||
al, ar = (vb['x'] + vb['width'] * 0.75,
|
||||
vb['x'] + vb['width'] * 0.15)
|
||||
ay = vb['y'] + vb['height'] * 0.5
|
||||
page.mouse.move(al, ay)
|
||||
page.mouse.down()
|
||||
page.mouse.move(ar, ay, steps=6)
|
||||
page.mouse.up()
|
||||
time.sleep(0.1)
|
||||
land = min(want_idx + 1, n - 1)
|
||||
assert_item(vimg_src() == photo_url(item, land),
|
||||
'viewer swipe-left advances + clamps')
|
||||
page.mouse.move(ar, ay)
|
||||
page.mouse.down()
|
||||
page.mouse.move(al, ay, steps=6)
|
||||
page.mouse.up()
|
||||
time.sleep(0.1)
|
||||
back = max(land - 1, 0)
|
||||
assert_item(vimg_src() == photo_url(item, back),
|
||||
'viewer swipe-right steps back (clamped)')
|
||||
page.mouse.dblclick(vb['x'] + vb['width'] * 0.5,
|
||||
vb['y'] + vb['height'] * 0.5)
|
||||
time.sleep(0.1)
|
||||
assert_item('scale(2.5)' in vimg_transform(),
|
||||
'double-tap zooms to 2.5x')
|
||||
page.mouse.dblclick(vb['x'] + vb['width'] * 0.5,
|
||||
vb['y'] + vb['height'] * 0.5)
|
||||
time.sleep(0.1)
|
||||
assert_item('scale(2.5)' not in vimg_transform(),
|
||||
'double-tap again returns to 1x')
|
||||
# pinch via synthetic pointer events (real handler path)
|
||||
page.evaluate("""() => {
|
||||
const v=document.getElementById('vphoto');
|
||||
const r=v.getBoundingClientRect();
|
||||
const mk=(t,id,x,y)=>{ v.dispatchEvent(new PointerEvent(t,
|
||||
{pointerId:id, clientX:x, clientY:y, bubbles:true})); };
|
||||
const x=r.width/2, y=r.height/2;
|
||||
mk('pointerdown',10,x-25,y); mk('pointerdown',11,x+25,y);
|
||||
for(let s=0;s<6;s++){ mk('pointermove',10,x-25-s*22,y);
|
||||
mk('pointermove',11,x+25+s*22,y); }
|
||||
mk('pointerup',10,x-25-6*22,y);
|
||||
mk('pointerup',11,x+25+6*22,y);
|
||||
}""")
|
||||
assert_item('scale(4)' in vimg_transform(),
|
||||
'pinch-zoom clamps at 4x')
|
||||
page.mouse.dblclick(vb['x'] + vb['width'] * 0.5,
|
||||
vb['y'] + vb['height'] * 0.5)
|
||||
time.sleep(0.1) # back to 1x for the pull gesture
|
||||
page.mouse.move(vb['x'] + vb['width'] * 0.5,
|
||||
vb['y'] + vb['height'] * 0.35)
|
||||
page.mouse.down()
|
||||
page.mouse.move(vb['x'] + vb['width'] * 0.5,
|
||||
vb['y'] + vb['height'] * 0.35 + 170, steps=8)
|
||||
page.mouse.up()
|
||||
time.sleep(0.2)
|
||||
assert_item(not viewer_on(),
|
||||
'pull-down (>110px) closes the viewer')
|
||||
st = top_state()
|
||||
assert_item(st['segOn'] == want_idx
|
||||
and st['photo'] == before_src,
|
||||
'close returns the same card + photo position')
|
||||
else:
|
||||
if n == 1:
|
||||
tap_third('center')
|
||||
assert_item(viewer_on(),
|
||||
'center tap opens the viewer (single photo)')
|
||||
page.locator('#vclose').click()
|
||||
time.sleep(0.15)
|
||||
if n == 0:
|
||||
tap_third('center')
|
||||
assert_item(not viewer_on(), 'zero-photo: no viewer')
|
||||
|
||||
# --- ⓘ beats the zones --------------------------------------
|
||||
page.locator('.topcard .ibtn').click()
|
||||
time.sleep(0.15)
|
||||
assert_item(page.evaluate(
|
||||
"() => document.getElementById('detail')"
|
||||
".classList.contains('on')"),
|
||||
'ⓘ opens the dossier (zones do not fire)')
|
||||
pre = top_state()
|
||||
page.locator('#dclose').click()
|
||||
time.sleep(0.2)
|
||||
post = top_state()
|
||||
assert_item(pre['photo'] == post['photo']
|
||||
and pre['segOn'] == post['segOn'],
|
||||
'dossier close leaves the photo position intact')
|
||||
if n >= 1:
|
||||
# dossier hero -> viewer at photo 0 (dossier stays open)
|
||||
page.locator('.topcard .ibtn').click()
|
||||
time.sleep(0.15)
|
||||
hb = page.locator('.dhero').bounding_box()
|
||||
page.mouse.click(hb['x'] + hb['width'] / 2,
|
||||
hb['y'] + hb['height'] / 2)
|
||||
time.sleep(0.15)
|
||||
assert_item(viewer_on() and page.evaluate(
|
||||
"() => document.getElementById('detail')"
|
||||
".classList.contains('on')"),
|
||||
'dossier hero tap opens the viewer over the dossier')
|
||||
assert_item(vimg_src() == photo_url(item, 0),
|
||||
'dossier viewer starts at photo 0')
|
||||
page.locator('#vclose').click()
|
||||
time.sleep(0.15)
|
||||
assert_item(not viewer_on() and page.evaluate(
|
||||
"() => document.getElementById('detail')"
|
||||
".classList.contains('on')"),
|
||||
'viewer ✕ returns to the still-open dossier')
|
||||
page.locator('#dclose').click()
|
||||
time.sleep(0.15)
|
||||
|
||||
# single commit per round (fast chain runs after the report)
|
||||
page.locator('#btnNope').click()
|
||||
time.sleep(0.07)
|
||||
|
||||
# --- P3 regression: report -> undo x3 -> fast chain -> forge -----
|
||||
wait('#report.on', 15000)
|
||||
print('report visible: %s' % page.locator('#repCounts').inner_text())
|
||||
assert_item('Section complete' in page.locator('#report').inner_text(),
|
||||
'report screen after the full section')
|
||||
for _ in range(4):
|
||||
page.locator('#btnUndo').click()
|
||||
time.sleep(0.08)
|
||||
assert_item(page.evaluate(
|
||||
"() => document.querySelectorAll('.topcard').length") == 1,
|
||||
'undo x4 from the report re-opens the deck (one .topcard)')
|
||||
for k in range(3):
|
||||
b = card_box()
|
||||
y = b['y'] + b['h'] * 0.6
|
||||
page.mouse.move(b['x'] + b['w'] * 0.5, y)
|
||||
page.mouse.down()
|
||||
page.mouse.move(b['x'] + b['w'] * 0.5 + 320, y, steps=5)
|
||||
page.mouse.up()
|
||||
if k < 2:
|
||||
time.sleep(0.07)
|
||||
tc = page.evaluate(
|
||||
"() => document.querySelectorAll('.topcard').length")
|
||||
assert tc == 1, 'fast chain: topcard=%s (must be 1)' % tc
|
||||
assert_item(True, '3 like-commits @70ms: one .topcard, no lockout')
|
||||
page.locator('#btnNope').click() # finish the 4th restored card
|
||||
time.sleep(0.1)
|
||||
wait('#report.on', 15000)
|
||||
page.locator('#btnForge').click()
|
||||
wait('.topcard', 15000)
|
||||
time.sleep(0.4)
|
||||
sect = page.evaluate(
|
||||
"() => document.getElementById('sect').textContent.trim()")
|
||||
assert_item(re.match(r'^\d+/25$', sect) is not None,
|
||||
'forge hydrates a fresh section (progress=%s)' % sect)
|
||||
# --- List + Trends tabs render with P3 elements intact ----------
|
||||
page.locator('.tab[data-tab="list"]').click()
|
||||
wait('.row')
|
||||
tanks = page.locator('.row .tank').count()
|
||||
rows = page.locator('.row').count()
|
||||
assert_item(tanks > 0 and rows > 0,
|
||||
'list: %d rows, %d tank gauges (P3 intact)'
|
||||
% (rows, tanks))
|
||||
page.locator('.tab[data-tab="trends"]').click()
|
||||
wait('#tLead')
|
||||
assert_item((page.locator('#tLead').text_content() or '').strip()
|
||||
!= '', 'trends tab renders')
|
||||
print('WALK COMPLETE — all B1 FE checks green')
|
||||
browser.close()
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
if 'setup' in sys.argv or not os.path.exists(WALK_DB):
|
||||
if not os.path.exists(PRISTINE):
|
||||
print('pristine copy DB missing: %s' % PRISTINE)
|
||||
return 1
|
||||
setup_db()
|
||||
stage_img_files()
|
||||
print('fixtures staged in %s' % IMG_DIR)
|
||||
if not need_server():
|
||||
print('NO SERVER on %s — start it (see module docstring).' % BASE_URL)
|
||||
return 1
|
||||
walk()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
876
app/fe_walk_v11.py
Normal file
876
app/fe_walk_v11.py
Normal file
@@ -0,0 +1,876 @@
|
||||
"""v1.1 FE walk — headless-chromium proof of every v1.1 item on the real page.
|
||||
|
||||
Self-contained: stages its own temp DBs (never the live file), boots the
|
||||
scratch server on 127.0.0.1:9455 (never 9453), runs the walks, kills the
|
||||
server. Mock forge only (OPENROUTER_API_KEY is not consulted — the server
|
||||
is started with the key unset).
|
||||
|
||||
cd /var/home/admin/dev/bike-tinder-v11/build
|
||||
.venv/bin/python -m app.fe_walk_v11 setup # (auto-runs at walk start)
|
||||
.venv/bin/python -m app.fe_walk_v11 # full walk
|
||||
|
||||
Phases:
|
||||
WALK1 (rich: pristine catalog + synthetic multi-photo fixtures 701-706,
|
||||
705 a liked return) — items 1, 2, 3, 4, 7, 10, B1 §11 regressions
|
||||
(flip clamps / one .topcard / no-lock swipe storm), full P3 loop
|
||||
(compose -> strike all -> report -> forge), item 6 non-dry.
|
||||
WALK2 (returns-only: every active pre-swiped maybe) — item 5 counter
|
||||
(0/N -> 1/N -> undo -> sweep -> 25/25 hot -> report counts),
|
||||
item 6 dry caption + dry forge status.
|
||||
WALK3 (0/0/0: returns one-shot-burned) — item 8 loud empty2, nightly-
|
||||
import recovery (a fresh listing re-lights the deck).
|
||||
"""
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import sqlite3
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import urllib.request
|
||||
|
||||
ARENA = '/var/home/admin/dev/bike-tinder-v11'
|
||||
REPO = os.path.join(ARENA, 'build')
|
||||
PRISTINE = os.path.join(ARENA, 'scratch-v11-pristine.sqlite3')
|
||||
WALK1 = os.path.join(ARENA, 'scratch-v11-walk1.sqlite3')
|
||||
WALK2 = os.path.join(ARENA, 'scratch-v11-walk2.sqlite3')
|
||||
WALK3 = os.path.join(ARENA, 'scratch-v11-walk3.sqlite3')
|
||||
IMG = os.path.join(ARENA, 'img-v11')
|
||||
MEDIA = os.path.join(ARENA, 'media-sample-v11')
|
||||
SHOTS = os.path.join(ARENA, 'shots-v11')
|
||||
BASE_URL = 'http://127.0.0.1:9455'
|
||||
PORT = 9455
|
||||
|
||||
CDN = ('https://media.kijiji.ca/api/v1/ca-prod-dealer-ads/images/x/%s'
|
||||
'?rule=kijijica-640-webp')
|
||||
|
||||
FIX = {
|
||||
701: (8, 'gallery-8'),
|
||||
702: (3, 'gallery-3'),
|
||||
703: (2, 'gallery-2'),
|
||||
704: (1, 'single-photo'),
|
||||
705: (8, 'return-rotation'),
|
||||
706: (0, 'zero-photo'),
|
||||
}
|
||||
SCORE_BASE = 2000
|
||||
|
||||
server_proc = None
|
||||
page = None
|
||||
|
||||
|
||||
# --- staging ---------------------------------------------------------------
|
||||
|
||||
def stage_img_files():
|
||||
os.makedirs(IMG, exist_ok=True)
|
||||
names = sorted(m for m in os.listdir(MEDIA) if m.endswith('.webp'))
|
||||
assert len(names) == 12, names
|
||||
k = 0
|
||||
for lid in sorted(FIX):
|
||||
n = FIX[lid][0]
|
||||
if n == 0:
|
||||
continue
|
||||
if n == 1:
|
||||
shutil.copy2(os.path.join(MEDIA, names[k % len(names)]),
|
||||
os.path.join(IMG, '%d.webp' % lid))
|
||||
k += 1
|
||||
continue
|
||||
for i in range(n):
|
||||
shutil.copy2(os.path.join(MEDIA, names[k % len(names)]),
|
||||
os.path.join(IMG, '%d_%d.webp' % (lid, i)))
|
||||
k += 1
|
||||
|
||||
|
||||
def seeds():
|
||||
"""Fixture rows + return candidates on a temp copy; returns the maybe-pair."""
|
||||
from app import db as dbmod
|
||||
conn = sqlite3.connect(WALK1)
|
||||
conn.row_factory = sqlite3.Row
|
||||
try:
|
||||
dbmod.init_db(conn) # guarded B1/P3 migrations
|
||||
for lid in sorted(FIX):
|
||||
n = FIX[lid][0]
|
||||
imgs = [CDN % ('x%d-%d' % (lid, i)) for i in range(n)]
|
||||
img = imgs[0] if imgs else None
|
||||
score = SCORE_BASE + (750 - lid)
|
||||
conn.execute("DELETE FROM listings WHERE id=?", (lid,))
|
||||
conn.execute(
|
||||
"INSERT INTO listings (id, region, src_id, title, url, status,"
|
||||
" img_url, imgs, score, first_seen, desc) VALUES"
|
||||
" (?, 'ns', ?, ?, ?, 'active', ?, ?, ?,"
|
||||
" '2026-11-11T00:00:00Z', ?)",
|
||||
(lid, 'v11fix%d' % lid, 'V1.1 test %s' % FIX[lid][1],
|
||||
'https://www.kijiji.ca/v-motorcycles/v11/%d' % lid,
|
||||
img, json.dumps(imgs) if imgs else None, score,
|
||||
'V1.1 fixture'))
|
||||
conn.execute(
|
||||
"INSERT OR REPLACE INTO swipes (listing_id, action, created_at,"
|
||||
" last_photo_idx) VALUES (705, 'like', '2026-11-08T00:00:00Z', 0)")
|
||||
# fresh fixtures: round-1 events keep them OUT of the wildcard pool
|
||||
for lid in FIX:
|
||||
conn.execute(
|
||||
"INSERT INTO swipe_events (listing_id, action, round,"
|
||||
" section_id) VALUES (?, ?, 1, NULL)",
|
||||
(lid, 'like' if lid == 705 else 'maybe'))
|
||||
# second reserved maybe-return: the highest-scored existing swiped
|
||||
# active swings to maybe so 705 keeps its reserved return slot
|
||||
x = conn.execute(
|
||||
"SELECT s.listing_id FROM swipes s"
|
||||
" JOIN listings l ON l.id = s.listing_id"
|
||||
" WHERE l.status='active' ORDER BY l.score DESC LIMIT 1"
|
||||
).fetchone()['listing_id']
|
||||
conn.execute("UPDATE swipes SET action='maybe' WHERE listing_id=?", (x,))
|
||||
conn.execute(
|
||||
"UPDATE swipe_events SET action='maybe' WHERE listing_id=?"
|
||||
" AND round=1", (x,))
|
||||
conn.execute("UPDATE sections SET status='closed'"
|
||||
" WHERE status!='closed'")
|
||||
conn.commit()
|
||||
return x
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
def setup():
|
||||
assert os.path.exists(PRISTINE), 'pristine copy missing'
|
||||
os.makedirs(SHOTS, exist_ok=True)
|
||||
stage_img_files()
|
||||
shutil.copy2(PRISTINE, WALK1)
|
||||
seeds()
|
||||
shutil.copy2(PRISTINE, WALK2)
|
||||
conn = sqlite3.connect(WALK2)
|
||||
try:
|
||||
conn.execute('DELETE FROM section_items')
|
||||
conn.execute("UPDATE sections SET status='closed'"
|
||||
" WHERE status!='closed'")
|
||||
conn.execute(
|
||||
"""INSERT INTO swipes (listing_id, action, created_at)
|
||||
SELECT id, 'maybe', '2026-11-01T00:00:00Z' FROM listings
|
||||
WHERE status='active'
|
||||
AND id NOT IN (SELECT listing_id FROM swipes)""")
|
||||
conn.execute(
|
||||
"""INSERT INTO swipe_events (listing_id, action, round, section_id)
|
||||
SELECT id, 'maybe', 1, NULL FROM listings
|
||||
WHERE status='active'
|
||||
AND id NOT IN (SELECT listing_id FROM swipe_events)""")
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
print('setup: walk DBs staged (%s, %s)' % (WALK1, WALK2))
|
||||
|
||||
|
||||
# --- server ----------------------------------------------------------------
|
||||
|
||||
def start_server(db_path):
|
||||
global server_proc
|
||||
env = dict(os.environ)
|
||||
env.pop('OPENROUTER_API_KEY', None) # mock forge pass only
|
||||
server_proc = subprocess.Popen(
|
||||
[os.path.join(REPO, '.venv/bin/python'), '-m', 'app.serve',
|
||||
'--db', db_path, '--img-dir', IMG, '--host', '127.0.0.1',
|
||||
'--port', str(PORT), '--state-dir',
|
||||
os.path.join(ARENA, 'state-v11')],
|
||||
cwd=REPO, env=env,
|
||||
stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
|
||||
for _ in range(60):
|
||||
try:
|
||||
with urllib.request.urlopen(BASE_URL + '/api/health',
|
||||
timeout=2) as r:
|
||||
if r.status == 200:
|
||||
return
|
||||
except Exception:
|
||||
pass
|
||||
time.sleep(0.25)
|
||||
raise RuntimeError('scratch server did not come up')
|
||||
|
||||
|
||||
def stop_server():
|
||||
global server_proc
|
||||
if server_proc:
|
||||
server_proc.terminate()
|
||||
try:
|
||||
server_proc.wait(timeout=5)
|
||||
except subprocess.TimeoutExpired:
|
||||
server_proc.kill()
|
||||
server_proc = None
|
||||
|
||||
|
||||
# --- walk helpers ----------------------------------------------------------
|
||||
|
||||
CHECKS = [0, 0]
|
||||
|
||||
|
||||
def wait(selector, timeout=10000):
|
||||
page.wait_for_selector(selector, timeout=timeout)
|
||||
|
||||
|
||||
def ok(msg):
|
||||
CHECKS[0] += 1
|
||||
print('ok ' + msg)
|
||||
|
||||
|
||||
def bad(msg):
|
||||
CHECKS[1] += 1
|
||||
print('FAIL ' + msg)
|
||||
page.screenshot(path=os.path.join(SHOTS, 'fail-%s.png' % int(time.time())))
|
||||
raise SystemExit(1)
|
||||
|
||||
|
||||
def check(cond, msg):
|
||||
if cond:
|
||||
ok(msg)
|
||||
else:
|
||||
bad(msg)
|
||||
|
||||
|
||||
def top_state():
|
||||
return page.evaluate("""() => {
|
||||
const t=document.querySelector('.topcard');
|
||||
const r={topcards:document.querySelectorAll('.topcard').length,
|
||||
photo:null, segOn:-1, segs:0, band:null, bandClass:null};
|
||||
if(!t) return r;
|
||||
const s=t.querySelector('.segments');
|
||||
if(s){ r.segs=s.children.length;
|
||||
[...s.children].forEach((x,k)=>{ if(x.classList.contains('on'))
|
||||
r.segOn=k; }); }
|
||||
const p=t.querySelector('.phwrap img.photo');
|
||||
if(p) r.photo=p.getAttribute('src');
|
||||
const b=t.querySelector('.band');
|
||||
if(b){ r.band=b.textContent; r.bandClass=b.className; }
|
||||
return r; }""")
|
||||
|
||||
|
||||
def top_id():
|
||||
t = top_state()
|
||||
if not t['photo']:
|
||||
return None
|
||||
m = re.search(r'/img/(\d+)(?:\?i=\d+)?$', t['photo'] or '')
|
||||
return int(m.group(1)) if m else None
|
||||
|
||||
|
||||
def sect_pill():
|
||||
return page.evaluate("() => ({txt:document.getElementById('sect').textContent,"
|
||||
" hot:document.getElementById('sect').classList.contains('hot')})")
|
||||
|
||||
|
||||
def pile_len():
|
||||
return page.evaluate("() => document.querySelectorAll('.topcard').length +"
|
||||
" + [...document.querySelectorAll('#stage .card')].filter("
|
||||
" e=>!e.classList.contains('topcard')).length")
|
||||
|
||||
|
||||
def key(k):
|
||||
page.keyboard.press(k)
|
||||
time.sleep(0.08)
|
||||
|
||||
|
||||
def api(path):
|
||||
with urllib.request.urlopen(BASE_URL + path, timeout=10) as r:
|
||||
return json.loads(r.read())
|
||||
|
||||
|
||||
def api_post(path, body):
|
||||
req = urllib.request.Request(BASE_URL + path,
|
||||
data=json.dumps(body).encode(),
|
||||
headers={'Content-Type': 'application/json'})
|
||||
with urllib.request.urlopen(req, timeout=30) as r:
|
||||
return json.loads(r.read())
|
||||
|
||||
|
||||
def section_body():
|
||||
return api('/api/section')
|
||||
|
||||
|
||||
def flick(ms=350):
|
||||
time.sleep(ms / 1000.0)
|
||||
|
||||
|
||||
def tap_center():
|
||||
b = page.evaluate("""() => { const el=document.querySelector('.topcard');
|
||||
const r=el.getBoundingClientRect();
|
||||
return {x:r.x+r.width/2,y:r.y+r.height*0.72}; }""")
|
||||
page.mouse.click(b['x'], b['y'])
|
||||
time.sleep(0.08)
|
||||
|
||||
|
||||
def tap_side(side):
|
||||
b = page.evaluate("""() => { const el=document.querySelector('.topcard');
|
||||
const r=el.getBoundingClientRect();
|
||||
return {x:r.x, w:r.width, y:r.y+r.height*0.72}; }""")
|
||||
x = b['x'] + (0.16 if side == 'left' else 0.84) * b['w']
|
||||
page.mouse.click(x, b['y'])
|
||||
time.sleep(0.08)
|
||||
|
||||
|
||||
def taps(clicks, gap=40):
|
||||
# real commit storm through the like button: the no-lock law must
|
||||
# survive button-speed swipes
|
||||
for _ in range(clicks):
|
||||
page.evaluate("() => document.getElementById('btnLike').click()")
|
||||
time.sleep(gap / 1000.0)
|
||||
|
||||
|
||||
def dossier_on():
|
||||
return page.evaluate(
|
||||
"() => document.getElementById('detail').classList.contains('on')")
|
||||
|
||||
|
||||
def viewer_on():
|
||||
return page.evaluate(
|
||||
"() => document.getElementById('viewer').classList.contains('on')")
|
||||
|
||||
|
||||
def dhero_click():
|
||||
b = page.evaluate("""() => { const el=document.getElementById('dhero')||
|
||||
document.querySelector('.dhero');
|
||||
const r=el.getBoundingClientRect();
|
||||
return {x:r.x+r.width/2,y:r.y+r.height/2}; }""")
|
||||
page.mouse.click(b['x'], b['y'])
|
||||
time.sleep(0.15)
|
||||
|
||||
|
||||
# --- WALK1: rich deck ------------------------------------------------------
|
||||
|
||||
def walk_rich():
|
||||
check(page.url.startswith(BASE_URL), 'page served from the app root')
|
||||
wait('.topcard')
|
||||
flick(800)
|
||||
body = section_body()
|
||||
check(len(body['items']) == 25, 'rich compose serves 25 items')
|
||||
check(body['recipe']['new'] == 21 and body['recipe']['return'] == 2
|
||||
and body['recipe']['wildcard'] == 2,
|
||||
'recipe 21/2/2 on the rich pool (the sign-off shape)')
|
||||
by_id = {i['id']: i for i in body['items']}
|
||||
for lid in (701, 702, 703, 704, 706):
|
||||
check(lid in by_id and by_id[lid]['slot'] == 'new',
|
||||
'fixture %s sits in the fresh slots' % lid)
|
||||
check(by_id[705]['slot'] == 'return', '705 composes into a return slot')
|
||||
|
||||
t = top_state()
|
||||
check(t['topcards'] == 1, 'exactly one .topcard on load')
|
||||
check(top_id() == 701, 'top card is the highest-scored fixture (701)')
|
||||
|
||||
# item 3: computed styles on the top card (fit + backdrop)
|
||||
css = page.evaluate("""() => { const c=document.querySelector('.topcard');
|
||||
const p=c.querySelector('.phwrap img.photo');
|
||||
const b=c.querySelector('.phwrap .phblur');
|
||||
return {fit:getComputedStyle(p).objectFit,
|
||||
blur:!!b, bg:b?b.style.backgroundImage:null,
|
||||
src:p.getAttribute('src')}; }""")
|
||||
check(css['fit'] == 'contain', 'item 3: card photo object-fit == contain')
|
||||
check(bool(css['blur']) and css['src'] in (css['bg'] or ''),
|
||||
'item 3: card backdrop exists and mirrors the photo URL')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'item3-card-fit.png'))
|
||||
|
||||
# --- item 5+1: strikes through the real key map ------------------------
|
||||
check(sect_pill()['txt'] == '0/25', 'fresh rich section starts 0/25')
|
||||
key('ArrowUp')
|
||||
check(sect_pill()['txt'] == '1/25', 'ArrowUp (maybe) -> 1/25')
|
||||
key('ArrowDown')
|
||||
check(sect_pill()['txt'] == '0/25', 'ArrowDown (undo) -> 0/25')
|
||||
key('ArrowUp')
|
||||
check(sect_pill()['txt'] == '1/25', 're-decide -> 1/25')
|
||||
key('Backspace')
|
||||
check(sect_pill()['txt'] == '0/25', 'Backspace is the undo alias')
|
||||
pill_before = sect_pill()['txt']
|
||||
# scroll prevention spy
|
||||
page.evaluate("""() => { window.__prev=[]; document.addEventListener(
|
||||
'keydown',e=>window.__prev.push([e.key,e.defaultPrevented])); }""")
|
||||
key('ArrowLeft')
|
||||
key('ArrowRight')
|
||||
prevented = page.evaluate("""() => window.__prev.filter(
|
||||
p=>p[0].startsWith('Arrow')).map(p=>p[1])""")
|
||||
check(all(prevented), 'item 1: arrows defaultPrevented (no page scroll)')
|
||||
pn = sect_pill()['txt']
|
||||
check(int(pn.split('/')[0]) == int(pill_before.split('/')[0]) + 2,
|
||||
'ArrowLeft/ArrowRight commit through the normal path (%s -> %s)'
|
||||
% (pill_before, pn))
|
||||
|
||||
# --- item 1: text-input guard (list search) ---------------------------
|
||||
page.evaluate("() => document.querySelector('.tab[data-tab=list]').click()")
|
||||
wait('#lsearch')
|
||||
page.evaluate("""() => { const s=document.getElementById('lsearch');
|
||||
s.focus(); }""")
|
||||
page.keyboard.type('abc')
|
||||
before_search = page.evaluate(
|
||||
"() => document.getElementById('lsearch').value")
|
||||
check(before_search == 'abc', 'search input accepts typing (focus guard on)')
|
||||
for kk in ('ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown'):
|
||||
page.keyboard.press(kk)
|
||||
flick(60)
|
||||
check(page.evaluate(
|
||||
"() => document.getElementById('lsearch').value") == 'abc',
|
||||
'arrows inside the search input never swipe (text + value unchanged)')
|
||||
check(sect_pill()['txt'] == pn,
|
||||
'input-focused arrows leave the section counter untouched')
|
||||
page.keyboard.press('Backspace')
|
||||
check(page.evaluate(
|
||||
"() => document.getElementById('lsearch').value") == 'ab',
|
||||
'Backspace edits text while an input owns focus (no undo fired)')
|
||||
page.evaluate("() => document.querySelector('.tab[data-tab=deck]').click()")
|
||||
flick(300)
|
||||
|
||||
# --- item 2: center tap -> dossier -> hero -> viewer; Esc/Es ----------
|
||||
tid_before = top_id()
|
||||
src_before = top_state()['photo']
|
||||
pill_pre_tap = sect_pill()['txt']
|
||||
tap_center()
|
||||
check(sect_pill()['txt'] == pill_pre_tap,
|
||||
'item 2: center tap commits nothing')
|
||||
check(dossier_on(), 'item 2: center tap opens the dossier')
|
||||
check(not viewer_on(), 'item 2: no viewer on center tap')
|
||||
check(bool(page.evaluate(
|
||||
"() => document.getElementById('dtitle').textContent")),
|
||||
'dossier carries the card title')
|
||||
dhero_click()
|
||||
check(viewer_on(), 'dossier hero tap opens the viewer (photo 0)')
|
||||
vidx = page.evaluate("""() => { const im=document.getElementById('vimg');
|
||||
return {src:im.getAttribute('src'),
|
||||
fot:getComputedStyle(im).objectFit}; }""")
|
||||
check(vidx['fot'] == 'contain', 'item 3: viewer vimg stays contain (no diff)')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'item3-viewer.png'))
|
||||
# arrows are inert while the viewer is open
|
||||
pill_now = sect_pill()['txt']
|
||||
for kk in ('ArrowLeft', 'ArrowRight', 'ArrowUp'):
|
||||
page.keyboard.press(kk)
|
||||
check(sect_pill()['txt'] == pill_now,
|
||||
'arrows are inert while the viewer is open')
|
||||
key('Escape')
|
||||
check(not viewer_on() and dossier_on(),
|
||||
'Esc closes the viewer only (dossier stays open)')
|
||||
key('Escape')
|
||||
check(not dossier_on() and not viewer_on(),
|
||||
'second Esc closes the dossier to the deck')
|
||||
check(top_id() == tid_before and top_state()['photo'] == src_before,
|
||||
'walk-back leaves the same card on the same photo')
|
||||
|
||||
# item 2 A5: list row -> dossier -> viewer -> Esc -> dossier -> Esc -> list
|
||||
page.evaluate("() => document.querySelector('.tab[data-tab=list]').click()")
|
||||
wait('#lrows .row')
|
||||
flick(400)
|
||||
thumb_fit = page.evaluate("""() => { const t=document.querySelector(
|
||||
'.thumb'); return t?getComputedStyle(t).objectFit:null; }""")
|
||||
check(thumb_fit == 'cover', 'item 3: list thumbs stay cover (no diff)')
|
||||
page.evaluate("""() => document.querySelector('#lrows .row').click()""")
|
||||
flick(400)
|
||||
check(dossier_on(), 'list row tap opens the dossier')
|
||||
dhero_click()
|
||||
check(viewer_on(), 'list dossier hero opens the viewer')
|
||||
key('Escape')
|
||||
check(not viewer_on() and dossier_on(), 'Esc: viewer -> dossier (list)')
|
||||
key('Escape')
|
||||
check(not dossier_on()
|
||||
and page.evaluate("() => document.getElementById('listScreen')"
|
||||
".classList.contains('on')"),
|
||||
'second Esc returns to the list screen')
|
||||
page.evaluate("() => document.querySelector('.tab[data-tab=deck]').click()")
|
||||
flick(300)
|
||||
|
||||
# arrows inert while the dossier is open
|
||||
tap_center()
|
||||
check(dossier_on(), 'dossier open for the key-inertness check')
|
||||
before_pill = sect_pill()['txt']
|
||||
for kk in ('ArrowLeft', 'ArrowRight', 'ArrowUp', 'ArrowDown'):
|
||||
page.keyboard.press(kk)
|
||||
flick(40)
|
||||
check(sect_pill()['txt'] == before_pill,
|
||||
'arrow keys are inert while the dossier is open')
|
||||
|
||||
# item 10+4: dossier band + minimal rubric on the fresh card
|
||||
db = page.evaluate("""() => { const b=document.getElementById('dband');
|
||||
if(b.style.display==='none') return {off:true};
|
||||
return {off:false, cls:b.className}; }""")
|
||||
check(bool(db.get('off')), 'dossier on a fresh card shows no band')
|
||||
drank = page.evaluate("""() => { const d=document.getElementById('drank');
|
||||
return {shown:d.style.display!=='none',
|
||||
pts:document.getElementById('dpts').textContent,
|
||||
lines:document.getElementById('dlines').innerHTML,
|
||||
foot:document.getElementById('dfoot').textContent}; }""")
|
||||
check(re.search(r'^\d+%$', drank['pts']),
|
||||
'item 4: rank block shows gauge + NN%% (%s)' % drank['pts'])
|
||||
check(not drank['lines'] and not drank['foot'],
|
||||
'item 4: breakdown lines + footer hidden with rubric_debug off')
|
||||
dc = page.evaluate("""() => { const p=document.getElementById('dphoto');
|
||||
const b=document.getElementById('dblur');
|
||||
return {fit:getComputedStyle(p).objectFit,
|
||||
bg:b.style.backgroundImage}; }""")
|
||||
check(dc['fit'] == 'contain' and bool(dc['bg']),
|
||||
'item 3: dossier hero fits contain over its backdrop')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'item3-dossier.png'))
|
||||
key('Escape')
|
||||
|
||||
# item 2: side taps still flip (clamped), never open a sheet
|
||||
before_photo = top_state()['photo']
|
||||
tap_side('left')
|
||||
check(top_state()['photo'] == before_photo, 'left tap clamps at photo 0')
|
||||
check(not dossier_on() and not viewer_on(),
|
||||
'side taps never open sheets (B1 §11.2 regression)')
|
||||
tap_side('right')
|
||||
check(top_state()['photo'] != before_photo, 'right tap flips forward')
|
||||
|
||||
# --- item 4: rubric_debug on -> breakdown appears ----------------------
|
||||
api_post('/api/prefs', {'key': 'rubric_debug', 'value': 'on'})
|
||||
page.reload(wait_until='networkidle')
|
||||
wait('.topcard')
|
||||
flick(400)
|
||||
tap_center()
|
||||
check(dossier_on(), 'dossier open for the debug-mode check')
|
||||
drank = page.evaluate("""() => { const d=document.getElementById('drank');
|
||||
if(d.style.display==='none') return {shown:false};
|
||||
return {shown:true,
|
||||
lines:document.getElementById('dlines').textContent,
|
||||
foot:document.getElementById('dfoot').textContent}; }""")
|
||||
check(bool(drank['shown']) and bool(drank['lines']),
|
||||
'item 4: rubric_debug on -> breakdown lines render')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'item4-debug-on.png'))
|
||||
key('Escape')
|
||||
page.evaluate("() => document.querySelector('.tab[data-tab=trends]').click()")
|
||||
flick(300)
|
||||
page.evaluate("() => document.getElementById('tRubOff').click()")
|
||||
flick(400)
|
||||
check(api('/api/section').get('prefs', {}).get('rubric_debug') == 'off',
|
||||
'Trends toggle wrote rubric_debug=off to the server')
|
||||
heck = page.evaluate("""() => document.getElementById(
|
||||
'tRubOff').classList.contains('on')""")
|
||||
check(bool(heck), 'toggle UI paints the off state')
|
||||
page.evaluate("() => document.querySelector('.tab[data-tab=deck]').click()")
|
||||
flick(300)
|
||||
|
||||
# --- item 7: header pill
|
||||
stats = api('/api/stats')
|
||||
pill_txt = page.evaluate(
|
||||
"() => document.getElementById('pill').textContent")
|
||||
check(('%d live' % stats['live']) in pill_txt
|
||||
and ('%d fresh' % stats['fresh']) in pill_txt,
|
||||
'item 7: pill reads live + fresh (%s)' % pill_txt.replace('\n', ' '))
|
||||
|
||||
# --- v1.1.1 (issue #2): the header pill keeps itself live --------------
|
||||
pl0 = api('/api/stats')
|
||||
key('ArrowRight') # probe swipe, undone right after
|
||||
flick(300)
|
||||
pl1 = api('/api/stats')
|
||||
dl = time.time() + 5
|
||||
ptx = ''
|
||||
while time.time() < dl:
|
||||
ptx = page.evaluate("() => document.getElementById('pill').textContent")
|
||||
if ('%d fresh' % pl1['fresh']) in ptx:
|
||||
break
|
||||
time.sleep(0.2)
|
||||
check(('%d fresh' % pl1['fresh']) in ptx and ('%d live' % pl1['live']) in ptx,
|
||||
'issue #2: pill refreshes itself after a swipe, no reload (%s -> %s)'
|
||||
% (pl0['fresh'], ptx))
|
||||
key('ArrowDown') # undo the probe swipe (net-zero)
|
||||
flick(300)
|
||||
pl2 = api('/api/stats')
|
||||
dl = time.time() + 5
|
||||
while time.time() < dl:
|
||||
ptx = page.evaluate("() => document.getElementById('pill').textContent")
|
||||
if ('%d fresh' % pl2['fresh']) in ptx:
|
||||
break
|
||||
time.sleep(0.2)
|
||||
check(('%d fresh' % pl2['fresh']) in ptx,
|
||||
'issue #2: pill refreshes itself after an undo, no reload (%s)' % ptx)
|
||||
|
||||
# --- B1 no-lock: rapid commit storm (no sheet, no lock) ----------------
|
||||
before = sect_pill()['txt']
|
||||
taps(2, 40)
|
||||
flick(500)
|
||||
t = top_state()
|
||||
check(t['topcards'] == 1, 'no-lock storm keeps exactly one .topcard')
|
||||
after = sect_pill()['txt']
|
||||
check(int(after.split('/')[0]) - int(before.split('/')[0]) == 2,
|
||||
'both storm swipes landed (%s -> %s)' % (before, after))
|
||||
|
||||
# --- item 10 + P3 loop: sweep to the return band and exhaust ------------
|
||||
bands = {}
|
||||
for _ in range(30):
|
||||
tid = top_id()
|
||||
if tid is not None and tid in by_id:
|
||||
slot = by_id[tid]['slot']
|
||||
if slot in ('return', 'wildcard') and slot not in bands:
|
||||
bands[slot] = page.evaluate("""() => { const b=document.querySelector(
|
||||
'.topcard .band'); if(!b) return null;
|
||||
const s=getComputedStyle(b);
|
||||
return {cls:b.className, color:s.color, bg:s.backgroundColor,
|
||||
text:b.textContent}; }""")
|
||||
if not page.evaluate("() => document.querySelector('.topcard')"):
|
||||
break
|
||||
key('ArrowRight')
|
||||
flick(80)
|
||||
check(bool(bands.get('return')),
|
||||
'item 10: a SECOND LOOK card topped and carried its band')
|
||||
if bands.get('return'):
|
||||
check(bands['return']['color'] == 'rgb(196, 181, 253)',
|
||||
'item 10: SL band text is the violet tint')
|
||||
check(bands['return']['bg'] == 'rgba(124, 58, 237, 0.22)',
|
||||
'item 10: SL band fill is violet 22%')
|
||||
check('SECOND LOOK' in bands['return']['text'],
|
||||
'item 10: SL band label intact')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'item10-card-band.png'))
|
||||
if bands.get('wildcard'):
|
||||
check('wild' in bands['wildcard']['cls'],
|
||||
'item 10: wildcard band keeps its amber variant')
|
||||
# dossier band on a return item: drive the real openDetail path
|
||||
ret_item = next((i for i in body['items'] if i['slot'] == 'return'), None)
|
||||
db = page.evaluate("""(item) => { openDetail(item, {type:'deck'});
|
||||
const b=document.getElementById('dband');
|
||||
const s=getComputedStyle(b);
|
||||
return {off:b.style.display==='none', color:s.color,
|
||||
bg:s.backgroundColor, text:b.textContent}; }""", ret_item)
|
||||
check(not db['off'] and db['color'] == 'rgb(196, 181, 253)'
|
||||
and 'SECOND LOOK' in db['text'],
|
||||
'item 10: dossier mirrors the violet SECOND LOOK band')
|
||||
key('Escape')
|
||||
|
||||
# finish the section -> report -> forge
|
||||
for _ in range(10):
|
||||
if not page.evaluate("() => document.querySelector('.topcard')"):
|
||||
break
|
||||
key('ArrowRight')
|
||||
flick(80)
|
||||
wait('#report.on, #empty2.on', timeout=10000)
|
||||
rep = page.evaluate("""() => ({report:document.getElementById('report')
|
||||
.classList.contains('on'),
|
||||
dry:document.getElementById('dryCap').style.display!=='none',
|
||||
counts:document.getElementById('repCounts').textContent,
|
||||
empty2:document.getElementById('empty2').classList.contains('on')})""")
|
||||
check(bool(rep['report']), 'P3 loop: report card owns the exhausted deck')
|
||||
check(not rep['dry'], 'item 6: rich batch shows no dry caption')
|
||||
check(not rep['empty2'], 'item 8: empty2 stays hidden while stock remains')
|
||||
check(sect_pill()['hot'], 'pill is hot at the section end')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'p3-report.png'))
|
||||
sec_before = section_body()['section']['id']
|
||||
page.evaluate("() => document.getElementById('btnForge').click()")
|
||||
wait('.topcard', timeout=20000)
|
||||
check(section_body()['section']['id'] != sec_before,
|
||||
'forge opened a brand-new section')
|
||||
pill = sect_pill()
|
||||
check(re.search(r'^\d+/25$', pill['txt']),
|
||||
'new section pill starts at a plain N/25 (%s)' % pill['txt'])
|
||||
check(not dossier_on() and not viewer_on(), 'forge leaves no sheets open')
|
||||
print('rich walk complete')
|
||||
|
||||
|
||||
# --- WALK2: returns-only (counter fix + dry messaging) ---------------------
|
||||
|
||||
def walk_returns_only():
|
||||
wait('.topcard')
|
||||
flick(800)
|
||||
body = section_body()
|
||||
check(len(body['items']) == 25 and body['recipe']['new'] == 0,
|
||||
'returns-only catalog composes 25 second looks (recipe %s)'
|
||||
% json.dumps(body['recipe']))
|
||||
check(body['progress']['decided'] == 0
|
||||
and body['progress']['total'] == 25,
|
||||
'item 5: fresh batch reads 0/25 (old code painted 25/25)')
|
||||
pill = sect_pill()
|
||||
check(pill['txt'] == '0/25' and not pill['hot'],
|
||||
'pill shows 0/25, no premature hot state')
|
||||
|
||||
# one real strike -> 1/25 (in-section event, not lifetime verdict)
|
||||
key('ArrowRight')
|
||||
pill = sect_pill()
|
||||
check(pill['txt'] == '1/25', 'first strike -> 1/25 (%s)' % pill['txt'])
|
||||
check(section_body()['progress']['decided'] == 1,
|
||||
'server truth agrees: one in-section decision')
|
||||
key('ArrowUp')
|
||||
check(sect_pill()['txt'] == '2/25', 'ArrowUp maybe -> 2/25')
|
||||
key('ArrowDown')
|
||||
check(sect_pill()['txt'] == '1/25', 'ArrowDown undo -> 1/25')
|
||||
key('Backspace')
|
||||
check(sect_pill()['txt'] == '0/25', 'Backspace undo -> 0/25')
|
||||
|
||||
# mixed actions -> report counts proven in-section only
|
||||
key('ArrowLeft')
|
||||
key('ArrowUp')
|
||||
key('ArrowRight')
|
||||
check(sect_pill()['txt'] == '3/25', 'three strikes -> 3/25 (clamped)')
|
||||
|
||||
# sweep to exhaustion
|
||||
for _ in range(30):
|
||||
if not page.evaluate("() => document.querySelector('.topcard')"):
|
||||
break
|
||||
key('ArrowRight')
|
||||
flick(60)
|
||||
wait('#report.on', timeout=10000)
|
||||
pill = sect_pill()
|
||||
check(pill['txt'] == '25/25' and pill['hot'],
|
||||
'pill clamps at 25/25 and goes hot (never 26/25)')
|
||||
counts = api('/api/section')['counts']
|
||||
check(counts['likes'] + counts['maybes'] + counts['nopes'] == 25,
|
||||
'report counts the 25 in-section verdicts (not lifetime)')
|
||||
rep = page.evaluate("""() => ({dry:document.getElementById('dryCap')
|
||||
.style.display!=='none',
|
||||
status:document.getElementById('forgeStatus').textContent})""")
|
||||
check(bool(rep['dry']), 'item 6: dry caption shows on the 0-fresh report')
|
||||
|
||||
# dry forge -> the sentence + a fresh 0/25 returns-only deck
|
||||
page.evaluate("() => document.getElementById('btnForge').click()")
|
||||
for _ in range(40):
|
||||
st = page.evaluate(
|
||||
"() => document.getElementById('forgeStatus').textContent")
|
||||
if 'Catalog fully reviewed' in st:
|
||||
break
|
||||
flick(250)
|
||||
st = page.evaluate(
|
||||
"() => document.getElementById('forgeStatus').textContent")
|
||||
check('Catalog fully reviewed — fresh listings arrive with the next'
|
||||
' 08:30 import; showing second looks' in st,
|
||||
'item 6: dry forge status shows the exact BACKLOG sentence')
|
||||
wait('.topcard', timeout=15000)
|
||||
body = section_body()
|
||||
check(body['recipe']['new'] == 0 and body['progress']['decided'] == 0,
|
||||
'dry forge decks another 25 second looks at 0/25')
|
||||
print('returns-only walk complete')
|
||||
|
||||
|
||||
# --- WALK3: dead catalog (loud empty2) -------------------------------------
|
||||
|
||||
def burn_returns(db_path):
|
||||
conn = sqlite3.connect(db_path)
|
||||
try:
|
||||
conn.execute('DELETE FROM section_items')
|
||||
conn.execute("UPDATE sections SET status='closed'"
|
||||
" WHERE status!='closed'")
|
||||
conn.execute(
|
||||
"""INSERT INTO section_items (section_id, listing_id, slot,
|
||||
position)
|
||||
SELECT (SELECT id FROM sections ORDER BY id DESC LIMIT 1),
|
||||
listing_id, 'return', 1 FROM swipes
|
||||
WHERE listing_id IN (SELECT id FROM listings
|
||||
WHERE status='active')""")
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
|
||||
|
||||
def walk_dead_catalog():
|
||||
body = section_body()
|
||||
check(body['pool'] == {'fresh': 0, 'returns': 0, 'wildcards': 0},
|
||||
'item 8: drained catalog reports pool 0/0/0')
|
||||
check(body['items'] == [], 'compose emits zero items on a dead pool')
|
||||
wait('#empty2.on', timeout=10000)
|
||||
st = page.evaluate("""() => { const e=document.getElementById('empty2');
|
||||
return {on:e.classList.contains('on'),
|
||||
txt:e.textContent,
|
||||
report:document.getElementById('report').classList.contains('on')}; }""")
|
||||
check(bool(st['on']), 'item 8: loud empty2 owns the stage')
|
||||
check('No more new bikes!' in st['txt'] and '08:30' in st['txt'],
|
||||
'item 8: exact title + next-import line')
|
||||
check(not st['report'], 'item 8: report card masked on the dead catalog')
|
||||
page.screenshot(path=os.path.join(SHOTS, 'item8-empty2.png'))
|
||||
|
||||
# forge on the dead catalog: still empty2, no wasted Forge invitation
|
||||
page.evaluate("() => document.getElementById('btnForge').click()")
|
||||
flick(1500)
|
||||
st = page.evaluate("""() => { const e=document.getElementById('empty2');
|
||||
return {on:e.classList.contains('on'),
|
||||
report:document.getElementById('report').classList.contains('on')}; }""")
|
||||
check(bool(st['on']) and not st['report'],
|
||||
'forge on 0/0/0 leaves empty2 (report never re-invites)')
|
||||
|
||||
# nightly import simulated: a brand-new listing re-lights the deck
|
||||
stop_server()
|
||||
conn = sqlite3.connect(WALK3)
|
||||
try:
|
||||
lid = 990
|
||||
conn.execute("DELETE FROM listings WHERE id=?", (lid,))
|
||||
conn.execute(
|
||||
"INSERT INTO listings (id, region, src_id, title, url, status,"
|
||||
" img_url, score, first_seen, desc) VALUES"
|
||||
" (?, 'ns', 'v11night', 'Fresh overnight listing',"
|
||||
" 'https://www.kijiji.ca/v-motorcycles/v11/990', 'active',"
|
||||
" NULL, 50, '2026-11-13T08:30:00Z', 'arrived with the import')",
|
||||
(lid,))
|
||||
conn.commit()
|
||||
finally:
|
||||
conn.close()
|
||||
start_server(WALK3)
|
||||
page.reload(wait_until='networkidle')
|
||||
wait('.topcard', timeout=15000)
|
||||
st = page.evaluate("""() => ({empty2:document.getElementById('empty2')
|
||||
.classList.contains('on'), top:!!document.querySelector('.topcard')})""")
|
||||
check(bool(st['top']) and not st['empty2'],
|
||||
'item 8: one fresh listing clears empty2 and relights the deck')
|
||||
print('dead-catalog walk complete')
|
||||
|
||||
|
||||
# --- WALK0: hand the rich DB a quick dry run through items 1 acceptance ---
|
||||
|
||||
def main():
|
||||
global page
|
||||
setup() # always: fresh staged DBs per run
|
||||
# clear any stray scratch server left by an aborted run
|
||||
import signal
|
||||
for line in subprocess.run(
|
||||
['ps', '-eo', 'pid,args'], capture_output=True,
|
||||
text=True).stdout.splitlines():
|
||||
if 'app.serve' in line and str(PORT) in line:
|
||||
try:
|
||||
os.kill(int(line.split()[0]), signal.SIGTERM)
|
||||
except (ValueError, ProcessLookupError):
|
||||
pass
|
||||
time.sleep(0.5)
|
||||
try:
|
||||
from playwright.sync_api import sync_playwright
|
||||
except ImportError:
|
||||
print('playwright missing — run: .venv/bin/python -m app.fe_walk_v11')
|
||||
return 1
|
||||
|
||||
with sync_playwright() as pw:
|
||||
exe = os.path.expanduser(
|
||||
'~/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome')
|
||||
if not os.path.exists(exe):
|
||||
exe = None
|
||||
|
||||
# phase 1: rich
|
||||
start_server(WALK1)
|
||||
try:
|
||||
browser = pw.chromium.launch(headless=True, executable_path=exe,
|
||||
args=['--no-sandbox'])
|
||||
ctx = browser.new_context(viewport={'width': 390, 'height': 844},
|
||||
has_touch=True, is_mobile=True)
|
||||
page = ctx.new_page()
|
||||
page.goto(BASE_URL + '/', wait_until='networkidle')
|
||||
walk_rich()
|
||||
ctx.close()
|
||||
finally:
|
||||
stop_server()
|
||||
|
||||
# phase 2: returns-only (uses WALK2 fresh from setup)
|
||||
start_server(WALK2)
|
||||
try:
|
||||
browser = pw.chromium.launch(headless=True, executable_path=exe,
|
||||
args=['--no-sandbox'])
|
||||
ctx = browser.new_context(viewport={'width': 390, 'height': 844},
|
||||
has_touch=True, is_mobile=True)
|
||||
page = ctx.new_page()
|
||||
page.goto(BASE_URL + '/', wait_until='networkidle')
|
||||
walk_returns_only()
|
||||
ctx.close()
|
||||
finally:
|
||||
stop_server()
|
||||
|
||||
# phase 3: dead catalog
|
||||
shutil.copy2(WALK2, WALK3)
|
||||
burn_returns(WALK3)
|
||||
start_server(WALK3)
|
||||
try:
|
||||
browser = pw.chromium.launch(headless=True, executable_path=exe,
|
||||
args=['--no-sandbox'])
|
||||
ctx = browser.new_context(viewport={'width': 390, 'height': 844},
|
||||
has_touch=True, is_mobile=True)
|
||||
page = ctx.new_page()
|
||||
page.goto(BASE_URL + '/', wait_until='networkidle')
|
||||
walk_dead_catalog()
|
||||
ctx.close()
|
||||
finally:
|
||||
stop_server()
|
||||
|
||||
print('---')
|
||||
print('%d/%d walk checks passed' % (CHECKS[0], CHECKS[0] + CHECKS[1]))
|
||||
return 1 if CHECKS[1] else 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
@@ -1,18 +1,24 @@
|
||||
"""Bike-Tinder local image mirror.
|
||||
|
||||
Downloads each active listing's card image once into data/img/{id}.webp.
|
||||
Downloads each active listing's photos once:
|
||||
- gallery listings (B1 §11.1): imgs[n] -> data/img/{id}_{n}.webp for the
|
||||
extra photos; the primary (n=0) lands at the legacy data/img/{id}.webp
|
||||
so the v1 single-image chain is untouched;
|
||||
- legacy listings: img_url -> data/img/{id}.webp (as before).
|
||||
|
||||
.venv/bin/python -m app.imgfetch --db data/bike-tinder.sqlite3
|
||||
.venv/bin/python -m app.imgfetch --limit 15
|
||||
|
||||
Polite by design: ~1 req/s (sleep between fetches), skip-existing, crash-safe
|
||||
(partial bytes land in .part and are atomically renamed), per-item failures
|
||||
never kill the run. Honest end summary: `fetched N · skipped M · failed K`.
|
||||
never kill the run. Per-file CLI progress; honest end summary:
|
||||
`fetched N · skipped M · failed K`.
|
||||
|
||||
UA + habits match the hunt scanner (reference/motorcycle-hunt-scan.py) so the
|
||||
CDN sees the same client as the crawl. Stdlib only — no requests dependency.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
@@ -44,8 +50,10 @@ def fetch_one(img_url, dst):
|
||||
})
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=TIMEOUT) as resp:
|
||||
if getattr(resp, 'status', 200) != 200:
|
||||
return 'HTTP %s' % resp.status
|
||||
status = (getattr(resp, 'status', None)
|
||||
or getattr(resp, 'code', None) or 200)
|
||||
if status != 200:
|
||||
return 'HTTP %s' % status
|
||||
buf = resp.read()
|
||||
if not is_webp(buf):
|
||||
return 'not webp (%d bytes, %r)' % (len(buf), buf[:8])
|
||||
@@ -65,33 +73,76 @@ def fetch_one(img_url, dst):
|
||||
pass
|
||||
|
||||
|
||||
def parse_imgs(raw):
|
||||
"""listings.imgs TEXT -> list of non-empty URL strings ([] when unparsable)."""
|
||||
if not raw:
|
||||
return []
|
||||
try:
|
||||
v = json.loads(raw)
|
||||
except ValueError:
|
||||
return []
|
||||
if not isinstance(v, list):
|
||||
return []
|
||||
return [u.strip() for u in v if isinstance(u, str) and u.strip()]
|
||||
|
||||
|
||||
def build_work(rows, img_dir):
|
||||
"""Flatten listings rows into (listing_id, n_or_None, url, dst) downloads.
|
||||
|
||||
Gallery rows fetch every imgs[n]: n=0 -> the legacy {id}.webp (the primary
|
||||
— one canonical file, no duplicate fetch), n>=1 -> {id}_{n}.webp. Legacy
|
||||
rows (no gallery) keep the img_url -> {id}.webp chain. Work is deduped by
|
||||
destination path.
|
||||
"""
|
||||
work = []
|
||||
for r in rows:
|
||||
g = parse_imgs(r['imgs'])
|
||||
if g:
|
||||
for n, url in enumerate(g):
|
||||
dst = os.path.join(img_dir, ('%d.webp' % r['id'] if n == 0
|
||||
else '%d_%d.webp' % (r['id'], n)))
|
||||
work.append((r['id'], n, url, dst))
|
||||
elif r['img_url']:
|
||||
work.append((r['id'], None, r['img_url'],
|
||||
os.path.join(img_dir, '%d.webp' % r['id'])))
|
||||
seen, deduped = set(), []
|
||||
for item in work:
|
||||
if item[3] not in seen:
|
||||
seen.add(item[3])
|
||||
deduped.append(item)
|
||||
return deduped
|
||||
|
||||
|
||||
def run_fetch(db_path, img_dir, limit=None, sleep=SLEEP, quiet=False):
|
||||
conn = db.connect(db_path)
|
||||
db.init_db(conn)
|
||||
rows = conn.execute(
|
||||
"SELECT id, img_url FROM listings"
|
||||
" WHERE status='active' AND img_url IS NOT NULL"
|
||||
" ORDER BY id").fetchall()
|
||||
"SELECT id, img_url, imgs FROM listings"
|
||||
" WHERE status='active' ORDER BY id").fetchall()
|
||||
conn.close()
|
||||
|
||||
os.makedirs(img_dir, exist_ok=True)
|
||||
work = build_work(rows, img_dir)
|
||||
total = len(work)
|
||||
fetched = skipped = failed = 0
|
||||
for row in rows:
|
||||
for idx, (lid, n, url, dst) in enumerate(work, 1):
|
||||
if limit is not None and fetched >= limit:
|
||||
break
|
||||
dst = os.path.join(img_dir, '%d.webp' % row['id'])
|
||||
if os.path.exists(dst):
|
||||
skipped += 1
|
||||
continue
|
||||
result = fetch_one(row['img_url'], dst)
|
||||
result = fetch_one(url, dst)
|
||||
if result == 'fetched':
|
||||
fetched += 1
|
||||
if not quiet:
|
||||
print(' [%d/%d] id=%d n=%s ok' % (idx, total, lid, n))
|
||||
else:
|
||||
failed += 1
|
||||
if not quiet:
|
||||
print(' fail id=%d %s' % (row['id'], result))
|
||||
print(' fail id=%d n=%s %s' % (lid, n, result))
|
||||
time.sleep(sleep)
|
||||
return {'fetched': fetched, 'skipped': skipped, 'failed': failed}
|
||||
return {'fetched': fetched, 'skipped': skipped, 'failed': failed,
|
||||
'total': total}
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
@@ -105,8 +156,8 @@ def main(argv=None):
|
||||
args = ap.parse_args(argv)
|
||||
|
||||
res = run_fetch(args.db, args.img_dir, limit=args.limit, sleep=args.sleep)
|
||||
print('fetched %d · skipped %d · failed %d' % (
|
||||
res['fetched'], res['skipped'], res['failed']))
|
||||
print('fetched %d · skipped %d · failed %d · total %d' % (
|
||||
res['fetched'], res['skipped'], res['failed'], res['total']))
|
||||
return 0
|
||||
|
||||
|
||||
|
||||
@@ -88,6 +88,24 @@ def iter_items(st):
|
||||
yield src_id, it
|
||||
|
||||
|
||||
def imgs_from_item(it):
|
||||
"""Gallery images from a state item: deduplicated, non-empty URL strings
|
||||
in page order, or None. The hunt guarantees imgs[0] equals `img` (the
|
||||
established primary)."""
|
||||
raw = it.get('imgs')
|
||||
if not isinstance(raw, (list, tuple)):
|
||||
return None
|
||||
out, seen = [], set()
|
||||
for u in raw:
|
||||
if not isinstance(u, str):
|
||||
continue
|
||||
u = u.strip()
|
||||
if u and u not in seen:
|
||||
seen.add(u)
|
||||
out.append(u)
|
||||
return out or None
|
||||
|
||||
|
||||
def normalize(region, src_id, it, now):
|
||||
"""Normalize one state item into a row dict (strings->ints robustly,
|
||||
missing fields -> NULL)."""
|
||||
@@ -102,6 +120,10 @@ def normalize(region, src_id, it, now):
|
||||
year = rubric.year_from_title(title)
|
||||
score, family = rubric.score_item(title, it.get('desc') or '', price_num, km, year)
|
||||
extras = rubric.extras_from_text(title, it.get('desc') or '')
|
||||
# B1: gallery (page order, entry 0 = the primary). img_url keeps the
|
||||
# established single `img` signal and falls back to imgs[0].
|
||||
imgs = imgs_from_item(it)
|
||||
img = it.get('img') or (imgs[0] if imgs else None)
|
||||
# seller_type only from a REAL signal in the state item (the hunt image
|
||||
# backfill / enrichment passes) — never inferred from titles.
|
||||
seller = it.get('seller_type') or it.get('seller')
|
||||
@@ -116,7 +138,8 @@ def normalize(region, src_id, it, now):
|
||||
'km': km,
|
||||
'location': (it.get('loc') or it.get('city') or None),
|
||||
'url': it.get('url') or '',
|
||||
'img_url': it.get('img') or None,
|
||||
'img_url': img,
|
||||
'imgs': json.dumps(imgs) if imgs else None,
|
||||
'desc': it.get('desc') or None,
|
||||
'family': family,
|
||||
'score': score,
|
||||
@@ -138,25 +161,25 @@ def upsert(conn, row, now):
|
||||
if existing:
|
||||
conn.execute(
|
||||
'''UPDATE listings SET title=?, price_display=?, price_num=?, km=?,
|
||||
location=?, url=?, img_url=?, desc=?, family=?, score=?,
|
||||
location=?, url=?, img_url=?, imgs=?, desc=?, family=?, score=?,
|
||||
year=?, seller_type=?, extras=?,
|
||||
status='active', dup_of=NULL, last_seen=?, updated_at=?
|
||||
WHERE id=?''',
|
||||
(row['title'], row['price_display'], row['price_num'], row['km'],
|
||||
row['location'], row['url'], row['img_url'], row['desc'],
|
||||
row['family'], row['score'], row['year'], row['seller_type'],
|
||||
row['extras'], now, now, existing['id']))
|
||||
row['location'], row['url'], row['img_url'], row['imgs'],
|
||||
row['desc'], row['family'], row['score'], row['year'],
|
||||
row['seller_type'], row['extras'], now, now, existing['id']))
|
||||
return existing['id'], False
|
||||
cur = conn.execute(
|
||||
'''INSERT INTO listings (region, src_id, title, price_display, price_num,
|
||||
km, location, url, img_url, desc, family, score, year, seller_type,
|
||||
extras, status, dup_of,
|
||||
km, location, url, img_url, imgs, desc, family, score, year,
|
||||
seller_type, extras, status, dup_of,
|
||||
first_seen, last_seen, created_at, updated_at)
|
||||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)''',
|
||||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)''',
|
||||
(row['region'], row['src_id'], row['title'], row['price_display'],
|
||||
row['price_num'], row['km'], row['location'], row['url'],
|
||||
row['img_url'], row['desc'], row['family'], row['score'], row['year'],
|
||||
row['seller_type'], row['extras'], 'active',
|
||||
row['img_url'], row['imgs'], row['desc'], row['family'], row['score'],
|
||||
row['year'], row['seller_type'], row['extras'], 'active',
|
||||
None, row['first_seen'], row['last_seen'], now, now))
|
||||
return cur.lastrowid, True
|
||||
|
||||
|
||||
146
app/sections.py
146
app/sections.py
@@ -1,8 +1,12 @@
|
||||
"""Bike-Tinder P3 section engine — compose / read / exhaust / forge.
|
||||
|
||||
The deck is one finite SECTION at a time (default 25 cards):
|
||||
2 wildcards + <=5 returns (<=2 nopes, "surprising" only) + remainder new,
|
||||
per docs/RANKING.md + docs/DATA-MODEL.md "P3 additions".
|
||||
v1.1 batch formula (amends the frozen "<=5 returns" rule — one-shot,
|
||||
re-nope and one-return rules unchanged): every batch targets 25 cards =
|
||||
fresh first (up to 23 slots) + >=2 second looks whenever eligible stock
|
||||
exists + the 2 wildcard slots; when fresh < the remainder, second looks
|
||||
FILL the batch up to 25 (family cap relaxes to 8 for fill returns only).
|
||||
Fresh exhausted -> returns-only batches; returns exhausted -> fresh-only;
|
||||
both -> an empty composed section (the loud empty state, item 8).
|
||||
|
||||
Pinned order within a section (position 1 first):
|
||||
new (points DESC) -> returns (maybe > like > nope, points DESC within
|
||||
@@ -11,10 +15,12 @@ Pinned order within a section (position 1 first):
|
||||
wildcard stretches sit at the back. (Wildcard placement inside the deck
|
||||
is not pinned anywhere in the frozen docs — noted in the P3 report.)
|
||||
|
||||
Constraints: <=4 per non-NULL family per section; >=3 price bands when the
|
||||
pool allows (soft repair swaps new-slot items within the final list).
|
||||
A re-nope (round>=2 nope event) rests an item: no more second looks.
|
||||
Rounds cap at 2 for influence (taste.py); returns are offered once.
|
||||
Constraints: <=4 per non-NULL family per section (fill-return slots relax
|
||||
to <=8); >=3 price bands when the pool allows (soft repair swaps new-slot
|
||||
items within the final list). <=2 re-nope returns per batch (reserved
|
||||
nope slots must be "surprising"). A re-nope (round>=2 nope event) rests
|
||||
an item: no more second looks. Rounds cap at 2 for influence (taste.py);
|
||||
returns are offered once.
|
||||
|
||||
Modes: 'ondemand' (default) — forge runs the agent pass then composes;
|
||||
'strict' — forge refuses (409) unless a taste_profile strictly newer than
|
||||
@@ -26,9 +32,11 @@ from . import taste as tastemod
|
||||
from .taste import NOPE
|
||||
|
||||
FAMILY_CAP = 4
|
||||
MAX_RETURNS = 5
|
||||
RETURN_FILL_FAMILY_CAP = 8
|
||||
MAX_RETURN_NOPES = 2
|
||||
WILDCARDS = 2
|
||||
FRESH_CAP = 23
|
||||
MIN_RETURNS = 2
|
||||
DEFAULT_SIZE = 25
|
||||
MIN_BANDS = 3
|
||||
|
||||
@@ -262,6 +270,11 @@ def compose_section(conn, engine, size=DEFAULT_SIZE, profile_version=None,
|
||||
|
||||
Caller closes/reports any prior section first. `engine` scores the
|
||||
candidates (a TasteEngine over active listings + events + profile).
|
||||
|
||||
v1.1 slot math (see module docstring; this amends the frozen "<=5
|
||||
returns" rule): reserved returns (>=2 when eligible stock exists) ->
|
||||
wildcards (2) -> fresh (capped at 23) -> fill returns to `size`
|
||||
(family cap 4 preferred, 8 rescue; <=2 re-nopes total).
|
||||
"""
|
||||
import datetime
|
||||
now = now or datetime.datetime.now(datetime.timezone.utc).replace(
|
||||
@@ -297,18 +310,18 @@ def compose_section(conn, engine, size=DEFAULT_SIZE, profile_version=None,
|
||||
top_bands = {tastemod.price_band(r['price_num']) for r in top3
|
||||
if tastemod.price_band(r['price_num']) is not None}
|
||||
|
||||
# 2) returns: maybe > like > nope, points DESC within role; nopes must be
|
||||
# "surprising" (points >=55 or net-positive family); <=5, <=2 nopes.
|
||||
# Budget: wildcards keep their 2 slots; returns never push the
|
||||
# section past `size`.
|
||||
wanted_rets = min(MAX_RETURNS, max(0, size - min(WILDCARDS, size)))
|
||||
# 2) reserved returns: the >=2 guarantee (role order maybe > like > nope,
|
||||
# points DESC within role). Nopes must be "surprising" for RESERVED
|
||||
# slots only (points >=55 or net-positive family); <=2 re-nope
|
||||
# returns per batch overall; family cap 4 applies here.
|
||||
role_order = {'maybe': 0, 'like': 1, 'nope': 2}
|
||||
ret_ordered = sorted(ret_cands, reverse=True,
|
||||
key=lambda r: (-role_order.get(r['verdict'], 9),
|
||||
_points_key(engine, r)))
|
||||
rets = []
|
||||
nope_count = 0
|
||||
for cand in sorted(ret_cands, reverse=True,
|
||||
key=lambda r: (-role_order.get(r['verdict'], 9),
|
||||
_points_key(engine, r))):
|
||||
if len(rets) >= wanted_rets:
|
||||
for cand in ret_ordered:
|
||||
if len(rets) >= min(MIN_RETURNS, size):
|
||||
break
|
||||
fam = cand['family']
|
||||
if fam and fam_count.get(fam, 0) >= FAMILY_CAP:
|
||||
@@ -325,7 +338,8 @@ def compose_section(conn, engine, size=DEFAULT_SIZE, profile_version=None,
|
||||
if fam:
|
||||
fam_count[fam] = fam_count.get(fam, 0) + 1
|
||||
|
||||
# 3) wildcards: min(2, size), preferred different family AND price band
|
||||
# 3) wildcards: min(2, remaining slots), preferred different family AND
|
||||
# price band (existing novel/preferred pick, unchanged)
|
||||
liked_ids = [r['listing_id'] for r in conn.execute(
|
||||
"SELECT listing_id FROM swipes WHERE action='like'")]
|
||||
nov = novelty(rows_by_id, liked_ids,
|
||||
@@ -339,7 +353,7 @@ def compose_section(conn, engine, size=DEFAULT_SIZE, profile_version=None,
|
||||
and (tastemod.price_band(r['price_num']) is None
|
||||
or tastemod.price_band(r['price_num']) not in top_bands)]
|
||||
|
||||
n_wilds = min(WILDCARDS, size)
|
||||
n_wilds = min(WILDCARDS, max(0, size - len(rets)))
|
||||
wilds = []
|
||||
avail = sorted([r for r in wild_cands if r['id'] not in picked_ids],
|
||||
key=wild_key)
|
||||
@@ -355,12 +369,41 @@ def compose_section(conn, engine, size=DEFAULT_SIZE, profile_version=None,
|
||||
picked_ids.add(cand['id'])
|
||||
if fam:
|
||||
fam_count[fam] = fam_count.get(fam, 0) + 1
|
||||
n_wilds = len(wilds) # pool shortfall reverts to new
|
||||
n_wilds = len(wilds) # pool shortfall reverts to fresh/fill
|
||||
|
||||
# 4) new fills the remainder of the section (size - returns - wildcards)
|
||||
want_new = max(0, size - len(rets) - n_wilds)
|
||||
# 4) fresh fills the remainder (size - returns - wildcards), never
|
||||
# beyond FRESH_CAP. Wildcards draw from the fresh pool but do NOT
|
||||
# count against the fresh-slot cap (25 - 0 - 2 = 23 new + 2 wild on
|
||||
# a returns-free rich day; 21 new + 2 wild + 2 returns when both
|
||||
# guarantees hold — the sign-off shape). Pool-limited by what the
|
||||
# wildcard pick left in new_cands; a dry wild pool reverts slots.
|
||||
want_new = min(size - len(rets) - len(wilds), FRESH_CAP,
|
||||
max(0, len(new_cands) - len(wilds)))
|
||||
picked_new = pick_new(engine, new_cands, want_new, fam_count, picked_ids)
|
||||
|
||||
# 5) fill returns to size: role order; re-nope cap <=2 total (reserved
|
||||
# included, no surprising gate here); two-pass family cap — prefer
|
||||
# <=4, rescue pass relaxes to <=8 for FILL slots only (fresh picks
|
||||
# and reserved returns keep 4). Deterministic: role order, points
|
||||
# DESC within role.
|
||||
for pass_cap in (FAMILY_CAP, RETURN_FILL_FAMILY_CAP):
|
||||
for cand in ret_ordered:
|
||||
if len(rets) >= size - len(picked_new) - n_wilds:
|
||||
break
|
||||
if cand['id'] in picked_ids:
|
||||
continue
|
||||
fam = cand['family']
|
||||
if fam and fam_count.get(fam, 0) >= pass_cap:
|
||||
continue
|
||||
if cand['verdict'] == NOPE and nope_count >= MAX_RETURN_NOPES:
|
||||
continue
|
||||
rets.append(cand)
|
||||
picked_ids.add(cand['id'])
|
||||
if cand['verdict'] == NOPE:
|
||||
nope_count += 1
|
||||
if fam:
|
||||
fam_count[fam] = fam_count.get(fam, 0) + 1
|
||||
|
||||
# final pinned order: new -> returns -> wildcards
|
||||
ordered = list(picked_new) + rets + wilds
|
||||
|
||||
@@ -416,7 +459,8 @@ def close_section(conn, section, now, status='closed',
|
||||
|
||||
def section_items(conn, section):
|
||||
return conn.execute(
|
||||
"""SELECT l.*, s.action AS decision, si.slot, si.position
|
||||
"""SELECT l.*, s.action AS decision, s.last_photo_idx AS last_photo_idx,
|
||||
si.slot, si.position
|
||||
FROM section_items si
|
||||
JOIN listings l ON l.id = si.listing_id
|
||||
LEFT JOIN swipes s ON s.listing_id = l.id
|
||||
@@ -424,16 +468,58 @@ def section_items(conn, section):
|
||||
ORDER BY si.position ASC""", (section['id'],)).fetchall()
|
||||
|
||||
|
||||
def section_decided_ids(conn, section):
|
||||
"""Listing ids with a swipe event stamped in THIS section.
|
||||
|
||||
The decided set for progress/report/exhaustion is always these ids —
|
||||
never the lifetime `swipes.action` verdict (a second-look card enters
|
||||
its section wearing an old decision; only an in-section event means it
|
||||
was actually decided here). The join keeps out-of-section stray events
|
||||
honest (same shape `section_counts` uses).
|
||||
"""
|
||||
return {r['listing_id'] for r in conn.execute(
|
||||
"""SELECT e.listing_id FROM swipe_events e
|
||||
JOIN section_items si
|
||||
ON si.section_id = e.section_id
|
||||
AND si.listing_id = e.listing_id
|
||||
WHERE e.section_id = ?""", (section['id'],))}
|
||||
|
||||
|
||||
def pool_counts(conn):
|
||||
"""Stock answer to \"can the forge serve anything?\" — fresh / eligible
|
||||
returns / wildcards candidate counts, each from the composer's own
|
||||
candidate SQL. The per-section LAST_TWO exclusion inside compose_section
|
||||
is deliberately NOT applied here: the answer is about stock, not about
|
||||
what one batch will pick (item 8)."""
|
||||
def _count(sql):
|
||||
return conn.execute(
|
||||
'SELECT COUNT(*) AS n FROM (%s)' % sql).fetchone()['n']
|
||||
return {'fresh': _count(NEW_POOL_SQL),
|
||||
'returns': _count(RETURNS_SQL),
|
||||
'wildcards': _count(WILDCARD_SQL)}
|
||||
|
||||
|
||||
def section_counts(conn, section):
|
||||
"""Per-action counts + second-look / wildcard engagement for this
|
||||
section (events stamped with this section_id only)."""
|
||||
counts = {'likes': 0, 'maybes': 0, 'nopes': 0}
|
||||
for item in section_items(conn, section):
|
||||
if item['decision'] == 'like':
|
||||
# one verdict per listing: the latest in-section event wins (an undo +
|
||||
# re-swipe within a section must not double-count the report numbers)
|
||||
latest = {}
|
||||
for ev in conn.execute(
|
||||
"""SELECT e.listing_id, e.action FROM swipe_events e
|
||||
JOIN section_items si
|
||||
ON si.section_id = e.section_id
|
||||
AND si.listing_id = e.listing_id
|
||||
WHERE e.section_id = ?
|
||||
ORDER BY e.id ASC""", (section['id'],)):
|
||||
latest[ev['listing_id']] = ev['action']
|
||||
for action in latest.values():
|
||||
if action == 'like':
|
||||
counts['likes'] += 1
|
||||
elif item['decision'] == 'maybe':
|
||||
elif action == 'maybe':
|
||||
counts['maybes'] += 1
|
||||
elif item['decision'] == 'nope':
|
||||
elif action == 'nope':
|
||||
counts['nopes'] += 1
|
||||
restruck = conn.execute(
|
||||
"""SELECT COUNT(DISTINCT e.listing_id) AS n FROM swipe_events e
|
||||
@@ -457,8 +543,9 @@ def maybe_exhaust(conn, section, now):
|
||||
"""Flip an all-decided open section to 'report' (returns the fresh row)."""
|
||||
if section['status'] != 'open':
|
||||
return section
|
||||
decided_ids = section_decided_ids(conn, section)
|
||||
items = section_items(conn, section)
|
||||
if all(it['decision'] is not None for it in items):
|
||||
if items and not [it for it in items if it['id'] not in decided_ids]:
|
||||
close_section(conn, section, now, status='report')
|
||||
return conn.execute('SELECT * FROM sections WHERE id=?',
|
||||
(section['id'],)).fetchone()
|
||||
@@ -469,7 +556,8 @@ def read_section(conn, section, now):
|
||||
"""Meta + items + progress + exhausted for GET /api/section."""
|
||||
section = maybe_exhaust(conn, section, now)
|
||||
items = section_items(conn, section)
|
||||
decided = sum(1 for it in items if it['decision'] is not None)
|
||||
decided_ids = section_decided_ids(conn, section)
|
||||
decided = sum(1 for it in items if it['id'] in decided_ids)
|
||||
return {
|
||||
'section': {
|
||||
'id': section['id'],
|
||||
|
||||
927
app/selfcheck.py
927
app/selfcheck.py
File diff suppressed because it is too large
Load Diff
@@ -33,7 +33,8 @@ header{height:calc(50px + env(safe-area-inset-top,0px));display:flex;align-items
|
||||
.card{position:absolute;left:14px;right:14px;top:6px;bottom:34px;border-radius:18px;overflow:hidden;background:var(--card);
|
||||
box-shadow:0 0 0 1px rgba(255,255,255,.07), 0 18px 40px rgba(0,0,0,.5);will-change:transform;touch-action:none}
|
||||
.nophoto{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;background:repeating-linear-gradient(45deg,#141419 0 14px,#18181f 14px 28px);color:#55555f;font-size:13px;text-align:center;padding:24px;line-height:1.6}
|
||||
.card .photo{position:absolute;inset:0;width:100%;height:100%;object-fit:cover}
|
||||
.card .photo{position:absolute;inset:0;width:100%;height:100%;object-fit:contain;filter:drop-shadow(0 6px 24px rgba(0,0,0,.45))}
|
||||
.phblur{position:absolute;inset:-18px;background-size:cover;background-position:center;background-repeat:no-repeat;filter:blur(22px) brightness(.55) saturate(1.1);transform:scale(1.08);pointer-events:none}
|
||||
.card .grad{position:absolute;left:0;right:0;bottom:0;height:52%;background:linear-gradient(180deg,rgba(0,0,0,0) 0%,rgba(0,0,0,.55) 55%,rgba(0,0,0,.88) 100%)}
|
||||
.card .info{position:absolute;left:16px;right:16px;bottom:14px;z-index:3}
|
||||
.chips{display:flex;gap:6px;margin-bottom:8px;flex-wrap:wrap}
|
||||
@@ -66,8 +67,9 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
.dgrab{flex:none;height:26px;display:flex;align-items:center;justify-content:center;background:#0f0f13;cursor:grab;touch-action:none}
|
||||
.dgrab i{width:42px;height:5px;border-radius:3px;background:rgba(255,255,255,.3);display:block}
|
||||
.dclose{position:absolute;top:38px;left:14px;width:36px;height:36px;border-radius:50%;background:rgba(0,0,0,.55);color:#fff;border:0;font-size:17px;z-index:5;cursor:pointer}
|
||||
.dhero{position:relative;height:34%;min-height:190px;flex:none;background:#17171c;touch-action:none}
|
||||
.dphoto{width:100%;height:100%;object-fit:cover;display:block}
|
||||
.dhero{position:relative;height:34%;min-height:190px;flex:none;background:#17171c;touch-action:none;overflow:hidden}
|
||||
.dblur{position:absolute;inset:-18px;background-size:cover;background-position:center;background-repeat:no-repeat;filter:blur(22px) brightness(.55) saturate(1.1);transform:scale(1.08);pointer-events:none}
|
||||
.dphoto{width:100%;height:100%;object-fit:contain;display:block;filter:drop-shadow(0 6px 24px rgba(0,0,0,.45))}
|
||||
.dphoto.ph{opacity:.25}
|
||||
.dherograd{position:absolute;left:0;right:0;bottom:0;height:70px;background:linear-gradient(transparent,rgba(15,15,19,.95))}
|
||||
.dbody{flex:1;overflow-y:auto;padding:14px 18px 20px}
|
||||
@@ -95,6 +97,10 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
.empty{position:absolute;inset:6px 14px 2px;display:none;flex-direction:column;align-items:center;justify-content:center;gap:8px;border:1px dashed #2a2a33;border-radius:18px;color:var(--mut);text-align:center;padding:24px;font-size:13.5px}
|
||||
.empty.on{display:flex}
|
||||
.empty b{color:#fff;font-size:16px}
|
||||
/* item 8: loud exhausted state — section mode only (legacy .empty stays) */
|
||||
.empty2{position:absolute;inset:6px 14px 2px;display:none;flex-direction:column;align-items:center;justify-content:center;gap:10px;border:1px dashed #4a4a55;border-radius:18px;background:#141419;color:var(--mut);text-align:center;padding:32px;font-size:14px;min-height:220px;z-index:3}
|
||||
.empty2.on{display:flex}
|
||||
.empty2 b{color:#fff;font-size:22px;font-weight:800}
|
||||
/* list screen */
|
||||
.list{position:absolute;inset:0;display:none;flex-direction:column;background:var(--bg);z-index:50;padding-bottom:68px}
|
||||
.list.on{display:flex}
|
||||
@@ -138,7 +144,8 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
.sect.hot{color:var(--accent1)}
|
||||
.band{position:absolute;top:12px;left:12px;z-index:4;max-width:78%;font-size:11px;font-weight:650;letter-spacing:.4px;border-radius:999px;padding:4px 9px;pointer-events:none;line-height:1.35;user-select:none}
|
||||
.band.wild{color:#ffb43a;background:rgba(255,180,58,.14);border:1px solid rgba(255,180,58,.35)}
|
||||
.band.sl{color:rgba(255,255,255,.85);background:rgba(255,255,255,.10);border:1px solid rgba(255,255,255,.22)}
|
||||
.band.sl{color:#c4b5fd;background:rgba(124,58,237,.22);border:1px solid rgba(167,139,250,.65);font-weight:800}
|
||||
.dband{position:static;display:inline-block;margin-top:6px}
|
||||
.report{position:absolute;inset:6px 14px 2px;display:none;flex-direction:column;align-items:center;justify-content:center;gap:8px;border:1px dashed #2a2a33;border-radius:18px;color:var(--mut);text-align:center;padding:24px;font-size:13.5px;z-index:3}
|
||||
.report.on{display:flex}
|
||||
.report b{color:#fff;font-size:16px}
|
||||
@@ -181,6 +188,21 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
.trow span{cursor:pointer}
|
||||
.trow i{color:#4a4a55;font-style:normal;cursor:default}
|
||||
.tmuted{font-size:12px;color:#6f6f7a;margin:10px 18px 20px}
|
||||
/* B1 §11 — photo galleries: segments, tap zones, fullscreen viewer */
|
||||
.segments{position:absolute;top:8px;left:50%;transform:translateX(-50%);display:flex;gap:4px;z-index:4;pointer-events:none}
|
||||
.segments i{width:22px;height:3px;border-radius:2px;background:rgba(255,255,255,.35);transition:background .15s}
|
||||
.segments i.on{background:#fff}
|
||||
.card.hasSegs .band{top:22px} /* §11.2 amendment: bands drop below the bars */
|
||||
.vback{position:absolute;inset:0;z-index:71;background:rgba(0,0,0,.45);opacity:0;pointer-events:none;transition:opacity .28s}
|
||||
.vback.on{opacity:1;pointer-events:auto}
|
||||
.viewer{position:absolute;top:26px;left:0;right:0;bottom:0;z-index:72;background:#0b0b0f;display:flex;flex-direction:column;border-radius:18px 18px 0 0;box-shadow:0 -14px 40px rgba(0,0,0,.5);transform:translateY(103%);transition:transform .3s cubic-bezier(.2,.8,.3,1);overflow:hidden}
|
||||
.viewer.on{transform:translateY(0)}
|
||||
.vgrab{flex:none;height:26px;display:flex;align-items:center;justify-content:center;cursor:grab;touch-action:none}
|
||||
.vgrab i{width:42px;height:5px;border-radius:3px;background:rgba(255,255,255,.3);display:block}
|
||||
.vclose{position:absolute;top:38px;left:14px;width:36px;height:36px;border-radius:50%;background:rgba(0,0,0,.55);color:#fff;border:0;font-size:16px;z-index:6;cursor:pointer;display:flex;align-items:center;justify-content:center}
|
||||
.vphoto{position:relative;flex:1;min-height:0;overflow:hidden;touch-action:none}
|
||||
.vimg{position:absolute;inset:0;width:100%;height:100%;object-fit:contain;transform-origin:center center}
|
||||
.viewer .segments{top:34px}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
@@ -195,6 +217,7 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
|
||||
<div class="stage" id="stage">
|
||||
<div class="empty" id="empty"><b>You're all caught up.</b>New bikes arrive nightly — next import 08:30.<br>↺ brings the last card back.</div>
|
||||
<div class="empty2" id="empty2"><b>No more new bikes!</b>New bikes arrive nightly — next import 08:30.<br>↺ brings the last card back.</div>
|
||||
<div class="report" id="report">
|
||||
<b>Section complete.</b>
|
||||
<div id="repCounts"></div>
|
||||
@@ -202,6 +225,7 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
<div id="repLine2"></div>
|
||||
<button class="rforge" id="btnForge">Forge next 25</button>
|
||||
<div class="rstatus" id="forgeStatus"></div>
|
||||
<div class="rcap" id="dryCap" style="display:none">Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks</div>
|
||||
<div class="rmode" id="modeRow">
|
||||
<span id="modeOnd" class="on">on demand</span><i class="sep">⇄</i><span id="modeStr">strict</span>
|
||||
<div class="rcap" id="strictCap" style="display:none">Waiting for the nightly read — next section after the agent runs.</div>
|
||||
@@ -227,11 +251,12 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
<div class="detail" id="detail">
|
||||
<div class="dgrab" id="dgrab"><i></i></div>
|
||||
<button class="dclose" id="dclose">⌄</button>
|
||||
<div class="dhero"><img class="dphoto" id="dphoto" alt=""><div class="dherograd"></div></div>
|
||||
<div class="dhero"><div class="dblur" id="dblur"></div><img class="dphoto" id="dphoto" alt=""><div class="dherograd"></div></div>
|
||||
<div class="dbody" id="dbody">
|
||||
<div class="dtitle" id="dtitle"></div>
|
||||
<div class="drow"><div class="dprice" id="dprice"></div><div class="dsub" id="dsub"></div></div>
|
||||
<div class="dchips" id="dchips"></div>
|
||||
<div class="band dband" id="dband" style="display:none"></div>
|
||||
<div class="drank" id="drank" style="display:none">
|
||||
<div class="tankwrap" id="drankTank"></div>
|
||||
<div style="flex:1;min-width:0">
|
||||
@@ -253,6 +278,14 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="vback" id="vback"></div>
|
||||
<div class="viewer" id="viewer">
|
||||
<div class="vgrab" id="vgrab"><i></i></div>
|
||||
<button class="vclose" id="vclose">✕</button>
|
||||
<div class="segments" id="vsegs"></div>
|
||||
<div class="vphoto" id="vphoto"><img class="vimg" id="vimg" alt="" draggable="false"></div>
|
||||
</div>
|
||||
|
||||
<div class="list" id="listScreen">
|
||||
<div class="lhead"><h1>All bikes</h1><div class="sub" id="lsub">—</div></div>
|
||||
<input class="search" id="lsearch" type="search" placeholder="Search titles" autocomplete="off">
|
||||
@@ -296,6 +329,7 @@ nav{height:calc(68px + env(safe-area-inset-bottom,0px));display:flex;align-items
|
||||
<div class="tstatus" id="runStatus"></div>
|
||||
</div>
|
||||
<div class="trow"><span>Forge:</span><span id="tOnd" class="on">on demand</span><i>⇄</i><span id="tStr">strict</span></div>
|
||||
<div class="trow"><span>Why breakdown:</span><span id="tRubOff" class="on">off</span><i>⇄</i><span id="tRubOn">on</span></div>
|
||||
<div class="tmuted" id="tLastRun"></div>
|
||||
</div>
|
||||
</div>
|
||||
@@ -332,12 +366,18 @@ async function getJSON(url){
|
||||
/* swipe persistence: optimistic, never waits; failures retry 2s/5s/10s then
|
||||
every 15s while the tab lives. Last write per listing wins; the queue runs
|
||||
serially so reorderings can't land out of sequence. */
|
||||
const pend=new Map(); // listing_id -> {act, secId, fails, warned}
|
||||
const pend=new Map(); // listing_id -> {act, secId, photoIdx, fails, warned}
|
||||
let qRunning=false, qTimer=null, qWarned=false;
|
||||
function enqueue(listingId, act, secId=null){ // act: 'like'|'nope'|'maybe'|null (delete)
|
||||
pend.set(listingId,{act,secId,fails:0});
|
||||
function enqueue(listingId, act, secId=null, photoIdx=null){ // act: 'like'|'nope'|'maybe'|null (delete)
|
||||
pend.set(listingId,{act,secId,photoIdx,fails:0});
|
||||
scheduleQueue();
|
||||
}
|
||||
function swipeBody(id, act, secId, photoIdx){
|
||||
const b={listing_id:id,action:act};
|
||||
if(secId!=null) b.section_id=secId;
|
||||
if(photoIdx!=null) b.photo_idx=photoIdx; // B1 §11.5: photo on screen at strike
|
||||
return b;
|
||||
}
|
||||
function queDelay(op){ return op.fails===1?2000:op.fails===2?5000:op.fails===3?10000:15000; }
|
||||
function scheduleQueue(){
|
||||
if(qRunning||!pend.size||qTimer) return;
|
||||
@@ -355,7 +395,7 @@ async function runQueue(){
|
||||
try{
|
||||
const res= p.act==null
|
||||
? await fetch('/api/swipe/'+id,{method:'DELETE'})
|
||||
: await fetch('/api/swipe',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(p.secId?{listing_id:id,action:p.act,section_id:p.secId}:{listing_id:id,action:p.act})});
|
||||
: await fetch('/api/swipe',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(swipeBody(id,p.act,p.secId,p.photoIdx))});
|
||||
if(res.ok){ pend.delete(id); }
|
||||
else { p.fails++; if(!qWarned){ qWarned=true; toast("Couldn't save — retrying"); } minDelay=Math.max(minDelay,queDelay(p)); }
|
||||
}catch(e){
|
||||
@@ -371,10 +411,11 @@ async function runQueue(){
|
||||
progress stays correct while the persistence queue is mid-flight. */
|
||||
const localDecisions=new Map(); // listing_id -> action|null
|
||||
let lastResyncAt=0;
|
||||
function setDecision(id, act, secId=null){
|
||||
function setDecision(id, act, secId=null, photoIdx=null){
|
||||
localDecisions.set(id, act);
|
||||
updateRowDecision(id, act); // optimistic paint
|
||||
enqueue(id, act, secId);
|
||||
enqueue(id, act, secId, photoIdx);
|
||||
refreshStats(); // v1.1.1 (#2): every decision change nudges the header counters
|
||||
}
|
||||
|
||||
/* ---------- payload -> display helpers ---------- */
|
||||
@@ -450,20 +491,93 @@ function setStamps(el,a,b,c){
|
||||
el.querySelector('.stamp.nope').style.opacity=b;
|
||||
el.querySelector('.stamp.maybe').style.opacity=c;
|
||||
}
|
||||
function bandHTML(item){ // P3 system bands — the ONLY card-face additions
|
||||
if(item.slot==='wildcard') return `<div class="band wild">WILDCARD · maybe you’ll like this one instead</div>`;
|
||||
function bandLabel(item){ // P3 system bands — text for card + dossier
|
||||
if(item.slot==='wildcard') return 'WILDCARD · maybe you’ll like this one instead';
|
||||
if(item.slot==='return'){
|
||||
const verb= item.decision==='like'?'liked':item.decision==='maybe'?'maybed':item.decision==='nope'?'noped':'seen';
|
||||
return `<div class="band sl">SECOND LOOK — you ${verb} this</div>`;
|
||||
return 'SECOND LOOK — you '+verb+' this';
|
||||
}
|
||||
return '';
|
||||
}
|
||||
function bandHTML(item){ // card face only
|
||||
const lbl=bandLabel(item);
|
||||
if(!lbl) return '';
|
||||
return `<div class="band${item.slot==='wildcard'?' wild':' sl'}">${lbl}</div>`;
|
||||
}
|
||||
/* ---------- B1 §11: photo galleries ---------- */
|
||||
function nPhotos(it){ // payload n_photos; tolerant of old APIs
|
||||
const n= it&&typeof it.n_photos==='number'?it.n_photos:(it&&it.img?1:0);
|
||||
return Math.max(0, Math.trunc(n));
|
||||
}
|
||||
function leadFor(it){ // §11.5 repeat rotation: (last+1) % n
|
||||
const n=nPhotos(it);
|
||||
if(n<2) return 0;
|
||||
const li=it.last_photo_idx;
|
||||
if(!Number.isInteger(li)||li<0) return 0;
|
||||
return (li+1)%n;
|
||||
}
|
||||
function photoSrc(it,i){ if(!it||!it.img) return null; return i>0?('/img/'+it.id+'?i='+i):it.img; }
|
||||
function segBars(n,cur){ // the <i> bars only (no wrapper)
|
||||
let h='';
|
||||
for(let k=0;k<n;k++) h+=`<i${k===cur?' class="on"':''}></i>`;
|
||||
return h;
|
||||
}
|
||||
function segHTML(n,cur){
|
||||
if(!n||n<2) return '';
|
||||
return `<div class="segments">${segBars(n,cur)}</div>`;
|
||||
}
|
||||
function escAttr(s){ return String(s).replace(/&/g,'&').replace(/"/g,'"').replace(/'/g,'''); }
|
||||
function phwrapHTML(src){
|
||||
const img=src?`<div class="phblur" style="background-image:url('${escAttr(src)}')"></div><img class="photo" src="${escAttr(src)}" alt="" draggable="false">`:`<div class="nophoto">Photo pending — thumbnail backfill queued</div>`;
|
||||
return `<div class="phwrap">${img}</div>`;
|
||||
}
|
||||
function attachPhError(entry){
|
||||
const wrap=entry.el.querySelector('.phwrap');
|
||||
const im=wrap.querySelector('img');
|
||||
if(im) im.addEventListener('error',()=>{ wrap.innerHTML='<div class="nophoto">Photo pending — thumbnail backfill queued</div>'; });
|
||||
}
|
||||
function paintSegs(entry){
|
||||
const segs=entry.el.querySelector('.segments');
|
||||
if(segs) [...segs.children].forEach((x,k)=>x.classList.toggle('on',k===(entry.cur||0)));
|
||||
}
|
||||
/* §11.2 flip — instant, clamped at the ends (no wrap), commits nothing */
|
||||
function flipCard(entry,dir){
|
||||
const n=nPhotos(entry.d);
|
||||
if(n<2) return;
|
||||
const cur=(entry.cur||0)+dir;
|
||||
if(cur<0||cur>=n) return;
|
||||
entry.cur=cur;
|
||||
const wrap=entry.el.querySelector('.phwrap');
|
||||
wrap.innerHTML= phwrapHTML(photoSrc(entry.d,cur));
|
||||
attachPhError(entry);
|
||||
paintSegs(entry);
|
||||
preloadPhotos();
|
||||
}
|
||||
/* §11.6 preload: top card's next photo + next card's lead photo, off-path */
|
||||
function preloadPhotos(){
|
||||
pile.slice(0,2).forEach((entry,pos)=>{
|
||||
const d=entry.d;
|
||||
if(!d) return;
|
||||
const targets= pos===0
|
||||
? ((()=>{ const n=nPhotos(d); const nx=(entry.cur||0)+1;
|
||||
return (n>1&&nx<n)?[photoSrc(d,nx)]:[]; })())
|
||||
: [photoSrc(d,leadFor(d))];
|
||||
for(const s of targets){
|
||||
if(!s) continue;
|
||||
const im=new Image(); im.decoding='async'; im.src=s;
|
||||
}
|
||||
});
|
||||
}
|
||||
function cardNode(item){
|
||||
const el=document.createElement('div');
|
||||
el.className='card';
|
||||
el.innerHTML=`${item.img?`<img class="photo" src="${item.img}" alt="" draggable="false">`:`<div class="nophoto">Photo pending — thumbnail backfill queued</div>`}
|
||||
const n=nPhotos(item);
|
||||
const lead=leadFor(item);
|
||||
if(n>=2) el.classList.add('hasSegs');
|
||||
el.innerHTML=`${phwrapHTML(photoSrc(item,lead))}
|
||||
<div class="grad"></div>
|
||||
${bandHTML(item)}
|
||||
${segHTML(n,lead)}
|
||||
<div class="stamp like">LIKE</div>
|
||||
<div class="stamp nope">NOPE</div>
|
||||
<div class="stamp maybe">MAYBE</div>
|
||||
@@ -474,11 +588,8 @@ function cardNode(item){
|
||||
info.querySelector('.title').textContent=item.title||'';
|
||||
info.querySelector('.price').textContent=priceFor(item);
|
||||
info.querySelector('.sub').textContent=subFor(item);
|
||||
const ph=el.querySelector('.photo');
|
||||
if(ph) ph.addEventListener('error',()=>{
|
||||
ph.remove();
|
||||
el.insertAdjacentHTML('afterbegin','<div class="nophoto">Photo pending — thumbnail backfill queued</div>');
|
||||
});
|
||||
const entry={d:item,el,cur:lead};
|
||||
attachPhError(entry);
|
||||
el.addEventListener('pointerdown',down);
|
||||
el.addEventListener('pointermove',move);
|
||||
el.addEventListener('pointerup',upH);
|
||||
@@ -486,7 +597,7 @@ function cardNode(item){
|
||||
const ib=el.querySelector('.ibtn');
|
||||
ib.addEventListener('pointerdown',e=>e.stopPropagation());
|
||||
ib.addEventListener('click',e=>{ e.stopPropagation(); if(isTop(el)) openDetail(item,{type:'deck'}); });
|
||||
return {d:item,el};
|
||||
return entry;
|
||||
}
|
||||
function layer(el,d,anim){
|
||||
el.classList.toggle('topcard',d===0);
|
||||
@@ -511,6 +622,7 @@ function fillPile(){
|
||||
layer(entry.el,d,true);
|
||||
}
|
||||
relayer();
|
||||
preloadPhotos();
|
||||
}
|
||||
/* deck feed: P3 sections (pinned order) with a legacy /api/deck fallback */
|
||||
async function loadDeck(){ // legacy cursor feed (pre-P3 API)
|
||||
@@ -549,10 +661,17 @@ async function loadSection(){
|
||||
buffer.push(...fresh);
|
||||
fillPile();
|
||||
updateSectionUI(body);
|
||||
refreshStats(); // v1.1.1 (#2): a new batch landed — freshen the counters
|
||||
}catch(e){ setTimeout(()=>loadSection(),15000); }
|
||||
finally{ deckLoading=false; }
|
||||
maybeRefill();
|
||||
}
|
||||
/* item 8: the deck can serve nothing at all (pool all-zero) -> loud empty */
|
||||
function poolDead(){
|
||||
return !!(section && section.pool
|
||||
&& section.pool.fresh===0 && section.pool.returns===0
|
||||
&& section.pool.wildcards===0);
|
||||
}
|
||||
function maybeRefill(){
|
||||
if(legacyMode){
|
||||
if(buffer.length<DEPTH&&deckCursor&&!deckLoaded) loadDeck();
|
||||
@@ -560,23 +679,31 @@ function maybeRefill(){
|
||||
return;
|
||||
}
|
||||
if(!pile.length&&!buffer.length&&!deckLoading){
|
||||
if(section&§Decided>=sectTotal){
|
||||
if(poolDead()){
|
||||
// nothing to serve at all: the loud empty owns the stage (no report)
|
||||
$('empty2').classList.add('on');
|
||||
$('report').classList.remove('on');
|
||||
$('empty').classList.remove('on');
|
||||
}else if(section&§Decided>=sectTotal){
|
||||
// locally exhausted (last POSTs may still be flushing — the report
|
||||
// shows from localDecisions; a quiet resync freshens counts and the
|
||||
// server's report flip, rate-limited so a failing last POST can't
|
||||
// cause a resync loop)
|
||||
$('report').classList.add('on');
|
||||
$('empty').classList.remove('on');
|
||||
$('empty2').classList.remove('on');
|
||||
if(!section.exhausted&&Date.now()-lastResyncAt>2000){
|
||||
lastResyncAt=Date.now();
|
||||
loadSection();
|
||||
}
|
||||
}else if(section){
|
||||
$('empty').classList.remove('on'); $('report').classList.remove('on');
|
||||
$('empty2').classList.remove('on');
|
||||
}
|
||||
}else{
|
||||
$('empty').classList.remove('on');
|
||||
$('report').classList.remove('on');
|
||||
$('empty2').classList.remove('on');
|
||||
}
|
||||
}
|
||||
|
||||
@@ -586,8 +713,9 @@ function commit(el,dir){
|
||||
const t=pile.shift();
|
||||
hist.push(t.d);
|
||||
const act= dir==='maybe'?'maybe':dir;
|
||||
setDecision(t.d.id, act, (!legacyMode&§ion&&!section.exhausted)?section.section.id:null);
|
||||
sectDecided++;
|
||||
setDecision(t.d.id, act, (!legacyMode&§ion&&!section.exhausted)?section.section.id:null,
|
||||
nPhotos(t.d)>1?(t.cur||0):null); // B1: photo on screen at strike
|
||||
sectDecided=Math.min(sectTotal, sectDecided+1); // clamp: never past the total
|
||||
paintSect();
|
||||
flyOut(el,dir);
|
||||
fillPile(); relayer();
|
||||
@@ -620,8 +748,10 @@ function undo(){
|
||||
if(pile.length>DEPTH){ const drop=pile.pop(); drop.el.remove(); buffer.unshift(drop.d); }
|
||||
void entry.el.offsetWidth;
|
||||
relayer();
|
||||
preloadPhotos();
|
||||
$('empty').classList.remove('on');
|
||||
$('report').classList.remove('on');
|
||||
$('empty2').classList.remove('on');
|
||||
}
|
||||
$('btnLike').onclick=()=>{ if(pile[0]) commit(pile[0].el,'like'); };
|
||||
$('btnNope').onclick=()=>{ if(pile[0]) commit(pile[0].el,'nope'); };
|
||||
@@ -654,21 +784,48 @@ function upH(e){
|
||||
if(dx>w*0.35) commit(el,'like');
|
||||
else if(dx<-w*0.35) commit(el,'nope');
|
||||
else if(dy<-140) commit(el,'maybe');
|
||||
else { el.style.transform=''; setStamps(el,0,0,0); if(!moved && e.type==='pointerup' && isTop(el)) openDetail(pile[0].d,{type:'deck'}); }
|
||||
else { el.style.transform=''; setStamps(el,0,0,0); if(!moved && e.type==='pointerup' && isTop(el)) tapZone(pile[0],e); }
|
||||
}
|
||||
/* §11.4 v1.1 tap zones: sides flip (clamped), CENTER = dossier (bike data
|
||||
first — the old center-tap→fullscreen and tap-anywhere→dossier gestures
|
||||
are retired). The deck dossier remembers its pile entry so a viewer
|
||||
opened from its hero walks back to it on Esc. */
|
||||
function tapZone(entry,e){
|
||||
const r=stage.getBoundingClientRect();
|
||||
const rel=e.clientX-r.left, w=r.width||360;
|
||||
if(rel>=w/3 && rel<=w*2/3){
|
||||
dEntry=entry; // live pile entry (cur photo index)
|
||||
openDetail(entry.d,{type:'deck'});
|
||||
}else{
|
||||
flipCard(entry, rel<w/3?-1:1); // no-ops on single/no-photo cards
|
||||
}
|
||||
}
|
||||
|
||||
/* ---------- docs/mockup core: fullscreen dossier ---------- */
|
||||
let dCtx=null;
|
||||
let dData=null; // B1: dossier payload (hero -> viewer)
|
||||
let dEntry=null; // v1.1: pile entry when opened from the deck
|
||||
function openDetail(data,ctx){
|
||||
dCtx=ctx||null;
|
||||
dData=data;
|
||||
dEntry=null; // only tapZone re-sets it (deck path)
|
||||
const ph=$('dphoto');
|
||||
if(data.img){ ph.src=data.img; ph.classList.remove('ph'); }
|
||||
else { ph.removeAttribute('src'); ph.classList.add('ph'); }
|
||||
ph.onerror=()=>{ ph.removeAttribute('src'); ph.classList.add('ph'); };
|
||||
const blur=$('dblur');
|
||||
if(data.img){ ph.src=data.img; ph.classList.remove('ph'); blur.style.backgroundImage='url("'+data.img+'")'; }
|
||||
else { ph.removeAttribute('src'); ph.classList.add('ph'); blur.style.backgroundImage='none'; }
|
||||
ph.onerror=()=>{ ph.removeAttribute('src'); ph.classList.add('ph'); blur.style.backgroundImage='none'; };
|
||||
$('dtitle').textContent=data.title||'';
|
||||
$('dprice').textContent=priceFor(data);
|
||||
$('dsub').textContent=subFor(data);
|
||||
$('dchips').innerHTML=cardChips(data).map(x=>`<span class="chip">${x}</span>`).join('');
|
||||
// item 10: the card band mirrors into the info view (violet SL / amber wild)
|
||||
const db=$('dband');
|
||||
const bl=bandLabel(data);
|
||||
if(bl){
|
||||
db.className='band'+(data.slot==='wildcard'?' wild':' sl')+' dband';
|
||||
db.textContent=bl;
|
||||
db.style.display='inline-block';
|
||||
}else{ db.style.display='none'; }
|
||||
const rows=[
|
||||
["Year",data.year!=null?String(data.year):null],
|
||||
["Odometer",data.km!=null?(fmtNum(data.km)+' km'):null],
|
||||
@@ -687,7 +844,9 @@ function openDetail(data,ctx){
|
||||
$('detail').classList.add('on'); $('dback').classList.add('on');
|
||||
$('dbody').scrollTop=0;
|
||||
}
|
||||
/* P3 dossier rank block: gauge + points + strongest ± lines + audit footer */
|
||||
/* P3 dossier rank block: gauge + points% minimal; the full "why" breakdown
|
||||
and the audit footer render only when prefs.rubric_debug === 'on' (§10.5). */
|
||||
function rubricOn(){ return !!(section&§ion.prefs&§ion.prefs.rubric_debug==='on'); }
|
||||
function fillRank(data){
|
||||
if(!data||data.tank==null||data.tank.value==null){
|
||||
$('drank').style.display='none';
|
||||
@@ -695,33 +854,47 @@ function fillRank(data){
|
||||
}
|
||||
$('drank').style.display='flex';
|
||||
$('drankTank').innerHTML=tankSVG(data.tank,true);
|
||||
$('dpts').textContent=data.tank.value+'/100';
|
||||
const lines=(data.points_breakdown||[]).slice()
|
||||
.sort((a,b)=>Math.abs(b.value)-Math.abs(a.value)).slice(0,4);
|
||||
$('dlines').innerHTML=lines.map(l=>{
|
||||
const lbl= l.source==='agent'?('agent: '+l.label):l.label;
|
||||
const n= l.value>=0?(' +'+l.value):(' '+l.value);
|
||||
return `<div class="${l.value>=0?'pos':'neg'}">· ${lbl}${n}</div>`;
|
||||
}).join('');
|
||||
const ri= section&§ion.read_info;
|
||||
$('dfoot').textContent= ri?`from ${ri.events} strikes · read ${relTime(ri.profile_at)}`:'';
|
||||
// list/matches payloads carry no breakdown — fill it on the quiet
|
||||
if(!data.points_breakdown&&data.id&&!legacyMode){
|
||||
getJSON('/api/listing/'+data.id).then(full=>{
|
||||
if(full&&full.points_breakdown&&dCtx) fillRank(full);
|
||||
});
|
||||
$('dpts').textContent=(data.tank.value|0)+'%';
|
||||
if(rubricOn()){
|
||||
const lines=(data.points_breakdown||[]).slice()
|
||||
.sort((a,b)=>Math.abs(b.value)-Math.abs(a.value)).slice(0,4);
|
||||
$('dlines').innerHTML=lines.map(l=>{
|
||||
const lbl= l.source==='agent'?('agent: '+l.label):l.label;
|
||||
const n= l.value>=0?(' +'+l.value):(' '+l.value);
|
||||
return `<div class="${l.value>=0?'pos':'neg'}">· ${lbl}${n}</div>`;
|
||||
}).join('');
|
||||
const ri= section&§ion.read_info;
|
||||
$('dfoot').textContent= ri?`from ${ri.events} strikes · read ${relTime(ri.profile_at)}`:'';
|
||||
// list/matches payloads carry no breakdown — fill it on the quiet
|
||||
if(!data.points_breakdown&&data.id&&!legacyMode){
|
||||
getJSON('/api/listing/'+data.id).then(full=>{
|
||||
if(full&&full.points_breakdown&&dCtx) fillRank(full);
|
||||
});
|
||||
}
|
||||
}else{
|
||||
// minimal display: gauge + % only; skip the quiet enrichment fetch
|
||||
$('dlines').innerHTML='';
|
||||
$('dfoot').textContent='';
|
||||
}
|
||||
}
|
||||
function closeDetail(){ const d=$('detail'); d.style.transition=''; d.style.transform=''; d.classList.remove('on'); $('dback').classList.remove('on'); dCtx=null; }
|
||||
function closeDetail(){ const d=$('detail'); d.style.transition=''; d.style.transform=''; d.classList.remove('on'); $('dback').classList.remove('on'); dCtx=null; dEntry=null; }
|
||||
$('dclose').onclick=closeDetail;
|
||||
$('dclose').addEventListener('pointerdown',e=>e.stopPropagation());
|
||||
/* pull-down-to-close (grabber bar + photo) */
|
||||
let dDragY=null;
|
||||
function dStart(e){ dDragY=e.clientY; $('detail').style.transition='none'; try{e.currentTarget.setPointerCapture(e.pointerId)}catch(_){} }
|
||||
let dDragY=null, heroTapped=false;
|
||||
function dStart(e){ heroTapped=false; dDragY=e.clientY; $('detail').style.transition='none'; try{e.currentTarget.setPointerCapture(e.pointerId)}catch(_){} }
|
||||
function dMoveH(e){ if(dDragY===null) return; const dy=Math.max(0,e.clientY-dDragY); $('detail').style.transform=`translateY(${dy}px)`; }
|
||||
function dEndH(e){ if(dDragY===null) return; const dy=Math.max(0,e.clientY-dDragY); dDragY=null;
|
||||
if(dy>110){ closeDetail(); }
|
||||
else { const d=$('detail'); d.style.transition='transform .25s cubic-bezier(.2,.8,.3,1)'; d.style.transform=''; } }
|
||||
else { const d=$('detail'); d.style.transition='transform .25s cubic-bezier(.2,.8,.3,1)'; d.style.transform='';
|
||||
heroTapped=e.type==='pointerup' && dy<=6 && e.currentTarget.classList.contains('dhero');
|
||||
} }
|
||||
/* Open on the completed click. Opening on touch pointerup puts the new
|
||||
backdrop under the finger just in time to receive the same tap's click. */
|
||||
document.querySelector('.dhero').addEventListener('click',()=>{
|
||||
if(heroTapped && dData && dData.img) openViewer(dData,0,{type:'dossier', backToDetail:dEntry});
|
||||
heroTapped=false;
|
||||
});
|
||||
[document.querySelector('.dgrab'),document.querySelector('.dhero')].forEach(el=>{ if(!el) return; el.addEventListener('pointerdown',dStart); el.addEventListener('pointermove',dMoveH); el.addEventListener('pointerup',dEndH); el.addEventListener('pointercancel',dEndH); });
|
||||
function dAction(a){
|
||||
const ctx=dCtx; closeDetail();
|
||||
@@ -736,6 +909,126 @@ function dAction(a){
|
||||
}
|
||||
$('dNo').onclick=()=>dAction('nope'); $('dMb').onclick=()=>dAction('maybe'); $('dLk').onclick=()=>dAction('like');
|
||||
|
||||
/* ---------- B1 §11.3: fullscreen viewer (swipe nav, pinch/double-tap zoom,
|
||||
✕ + pull-down close) — returns to the same card & photo position ---------- */
|
||||
let vCtx=null; // {item, idx, back} — deck cards untouched
|
||||
let vScale=1, vTx=0, vTy=0;
|
||||
let vDrag=null; // single-pointer gesture state
|
||||
const vPtrs=new Map(); // pointerId -> {x,y}
|
||||
let vPinch=null; // {d0, scale0}
|
||||
let vLastTap=0;
|
||||
function vCount(){ return vCtx&&vCtx.item?nPhotos(vCtx.item):0; }
|
||||
function vApply(){ if(!vCtx) return; if(vScale<=1){ vTx=0; vTy=0; } $('vimg').style.transform=`translate(${vTx}px,${vTy}px) scale(${vScale})`; }
|
||||
function vPaint(){
|
||||
const item=vCtx.item, i=vCtx.idx, n=vCount();
|
||||
$('vsegs').innerHTML= n>=2?segBars(n,i):'';
|
||||
const im=$('vimg'), s=photoSrc(item,i);
|
||||
if(s){ im.src=s; im.style.opacity=1; }
|
||||
else { im.removeAttribute('src'); im.style.opacity=.25; }
|
||||
im.onerror=()=>{ im.style.opacity=.25; };
|
||||
vApply();
|
||||
}
|
||||
function openViewer(item, idx, back){
|
||||
const n=nPhotos(item);
|
||||
if(!n||!item||!item.img) return;
|
||||
vCtx={item, idx:Math.max(0,Math.min(idx||0,n-1)), back:back||null};
|
||||
vScale=1; vTx=0; vTy=0;
|
||||
vPaint();
|
||||
$('viewer').classList.add('on'); $('vback').classList.add('on');
|
||||
}
|
||||
function closeViewer(){
|
||||
const v=$('viewer');
|
||||
v.classList.remove('on'); $('vback').classList.remove('on');
|
||||
v.style.transition=''; v.style.transform='';
|
||||
vCtx=null; vPtrs.clear(); vPinch=null; vDrag=null;
|
||||
}
|
||||
/* v1.1 walk-back chain: when the viewer was reached from the deck dossier
|
||||
hero, Esc returns to the dossier (photo 0) instead of the deck. */
|
||||
function vWalkBack(){
|
||||
const back=vCtx&&vCtx.back;
|
||||
if(back&&back.backToDetail){
|
||||
const item=vCtx.item;
|
||||
closeViewer();
|
||||
openDetail(item, back.backToDetail);
|
||||
dEntry=back.backToDetail.entry||null; // keep the chain repeatable
|
||||
} else {
|
||||
closeViewer();
|
||||
}
|
||||
}
|
||||
$('vback').addEventListener('click',closeViewer);
|
||||
$('vclose').onclick=closeViewer;
|
||||
$('vclose').addEventListener('pointerdown',e=>e.stopPropagation());
|
||||
const vph=$('vphoto');
|
||||
function vDist(){
|
||||
const pts=[...vPtrs.values()];
|
||||
return pts.length>=2?Math.hypot(pts[0].x-pts[1].x,pts[0].y-pts[1].y):null;
|
||||
}
|
||||
vph.addEventListener('pointerdown',e=>{
|
||||
if(!vCtx) return;
|
||||
vPtrs.set(e.pointerId,{x:e.clientX,y:e.clientY});
|
||||
try{ vph.setPointerCapture(e.pointerId); }catch(_){}
|
||||
if(vPtrs.size===1){ vDrag={sx:e.clientX,sy:e.clientY,px:vTx,py:vTy,scale0:vScale,mode:null}; }
|
||||
else if(vPtrs.size===2){ vDrag=null; vPinch={d0:vDist()||1,scale0:vScale}; }
|
||||
});
|
||||
vph.addEventListener('pointermove',e=>{
|
||||
if(!vCtx) return;
|
||||
const pt=vPtrs.get(e.pointerId); if(pt){ pt.x=e.clientX; pt.y=e.clientY; }
|
||||
if(vPtrs.size>=2&&vPinch){
|
||||
const dd=vDist(); if(!dd) return;
|
||||
vScale=Math.max(1,Math.min(4,vPinch.scale0*dd/vPinch.d0)); // 1×–4×
|
||||
vApply(); return;
|
||||
}
|
||||
if(!vDrag) return;
|
||||
const dx=e.clientX-vDrag.sx, dy=e.clientY-vDrag.sy;
|
||||
if(!vDrag.mode){
|
||||
if(Math.abs(dx)<=6&&Math.abs(dy)<=6) return;
|
||||
vDrag.mode= vScale>1?'pan':(Math.abs(dx)>=Math.abs(dy)?'nav':'pull');
|
||||
}
|
||||
if(vDrag.mode==='pull'){
|
||||
const v=$('viewer'); v.style.transition='none';
|
||||
v.style.transform=`translateY(${Math.max(0,dy)}px)`;
|
||||
} else if(vDrag.mode==='nav'){
|
||||
vTx=Math.max(-70,Math.min(70,dx)); vApply(); // live edge-feedback
|
||||
} else { vTx=vDrag.px+dx; vTy=vDrag.py+dy; vApply(); } // pan while zoomed
|
||||
});
|
||||
function vUp(e){
|
||||
const wasDrag=vDrag, dx=wasDrag?e.clientX-wasDrag.sx:0, dy=wasDrag?e.clientY-wasDrag.sy:0;
|
||||
if(wasDrag&&vPtrs.size<=1){
|
||||
const mode=wasDrag.mode;
|
||||
if(mode==='pull'){
|
||||
if(dy>110){ closeViewer(); }
|
||||
else { const v=$('viewer'); v.style.transition='transform .25s cubic-bezier(.2,.8,.3,1)'; v.style.transform=''; }
|
||||
} else if(mode==='nav'){
|
||||
if(Math.abs(dx)>=50&&vCtx){
|
||||
const nx=vCtx.idx+(dx>0?-1:1); // clamp at the ends
|
||||
if(nx>=0&&nx<vCount()){ vCtx.idx=nx; vPaint(); }
|
||||
}
|
||||
vTx=0; vApply();
|
||||
} else if(mode==='pan'){
|
||||
// keep pan position
|
||||
} else if(e.type==='pointerup'){ // tap -> double-tap zoom toggle
|
||||
const now=Date.now();
|
||||
if(now-vLastTap<300){ vLastTap=0; vScale= vScale>1?1:2.5; vApply(); }
|
||||
else vLastTap=now;
|
||||
}
|
||||
vDrag=null;
|
||||
}
|
||||
vPtrs.delete(e.pointerId); vPinch=null;
|
||||
}
|
||||
vph.addEventListener('pointerup',vUp);
|
||||
vph.addEventListener('pointercancel',vUp);
|
||||
/* pull-down close from the grabber (the §3 idiom) */
|
||||
let vgY=null;
|
||||
function vgStart(e){ vgY=e.clientY; $('viewer').style.transition='none'; try{e.currentTarget.setPointerCapture(e.pointerId)}catch(_){} }
|
||||
function vgMove(e){ if(vgY===null) return; $('viewer').style.transform=`translateY(${Math.max(0,e.clientY-vgY)}px)`; }
|
||||
function vgEnd(e){ if(vgY===null) return; const dy=Math.max(0,e.clientY-vgY); vgY=null;
|
||||
if(dy>110){ closeViewer(); }
|
||||
else { const v=$('viewer'); v.style.transition='transform .25s cubic-bezier(.2,.8,.3,1)'; v.style.transform=''; } }
|
||||
$('vgrab').addEventListener('pointerdown',vgStart);
|
||||
$('vgrab').addEventListener('pointermove',vgMove);
|
||||
$('vgrab').addEventListener('pointerup',vgEnd);
|
||||
$('vgrab').addEventListener('pointercancel',vgEnd);
|
||||
|
||||
/* ---------- list screen (real filters + search) ---------- */
|
||||
let listItems=[];
|
||||
const listCtl={decision:'all',sort:'score',q:'',priceDir:1};
|
||||
@@ -792,10 +1085,14 @@ function renderList(){
|
||||
}
|
||||
/* optimistic decision updates for whichever screens show this listing */
|
||||
function updateRowDecision(id, act){
|
||||
const find=[listItems];
|
||||
for(const arr of find){
|
||||
const it=arr.find(x=>x.id===id);
|
||||
if(it) it.decision=act;
|
||||
const it=listItems.find(x=>x.id===id);
|
||||
if(it){
|
||||
it.decision=act;
|
||||
if(listCtl.decision!=='all' && listCtl.decision!==(act||'undecided')){
|
||||
listItems=listItems.filter(x=>x!==it);
|
||||
$('lrows').querySelector(`.row[data-i="${id}"]`)?.remove();
|
||||
if(!listItems.length) renderList(); // existing empty state
|
||||
}
|
||||
}
|
||||
const el=$('lrows').querySelector(`.rc[data-i="${id}"]`);
|
||||
if(el) el.querySelectorAll('.rbtn').forEach(b=>b.classList.toggle('on',b.dataset.s===act));
|
||||
@@ -822,7 +1119,6 @@ $('lrows').addEventListener('click',e=>{
|
||||
if(!it) return;
|
||||
const next= it.decision===s?null:s; // tapping the lit button clears
|
||||
setDecision(id,next);
|
||||
if(next===null && (listCtl.decision===s)) renderList(); // row leaves a filtered view
|
||||
});
|
||||
$('fdec').addEventListener('click',e=>{
|
||||
const chip=e.target.closest('.fchip'); if(!chip) return;
|
||||
@@ -908,20 +1204,34 @@ let badgeFired=false;
|
||||
async function loadStats(){
|
||||
const res=await getJSON('/api/stats');
|
||||
if(!res) return;
|
||||
$('pill').innerHTML=`<b>${res.live}</b> live`+(res.new>0?` · <b>${res.new}</b> new`:'');
|
||||
const fresh=typeof res.fresh==='number'?res.fresh:null; // old API: no segment
|
||||
$('pill').innerHTML=`<b>${res.live}</b> live${fresh!=null?` · <b>${fresh}</b> fresh`:''}`+(res.new>0?` · <b>${res.new}</b> new`:'');
|
||||
$('lsub').innerHTML=`${res.live} active · `+(res.new>0?`<b style="color:#fff">${res.new} new</b>`:res.new+' new')+' since your last visit';
|
||||
if(!badgeFired){
|
||||
badgeFired=true;
|
||||
fetch('/api/badge/seen',{method:'POST'}).catch(()=>{});
|
||||
}
|
||||
}
|
||||
/* v1.1.1 (issue #2): loadStats only ran at boot, so the header pill and the
|
||||
list sub-line went stale after every swipe until a full reload. Refresh
|
||||
shortly after any decision change (swipes, undo, dossier/list/matches
|
||||
edits) and whenever a new batch lands. Coalesced + fire-and-forget: a
|
||||
swipe never waits on it. */
|
||||
let statsTimer=null;
|
||||
function refreshStats(){
|
||||
if(statsTimer) return; // bursts collapse into one read
|
||||
statsTimer=setTimeout(()=>{ statsTimer=null; loadStats(); },600);
|
||||
}
|
||||
/* foreground/resume: catch anything that changed while the app slept
|
||||
(e.g. the 08:30 import) without waiting for the next swipe */
|
||||
document.addEventListener('visibilitychange',()=>{ if(!document.hidden) refreshStats(); });
|
||||
|
||||
/* ---------- P3 section UI: progress pill + report + forge + modes ---------- */
|
||||
let sectDecided=0, sectTotal=0;
|
||||
function paintSect(){
|
||||
const t=$('sect');
|
||||
if(legacyMode||!section){ t.textContent=''; return; }
|
||||
t.textContent=`${sectDecided}/${sectTotal}`;
|
||||
t.textContent=`${Math.min(sectDecided,sectTotal)}/${sectTotal}`; // clamp: never paints past the total
|
||||
t.classList.toggle('hot',sectDecided>=sectTotal);
|
||||
}
|
||||
function paintMode(){
|
||||
@@ -937,14 +1247,20 @@ function paintMode(){
|
||||
}
|
||||
function updateSectionUI(body){
|
||||
sectTotal=body.progress.total;
|
||||
// item 6: the dry-catalog caption rides every hydrate (legacy API -> absent)
|
||||
$('dryCap').style.display= dryLabel(body)?'':'none';
|
||||
let decided=0;
|
||||
for(const it of (body.items||[])){
|
||||
const local=localDecisions.get(it.id);
|
||||
if(local===undefined? it.decision!=null : local!=null) decided++;
|
||||
// item 5: server truth = decided DURING this section (an in-section
|
||||
// event), never the lifetime decision a second look wears into it;
|
||||
// local intent wins while a swipe's POST is in flight
|
||||
if(local===undefined? !!it.decided_this_section : local!=null) decided++;
|
||||
}
|
||||
sectDecided=decided;
|
||||
paintSect();
|
||||
paintMode();
|
||||
paintRubricMode();
|
||||
const c=body.counts||{};
|
||||
$('repCounts').innerHTML=`♥ ${c.likes||0} · ★ ${c.maybes||0} · ✕ ${c.nopes||0}`;
|
||||
const hits=[];
|
||||
@@ -958,6 +1274,28 @@ async function setMode(m){
|
||||
}
|
||||
$('modeOnd').onclick=()=>setMode('ondemand');
|
||||
$('modeStr').onclick=()=>setMode('strict');
|
||||
function paintRubricMode(){
|
||||
const on=rubricOn();
|
||||
$('tRubOff').classList.toggle('on',!on);
|
||||
$('tRubOn').classList.toggle('on',on);
|
||||
}
|
||||
async function setRubricDebug(m){
|
||||
const res=await fetch('/api/prefs',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({key:'rubric_debug',value:m})}).catch(()=>null);
|
||||
if(res&&res.ok){
|
||||
if(section){ section.prefs=section.prefs||{}; section.prefs.rubric_debug=m; }
|
||||
paintRubricMode();
|
||||
if(!legacyMode) loadSection(); // repaint any dossier already open
|
||||
}
|
||||
}
|
||||
$('tRubOff').onclick=()=>setRubricDebug('off');
|
||||
$('tRubOn').onclick=()=>setRubricDebug('on');
|
||||
/* item 6: dry catalog — a forged batch with zero fresh cards is labeled,
|
||||
never silent (BACKLOG "Dry-catalog messaging"). */
|
||||
const DRY_MSG='Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks';
|
||||
function dryLabel(body){
|
||||
return !!(body && body.recipe && body.recipe.new===0
|
||||
&& body.items && body.items.length>0);
|
||||
}
|
||||
$('btnForge').onclick=async()=>{
|
||||
if(forgeBusy||!section) return;
|
||||
forgeBusy=true;
|
||||
@@ -967,8 +1305,10 @@ $('btnForge').onclick=async()=>{
|
||||
const res=await fetch('/api/section/forge',{method:'POST',headers:{'Content-Type':'application/json'},body:'{}'});
|
||||
const body=await res.json();
|
||||
if(res.ok){
|
||||
$('forgeStatus').textContent= body.note&&body.note.indexOf('fallback')>=0
|
||||
?'Agent offline — forging on the last read.':'';
|
||||
$('forgeStatus').textContent= dryLabel(body)
|
||||
?DRY_MSG
|
||||
:(body.note&&body.note.indexOf('fallback')>=0
|
||||
?'Agent offline — forging on the last read.':'');
|
||||
section=body;
|
||||
buffer.length=0;
|
||||
const live=new Set([...pile.map(c=>c.d.id),...hist.map(h=>h.id)]);
|
||||
@@ -976,7 +1316,14 @@ $('btnForge').onclick=async()=>{
|
||||
buffer.push(...fresh);
|
||||
fillPile();
|
||||
updateSectionUI(body);
|
||||
refreshStats(); // v1.1.1 (#2): forged batch — freshen the counters
|
||||
if(pile.length){ $('report').classList.remove('on'); }
|
||||
// item 8: a zero-item forge on a fully drained catalog -> empty2,
|
||||
// no lone Forge button inviting a wasted agent run
|
||||
if((body.items||[]).length===0 && poolDead()){
|
||||
$('report').classList.remove('on');
|
||||
$('empty2').classList.add('on');
|
||||
}
|
||||
}else{
|
||||
$('forgeStatus').textContent= body.detail||'Forge failed';
|
||||
paintMode();
|
||||
@@ -1041,13 +1388,29 @@ document.querySelectorAll('.tab').forEach(t=>t.onclick=()=>{
|
||||
else if(name==='trends') fetchTrends();
|
||||
});
|
||||
|
||||
/* ---------- desktop keyboard arrows (DESIGN.md: v1 frontend) ---------- */
|
||||
/* ---------- v1.1 keyboard map (BACKLOG "Shortcuts"): ← nope · → like ·
|
||||
↑ maybe · ↓ undo · Backspace = undo alias (kept for muscle memory) ·
|
||||
Esc closes the top open sheet (viewer → dossier → deck). Arrows act only
|
||||
on the deck; text-input focus and open sheets swallow them; arrow-key
|
||||
defaults are prevented so no page scroll can fire. -------------------- */
|
||||
document.addEventListener('keydown',e=>{
|
||||
if(e.target.tagName==='INPUT'||$('detail').classList.contains('on')) return;
|
||||
if(e.key==='ArrowRight'){ if(pile[0]) commit(pile[0].el,'like'); }
|
||||
else if(e.key==='ArrowLeft'){ if(pile[0]) commit(pile[0].el,'nope'); }
|
||||
else if(e.key==='ArrowUp'){ if(pile[0]) commit(pile[0].el,'maybe'); }
|
||||
else if(e.key==='Backspace'){ undo(); }
|
||||
const t=e.target;
|
||||
if(t && (t.tagName==='INPUT'||t.tagName==='TEXTAREA'||t.tagName==='SELECT'||t.isContentEditable)) return;
|
||||
const k=e.key;
|
||||
if(k==='Escape'){
|
||||
if($('viewer').classList.contains('on')) vWalkBack(); // viewer → dossier (when reached from it) → deck
|
||||
else if($('detail').classList.contains('on')) closeDetail();
|
||||
return; // Esc never forges or navigates tabs
|
||||
}
|
||||
const sheetOpen=()=>$('detail').classList.contains('on')||$('viewer').classList.contains('on');
|
||||
if(k==='ArrowDown'){ e.preventDefault(); if(!sheetOpen()) undo(); return; }
|
||||
if(k==='Backspace'){ if(!sheetOpen()) undo(); return; }
|
||||
if(k==='ArrowLeft'||k==='ArrowRight'||k==='ArrowUp'){
|
||||
e.preventDefault();
|
||||
if(sheetOpen()) return;
|
||||
const el=pile[0]&&pile[0].el;
|
||||
if(el) commit(el, k==='ArrowLeft'?'nope':k==='ArrowRight'?'like':'maybe');
|
||||
}
|
||||
});
|
||||
|
||||
/* ---------- boot ---------- */
|
||||
|
||||
@@ -6,7 +6,7 @@
|
||||
offline once seen).
|
||||
- Everything else (shell/navigation): network-first, fall back to cache.
|
||||
*/
|
||||
const VERSION = 'bike-tinder-v2';
|
||||
const VERSION = 'bike-tinder-v3';
|
||||
const SHELL = [
|
||||
'/',
|
||||
'/manifest.json',
|
||||
|
||||
@@ -379,8 +379,13 @@ class TasteEngine:
|
||||
"""Source-labeled breakdown lines for the dossier."""
|
||||
row = self.by_id.get(listing_id)
|
||||
lines = []
|
||||
lines.append({'source': 'rubric', 'label': 'rubric fit',
|
||||
'value': int(row['score'] or 0)})
|
||||
# issue #3: a section can outlive an ad. A listing that left the
|
||||
# active pool mid-batch (and has no swipe history) is not in
|
||||
# by_id; its breakdown degrades to no-signal lines instead of a
|
||||
# TypeError that would 500 the whole section render.
|
||||
if row is not None:
|
||||
lines.append({'source': 'rubric', 'label': 'rubric fit',
|
||||
'value': int(row['score'] or 0)})
|
||||
for label, s, _d, _v in self.contributions(listing_id)[:3]:
|
||||
lines.append({'source': 'taste', 'label': label,
|
||||
'value': round(s, 1)})
|
||||
|
||||
@@ -1,15 +1,18 @@
|
||||
# Bike-Tinder app container (Phase 2 build).
|
||||
# The compose stack, systemd unit and Tailscale sidecar belong to the parent —
|
||||
# Bike-Tinder app container (Phase 4 deploy).
|
||||
# The compose stack, systemd unit and Tailscale sidecar live beside this file —
|
||||
# this file is only the app image contract.
|
||||
FROM python:3.13-slim
|
||||
FROM python:3.14-slim
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
COPY requirements.txt ./
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY app/ ./app/
|
||||
|
||||
# Data lands on the stack volume: /data/bike-tinder.sqlite3 and /data/img/
|
||||
# Data lands on the stack volume: /data/bike-tinder.sqlite3 and /data/img/.
|
||||
# /state is the hunt state dir (bind-mounted read-only) used by POST /api/import.
|
||||
EXPOSE 8000
|
||||
CMD ["python", "-m", "app.serve", "--host", "0.0.0.0", "--port", "8000", "--db", "/data/bike-tinder.sqlite3", "--img-dir", "/data/img"]
|
||||
CMD ["python", "-m", "app.serve", "--host", "0.0.0.0", "--port", "8000", \
|
||||
"--db", "/data/bike-tinder.sqlite3", "--img-dir", "/data/img", \
|
||||
"--state-dir", "/state"]
|
||||
|
||||
64
deploy/docker-compose.yml
Normal file
64
deploy/docker-compose.yml
Normal file
@@ -0,0 +1,64 @@
|
||||
# Bike-Tinder stack — deck app + Tailscale sidecar.
|
||||
#
|
||||
# Deployed on Rotarran at /var/mnt/DATA/podman-stacks/bike-tinder/ (a checkout
|
||||
# of the `release` branch). Run via the user unit podman-stack-bike-tinder.service
|
||||
# (Delegate=yes) or manually:
|
||||
# podman-compose -f deploy/docker-compose.yml --env-file .env up -d
|
||||
#
|
||||
# Networking:
|
||||
# - app: published on 127.0.0.1:9453 only — Hermes cron triggers (import /
|
||||
# agent read) and local debugging. The LAN sees nothing.
|
||||
# - tailscale (userspace mode, no tun/caps): joins the tailnet as `biketinder`
|
||||
# and serves https://biketinder.tailf35a34.ts.net -> http://app:8000 (443).
|
||||
# Secrets: TS_AUTHKEY + OPENROUTER_API_KEY come from the stack-local .env
|
||||
# (never committed). Before the authkey is placed, the sidecar simply reports
|
||||
# "no authkey" and exits — the app runs fine on its own.
|
||||
|
||||
x-logging: &default-logging
|
||||
driver: "json-file"
|
||||
options:
|
||||
max-size: "50m"
|
||||
max-file: "5"
|
||||
compress: "true"
|
||||
|
||||
services:
|
||||
app:
|
||||
build:
|
||||
context: ..
|
||||
dockerfile: deploy/Dockerfile
|
||||
image: localhost/bike-tinder:latest
|
||||
container_name: bike-tinder-app
|
||||
restart: unless-stopped
|
||||
environment:
|
||||
- TZ=America/Halifax
|
||||
- OPENROUTER_API_KEY=${OPENROUTER_API_KEY:-}
|
||||
volumes:
|
||||
- /var/mnt/DATA/podman-stacks/bike-tinder/data:/data
|
||||
- /var/home/admin/.hermes/scripts/motorcycle-hunt.d:/state:ro,z
|
||||
ports:
|
||||
- "127.0.0.1:9453:8000"
|
||||
stop_grace_period: 15s
|
||||
security_opt:
|
||||
- no-new-privileges:true
|
||||
logging:
|
||||
<<: *default-logging
|
||||
|
||||
tailscale:
|
||||
image: docker.io/tailscale/tailscale:latest
|
||||
container_name: bike-tinder-ts
|
||||
hostname: biketinder
|
||||
restart: unless-stopped
|
||||
depends_on:
|
||||
- app
|
||||
environment:
|
||||
- TS_AUTHKEY=${TS_AUTHKEY:-}
|
||||
- TS_HOSTNAME=biketinder
|
||||
- TS_STATE_DIR=/var/lib/tailscale
|
||||
- TS_SERVE_CONFIG=/config/serve.json
|
||||
- TS_USERSPACE=true
|
||||
- TZ=America/Halifax
|
||||
volumes:
|
||||
- /var/mnt/DATA/podman-stacks/bike-tinder/tailscale-state:/var/lib/tailscale
|
||||
- /var/mnt/DATA/podman-stacks/bike-tinder/deploy/tailscale:/config:ro
|
||||
logging:
|
||||
<<: *default-logging
|
||||
18
deploy/podman-stack-bike-tinder.service
Normal file
18
deploy/podman-stack-bike-tinder.service
Normal file
@@ -0,0 +1,18 @@
|
||||
# /var/home/admin/.config/systemd/user/podman-stack-bike-tinder.service
|
||||
# (installed from the repo: deploy/podman-stack-bike-tinder.service)
|
||||
[Unit]
|
||||
Description=Bike-Tinder podman-compose stack (deck app + Tailscale sidecar)
|
||||
Wants=network-online.target
|
||||
After=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
RemainAfterExit=yes
|
||||
Delegate=yes
|
||||
WorkingDirectory=/var/mnt/DATA/podman-stacks/bike-tinder
|
||||
ExecStart=/var/home/admin/.local/bin/podman-compose -f deploy/docker-compose.yml --env-file .env up -d
|
||||
ExecStop=/var/home/admin/.local/bin/podman-compose -f deploy/docker-compose.yml --env-file .env down
|
||||
TimeoutStartSec=600
|
||||
|
||||
[Install]
|
||||
WantedBy=default.target
|
||||
10
deploy/tailscale/serve.json
Normal file
10
deploy/tailscale/serve.json
Normal file
@@ -0,0 +1,10 @@
|
||||
{
|
||||
"TCP": { "443": { "HTTPS": true } },
|
||||
"Web": {
|
||||
"${TS_CERT_DOMAIN}:443": {
|
||||
"Handlers": {
|
||||
"/": { "Proxy": "http://app:8000" }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2,9 +2,61 @@
|
||||
|
||||
Glenn's "later versions" idea queue. He drops ideas in conversation; they land here (near-verbatim + a scope sketch + open questions), and get built in a future version — never mid-phase. Newest first.
|
||||
|
||||
## v1.1 — QOL wishlist (drafted 2026-11-12; feasibility triaged same day; build awaits Glenn's go-ahead)
|
||||
|
||||
Glenn's words: *"Going to go through a laundry list of fixes before we do lets say 1.1?"* — nothing here is started.
|
||||
|
||||
### Bugs & dry-catalog messaging (reported live 2026-11-12 evening)
|
||||
|
||||
Glenn's words: *"I just got a new batch and its marked as 2/2. When I go to the next, its 3/2… I don't believe it's counting the entries correctly. Furthermore, I'm only again getting 2 bikes at a time… I feel I should be getting batches of 25 at a time?"*
|
||||
|
||||
- **Counter bug (diagnosed in code 2026-11-12):** the pill shows `decided/total` for the current section. **Returns arrive wearing their previous decision** (the section payload joins `swipes.action`), so a fresh second-looks-only batch instantly counts as fully decided — a new batch paints "2/2" before it is touched, and the hot/complete state fires prematurely. Swiping then increments optimistically on top (`sectDecided++`), so the count runs past the total — "3/2", "4/2". **Fix sketch:** count a card as decided only if decided *during this section* (server per-item flag from events stamped with this section_id — the source `section_counts` already uses); clamp to total; keep the hot state off until a real in-section decision exists.
|
||||
- **Dry-catalog messaging (pulled forward from the Dry-pool UX note below):** when the fresh pool is 0 the deck silently degrades to returns-only sections (2–3 cards: ≤5 returns budget, one-shot per item, family caps) — by design but confusing. v1.1: surface the state ("Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks") whenever a composed/forged batch reports `new: 0`, and label forge results accordingly so it never silently drips 2 cards again.
|
||||
|
||||
### Batch formula v2 + fresh counter + empty state + Second Look pop (requested live 2026-11-12 evening, round 2)
|
||||
|
||||
Glenn's words: *"Alright lets add a new counter to the top of 'bikes lef' or something to indicate how many bikes are fresh. I think if there is no more new bikes, the empty page (all bikes gone through) should say 'no more new bikes!'. Maybe there is already but I didn't read it. Make the UI more pronounced so I can see it clearly. One more thing, I think there should be 25 bikes at a time, min 2 of second look. So say there is 5 bikes left, those 5 fresh bikes are listed, with the rest being second looks. Ok last thing, the Second Look indicator, make it more pronounced visually. Change the color a bit so it pops a bit more."*
|
||||
|
||||
- **Fresh counter (header):** new chip in the top header showing **fresh (undecided) bikes left** — extend `/api/stats` with `fresh` (active listings with no swipe — the exact NEW_POOL predicate). Header pill gains `<b>K</b> fresh`. When 0, the state of the hunt reads at a glance.
|
||||
- **Empty state, loud:** the exhausted screen becomes prominent **"No more new bikes!"** (today `.empty` says a quiet "You're all caught up" and the report screen can mask it in section mode). Show whenever the deck can serve *nothing* at all (no fresh, no eligible second looks, no wildcards); keep "New bikes arrive nightly — next import 08:30".
|
||||
- **Batch formula v2** *(amends the frozen ≤5-returns rule — build-time UI-SPEC/P3 note):* every batch targets **25 cards**. Fresh first (up to 23 slots); **≥2 second looks per batch whenever eligible stock exists** *(reading Glenn's "min 2": a full-fresh day = 23 fresh + 2 second looks; veto line if he wants pure-fresh instead)*; when fresh < 23, second looks **fill the remainder up to 25** (his example: 5 fresh + 20 second looks); leftover fresh rolls to the next batch. Limits kept: ≤2 re-noped returns per batch; family cap relaxes for fill-returns when needed (build detail); returns stay one-shot. Fresh exhausted → second-looks-only batches; returns exhausted → fresh-only batches; both → the loud empty state.
|
||||
- *Noted consequence:* with fill-to-25, the one-shot second-look pool (~30 remaining as of tonight) burns through in a batch or two — after that only nightly imports feed the deck. Re-offer policy (e.g. re-eligible after everything's had its turn) stays queued (option (c) below); revisit after living with v2.
|
||||
- **Second Look band pops:** `.band.sl` is currently near-invisible (white at ~10% on dark); re-tint to a distinct **violet accent** (bold fill + border) on card face + info view. Wildcard stays amber for contrast.
|
||||
- **UI-SPEC amendments at build:** §11 tap flow (already queued) + `.band.sl` palette + empty-state copy + header fresh counter.
|
||||
- **Glenn's sign-offs (2026-11-12, live):** ≥2-second-looks default CONFIRMED (rich-day deck = 21 fresh + 2 second looks + 2 wildcards) · violet band CONFIRMED · Backspace kept as undo alias CONFIRMED. **Build phase AUTHORIZED** the same day — implementation spec = `docs/V1.1-BUILD.md`.
|
||||
|
||||
### Shortcuts
|
||||
- Arrow keys: Left = Nope, Right = Like, Up = Maybe, **Down = back one** *(read as: undo the last swipe — confirm at spec time)*. **Esc** = exit fullscreen views.
|
||||
- Feasibility: trivial — keyboard invokes the exact actions gestures/buttons already call (undo exists). Care: ignore keys while a text input has focus; prevent arrow-key page scroll. Desktop/Bluetooth-keyboard benefit only; the app is reachable from any tailnet device (MacBook included).
|
||||
|
||||
### UI changes
|
||||
1. **Tap flow — info first, then photos.** Center tap opens the fullscreen **bike data view** (today it opens the photo); tapping the photo there opens the fullscreen **image viewer**. Side taps keep flipping photos on the card. Esc/back pops viewer → data → deck. Resolves "can't get info unless I hit the ⓘ button." Revisit `UI-SPEC.md` §11 tap map before build (v1.1 spec bump).
|
||||
2. **Photo fit: fill → contain, option C chosen.** Show photos uncropped — no "zoomed" crops. **Decided 2026-11-12 (Glenn: "OH C! I love C!"): option C — fit + blurred backdrop (whole photo over a soft blur of the same image) on the card AND the info-page hero.** Fullscreen viewer already fits (unchanged); list thumbs stay fill (56px, irrelevant). Demo reference: `~/dev/bike-tinder-demos/fit-vs-fill.html` (panel C).
|
||||
3. **Rubric display goes minimal.** Show ONLY the gas-tank gauge + percent full (e.g. "76%"); drop the rest of the rubric-fit display in bike views — **plus a setting that re-enables the full "why" breakdown for debugging** (Glenn, 2026-11-12; wire via the existing `prefs` key/value API — same pattern as `forge_mode`).
|
||||
|
||||
## v1.2 — Analytics suite (version split set with Glenn 2026-11-12)
|
||||
|
||||
Glenn's words: *"take in just about all interactions… how long I have looked at each picture, how many pictures I flipped through, how quickly I swiped… kept on an individual bike perspective and fed to the model for further accuracy"* + *"start the database from scratch, giving myself a new start."*
|
||||
|
||||
- **Capture (local-only, per bike):** dwell time per photo, flips (count/order), decision latency (card visible → swipe), maybe/undo/list-edit events, session id; card-dwell vs fullscreen-dwell as separate signals.
|
||||
- **Store:** new append-only `interaction_events` table (same pattern as `swipe_events`); batched client flush (`sendBeacon`/pagehide); iOS PWA: pause dwell clocks on `visibilitychange` so background time can't pollute.
|
||||
- **Feed the model:** nightly agent pass consumes per-bike aggregates as extra taste features. HARD LAW unchanged: no LLM in the swipe path — capture is write-only until the nightly read.
|
||||
- **Reset:** ships with v1.2, paired with a from-scratch DB reset so telemetry starts clean on the new ledger. Scope to confirm: wipe swipes + events + profile only (listings/catalog stay — re-import is idempotent); legacy data stays in `data/backup/` archives. (v1.1 does NOT reset anything — swipe history survives it untouched.)
|
||||
- **Open questions:** reset scope; raw events forever vs aggregate-and-prune; include list-browsing events; surface any of it in the UI (probably not).
|
||||
|
||||
## Gallery mirror gap (found 2026-11-12, filing for a later phase)
|
||||
|
||||
Verified while preparing the fit/fill demo: the local image mirror (`data/img/{id}.webp`) holds **primaries only**. Gallery photos beyond the first (`/img/{id}?i≥1`) serve a **302 redirect to the Kijiji CDN** — not hedged locally. If an ad is deleted we keep photo 1, but the gallery (often where the good shots are) is gone. Fix options for a later phase: mirror galleries on import/first-touch (estimates in the B1 notes: roughly +350–600 MB for the full catalog — fine for the mirror volume), keep the redirect as fallback. Not urgent; filed so it is not forgotten.
|
||||
|
||||
## Dry-pool UX + agent feedback (noted 2026-11-12)
|
||||
|
||||
Glenn hit a fully-reviewed catalog: 563/563 actives decided → fresh pool = 0 → forges returned 2-card returns-only sections ("stuck on a couple bikes"), and "Run agent now" looked inert (a pass ran, but the deck can't change without fresh listings). Possible polish: (a) report/forge state says "catalog fully reviewed — fresh listings arrive with the next import" instead of silently dripping 2 cards; (b) agent button shows a richer confirmation (profile version + lean delta); (c) re-open "second look" eligibility or widen the wildcard pool when the catalog is dry; (d) a "review your Maybes" shortcut at exhaustion. Related: the nightly import + nightly agent read make the pool self-refreshing (Phase 4).
|
||||
|
||||
**Pulled into v1.1 (2026-11-12):** option (a) — dry-state messaging — is now part of the v1.1 scope (see Bugs & dry-catalog messaging above); options (b)/(c)/(d) remain queued for a later version.
|
||||
|
||||
## B1 · Photo experience v2 — multi-image galleries, photo swipe, fullscreen viewer
|
||||
|
||||
**Queued 2026-11-10** (during the P3 build; for the version after it). **PULLED FORWARD 2026-11-10 — building now, before Phase 4 (Glenn's call).** Spec frozen in `UI-SPEC.md` §11 + `DATA-MODEL.md` B1 additions; live tree untouched during the build.
|
||||
**Queued 2026-11-10** (during the P3 build; for the version after it). **PULLED FORWARD 2026-11-10; SHIPPED 2026-11-11 — built, verified (walk 390/390, selfcheck 31/31), LIVE on :9453; see `PLAN.md`.** Spec frozen in `UI-SPEC.md` §11 + `DATA-MODEL.md` B1 additions.
|
||||
|
||||
Glenn's words: *"more pictures! As many pictures as we can get honestly. I'd like to swipe through them left and right like tinder does. One repeats, the image should change as to not tip me off."* · *"I'd like to tap the image to 'full screen' it so I can see it better."*
|
||||
|
||||
|
||||
@@ -162,9 +162,9 @@ Semantics:
|
||||
- Round = prior events for that listing + 1, assigned at write time. Rounds cap at 2 for engine influence (any later events weigh as round 2; v1 returns never produce rounds >2 by design).
|
||||
- **Migration seeding:** when `swipe_events` is empty and `swipes` has rows → insert one round-1 event per swipe row (created_at copied). Only-when-empty, hence idempotent.
|
||||
- **Sections:** at most ONE `open` section at a time. The deck = that section's `section_items` in `position` order, filtered to items undecided at read. Exhausted = no item undecided → `status='report'`. Forge = close current + open new. First-ever read composes a cold section (rubric-weighted, w=0).
|
||||
- **Returns eligibility (v1 contract):** a verdict exists (like/maybe/nope in `swipes`); listing `active`; NOT in either of the previous two sections; no round≥2 `nope` ever (rested); not already returned once (round cap). Selection prefers maybe > like > nope; nope candidates must be "surprising" (points ≥55 or net-positive family). Max 5 returns per section, ≤2 of them nopes.
|
||||
- **Returns eligibility (v1.1 contract, amends the frozen ≤5 rule):** a verdict exists (like/maybe/nope in `swipes`); listing `active`; NOT in either of the previous two sections; no round≥2 `nope` ever (rested); not already returned once (round cap). Selection prefers maybe > like > nope; nope candidates must be "surprising" (points ≥55 or net-positive family) for the RESERVED slots only. Every batch carries ≥2 returns whenever eligible stock exists and fills the remainder up to 25 when fresh < 23; ≤2 nope-verdict returns per batch; fill returns relax the per-family cap from 4 to 8 (fill slots only).
|
||||
- **`points` is computed, not stored** (deterministic from events + profile; a cache is allowed only if it never changes semantics).
|
||||
- **prefs:** `forge_mode` ('ondemand' default | 'strict'). Existing keys unchanged.
|
||||
- **prefs:** `forge_mode` ('ondemand' default | 'strict') · `rubric_debug` ('off' default | 'on' — dossier "why" breakdown visibility; v1.1). Existing keys unchanged.
|
||||
- **Legacy deck semantics:** `/api/deck` (cursor paging; 7-day maybe re-admit) stays as a read-only fallback for debugging; sections are the production flow.
|
||||
|
||||
## B1 additions — frozen 2026-11-10 (photo experience v2)
|
||||
|
||||
@@ -116,6 +116,29 @@ data/ runtime state (gitignored)
|
||||
docs/ this design set
|
||||
```
|
||||
|
||||
## Runbook (completed at Phase 4)
|
||||
## Runbook (Phase 4)
|
||||
|
||||
Deploy / update / rollback steps, log locations, import troubleshooting (gates), backup-restore drill, phone verification checklist.
|
||||
**Stack home:** `/var/mnt/DATA/podman-stacks/bike-tinder/` — a checkout of the `release` branch, plus stack-local `data/` (DB + image mirror + backups), `.env` (secrets, never committed) and `tailscale-state/` (node identity). Unit: `podman-stack-bike-tinder.service` (installed from `deploy/`).
|
||||
|
||||
**Deploy / update a cut:**
|
||||
|
||||
```sh
|
||||
# from the repo: merge dev -> main, then fast-forward release
|
||||
git -C /var/mnt/DATA/podman-stacks/bike-tinder pull --ff-only
|
||||
podman-compose -f deploy/docker-compose.yml --env-file .env build
|
||||
systemctl --user restart podman-stack-bike-tinder.service
|
||||
```
|
||||
|
||||
Docs-only cuts stop after the `pull`. The unit is `oneshot` + `RemainAfterExit` with `Delegate=yes`, so the stack survives `hermes gateway restart` and reboots. The historical dev service (`bike-tinder-dev.service`) is retired at deploy; rollback happens through the stack, not that unit.
|
||||
|
||||
**Rollback:** check out the previous release SHA in the stack dir, rebuild, restart. The DB is never touched by code rollbacks (migrations are guarded and idempotent); if a migration ever needs unwinding, restore the last backup (below).
|
||||
|
||||
**Logs:** `podman logs bike-tinder-app`, `podman logs bike-tinder-ts`, `journalctl --user -u podman-stack-bike-tinder.service`.
|
||||
|
||||
**Import troubleshooting:** `POST /api/import` refuses when the hunt state is older than 26 h or missing — check `~/.hermes/scripts/motorcycle-hunt.d/*.json`. The nightly chain is the Hermes cron job `bike-tinder-import` (08:30 Atlantic: import → agent read → DB backup); it is silent on success by design — inspect its last run in the cron list if a morning looks stale. The container also runs an on-boot catch-up import when the last run is >26 h old.
|
||||
|
||||
**Backups:** nightly `data/backup/bike-tinder-YYYYMMDD-HHMM.sqlite3`, last 14 kept. Restore drill: stop the unit → remove `data/bike-tinder.sqlite3-wal`/`-shm` → copy the chosen backup over `data/bike-tinder.sqlite3` → start the unit → check `GET /api/stats`.
|
||||
|
||||
**Phone checklist:** open `https://biketinder.tailf35a34.ts.net` from a tailnet device → expect the deck; Add to Home Screen (PWA installs via the manifest); swipe once and confirm the decision shows in List. If the URL fails: check the sidecar (`podman logs bike-tinder-ts`), confirm `TS_AUTHKEY` in `.env`, and re-run `podman-compose -f deploy/docker-compose.yml --env-file .env up -d`.
|
||||
|
||||
**First-run sidecar (one-time):** mint a Tailscale auth key (admin console → Settings → Keys), put `TS_AUTHKEY=<key>` into the stack `.env`, then `podman-compose -f deploy/docker-compose.yml --env-file .env up -d tailscale`.
|
||||
|
||||
42
docs/DEVELOPMENT.md
Normal file
42
docs/DEVELOPMENT.md
Normal file
@@ -0,0 +1,42 @@
|
||||
# Development and deployment
|
||||
|
||||
Run these commands from the repo root. The container uses Python 3.14. Use a scratch database and a different port from any running instance; the example binds only to localhost.
|
||||
|
||||
```sh
|
||||
python3 -m venv .venv
|
||||
.venv/bin/python -m pip install -r requirements.txt
|
||||
mkdir -p data/dev-img
|
||||
|
||||
# Optional: seed a development catalog from motorcycle-hunt snapshots.
|
||||
.venv/bin/python -m app.importer --state-dir /path/to/hunt-snapshots --db data/dev.sqlite3
|
||||
|
||||
# Local app and read-only deck preview.
|
||||
.venv/bin/python -m app.serve --host 127.0.0.1 --port 9454 --db data/dev.sqlite3 --img-dir data/dev-img
|
||||
.venv/bin/python -m app.deck --db data/dev.sqlite3 --top 15
|
||||
|
||||
# Run separately from the dev server.
|
||||
.venv/bin/python -m app.selfcheck
|
||||
```
|
||||
|
||||
`data/` and `.venv/` are local and ignored by Git. The `app.imgfetch` CLI can cache images for a development catalog; use `--help` for options. The nightly process in the live stack imports the catalog, refreshes the taste profile, and backs up SQLite.
|
||||
|
||||
For an offline taste-profile pass, run `app.agentpass --mock` against a development database with swipe history. To inspect the inputs without writing a profile, use `--print-summary --dry-run`. The optional live provider is configured outside the repo. Never use the running instance's DB for test writes; use SQLite's backup API if you need a consistent copy of a database in use. The legacy browser walks (`app.fe_walk_b1`, `app.fe_walk_v11`) need Playwright, Chromium, and staged scratch fixtures; inspect their fixture paths before running them.
|
||||
|
||||
## API entry points
|
||||
|
||||
| Area | Routes |
|
||||
| --- | --- |
|
||||
| Status | `GET /api/health`, `GET /api/stats` |
|
||||
| Browse | `GET /api/section`, `GET /api/list`, `GET /api/listing/{id}` |
|
||||
| Decide | `POST /api/swipe`, `DELETE /api/swipe/{id}` |
|
||||
| Refresh | `POST /api/import`, `POST /api/section/forge`, `POST /api/agent/run` |
|
||||
| Preferences | `POST /api/prefs`, `POST /api/badge/seen` |
|
||||
| Display | `GET /api/trends`, `GET /img/{id}?i=n` |
|
||||
|
||||
For data contracts, see [Data model](DATA-MODEL.md), [Ranking](RANKING.md), and the [UI spec](UI-SPEC.md).
|
||||
|
||||
## Deployment
|
||||
|
||||
The [Podman Compose definition](../deploy/docker-compose.yml) runs the app and a Tailscale sidecar for private access. The [systemd user unit](../deploy/podman-stack-bike-tinder.service) owns the running containers. Keep deployment-specific configuration outside Git and retain independent backups of the SQLite data. Do not expose the single-user app directly to the public internet.
|
||||
|
||||
Development lands on `dev`, verified changes move to `main`, and the running stack follows `release`. Build the candidate image before restarting the service. After cutover, check `/api/health` and confirm that the HTTP shell matches the intended revision. Keep the previous image for rollback.
|
||||
17
docs/HOW-IT-WORKS.md
Normal file
17
docs/HOW-IT-WORKS.md
Normal file
@@ -0,0 +1,17 @@
|
||||
# How Bike-Tinder works
|
||||
|
||||
## From classifieds to cards
|
||||
|
||||
The motorcycle-hunt crawler collects Kijiji listings in Nova Scotia and New Brunswick. The importer reads the crawler's snapshots, adds new listings, updates existing ones, and retires listings only after repeated misses. A blocked or failed fetch isn't proof that a listing is gone. See [Sources](SOURCES.md) and the [data model](DATA-MODEL.md).
|
||||
|
||||
The web app reads that catalog from SQLite and presents listings in a swipe deck or a searchable List. Your current verdict is editable; the app also records swipe events for ranking. Tap the sides of a deck card to browse its photos, the center to open the details, or the photo in the details view to open the fullscreen gallery. See the [interface spec](UI-SPEC.md) for gesture and keyboard behavior.
|
||||
|
||||
## Ranking and photos
|
||||
|
||||
With no swipe history, the deck starts with the motorcycle hunt's scoring rubric. Once there is history, the app builds a taste profile and uses it when ordering future batches. Batches can mix fresh bikes, wildcards, and second looks. A model runs outside the swipe path: the swipe itself never waits for a model response. See [Ranking](RANKING.md) and [Design](DESIGN.md).
|
||||
|
||||
The importer retains gallery URLs in source order. The running stack keeps primary photos locally; when a requested gallery photo isn't cached, the app redirects to the source image. A missing photo uses a placeholder. See [the gallery mirror backlog](BACKLOG.md#gallery-mirror-gap-found-2026-11-12-filing-for-a-later-phase).
|
||||
|
||||
## More detail
|
||||
|
||||
[Development and deployment](DEVELOPMENT.md) covers setup and testing. The [roadmap](PLAN.md) and [backlog](BACKLOG.md) cover planned work.
|
||||
26
docs/PLAN.md
26
docs/PLAN.md
@@ -1,6 +1,12 @@
|
||||
# PLAN — Bike-Tinder
|
||||
|
||||
**Status:** Build phase — Phase 2 complete + phone-proven (2026-11-10); **Phase 3 built, verified, and live on the dev server (2026-11-11)**; Phase 4 next. Phases are gated: each lands, is verified, then the next begins. Glenn's standing rule applies — "pause" stops all spend immediately.
|
||||
**Status:** **v1.0 SHIPPED (2026-11-12)** — Phases 1–4 complete: stack live under its unit, nightly chain armed, tailnet URL in daily use, Gitea release `v1.0.0` cut. **v1.1** (QOL batch) is spec'd and awaits Glenn's build order; **v1.2** (analytics suite + fresh-ledger reset) queued. Phases are gated: each lands, is verified, then the next begins. Glenn's standing rule applies — "pause" stops all spend immediately.
|
||||
|
||||
## Version map
|
||||
|
||||
- **v1.0** — shipped 2026-11-12: the working loop (Phases 1–4 — catalog, swipe deck, personalization, deployed stack + nightly automation). Gitea release `v1.0.0`.
|
||||
- **v1.1** — QOL batch, spec'd 2026-11-12 (`BACKLOG.md`): keyboard shortcuts · info-first tap flow · option C photos (fit + blurred backdrop) · minimal rubric + debug "why" toggle · section-counter fix + dry-catalog messaging · fresh counter + loud "No more new bikes!" empty state · batch formula v2 (25-target, second-look fill, ≥2 per batch) + Second Look band pop. No data reset. **Build authorized 2026-11-12** — sign-offs: ≥2-SL default (rich day 21 fresh/2 SL/2 wild) · violet band · Backspace alias; spec = `docs/V1.1-BUILD.md`; build phase in progress.
|
||||
- **v1.2** — analytics suite (`BACKLOG.md`): full interaction capture + from-scratch ledger reset ("fresh start").
|
||||
|
||||
## v1 goal
|
||||
|
||||
@@ -59,14 +65,20 @@ Glenn's approved design (2026-11-10):
|
||||
|
||||
**Carried forward:** service-side OpenRouter key wiring at P4 — until then each forge's agent pass runs in mock mode and supersedes the live profile · wildcard pool hygiene (rare non-bike listings can surface) · early-ramp texture: dense nopes punish broad cells (year 2020+, 12k+, nb) — the Scouts read mid until the agent carves family-level exceptions · minor reload edge: an already-restruck second look can re-cycle on mid-section reload.
|
||||
|
||||
**Glenn's call (2026-11-10, late): B1 "Photo experience v2" pulled forward** — built next, *before* Phase 4 ("get that feature baked in before we proceed to phase 4"). Spec frozen in `UI-SPEC.md` §11 (galleries · tap-side photo flip · center-tap fullscreen viewer · fresh lead photo on repeats) + `DATA-MODEL.md` B1 additions. Rail side: hunt gallery capture + full-catalog backfill (Alex). App side: Torres on a fresh clone (`~/dev/bike-tinder-b1-build`) — the live tree and live DB stay untouched during the build; tests on port 9454 + DB copies.
|
||||
**Glenn's call (2026-11-10, late): B1 "Photo experience v2" pulled forward** — built next, *before* Phase 4 ("get that feature baked in before we proceed to phase 4"). Spec frozen in `UI-SPEC.md` §11 (galleries · tap-side photo flip · center-tap fullscreen viewer · fresh lead photo on repeats) + `DATA-MODEL.md` B1 additions.
|
||||
|
||||
## Phase 4 — Deploy + automate
|
||||
**Status: BUILT → VERIFIED → LIVE (2026-11-11).** Rail: hunt gallery capture + full-catalog backfill — 639/640 state items carry `imgs[]` (612 with 2+ photos); the 1 remainder is a photo-less ad at source ("no photo found", retried and confirmed) → app shows the placeholder, by design. App: Torres on a fresh clone (`~/dev/bike-tinder-b1-build`, commits `3b64635..036a511`, report `~/dev/bike-tinder-b1/TORRES-B1-REPORT.md`); live tree + live DB untouched during the build. Verification: selfcheck 31/31 both sides; `fe_walk_b1` headless §11 walk 390/390 (Alex re-ran green with a fresh setup). **Live integration (2026-11-11, ~00:40 AST):** pre-B1 backups `~/dev/bike-tinder-b1/preb1-live-*.sqlite3` + `preb1-files/`; 11 files deployed; service restarted; `POST /api/import` idempotent (`new:0`); live DB now 639/640 with galleries, 612 multi-photo (sample id 430 Indian Sport Scout n=8; `/img/430?i=1` → 302). Live gesture proof: side-tap flip `?i=0 ↔ ?i=1`, center-tap viewer with segments, screenshot `~/dev/bike-tinder-b1/b1-live-9453.png`. Glenn's ledger intact (248 swipes / 279 events carried). `dev` + `main` merged (`49466fb`); live tree commit `3a399e1`.
|
||||
|
||||
- Podman compose stack at `/var/mnt/DATA/podman-stacks/bike-tinder/` + systemd unit (`Delegate=yes`) + in-stack Tailscale sidecar serving `https://biketinder.tailf35a34.ts.net`; PWA install on Glenn's phone
|
||||
- Enable the new `bike-tinder-import` Hermes cron (08:30 daily, post-hunt; script-only, zero LLM; parked until deploy); DB backup routine
|
||||
- Runbook in DESIGN.md; announce + handover note
|
||||
- **Exit criteria:** survives a reboot; refreshes overnight unattended; installable and used from the phone.
|
||||
## Phase 4 — Deploy + automate (stack deployed 2026-11-12; phone check pending)
|
||||
|
||||
- ✅ Podman compose stack at `/var/mnt/DATA/podman-stacks/bike-tinder/` (release checkout) + systemd unit `podman-stack-bike-tinder.service` (`Delegate=yes`; verified to survive gateway/desktop restarts and re-raise after `systemctl --user restart`) + in-stack Tailscale sidecar (userspace mode) serving `https://biketinder.tailf35a34.ts.net` — **AUTHORIZED + serving 2026-11-12** (node `biketinder`, `100.114.195.22`; first phone swipes logged through the sidecar)
|
||||
- ✅ `bike-tinder-import` Hermes cron live (08:30 daily, post-hunt): import → live agent read → sqlite backup (14-deep); silent on success (three clean live runs on deploy day)
|
||||
- ✅ DB + image mirror migrated intact into the stack volume; backup drill produced its first files
|
||||
- ✅ Deploy fix (found on first in-container agent call): `requests` was missing from requirements — the host venv had it incidentally, the slim image did not
|
||||
- ✅ Runbook in DESIGN.md (deploy/rollback/logs/import gates/backup-restore/phone checklist)
|
||||
- ✅ **Release v1.0.0 published 2026-11-12** — Gitea release, tag pinned to `main` head; notes summarize the working loop; source zip/tar.gz auto-generated by Gitea (nothing attached)
|
||||
- ✅ In use from Glenn's phone (2026-11-12 — first photo flips + swipes logged through the sidecar); PWA "Add to Home Screen" available; full reboot test optional/pending
|
||||
- **Exit criteria:** survives a reboot (service-level verified; power-level test optional); refreshes overnight unattended (armed, first automatic run 08:30 next day); installable and used from the phone — **achieved 2026-11-12.**
|
||||
|
||||
## Non-goals (v1)
|
||||
|
||||
|
||||
@@ -26,7 +26,7 @@ Deterministic, explainable, pure-Python. Learning reads `swipe_events` only.
|
||||
|
||||
**Score.** `taste_raw` = Σ shrunk weights over the listing's values; `taste_norm` = percentile rank among active listings (0–100). Blend: `w = min(0.85, N/60)` where N = total events; `points = clip( round( (1−w)·rubric + w·taste_norm + agent_adj ), 0, 100 )`. `agent_adj` = Σ profile adjustments (clamped ±10 per listing). Breakdown for the dossier: rubric share · top 3 ± taste features · agent lines — all source-labeled.
|
||||
|
||||
**Section recipe.** 25 cards = 2 wildcards + ≤5 returns + remainder new (points DESC). Constraints: ≤4 per family per section; ≥3 price bands when the pool allows; shortfalls fill from new.
|
||||
**Section recipe.** Every batch targets 25 cards = fresh first (up to 23 slots) + ≥2 second looks whenever eligible stock exists + the 2 wildcard slots (wildcards draw from the fresh pool). When fresh < the remainder, second looks fill up to 25 (family cap relaxes to 8 for fill returns only); leftover fresh rolls to the next batch; fresh/return shortfalls are never padded — a drained pool yields a short (or empty) section. Constraints: ≤4 per family per section for fresh + reserved returns; ≥3 price bands when the pool allows.
|
||||
|
||||
**Wildcards.** Candidates: active, unseen, not in the last two sections. Exclusions: families with ≥3 cumulative nopes and net-negative weight. Prefer: different family AND different price band than the section's top new items. Score = `0.5·points + 0.5·novelty` (novelty = distance from the liked-profile centroid). Picks: 2 per section.
|
||||
|
||||
|
||||
@@ -20,6 +20,7 @@
|
||||
### Card geometry
|
||||
- `.card{position:absolute;left:14px;right:14px;top:6px;bottom:34px;border-radius:18px;overflow:hidden;background:var(--card);box-shadow:0 0 0 1px rgba(255,255,255,.07),0 18px 40px rgba(0,0,0,.5);will-change:transform;touch-action:none}`
|
||||
- Photo full-bleed (`object-fit:cover`); bottom gradient 52% tall (transparent → rgba(0,0,0,.55) @55% → .88). Info block at bottom:14px: chips row → title (23px/800, clamp 2 lines) → price (20px/600) → sub (13px, var(--mut)).
|
||||
- Photo fit is **contain** (v1.1): the whole photo is shown uncropped over a soft blurred backdrop of the same image (option C). The backdrop is decorative (blurred, dimmed, overflow-clipped); the sharp photo sits on top with a gentle shadow. The fullscreen viewer already fits; list thumbs stay `cover` (56px).
|
||||
- No photo → placeholder panel: 45° repeating stripes (#141419/#18181f), centered copy: "Photo pending — thumbnail backfill queued".
|
||||
- ⓘ button: 32px circle, top-right of card (rgba(0,0,0,.45), 1px rgba(255,255,255,.25) border) → opens the dossier for that card.
|
||||
- Chips: 11px/600, rgba(255,255,255,.14) bg, radius 999px. Production content: max 3 = seller chip ("Dealer" only when seller_type=dealer) + first 2 extras.
|
||||
@@ -51,6 +52,8 @@
|
||||
### Empty state
|
||||
Dashed panel, copy exactly: **"You're all caught up."** / "New bikes arrive nightly — next import 08:30." / "↺ brings the last card back." Undo restores the last card.
|
||||
|
||||
§2's quiet "You're all caught up." remains only for legacy (pre-section) mode. In section mode, when the deck can serve nothing at all — no fresh listings, no eligible second looks, no wildcards — the deck shows a prominent **"No more new bikes!"** panel with "New bikes arrive nightly — next import 08:30." and, when true, "↺ brings the last card back." This panel supersedes the report card in that state only; the report card remains the end-of-section screen whenever more cards can still be served (v1.1).
|
||||
|
||||
## 3. Dossier (fullscreen sheet) — one sheet, both doors
|
||||
|
||||
Opened from deck ⓘ (or tap) AND list row tap. iOS-sheet geometry: top gap 26px; `border-radius:18px 18px 0 0`; bg #0f0f13; slide-in `.3s cubic-bezier(.2,.8,.3,1)` from `translateY(103%)`. Backdrop: rgba(0,0,0,.38), z 69/70.
|
||||
@@ -87,7 +90,7 @@ Opened from deck ⓘ (or tap) AND list row tap. iOS-sheet geometry: top gap 26px
|
||||
|
||||
1. **Data wiring.** Deck buffer from `GET /api/deck` (limit 40, opaque cursor); refill when buffer <5 and a cursor exists. List from `GET /api/list`. Dossier from the row/card payload. Header from `GET /api/stats`.
|
||||
2. **Swipe persistence.** Commits fire `POST /api/swipe` optimistically — the UI never waits. Failures go to a retry queue (attempts at ~2s/5s/10s, then every 15s while the tab lives); toast "Couldn't save — retrying" on first failure. Undo fires `DELETE /api/swipe/{id}` through the same queue.
|
||||
3. **Badge.** `POST /api/badge/seen` once per session when the deck first renders. Header shows "{live} live" always; "· {new} new" only when new>0.
|
||||
3. **Badge.** `POST /api/badge/seen` once per session when the deck first renders. Header pill shows `{live} live · {fresh} fresh` always, and `· {new} new` only when new > 0. `fresh` = active listings with no swipe (the deck's new-pool predicate) — v1.1. The pill and the list sub-line refresh themselves shortly after any decision change (swipes, undo, dossier/list/matches edits) and whenever a new batch lands — no reload needed (v1.1.1, issue #2).
|
||||
4. **List filters + search** per §4 (mockup had placeholder chips only).
|
||||
5. **Matches real (§5); Trends stays stub.**
|
||||
6. **Images.** Every card/thumb references `/img/{id}` (server: cached file → 302 CDN → 404 → placeholder). The client never hotlinks directly.
|
||||
@@ -119,7 +122,7 @@ Human (parent-run after build): Glenn swipes a real deck from his phone and edit
|
||||
|
||||
- The deck serves ONE section at a time: 25 cards (default). A section is the unit of a swipe burst; when it is exhausted, the next one is forged (with an agent pass in between — §10.2).
|
||||
- Header right side, next to the stats: section progress "7/25" (12px/650, muted; turns `--accent1` at 25/25; fits within the existing header, no layout shift).
|
||||
- Section composition (engine side — RANKING.md): ≤5 SECOND LOOK cards + 2 WILDCARD cards + the remainder new.
|
||||
- Section composition (engine side — RANKING.md): every batch targets 25 cards = fresh first (up to 23 slots) + ≥2 SECOND LOOK cards whenever eligible stock exists + 2 WILDCARD cards; when fresh < 23, second looks fill the remainder up to 25. Re-nope returns stay ≤2 per batch; fresh shortfalls are never padded (v1.1).
|
||||
- ALL §2 mechanics apply unchanged inside a section: 5-deep stack, `.topcard` invariant, no-lock commit, stamps, undo; the buffer refills from the pinned section order.
|
||||
|
||||
### 10.2 Section report + forge
|
||||
@@ -133,13 +136,14 @@ Human (parent-run after build): Glenn swipes a real deck from his phone and edit
|
||||
- **Forge mode `ondemand` (default):** primary button **"Forge next 25"**. Tap → inline status "The agent is reading your strikes…" → new section hydrates. If the pass fails: "Agent offline — forging on the last read." and the forge still lands (fallback profile).
|
||||
- **Forge mode `strict`:** button disabled; caption "Waiting for the nightly read — next section after the agent runs."
|
||||
- Both modes: small toggle row under the actions — "Forge: on demand ⇄ strict" (persists `prefs['forge_mode']`).
|
||||
- When a forged batch reports `new: 0` the report shows: "Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks." and the forge reads the same note in its status line (v1.1).
|
||||
- Undo from the report screen re-opens the section with the last card (§2 undo semantics).
|
||||
|
||||
### 10.3 Card bands (the ONLY card-face additions)
|
||||
|
||||
- Position: top-left inset (12px); `pointer-events:none`; no layout shift; no effect on stack metrics or drag. 11px/650, letter-spacing .4px, radius 999px, padding 4px 9px, max-width 78%; may wrap to 2 lines.
|
||||
- **WILDCARD — maybe you'll like this one instead** — color `#ffb43a`; bg `rgba(255,180,58,.14)`; border `1px solid rgba(255,180,58,.35)`.
|
||||
- **SECOND LOOK — you {liked|maybed|noped} this** — color `rgba(255,255,255,.85)`; bg `rgba(255,255,255,.10)`; border `1px solid rgba(255,255,255,.22)`.
|
||||
- **SECOND LOOK — you {liked|maybed|noped} this** — color `#c4b5fd`; bg `rgba(124,58,237,.22)`; border `1px solid rgba(167,139,250,.65)`; font-weight 800. Wildcard stays amber (`#ffb43a` family values unchanged) for contrast. The same band renders in the dossier ("info view") when the listing's slot is `return` or `wildcard` (v1.1).
|
||||
- No other text may sit on the card face in v3.
|
||||
|
||||
### 10.4 Tank gauge (match points, non-numeric)
|
||||
@@ -151,9 +155,10 @@ Human (parent-run after build): Glenn swipes a real deck from his phone and edit
|
||||
### 10.5 Dossier — "Why this rank"
|
||||
|
||||
- New block after chips, before "The machine":
|
||||
- Gauge + "{points}/100" (17px/700).
|
||||
- Gauge + "{points}%" (17px/700).
|
||||
- Up to 4 breakdown lines, strongest first, muted: "· {feature} {±n}"; agent contributions render as "· agent: {why} {±n}".
|
||||
- Footer: "from {N} strikes · read {relative}" (N = events count; time = profile version time).
|
||||
- Hidden-by-default detail: the breakdown lines and the "from N strikes" footer render only when `prefs['rubric_debug'] === 'on'` (default `'off'`). With the pref off the block shows **the tank gauge + "{points}%"** only — the minimal rubric display. The toggle lives in the Trends "Actions" area (why-breakdown on ⇄ off, same control style as the forge-mode toggle) — v1.1.
|
||||
- This is the only numeric display in the app (accepted — it exists for audit).
|
||||
|
||||
### 10.6 Trends tab (real)
|
||||
@@ -192,14 +197,15 @@ Top→bottom:
|
||||
|
||||
### 11.3 Fullscreen viewer
|
||||
|
||||
- Tap the CENTER third → fullscreen viewer opens on the photo currently shown.
|
||||
- Tap the photo in the dossier hero → fullscreen viewer opens (starts at photo 0). Direct card→viewer is retired (see §11.4); the viewer is reached from the dossier (v1.1).
|
||||
- Viewer: horizontal swipe = prev/next (clamp); pinch-zoom + double-tap = zoom (1×–~4×); segment bars stay visible; close via ✕ (36px, top-left) or pull-down (grabber or photo, `dy > 110` — the §3 idiom). Closing returns to the same card, same photo position; deck state untouched.
|
||||
- Also opens from the dossier hero (starts at photo 0). Same sheet geometry as the dossier (z-band 69/70), photo-first: no body, no actions row.
|
||||
- Viewer close (✕, pull-down, or Esc) returns to the dossier; the next Esc returns to the deck (v1.1).
|
||||
|
||||
### 11.4 Doors (supersedes the old tap→dossier)
|
||||
|
||||
- ⓘ (top-right of card) → dossier (unchanged). The card face now owns: **sides = flip, center = fullscreen**; the "tap anywhere → dossier" gesture is RETIRED.
|
||||
- The dossier stays reachable from ⓘ and from list rows (§3/§4 unchanged).
|
||||
- ⓘ (top-right of card) → dossier (unchanged). The card face now owns: **sides = flip, center = dossier (bike data first)**; the "tap anywhere → dossier" gesture is RETIRED and the B1 center-tap→fullscreen gesture is RETIRED in favour of it (v1.1).
|
||||
- Tapping the photo in the dossier hero opens the fullscreen image viewer (§11.3). Viewer close (✕, pull-down, or Esc) returns to the dossier; the next Esc returns to the deck. The dossier stays reachable from ⓘ and from list rows (§3/§4 unchanged).
|
||||
|
||||
### 11.5 Repeat rotation
|
||||
|
||||
|
||||
624
docs/V1.1-BUILD.md
Normal file
624
docs/V1.1-BUILD.md
Normal file
@@ -0,0 +1,624 @@
|
||||
# V1.1-BUILD — v1.1 implementation specification
|
||||
|
||||
Build spec for the v1.1 QOL batch. Requirements: `docs/BACKLOG.md` "v1.1 — QOL wishlist" (both subsections). Frozen UI contract this amends: `docs/UI-SPEC.md` (v2 + P3 §10 + B1 §11). Version map: `docs/PLAN.md`.
|
||||
|
||||
**Status:** APPROVED 2026-11-12 (Glenn): ≥2-second-looks default confirmed (rich day = 21 fresh + 2 second looks + 2 wildcards); violet band; Backspace kept as undo alias. Build authorized — implementation in progress on `dev`. Every item below states goal, exact change plan (file/function/line anchors verified against the code at `381b6c8`), pseudocode where the logic is heavy, edge cases, acceptance criteria, and the verification steps the parent will run. Nothing is built yet.
|
||||
|
||||
**No data reset. No schema change. v1.1 is frontend + read-path/query only** (see "Data safety"). The only logic rewrite is the compose allocation itself (`compose_section`), which still writes *only* what it writes today (a new `sections`/`section_items` row set, exactly as a forge already does).
|
||||
|
||||
## Code facts everyone should start from (verified 2026-11-12, commit `381b6c8`)
|
||||
|
||||
Backend:
|
||||
|
||||
- `app/sections.py` (488 lines): `NEW_POOL_SQL` (40–44), `RETURNS_SQL` (46–55), `WILDCARD_SQL` (57–61), constants `FAMILY_CAP=4 MAX_RETURNS=5 MAX_RETURN_NOPES=2 WILDCARDS=2 DEFAULT_SIZE=25 MIN_BANDS=3` (28–33), `pick_new` (160–178), `repair_bands` (181–256), `compose_section` (259–404), `section_items` (417–425), `section_counts` (428–454), `maybe_exhaust` (457–466), `read_section` (469–488).
|
||||
- `app/api.py` (738 lines): `/api/stats` (234–264), `swipe` POST (299–357; `section_id` optional at 307–309, `append_event` call at 345–346), `section_state` (446–471), `get_section` (473–488; cold compose hardcodes `size=25` at 482–485), `forge` (490–527), `/api/prefs` (652–666; `allowed = {'forge_mode': ('ondemand','strict')}` at 656), `img` with `object-fit:contain` viewer served at 670–708.
|
||||
- `app/db.py`: `swipe_events` schema with `section_id` (18–26), `append_event` (120–143) — already stamps `section_id` when the client sends it; P3 seeding copies events with `section_id=NULL` (111–117).
|
||||
|
||||
Frontend: `app/static/index.html` (1282 lines, single-file app):
|
||||
|
||||
- Keyboard handler ALREADY EXISTS at 1263–1270 (see item 1 — this must be reconciliated with the BACKLOG key map).
|
||||
- Tap zones: `tapZone` (756–763) — sides flip, center opens viewer. Built faithful to B1 §11.4. v1.1 changes the center-target only.
|
||||
- Deck→dossier door: `.ibtn` click (578–580); `openDetail` (768–796); dossier hero with `dphoto` (245) and hero-tap→viewer in `dEndH` (832–837).
|
||||
- Viewer: `openViewer` (870–877), `closeViewer` (878–883), `vCtx={item,idx,back}` (853, 873); `.vimg` (197) already `object-fit:contain`.
|
||||
- Card DOM: `phwrapHTML` (512–513) puts `<img class="photo">` inside the `.phwrap`; `.card .photo` is `object-fit:cover` (CSS 36).
|
||||
- Header: `#pill` (206, filled by `loadStats` 1127–1136 — it renders `live · new` from `/api/stats`), `#sect` (207) is the section progress pill, `.sect` CSS 137–138, `.pill` 29–30.
|
||||
- Empty state: `#empty` (212) with copy "You're all caught up."; CSS 95–97; shown only by `maybeRefill` in **legacy mode** (652) — unreachable in section mode, where the report card (`#report`, 213–224, shown at 660–662) owns exhaustion.
|
||||
- Section counter: client state `sectDecided/sectTotal` (1139); `paintSect` (1140–1145); increments in `commit` (684) and `undo` (706); server truth re-derived on every `updateSectionUI` (1157–1173) from `body.items[].decision` — the bug: `decision` is the listing's *lifetime* verdict, not a this-section decision.
|
||||
- `bandHTML` (482–489); `.band` (139), `.band.wild` (140), `.band.sl` (141); `hasSegs` band offset (188); `updateSectionUI` (1157); `forge` button flow (1180–1206); prefs pattern `setMode` (1174–1179); `loadStats` (1127).
|
||||
- Info-page hero: `.dphoto` (70) is `object-fit:cover`; list thumbs `.thumb` (110) are `cover` and stay that way.
|
||||
- Rubric display: dossier "Why this rank" block `#drank` (250–257) filled by `fillRank` (798–821) — gauge + `{points}/100` (805) + up to 4 breakdown lines (806–812) + footer (813–814); list rows show tank only (985).
|
||||
|
||||
Discrepancies found between docs and code (code wins; both recorded):
|
||||
|
||||
- B1 §11.4 says center-tap = fullscreen viewer. Code matches. v1.1 re-maps center-tap = dossier (BACKLOG UI change 1) — the UI-SPEC amendment in this doc supersedes §11.3/§11.4.
|
||||
- `sections.py` module docstring (2–17) and `docs/RANKING.md:29` still say "≤5 returns"; DATA-MODEL line 165 says "Max 5 returns per section". All replaced by item 9's formula (docs to update: RANKING.md:29, DATA-MODEL.md:165, the module docstring — the spec's one doc-touch, see item 9).
|
||||
- The 2026-11-12 empty-pool symptom ("forges returned 2-card sections") means the eligible-return pool is *near-empty today*; details in item 9.
|
||||
- Current keyboard handler maps **Backspace**, not ArrowDown, to undo, and does not prevent arrow page scroll — item 1 fixes this.
|
||||
|
||||
---
|
||||
|
||||
## Item 1 — Keyboard shortcuts
|
||||
|
||||
**Goal (BACKLOG "Shortcuts"):** ← nope, → like, ↑ maybe, ↓ undo (back one), Esc exits fullscreen views. Desktop/Bluetooth-keyboard benefit; no touch changes.
|
||||
|
||||
Notes before the plan:
|
||||
|
||||
- The expected row of actions shares handlers: commits go through `commit()` (`index.html` 677–689; button bindings at 721–723), undo through `undo()` (702–720; binding 724). The keys must call these exact functions so all P3 invariants (optimistic persist through `setDecision`, photo_idx, no-lock flight) hold — never bespoke handlers.
|
||||
- A keyboard handler already exists (1263–1270): ← / → / ↑ do the right things, but undo is **Backspace**, ↓ is unmapped, Esc is unmapped, there is no scroll guard, and the text-input guard covers only `INPUT`.
|
||||
|
||||
**Plan (all in `app/static/index.html`):**
|
||||
|
||||
1. Replace the handler (1264–1270) with the v1.1 key map:
|
||||
```
|
||||
ArrowLeft -> nope (commit(pile[0].el,'nope'))
|
||||
ArrowRight -> like (commit(pile[0].el,'like'))
|
||||
ArrowUp -> maybe (commit(pile[0].el,'maybe'))
|
||||
ArrowDown -> undo (undo())
|
||||
Backspace -> undo (undo()) // kept: existing users' muscle memory — note in Open Questions
|
||||
Escape -> exit fullscreen views (below)
|
||||
```
|
||||
2. Guard before acting: **ignore all keys while a text input has focus.** Extend the existing `e.target.tagName==='INPUT'` check to also skip `TEXTAREA`, `SELECT`, or any element with `isContentEditable` (the list screen has a live search input; searching with arrows must filter, not swipe):
|
||||
```
|
||||
const t=e.target;
|
||||
if(t && (t.tagName==='INPUT'||t.tagName==='TEXTAREA'||t.tagName==='SELECT'||t.isContentEditable)) return;
|
||||
```
|
||||
3. **Prevent arrow-key page scroll** (the app body is `overflow:hidden`, but focused buttons can still scroll; be safe): for the four arrow keys, `e.preventDefault()` immediately after the guard passes — i.e. before letting the browser's default horizontal/vertical scroll run. Backspace default is harmless and untouched.
|
||||
4. **Esc, one key, stack order** (viewer `#viewer` z-72 > dossier `#detail` z-70 > deck):
|
||||
- if `#viewer` has class `on` -> `closeViewer()` (878)
|
||||
- else if `#detail` has class `on` -> `closeDetail()` (822; returns to deck or, from a list row, to the list screen that stays open underneath — same as today's pull-down close)
|
||||
- else if `#report` has class `on` -> do nothing (Esc never forges or navigates tabs)
|
||||
- else -> ignore.
|
||||
Note: the currently-open sheet also swallows keys before Esc gets them, because the existing early-return for open `#detail`/`#viewer` is removed in favour of the Esc-first ordering above. Esc only closes; arrows only work on the deck.
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- Arrow keys must do nothing when no pile: `commit` and `undo` already no-op on empty `pile[0]`/`hist` (677–678, 703).
|
||||
- Key repeat (holding →): `commit` drains the pile as fast as repeat fires — same behaviour as mashing the like button, acceptable, no extra lock needed (the no-lock law already tolerates fast commits).
|
||||
- The report card is up but the section is closed: arrows no-op (pile empty); Esc no-ops; the Forge button remains mouse/tap only.
|
||||
|
||||
**Acceptance criteria (objective):**
|
||||
|
||||
1. New chromium/headless page, deck served: dispatch `ArrowLeft/Right/Up` -> top card flies nope/like/maybe; the very same network payloads fire as button taps (verify no second code path: instrument or assert `sectDecided`/paintSect side effects identical).
|
||||
2. Dispatch `ArrowDown` -> the swiped card returns to the top of the pile (undo flight + `DELETE /api/swipe/{id}` queued).
|
||||
3. Dispatch `Backspace` -> same undo.
|
||||
4. Focus the list search input, type arrows -> input cursor moves / text unchanged, zero swipe commits (assert pile length unchanged).
|
||||
5. While the dossier is open, all arrow keys are inert; Esc closes it. While the viewer is open, Esc closes only the viewer (dossier, if underneath, stays open; a second Esc closes it).
|
||||
6. Call `window.scrollTo(0,100)`-style check: with `document.body.scrollTop` manipulable, arrow dispatch does not change scroll (assert via `e.defaultPrevented` spy on `keydown`).
|
||||
|
||||
**Parent verification:**
|
||||
|
||||
1. `fe_walk_b1`-style headless walk: boot app, run acceptance 1–6 in order, assert green.
|
||||
2. Optional human spot-check on MacBook over the tailnet.
|
||||
|
||||
---
|
||||
|
||||
## Item 2 — Info-first tap flow
|
||||
|
||||
**Goal (BACKLOG UI changes 1):** center tap → bike data dossier first; tapping the photo there → fullscreen image viewer; side taps still flip photos; Esc walks back out (viewer → data → deck). Resolves "can't get info unless I hit the ⓘ button". Esc routing is item 1's stack; this item changes the tap targets + the viewer's back-chain.
|
||||
|
||||
**Current state:** `tapZone` (756–763) sends the center third to `openViewer(entry.d, entry.cur, {type:'card',entry})`; side thirds flip (`flipCard`, 525–536). `openDetail` is only reachable via ⓘ (578–580) / list rows (1036) / matches rows (1113). Dossier hero tap opens the viewer (832–837). Viewer close returns to whatever was under it (878–883).
|
||||
|
||||
**Plan (all `app/static/index.html`):**
|
||||
|
||||
1. `tapZone` (761): change the center branch to `openDetail(entry.d, {type:'deck'})`. Sides unchanged. Do not clear the card's photo position — the dossier is a sheet over the deck.
|
||||
2. **Esc walk-back chain (new):** `openDetail` (768) must record *how it was opened* so a viewer reached from it can walk back. Add one module-level variable, e.g. `let dEntry=null;` — set in `tapZone`'s new branch to `{...dCtx, entry}` (the pile entry with its live `cur` photo index), set to `null` for row/matches opens (1036, 1113) and for ⓘ (580). `closeDetail` (822) clears it.
|
||||
3. Viewer back-chain: when `tapZone`'s center branch opens the dossier, the dossier hero keeps its existing tap→`openViewer(dData,0,{type:'dossier'})` (835). Extend the viewer context so it can walk back to the dossier-on-deck:
|
||||
- in `openViewer` (870–877): pass anextra field on `back`, e.g. `{type:'dossier', walkBack:dEntry}` or simpler: make the dossier-hero call (835) pass `{type:'dossier', backToDetail:dEntry}`;
|
||||
- item 1's Esc handler calls, before plain `closeViewer()`, a new tiny `vWalkBack()`: if `vCtx.back.backToDetail` exists, capture the item, call `closeViewer()`, then `openDetail(item, backToDetail)` — image returns to the deck dossier (photo 0, per §3's hero contract), where the *next* Esc closes to the deck. If no `backToDetail`, plain `closeViewer()`.
|
||||
4. The dossier closes to exactly the deck it came from: when opened from a deck card, the ⓘ/pull-down close semantics (822) already leave the pile untouched; no change. From a list row, Esc closes to the list (already true).
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- One-photo / no-photo cards: center tap still opens the dossier (data-first is the point); the hero tap no-ops when `dData.img` is null (835 already guards).
|
||||
- The dossier's own action buttons (838–848) still commit the current top card — unchanged; the flow is open data, read it, swipe from inside it. That is desired: dossier actions exist today.
|
||||
- Viewer opened the old way from a deck card — gone: after item 2 there is no direct card→viewer path; every deck-carded viewer is reached via dossier. `{type:'card',entry}` back shape (873) becomes unused from the deck; leave the plumbing, back-chain field only added for the dossier path.
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Center tap (≤6px movement) on the top card opens `#detail` (`.on`), populated with that card's payload; **no** viewer opens; no commit fires.
|
||||
2. Side taps still flip photos both directions, clamped; no dossier opens (existing B1 §11.2 behaviour re-verified).
|
||||
3. Tap the dossier hero photo -> `#viewer` opens at photo 0. Esc -> viewer closes, dossier still open. Esc -> dossier closes, same deck/pile state and same top card (photo index intact).
|
||||
4. ⓘ tap still opens the dossier (regression).
|
||||
5. From the list: row tap -> dossier -> hero tap -> viewer -> Esc -> dossier -> Esc -> list (regression with the new Esc routing).
|
||||
|
||||
**Parent verification:**
|
||||
|
||||
1. Headless walk of acceptance 1–5 plus the B1 §11.7 suite re-run green (flip clamps, viewer swarm, no-lock, one `.topcard`).
|
||||
2. Human: phone pass — Glenn taps the middle of a card, sees data, taps the photo, sees fullscreen, Esc/Esc (desktop) or ✕/pull-close (touch) walks back out.
|
||||
|
||||
---
|
||||
|
||||
## Item 3 — Photos = option C (fit + blurred backdrop)
|
||||
|
||||
**Goal (BACKLOG UI changes 2, decided 2026-11-12: "OH C! I love C!"):** the whole photo is shown uncropped (fit) over a soft blurred backdrop of itself, on the deck card AND the info-page hero. Fullscreen viewer unchanged (already fits). List thumbs stay `cover` (56px, irrelevant). Demo reference panel C: `~/dev/bike-tinder-demos/fit-vs-fill.html`.
|
||||
|
||||
**Verified current CSS (index.html):**
|
||||
|
||||
- Deck card photo: `.card .photo{position:absolute;inset:0;width:100%;height:100%;object-fit:cover}` (36) — the element is inside `.phwrap` (513).
|
||||
- Info hero: `.dphoto{width:100%;height:100%;object-fit:cover;display:block}` (70) inside `.dhero` (69; bg `#17171c`).
|
||||
- Viewer: `.vimg{...object-fit:contain...}` (197) — already fits; **verify only, change nothing.**
|
||||
- List thumbs: `.thumb{...object-fit:cover...}` (110) — **unchanged.**
|
||||
|
||||
**Plan (CSS-only, `app/static/index.html` <style>):**
|
||||
|
||||
1. Deck card:
|
||||
- change line 36 to `object-fit:contain` (keep `position:absolute;inset:0;width:100%;height:100%`).
|
||||
- add inside `.phwrap` (512–513) a backdrop layer behind the sharp photo. HTML: when a `src` exists render `<div class="phblur"></div><img class="photo" ...>` (use an inline `style="background-image:url('...')"` from the same `photoSrc` value; escape the URL-attrs as the file already does elsewhere — the src is app-server-generated, but quote-escape it to be safe). CSS:
|
||||
```
|
||||
.phblur{position:absolute;inset:-18px;background-size:cover;background-position:center;
|
||||
background-repeat:no-repeat;filter:blur(22px) brightness(.55) saturate(1.1);transform:scale(1.08)}
|
||||
```
|
||||
The photo gets a touch of shadow so the edge reads on top of the blur: `filter:drop-shadow(0 6px 24px rgba(0,0,0,.45))` on `.card .photo`. The `nophoto` fallback path (513) renders no `.phblur`, naturally.
|
||||
- `container` presence check: `.card .grad` (37) sits over the fit area — fine (it is a scrim, UI-SPEC §2).
|
||||
2. Info-page hero:
|
||||
- change line 70 to `object-fit:contain`.
|
||||
- give `#dphoto` the same twin: add a `.dblur` div inside `.dhero` (245) *behind* the image, styled identically to `.phblur` (`.dhero` has no `overflow:hidden`; add it). Populate on `openDetail` (772 area): same `data.img` URL, emptied when no photo / error fallback (774). Simplest robust approach: reuse a tiny helper `setBackdrop(shellEl, url)` called from `openDetail` and `phwrapHTML`'s error/success paths.
|
||||
3. No-reflow guarantees: both fits put letterbox bars around the photo; because the photo is `position:absolute` and the blur is a sibling underneath, nothing shifts. Card title/text keep their spot (info block is below the fold of a 4:3-ish area; on unusually tall images the photo shrinks towards the center and the bottom gradient may clip more of it than today — accepted, that is the point of "uncropped").
|
||||
4. Cost note: `filter:blur(22px)` per card × up to 5 cards. GPU-composited in Chrome/Safari; on the older iPhone, if paint cost shows, drop the blur radius to 16px or disable the backdrop layer when `prefers-reduced-motion` — implementer's knob, not a spec change.
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- 0-photo listing: `.nophoto` panel unchanged, no backdrop, dossier hero dimmed as today.
|
||||
- Aspect extremes (portrait screenshots inside 16:9 crops): letterbox grows as the photo gets wider/taller; clamp with a `max-height:100%` implicit via fit (contain already does), nothing else needed.
|
||||
- B1 preloader (538–551) fetches `photoSrc` — unaffected.
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Computed style on a rendered deck card photo == `object-fit:contain`; a backdrop node exists per card and its background-image equals the photo's resolved URL; paddings/sizes of the info block are unchanged vs pre-change (measure before/after in the headless walk).
|
||||
2. Dossier hero photo == `contain`, backdrop present, spec table layout unmoved.
|
||||
3. Viewer `.vimg` computed style == `contain` (no diff), list `.thumb` == `cover` (no diff).
|
||||
4. 0-photo card and 1-photo card still render their fallbacks (B1 §11.7 fallback checks re-run).
|
||||
|
||||
**Parent verification:** headless computed-style assertions 1–4 + half a dozen screenshots (portrait + landscape cards, dossier, viewer) eyeballed against the demo's panel C.
|
||||
|
||||
---
|
||||
|
||||
## Item 4 — Minimal rubric + debug "why" toggle
|
||||
|
||||
**Goal (BACKLOG UI changes 3):** bike views show ONLY the gas-tank gauge + percent full (e.g. "76%"); a setting re-enables the full "why" breakdown for debugging. Wired via the existing `prefs` key/value API (same pattern as `forge_mode`).
|
||||
|
||||
**Where rubric displays today (index.html):**
|
||||
|
||||
- Dossier "Why this rank" block `#drank` (250–257), filled by `fillRank` (798–821): gauge (`drankTank`), `{points}/100` (805), breakdown lines (806–812), footer (813–814).
|
||||
- List rows: tank gauge only, inside `rowHTML` (985) — already minimal; **untouched**.
|
||||
- Deck card face: no rubric display — nothing to do.
|
||||
|
||||
**Plan:**
|
||||
|
||||
Backend (`app/api.py`):
|
||||
|
||||
1. Extend the allowed prefs set (656): `allowed = {'forge_mode': ('ondemand','strict'), 'rubric_debug': ('off','on')}` — the key/value API then accepts `{key:'rubric_debug', value:'off'|'on'}` with zero new plumbing (the endpoint at 652–666 is generic).
|
||||
2. Expose the value so the FE can paint: add to `section_state` (446–471) one field, e.g. `data['prefs'] = {'rubric_debug': get_pref(conn, 'rubric_debug', 'off')}` (same read shape as `data['mode']` at 453). `/api/section` and the forge response already go through `section_state`, so every section load carries it. No `/api/stats` change needed.
|
||||
3. Nothing else backend-side: the breakdown payload (`points_breakdown`) is already in section items (`include_breakdown=True`, 454–456) — cheap to keep sending.
|
||||
|
||||
Frontend (index.html):
|
||||
|
||||
4. `fillRank` (798–821) renders by default: the gauge (existing 804) + compact "76%" label. Change 805 from `data.tank.value+'/100'` to `data.tank.value+'%'` and move the label into the existing left gauge column or directly beside it (e.g. wrap gauge + `%` in the `.tankwrap`).
|
||||
5. Guard the detailed parts behind the pref: build the `dlines` HTML (806–812) and the `dfoot` line (813–814) ONLY when the pref is `'on'`; otherwise empty both and keep `#drank` visible with just gauge + `%` (the block itself persists so the minimal state is still "gauge + %", matching the BACKLOG ask).
|
||||
6. Toggle UI (findable by Glenn, harmless otherwise): add to the Trends "Actions" area (317–320) a second `.trow` exactly in the `setMode` style (1174–1179 + 1248–1249): "Why breakdown: on ⇄ off", both spans wired like `tOnd`/`tStr` to a new `setRubricDebug(m)` that POSTs `/api/prefs` and updates the sections-wide `section.prefs.rubric_debug` for the next `fillRank`. Persist per session: `updateSectionUI` (1157–1173) also stores `section.prefs` (already via body) so a re-loaded deck repaints correctly.
|
||||
7. `fillRank` reads `((section&§ion.prefs&§ion.prefs.rubric_debug)==='on')`; also keep the existing on-the-quiet `/api/listing/` enrichment for list rows (816–819) guarded the same way — when off, don't fetch (saves a request; nothing is displayed).
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- Legacy (no `/api/section`) mode: `section` is null → pref off → minimal display; the API call for the toggle then target isn't the issue (legacy servers return 404 on `/api/prefs` POST; FE silently ignores failure, `setMode` precedent 1175–1176).
|
||||
- `tank.value` null (unscored/deep rows): `fillRank` already hides the whole block (799–802) — unchanged.
|
||||
- The percent must be the rounded tank value (0–100 clamp is already applied in `tankSVG` 455).
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Dossier for a scored listing shows gauge + "NN%" and NO breakdown lines, NO footer line, on a fresh load (pref unset).
|
||||
2. `POST /api/prefs {rubric_debug:'on'}` → 200 `{key,value}`; reload → same dossier shows breakdown lines + footer. `'off'` → they disappear. Invalid value → 400.
|
||||
3. List rows and card face carry zero rubric text in both states (regression).
|
||||
4. Pref survives server restart (SQLite `prefs`) and page reload; forge response carries it.
|
||||
|
||||
**Parent verification:**
|
||||
|
||||
1. TestClient: prefs happy path / 400 path; fresh-DB `/api/section` body includes `prefs.rubric_debug`.
|
||||
2. Headless: dossier DOM assertions with the pref off and on (steps A2).
|
||||
|
||||
---
|
||||
|
||||
## Item 5 — Section counter fix (the 2/2 → 3/2 bug)
|
||||
|
||||
**Goal (BACKLOG "Counter bug"):** count a card as decided only if decided DURING this section (server-side per-item flag, from events stamped with this section_id — the source `section_counts` uses); clamp to total; no premature "hot"/complete state.
|
||||
|
||||
**Root cause (verified):** `section_items` (sections.py 417–425) LEFT-JOINs `swipes` so items carry `decision` = lifetime verdict. A second-look card enters its section with `decision='like'|'maybe'|'nope'` already set, but it has NOT been decided in this section (no event with `section_id` = this section). `read_section` progress (473) and the FE (`updateSectionUI` 1160–1164) count those as decided → fresh batch paints "2/2" before any touch; the next swipe increments optimistically (`commit` 684) → "3/2". Fix = use only events with `e.section_id = section.id` as the decided set, plus clamping at the FE.
|
||||
|
||||
**Plan:**
|
||||
|
||||
Server (`app/sections.py`):
|
||||
|
||||
1. Add a helper next to `section_counts`:
|
||||
```sql
|
||||
SELECT e.listing_id FROM swipe_events e
|
||||
JOIN section_items si ON si.section_id = e.section_id
|
||||
AND si.listing_id = e.listing_id
|
||||
WHERE e.section_id = ? -- decisive: an event stamped in THIS section
|
||||
```
|
||||
as `section_decided_ids(conn, section) -> set(listing_id)`. (Filtering to `si.listing_id` membership keeps out-of-section stray events from a foreign section_id honest; the join is the same shape `section_counts` uses at 439–451.)
|
||||
2. Add the per-item flag on the read path: `section_items` cannot see events per row without a second join; cheaper — after building `items` in `read_section` (471–472), set `item['decided_this_section'] = item['id'] in decided_ids`. (`sqlite3.Row` is read-only until cast; either materialize items as dicts there or attach the flag in `api.section_state` (447–457) where items are rebuilt as full payloads anyway — recompute `section_decided_ids` once in `section_state` and add `p['decided_this_section'] = p['id'] in ids` alongside `p['slot']` at 454–456. Prefer this: one read, no Row mutation.)
|
||||
3. `read_section` progress (473): `decided = sum(1 for it in items if it['decided_this_section'])`. `maybe_exhaust` (457–466) **unchanged** — it must wait for real in-section verdicts too, which it now does automatically because `section_items` is ALSO the joined-swipes view it reads... No: `maybe_exhaust` reads `it['decision'] is not None`. Change line 462 to check `section_decided_ids(conn, section)` membership instead: `undecided = [it for it in items if it['id'] not in decided_ids]` and `if not undecided: close_section(...)`. Otherwise a returns-only section reports "complete" before a single strike. This is part of the same fix.
|
||||
4. `section_counts` (428–454) already derives like/maybe/nope from `decision` (432–438) — same lifetime-verdict flaw in *report numbers*. Change its per-item loop to use the same decided-ids set: count an action for this section ONLY when an event with this `section_id` exists and matches (`SELECT e.listing_id, e.action ... WHERE e.section_id=?` joined to `section_items` the same way; the existing `restruck`/`wildcard_hits` queries at 439–451 already do exactly this join — mirror it). Note: this does not change what is *stored*, only what the report shows.
|
||||
5. No DB writes anywhere in this item (flag is computed per read).
|
||||
|
||||
Frontend (`app/static/index.html`):
|
||||
|
||||
6. `updateSectionUI` (1157–1173) counting loop (1160–1163) → `if(local===undefined ? !!it.decided_this_section : local!=null) decided++`. (Local intent still wins while a swipe's POST is in flight — the optimistic window is seconds and cannot resurrect the 2/2 bug because it only ever reflects what the user just did in this session.)
|
||||
7. Clamp everywhere `sectDecided` is incremented, so a stale/foreign path can never paint past the total: `commit` (684) → `sectDecided=Math.min(sectTotal, sectDecided+1)`; `undo` (706) already clamps the floor. `paintSect` (1140–1145) additionally renders `Math.min(sectDecided, sectTotal)`.
|
||||
8. Hot state: `paintSect` toggles `hot` only when `sectDecided>=sectTotal` (1144, unchanged code) — with in-section counting this now fires only when the section truly has a verdict per card; `commit` keeps painting immediately after a full sweep (the server resync in `maybeRefill` 663–666 handles the exhausted flip and a rapid double-swipe resync on deck reload straightens the numbers, same as today).
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- **Undo of a swipe on a second look (return slot) that already has a lifetime verdict:** the DELETE restores the prior `swipes` row and clears no `section_id` event (out of scope — see Data safety), so the server's in-section decided count still contains that card until the section dies. The FE decrements optimistically (706), then a resync re-counts it. Net: `sectDecided` may show one more decided than the user feels, but NEVER past `sectTotal` thanks to the clamp, and never "hot" before the section is substantively done. This same artifact exists today, worse. Flagged in Open Questions (a true fix needs an event-deletion rule — data semantics, v1.2 territory).
|
||||
- List/matches edits during a section: swipes posted WITHOUT `section_id` (setDecision from rows, 844–845) → no event with this section_id → a card in the section whose verdict was flipped from the list is (correctly) not counted as decided-in-section. The deck will simply re-offer it if still in buffer — acceptable and consistent.
|
||||
- **Seeded legacy events have `section_id=NULL`** (db.py 111–117): they never count for any section — exactly the intended behaviour (they predate sections).
|
||||
- `decided_this_section` must be present for ALL items in `section_state` payloads or the FE `local===undefined` branch misfires — set it unconditionally (not only for returns).
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Compose a returns-only section (fresh pool 0 — reproducible by DELETE-ing all fresh rows' absence or staging a DB where every active listing has a swipe): `/api/section` `progress.decided == 0` even though every `item.decision` is non-null; every `item.decided_this_section == false`.
|
||||
2. Post one swipe with `section_id`: progress 1/2; recount matches events; `paintSect` shows 1/2. Post the second: 2/2, `hot` class present, section flips to `report` on next read, report counts reflect the two verdicts (not lifetime).
|
||||
3. With 2 items and a double-swipe (two commits before any resync): painted pill never exceeds `2/2` (clamp assertion).
|
||||
4. A section that mixes new + return: decided counts only in-section events on both slots; a fresh item swiped from the LIST (no section_id) leaves `progress.decided` unchanged.
|
||||
5. Full P3 regression: compose→strike→rounds→report→forge loop green; undo restores the previous pill value minus one.
|
||||
|
||||
**Parent verification:**
|
||||
|
||||
1. Selfcheck additions in `selfcheck.py` (new checks against a temp DB, same style as existing) + the staged-DB walk in acceptance 1–4.
|
||||
2. Live-DB dry run: snapshot `swipe_events`, compute `section_decided_ids` for the current section, assert it matches the user-visible count story. No writes.
|
||||
|
||||
---
|
||||
|
||||
## Item 6 — Dry-catalog messaging
|
||||
|
||||
**Goal (BACKLOG "Dry-catalog messaging"):** whenever a composed/forged batch reports `new: 0`, surface "Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks" in the UI and label forge results accordingly, so the deck never silently drips 2 cards.
|
||||
|
||||
**Why it happens:** `NEW_POOL_SQL` (sections.py 40–44) is empty once every active listing has a swipe row; `compose_section` still forges from `RETURNS_SQL` — under v1 formula a few cards (night-of-symptom: 2). By design, but invisible.
|
||||
|
||||
**Plan:**
|
||||
|
||||
Server: the recipe already carries the number. `compose_section` returns `recipe: {'new': ..., 'return': ..., 'wildcard': ...}` (377–386) and `section_state` (446–471) already exposes `recipe` in `read_section` (479–480). **No server change required for the number itself.** Optional hardening: `forge` (490–527) appends to its `note` when the composed recipe has 0 new — e.g. `note += ' · catalog fully reviewed'` — so `section_state(note=...)` returns a labeled state (469–470); the FE below is the primary surface.
|
||||
|
||||
Frontend (index.html):
|
||||
|
||||
1. Shared renderer: a function `dryLabel(body)` → `body.recipe && body.recipe.new===0` (and `body.items.length>0`, i.e. there IS a section being served) → the BACKLOG sentence. Wire it into both hydrations:
|
||||
- `updateSectionUI` (1157): show/hide a new caption node in the report block — reuse `#strictCap` pattern (223): add `<div class="rcap" id="dryCap">Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks</div>` to `#report` (212–224 area; display:none default), toggled by `dryLabel`. Report is where the deck lands after the batch, so the message persists exactly where Glenn looks.
|
||||
- `btnForge` success path (1188–1198): when the forge response is dry → `$('forgeStatus').textContent = dry text` (instead of blanking at 1189–1190) and `dryCap` stays visible via the `updateSectionUI(body)` call (1197).
|
||||
2. Fresh inventory restored mid-session (import lands): `loadSection` already refetches on reload/resync — `updateSectionUI` recomputes `dryLabel` every time; no timer needed.
|
||||
3. Copy stays exactly the BACKLOG sentence (keep "08:30" hardcoded as today — same assumption the empty state makes).
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- Dry + zero items (nothing left at all): item 8's loud empty owns that state — `dryCap` must NOT show there (guard on `items.length>0`).
|
||||
- `recipe` absent/legacy API: no label; `dryLabel` returns false (body check).
|
||||
- Forge in `strict` mode can't be run anyway; the caption still paints from `GET /api/section` on load.
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Forge with `recipe.new:0` and >0 items → forgeStatus shows the exact sentence; report shows `dryCap`; a subsequent full-import + reload clears it (recipe.new>0).
|
||||
2. Non-dry forge → `dryCap` absent, forgeStatus behaves as before.
|
||||
3. Deck behaviour unchanged otherwise (no new fetch loops; swipes unaffected).
|
||||
|
||||
**Parent verification:** staged-DB forge with an emptied fresh pool; assert the DOM states in A1/A2 + the existing section-loop selfcheck green.
|
||||
|
||||
---
|
||||
|
||||
## Item 7 — Fresh counter (header)
|
||||
|
||||
**Goal (BACKLOG "Fresh counter"):** extend `/api/stats` with `fresh` = active listings with no swipe (the `NEW_POOL_SQL` predicate); header shows "N fresh" by the existing live/new pill. Zero reads at a glance.
|
||||
|
||||
**Plan:**
|
||||
|
||||
Backend (`app/api.py`, `stats`, 234–264):
|
||||
|
||||
1. Add one query next to `live` (238–240):
|
||||
```sql
|
||||
SELECT COUNT(*) AS n FROM listings l
|
||||
WHERE l.status='active'
|
||||
AND NOT EXISTS (SELECT 1 FROM swipes s WHERE s.listing_id = l.id)
|
||||
```
|
||||
— verbatim the `NEW_POOL_SQL` predicate (sections.py 40–44). Add `'fresh': fresh` to the return dict (254–262). Note the deliberate semantic: a like/nope/maybe row of ANY age removes freshness (fresh = never touched), which is the same predicate the pool uses. A maybe swiped 8+ days ago that the legacy deck re-admits is still not "fresh" — correct per definition.
|
||||
2. No other backend change: `fresh` can differ from `live - decided` because `swipes` rows are never deleted by undos that keep events, and list edits create rows too — define fresh exactly by the predicate above and do not try to reconcile.
|
||||
|
||||
Frontend (index.html, `loadStats`, 1127–1136):
|
||||
|
||||
3. Change the pill line 1130 to `<b>${res.live}</b> live` + `· <b>${res.fresh}</b> fresh` (always shown; `` fresh `0` when the pool is dry — that's the point) + the existing new-count only when >0. Spacing stays in the one `.pill` (206). Match the UI-SPEC §10.1 fit rule (no layout shift — a pill string is fine).
|
||||
4. Add the same fresh number to the list sub-line? No — keep `lsub` unchanged (1131); the header pill is the requested surface.
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- Fresh goes below 0/negative never (a COUNT).
|
||||
- Badge `new` counts first-seen-since-visit, an orthogonal thing; both can coexist in the pill.
|
||||
- Old API (missing `fresh`): `res.fresh` undefined → guard (`res.fresh??0` or `typeof res.fresh==='number'?res.fresh:0`), fallback renders no fresh segment.
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Fresh staging DB: 5 actives, 3 with a swipes row, 2 not → `/api/stats.fresh == 2`; header pill text contains "2 fresh".
|
||||
2. All-5 swiped → `fresh:0`; pill shows "0 fresh" (not hidden).
|
||||
3. Swiping one card → next `loadStats` shows 4 fresh (server read reflects the upsert; FE doesn't optimistically touch the stats pill — the pill updates on next stats fetch, same as today).
|
||||
|
||||
**Parent verification:** TestClient stats assertions on the staged DB + headless DOM text check after a swipe.
|
||||
|
||||
---
|
||||
|
||||
## Item 8 — Loud empty state ("No more new bikes!")
|
||||
|
||||
**Goal (BACKLOG "Empty state, loud"):** when the deck can serve nothing at all — no fresh, no eligible second looks, no wildcards — show a prominent "No more new bikes!" keeping the "next import 08:30" line. Today's `.empty` ("You're all caught up") is unreachable in section mode (only `legacyMode` shows it — `maybeRefill` 649–654) and the report card masks exhaustion.
|
||||
|
||||
**Plan:**
|
||||
|
||||
Server (`app/sections.py` + `app/api.py`):
|
||||
|
||||
1. New pool helper in `sections.py` (mirrors the composer's candidate queries, minus the per-section exclusions — "can the forge serve anything?"):
|
||||
```python
|
||||
def pool_counts(conn):
|
||||
fresh = count(NEW_POOL_SQL)
|
||||
rets = count(RETURNS_SQL)
|
||||
wilds = count(WILDCARD_SQL)
|
||||
```
|
||||
(`RETURNS_SQL` is the composer's own eligibility predicate — resting/one-shot/last-two rules included; the last-two exclusion inside `compose_section` (274–278) is skipped here so the answer is about *stock*, not *this batch*; document that choice.)
|
||||
2. `section_state` (446–471) gains `data['pool'] = secmod.pool_counts(conn)` (fresh/returns/wildcards). Every section GET + forge response carries it. No write.
|
||||
|
||||
Frontend (index.html):
|
||||
|
||||
3. **Loud empty element:** new `#empty2` beside `#report` in `#stage` (after 212), styled prominently (CSS near 95–97): big title 22px/800, larger panel (min-height ~220px), accent border, centered; copy:
|
||||
```
|
||||
<b>No more new bikes!</b>
|
||||
New bikes arrive nightly — next import 08:30.
|
||||
(↺ still brings the last card back — keep the line only if it remains true after item 1.)
|
||||
```
|
||||
4. **Reachability (the fix):**
|
||||
- `maybeRefill` (649–674) section-mode branch: BEFORE the `sectDecided>=sectTotal` report check, if `section.pool` exists and `!buffer.length&&!pile.length` and `section.pool.fresh===0 && section.pool.returns===0 && section.pool.wildcards===0` → show `#empty2`, hide `#report` and `#empty`.
|
||||
- `btnForge` success path (1188–1206): after `updateSectionUI`, run the same check against the new body — if the forge returned zero items and `pool` is all-zero, show `#empty2` and don't leave the report's Forge button inviting a wasted agent run (hide the button or keep row; show empty2 above it).
|
||||
- Report screen stays the state for "section finished, more remains" (pool non-zero) — unchanged.
|
||||
5. Keep `.empty` (legacy mode) as-is; `#empty2` exists only for section mode. Undo (`undo()` 702–720) removes `#empty2`'s `.on` class exactly like it clears `.empty`/`.report` (718–719).
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- The last-two-sections exclusion: a listing only appears in the last two sections' worth of items — pool query ignores that; near-total exhaustion could still leave 1–2 stale-but-served listings? No: `section_items` only blocks `RETURNS_SQL` re-offer, not `NEW`/`WILDCARD`; if pool counts say zero, compose genuinely returns zero cards (same SQLs). The tiny edge where pool>0 but compose emits 0 due to last-two+wanted-order interplay is handled by the `items.length===0` fallback: empty2 shows when a forge returns no cards AND pool is all-zero; if forge returns 0 items with pool>0 (should not happen), show empty2 with the dry line instead and log — implementer's guard, not spec.
|
||||
- Import lands at 08:30 → first visit reloads sections: pool.fresh>0 → empty2 clears automatically on the next `loadSection`. No push, same as all state today.
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Staged DB with zero fresh, zero eligible returns, zero wildcards: `/api/section` body includes `pool` all-zero and `items` empty; FE shows `#empty2.on` with the exact title "No more new bikes!" and the 08:30 line; `#report` NOT shown.
|
||||
2. `pool.returns>0` (dry but alive) → report card shown, `dryCap` (item 6) active, NO empty2.
|
||||
3. Undo restores the last card from empty2 → empty2 hides (718–719 parity).
|
||||
4. Report + forge loops still work when pool is non-zero (regression).
|
||||
|
||||
**Parent verification:** staged-DB headless walk A1–A4; plus the nightly-import path simulated by inserting one fresh listing + reload → normal deck.
|
||||
|
||||
---
|
||||
|
||||
## Item 9 — Batch formula v2 (compose rewrite)
|
||||
|
||||
**This item AMENDS the frozen P3 rule "≤5 returns per section"** (`RANKING.md:29`, `DATA-MODEL.md:165`, `sections.py` docstring 2–17 — all say ≤5 / max 5). Say so in the commit notes. New rule, Glenn's words (BACKLOG "Batch formula v2"):
|
||||
|
||||
- Every batch targets **25 cards**.
|
||||
- Fresh first (up to 23 slots); **≥2 second looks per batch whenever eligible stock exists** *(DEFAULT PENDING GLENN'S CONFIRMATION — the alternative, pure-fresh batches on rich days with second looks as fill only, is below)*; when fresh < 23, second looks FILL the remainder up to 25 (his example: 5 fresh + 20 second looks).
|
||||
- Leftover fresh rolls to the next batch.
|
||||
- Limits kept: ≤2 re-noped returns per batch; family cap relaxes for fill-returns when needed (spec below); returns stay one-shot.
|
||||
- Fresh exhausted → second-looks-only batches; returns exhausted → fresh-only; both → item 8's loud empty state (forges may return 0 items — already legal: `compose_section` inserts whatever it picks, 388–401).
|
||||
|
||||
### Allocation (the exact slot math, spelling out the 23/25/2 interplay)
|
||||
|
||||
Wildcards keep their 2 slots (BACKLOG leaves them standing; `WILDCARDS=2` 31). Resolve the equations in this order:
|
||||
|
||||
```
|
||||
want_ret = 2 if len(ret_cands) >= 2 else len(ret_cands) # the >=2 guarantee
|
||||
(0 when ret_cands empty -> pure-fresh batch)
|
||||
want_wild = 2 if usable wildcard candidates exist else fewer
|
||||
fresh_cap = 23
|
||||
want_fresh = size(25) - want_ret - want_wild
|
||||
clamped to min(len(new_cands), fresh_cap)
|
||||
```
|
||||
1. Returns and wildcards take their reserved slots FIRST (returns before wildcards before fresh, so the guarantee can never be crowded out by fresh).
|
||||
2. Fresh fills the remainder: `want_fresh = 25 - want_ret - want_wild` (max 23 when want_ret=2&wild=0? No — min is 21 on a rich day with 2+2 reserved). Then, **fill slack**: if `len(ret_cands)` has more offers and `len(picked) < 25`, add returns in role order (maybe > like > nope, points DESC — existing key 305–310) until 25 or the pool dries.
|
||||
|
||||
The resulting shapes on Glenn's scenarios:
|
||||
|
||||
- **Rich day, returns exist:** 25 cards = up to 23 fresh + ≥2 second looks + 2 wildcards. With 2 wildcards AND the 2-return guarantee, a full deck actually reads 21 fresh / 2 returns / 2 wildcards. (This is the one arithmetic consequence of "≥2 always" + "wildcards keep 2" + "target 25". The veto alternative below restores 23 fresh + ≤2.)
|
||||
- **His dry-day example:** 5 fresh + fill returns up to total 25 → 5 fresh + up to 18 returns + 2 wildcards (or 20 returns + 0 wildcards when the wildcard pool is dry — his literal "5 fresh + 20 second looks"). Fractional pools (e.g. 5 fresh + 12 returns) produce a short section (<25) — correct; nothing is invented to pad.
|
||||
- **Fresh = 0:** returns-only section(s) up to 25 cards each until the ~one-shot pool (≈0–30 remaining tonight per BACKLOG) dries — burns fast; BACKLOG's noted consequence is accepted in v1.1: after that, only nightly imports feed the deck.
|
||||
- **Returns = 0:** fresh 25-card batches again (plus wildcards).
|
||||
- **Both 0:** the loud empty state (item 8). Forge then legitimately returns a zero-item composed row; the FE renders empty2 — the report screen's Forge button should also stop being the only thing on screen (item 8 handles the mask).
|
||||
|
||||
### Re-nope + family-cap rules for fill-returns
|
||||
|
||||
- Keep ≤2 nope-verdict returns per batch (`MAX_RETURN_NOPES` 30; the "surprising" gate at 317–321 stays for *reserved* nope slots only).
|
||||
- **Fill-returns relax the family cap:** when selected as fill and the choice is between skipping the cap and landing a short deck, raise the per-family limit for `return`-slot items from 4 to 8 (fill-returns only; fresh picks and reserved returns keep 4). Deterministic: fill sweeps role order; a candidate that would exceed 8 is skipped; <=4 is always preferred pass 1 (two-pass fill: first under cap 4, then under cap 8).
|
||||
- Returns stay one-shot (`RETURNS_SQL`'s `NOT EXISTS section_items slot='return'` 53–54) and re-noped items rest forever (50–52). **No change to those predicates.**
|
||||
- Prefer not to burn the whole one-shot pool in two batches? The BACKLOG explicitly notes the pool ~30 tonight and accepts the burn; no v1.1 policy change. **If Glenn instead wants a drip feed, that is the veto line in Open Questions.**
|
||||
|
||||
### Compose pseudocode (replaces the flavour of `compose_section` at 259–404; structure kept)
|
||||
|
||||
```
|
||||
compose_section(conn, engine, size=DEFAULT_SIZE, ...):
|
||||
now, rows_by_id, last_two # unchanged (266-271)
|
||||
new_cands = NEW_POOL_SQL - last_two # unchanged (273-274)
|
||||
ret_cands = RETURNS_SQL - last_two # unchanged (275-276)
|
||||
wild_cands = WILDCARD_SQL - last_two - excluded_fams # unchanged (277-289)
|
||||
fam_count, picked_ids # unchanged (291-292)
|
||||
top3 = pick_new(...) ; top_fams/top_bands # unchanged (294-298) — feeds wildcard
|
||||
# preference; pure pick, no commit
|
||||
|
||||
# 1) reserved returns: min(2 + shortfall_unknown, len(ret_cands)), role order
|
||||
reserved_rets = ret_cands sorted by role_order/points; take until want_ret_nopes-rule or 2-max;
|
||||
always count the 2 GUARANTEED slots (skipping only ineligible nopes)
|
||||
# 2) wildcards: n_wilds = 2 (existing novel/preferred pick 328-358, unchanged)
|
||||
# 3) fresh: want_fresh = size - len(rets_reserved) - n_wilds, capped 23; pick_new (360-362)
|
||||
# 4) fill returns: while len(rets)<size-n_wilds-len(picked_new) and ret_cands remain:
|
||||
next in role order; nope cap (<=2 total incl. reserved);
|
||||
family rescue pass at cap 8 for fill only
|
||||
# 5) repair bands on new slots only (unchanged 367-375)
|
||||
# 6) pinned order new -> returns -> wildcards (unchanged 364-365); recipe/JSON/inserts
|
||||
unchanged (377-404) with recipe.new/return/wildcard the real counts
|
||||
```
|
||||
|
||||
Deliberate simplifications vs a full re-derivation:
|
||||
|
||||
- `pick_new`'s family cap 4, band repair, wildcard novelty, excluded families, LAST_TWO exclusion: **all unchanged** (160–178, 181–256, 284–289, 329–358).
|
||||
- The `wanted_rets` line 304 dies; the reserved-returns stage replaces it. Constants at 28–33: `MAX_RETURNS` is deleted/renamed (fill is bounded by size), `MAX_RETURN_NOPES` stays 2, add `FRESH_CAP=23` and `MIN_RETURNS=2` (pending Glenn's confirmation — the DEFAULT in this spec).
|
||||
- `read_section`/`section_state`/FE need **zero changes for the formula itself** — a section of any size ≤25 renders as today (progress pill counts `body.progress.total`).
|
||||
|
||||
Edge cases:
|
||||
|
||||
- Fewer than 2 eligible returns but ≥1: guarantee degrades gracefully (1 return + fill from... nothing else exists, that's the pool) — never fake it.
|
||||
- `size` stays the clamp (`size=25` default; the forge endpoint 492–495 accepts 1..100 — body `size` unchanged in the FE which always sends 25/`{}`).
|
||||
- Batch smaller than 25 mid-drain: the FE, report, and progress all already key off `progress.total`; nothing to cap client-side.
|
||||
|
||||
The veto alternative (record for Glenn):
|
||||
|
||||
- **≥2-always** (this spec's DEFAULT): every batch with any eligible return carries ≥2 second looks, even on a rich fresh day (21/2/2 shape). Keeps Glenn's "min 2" literally true.
|
||||
- **Pure-fresh-on-rich-days:** reserve 2 wildcards + up to 23 fresh; returns used ONLY as fill when fresh < 23 (rich day → 23 fresh + 2 wildcards + 0 returns). This obeys "fresh first, up to 23" literally but drops the "min 2" guarantee on the days he has the most fresh to see. One boolean switch in the allocator (`min_ret = 2 if Glenn confirms else 0`); nothing else moves.
|
||||
|
||||
**Acceptance criteria (staged DBs, deterministic pools):**
|
||||
|
||||
1. Pool 30 fresh / 10 eligible returns / wildcards available → forge composes 25: fresh + wildcard + return counts match the ≥2 + fill math; `recipe` JSON exact; `progress.total == 25`.
|
||||
2. Pool 5 fresh / 20 eligible returns / wildcards available → 25 cards, 5 fresh, returns fill to 20 (with 2 wildcards → 18; without → 20); his example honoured modulo wildcards.
|
||||
3. Pool 23 fresh / 5 returns / wildcards available → fresh 21 + returns 2 + wildcards 2 (the ≥2 formula) — and this exact result is the sentence Glenn must sign off (Open Questions).
|
||||
4. Pool 0 fresh / 12 returns → 12-card returns-only section; ≤2 nopes present; no item repeated from either of the previous two sections (LAST_TWO).
|
||||
5. Pool 40 fresh / 0 returns → 25-card fresh batch, order points DESC, leftover 15 fresh roll and appear in the NEXT forge (compose twice, zero overlap, no re-offer).
|
||||
6. Pool 0/0/0 → composed section with `items=[]`, FE shows item 8's empty2.
|
||||
7. Family cap: a fill-heavy batch with a dominant family raises its return-slot count only to ≤8 and never violates ≤4 for fresh/reserved; band-repair still reaches 3 bands when possible.
|
||||
8. Re-nope gate: exactly ≤2 nope-verdict returns per batch; a rested item (round≥2 nope) never appears.
|
||||
|
||||
**Parent verification:**
|
||||
|
||||
1. `selfcheck.py` additions driving `compose_section` against generated temp DBs for A1–A8 (the module is pure Python + SQLite and already selfcheck-tested this way for P3).
|
||||
2. Full P3 loop regression on a rich and a dry DB: compose → strikes → rounds → report → forge → counts; trends numbers unchanged in shape.
|
||||
|
||||
---
|
||||
|
||||
## Item 10 — Second Look band pops
|
||||
|
||||
**Goal (BACKLOG "Second Look band pops"):** `.band.sl` is near-invisible today — re-tint to a **violet accent** (bold fill + border), on card face + info view. Wildcard stays amber for contrast. *(DEFAULT violet pending Glenn's nod — one-line re-tint if he prefers another hue.)*
|
||||
|
||||
**Current:** `.band.sl{color:rgba(255,255,255,.85);background:rgba(255,255,255,.10);border:1px solid rgba(255,255,255,.22)}` (141) — white ~10% on dark, matches the P3 §10.3 second-look recipe (142). The band appears where `bandHTML` renders it: card face (560) and — verify — the dossier does NOT currently render a band at all: `openDetail` (768–796) has no band markup. "Info view" for the pill therefore needs a small addition, see 3 below.
|
||||
|
||||
**Plan (CSS + one markup line):**
|
||||
|
||||
1. Replace line 141:
|
||||
```
|
||||
.band.sl{color:#c4b5fd;background:rgba(124,58,237,.22);border:1px solid rgba(167,139,250,.65);font-weight:800}
|
||||
```
|
||||
(violet #7c3aed family; text near-white-violet `#c4b5fd`; bold fill + crisp border). Uppercase "SECOND LOOK" label (486) reads instantly against this.
|
||||
2. `.band.wild` (140) untouched — amber stays the contrast.
|
||||
3. Dossier/info view: add the same band to the dossier body so "info view" carries it. In `openDetail`, after the chips (778), insert the band when `data.slot==='return'|'wildcard'`:
|
||||
- simplest: an anchor div in `#dbody` (246, e.g. `<div class="band" style="position:static;display:inline-block;margin-top:6px" id="dband"></div>` — `display:none` default) filled by `openDetail` with `bandHTML(data)` logic (reuse the string builder 482–488; note `.band` is `position:absolute` by default, so give the dossier variant the static class or a dedicated `.dband` style with the same palette, per UI-SPEC palette text below).
|
||||
- `.card.hasSegs .band{top:22px}` (188) already handles the card-face coexistence with segment bars.
|
||||
4. No other surface: list rows don't carry bands today (not required).
|
||||
|
||||
**Edge cases:**
|
||||
|
||||
- Wildcard + segments + violet coexistence on the card: bands at 22px (188), segments at 8px (185) — unchanged geometry.
|
||||
- The band wraps up to 2 lines (139 `max-width:78%`) — violet fill still legible.
|
||||
- Contrast check: `#a78bfa` border on `#0b0b0e`-family backgrounds ≈ 7:1; text `#c4b5fd` on the violet-22% fill ≈ 6.5:1 — passes WCAG AA while staying dark-mode.
|
||||
|
||||
**Acceptance criteria:**
|
||||
|
||||
1. Card with `slot:'return'` renders a violet band; computed styles match the new palette (assert colour/background/border strings); wildcard card still amber.
|
||||
2. Dossier opened on a return card shows the same violet band; on a new-slot card, no band.
|
||||
3. Segments + band layout regression green (B1 walk).
|
||||
|
||||
**Parent verification:** computed-style assertions + two screenshots (card, dossier) over the tailnet or headless.
|
||||
|
||||
---
|
||||
|
||||
## Data safety
|
||||
|
||||
v1.1 makes **ZERO schema migrations, zero data mutations, no reset.** Every DATA-MODEL table and every existing row survives untouched; Glenn's ledger (swipes/events) is not read-modified in any new way.
|
||||
|
||||
Writes that happen in v1.1 are only the writes that already happen today, unchanged:
|
||||
|
||||
- `POST /api/swipe` (upsert `swipes` + `append_event`), `DELETE /api/swipe`, `POST /api/prefs` (one new key: `rubric_debug` — a new `prefs` row is the ONLY new write in v1.1, and it is a settings row, not data).
|
||||
- Compose/forge writes a new `sections` + `section_items` row set — the normal P3 flow, identical write shape.
|
||||
|
||||
New READS only:
|
||||
|
||||
- `/api/stats` +1 COUNT (fresh).
|
||||
- `GET /api/section` / forge response +2 small derived reads: `decided_this_section` flags (from `swipe_events` WHERE section_id — read-only), `pool` counts (the three existing candidate SQLs, counted).
|
||||
- `/api/section` payload +1 prefs read (`rubric_debug`).
|
||||
|
||||
No new tables, no new columns, no imports, no re-seeding (the `swipe_events` seed in `db.init_db`, db.py 109–117, runs only when empty and is not re-run by anything here, and v1.1 ships no changes to `schema.sql` or `P3_SCHEMA`).
|
||||
|
||||
Rollback: revert the commit; the only residue is the `rubric_debug` pref row, harmless if left.
|
||||
|
||||
---
|
||||
|
||||
## Open Questions (blocking decisions → Glenn / Alex)
|
||||
|
||||
1. **Item 9 — the "≥2 second looks" guarantee on rich days (confirmed needed to build).** Default specced: every batch carries ≥2 returns whenever eligible stock exists → a full 25-deck on a rich day reads **21 fresh + 2 second looks + 2 wildcards** (fresh capped at 23 = 25-2, and the two wildcard slots come out of fresh). Alternative for Glenn to veto: pure-fresh batches on rich days (23 fresh + 2 wildcards + 0 returns; returns fill only when fresh < 23). One switch in the allocator; everything else identical.
|
||||
2. **Item 10 — violet nod.** Default `#7c3aed`/`#a78bfa`/`#c4b5fd` (see amendment text). Trivial to re-tint if he picks another hue.
|
||||
3. **Item 1 — Backspace vs ArrowDown for undo.** BACKLOG names ↓; the live v1.0 handler already uses Backspace. Spec keeps BOTH (↓ primary per Glenn's words, Backspace retained as the muscle-memory alias). Confirm or drop Backspace.
|
||||
4. **Item 2 — dossier opened from a deck card, swiped via its own buttons:** `openDetail` from the deck currently allows committing the top card from inside the dossier (`dAction` 838–848). Under info-first flow this stays. If Glenn wants the sheet to be read-only from the deck, that's a v1.2 behaviour change — not in this spec.
|
||||
5. **Item 5 — undo-on-a-return residual:** un-deciding a second look that carries a lifetime verdict restores the swipes row but leaves the `section_id`-stamped event; the in-section count re-includes it on resync (clamped so it can never exceed the total, but it can sit AT the total with one undone card). A clean fix needs an event-deletion/„undo" semantics decision (v1.2 territory alongside analytics); accepted as-is for v1.1 and stated explicitly so the parent doesn't chase it as a leak.
|
||||
6. **Item 9 — one-shot return-pool burn:** with fill-to-25 the remaining eligible second looks (~≤30 as of 2026-11-12) drain within a batch or two. Accepted per BACKLOG's noted consequence; the drip-vs-burn preference belongs to Glenn before build if he cares.
|
||||
7. **Item 8 — copy retention:** "↺ brings the last card back" line kept only if still true after item 1's undo mapping (it is — undo exists either way). Any copy tweaks Glenn wants on "No more new bikes!" (exclamation, wording) noted before build.
|
||||
8. **Found while verifying (pre-existing, NOT v1.1 scope — flagged):** `maybe_exhaust` uses lifetime `decision` (sections.py 462) and the FE send of `photo_idx` is conditional on `nPhotos>1` (683) so single-photo cards don't update rotation; both are covered or neutral after item 5, no action. Also verified: the live "keyboard arrows" feature in v1.0 was live-deployed ahead of the BACKLOG as part of the P2 build (DESIGN.md:63, index.html 1263) — v1.1 formalizes and extends it rather than introducing it.
|
||||
|
||||
---
|
||||
|
||||
## Proposed UI-SPEC amendments (verbatim replacement text — DO NOT apply during the docs phase)
|
||||
|
||||
### A) §11.4 "Doors" — replace the whole subsection's body paragraph
|
||||
|
||||
> ### 11.4 Doors (supersedes the old tap→dossier)
|
||||
>
|
||||
> - ⓘ (top-right of card) → dossier (unchanged). The card face now owns: **sides = flip, center = dossier (bike data first)**; the "tap anywhere → dossier" gesture is RETIRED and the B1 center-tap→fullscreen gesture is RETIRED in favour of it.
|
||||
> - Tapping the photo in the dossier hero opens the fullscreen image viewer (§11.3). **Viewer close (✕, pull-down, or Esc) returns to the dossier; the next Esc returns to the deck.** The dossier stays reachable from ⓘ and from list rows (§3/§4 unchanged).
|
||||
|
||||
### B) §11.3 "Fullscreen viewer" — amend the entry sentence
|
||||
|
||||
> - Tap the CENTER third → fullscreen viewer opens on the photo currently shown.
|
||||
>
|
||||
> becomes:
|
||||
>
|
||||
> - Tap the photo in the dossier hero → fullscreen viewer opens (starts at photo 0). Direct card→viewer is retired (see §11.4); the viewer is reached from the dossier.
|
||||
|
||||
### C) §2 card geometry — photo fit: add a new bullet after "Photo full-bleed"
|
||||
|
||||
> - Photo fit is **contain**: the whole photo is shown uncropped over a soft blurred backdrop of the same image (option C). The backdrop is decorative (blurred, dimmed, overflow-clipped); the sharp photo sits on top with a gentle shadow. The fullscreen viewer already fits; list thumbs stay `cover` (56px).
|
||||
|
||||
### D) §10.3 Card bands — replace the SECOND LOOK palette line
|
||||
|
||||
> - **SECOND LOOK — you {liked|maybed|noped} this** — color `rgba(255,255,255,.85)`; bg `rgba(255,255,255,.10)`; border `1px solid rgba(255,255,255,.22)`.
|
||||
>
|
||||
> becomes:
|
||||
>
|
||||
> - **SECOND LOOK — you {liked|maybed|noped} this** — color `#c4b5fd`; bg `rgba(124,58,237,.22)`; border `1px solid rgba(167,139,250,.65)`; font-weight 800. Wildcard stays amber (`#ffb43a` family values unchanged) for contrast. The same band renders in the dossier ("info view") when the listing's slot is `return` or `wildcard`.
|
||||
|
||||
### E) §10.5 Dossier "Why this rank" — add a debug-visibility paragraph
|
||||
|
||||
> - Hidden-by-default detail: the breakdown lines and the "from N strikes" footer render only when `prefs['rubric_debug'] === 'on'` (default `'off'`). With the pref off the block shows **the tank gauge + "{points}%"** only — the minimal rubric display. The toggle lives in the Trends "Actions" area (why-breakdown on ⇄ off, same control style as the forge-mode toggle).
|
||||
|
||||
### F) §10.1 Sections — replace the composition sentence within the section-progress bullet
|
||||
|
||||
> - Section composition (engine side — RANKING.md): ≤5 SECOND LOOK cards + 2 WILDCARD cards + the remainder new.
|
||||
>
|
||||
> becomes:
|
||||
>
|
||||
> - Section composition (engine side — RANKING.md): every batch targets 25 cards = fresh first (up to 23 slots) + ≥2 SECOND LOOK cards whenever eligible stock exists + 2 WILDCARD cards; when fresh < 23, second looks fill the remainder up to 25. Re-nope returns stay ≤2 per batch; fresh shortfalls are never padded.
|
||||
|
||||
### G) §2 Empty state + §10.2 report — add the loud exhausted state
|
||||
|
||||
> - §2's quiet "You're all caught up." remains only for legacy (pre-section) mode. In section mode, when the deck can serve nothing at all — no fresh listings, no eligible second looks, no wildcards — the deck shows a prominent **"No more new bikes!"** panel with "New bikes arrive nightly — next import 08:30." and, when true, "↺ brings the last card back." This panel supersedes the report card in that state only; the report card remains the end-of-section screen whenever more cards can still be served.
|
||||
|
||||
### H) §1 Globals — header pill
|
||||
|
||||
> - Header pill shows `{live} live · {fresh} fresh` always, and `· {new} new` only when new > 0. `fresh` = active listings with no swipe (the deck's new-pool predicate).
|
||||
|
||||
### I) §10.2 Forge — dry-catalog note
|
||||
|
||||
> - When a forged batch reports `new: 0` the report shows: "Catalog fully reviewed — fresh listings arrive with the next 08:30 import; showing second looks." and the forge reads the same note in its status line.
|
||||
|
||||
(Collecting all in one place per protocol — the file itself is not touched in this phase.)
|
||||
|
||||
---
|
||||
|
||||
## Verification plan (summary the parent will re-run after the build)
|
||||
|
||||
1. Fresh-clone checkout of the v1.1 build, temp DB copies only (never the live DB): existing selfcheck + new v1.1 checks, all green.
|
||||
2. Per item with the acceptance criteria above: 1 (keyboard: key dispatch, guards, scroll, Esc stack) · 2 (tap-flow walk + B1 §11.7 suite) · 3 (computed styles + screenshots vs demo panel C) · 4 (prefs API 200/400, dossier DOM with pref off/on) · 5 (staged returns-only section: 0/2 → 1/2 → 2/2 → report, clamp, list-edit neutrality) · 6 (dry forge → caption + status line) · 7 (stats fresh count + pill text) · 8 (0/0/0 pool → loud empty2, report mask gone) · 9 (A1–A8 compose matrix on generated pools) · 10 (violet band computed styles, wildcard unchanged, segments coexistence).
|
||||
3. Full section loop regression: compose → strikes → rounds → report → forge on a rich DB and a dry DB; trends, deck feed, undos unchanged in shape.
|
||||
4. Zero-mutation audit: diff against `381b6c8` shows no `schema.sql`/`P3_SCHEMA`/migration writes; `rubric_debug` pref row is the only new write.
|
||||
5. Glenn phone pass (human): keyboard on MacBook; center-tap data-first on phone; violet band visible; fresh counter reads; empty2 appears when shown a dry copy (staged), loud and clear.
|
||||
BIN
docs/images/bike-details.png
Normal file
BIN
docs/images/bike-details.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 74 KiB |
BIN
docs/images/swipe-deck.png
Normal file
BIN
docs/images/swipe-deck.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 101 KiB |
@@ -2,3 +2,5 @@
|
||||
fastapi
|
||||
uvicorn
|
||||
httpx
|
||||
requests # agent-pass live call (OpenRouter) — imported by app/agentpass.py
|
||||
playwright==1.54.0 # B1 dev/test only: headless FE walk (app/fe_walk_b1.py)
|
||||
|
||||
Reference in New Issue
Block a user