# IDEA.md – en egen crawler för teknisk SEO Det här är en fristående uppdragsbeskrivning. Ge den i sin helhet till Claude Code (eller ett liknande verktyg) för att bygga en egen implementation. Den bygger på det som lärdes när SEO Spider byggdes, en skrivbordsapp för Windows och macOS skriven i Rust med Claude Code. ## 1. Vad som ska byggas En skrivbordscrawler för teknisk SEO-analys med Screaming Frog SEO Spider som förebild – samma funktionsomfång och terminologi, men väsentligt snabbare och snålare med minne, och utan prenumeration. Dessutom ett CLI som kör samma motor utan fönster. Appen ska kunna: - **crawla en sajt** från en start-URL med robots.txt (inklusive crawl-delay), omfång (intern/extern, include/exclude), djup- och antalsgränser, och samtidighet; pausa och fortsätta, även efter omstart - visa resultatet i **flikar med filter** enligt Screaming Frogs namn: Internal, External, Response Codes, Page Titles, Meta Description, H1, Content, Images, Canonicals, Pagination & AMP, Hreflang, Accessibility, Cookies, Structured Data, Sitemaps, JavaScript, Directives med flera – till exempel titlar som saknas, är dubbletter, är över 60 eller under 30 tecken - en **virtualiserad tabell** med sortering, fritextsökning och export, och en **detaljpanel** per URL: detaljer, inlänkar, utlänkar, dubbletter, hreflang, huvuden, kakor, strukturerad data, tillgänglighet - **länkgraf och länkstyrka** (PageRank över interna sidor), föräldralösa sidor - **XML-sitemaps**: läsa, index, gzip, jämföra med crawlen, generera - **JavaScript-rendering** i headless Chrome via CDP, med rå/renderad-jämförelse - **strukturerad data** (JSON-LD mot Googles krav för rich results), **hreflang** (returlänkar, självreferens, x-default, koder mot ISO; ur ``, `Link:`-huvudet och sitemaps), **paginering och AMP** - **egen extraktion** (CSS-selektorer och reguljära uttryck) och **egen sökning** i källkoden, i samma parsningspass - **list-läge**, **nära dubbletter** (MinHash med LSH), **crawl-jämförelse**, **tillgänglighet** (statiska regler eller axe-core i den renderade sidan), **kakor** med flaggor, **autentisering** (HTTP Basic och egna huvuden) - **visualiseringar** (crawl-träd, katalogträd, kraftdiagram, ordmoln), **schemaläggning** och ett **crawl-bibliotek** - **räkna om** en sparad crawl utan att hämta om sajten, när den råa HTML:en sparats - Search Console, Analytics och PageSpeed Insights via Googles API:er **Ingår inte**: XPath i egen extraktion (kräver ett dokumentträd), formulärinloggning med session över crawlen, och molntjänster. ## 2. Stack och arkitektur Det som **spelar roll** är markerat; resten går att byta. - **Rust-workspace**: `parse` (HTML-extraktion, ren CPU, inget I/O), `core` (crawl-motorn: HTTP, robots, omfång, kö, länkgraf, sitemaps, rendering, strukturerad data, MinHash, Google-klienter), `store` (lagring och frågor), `cli`. Ovanpå det en **Tauri 2-app** med React och Vite. - **Viktigt: strömmande extraktion med `lol_html`, utan DOM-träd.** Ett enda tokeniseringspass plockar ut allt på vägen – ingen trädallokering. Det är hela prestandapoängen. Allt nytt arbete ska in i samma pass, inte som en extra genomsökning. - **Viktigt: en koordinator utan lås.** Kön och dubblettmängden ägs av en enda uppgift. Arbetarna gör bara I/O och parsning och skickar färdiga resultat tillbaka över en kanal. Ingen `Mutex` i den heta vägen. - **Lagring i redb och frågor i Polars.** Crawl-data skrivs till redb under körningen och materialiseras till Arrow-batcher som Polars frågar mot, så sortering av miljoner rader blir en kolumnläsning. - **Länkgrafen utanför posterna**, i två tabeller med nycklarna `från‖till` och `till‖från`. Inlänkspanelen blir en sekventiell läsning i stället för en genomsökning av hela grafen. - Gränssnittet: en virtualiserad grid (bara synliga rader ritas), flikar och filter som data, ljust och mörkt tema. All text användaren ser på engelska, med Screaming Frogs termer. ## 3. Beslut som visade sig avgörande **Spara exakt det som skickades och togs emot** – alla svarshuvuden och begäranshuvuden – så att en rapport månader senare visar vad som hände. Läs huvudvärden som bytes, inte bara som synlig ASCII. Ta vara på `Content-Encoding` och `Content-Length` innan HTTP-klienten packar upp svaret, annars försvinner de och den sanna storleken. **Men maskera det användaren själv lagt till.** Huvuden ur autentisering och egna huvuden sparas med namnet kvar och värdet ersatt. De huvuden crawlern sätter själv (`accept`, `user-agent` …) sparas som de är. Testa båda riktningarna: huvudet måste fortfarande skickas och får inte nå filen. **`X-Robots-Tag` är lika viktigt som robots-metataggen.** Läs det före parsningen – det gäller även PDF:er och andra svar utan HTML. **Externa URL:er kontrolleras bara.** Hämta statuskod och huvuden, men inte svarskroppen. Följ sitemaps ur robots.txt bara för interna värdar. Annars kan en enda extern länk dra in andra sajters sitemaps, med nya externa värdar och nya robots.txt – en kedjereaktion. **Valfri lagring av den råa HTML:en**, komprimerad i crawl-filen. Då kan nya kontroller köras mot en gammal crawl utan att sajten hämtas om. **En beständig kö**, så att en pausad crawl kan sparas, öppnas igen och fortsätta där den slutade. **Varje renderare får en egen Chrome-profil** i en temporär katalog, och gamla profiler städas. Annars dödar två renderande crawls samtidigt varandra. **Spara en crawl genom databasens eget handtag**, post för post. Kopiera aldrig den öppna filen bakom databasens rygg. **Terminologi som Screaming Frog** – `Response Codes`, `Indexability Status`, `Orphan URLs`, `Link Score` – så att resultaten går att jämföra mellan verktygen. **Utvecklarhjälp från dag ett**: startargument som `--url` och `--crawl`, ett CLI med samma motor och samma rapporter, och ett skript som hittar appfönstret, klickar, skriver och tar en skärmbild av bara det fönstret. ## 4. Fallgropar - **Fillås beter sig olika.** På Windows är ett lås bindande för alla andra handtag, även läsande; på Linux är `flock` bara rådgivande. Ett fel som bara finns på Windows syns aldrig vid provkörning på Linux. - **Tauri måste byggas med `--features custom-protocol`** för en distribuerad binär. Utan den laddar appen gränssnittet från dev-servern på localhost, och felet syns först hos någon som startar paketet. Kontrollera efteråt att frontendens filer finns i binären. - **Bygg inte frontenden till `dist/`** om `dist/` är distributionspaketen – Vite tömmer katalogen. - **Bygg inte i release för att prova beteende.** Med `lto` och `codegen-units = 1` tar release-bygget runt 20 gånger längre tid än dev; funktionsprov ger samma svar. - **Under WSL: lägg `target/` på ext4**, inte på Windows-disken via 9p, där cargos många små skrivningar är mycket långsamma. Sätt inte en delad `CARGO_TARGET_DIR` för alla projekt. - **Under WSLg** måste fönstret startas med `GDK_BACKEND=x11` för att X-verktyg ska se det, och WebKitGTK behöver `WEBKIT_DISABLE_COMPOSITING_MODE=1`. Kontrollera att skärmbildsverktyget tar rätt fönster. - **Mät inte crawl-genomströmning mot `python3 -m http.server`** – den kollapsar vid många samtidiga anslutningar och mäter servern, inte crawlern. - **Lita inte på kommentarer.** "Värdena skrivs aldrig till crawl-filen" stod i koden medan de gjorde det. Testa det kommentaren lovar. ## 5. Krav och mätningar - Extraktion med en tråd: runt 34 000 små sidor (1,6 KB) per sekund och runt 1 900 verklighetsnära sidor (62 KB, 180 länkar, 120 bilder) per sekund. Med många kärnor blir parsningen aldrig flaskhalsen. - Sortering och filtrering av hundratusentals rader utan väntan. - Rust-sidan med över 350 tester, frontenden med egna tester av de rena funktionerna, typkontroll och lint utan varningar. ## 6. Så verifieras det - `cargo test --workspace`, `cargo clippy --workspace --all-targets -- -D warnings`, frontendens tester, typkontroll och lint. - Integrationstester mot en riktig lokal server: att crawlen rapporterar exakt de huvuden den skickar, omdirigeringar, robots, sitemaps, `X-Robots-Tag`. - Renderingstestet med en installerad Chrome, separat. - Windows-delen med `cargo xwin` från WSL, och den körande appen på varje plattform. - **I det körande gränssnittet**: crawl, flikbyte, filter, fritextsökning, scrollning förbi radfönstret, detaljpanelen och inställningarna – och att siffrorna i gränssnittet stämmer med CLI:ts. ## 7. Arbetssätt - **Research först**: Screaming Frog och andra crawlers, vad varje flik och filter betyder och hur Google tolkar direktiven. Markera vad som är kontrollerat mot en källa och vad som är bedömning. - **Ett ärende i taget**, med mätningen i den avslutande kommentaren. - **Provkör mot riktiga sajter.** Flera av de viktigaste felen syntes bara där: kön som exploderade, huvudena som saknades jämfört med webbläsarens nätverkspanel. - **Det som kräver ett riktigt konto** – Googles API:er, signering – blir ett eget verifieringsärende med en checklista. ## 8. Prompten > Bygg en skrivbordscrawler för teknisk SEO för [Windows och macOS] i [Rust med Tauri 2 och React], med Screaming Frog SEO Spider som förebild: samma flikar, filter och terminologi, men snabbare och snålare med minne. Den ska crawla en sajt med robots.txt och omfång, visa resultatet i en virtualiserad tabell med filter och en detaljpanel, och klara JavaScript-rendering, sitemaps, hreflang, strukturerad data, egen extraktion och list-läge. Ett CLI ska köra samma motor. > > Läs hela IDEA.md nedan först. Den beskriver funktionerna, arkitekturen, de beslut som visade sig avgörande och fallgroparna att undvika. > > Arbeta så här: > 1. Gör research och skriv en plan uppdelad i ärenden. Fråga mig om det som är mina beslut. > 2. Extrahera allt i ett enda strömmande parsningspass, utan DOM-träd. > 3. Låt en enda uppgift äga kön, utan lås i den heta vägen. > 4. Spara aldrig lösenord eller nycklar i crawl-filen. > 5. Prova i det körande gränssnittet och jämför siffrorna med CLI:t. > > [klistra in IDEA.md här]