linkfetch 0.1.2__tar.gz → 1.0.0__tar.gz

{linkfetch-0.1.2 → linkfetch-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: linkfetch
-Version: 0.1.2
+Version: 1.0.0
 Summary: Capture your own LinkedIn profile on your own computer and turn it into structured profile files
 Project-URL: Homepage, https://github.com/Prosperis/linkfetch
 Project-URL: Issues, https://github.com/Prosperis/linkfetch/issues
@@ -8,7 +8,7 @@ Author: Prosperis
 License-Expression: MIT
 License-File: LICENSE
 Keywords: cv,export,linkedin,playwright,profile,resume
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: End Users/Desktop
 Classifier: Operating System :: OS Independent
@@ -41,8 +41,11 @@ Description-Content-Type: text/markdown
 
 Capture **your own** LinkedIn profile on **your own computer** and turn it into
 structured profile files — every role, description, skill, project,
-certification and more — ready to import into
-[THRIVE](https://prosperis-thrive.vercel.app) or any tool that reads YAML.
+certification and more — as plain YAML you can keep, edit, version or feed to
+any other tool.
+
+**In:** your LinkedIn profile address. **Out:** one YAML file per profile
+section, plus `linkfetch-profile.zip` bundling them.
 
 LinkedIn's official data export leaves out details the profile page shows.
 linkfetch reads the rendered pages instead, in a real browser window that you
@@ -72,7 +75,7 @@ linkfetch install-browser        # one-time download of the browser linkfetch dr
 ## Use
 
 ```bash
-linkfetch login                       # a browser window opens: log in to LinkedIn, then close it
+linkfetch login                       # a browser window opens; log in to LinkedIn and it closes by itself
 linkfetch run --vanity your-name      # capture your profile and build the files
 ```
 
@@ -82,12 +85,7 @@ linkfetch run --vanity your-name      # capture your profile and build the files
 `run` visits each section of your profile (experience, education, skills, …),
 expands every "see more", saves the pages, and turns them into one YAML file
 per section plus **`linkfetch-profile.zip`**. `linkfetch` prints where they
-are.
-
-### Import into THRIVE
-
-In THRIVE, open **Tailor → Profile → Import** and choose
-`linkfetch-profile.zip`. Review each section before saving.
+are. See [Output](#output) for what they contain.
 
 ## Where your data is kept
 
@@ -125,15 +123,46 @@ and `parse --no-zip` to skip the ZIP.
 
 ## Output
 
-One file per section, each a list under a top-level key:
-`basics.yaml`, `experiences.yaml`, `education.yaml`, `skills.yaml`,
-`projects.yaml`, `certifications.yaml`, `awards.yaml`, `languages.yaml`,
-`courses.yaml`, `patents.yaml`, `recommendations.yaml`, `volunteering.yaml`,
-plus `honors.yaml` (a richer copy of awards, not included in the ZIP).
-Experiences keep their full description as bullets. Several roles at one
-company become separate experiences — each with its own title, dates and
-bullets — all under the company's name, because a role's dates and
-achievements are what tailoring selects from.
+Written to `data/output/` inside the data folder.
+
+| File | Contains |
+|---|---|
+| `basics.yaml` | name, headline, location, about, contact links |
+| `experiences.yaml` | one entry per role: company, title, dates, location, description bullets, skills used |
+| `education.yaml` | school, degree, field, dates, activities |
+| `skills.yaml` | skill name, and where you used it |
+| `projects.yaml` | name, role, dates, description, links |
+| `certifications.yaml` | name, issuer, issue/expiry dates, credential id and link |
+| `awards.yaml` | honors & awards: name, issuer, date |
+| `languages.yaml` | language and proficiency |
+| `courses.yaml` | course name and number |
+| `patents.yaml` | title, number, status, date, summary |
+| `recommendations.yaml` | author, their title, relationship, text |
+| `volunteering.yaml` | organization, role, cause, dates, summary |
+| `honors.yaml` | a fuller copy of honors & awards, with descriptions |
+| `linkfetch-profile.zip` | every file above except `honors.yaml`, in one archive |
+
+Each file holds its section under a top-level key named after the file:
+
+```yaml
+experiences:
+  - id: example-co-senior-engineer
+    org: Example Co
+    location: Austin, Texas, United States
+    positions:
+      - title: Senior Engineer
+    timeline:
+      start: Mar 2022
+      end: Present
+    bullets:
+      - Led the migration of the billing platform
+    tech:
+      - TypeScript
+```
+
+Several roles at one company become separate entries — each with its own
+title, dates and bullets — under the company's name. Empty fields are left out.
+`id` values are stable slugs, so re-running produces small, reviewable diffs.
 
 ## How it works
 

{linkfetch-0.1.2 → linkfetch-1.0.0}/README.md

@@ -7,8 +7,11 @@
 
 Capture **your own** LinkedIn profile on **your own computer** and turn it into
 structured profile files — every role, description, skill, project,
-certification and more — ready to import into
-[THRIVE](https://prosperis-thrive.vercel.app) or any tool that reads YAML.
+certification and more — as plain YAML you can keep, edit, version or feed to
+any other tool.
+
+**In:** your LinkedIn profile address. **Out:** one YAML file per profile
+section, plus `linkfetch-profile.zip` bundling them.
 
 LinkedIn's official data export leaves out details the profile page shows.
 linkfetch reads the rendered pages instead, in a real browser window that you
@@ -38,7 +41,7 @@ linkfetch install-browser        # one-time download of the browser linkfetch dr
 ## Use
 
 ```bash
-linkfetch login                       # a browser window opens: log in to LinkedIn, then close it
+linkfetch login                       # a browser window opens; log in to LinkedIn and it closes by itself
 linkfetch run --vanity your-name      # capture your profile and build the files
 ```
 
@@ -48,12 +51,7 @@ linkfetch run --vanity your-name      # capture your profile and build the files
 `run` visits each section of your profile (experience, education, skills, …),
 expands every "see more", saves the pages, and turns them into one YAML file
 per section plus **`linkfetch-profile.zip`**. `linkfetch` prints where they
-are.
-
-### Import into THRIVE
-
-In THRIVE, open **Tailor → Profile → Import** and choose
-`linkfetch-profile.zip`. Review each section before saving.
+are. See [Output](#output) for what they contain.
 
 ## Where your data is kept
 
@@ -91,15 +89,46 @@ and `parse --no-zip` to skip the ZIP.
 
 ## Output
 
-One file per section, each a list under a top-level key:
-`basics.yaml`, `experiences.yaml`, `education.yaml`, `skills.yaml`,
-`projects.yaml`, `certifications.yaml`, `awards.yaml`, `languages.yaml`,
-`courses.yaml`, `patents.yaml`, `recommendations.yaml`, `volunteering.yaml`,
-plus `honors.yaml` (a richer copy of awards, not included in the ZIP).
-Experiences keep their full description as bullets. Several roles at one
-company become separate experiences — each with its own title, dates and
-bullets — all under the company's name, because a role's dates and
-achievements are what tailoring selects from.
+Written to `data/output/` inside the data folder.
+
+| File | Contains |
+|---|---|
+| `basics.yaml` | name, headline, location, about, contact links |
+| `experiences.yaml` | one entry per role: company, title, dates, location, description bullets, skills used |
+| `education.yaml` | school, degree, field, dates, activities |
+| `skills.yaml` | skill name, and where you used it |
+| `projects.yaml` | name, role, dates, description, links |
+| `certifications.yaml` | name, issuer, issue/expiry dates, credential id and link |
+| `awards.yaml` | honors & awards: name, issuer, date |
+| `languages.yaml` | language and proficiency |
+| `courses.yaml` | course name and number |
+| `patents.yaml` | title, number, status, date, summary |
+| `recommendations.yaml` | author, their title, relationship, text |
+| `volunteering.yaml` | organization, role, cause, dates, summary |
+| `honors.yaml` | a fuller copy of honors & awards, with descriptions |
+| `linkfetch-profile.zip` | every file above except `honors.yaml`, in one archive |
+
+Each file holds its section under a top-level key named after the file:
+
+```yaml
+experiences:
+  - id: example-co-senior-engineer
+    org: Example Co
+    location: Austin, Texas, United States
+    positions:
+      - title: Senior Engineer
+    timeline:
+      start: Mar 2022
+      end: Present
+    bullets:
+      - Led the migration of the billing platform
+    tech:
+      - TypeScript
+```
+
+Several roles at one company become separate entries — each with its own
+title, dates and bullets — under the company's name. Empty fields are left out.
+`id` values are stable slugs, so re-running produces small, reviewable diffs.
 
 ## How it works
 

{linkfetch-0.1.2 → linkfetch-1.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "linkfetch"
-version = "0.1.2"
+version = "1.0.0"
 description = "Capture your own LinkedIn profile on your own computer and turn it into structured profile files"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -9,7 +9,7 @@ license-files = ["LICENSE"]
 authors = [{ name = "Prosperis" }]
 keywords = ["linkedin", "profile", "resume", "cv", "export", "playwright"]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Environment :: Console",
     "Intended Audience :: End Users/Desktop",
     "Operating System :: OS Independent",

linkfetch-1.0.0/src/linkfetch/__init__.py

@@ -0,0 +1,3 @@
+"""linkfetch — capture your own LinkedIn profile locally as structured YAML."""
+
+__version__ = "0.1.0"

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/capture/browser.py

@@ -4,9 +4,8 @@ Uses a **persistent browser context** rooted at ``user_data_dir`` so the login
 cookie survives between runs — you log in once via ``linkfetch login`` and later
 ``capture`` runs reuse the session.
 
-Playwright is an optional dependency. Importing this module is fine without it;
-the ImportError only surfaces when you actually open a browser, with the same
-install hint tailor uses.
+Importing this module never needs Playwright; a missing Playwright or browser
+only surfaces when a browser is actually opened, with a hint on how to fix it.
 """
 
 from __future__ import annotations

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/cli.py

@@ -4,7 +4,7 @@ Commands:
   linkfetch doctor             — show config, Playwright availability, session state
   linkfetch login              — open the browser and establish/refresh the session
   linkfetch capture [opts]     — phase 1: save section HTML to data/captures
-  linkfetch parse  [opts]      — phase 2: HTML -> profile YAML (+ ZIP for THRIVE) in data/output
+  linkfetch parse  [opts]      — phase 2: HTML -> profile YAML (+ linkfetch-profile.zip) in data/output
   linkfetch run    [opts]      — capture then parse
 """
 
@@ -52,6 +52,20 @@ def _playwright_installed() -> bool:
     return importlib.util.find_spec("playwright") is not None
 
 
+def _browser_downloaded() -> bool:
+    """True if the Chromium build this Playwright version drives is on disk.
+
+    Starts Playwright's driver only to ask for the path; no browser opens.
+    """
+    try:
+        from playwright.sync_api import sync_playwright
+
+        with sync_playwright() as p:
+            return Path(p.chromium.executable_path).is_file()
+    except Exception:
+        return False
+
+
 def _section_arg(sections: list[str] | None) -> list[Section]:
     try:
         return resolve(sections)
@@ -76,6 +90,10 @@ def doctor() -> None:
 
     if _playwright_installed():
         console.print("[green]✓[/] Playwright is installed")
+        if _browser_downloaded():
+            console.print("[green]✓[/] The browser is downloaded")
+        else:
+            console.print("[yellow]![/] The browser is not downloaded yet — run `linkfetch install-browser`")
     else:
         console.print(
             "[yellow]![/] Playwright not installed — capture/login unavailable.\n"
@@ -193,7 +211,7 @@ def _section_url(cfg: Config, sec: Section, vanity: str) -> str:
 def parse(
     section: list[str] = typer.Option(None, "--section", "-s", help="Section slug(s); default all"),
     zip_output: bool = typer.Option(
-        True, "--zip/--no-zip", help="Also bundle the profile files into one ZIP for THRIVE"
+        True, "--zip/--no-zip", help="Also bundle the profile files into linkfetch-profile.zip"
     ),
 ) -> None:
     """Phase 2: parse captured HTML into YAML. No browser needed."""
@@ -243,7 +261,7 @@ def parse(
             bundle = write_profile_zip(cfg.output_dir / PROFILE_ZIP, profile_files)
             console.print(
                 f"[green]✓[/] Profile bundle: {bundle}\n"
-                "Import it in THRIVE: Tailor → Profile → Import → choose this file."
+                "One file with every profile section, ready to import or share."
             )
 
 
@@ -251,7 +269,7 @@ PROFILE_ZIP = "linkfetch-profile.zip"
 
 
 def write_profile_zip(target: Path, files: list[Path]) -> Path:
-    """Bundle profile YAML files flat into one ZIP, the form THRIVE imports."""
+    """Bundle profile YAML files flat into one ZIP (one YAML file per section)."""
     import zipfile
 
     with zipfile.ZipFile(target, "w", compression=zipfile.ZIP_DEFLATED) as bundle:

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/emit.py

@@ -1,12 +1,11 @@
 """Serialize parsed models to YAML.
 
-Uses the same dumper settings as tailor's profile store so the mapped output
-files are stylistically identical to tailor's own YAML (and therefore drop in
-cleanly): ``sort_keys=False``, ``allow_unicode=True``, block style, width 100.
+Output is stable and readable: ``sort_keys=False``, ``allow_unicode=True``,
+block style, width 100, so re-runs produce small, reviewable diffs.
 
-Each output file wraps its list under a top-level key (``experiences:``,
-``skills:``, …), matching tailor's per-category file shape. ``basics`` is
-wrapped under ``basics:``.
+Each output file wraps its list under a top-level key named after the file
+(``experiences:``, ``skills:``, …). ``basics`` is a single mapping under
+``basics:``.
 """
 
 from __future__ import annotations
@@ -25,7 +24,30 @@ def _to_plain(models: list[BaseModel] | BaseModel) -> object:
     """
     if isinstance(models, BaseModel):
         return _prune(models.model_dump())
-    return [_prune(m.model_dump()) for m in models]
+    return _unique([_prune(m.model_dump()) for m in models])
+
+
+def _unique(items: list[dict]) -> list[dict]:
+    """Drop exact duplicates and keep ``id`` values unique.
+
+    LinkedIn can render the same entry twice (a lazy-loaded list re-rendering,
+    or an entry genuinely listed twice); an identical copy adds nothing. Two
+    *different* entries that slug to the same ``id`` both stay, the later one
+    suffixed ``-2``, ``-3`` … so ids remain unique within a file.
+    """
+    out: list[dict] = []
+    seen_ids: dict[str, int] = {}
+    for item in items:
+        if item in out:
+            continue
+        base = item.get("id")
+        if isinstance(base, str):
+            count = seen_ids.get(base, 0) + 1
+            seen_ids[base] = count
+            if count > 1:
+                item = {**item, "id": f"{base}-{count}"}
+        out.append(item)
+    return out
 
 
 def _prune(value: object) -> object:
@@ -43,7 +65,7 @@ def _prune(value: object) -> object:
 
 
 def dump_yaml(path: Path, top_key: str, models: list[BaseModel] | BaseModel) -> None:
-    """Write ``{top_key: <plain data>}`` to ``path`` as tailor-style YAML."""
+    """Write ``{top_key: <plain data>}`` to ``path`` as YAML."""
     path.parent.mkdir(parents=True, exist_ok=True)
     payload = {top_key: _to_plain(models)}
     with path.open("w", encoding="utf-8") as fh:

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/models.py

@@ -2,15 +2,14 @@
 
 Two families:
 
-1. **tailor-mapped** models — a *subset* of tailor's profile models using the
-   **same field names** (``id``, ``summary``, ``bullets``, ``tags``, ``org``,
-   ``positions``, ``timeline``, …). YAML emitted from these drops straight into
-   tailor's profile store. We intentionally omit fields tailor fills in by hand
-   (e.g. multiple position framings, emphasis) — the scrape is deterministic and
+1. **profile** models — one per profile section, with consistent field names
+   (``id``, ``summary``, ``bullets``, ``tags``, ``org``, ``positions``,
+   ``timeline``, …). Fields that only a person can fill in (alternative title
+   framings, emphasis) exist but stay empty: the scrape is deterministic and
    leaves enrichment to the user.
 
-2. **extra** models — small purpose-built models for LinkedIn sections tailor
-   has no home for (education, volunteering, recommendations, …).
+2. **extra** models — richer copies of a section kept alongside the profile
+   files (currently ``honors``).
 
 All ``id`` values are stable slugs derived from the item's identity so re-runs
 produce diffable YAML.
@@ -28,7 +27,7 @@ from pydantic import BaseModel, Field
 class Timeline(BaseModel):
     """A start/end span. ``end`` omitted or 'present' means ongoing.
 
-    Mirrors tailor.profile.models.Timeline (field-compatible).
+    ``start``/``end`` keep LinkedIn's wording; a missing ``end`` means current.
     """
 
     start: str | None = None
@@ -37,10 +36,10 @@ class Timeline(BaseModel):
 
 
 class Position(BaseModel):
-    """One title framing for a role. Mirrors tailor's Position.
+    """One title framing for a role.
 
     The scrape produces exactly one framing (the real LinkedIn title); the user
-    adds alternative framings later in tailor.
+    can add alternative framings later.
     """
 
     title: str
@@ -55,7 +54,7 @@ class Link(BaseModel):
 
 
 # ---------------------------------------------------------------------------
-# tailor-mapped models (field names match tailor.profile.models)
+# profile models
 # ---------------------------------------------------------------------------
 
 
@@ -129,7 +128,7 @@ class Award(BaseModel):
 
 
 # ---------------------------------------------------------------------------
-# extra models (linkfetch-local schema; not in tailor)
+# extra models
 # ---------------------------------------------------------------------------
 
 
@@ -185,8 +184,8 @@ class Language(BaseModel):
 class Honor(BaseModel):
     """Honors & awards as a standalone extra section.
 
-    Note: tailor's Award is also populated from this section; this richer extra
-    file preserves everything (issuer, date, description) for the user.
+    The trimmed Award (awards.yaml) comes from the same section; this richer
+    file preserves everything (issuer, date, description).
     """
 
     id: str

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/parse/awards.py

@@ -1,4 +1,4 @@
-"""Parse Honors & awards into tailor's Award model.
+"""Parse Honors & awards into the trimmed Award model (awards.yaml).
 
 Ordered fragments per entry::
 

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/parse/common.py

@@ -44,6 +44,9 @@ _CHROME = (
     "select language", "profile language", "accessibility", "talent solutions",
     "community guidelines", "marketing solutions", "privacy & terms",
     "ad choices", "sales solutions", "small business", "safety center",
+    # In-section notices, e.g. "Projects from connected apps sync
+    # automatically and can't be edited on LinkedIn."
+    "sync automatically", "be edited on linkedin",
 )
 
 # Section-title fragments that appear as the first child block of the content

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/parse/honors.py

@@ -1,8 +1,8 @@
 """Parse Honors & awards into the richer extra Honor model.
 
 Same source section as awards.py (same fragment order), but kept as a standalone
-extra file so the full description survives in ``summary``. tailor's Award
-(awards.py) is the trimmed, mappable view.
+extra file so the full description survives in ``summary``. The Award
+(awards.py) is the trimmed view included in the profile bundle.
 """
 
 from __future__ import annotations

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/parse/skills.py

@@ -3,7 +3,7 @@
 Each entry's first visible fragment is the skill name; a second fragment gives
 the context where it was used ("Senior Software Development Engineer at Roche"),
 which we keep as the skill ``summary``. Duplicates are dropped; categorization is
-left to the user in tailor.
+left to the user.
 """
 
 from __future__ import annotations

{linkfetch-0.1.2 → linkfetch-1.0.0}/src/linkfetch/sections.py

@@ -6,12 +6,12 @@ Each Section ties together:
     None for ``basics`` which comes from the main profile page
   - ``parser``: the pure ``parse(html)`` callable
   - ``out_file`` / ``top_key``: where parsed YAML is written and under what key
-  - ``mapped``: True if the output file is one of the profile files THRIVE and
-    tailor read (``data/profile/<name>.yaml``); ``honors`` is an extra,
-    richer copy of awards and is not
+  - ``mapped``: True for the standard profile files that go into
+    ``linkfetch-profile.zip``; ``honors`` is an extra, richer copy of awards
+    and is not
 
 Note ``honors`` and ``awards`` share the same source page ('honors') but produce
-two different output files (the trimmed tailor Award + the richer extra Honor).
+two different output files (the trimmed Award + the richer extra Honor).
 """
 
 from __future__ import annotations

linkfetch-1.0.0/tests/test_emit.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import yaml
+
+from linkfetch.emit import dump_yaml
+from linkfetch.models import Experience, Position, Timeline
+
+
+def _sample_experiences() -> list[Experience]:
+    return [
+        Experience(
+            id="acme-corp-senior-backend-engineer",
+            org="Acme Corp",
+            location="Berlin, Germany",
+            positions=[Position(title="Senior Backend Engineer")],
+            timeline=Timeline(start="Mar 2021", end="Present"),
+            bullets=["Led the payments platform team.", "Cut p99 latency by 40%."],
+        )
+    ]
+
+
+def test_round_trip_and_pruning(tmp_path):
+    path = tmp_path / "experiences.yaml"
+    dump_yaml(path, "experiences", _sample_experiences())
+    loaded = yaml.safe_load(path.read_text())
+
+    assert "experiences" in loaded
+    exp = loaded["experiences"][0]
+    assert exp["org"] == "Acme Corp"
+    assert exp["positions"][0]["title"] == "Senior Backend Engineer"
+    assert exp["timeline"]["start"] == "Mar 2021"
+    # Empty fields (tags, tech, links) are pruned, not emitted as [].
+    assert "tags" not in exp
+    assert "tech" not in exp
+    assert "links" not in exp

linkfetch-1.0.0/tests/test_regressions.py

@@ -0,0 +1,34 @@
+"""Bugs found in a real capture, kept fixed."""
+
+from linkfetch.emit import _to_plain
+from linkfetch.models import Course
+from linkfetch.parse import projects
+
+
+def _page(*entries: str) -> str:
+    return (
+        "<html><body><main><section aria-label='Primary content'>"
+        "<div><p>Projects</p></div><div>" + "".join(entries) + "</div>"
+        "</section></main></body></html>"
+    )
+
+
+def test_linkedin_notice_is_not_a_project():
+    html = _page(
+        "<div><p>Projects from connected apps sync automatically and can’t be edited on LinkedIn.</p>"
+        "<span>Learn more</span></div>",
+        "<div><p>Example Viewer</p><p>Nov 2025 – Present</p></div>",
+        "<div><p>Example CLI</p><p>Jan 2024 – Mar 2024</p></div>",
+    )
+    assert [p.name for p in projects.parse(html)] == ["Example Viewer", "Example CLI"]
+
+
+def test_identical_entries_are_written_once_and_ids_stay_unique():
+    data = _to_plain([
+        Course(id="stats-math-32", name="Probability and Statistics", number="MATH 32"),
+        Course(id="stats-math-32", name="Probability and Statistics", number="MATH 32"),
+        Course(id="intro", name="Intro", associated_with="School A"),
+        Course(id="intro", name="Intro", associated_with="School B"),
+    ])
+    assert [c["id"] for c in data] == ["stats-math-32", "intro", "intro-2"]
+    assert data[2]["associated_with"] == "School B"

{linkfetch-0.1.2 → linkfetch-1.0.0}/tests/test_release.py

@@ -41,11 +41,11 @@ def test_profile_bundle_is_flat_and_has_only_profile_files(tmp_path):
         assert sorted(archive.namelist()) == ["basics.yaml", "experiences.yaml"]
 
 
-def test_every_profile_section_maps_to_a_thrive_category_file():
-    thrive = {
+def test_every_standard_section_goes_into_the_profile_bundle():
+    standard = {
         "basics", "experiences", "skills", "projects", "certifications", "awards",
         "education", "languages", "courses", "patents", "recommendations", "volunteering",
     }
     mapped = {Path(s.out_file).stem for s in SECTIONS if s.mapped}
-    assert mapped == thrive
+    assert mapped == standard
     assert {s.slug for s in SECTIONS if not s.mapped} == {"honors"}

{linkfetch-0.1.2 → linkfetch-1.0.0}/uv.lock

@@ -138,7 +138,7 @@ wheels = [
 
 [[package]]
 name = "linkfetch"
-version = "0.1.2"
+version = "1.0.0"
 source = { editable = "." }
 dependencies = [
     { name = "lxml" },

linkfetch-0.1.2/docs/superpowers/specs/2026-06-15-linkfetch-design.md

@@ -1,184 +0,0 @@
-# linkfetch — Local LinkedIn Profile Scraper
-
-**Date:** 2026-06-15
-**Status:** Approved design, building
-
-## Purpose
-
-A **local CLI tool** that scrapes *your own* LinkedIn profile via browser
-automation and emits **`tailor`-compatible YAML**, so you can bootstrap or
-refresh your `tailor` profile from LinkedIn instead of typing it by hand.
-
-It is a sibling project under `prosperis`, decoupled from `tailor`: it knows
-`tailor`'s profile schema and writes matching YAML, but does not import or
-modify `tailor`. You review the emitted YAML and copy it into `tailor/data/profile/`.
-
-This is **not** a web service. Nothing is hosted; it is a command run on your
-machine that drives a real browser you log into.
-
-## Scope
-
-### Sections captured
-
-LinkedIn exposes far more than `tailor` models. We capture all of the
-following. Sections that map onto `tailor`'s schema are emitted as
-`tailor`-ready files; the rest are emitted as extra YAML for the user to handle.
-
-| LinkedIn section            | Output file              | Maps to tailor? |
-|-----------------------------|--------------------------|-----------------|
-| Name / headline / about / location | `basics.yaml`     | yes (`Basics`)  |
-| Experience                  | `experiences.yaml`       | yes (`Experience`) |
-| Skills                      | `skills.yaml`            | yes (`Skill`)   |
-| Projects                    | `projects.yaml`          | yes (`Project`) |
-| Licenses & certifications   | `certifications.yaml`    | yes (`Certification`) |
-| Honors & awards             | `awards.yaml`            | yes (`Award`)   |
-| Education                   | `education.yaml`         | no — extra      |
-| Volunteering                | `volunteering.yaml`      | no — extra      |
-| Recommendations             | `recommendations.yaml`   | no — extra      |
-| Patents                     | `patents.yaml`           | no — extra      |
-| Courses                     | `courses.yaml`           | no — extra      |
-| Languages                   | `languages.yaml`         | no — extra      |
-
-"Extra" files use a simple, readable schema of our own (defined in this repo),
-not `tailor`'s.
-
-### Out of scope
-
-- Scraping other people / companies / job postings (job postings are `tailor`'s job).
-- AI / Ollama normalization. **Pure deterministic scrape** — fields come straight
-  from the page. `summary` is raw text; `bullets` split on the page's own line
-  breaks; the user enriches tags / position framings later in `tailor`.
-- Official-export ZIP parsing.
-- Auto-writing into `tailor`'s profile dir (user reviews and copies manually).
-
-## Architecture — two-phase: capture HTML → parse offline
-
-The fragile part (LinkedIn's DOM, login, lazy loading) is **quarantined** in a
-capture phase that runs rarely and needs a live session. Parsing is a **pure
-function over saved HTML**, fully unit-testable against fixtures and re-runnable
-with no browser.
-
-```
-                 phase 1: capture (Playwright, live session)
-  LinkedIn  ──►  login (persistent context)  ──►  visit each section's
-                                                    /details/<section>/ page
-                                                  ──►  expand "see more", scroll
-                                                  ──►  save rendered HTML
-                                                       to captures/<section>.html
-                 ─────────────────────────────────────────────────────────────
-                 phase 2: parse (pure, no browser)
-  captures/*.html  ──►  per-section lxml parser  ──►  pydantic models
-                                                  ──►  YAML files in out/
-```
-
-### Components
-
-Package `linkfetch` under `src/linkfetch/` (mirrors `tailor`'s `src/` layout).
-
-- **`config.py`** — `Config` dataclass + `load_config()`, walking up for
-  `config.toml`, exactly like `tailor`. Paths: `captures_dir` (default
-  `data/captures`), `output_dir` (default `data/output`). Browser settings:
-  `user_data_dir` (persistent Chromium profile so login sticks),
-  `headless` (default false for login), `nav_timeout`.
-
-- **`capture/browser.py`** — Playwright session management. Launches a
-  **persistent context** (`launch_persistent_context(user_data_dir=...)`) so the
-  login cookie survives between runs. Exposes:
-  - `ensure_logged_in()` — open `linkedin.com/feed`, detect whether logged in;
-    if not, print instructions and wait for the user to log in manually, then
-    continue.
-  - `capture_section(section)` — navigate to the section's detail URL, run the
-    auto-expand routine, return rendered HTML.
-
-- **`capture/expand.py`** — the scroll + "…see more" / "Show all" expansion
-  routine, shared by all sections. Deterministic: scroll to bottom in steps
-  until height stops changing; click every visible expand control until none
-  remain. No section-specific logic here.
-
-- **`capture/sections.py`** — the registry of sections: slug, detail-page URL
-  template (e.g. `/in/{vanity}/details/experience/`), and which parser handles it.
-  The single source of truth for "what sections exist".
-
-- **`parse/` (one module per section)** — `experience.py`, `skills.py`,
-  `education.py`, etc. Each exposes `parse(html: str) -> list[Model]` (or a single
-  model for basics). Pure: `lxml` in, pydantic out. LinkedIn's randomized class
-  names are avoided by anchoring on **stable structures**: the visually-hidden
-  `<span aria-hidden="true">` text, `aria-label`s, and the section's anchor `id`.
-
-- **`models.py`** — pydantic models. For mapped sections, fields are a **subset**
-  of `tailor`'s models using the **same field names** (`id`, `summary`, `bullets`,
-  `tags`, `org`, `positions`, `timeline`, …) so emitted YAML drops into `tailor`.
-  For extra sections, small purpose-built models.
-
-- **`emit.py`** — serialize models to YAML using the same dumper settings as
-  `tailor`'s `store.py` (`sort_keys=False`, `allow_unicode=True`,
-  `default_flow_style=False`, `width=100`) so output is human-editable and
-  diffable, and identical in style to `tailor`'s files.
-
-- **`cli.py`** — `typer` app mirroring `tailor`'s style. Commands:
-  - `linkfetch doctor` — show config, whether Playwright is installed, whether a
-    login session exists.
-  - `linkfetch login` — open the browser and establish/refresh the session.
-  - `linkfetch capture [--section X ...] [--vanity NAME]` — phase 1; saves HTML
-    to `captures/`. Default: all sections.
-  - `linkfetch parse [--section X ...]` — phase 2; reads `captures/`, writes
-    YAML to `out/`. No browser needed.
-  - `linkfetch run` — convenience: `capture` then `parse`.
-
-### Data flow
-
-1. `login` → persistent Chromium profile stores the LinkedIn cookie under
-   `user_data_dir`.
-2. `capture` → for each section, navigate to its `/details/<section>/` page
-   (these are paginated and far simpler than the monolithic profile page),
-   expand everything, write `captures/<section>.html` + a `captures/meta.json`
-   (timestamp, vanity, section list).
-3. `parse` → for each captured section, run its parser, collect models, emit
-   `out/<file>.yaml`. Mapped files are byte-compatible with `tailor`; extra files
-   use local schemas.
-4. User reviews `out/`, copies the mapped YAML into `tailor/data/profile/`,
-   runs `tailor profile validate`.
-
-### Error handling
-
-- **Playwright missing** → `capture`/`login` fail with the same install hint
-  style `tailor` uses (`uv pip install playwright && playwright install chromium`).
-  `parse` and `doctor` still work without it.
-- **Not logged in** → `capture` detects the login wall and tells the user to run
-  `linkfetch login` (or logs in inline and waits).
-- **Section markup not recognized** → parser returns `[]` for that section and
-  records a warning in the run summary rather than crashing the whole run; the
-  raw HTML stays on disk so parsing can be retried after a selector fix.
-- **Partial captures** → `parse` only processes sections present in `captures/`;
-  missing ones are skipped with a note.
-
-### Testing
-
-- **Parsers (primary):** unit tests over **saved HTML fixtures** in
-  `tests/fixtures/<section>.html` (sanitized, anonymized snippets). Each parser
-  has a test asserting the structured output. This is where correctness lives and
-  is fully offline / CI-friendly.
-- **expand.py:** logic is browser-bound; covered by a thin smoke path, not unit
-  tested against live LinkedIn.
-- **emit.py:** round-trip test — models → YAML → re-load → equal; and a test that
-  mapped YAML validates against `tailor`'s pydantic models (import `tailor` as a
-  test-only dependency *if available*, else skip).
-- **config.py:** test root discovery and path resolution, mirroring `tailor`.
-
-TDD: write the failing parser test against a fixture first, then the parser.
-
-## Stack & conventions
-
-- Python ≥ 3.10, `uv`-managed venv, `pyproject.toml` with `hatchling`,
-  `src/linkfetch/` layout, `typer` + `rich` CLI, `pydantic` v2 models,
-  `pyyaml`, `lxml`. `playwright` is an **optional** extra (`[browser]`), exactly
-  like `tailor`. `pytest` + `pytest-mock` dev extra.
-- `config.toml` at project root; `data/` gitignored.
-- Console-script entry point `linkfetch = "linkfetch.cli:app"`.
-
-## Legal / safety note
-
-For **personal use on the user's own profile**. LinkedIn's ToS restricts
-automated access; this tool uses a real logged-in browser session at human-ish
-pace, captures only the authenticated user's own data, and stores nothing
-remotely. The README states this plainly.

linkfetch-0.1.2/src/linkfetch/__init__.py

@@ -1,3 +0,0 @@
-"""linkfetch — local LinkedIn profile scraper emitting tailor-compatible YAML."""
-
-__version__ = "0.1.0"

linkfetch-0.1.2/tests/test_emit.py

@@ -1,78 +0,0 @@
-from __future__ import annotations
-
-import importlib.util
-import sys
-from pathlib import Path
-
-import yaml
-
-from linkfetch.emit import dump_yaml
-from linkfetch.models import Experience, Position, Timeline
-
-
-def _sample_experiences() -> list[Experience]:
-    return [
-        Experience(
-            id="acme-corp-senior-backend-engineer",
-            org="Acme Corp",
-            location="Berlin, Germany",
-            positions=[Position(title="Senior Backend Engineer")],
-            timeline=Timeline(start="Mar 2021", end="Present"),
-            bullets=["Led the payments platform team.", "Cut p99 latency by 40%."],
-        )
-    ]
-
-
-def test_round_trip_and_pruning(tmp_path):
-    path = tmp_path / "experiences.yaml"
-    dump_yaml(path, "experiences", _sample_experiences())
-    loaded = yaml.safe_load(path.read_text())
-
-    assert "experiences" in loaded
-    exp = loaded["experiences"][0]
-    assert exp["org"] == "Acme Corp"
-    assert exp["positions"][0]["title"] == "Senior Backend Engineer"
-    assert exp["timeline"]["start"] == "Mar 2021"
-    # Empty fields (tags, tech, links) are pruned, not emitted as [].
-    assert "tags" not in exp
-    assert "tech" not in exp
-    assert "links" not in exp
-
-
-_TAILOR_MODELS = (
-    Path(__file__).resolve().parents[2]
-    / "tailor"
-    / "src"
-    / "tailor"
-    / "profile"
-    / "models.py"
-)
-
-
-def _load_tailor_models():
-    """Import tailor's models module directly from the sibling project, if present."""
-    if not _TAILOR_MODELS.is_file():
-        return None
-    spec = importlib.util.spec_from_file_location("tailor_profile_models", _TAILOR_MODELS)
-    module = importlib.util.module_from_spec(spec)
-    sys.modules[spec.name] = module
-    spec.loader.exec_module(module)
-    return module
-
-
-def test_emitted_yaml_validates_against_tailor_schema(tmp_path):
-    """The mapped experiences.yaml must load into tailor's own pydantic model."""
-    tailor = _load_tailor_models()
-    if tailor is None:
-        import pytest
-
-        pytest.skip("tailor project not available next to linkfetch")
-
-    path = tmp_path / "experiences.yaml"
-    dump_yaml(path, "experiences", _sample_experiences())
-    raw = yaml.safe_load(path.read_text())
-
-    # Should validate without error.
-    wrapper = tailor.ExperiencesFile.model_validate(raw)
-    assert wrapper.experiences[0].org == "Acme Corp"
-    assert wrapper.experiences[0].positions[0].title == "Senior Backend Engineer"