# my-publisher Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Build a PyQt6 desktop GUI for Linux that centralizes the danix.xyz blog publishing workflow — articles, translations, git, hugo server, media, and taxonomy management.

**Architecture:** Single Python process, PyQt6 for UI, QThread/QProcess for all async operations so the UI never blocks. Core layer (data models, config, file scanning) is UI-agnostic. Workers wrap subprocess operations and emit Qt signals. UI components consume workers via signals/slots.

**Tech Stack:** Python 3.11+, PyQt6, tomlkit, mistune. Blog repo at `/home/danix/Programming/GIT/danix.xyz-hacker-theme`, translation script at `/home/danix/bin/transart.py`.

---

## File Map

```
my-publisher/
├── main.py                         # QApplication entry point, loads config, shows main window
├── requirements.txt
├── core/
│   ├── __init__.py
│   ├── config.py                   # load/save ~/.config/my-publisher/config.toml
│   ├── models.py                   # Article, TaxonomyModel dataclasses + ARTICLE_TYPES
│   ├── article_scanner.py          # scan content/it/ + content/en/, build list[Article]
│   ├── frontmatter.py              # parse/write TOML frontmatter with tomlkit
│   └── taxonomy.py                 # load/save tags-it.txt + tags-en.txt, TaxonomyModel
├── workers/
│   ├── __init__.py
│   ├── git_worker.py               # QThread: pull, push master, push production, rm, restore
│   ├── hugo_worker.py              # QProcess wrapper: hugo server start/stop + log streaming
│   └── translation_worker.py      # QProcess wrapper: transart.py + stdout streaming
├── ui/
│   ├── __init__.py
│   ├── main_window.py              # QMainWindow: sidebar + QStackedWidget content area
│   ├── setup_dialog.py             # first-run config dialog
│   ├── articles_view.py            # tab IT/EN list + "Senza Traduzione" mode
│   ├── article_detail.py           # header + frontmatter column + markdown preview column
│   ├── frontmatter_editor.py       # modal dialog: dynamic TOML form
│   ├── translation_view.py         # QProcess log streaming + post-translation preview
│   ├── git_view.py                 # repo status + pull/push buttons + deleted articles
│   ├── taxonomy_view.py            # tab Tags/Categorie, IT|EN columns, edit + translate
│   ├── media_view.py               # drag-drop upload to static/uppies/YYYY/MM/
│   └── hugo_panel.py               # hugo server start/stop + log + URL link
└── tests/
    ├── test_config.py
    ├── test_models.py
    ├── test_article_scanner.py
    ├── test_frontmatter.py
    └── test_taxonomy.py
```

---

## Task 1: Project scaffold + dependencies

**Files:**
- Create: `requirements.txt`
- Create: `main.py`
- Create: `core/__init__.py`, `workers/__init__.py`, `ui/__init__.py`

- [ ] **Step 1: Create requirements.txt**

```
PyQt6>=6.6.0
tomlkit>=0.12.0
mistune>=3.0.0
```

- [ ] **Step 2: Install dependencies**

```bash
cd /home/danix/Programming/GIT/my-publisher
pip install -r requirements.txt
```

Expected: all packages install without errors.

- [ ] **Step 3: Create package init files**

```bash
mkdir -p core workers ui tests
touch core/__init__.py workers/__init__.py ui/__init__.py tests/__init__.py
```

- [ ] **Step 4: Create minimal main.py**

```python
import sys
from PyQt6.QtWidgets import QApplication

def main():
    app = QApplication(sys.argv)
    app.setApplicationName("my-publisher")
    app.setOrganizationName("danix")
    sys.exit(app.exec())

if __name__ == "__main__":
    main()
```

- [ ] **Step 5: Verify app launches and exits**

```bash
python main.py &
sleep 1
kill %1
```

Expected: no import errors.

- [ ] **Step 6: Commit**

```bash
git init
git add requirements.txt main.py core/__init__.py workers/__init__.py ui/__init__.py tests/__init__.py
git commit -m "chore: initial project scaffold"
```

---

## Task 2: Config module

**Files:**
- Create: `core/config.py`
- Create: `tests/test_config.py`

- [ ] **Step 1: Write failing tests**

```python
# tests/test_config.py
import pytest
from pathlib import Path
import tempfile, os
from core.config import Config, DEFAULT_CONFIG_PATH

def test_config_loads_defaults_when_missing(tmp_path, monkeypatch):
    monkeypatch.setattr("core.config.DEFAULT_CONFIG_PATH", tmp_path / "config.toml")
    cfg = Config.load()
    assert cfg.blog_repo == ""
    assert cfg.transart_script == "/home/danix/bin/transart.py"
    assert cfg.typora_bin == "typora"

def test_config_round_trips(tmp_path, monkeypatch):
    path = tmp_path / "config.toml"
    monkeypatch.setattr("core.config.DEFAULT_CONFIG_PATH", path)
    cfg = Config(blog_repo="/some/path", transart_script="/bin/x", typora_bin="typora")
    cfg.save()
    loaded = Config.load()
    assert loaded.blog_repo == "/some/path"

def test_config_is_complete_false_when_blog_repo_empty(tmp_path, monkeypatch):
    monkeypatch.setattr("core.config.DEFAULT_CONFIG_PATH", tmp_path / "config.toml")
    cfg = Config.load()
    assert cfg.is_complete() is False

def test_config_is_complete_true_when_all_set(tmp_path, monkeypatch):
    monkeypatch.setattr("core.config.DEFAULT_CONFIG_PATH", tmp_path / "config.toml")
    cfg = Config(blog_repo="/some/repo", transart_script="/bin/x", typora_bin="typora")
    assert cfg.is_complete() is True
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
pytest tests/test_config.py -v
```

Expected: ImportError or AttributeError — `core.config` not defined.

- [ ] **Step 3: Implement core/config.py**

```python
from __future__ import annotations
from dataclasses import dataclass, field
from pathlib import Path
import tomlkit

DEFAULT_CONFIG_PATH = Path.home() / ".config" / "my-publisher" / "config.toml"

@dataclass
class Config:
    blog_repo: str = ""
    transart_script: str = "/home/danix/bin/transart.py"
    typora_bin: str = "typora"

    def is_complete(self) -> bool:
        return bool(self.blog_repo)

    def save(self, path: Path = DEFAULT_CONFIG_PATH) -> None:
        path.parent.mkdir(parents=True, exist_ok=True)
        doc = tomlkit.document()
        doc.add("blog_repo", self.blog_repo)
        doc.add("transart_script", self.transart_script)
        doc.add("typora_bin", self.typora_bin)
        path.write_text(tomlkit.dumps(doc))

    @classmethod
    def load(cls, path: Path = DEFAULT_CONFIG_PATH) -> "Config":
        if not path.exists():
            return cls()
        data = tomlkit.loads(path.read_text())
        return cls(
            blog_repo=str(data.get("blog_repo", "")),
            transart_script=str(data.get("transart_script", "/home/danix/bin/transart.py")),
            typora_bin=str(data.get("typora_bin", "typora")),
        )
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
pytest tests/test_config.py -v
```

Expected: 4 passed.

- [ ] **Step 5: Commit**

```bash
git add core/config.py tests/test_config.py
git commit -m "feat: config load/save with tomlkit"
```

---

## Task 3: Data models

**Files:**
- Create: `core/models.py`
- Create: `tests/test_models.py`

- [ ] **Step 1: Write failing tests**

```python
# tests/test_models.py
from pathlib import Path
from core.models import Article, ARTICLE_TYPES

def test_article_types_contains_five():
    assert len(ARTICLE_TYPES) == 5
    assert "Tech" in ARTICLE_TYPES
    assert "Life" in ARTICLE_TYPES

def test_article_fields():
    a = Article(
        slug="test-post",
        lang="it",
        path=Path("/blog/content/it/articles/test-post/index.md"),
        frontmatter={"title": "Test", "type": "Tech"},
        has_translation=False,
        translation_path=None,
    )
    assert a.slug == "test-post"
    assert a.lang == "it"
    assert a.has_translation is False
    assert a.translation_path is None

def test_article_with_translation():
    a = Article(
        slug="test-post",
        lang="it",
        path=Path("/blog/content/it/articles/test-post/index.md"),
        frontmatter={},
        has_translation=True,
        translation_path=Path("/blog/content/en/articles/test-post/index.md"),
    )
    assert a.has_translation is True
    assert a.translation_path is not None
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
pytest tests/test_models.py -v
```

Expected: ImportError.

- [ ] **Step 3: Implement core/models.py**

```python
from __future__ import annotations
from dataclasses import dataclass
from pathlib import Path

ARTICLE_TYPES = ["Life", "Photo", "Link", "Quote", "Tech"]

@dataclass
class Article:
    slug: str
    lang: str          # "it" | "en"
    path: Path
    frontmatter: dict
    has_translation: bool
    translation_path: Path | None
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
pytest tests/test_models.py -v
```

Expected: 3 passed.

- [ ] **Step 5: Commit**

```bash
git add core/models.py tests/test_models.py
git commit -m "feat: Article dataclass and ARTICLE_TYPES"
```

---

## Task 4: Frontmatter parser

**Files:**
- Create: `core/frontmatter.py`
- Create: `tests/test_frontmatter.py`

- [ ] **Step 1: Write failing tests**

```python
# tests/test_frontmatter.py
import pytest
from pathlib import Path
import tempfile
from core.frontmatter import parse_frontmatter, write_frontmatter

SAMPLE_MD = """\
+++
title = "Test Article"
type = "Tech"
draft = false
tags = ["linux", "python"]
+++

# Body

Some content here.
"""

def test_parse_returns_frontmatter_dict(tmp_path):
    f = tmp_path / "index.md"
    f.write_text(SAMPLE_MD)
    fm, body = parse_frontmatter(f)
    assert fm["title"] == "Test Article"
    assert fm["type"] == "Tech"
    assert fm["draft"] is False
    assert "linux" in fm["tags"]

def test_parse_returns_body(tmp_path):
    f = tmp_path / "index.md"
    f.write_text(SAMPLE_MD)
    fm, body = parse_frontmatter(f)
    assert "# Body" in body
    assert "Some content here." in body

def test_write_preserves_format(tmp_path):
    f = tmp_path / "index.md"
    f.write_text(SAMPLE_MD)
    fm, body = parse_frontmatter(f)
    fm["title"] = "Updated Title"
    write_frontmatter(f, fm, body)
    fm2, _ = parse_frontmatter(f)
    assert fm2["title"] == "Updated Title"
    assert fm2["type"] == "Tech"

def test_parse_raises_on_missing_delimiters(tmp_path):
    f = tmp_path / "index.md"
    f.write_text("# No frontmatter\n\nJust body.")
    with pytest.raises(ValueError, match="frontmatter"):
        parse_frontmatter(f)
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
pytest tests/test_frontmatter.py -v
```

Expected: ImportError.

- [ ] **Step 3: Implement core/frontmatter.py**

```python
from __future__ import annotations
from pathlib import Path
import tomlkit

def parse_frontmatter(path: Path) -> tuple[dict, str]:
    """Parse TOML frontmatter delimited by +++. Returns (frontmatter_dict, body_str)."""
    text = path.read_text(encoding="utf-8")
    if not text.startswith("+++"):
        raise ValueError(f"No TOML frontmatter found in {path}")
    parts = text.split("+++", 2)
    if len(parts) < 3:
        raise ValueError(f"Malformed frontmatter in {path}")
    _, toml_block, body = parts
    fm = dict(tomlkit.loads(toml_block))
    return fm, body.lstrip("\n")

def write_frontmatter(path: Path, frontmatter: dict, body: str) -> None:
    """Write frontmatter + body back to file, preserving TOML format."""
    text = path.read_text(encoding="utf-8")
    parts = text.split("+++", 2)
    if len(parts) < 3:
        raise ValueError(f"Malformed frontmatter in {path}")
    _, original_toml, _ = parts
    doc = tomlkit.loads(original_toml)
    for k, v in frontmatter.items():
        doc[k] = v
    new_text = f"+++\n{tomlkit.dumps(doc).strip()}\n+++\n\n{body}"
    path.write_text(new_text, encoding="utf-8")
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
pytest tests/test_frontmatter.py -v
```

Expected: 4 passed.

- [ ] **Step 5: Commit**

```bash
git add core/frontmatter.py tests/test_frontmatter.py
git commit -m "feat: TOML frontmatter parse/write with tomlkit"
```

---

## Task 5: Taxonomy module

**Files:**
- Create: `core/taxonomy.py`
- Create: `tests/test_taxonomy.py`

- [ ] **Step 1: Write failing tests**

```python
# tests/test_taxonomy.py
import pytest
from pathlib import Path
from core.taxonomy import TaxonomyModel, load_taxonomy, save_taxonomy

def _write_pair(tmp_path, it_lines, en_lines):
    it_file = tmp_path / "tags-it.txt"
    en_file = tmp_path / "tags-en.txt"
    it_file.write_text("\n".join(it_lines) + "\n")
    en_file.write_text("\n".join(en_lines) + "\n")
    return it_file, en_file

def test_load_taxonomy_basic(tmp_path):
    it_f, en_f = _write_pair(tmp_path, ["linux", "vita"], ["linux", "life"])
    model = load_taxonomy(it_f, en_f)
    assert model.it_to_en["linux"] == "linux"
    assert model.it_to_en["vita"] == "life"

def test_load_taxonomy_orphan_it(tmp_path):
    it_f, en_f = _write_pair(tmp_path, ["linux", "vita", "extra"], ["linux", "life"])
    model = load_taxonomy(it_f, en_f)
    assert "extra" in model.orphans_it

def test_load_taxonomy_orphan_en(tmp_path):
    it_f, en_f = _write_pair(tmp_path, ["linux"], ["linux", "extra-en"])
    model = load_taxonomy(it_f, en_f)
    assert "extra-en" in model.orphans_en

def test_save_taxonomy_round_trips(tmp_path):
    it_f, en_f = _write_pair(tmp_path, ["linux"], ["linux"])
    model = load_taxonomy(it_f, en_f)
    model.it_to_en["vita"] = "life"
    save_taxonomy(model, it_f, en_f)
    model2 = load_taxonomy(it_f, en_f)
    assert model2.it_to_en["vita"] == "life"

def test_save_taxonomy_sorted(tmp_path):
    it_f, en_f = _write_pair(tmp_path, [], [])
    from core.taxonomy import TaxonomyModel
    model = TaxonomyModel(it_to_en={"zzz": "zzz", "aaa": "aaa"}, orphans_it=[], orphans_en=[])
    save_taxonomy(model, it_f, en_f)
    lines = it_f.read_text().splitlines()
    assert lines == sorted(lines)
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
pytest tests/test_taxonomy.py -v
```

Expected: ImportError.

- [ ] **Step 3: Implement core/taxonomy.py**

```python
from __future__ import annotations
from dataclasses import dataclass, field
from pathlib import Path

@dataclass
class TaxonomyModel:
    it_to_en: dict[str, str]
    orphans_it: list[str]   # IT terms with no EN pair
    orphans_en: list[str]   # EN terms with no IT pair

def load_taxonomy(it_path: Path, en_path: Path) -> TaxonomyModel:
    it_terms = [l.strip() for l in it_path.read_text().splitlines() if l.strip()] if it_path.exists() else []
    en_terms = [l.strip() for l in en_path.read_text().splitlines() if l.strip()] if en_path.exists() else []
    min_len = min(len(it_terms), len(en_terms))
    it_to_en = {it_terms[i]: en_terms[i] for i in range(min_len)}
    orphans_it = it_terms[min_len:]
    orphans_en = en_terms[min_len:]
    return TaxonomyModel(it_to_en=it_to_en, orphans_it=orphans_it, orphans_en=orphans_en)

def save_taxonomy(model: TaxonomyModel, it_path: Path, en_path: Path) -> None:
    pairs = sorted(model.it_to_en.items(), key=lambda x: x[0])
    it_path.write_text("\n".join(k for k, _ in pairs) + "\n")
    en_path.write_text("\n".join(v for _, v in pairs) + "\n")
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
pytest tests/test_taxonomy.py -v
```

Expected: 5 passed.

- [ ] **Step 5: Commit**

```bash
git add core/taxonomy.py tests/test_taxonomy.py
git commit -m "feat: taxonomy load/save with IT/EN pair alignment"
```

---

## Task 6: Article scanner

**Files:**
- Create: `core/article_scanner.py`
- Create: `tests/test_article_scanner.py`

- [ ] **Step 1: Write failing tests**

```python
# tests/test_article_scanner.py
from pathlib import Path
from core.article_scanner import scan_articles

def _make_article(base: Path, lang: str, slug: str, fm_extra: str = "") -> Path:
    p = base / "content" / lang / "articles" / slug
    p.mkdir(parents=True)
    (p / "index.md").write_text(f"+++\ntitle = \"{slug}\"\ntype = \"Tech\"\n{fm_extra}+++\n\nBody.\n")
    return p / "index.md"

def test_scan_finds_articles(tmp_path):
    _make_article(tmp_path, "it", "primo-post")
    _make_article(tmp_path, "en", "first-post")
    articles = scan_articles(tmp_path)
    slugs = [a.slug for a in articles]
    assert "primo-post" in slugs
    assert "first-post" in slugs

def test_scan_detects_translation_pair(tmp_path):
    _make_article(tmp_path, "it", "shared-slug")
    _make_article(tmp_path, "en", "shared-slug")
    articles = scan_articles(tmp_path)
    it_art = next(a for a in articles if a.lang == "it" and a.slug == "shared-slug")
    en_art = next(a for a in articles if a.lang == "en" and a.slug == "shared-slug")
    assert it_art.has_translation is True
    assert it_art.translation_path == en_art.path
    assert en_art.has_translation is True

def test_scan_detects_missing_translation(tmp_path):
    _make_article(tmp_path, "it", "solo-italiano")
    articles = scan_articles(tmp_path)
    art = next(a for a in articles if a.slug == "solo-italiano")
    assert art.has_translation is False
    assert art.translation_path is None

def test_scan_parses_frontmatter(tmp_path):
    _make_article(tmp_path, "it", "con-fm", 'tags = ["linux"]\n')
    articles = scan_articles(tmp_path)
    art = next(a for a in articles if a.slug == "con-fm")
    assert art.frontmatter["title"] == "con-fm"
    assert "linux" in art.frontmatter["tags"]
```

- [ ] **Step 2: Run tests to verify they fail**

```bash
pytest tests/test_article_scanner.py -v
```

Expected: ImportError.

- [ ] **Step 3: Implement core/article_scanner.py**

```python
from __future__ import annotations
from pathlib import Path
from core.models import Article
from core.frontmatter import parse_frontmatter

def scan_articles(blog_root: Path) -> list[Article]:
    articles: list[Article] = []
    by_slug: dict[tuple[str, str], Path] = {}

    for lang in ("it", "en"):
        content_dir = blog_root / "content" / lang / "articles"
        if not content_dir.exists():
            continue
        for index_md in sorted(content_dir.glob("*/index.md")):
            slug = index_md.parent.name
            by_slug[(lang, slug)] = index_md

    for (lang, slug), path in by_slug.items():
        other_lang = "en" if lang == "it" else "it"
        translation_path = by_slug.get((other_lang, slug))
        try:
            fm, _ = parse_frontmatter(path)
        except (ValueError, Exception):
            fm = {}
        articles.append(Article(
            slug=slug,
            lang=lang,
            path=path,
            frontmatter=fm,
            has_translation=translation_path is not None,
            translation_path=translation_path,
        ))

    return articles
```

- [ ] **Step 4: Run tests to verify they pass**

```bash
pytest tests/test_article_scanner.py -v
```

Expected: 4 passed.

- [ ] **Step 5: Commit**

```bash
git add core/article_scanner.py tests/test_article_scanner.py
git commit -m "feat: article scanner with translation pair detection"
```

---

## Task 7: Git worker

**Files:**
- Create: `workers/git_worker.py`

- [ ] **Step 1: Implement workers/git_worker.py**

```python
from __future__ import annotations
from PyQt6.QtCore import QThread, pyqtSignal
import subprocess
from pathlib import Path

class GitWorker(QThread):
    output = pyqtSignal(str)
    error = pyqtSignal(str)
    finished = pyqtSignal(bool)  # True = success

    def __init__(self, repo_path: Path, command: list[str], parent=None):
        super().__init__(parent)
        self._repo_path = repo_path
        self._command = command

    def run(self):
        try:
            result = subprocess.run(
                self._command,
                cwd=self._repo_path,
                capture_output=True,
                text=True,
            )
            if result.stdout:
                self.output.emit(result.stdout)
            if result.returncode != 0:
                self.error.emit(result.stderr or f"Exit code {result.returncode}")
                self.finished.emit(False)
            else:
                self.finished.emit(True)
        except Exception as e:
            self.error.emit(str(e))
            self.finished.emit(False)

    @staticmethod
    def pull(repo_path: Path, parent=None) -> "GitWorker":
        return GitWorker(repo_path, ["git", "pull"], parent)

    @staticmethod
    def push_master(repo_path: Path, parent=None) -> "GitWorker":
        return GitWorker(repo_path, ["git", "push", "origin", "master"], parent)

    @staticmethod
    def push_production(repo_path: Path, parent=None) -> "GitWorker":
        return GitWorker(repo_path, ["git", "push", "origin", "production"], parent)

    @staticmethod
    def remove_article(repo_path: Path, rel_path: str, slug: str, lang: str, parent=None) -> "GitWorker":
        # Two-step: git rm then git commit
        class _RmWorker(QThread):
            output = pyqtSignal(str)
            error = pyqtSignal(str)
            finished = pyqtSignal(bool)

            def run(self_inner):
                for cmd in [
                    ["git", "rm", "-r", rel_path],
                    ["git", "commit", "-m", f"remove: {slug} ({lang})"],
                ]:
                    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
                    if result.stdout:
                        self_inner.output.emit(result.stdout)
                    if result.returncode != 0:
                        self_inner.error.emit(result.stderr or f"Exit code {result.returncode}")
                        self_inner.finished.emit(False)
                        return
                self_inner.finished.emit(True)

        return _RmWorker(parent)

    @staticmethod
    def restore_article(repo_path: Path, commit_hash: str, rel_path: str, parent=None) -> "GitWorker":
        return GitWorker(repo_path, ["git", "checkout", commit_hash, "--", rel_path], parent)
```

- [ ] **Step 2: Verify import works**

```bash
python -c "from workers.git_worker import GitWorker; print('ok')"
```

Expected: `ok`

- [ ] **Step 3: Commit**

```bash
git add workers/git_worker.py
git commit -m "feat: GitWorker QThread for pull/push/rm/restore"
```

---

## Task 8: Hugo worker

**Files:**
- Create: `workers/hugo_worker.py`

- [ ] **Step 1: Implement workers/hugo_worker.py**

```python
from __future__ import annotations
from PyQt6.QtCore import QObject, QProcess, pyqtSignal
from pathlib import Path

class HugoWorker(QObject):
    log_line = pyqtSignal(str)
    started = pyqtSignal()
    stopped = pyqtSignal()
    error = pyqtSignal(str)

    def __init__(self, repo_path: Path, parent=None):
        super().__init__(parent)
        self._repo_path = repo_path
        self._process = QProcess(self)
        self._process.readyReadStandardOutput.connect(self._on_stdout)
        self._process.readyReadStandardError.connect(self._on_stderr)
        self._process.finished.connect(self._on_finished)

    @property
    def is_running(self) -> bool:
        return self._process.state() == QProcess.ProcessState.Running

    def start(self):
        if self.is_running:
            return
        self._process.setWorkingDirectory(str(self._repo_path))
        self._process.start("hugo", ["server", "-D"])
        self.started.emit()

    def stop(self):
        if self.is_running:
            self._process.terminate()
            self._process.waitForFinished(3000)
            self.stopped.emit()

    def _on_stdout(self):
        data = self._process.readAllStandardOutput().data().decode("utf-8", errors="replace")
        for line in data.splitlines():
            self.log_line.emit(line)

    def _on_stderr(self):
        data = self._process.readAllStandardError().data().decode("utf-8", errors="replace")
        for line in data.splitlines():
            self.log_line.emit(line)

    def _on_finished(self, exit_code: int, _):
        if exit_code != 0:
            self.error.emit(f"hugo server exited with code {exit_code}")
        self.stopped.emit()
```

- [ ] **Step 2: Verify import**

```bash
python -c "from workers.hugo_worker import HugoWorker; print('ok')"
```

Expected: `ok`

- [ ] **Step 3: Commit**

```bash
git add workers/hugo_worker.py
git commit -m "feat: HugoWorker QProcess with log streaming"
```

---

## Task 9: Translation worker

**Files:**
- Create: `workers/translation_worker.py`

- [ ] **Step 1: Implement workers/translation_worker.py**

```python
from __future__ import annotations
from PyQt6.QtCore import QObject, QProcess, pyqtSignal
from pathlib import Path

class TranslationWorker(QObject):
    log_line = pyqtSignal(str)
    finished = pyqtSignal(bool, str)  # success, output_path
    error = pyqtSignal(str)

    def __init__(self, transart_script: Path, article_path: Path, direction: str, parent=None):
        super().__init__(parent)
        self._script = transart_script
        self._article_path = article_path
        self._direction = direction  # e.g. "it-en" or "en-it"
        self._process = QProcess(self)
        self._process.readyReadStandardOutput.connect(self._on_stdout)
        self._process.readyReadStandardError.connect(self._on_stderr)
        self._process.finished.connect(self._on_finished)

    def start(self):
        self._process.start("python3", [
            str(self._script),
            "--direction", self._direction,
            str(self._article_path),
        ])

    def _on_stdout(self):
        data = self._process.readAllStandardOutput().data().decode("utf-8", errors="replace")
        for line in data.splitlines():
            self.log_line.emit(line)

    def _on_stderr(self):
        data = self._process.readAllStandardError().data().decode("utf-8", errors="replace")
        for line in data.splitlines():
            self.log_line.emit(f"[stderr] {line}")

    def _on_finished(self, exit_code: int, _):
        success = exit_code == 0
        # Derive expected output path: content/it/... → content/en/...
        path_str = str(self._article_path)
        if "/it/" in path_str:
            out = path_str.replace("/it/", "/en/", 1)
        elif "/en/" in path_str:
            out = path_str.replace("/en/", "/it/", 1)
        else:
            out = ""
        if not success:
            self.error.emit(f"transart.py exited with code {exit_code}")
        self.finished.emit(success, out)
```

- [ ] **Step 2: Verify import**

```bash
python -c "from workers.translation_worker import TranslationWorker; print('ok')"
```

Expected: `ok`

- [ ] **Step 3: Commit**

```bash
git add workers/translation_worker.py
git commit -m "feat: TranslationWorker QProcess for transart.py streaming"
```

---

## Task 10: Main window + setup dialog

**Files:**
- Create: `ui/setup_dialog.py`
- Create: `ui/main_window.py`
- Modify: `main.py`

- [ ] **Step 1: Implement ui/setup_dialog.py**

```python
from __future__ import annotations
from PyQt6.QtWidgets import (
    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QLineEdit,
    QPushButton, QFileDialog, QFormLayout,
)
from core.config import Config

class SetupDialog(QDialog):
    def __init__(self, config: Config, parent=None):
        super().__init__(parent)
        self.setWindowTitle("my-publisher — Setup")
        self.setMinimumWidth(500)
        self._config = config
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)
        layout.addWidget(QLabel("Configura my-publisher prima di iniziare."))

        form = QFormLayout()

        self._blog_repo = QLineEdit(self._config.blog_repo)
        browse_btn = QPushButton("Sfoglia...")
        browse_btn.clicked.connect(self._browse_repo)
        row = QHBoxLayout()
        row.addWidget(self._blog_repo)
        row.addWidget(browse_btn)
        form.addRow("Blog repo:", row)

        self._transart = QLineEdit(self._config.transart_script)
        form.addRow("transart.py:", self._transart)

        self._typora = QLineEdit(self._config.typora_bin)
        form.addRow("Typora bin:", self._typora)

        layout.addLayout(form)

        btns = QHBoxLayout()
        save_btn = QPushButton("Salva")
        save_btn.clicked.connect(self._save)
        btns.addStretch()
        btns.addWidget(save_btn)
        layout.addLayout(btns)

    def _browse_repo(self):
        path = QFileDialog.getExistingDirectory(self, "Seleziona blog repo")
        if path:
            self._blog_repo.setText(path)

    def _save(self):
        self._config.blog_repo = self._blog_repo.text().strip()
        self._config.transart_script = self._transart.text().strip()
        self._config.typora_bin = self._typora.text().strip()
        self._config.save()
        self.accept()
```

- [ ] **Step 2: Implement ui/main_window.py**

```python
from __future__ import annotations
from PyQt6.QtWidgets import (
    QMainWindow, QWidget, QHBoxLayout, QVBoxLayout,
    QLabel, QPushButton, QStackedWidget, QFrame, QSizePolicy,
)
from PyQt6.QtCore import Qt, QFileSystemWatcher
from PyQt6.QtGui import QFont
from pathlib import Path
from core.config import Config
from core.article_scanner import scan_articles
from core.models import Article

class SidebarButton(QPushButton):
    def __init__(self, text: str, parent=None):
        super().__init__(text, parent)
        self.setFlat(True)
        self.setCheckable(True)
        self.setStyleSheet("""
            QPushButton { text-align: left; padding: 5px 10px; border-radius: 4px; color: #888; }
            QPushButton:checked { background: #2a2a4e; color: #a855f7; }
            QPushButton:hover:!checked { background: #1a1a2e; color: #ccc; }
        """)

class MainWindow(QMainWindow):
    def __init__(self, config: Config, parent=None):
        super().__init__(parent)
        self.config = config
        self._articles: list[Article] = []
        self._watcher = QFileSystemWatcher(self)
        self._watcher.directoryChanged.connect(self._on_fs_change)
        self.setWindowTitle("my-publisher")
        self.setMinimumSize(1100, 700)
        self._build_ui()
        self._refresh_articles()
        self._setup_watcher()

    def _build_ui(self):
        central = QWidget()
        self.setCentralWidget(central)
        root = QHBoxLayout(central)
        root.setContentsMargins(0, 0, 0, 0)
        root.setSpacing(0)

        # Sidebar
        sidebar = self._build_sidebar()
        root.addWidget(sidebar)

        # Divider
        line = QFrame()
        line.setFrameShape(QFrame.Shape.VLine)
        line.setStyleSheet("color: #2a2a4e;")
        root.addWidget(line)

        # Content stack
        self._stack = QStackedWidget()
        root.addWidget(self._stack, stretch=1)

        # Placeholder pages (replaced in later tasks)
        for name in ["articles", "no_translation", "new_article", "taxonomy",
                     "media", "translations", "git", "hugo"]:
            w = QLabel(f"[{name}]")
            w.setAlignment(Qt.AlignmentFlag.AlignCenter)
            self._stack.addWidget(w)
            setattr(self, f"_page_{name}", self._stack.count() - 1)

    def _build_sidebar(self) -> QWidget:
        w = QWidget()
        w.setFixedWidth(210)
        w.setStyleSheet("background: #1a1a2e;")
        layout = QVBoxLayout(w)
        layout.setContentsMargins(8, 12, 8, 12)
        layout.setSpacing(2)

        header = QHBoxLayout()
        title = QLabel("📰 my-publisher")
        title.setStyleSheet("color: #fff; font-weight: bold; font-size: 13px; padding: 4px 8px;")
        header.addWidget(title)
        self._refresh_btn = QPushButton("🔄")
        self._refresh_btn.setFlat(True)
        self._refresh_btn.setFixedSize(28, 28)
        self._refresh_btn.setStyleSheet("color: #555; border: none;")
        self._refresh_btn.clicked.connect(self._refresh_articles)
        header.addWidget(self._refresh_btn)
        layout.addLayout(header)

        def section(text):
            lbl = QLabel(text)
            lbl.setStyleSheet("color: #a855f7; font-size: 9px; text-transform: uppercase; letter-spacing: 1px; padding: 8px 8px 2px;")
            layout.addWidget(lbl)

        self._btn_group: list[SidebarButton] = []

        def btn(icon_text: str, page_attr: str) -> SidebarButton:
            b = SidebarButton(icon_text)
            b.clicked.connect(lambda: self._show_page(page_attr, b))
            layout.addWidget(b)
            self._btn_group.append(b)
            return b

        section("CONTENUTO")
        btn("📋 Articoli", "_page_articles")
        self._btn_no_trans = btn("⚠️ Senza Traduzione", "_page_no_translation")
        self._badge_no_trans = QLabel("0")
        self._badge_no_trans.setStyleSheet("background:#3a1a1a;color:#ff6b6b;border-radius:8px;padding:1px 6px;font-size:10px;")
        btn("➕ Nuovo articolo", "_page_new_article")
        btn("🏷 Tassonomia", "_page_taxonomy")
        btn("🖼 Media", "_page_media")

        section("WORKFLOW")
        btn("🌍 Traduzioni", "_page_translations")
        btn("🔧 Git ops", "_page_git")
        btn("🚀 Hugo server", "_page_hugo")

        section("DEPLOY")
        btn("🧪 Test (master)", "_page_git")
        btn("🚢 Production", "_page_git")

        layout.addStretch()
        return w

    def _show_page(self, page_attr: str, active_btn: SidebarButton):
        for b in self._btn_group:
            b.setChecked(False)
        active_btn.setChecked(True)
        self._stack.setCurrentIndex(getattr(self, page_attr))

    def _refresh_articles(self):
        if not self.config.blog_repo:
            return
        self._articles = scan_articles(Path(self.config.blog_repo))
        missing = [a for a in self._articles if not a.has_translation]
        self._badge_no_trans.setText(str(len(missing)))

    def _setup_watcher(self):
        if not self.config.blog_repo:
            return
        root = Path(self.config.blog_repo)
        for lang in ("it", "en"):
            d = root / "content" / lang / "articles"
            if d.exists():
                self._watcher.addPath(str(d))

    def _on_fs_change(self, _path: str):
        self._refresh_articles()
```

- [ ] **Step 3: Update main.py to show window**

```python
import sys
from PyQt6.QtWidgets import QApplication
from core.config import Config
from ui.main_window import MainWindow
from ui.setup_dialog import SetupDialog

def main():
    app = QApplication(sys.argv)
    app.setApplicationName("my-publisher")
    app.setOrganizationName("danix")

    config = Config.load()
    if not config.is_complete():
        dlg = SetupDialog(config)
        if dlg.exec() == 0:
            sys.exit(0)
        config = Config.load()

    window = MainWindow(config)
    window.show()
    sys.exit(app.exec())

if __name__ == "__main__":
    main()
```

- [ ] **Step 4: Launch app and verify sidebar renders**

```bash
python main.py
```

Expected: window opens with sidebar, all section buttons visible, no errors in terminal.

- [ ] **Step 5: Commit**

```bash
git add ui/setup_dialog.py ui/main_window.py main.py
git commit -m "feat: main window with sidebar navigation and file watcher"
```

---

## Task 11: Articles view

**Files:**
- Create: `ui/articles_view.py`
- Modify: `ui/main_window.py` (replace placeholder page)

- [ ] **Step 1: Implement ui/articles_view.py**

```python
from __future__ import annotations
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QTabWidget,
    QListWidget, QListWidgetItem, QLabel, QPushButton,
)
from PyQt6.QtCore import Qt, pyqtSignal
from PyQt6.QtGui import QColor
from core.models import Article

class ArticleItem(QListWidgetItem):
    def __init__(self, article: Article):
        super().__init__()
        self.article = article
        lang_other = "EN" if article.lang == "it" else "IT"
        if article.has_translation:
            badge = f"🇬🇧 ✓" if article.lang == "it" else "🇮🇹 ✓"
            status = f"{article.slug}  [{badge}]"
        else:
            badge = f"🇬🇧 ✗" if article.lang == "it" else "🇮🇹 ✗"
            status = f"{article.slug}  [{badge}]"
        self.setText(status)
        if not article.has_translation:
            self.setForeground(QColor("#ff6b6b"))

class ArticlesView(QWidget):
    article_selected = pyqtSignal(object)  # Article
    translate_requested = pyqtSignal(object)  # Article

    def __init__(self, parent=None):
        super().__init__(parent)
        self._articles: list[Article] = []
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)
        self._tabs = QTabWidget()
        self._tabs.setStyleSheet("QTabBar::tab { padding: 6px 16px; }")
        self._list_it = QListWidget()
        self._list_en = QListWidget()
        self._tabs.addTab(self._list_it, "🇮🇹 Italiano")
        self._tabs.addTab(self._list_en, "🇬🇧 English")
        layout.addWidget(self._tabs)
        self._list_it.itemClicked.connect(lambda item: self.article_selected.emit(item.article))
        self._list_en.itemClicked.connect(lambda item: self.article_selected.emit(item.article))

    def set_articles(self, articles: list[Article]):
        self._articles = articles
        self._list_it.clear()
        self._list_en.clear()
        for a in articles:
            item = ArticleItem(a)
            if a.lang == "it":
                self._list_it.addItem(item)
            else:
                self._list_en.addItem(item)

class MissingTranslationView(QWidget):
    article_selected = pyqtSignal(object)  # Article
    translate_requested = pyqtSignal(object)  # Article

    def __init__(self, parent=None):
        super().__init__(parent)
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)
        header = QLabel("⚠️ Articoli senza traduzione")
        header.setStyleSheet("color: #ff6b6b; font-weight: bold; font-size: 13px; padding: 10px;")
        layout.addWidget(header)
        self._list = QListWidget()
        layout.addWidget(self._list)
        self._list.itemClicked.connect(lambda item: self.article_selected.emit(item.article))

    def set_articles(self, articles: list[Article]):
        self._list.clear()
        missing = [a for a in articles if not a.has_translation]
        for a in missing:
            lang_other = "🇬🇧" if a.lang == "it" else "🇮🇹"
            item = ArticleItem(a)
            item.setText(f"{a.slug}  [manca {lang_other}]  ({a.lang.upper()})")
            self._list.addItem(item)
```

- [ ] **Step 2: Wire into main_window.py**

In `MainWindow._build_ui`, after creating `self._stack`, replace placeholder article pages:

```python
from ui.articles_view import ArticlesView, MissingTranslationView

# replace placeholder creation for "articles" and "no_translation":
self._articles_view = ArticlesView()
self._articles_view.article_selected.connect(self._on_article_selected)
self._stack.addWidget(self._articles_view)
self._page_articles = self._stack.count() - 1

self._missing_view = MissingTranslationView()
self._missing_view.article_selected.connect(self._on_article_selected)
self._stack.addWidget(self._missing_view)
self._page_no_translation = self._stack.count() - 1
```

Add `_refresh_articles` update and `_on_article_selected` stub to `MainWindow`:

```python
def _refresh_articles(self):
    if not self.config.blog_repo:
        return
    self._articles = scan_articles(Path(self.config.blog_repo))
    self._articles_view.set_articles(self._articles)
    self._missing_view.set_articles(self._articles)
    missing = [a for a in self._articles if not a.has_translation]
    self._badge_no_trans.setText(str(len(missing)))

def _on_article_selected(self, article: Article):
    # placeholder — wired in Task 12
    pass
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "Articoli" → tab IT/EN with real articles from blog repo. Untranslated articles shown in red.

- [ ] **Step 4: Commit**

```bash
git add ui/articles_view.py ui/main_window.py
git commit -m "feat: articles view with IT/EN tabs and missing translation highlight"
```

---

## Task 12: Article detail panel

**Files:**
- Create: `ui/article_detail.py`
- Modify: `ui/main_window.py`

- [ ] **Step 1: Implement ui/article_detail.py**

```python
from __future__ import annotations
import subprocess
import re
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel,
    QPushButton, QTextBrowser, QScrollArea, QSizePolicy, QFrame,
)
from PyQt6.QtCore import pyqtSignal, Qt
from core.models import Article
from core.frontmatter import parse_frontmatter

def _strip_shortcodes(text: str) -> str:
    return re.sub(r'\{\{[^}]+\}\}', '[shortcode]', text)

class ArticleDetailView(QWidget):
    open_typora = pyqtSignal(object)       # Article
    open_frontmatter = pyqtSignal(object)  # Article
    translate = pyqtSignal(object)         # Article
    push_master = pyqtSignal(object)       # Article
    publish = pyqtSignal(object)           # Article
    delete_article = pyqtSignal(object)    # Article

    def __init__(self, parent=None):
        super().__init__(parent)
        self._article: Article | None = None
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 0, 0, 0)

        # Header
        header = QWidget()
        header.setStyleSheet("background: #0f0f1a; border-bottom: 1px solid #2a2a4e;")
        h_layout = QHBoxLayout(header)
        h_layout.setContentsMargins(12, 8, 12, 8)

        self._title_label = QLabel("")
        self._title_label.setStyleSheet("color: #fff; font-weight: bold; font-size: 13px;")
        self._path_label = QLabel("")
        self._path_label.setStyleSheet("color: #555; font-size: 10px;")
        info = QVBoxLayout()
        info.addWidget(self._title_label)
        info.addWidget(self._path_label)
        h_layout.addLayout(info, stretch=1)

        for (icon, signal_name, style) in [
            ("✏️ Typora", "open_typora", "color:#a855f7;border:1px solid #a855f7;"),
            ("🔧 Frontmatter", "open_frontmatter", "color:#888;border:1px solid #444;"),
            ("🌍 Traduci", "translate", "color:#f59e0b;border:1px solid #f59e0b;"),
            ("🧪 Push master", "push_master", "color:#60a5fa;border:1px solid #60a5fa;"),
            ("🚢 Pubblica", "publish", "color:#00ff88;border:1px solid #00ff88;"),
            ("🗑 Elimina", "delete_article", "color:#ff6b6b;border:1px solid #ff6b6b;"),
        ]:
            btn = QPushButton(icon)
            btn.setStyleSheet(f"background:#1a1a2e;{style}padding:4px 10px;border-radius:4px;font-size:10px;")
            btn.clicked.connect(lambda _, s=signal_name: getattr(self, s).emit(self._article))
            h_layout.addWidget(btn)

        layout.addWidget(header)

        # Body: split columns
        body = QHBoxLayout()
        body.setContentsMargins(0, 0, 0, 0)
        body.setSpacing(0)

        # Frontmatter column
        self._fm_widget = QWidget()
        self._fm_widget.setFixedWidth(230)
        self._fm_widget.setStyleSheet("background:#0a0a12;")
        self._fm_layout = QVBoxLayout(self._fm_widget)
        self._fm_layout.setContentsMargins(10, 10, 10, 10)
        fm_title = QLabel("Frontmatter")
        fm_title.setStyleSheet("color:#a855f7;font-size:9px;text-transform:uppercase;letter-spacing:1px;")
        self._fm_layout.addWidget(fm_title)
        self._fm_content = QVBoxLayout()
        self._fm_layout.addLayout(self._fm_content)
        self._fm_layout.addStretch()
        body.addWidget(self._fm_widget)

        divider = QFrame()
        divider.setFrameShape(QFrame.Shape.VLine)
        divider.setStyleSheet("color:#1a1a2e;")
        body.addWidget(divider)

        # Preview column
        preview_container = QWidget()
        preview_layout = QVBoxLayout(preview_container)
        preview_layout.setContentsMargins(12, 10, 12, 10)
        preview_title = QLabel("Preview markdown")
        preview_title.setStyleSheet("color:#a855f7;font-size:9px;text-transform:uppercase;letter-spacing:1px;")
        preview_layout.addWidget(preview_title)
        self._preview = QTextBrowser()
        self._preview.setStyleSheet("background:#0d0d1a;color:#ccc;border:none;")
        self._preview.setOpenExternalLinks(True)
        preview_layout.addWidget(self._preview)
        body.addWidget(preview_container, stretch=1)

        layout.addLayout(body, stretch=1)

    def set_article(self, article: Article):
        self._article = article
        self._title_label.setText(article.slug)
        rel = str(article.path).replace(str(article.path.parent.parent.parent.parent), "")
        self._path_label.setText(rel)

        # Populate frontmatter
        while self._fm_content.count():
            item = self._fm_content.takeAt(0)
            if item.widget():
                item.widget().deleteLater()

        for key, val in article.frontmatter.items():
            row = QVBoxLayout()
            key_lbl = QLabel(key)
            key_lbl.setStyleSheet("color:#555;font-size:9px;")
            val_lbl = QLabel(str(val) if not isinstance(val, list) else ", ".join(str(v) for v in val))
            val_lbl.setStyleSheet("color:#e2e8f0;font-size:11px;")
            val_lbl.setWordWrap(True)
            row.addWidget(key_lbl)
            row.addWidget(val_lbl)
            container = QWidget()
            container.setLayout(row)
            self._fm_content.addWidget(container)

        # Load and render markdown preview
        try:
            _, body = parse_frontmatter(article.path)
            clean = _strip_shortcodes(body)
            self._preview.setMarkdown(clean)
        except Exception as e:
            self._preview.setPlainText(f"[Errore caricamento: {e}]")
```

- [ ] **Step 2: Wire into main_window.py**

Add to `MainWindow._build_ui` after the missing_view block:

```python
from ui.article_detail import ArticleDetailView

self._detail_view = ArticleDetailView()
self._detail_view.open_typora.connect(self._do_open_typora)
self._detail_view.open_frontmatter.connect(self._do_open_frontmatter)
self._detail_view.translate.connect(self._do_translate)
self._detail_view.push_master.connect(lambda a: self._do_git_push("master"))
self._detail_view.publish.connect(lambda a: self._do_git_push("production"))
self._detail_view.delete_article.connect(self._do_delete_article)
self._stack.addWidget(self._detail_view)
self._page_detail = self._stack.count() - 1
```

Add action stubs to `MainWindow`:

```python
def _on_article_selected(self, article: Article):
    self._detail_view.set_article(article)
    self._stack.setCurrentIndex(self._page_detail)

def _do_open_typora(self, article: Article):
    subprocess.Popen([self.config.typora_bin, str(article.path)])

def _do_open_frontmatter(self, article: Article):
    pass  # implemented in Task 13

def _do_translate(self, article: Article):
    pass  # implemented in Task 15

def _do_git_push(self, branch: str):
    pass  # implemented in Task 16

def _do_delete_article(self, article: Article):
    pass  # implemented in Task 16
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click article → detail panel shows frontmatter fields + markdown preview. "✏️ Typora" opens file in Typora.

- [ ] **Step 4: Commit**

```bash
git add ui/article_detail.py ui/main_window.py
git commit -m "feat: article detail panel with frontmatter display and markdown preview"
```

---

## Task 13: Frontmatter editor dialog

**Files:**
- Create: `ui/frontmatter_editor.py`
- Modify: `ui/main_window.py` (wire `_do_open_frontmatter`)

- [ ] **Step 1: Implement ui/frontmatter_editor.py**

```python
from __future__ import annotations
from PyQt6.QtWidgets import (
    QDialog, QVBoxLayout, QHBoxLayout, QFormLayout,
    QLabel, QLineEdit, QComboBox, QPushButton,
    QCompleter, QWidget, QScrollArea,
)
from PyQt6.QtCore import Qt
from pathlib import Path
from core.models import Article, ARTICLE_TYPES
from core.frontmatter import parse_frontmatter, write_frontmatter
from core.taxonomy import load_taxonomy

class FrontmatterEditor(QDialog):
    def __init__(self, article: Article, blog_root: Path, parent=None):
        super().__init__(parent)
        self.setWindowTitle(f"Frontmatter — {article.slug}")
        self.setMinimumWidth(520)
        self._article = article
        self._blog_root = blog_root
        self._fields: dict[str, QWidget] = {}
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)

        scroll = QScrollArea()
        scroll.setWidgetResizable(True)
        inner = QWidget()
        form = QFormLayout(inner)
        scroll.setWidget(inner)
        layout.addWidget(scroll)

        lang = self._article.lang
        tags_it = self._blog_root / "docs" / "tags-it.txt"
        tags_en = self._blog_root / "docs" / "tags-en.txt"
        taxonomy = load_taxonomy(tags_it, tags_en)
        known_tags = list(taxonomy.it_to_en.keys()) if lang == "it" else list(taxonomy.it_to_en.values())

        for key, val in self._article.frontmatter.items():
            if key == "type":
                widget = QComboBox()
                widget.addItems(ARTICLE_TYPES)
                if str(val) in ARTICLE_TYPES:
                    widget.setCurrentText(str(val))
                self._fields[key] = widget
            elif key == "tags":
                widget = QLineEdit(", ".join(str(v) for v in val) if isinstance(val, list) else str(val))
                completer = QCompleter(known_tags)
                completer.setCaseSensitivity(Qt.CaseSensitivity.CaseInsensitive)
                widget.setCompleter(completer)
                self._fields[key] = widget
            else:
                widget = QLineEdit(str(val))
                self._fields[key] = widget
            form.addRow(QLabel(key), widget)

        btns = QHBoxLayout()
        save_btn = QPushButton("Salva")
        save_btn.clicked.connect(self._save)
        cancel_btn = QPushButton("Annulla")
        cancel_btn.clicked.connect(self.reject)
        btns.addStretch()
        btns.addWidget(cancel_btn)
        btns.addWidget(save_btn)
        layout.addLayout(btns)

    def _save(self):
        updated = dict(self._article.frontmatter)
        for key, widget in self._fields.items():
            if isinstance(widget, QComboBox):
                updated[key] = widget.currentText()
            elif isinstance(widget, QLineEdit):
                val = widget.text().strip()
                if key == "tags":
                    updated[key] = [t.strip() for t in val.split(",") if t.strip()]
                else:
                    updated[key] = val
        try:
            _, body = parse_frontmatter(self._article.path)
            write_frontmatter(self._article.path, updated, body)
            self._article.frontmatter.update(updated)
            self.accept()
        except Exception as e:
            from PyQt6.QtWidgets import QMessageBox
            QMessageBox.critical(self, "Errore", str(e))
```

- [ ] **Step 2: Wire into main_window.py**

Replace `_do_open_frontmatter` stub:

```python
def _do_open_frontmatter(self, article: Article):
    from ui.frontmatter_editor import FrontmatterEditor
    dlg = FrontmatterEditor(article, Path(self.config.blog_repo), self)
    if dlg.exec():
        self._detail_view.set_article(article)
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "🔧 Frontmatter" → dialog with all fields. `type` field is dropdown with 5 options. Save writes to disk. Reopen article → updated values visible.

- [ ] **Step 4: Commit**

```bash
git add ui/frontmatter_editor.py ui/main_window.py
git commit -m "feat: frontmatter editor dialog with type dropdown and tag autocomplete"
```

---

## Task 14: New article stub creation

**Files:**
- Create: `ui/new_article_dialog.py`
- Modify: `ui/main_window.py`

- [ ] **Step 1: Implement ui/new_article_dialog.py**

```python
from __future__ import annotations
from datetime import date
from pathlib import Path
from PyQt6.QtWidgets import (
    QDialog, QVBoxLayout, QFormLayout, QHBoxLayout,
    QLineEdit, QComboBox, QLabel, QPushButton, QMessageBox,
)
from core.models import ARTICLE_TYPES

STUB_TEMPLATE = """\
+++
title = "{title}"
date = {date}
type = "{type}"
draft = true
excerpt = ""
tags = []
categories = []
+++

TODO: scrivi il contenuto qui.
"""

class NewArticleDialog(QDialog):
    def __init__(self, blog_root: Path, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Nuovo articolo")
        self.setMinimumWidth(400)
        self._blog_root = blog_root
        self._created_path: Path | None = None
        self._build_ui()

    @property
    def created_path(self) -> Path | None:
        return self._created_path

    def _build_ui(self):
        layout = QVBoxLayout(self)
        form = QFormLayout()

        self._slug = QLineEdit()
        self._slug.setPlaceholderText("mio-articolo-2026")
        form.addRow("Slug:", self._slug)

        self._title = QLineEdit()
        self._title.setPlaceholderText("Il mio articolo")
        form.addRow("Titolo:", self._title)

        self._lang = QComboBox()
        self._lang.addItems(["it", "en"])
        form.addRow("Lingua:", self._lang)

        self._type = QComboBox()
        self._type.addItems(ARTICLE_TYPES)
        form.addRow("Tipo:", self._type)

        layout.addLayout(form)

        btns = QHBoxLayout()
        create_btn = QPushButton("Crea")
        create_btn.clicked.connect(self._create)
        cancel_btn = QPushButton("Annulla")
        cancel_btn.clicked.connect(self.reject)
        btns.addStretch()
        btns.addWidget(cancel_btn)
        btns.addWidget(create_btn)
        layout.addLayout(btns)

    def _create(self):
        slug = self._slug.text().strip()
        title = self._title.text().strip()
        lang = self._lang.currentText()
        article_type = self._type.currentText()

        if not slug or not title:
            QMessageBox.warning(self, "Errore", "Slug e titolo sono obbligatori.")
            return

        target = self._blog_root / "content" / lang / "articles" / slug
        if target.exists():
            QMessageBox.warning(self, "Errore", f"Esiste già: {target}")
            return

        target.mkdir(parents=True)
        index_md = target / "index.md"
        index_md.write_text(STUB_TEMPLATE.format(
            title=title,
            date=date.today().isoformat(),
            type=article_type,
        ), encoding="utf-8")

        self._created_path = index_md
        self.accept()
```

- [ ] **Step 2: Wire into main_window.py**

Replace the placeholder for `_page_new_article`. In `_build_ui`, instead of adding a label placeholder, connect the sidebar button to open the dialog:

```python
# In _build_sidebar, change the "Nuovo articolo" button click handler:
# Find the btn("➕ Nuovo articolo", ...) call and replace with:
b_new = SidebarButton("➕ Nuovo articolo")
b_new.clicked.connect(self._do_new_article)
layout.addWidget(b_new)
self._btn_group.append(b_new)
```

Add to `MainWindow`:

```python
def _do_new_article(self):
    from ui.new_article_dialog import NewArticleDialog
    import subprocess
    dlg = NewArticleDialog(Path(self.config.blog_repo), self)
    if dlg.exec() and dlg.created_path:
        self._refresh_articles()
        subprocess.Popen([self.config.typora_bin, str(dlg.created_path)])
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "➕ Nuovo articolo" → dialog → fill slug/title/type → create → file appears in blog repo → Typora opens it.

- [ ] **Step 4: Commit**

```bash
git add ui/new_article_dialog.py ui/main_window.py
git commit -m "feat: new article stub creation with Typora open"
```

---

## Task 15: Translation view

**Files:**
- Create: `ui/translation_view.py`
- Modify: `ui/main_window.py` (wire `_do_translate`)

- [ ] **Step 1: Implement ui/translation_view.py**

```python
from __future__ import annotations
import subprocess
from pathlib import Path
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel,
    QPushButton, QPlainTextEdit, QTextBrowser,
)
from PyQt6.QtCore import pyqtSignal
from core.models import Article
from core.frontmatter import parse_frontmatter
from workers.translation_worker import TranslationWorker
import re

def _strip_shortcodes(text: str) -> str:
    return re.sub(r'\{\{[^}]+\}\}', '[shortcode]', text)

class TranslationView(QWidget):
    push_master = pyqtSignal()
    publish = pyqtSignal()

    def __init__(self, transart_script: str, typora_bin: str, parent=None):
        super().__init__(parent)
        self._transart_script = transart_script
        self._typora_bin = typora_bin
        self._article: Article | None = None
        self._worker: TranslationWorker | None = None
        self._output_path: str = ""
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)

        # Header
        self._header = QLabel("")
        self._header.setStyleSheet("color:#fff;font-weight:bold;font-size:13px;padding:10px;")
        layout.addWidget(self._header)

        # Log
        log_label = QLabel("Output traduzione:")
        log_label.setStyleSheet("color:#a855f7;font-size:9px;text-transform:uppercase;letter-spacing:1px;padding:0 10px;")
        layout.addWidget(log_label)
        self._log = QPlainTextEdit()
        self._log.setReadOnly(True)
        self._log.setStyleSheet("background:#0a0a12;color:#00ff88;font-family:monospace;font-size:11px;")
        self._log.setMaximumHeight(180)
        layout.addWidget(self._log)

        # Preview
        preview_label = QLabel("Preview traduzione:")
        preview_label.setStyleSheet("color:#a855f7;font-size:9px;text-transform:uppercase;letter-spacing:1px;padding:0 10px;")
        layout.addWidget(preview_label)
        self._preview = QTextBrowser()
        self._preview.setStyleSheet("background:#0d0d1a;color:#ccc;border:none;")
        layout.addWidget(self._preview, stretch=1)

        # Action buttons (hidden until translation done)
        self._action_bar = QWidget()
        btns = QHBoxLayout(self._action_bar)
        btns.setContentsMargins(10, 6, 10, 6)

        self._btn_typora = QPushButton("✏️ Apri in Typora")
        self._btn_typora.clicked.connect(self._open_typora)
        self._btn_retry = QPushButton("🔄 Rigenera")
        self._btn_retry.clicked.connect(self._retry)
        self._btn_master = QPushButton("🧪 Push master")
        self._btn_master.clicked.connect(self.push_master.emit)
        self._btn_publish = QPushButton("🚢 Pubblica")
        self._btn_publish.clicked.connect(self.publish.emit)

        for btn in (self._btn_typora, self._btn_retry, self._btn_master, self._btn_publish):
            btns.addWidget(btn)
        btns.addStretch()

        self._action_bar.setVisible(False)
        layout.addWidget(self._action_bar)

    def start_translation(self, article: Article):
        self._article = article
        self._log.clear()
        self._preview.clear()
        self._action_bar.setVisible(False)

        direction = "it-en" if article.lang == "it" else "en-it"
        self._header.setText(f"Traduzione: {article.slug} ({article.lang.upper()} → {('EN' if article.lang == 'it' else 'IT')})")

        self._worker = TranslationWorker(
            Path(self._transart_script),
            article.path,
            direction,
            parent=self,
        )
        self._worker.log_line.connect(self._log.appendPlainText)
        self._worker.finished.connect(self._on_finished)
        self._worker.error.connect(lambda e: self._log.appendPlainText(f"[ERRORE] {e}"))
        self._worker.start()

    def _on_finished(self, success: bool, output_path: str):
        self._output_path = output_path
        if success and Path(output_path).exists():
            try:
                _, body = parse_frontmatter(Path(output_path))
                self._preview.setMarkdown(_strip_shortcodes(body))
            except Exception as e:
                self._preview.setPlainText(f"[Errore preview: {e}]")
        self._action_bar.setVisible(True)

    def _open_typora(self):
        if self._output_path:
            subprocess.Popen([self._typora_bin, self._output_path])

    def _retry(self):
        if self._article:
            self.start_translation(self._article)
```

- [ ] **Step 2: Wire into main_window.py**

Add to `MainWindow._build_ui`:

```python
from ui.translation_view import TranslationView

self._translation_view = TranslationView(
    self.config.transart_script,
    self.config.typora_bin,
    parent=self,
)
self._translation_view.push_master.connect(lambda: self._do_git_push("master"))
self._translation_view.publish.connect(lambda: self._do_git_push("production"))
self._stack.addWidget(self._translation_view)
self._page_translation = self._stack.count() - 1
```

Replace `_do_translate` stub:

```python
def _do_translate(self, article: Article):
    self._translation_view.start_translation(article)
    self._stack.setCurrentIndex(self._page_translation)
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "🌍 Traduci" on an article → translation view appears with streaming log. When done: preview shows translated markdown + action buttons appear.

- [ ] **Step 4: Commit**

```bash
git add ui/translation_view.py ui/main_window.py
git commit -m "feat: translation view with QProcess streaming and post-translation preview"
```

---

## Task 16: Git view

**Files:**
- Create: `ui/git_view.py`
- Modify: `ui/main_window.py`

- [ ] **Step 1: Implement ui/git_view.py**

```python
from __future__ import annotations
from pathlib import Path
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QLabel,
    QPushButton, QPlainTextEdit, QTabWidget, QListWidget, QListWidgetItem,
)
from PyQt6.QtCore import pyqtSignal
from workers.git_worker import GitWorker
import subprocess

class GitView(QWidget):
    refresh_needed = pyqtSignal()

    def __init__(self, repo_path: Path, parent=None):
        super().__init__(parent)
        self._repo_path = repo_path
        self._worker: GitWorker | None = None
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)

        # Status bar
        status_row = QHBoxLayout()
        self._branch_label = QLabel("Branch: —")
        self._branch_label.setStyleSheet("color:#a855f7;font-weight:bold;")
        status_row.addWidget(self._branch_label)
        status_row.addStretch()
        refresh_btn = QPushButton("🔄 Refresh")
        refresh_btn.clicked.connect(self.load_status)
        status_row.addWidget(refresh_btn)
        layout.addLayout(status_row)

        # Tabs
        tabs = QTabWidget()

        # Status tab
        status_tab = QWidget()
        st_layout = QVBoxLayout(status_tab)
        self._status_log = QPlainTextEdit()
        self._status_log.setReadOnly(True)
        self._status_log.setStyleSheet("background:#0a0a12;color:#ccc;font-family:monospace;font-size:11px;")
        st_layout.addWidget(self._status_log)

        btns = QHBoxLayout()
        for label, slot in [
            ("⬇ Pull", self._do_pull),
            ("🧪 Push master", self._do_push_master),
            ("🚢 Push production", self._do_push_production),
        ]:
            btn = QPushButton(label)
            btn.clicked.connect(slot)
            btns.addWidget(btn)
        btns.addStretch()
        st_layout.addLayout(btns)
        tabs.addTab(status_tab, "Stato repo")

        # Deleted articles tab
        deleted_tab = QWidget()
        del_layout = QVBoxLayout(deleted_tab)
        del_layout.addWidget(QLabel("Articoli eliminati (da git log):"))
        self._deleted_list = QListWidget()
        del_layout.addWidget(self._deleted_list)
        restore_btn = QPushButton("♻️ Ripristina selezionato")
        restore_btn.clicked.connect(self._do_restore)
        del_layout.addWidget(restore_btn)
        tabs.addTab(deleted_tab, "Articoli eliminati")

        layout.addWidget(tabs)

        # Output log
        self._output = QPlainTextEdit()
        self._output.setReadOnly(True)
        self._output.setStyleSheet("background:#0a0a12;color:#00ff88;font-family:monospace;font-size:11px;")
        self._output.setMaximumHeight(150)
        layout.addWidget(self._output)

    def load_status(self):
        try:
            branch = subprocess.check_output(
                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
                cwd=self._repo_path, text=True,
            ).strip()
            self._branch_label.setText(f"Branch: {branch}")

            status = subprocess.check_output(
                ["git", "status", "--short"],
                cwd=self._repo_path, text=True,
            )
            log = subprocess.check_output(
                ["git", "log", "--oneline", "-5"],
                cwd=self._repo_path, text=True,
            )
            self._status_log.setPlainText(f"--- git status ---\n{status}\n--- ultimi commit ---\n{log}")

            # Load deleted articles
            self._deleted_list.clear()
            deleted = subprocess.check_output(
                ["git", "log", "--diff-filter=D", "--name-only", "--pretty=format:%H %s", "--", "content/"],
                cwd=self._repo_path, text=True,
            )
            current_hash = None
            for line in deleted.splitlines():
                if line.strip() == "":
                    continue
                if line.startswith("content/"):
                    if current_hash:
                        item = QListWidgetItem(f"{line}  [{current_hash[:8]}]")
                        item.setData(256, (current_hash, line))
                        self._deleted_list.addItem(item)
                else:
                    parts = line.split(" ", 1)
                    current_hash = parts[0] if parts else None
        except Exception as e:
            self._output.appendPlainText(f"[Errore] {e}")

    def _run_worker(self, worker: GitWorker):
        self._worker = worker
        worker.output.connect(self._output.appendPlainText)
        worker.error.connect(lambda e: self._output.appendPlainText(f"[ERRORE] {e}"))
        worker.finished.connect(lambda ok: self.refresh_needed.emit() if ok else None)
        worker.start()

    def _do_pull(self):
        self._run_worker(GitWorker.pull(self._repo_path, self))

    def _do_push_master(self):
        self._run_worker(GitWorker.push_master(self._repo_path, self))

    def _do_push_production(self):
        self._run_worker(GitWorker.push_production(self._repo_path, self))

    def _do_restore(self):
        item = self._deleted_list.currentItem()
        if not item:
            return
        commit_hash, rel_path = item.data(256)
        worker = GitWorker.restore_article(self._repo_path, commit_hash, rel_path, self)
        self._run_worker(worker)
        self.load_status()
```

- [ ] **Step 2: Wire into main_window.py**

Replace git placeholder in `_build_ui`:

```python
from ui.git_view import GitView

self._git_view = GitView(Path(self.config.blog_repo), parent=self)
self._git_view.refresh_needed.connect(self._refresh_articles)
self._stack.addWidget(self._git_view)
self._page_git = self._stack.count() - 1
```

Replace `_do_git_push` stub:

```python
def _do_git_push(self, branch: str):
    from workers.git_worker import GitWorker
    repo = Path(self.config.blog_repo)
    if branch == "master":
        worker = GitWorker.push_master(repo, self)
    else:
        worker = GitWorker.push_production(repo, self)
    worker.error.connect(lambda e: self.statusBar().showMessage(f"Git error: {e}", 5000))
    worker.finished.connect(lambda ok: self.statusBar().showMessage("Push completato." if ok else "Push fallito.", 4000))
    worker.start()

def _do_delete_article(self, article: Article):
    from PyQt6.QtWidgets import QMessageBox
    from workers.git_worker import GitWorker
    reply = QMessageBox.question(
        self, "Elimina articolo",
        f"Eliminare '{article.slug}' ({article.lang})? L'operazione sarà tracciata in git.",
    )
    if reply == QMessageBox.StandardButton.Yes:
        rel = str(article.path.parent.relative_to(Path(self.config.blog_repo)))
        worker = GitWorker.remove_article(
            Path(self.config.blog_repo), rel, article.slug, article.lang, self
        )
        worker.error.connect(lambda e: self.statusBar().showMessage(f"Errore: {e}", 5000))
        worker.finished.connect(lambda ok: self._refresh_articles() if ok else None)
        worker.start()
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "🔧 Git ops" → branch shown, status + last 5 commits visible. Pull/push buttons run git ops with output in log.

- [ ] **Step 4: Commit**

```bash
git add ui/git_view.py ui/main_window.py
git commit -m "feat: git view with status, pull/push, and deleted article restore"
```

---

## Task 17: Hugo server panel

**Files:**
- Create: `ui/hugo_panel.py`
- Modify: `ui/main_window.py`

- [ ] **Step 1: Implement ui/hugo_panel.py**

```python
from __future__ import annotations
from pathlib import Path
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QPushButton, QPlainTextEdit,
)
from PyQt6.QtCore import pyqtSignal, QUrl
from PyQt6.QtGui import QDesktopServices
from workers.hugo_worker import HugoWorker

class HugoPanel(QWidget):
    def __init__(self, repo_path: Path, parent=None):
        super().__init__(parent)
        self._worker = HugoWorker(repo_path, parent=self)
        self._worker.log_line.connect(self._on_log)
        self._worker.started.connect(self._on_started)
        self._worker.stopped.connect(self._on_stopped)
        self._worker.error.connect(lambda e: self._log.appendPlainText(f"[ERRORE] {e}"))
        self._build_ui()

    def _build_ui(self):
        layout = QVBoxLayout(self)

        top = QHBoxLayout()
        self._status_label = QLabel("🔴 Hugo server: fermo")
        self._status_label.setStyleSheet("color:#ff6b6b;font-weight:bold;")
        top.addWidget(self._status_label)
        top.addStretch()

        self._start_btn = QPushButton("▶ Avvia")
        self._start_btn.clicked.connect(self._worker.start)
        self._stop_btn = QPushButton("⏹ Ferma")
        self._stop_btn.clicked.connect(self._worker.stop)
        self._stop_btn.setEnabled(False)
        top.addWidget(self._start_btn)
        top.addWidget(self._stop_btn)

        self._url_btn = QPushButton("🌐 http://localhost:1313")
        self._url_btn.setFlat(True)
        self._url_btn.setStyleSheet("color:#60a5fa;text-decoration:underline;")
        self._url_btn.clicked.connect(lambda: QDesktopServices.openUrl(QUrl("http://localhost:1313")))
        self._url_btn.setVisible(False)
        top.addWidget(self._url_btn)

        layout.addLayout(top)

        self._log = QPlainTextEdit()
        self._log.setReadOnly(True)
        self._log.setStyleSheet("background:#0a0a12;color:#00ff88;font-family:monospace;font-size:11px;")
        layout.addWidget(self._log)

    def _on_log(self, line: str):
        self._log.appendPlainText(line)

    def _on_started(self):
        self._status_label.setText("🟢 Hugo server: in esecuzione")
        self._status_label.setStyleSheet("color:#00ff88;font-weight:bold;")
        self._start_btn.setEnabled(False)
        self._stop_btn.setEnabled(True)
        self._url_btn.setVisible(True)

    def _on_stopped(self):
        self._status_label.setText("🔴 Hugo server: fermo")
        self._status_label.setStyleSheet("color:#ff6b6b;font-weight:bold;")
        self._start_btn.setEnabled(True)
        self._stop_btn.setEnabled(False)
        self._url_btn.setVisible(False)

    def closeEvent(self, event):
        self._worker.stop()
        super().closeEvent(event)
```

- [ ] **Step 2: Wire into main_window.py**

Replace hugo placeholder in `_build_ui`:

```python
from ui.hugo_panel import HugoPanel

self._hugo_panel = HugoPanel(Path(self.config.blog_repo), parent=self)
self._stack.addWidget(self._hugo_panel)
self._page_hugo = self._stack.count() - 1
```

Also stop hugo server on app close — override `closeEvent` in `MainWindow`:

```python
def closeEvent(self, event):
    self._hugo_panel._worker.stop()
    super().closeEvent(event)
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "🚀 Hugo server" → panel with start button. Click "▶ Avvia" → log streams hugo output → link `http://localhost:1313` appears clickable. "⏹ Ferma" kills server.

- [ ] **Step 4: Commit**

```bash
git add ui/hugo_panel.py ui/main_window.py
git commit -m "feat: hugo server panel with start/stop and log streaming"
```

---

## Task 18: Taxonomy view

**Files:**
- Create: `ui/taxonomy_view.py`
- Modify: `ui/main_window.py`

- [ ] **Step 1: Implement ui/taxonomy_view.py**

```python
from __future__ import annotations
from pathlib import Path
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout, QTabWidget,
    QTableWidget, QTableWidgetItem, QPushButton,
    QLabel, QDialog, QFormLayout, QLineEdit, QMessageBox,
)
from PyQt6.QtCore import Qt
from PyQt6.QtGui import QColor
from core.taxonomy import TaxonomyModel, load_taxonomy, save_taxonomy

class AddTermDialog(QDialog):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Aggiungi termine")
        layout = QVBoxLayout(self)
        form = QFormLayout()
        self._it = QLineEdit()
        self._en = QLineEdit()
        form.addRow("IT:", self._it)
        form.addRow("EN:", self._en)
        layout.addLayout(form)
        btns = QHBoxLayout()
        ok = QPushButton("Aggiungi")
        ok.clicked.connect(self.accept)
        cancel = QPushButton("Annulla")
        cancel.clicked.connect(self.reject)
        btns.addStretch()
        btns.addWidget(cancel)
        btns.addWidget(ok)
        layout.addLayout(btns)

    @property
    def it_term(self) -> str:
        return self._it.text().strip()

    @property
    def en_term(self) -> str:
        return self._en.text().strip()

class TaxonomyView(QWidget):
    def __init__(self, blog_root: Path, parent=None):
        super().__init__(parent)
        self._blog_root = blog_root
        self._tags_it = blog_root / "docs" / "tags-it.txt"
        self._tags_en = blog_root / "docs" / "tags-en.txt"
        self._cats_it = blog_root / "docs" / "categories.txt"
        self._model: TaxonomyModel | None = None
        self._build_ui()
        self.load()

    def _build_ui(self):
        layout = QVBoxLayout(self)

        tabs = QTabWidget()

        # Tags tab
        tags_tab = QWidget()
        tl = QVBoxLayout(tags_tab)
        self._tags_table = QTableWidget(0, 2)
        self._tags_table.setHorizontalHeaderLabels(["🇮🇹 Italiano", "🇬🇧 English"])
        self._tags_table.horizontalHeader().setStretchLastSection(True)
        tl.addWidget(self._tags_table)
        tag_btns = QHBoxLayout()
        add_tag_btn = QPushButton("➕ Aggiungi termine")
        add_tag_btn.clicked.connect(self._add_term)
        save_tags_btn = QPushButton("💾 Salva")
        save_tags_btn.clicked.connect(self._save)
        tag_btns.addWidget(add_tag_btn)
        tag_btns.addStretch()
        tag_btns.addWidget(save_tags_btn)
        tl.addLayout(tag_btns)
        tabs.addTab(tags_tab, "🏷 Tags")

        layout.addWidget(tabs)

        self._status = QLabel("")
        self._status.setStyleSheet("color:#888;font-size:10px;padding:4px;")
        layout.addWidget(self._status)

    def load(self):
        if not self._tags_it.exists():
            self._status.setText("tags-it.txt non trovato.")
            return
        self._model = load_taxonomy(self._tags_it, self._tags_en)
        self._populate_table()

    def _populate_table(self):
        if not self._model:
            return
        self._tags_table.setRowCount(0)
        for it_term, en_term in sorted(self._model.it_to_en.items()):
            row = self._tags_table.rowCount()
            self._tags_table.insertRow(row)
            self._tags_table.setItem(row, 0, QTableWidgetItem(it_term))
            self._tags_table.setItem(row, 1, QTableWidgetItem(en_term))

        for orphan in self._model.orphans_it:
            row = self._tags_table.rowCount()
            self._tags_table.insertRow(row)
            it_item = QTableWidgetItem(orphan)
            it_item.setForeground(QColor("#ff6b6b"))
            en_item = QTableWidgetItem("⚠ mancante")
            en_item.setForeground(QColor("#ff6b6b"))
            self._tags_table.setItem(row, 0, it_item)
            self._tags_table.setItem(row, 1, en_item)

        self._status.setText(
            f"{len(self._model.it_to_en)} coppie · {len(self._model.orphans_it)} IT orfani · {len(self._model.orphans_en)} EN orfani"
        )

    def _add_term(self):
        dlg = AddTermDialog(self)
        if dlg.exec() and dlg.it_term and dlg.en_term:
            if self._model:
                self._model.it_to_en[dlg.it_term] = dlg.en_term
                self._populate_table()

    def _save(self):
        if not self._model:
            return
        updated: dict[str, str] = {}
        for row in range(self._tags_table.rowCount()):
            it_item = self._tags_table.item(row, 0)
            en_item = self._tags_table.item(row, 1)
            if it_item and en_item:
                it_val = it_item.text().strip()
                en_val = en_item.text().strip()
                if it_val and en_val and en_val != "⚠ mancante":
                    updated[it_val] = en_val
        self._model.it_to_en = updated
        save_taxonomy(self._model, self._tags_it, self._tags_en)
        self._status.setText("Salvato.")
```

- [ ] **Step 2: Wire into main_window.py**

Replace taxonomy placeholder in `_build_ui`:

```python
from ui.taxonomy_view import TaxonomyView

self._taxonomy_view = TaxonomyView(Path(self.config.blog_repo), parent=self)
self._stack.addWidget(self._taxonomy_view)
self._page_taxonomy = self._stack.count() - 1
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "🏷 Tassonomia" → table with IT|EN tag pairs. Orphans shown in red. Add term dialog works. Save updates `docs/tags-it.txt` and `docs/tags-en.txt`.

- [ ] **Step 4: Commit**

```bash
git add ui/taxonomy_view.py ui/main_window.py
git commit -m "feat: taxonomy view with IT/EN pair table and orphan detection"
```

---

## Task 19: Media view

**Files:**
- Create: `ui/media_view.py`
- Modify: `ui/main_window.py`

- [ ] **Step 1: Implement ui/media_view.py**

```python
from __future__ import annotations
import shutil
from datetime import date
from pathlib import Path
from PyQt6.QtWidgets import (
    QWidget, QVBoxLayout, QHBoxLayout,
    QLabel, QPushButton, QListWidget, QListWidgetItem, QFileDialog,
)
from PyQt6.QtCore import Qt, pyqtSignal
from PyQt6.QtGui import QDragEnterEvent, QDropEvent

class MediaView(QWidget):
    def __init__(self, blog_root: Path, parent=None):
        super().__init__(parent)
        self._blog_root = blog_root
        self.setAcceptDrops(True)
        self._build_ui()
        self._refresh_list()

    def _target_dir(self) -> Path:
        today = date.today()
        return self._blog_root / "static" / "uppies" / str(today.year) / f"{today.month:02d}"

    def _build_ui(self):
        layout = QVBoxLayout(self)

        header = QLabel("🖼 Media — static/uppies/YYYY/MM/")
        header.setStyleSheet("color:#fff;font-weight:bold;font-size:13px;padding:10px;")
        layout.addWidget(header)

        drop_zone = QLabel("Trascina file qui, oppure usa il pulsante sotto.")
        drop_zone.setAlignment(Qt.AlignmentFlag.AlignCenter)
        drop_zone.setStyleSheet("border:2px dashed #2a2a4e;color:#555;padding:20px;border-radius:6px;margin:10px;")
        drop_zone.setMinimumHeight(80)
        layout.addWidget(drop_zone)

        btns = QHBoxLayout()
        add_btn = QPushButton("📂 Aggiungi file...")
        add_btn.clicked.connect(self._pick_files)
        btns.addWidget(add_btn)
        btns.addStretch()
        self._path_label = QLabel("")
        self._path_label.setStyleSheet("color:#a855f7;font-size:10px;")
        btns.addWidget(self._path_label)
        layout.addLayout(btns)

        self._list = QListWidget()
        layout.addWidget(self._list, stretch=1)

        self._status = QLabel("")
        self._status.setStyleSheet("color:#888;font-size:10px;padding:4px;")
        layout.addWidget(self._status)

    def _copy_files(self, paths: list[str]):
        target = self._target_dir()
        target.mkdir(parents=True, exist_ok=True)
        last_web_path = ""
        for src in paths:
            dest = target / Path(src).name
            shutil.copy2(src, dest)
            today = date.today()
            last_web_path = f"/uppies/{today.year}/{today.month:02d}/{Path(src).name}"

        if last_web_path:
            from PyQt6.QtWidgets import QApplication
            QApplication.clipboard().setText(last_web_path)
            self._status.setText(f"Copiato in clipboard: {last_web_path}")

        self._refresh_list()

    def _pick_files(self):
        files, _ = QFileDialog.getOpenFileNames(self, "Seleziona file media")
        if files:
            self._copy_files(files)

    def _refresh_list(self):
        self._list.clear()
        target = self._target_dir()
        today = date.today()
        self._path_label.setText(f"Cartella: static/uppies/{today.year}/{today.month:02d}/")
        if not target.exists():
            return
        for f in sorted(target.iterdir()):
            if f.is_file():
                self._list.addItem(QListWidgetItem(f.name))

    def dragEnterEvent(self, event: QDragEnterEvent):
        if event.mimeData().hasUrls():
            event.acceptProposedAction()

    def dropEvent(self, event: QDropEvent):
        paths = [u.toLocalFile() for u in event.mimeData().urls() if u.isLocalFile()]
        if paths:
            self._copy_files(paths)
```

- [ ] **Step 2: Wire into main_window.py**

Replace media placeholder in `_build_ui`:

```python
from ui.media_view import MediaView

self._media_view = MediaView(Path(self.config.blog_repo), parent=self)
self._stack.addWidget(self._media_view)
self._page_media = self._stack.count() - 1
```

- [ ] **Step 3: Launch and verify**

```bash
python main.py
```

Expected: click "🖼 Media" → drag a file onto the window → file copied to `static/uppies/YYYY/MM/` → web path copied to clipboard → file appears in list.

- [ ] **Step 4: Commit**

```bash
git add ui/media_view.py ui/main_window.py
git commit -m "feat: media view with drag-drop upload and clipboard path copy"
```

---

## Task 20: Final wiring + polish

**Files:**
- Modify: `ui/main_window.py`
- Modify: `main.py`

- [ ] **Step 1: Add statusbar to MainWindow**

In `MainWindow.__init__`, after `self._build_ui()`:

```python
self.statusBar().showMessage("my-publisher pronto.")
self.statusBar().setStyleSheet("background:#0f0f1a;color:#555;font-size:10px;")
```

- [ ] **Step 2: Default to articles view on startup**

At end of `MainWindow.__init__`, after `_refresh_articles()`:

```python
# Select articles button and show articles view by default
if self._btn_group:
    self._btn_group[0].setChecked(True)
    self._stack.setCurrentIndex(self._page_articles)
```

- [ ] **Step 3: Add .gitignore**

```bash
cat > /home/danix/Programming/GIT/my-publisher/.gitignore << 'EOF'
__pycache__/
*.pyc
.superpowers/
EOF
```

- [ ] **Step 4: Run all tests**

```bash
pytest tests/ -v
```

Expected: all tests pass.

- [ ] **Step 5: End-to-end verification**

Run through the full checklist from the spec:

1. `python main.py` → sidebar with articles from real blog repo
2. Click article → frontmatter + markdown preview visible
3. Click "🔧 Frontmatter" → edit `type` via dropdown → save → reopen → value persisted
4. Open Typora → edit file → return to app → `QFileSystemWatcher` triggers refresh
5. Click "🌍 Traduci" → log streams → preview appears after completion
6. Click "🔧 Git ops" → branch and status visible → pull works
7. Click "🖼 Media" → drop a file → appears in list → path in clipboard
8. Delete article → confirm dialog → scompare dalla lista → ripristino da Git ops funziona

- [ ] **Step 6: Final commit**

```bash
git add .
git commit -m "feat: complete my-publisher app — all views wired and working"
```