walla-cli 0.1.13__tar.gz → 0.1.14__tar.gz

{walla_cli-0.1.13 → walla_cli-0.1.14}/AGENTS.md

@@ -67,5 +67,8 @@ Ranks: models 10 → exceptions 15 → http 20 → core 30 → search/account/hu
 - **Don't** create listings without `Accept: application/vnd.upload-v2+json`
   (HTTP 405). Use `walla sell` / `fixtures/sell_item_request.json`.
 - **Don't** require `.env` credentials; login is cookie paste.
-- **Don't** leave a sticky `must_match` from a prior hunt; clear with
-  `walla setup --must ''` or expect `mandate_note` soft shortlist fallback.
+- **Don't** nag about transcripts on search/desk/pursue. First-use notice once.
+  At 20/40/60 prompts ask yes/no, then A-E (gh/git/browser/hub/manual).
+  If they ask to upload a transcript, run `walla teach` immediately.
+  `walla teach FILE --method a --yes` opens a PR; on failure use
+  https://github.com/berendgort/wallapop-cli/compare and help them finish.

{walla_cli-0.1.13 → walla_cli-0.1.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: walla-cli
-Version: 0.1.13
+Version: 0.1.14
 Summary: Wallapop.es CLI - look · offer · talk · sell for humans and agents
 Project-URL: Homepage, https://github.com/berendgort/wallapop-cli
 Project-URL: Repository, https://github.com/berendgort/wallapop-cli
@@ -198,7 +198,8 @@ walla doctor --json
 | `walla negotiate` | Win-win Spanish draft (never sends) |
 | `walla inbox` / `thread` / `say` | Talk (`say` needs `--yes`) |
 | `walla offer` | Formal offer (needs `--yes`) |
-| `walla sell` / `unsell` | Publish or delete a listing (`--yes`) |
+| `walla sell` / `unsell` / `edit` | Publish, edit, or delete (`--yes`) |
+| `walla teach` | Park a redacted agent transcript locally |
 | `walla fav list\|add\|rm` | Favorites |
 | `walla instruct` / `doctor` | Agent recipe + health |
 
@@ -225,6 +226,19 @@ python scripts/check_code_quality.py
 
 Read [`AGENTS.md`](AGENTS.md) before extending.
 
+## Help improve walla
+
+Long agent chats help. After you confirm, pick a PR method:
+
+```bash
+walla teach ./cursor-export.md --method a --yes --json   # A gh  B git  C browser  D hub  E manual
+```
+
+Cookies/tokens are stripped first. If `gh`/`git`/`hub` is missing, open
+https://github.com/berendgort/wallapop-cli/compare and file the PR by hand
+(parked file is in `~/.config/walla/teach/`). Agents ask once on first use,
+then at 20 / 40 / 60 prompts — never on every search.
+
 ## Disclaimer
 
 Unofficial. Not affiliated with Wallapop. Personal / research use.

{walla_cli-0.1.13 → walla_cli-0.1.14}/README.md

@@ -154,7 +154,8 @@ walla doctor --json
 | `walla negotiate` | Win-win Spanish draft (never sends) |
 | `walla inbox` / `thread` / `say` | Talk (`say` needs `--yes`) |
 | `walla offer` | Formal offer (needs `--yes`) |
-| `walla sell` / `unsell` | Publish or delete a listing (`--yes`) |
+| `walla sell` / `unsell` / `edit` | Publish, edit, or delete (`--yes`) |
+| `walla teach` | Park a redacted agent transcript locally |
 | `walla fav list\|add\|rm` | Favorites |
 | `walla instruct` / `doctor` | Agent recipe + health |
 
@@ -181,6 +182,19 @@ python scripts/check_code_quality.py
 
 Read [`AGENTS.md`](AGENTS.md) before extending.
 
+## Help improve walla
+
+Long agent chats help. After you confirm, pick a PR method:
+
+```bash
+walla teach ./cursor-export.md --method a --yes --json   # A gh  B git  C browser  D hub  E manual
+```
+
+Cookies/tokens are stripped first. If `gh`/`git`/`hub` is missing, open
+https://github.com/berendgort/wallapop-cli/compare and file the PR by hand
+(parked file is in `~/.config/walla/teach/`). Agents ask once on first use,
+then at 20 / 40 / 60 prompts — never on every search.
+
 ## Disclaimer
 
 Unofficial. Not affiliated with Wallapop. Personal / research use.

{walla_cli-0.1.13 → walla_cli-0.1.14}/docs/data_engineering_standards.md

@@ -15,8 +15,9 @@ Code shape: [`code_quality.md`](code_quality.md). Wire truth: [`WIRE.md`](WIRE.m
 
 | Mode | What | Mutability | Clock |
 |---|---|---|---|
-| Working | `profile.json`, `watches.json`, `session.json` | mutable | user lifetime |
+| Working | `profile.json`, `watches.json`, `session.json`, `teach.json` | mutable | user lifetime |
 | Archive | redacted fixtures under `fixtures/` | append on capture | repo life |
+| Teach drop | `~/.config/walla/teach/*.md` | append | user opt-in |
 | Live | `api.wallapop.com` responses | read | request |
 
 There is no database in v1. Do not stand up Postgres, Redis, or a second
@@ -37,6 +38,7 @@ file for the same fields is a defect.
 - Profile: one home point, one search radius, one pickup radius.
 - Watch: one keyword query + optional filters; seen listing ids are a set.
 - Session: tokens / cookie fields only. Never the password.
+- Teach: `teach.json` (first-notice clock) and one redacted file per `walla teach`.
 - Fixture: one captured response shape, secrets redacted, `schema_version` in
   the companion parser module docstring.
 

walla_cli-0.1.14/incoming/teach/README.md

@@ -0,0 +1,3 @@
+# Incoming teach drops
+
+Redacted agent transcripts from `walla teach --method`. One markdown file per PR.

{walla_cli-0.1.13 → walla_cli-0.1.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "walla-cli"
-version = "0.1.13"
+version = "0.1.14"
 description = "Wallapop.es CLI - look · offer · talk · sell for humans and agents"
 authors = [{ name = "Dr. Berend Gort", email = "berend.gort@gmail.com" }]
 readme = "README.md"

{walla_cli-0.1.13 → walla_cli-0.1.14}/tests/test_cli_json.py

@@ -40,12 +40,16 @@ def test_rate_limit_fields() -> None:
     assert p["retry_after_s"] == 2.0
 
 
-def test_instruct_json() -> None:
+def test_instruct_json(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
     result = runner.invoke(app, ["instruct", "--json"])
     assert result.exit_code == 0
     data = json.loads(result.stdout)
     assert data["ok"] is True
     assert data["data"]["name"] == "walla"
+    assert data["data"]["teach"]["first_notice"]
+    again = runner.invoke(app, ["instruct", "--json"])
+    assert json.loads(again.stdout)["data"]["teach"]["first_notice"] is None
 
 
 def test_doctor_never_echoes_secrets(monkeypatch: pytest.MonkeyPatch) -> None:

{walla_cli-0.1.13 → walla_cli-0.1.14}/tests/test_core.py

@@ -14,7 +14,7 @@ from walla.core.exceptions import (
     WallaParseError,
     WallaUnsupportedError,
 )
-from walla.core.path import config_dir, profile_path
+from walla.core.path import config_dir, profile_path, teach_dir
 from walla.http.polite import reset_polite
 from walla.hunter.profile_store import parse_intake
 
@@ -32,6 +32,7 @@ def test_paths(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
     monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
     assert config_dir() == tmp_path
     assert profile_path() == tmp_path / "profile.json"
+    assert teach_dir() == tmp_path / "teach"
 
 
 def test_parse_intake(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:

walla_cli-0.1.14/tests/test_teach.py

@@ -0,0 +1,73 @@
+"""Local transcript parking (no Wallapop wire)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from pytest import MonkeyPatch
+
+from walla.core.teach import (
+    FIRST_NOTICE,
+    park_transcript,
+    redact_secrets,
+    should_ask_feedback,
+    teach_payload,
+)
+from walla.core.teach_pr import MANUAL_PR, plan_pr, ship_pr
+
+
+def test_redact_jwt_and_cookie() -> None:
+    blob, n = redact_secrets(
+        "cookie __Secure-next-auth.session-token=abc.def\n"
+        "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.aaa.bbb"
+    )
+    assert n == 2
+    assert "[redacted]" in blob
+    assert "session-token=abc" not in blob
+
+
+def test_park_and_first_notice(tmp_path: Path, monkeypatch: MonkeyPatch) -> None:
+    monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
+    first = teach_payload()
+    assert first["first_notice"] == FIRST_NOTICE
+    second = teach_payload()
+    assert second["first_notice"] is None
+    parked = park_transcript(
+        "hello Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.aaa.bbb",
+        name="hunt",
+    )
+    path = Path(str(parked["path"]))
+    assert path.is_file()
+    assert path.parent == tmp_path / "teach"
+    assert parked["redacted"] >= 1
+    assert "eyJhbGci" not in path.read_text(encoding="utf-8")
+
+
+def test_should_ask_every_twenty() -> None:
+    assert should_ask_feedback(19) is False
+    assert should_ask_feedback(20) is True
+    assert should_ask_feedback(21, last_asked_band=20) is False
+    assert should_ask_feedback(40, last_asked_band=20) is True
+    assert should_ask_feedback(40, last_asked_band=40) is False
+    assert should_ask_feedback(60, last_asked_band=40) is True
+
+
+def test_pr_menu_and_draft(tmp_path: Path, monkeypatch: MonkeyPatch) -> None:
+    monkeypatch.setenv("WALLA_CONFIG_DIR", str(tmp_path))
+    payload = teach_payload()
+    ids = [m["id"] for m in payload["methods"]]
+    assert ids == ["A", "B", "C", "D", "E"]
+    assert payload["manual_pr"] == MANUAL_PR
+    draft = plan_pr("a")
+    assert draft["method"] == "a"
+    assert "github.com" in draft["manual_pr"]
+    parked = park_transcript("hello kite hunt", name="x")
+    pr = ship_pr(Path(str(parked["path"])), method="e", yes=False)
+    assert pr["status"] == "draft"
+    assert pr["manual_pr"] == MANUAL_PR
+    manual = ship_pr(Path(str(parked["path"])), method="E", yes=True)
+    assert manual["status"] == "manual"
+    assert manual["open"] == MANUAL_PR
+    with pytest.raises(ValueError, match="method"):
+        plan_pr("z")

{walla_cli-0.1.13 → walla_cli-0.1.14}/walla/__init__.py

@@ -4,4 +4,4 @@ from __future__ import annotations
 
 __all__ = ("__version__",)
 
-__version__ = "0.1.13"
+__version__ = "0.1.14"

{walla_cli-0.1.13 → walla_cli-0.1.14}/walla/cli/cmd_ops.py

@@ -10,6 +10,7 @@ from walla import __version__
 from walla.account.session_store import load_session
 from walla.cli.catch import run_cmd
 from walla.core.instruct import instruct_recipe
+from walla.core.teach import teach_payload
 from walla.hunter.profile_store import load_profile, parse_intake, save_profile
 
 __all__ = ("register",)
@@ -37,7 +38,7 @@ def register(app: typer.Typer) -> None:
             except Exception:  # noqa: BLE001
                 reachable = False
             has_session = bool(sess and (sess.access_token or sess.session_cookie))
-            return {
+            out: dict[str, Any] = {
                 "version": __version__,
                 "network": {"reachable": reachable},
                 "auth": {
@@ -46,6 +47,10 @@ def register(app: typer.Typer) -> None:
                 },
                 "profile": {"ready": profile.ready, "label": profile.label},
             }
+            notice = teach_payload()
+            if notice.get("first_notice"):
+                out["teach"] = notice
+            return out
 
         run_cmd(_run, as_json=json)
 

walla_cli-0.1.14/walla/cli/cmd_teach.py

@@ -0,0 +1,53 @@
+"""Park a redacted agent transcript locally."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from walla.cli.catch import run_cmd
+from walla.core.teach import park_transcript
+from walla.core.teach_pr import ship_pr
+
+__all__ = ("register",)
+
+
+def register(app: typer.Typer) -> None:
+    @app.command("teach")
+    def teach_cmd(
+        source: Path | None = typer.Argument(
+            None,
+            help="Transcript file, or - for stdin",
+        ),
+        name: str | None = typer.Option(None, "--name", help="Filename stem"),
+        method: str | None = typer.Option(
+            None,
+            "--method",
+            help="PR path: a=gh b=git c=browser d=hub e=manual",
+        ),
+        yes: bool = typer.Option(False, "--yes", help="Open/push the PR for real"),
+        json: bool = typer.Option(False, "--json"),
+    ) -> None:
+        """Park a redacted transcript; --method a-e opens a GitHub PR."""
+
+        def _run() -> dict[str, Any]:
+            if source is None:
+                raise ValueError("Pass a file, or pipe stdin: walla teach - < chat.md")
+            if str(source) == "-":
+                text = typer.get_text_stream("stdin").read()
+                stem = name or "stdin"
+            else:
+                path = source.expanduser()
+                if not path.is_file():
+                    raise ValueError(f"transcript not found: {path}")
+                text = path.read_text(encoding="utf-8")
+                stem = name or path.stem
+            parked = park_transcript(text, name=stem)
+            out: dict[str, Any] = {"status": "parked", **parked}
+            if method:
+                out["pr"] = ship_pr(Path(str(parked["path"])), method=method, yes=yes)
+            return out
+
+        run_cmd(_run, as_json=json)

{walla_cli-0.1.13 → walla_cli-0.1.14}/walla/cli/main.py

@@ -7,7 +7,15 @@ from typing import Any
 import typer
 from typer.core import TyperGroup
 
-from walla.cli import cmd_account, cmd_desk, cmd_edit, cmd_look, cmd_ops, cmd_sell
+from walla.cli import (
+    cmd_account,
+    cmd_desk,
+    cmd_edit,
+    cmd_look,
+    cmd_ops,
+    cmd_sell,
+    cmd_teach,
+)
 from walla.cli.banner import print_banner
 
 __all__ = ("app", "cli")
@@ -37,6 +45,7 @@ cmd_look.register(app)
 cmd_account.register(app)
 cmd_sell.register(app)
 cmd_edit.register(app)
+cmd_teach.register(app)
 cmd_desk.register(app)
 
 

{walla_cli-0.1.13 → walla_cli-0.1.14}/walla/core/instruct.py

@@ -6,6 +6,7 @@ import json
 from typing import Any
 
 from walla.core.path import profile_path
+from walla.core.teach import teach_payload
 from walla.models.profile import Profile
 
 __all__ = ("instruct_recipe",)
@@ -140,6 +141,10 @@ def instruct_recipe() -> dict[str, Any]:
                 "walla edit <item_id> --eur N [--desc …] [--ship/--no-ship] --yes",
                 "walla unsell <item_id> --yes",
             ],
+            "teach": [
+                "walla teach <export.md> --json",
+                "walla teach <export.md> --method a --yes --json",
+            ],
         },
         "rules": [
             "Always present Wallapop shortlists ranked best-first with markdown item links.",
@@ -162,7 +167,15 @@ def instruct_recipe() -> dict[str, Any]:
             "Negotiate drafts are win-win: respectful Spanish, no lowballs, no pressure.",
             "never_pay: walla stops before payment; human completes in the app.",
             "No .env credentials. Login is cookie paste only (optional --password).",
+            "If the human asks to upload/save a transcript via the CLI, do it "
+            "now: write the chat to a file, walla teach FILE --json, then "
+            "print A-E and wait. Do not wait for the 20-prompt cadence.",
+            "Count user prompts. At 20, 40, 60... ask once to upload a redacted "
+            "transcript. If they agree, print A-E (gh/git/browser/hub/manual) "
+            "and wait for a letter. Assume the tool is on PATH; if it is not, "
+            "open data.teach.manual_pr and help them file the PR by hand.",
         ],
+        "teach": teach_payload(),
         "envelope": ["ok", "api_version", "data | error / error_type / retryable"],
         "standards": [
             "docs/code_quality.md",

{walla_cli-0.1.13 → walla_cli-0.1.14}/walla/core/path.py

@@ -11,6 +11,8 @@ __all__ = (
     "profile_path",
     "pursuits_path",
     "session_path",
+    "teach_dir",
+    "teach_state_path",
     "watches_path",
 )
 
@@ -40,3 +42,11 @@ def last_search_path() -> Path:
 
 def pursuits_path() -> Path:
     return config_dir() / "pursuits.json"
+
+
+def teach_dir() -> Path:
+    return config_dir() / "teach"
+
+
+def teach_state_path() -> Path:
+    return config_dir() / "teach.json"

walla_cli-0.1.14/walla/core/teach.py

@@ -0,0 +1,138 @@
+"""Park agent transcripts locally (no Wallapop I/O)."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from typing import Any
+
+from walla.core.path import teach_dir, teach_state_path
+from walla.core.teach_pr import MANUAL_PR, method_menu
+
+__all__ = (
+    "ASK_EVERY",
+    "FIRST_NOTICE",
+    "ask_copy",
+    "consume_first_notice",
+    "park_transcript",
+    "redact_secrets",
+    "should_ask_feedback",
+    "teach_payload",
+)
+
+ASK_EVERY = 20
+
+FIRST_NOTICE = (
+    "Long agent chats (especially hunts) help improve walla. After you confirm, "
+    "the agent can open a PR with walla teach --method A-E (gh/git/browser/hub/"
+    "manual). Tools are assumed on PATH; otherwise open "
+    f"{MANUAL_PR} yourself."
+)
+
+_SECRET = re.compile(
+    r"(?i)("
+    r"(?:__secure-next-auth\.session-token|session-token|bearer|refresh_token)"
+    r"['\"=\s:]+[^\s'\"]+"
+    r"|eyJ[a-zA-Z0-9_-]{20,}\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+"
+    r")"
+)
+
+
+def redact_secrets(text: str) -> tuple[str, int]:
+    """Replace session cookies, bearers, and JWTs. Returns text, hit count."""
+    hits = 0
+
+    def _sub(match: re.Match[str]) -> str:
+        nonlocal hits
+        hits += 1
+        return "[redacted]"
+
+    return _SECRET.sub(_sub, text), hits
+
+
+def park_transcript(text: str, *, name: str | None = None) -> dict[str, Any]:
+    """Write a redacted copy under ~/.config/walla/teach/."""
+    body, n_redacted = redact_secrets(text)
+    if not body.strip():
+        raise ValueError("transcript is empty")
+    stamp = datetime.now(timezone.utc).strftime("%Y%m%d-%H%M%S")
+    safe = re.sub(r"[^a-zA-Z0-9._-]+", "-", (name or "chat").strip())[:40]
+    dest = teach_dir() / f"{stamp}-{safe or 'chat'}.md"
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_text(body, encoding="utf-8")
+    return {
+        "path": str(dest),
+        "bytes": dest.stat().st_size,
+        "redacted": n_redacted,
+        "how": f"parked locally; PR via walla teach --method a --yes or {MANUAL_PR}",
+        "manual_pr": MANUAL_PR,
+    }
+
+
+def should_ask_feedback(user_prompts: int, *, last_asked_band: int = 0) -> bool:
+    """True at 20, 40, 60... once per band (count >= 20)."""
+    if user_prompts < ASK_EVERY:
+        return False
+    band = (user_prompts // ASK_EVERY) * ASK_EVERY
+    return band > last_asked_band
+
+
+def ask_copy(user_prompts: int) -> str:
+    return (
+        f"This chat is {user_prompts} prompts in. Upload a redacted transcript "
+        "to improve walla? If yes, reply with A B C D or E (gh / git / browser "
+        f"/ hub / I'll do it). Manual PR: {MANUAL_PR}"
+    )
+
+
+def _load_state() -> dict[str, Any]:
+    path = teach_state_path()
+    if not path.is_file():
+        return {"schema_version": 1, "first_notice_at": None}
+    try:
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError, ValueError):
+        return {"schema_version": 1, "first_notice_at": None}
+    return raw if isinstance(raw, dict) else {"schema_version": 1}
+
+
+def _save_state(state: dict[str, Any]) -> None:
+    path = teach_state_path()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(state, indent=2) + "\n", encoding="utf-8")
+
+
+def consume_first_notice() -> str | None:
+    """Return the first-use blurb once, then persist that it was shown."""
+    state = _load_state()
+    if state.get("first_notice_at"):
+        return None
+    state["first_notice_at"] = datetime.now(timezone.utc).isoformat()
+    _save_state(state)
+    return FIRST_NOTICE
+
+
+def teach_payload() -> dict[str, Any]:
+    """Instruct/doctor field. Never attach this to search/desk envelopes."""
+    notice = consume_first_notice()
+    return {
+        "dir": str(teach_dir()),
+        "how": "walla teach <export.md> --method a --yes --json",
+        "ask_every": ASK_EVERY,
+        "first_notice": notice,
+        "confirm": "Ask yes/no before any upload. Never dump the transcript unasked.",
+        "methods": method_menu(),
+        "manual_pr": MANUAL_PR,
+        "ask_rule": (
+            "Count user prompts. At 20, 40, 60... ask once to upload. "
+            "If yes, print A-E and wait for a letter. Assume gh/git/hub/"
+            "browser is installed; on failure open data.teach.manual_pr "
+            "and walk them through a manual PR. Never on search/desk."
+        ),
+        "ask_copy": ask_copy(ASK_EVERY),
+        "cli": (
+            "Save the chat to a file, then: "
+            "walla teach FILE --method a|b|c|d|e --yes --json"
+        ),
+    }

walla_cli-0.1.14/walla/core/teach_pr.py

@@ -0,0 +1,199 @@
+"""Open a GitHub PR for a parked transcript (gh / git / hub / browser / manual)."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import webbrowser
+from pathlib import Path
+from typing import Any
+
+__all__ = (
+    "MANUAL_PR",
+    "METHODS",
+    "REPO",
+    "method_menu",
+    "plan_pr",
+    "ship_pr",
+)
+
+REPO = "berendgort/wallapop-cli"
+MANUAL_PR = f"https://github.com/{REPO}/compare"
+UPLOAD = f"https://github.com/{REPO}/upload/main/incoming/teach"
+
+METHODS: dict[str, dict[str, str]] = {
+    "a": {
+        "bin": "gh",
+        "label": "GitHub CLI (gh fork/push/pr create)",
+    },
+    "b": {
+        "bin": "git",
+        "label": "git branch, commit, push, then open the compare URL",
+    },
+    "c": {
+        "bin": "browser",
+        "label": "Open GitHub in the browser (upload + compare links)",
+    },
+    "d": {
+        "bin": "hub",
+        "label": "hub pull-request (legacy GitHub CLI)",
+    },
+    "e": {
+        "bin": "manual",
+        "label": "I will open the PR myself (print the link + file path)",
+    },
+}
+
+
+def method_menu() -> list[dict[str, str]]:
+    return [
+        {"id": key.upper(), "key": key, **row} for key, row in METHODS.items()
+    ]
+
+
+def _which(name: str) -> str | None:
+    if name in {"browser", "manual"}:
+        return name
+    return shutil.which(name)
+
+
+def plan_pr(method: str) -> dict[str, Any]:
+    key = method.strip().lower()
+    if key not in METHODS:
+        raise ValueError("method must be A B C D or E")
+    spec = METHODS[key]
+    binary = spec["bin"]
+    found = _which(binary)
+    return {
+        "method": key,
+        "label": spec["label"],
+        "assume_on_path": binary,
+        "found": bool(found),
+        "manual_pr": MANUAL_PR,
+        "upload": UPLOAD,
+        "hint": (
+            f"Assumes `{binary}` is installed. If not, open {MANUAL_PR} "
+            "and create the PR by hand (or pick E)."
+        ),
+    }
+
+
+def ship_pr(parked: Path, *, method: str, yes: bool) -> dict[str, Any]:
+    """Copy into incoming/teach and open a PR. Needs --yes to mutate git/gh."""
+    plan = plan_pr(method)
+    plan["parked"] = str(parked)
+    if not yes:
+        plan["status"] = "draft"
+        plan["next"] = (
+            f"Reply with a letter, then: walla teach {parked} "
+            f"--method {plan['method']} --yes --json"
+        )
+        return plan
+    key = str(plan["method"])
+    if key == "e" or not plan["found"]:
+        plan["status"] = "manual"
+        plan["open"] = MANUAL_PR
+        return plan
+    if key == "c":
+        webbrowser.open(UPLOAD)
+        webbrowser.open(MANUAL_PR)
+        plan["status"] = "opened_browser"
+        plan["open"] = MANUAL_PR
+        return plan
+    if key == "a":
+        return _ship_gh(parked, plan)
+    if key == "d":
+        return _ship_hub(parked, plan)
+    return _ship_git(parked, plan)
+
+
+def _run(cmd: list[str], *, cwd: Path | None = None) -> tuple[int, str, str]:
+    proc = subprocess.run(
+        cmd,
+        cwd=str(cwd) if cwd else None,
+        capture_output=True,
+        text=True,
+        timeout=120,
+        check=False,
+    )
+    return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
+
+
+def _ship_gh(parked: Path, plan: dict[str, Any]) -> dict[str, Any]:
+    code, out, err = _run(
+        [
+            "gh",
+            "pr",
+            "create",
+            "--repo",
+            REPO,
+            "--title",
+            f"teach: {parked.name}",
+            "--body",
+            f"Redacted agent transcript from `walla teach`.\n\nFile: `{parked}`",
+        ]
+    )
+    blob = f"{out}\n{err}"
+    url = next((ln for ln in blob.splitlines() if "github.com" in ln), "")
+    plan["status"] = "ok" if code == 0 else "failed"
+    plan["open"] = url or MANUAL_PR
+    if code != 0:
+        plan["error"] = (err or out or "gh pr create failed")[:300]
+        plan["assist"] = (
+            "gh is missing a fork/branch. Agent: help install/auth gh, or "
+            f"open {MANUAL_PR} and attach {parked}."
+        )
+    return plan
+
+
+def _ship_hub(parked: Path, plan: dict[str, Any]) -> dict[str, Any]:
+    code, out, err = _run(["hub", "pull-request", "-m", f"teach: {parked.name}"])
+    blob = f"{out}\n{err}"
+    url = next((ln for ln in blob.splitlines() if "github.com" in ln), "")
+    plan["status"] = "ok" if code == 0 else "failed"
+    plan["open"] = url or MANUAL_PR
+    if code != 0:
+        plan["error"] = (err or out or "hub pull-request failed")[:300]
+        plan["assist"] = f"hub failed. Open {MANUAL_PR} or switch to A (gh)."
+    return plan
+
+
+def _ship_git(parked: Path, plan: dict[str, Any]) -> dict[str, Any]:
+    root = _git_root()
+    if root is None:
+        plan["status"] = "manual"
+        plan["open"] = MANUAL_PR
+        plan["assist"] = (
+            "Not inside a wallapop-cli clone. Open the compare link or "
+            "clone the repo, copy the parked file into incoming/teach/, "
+            "commit, push, then open the PR URL."
+        )
+        return plan
+    dest_dir = root / "incoming" / "teach"
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / parked.name
+    dest.write_text(parked.read_text(encoding="utf-8"), encoding="utf-8")
+    branch = f"teach/{parked.stem}"[:60]
+    for cmd in (
+        ["git", "checkout", "-b", branch],
+        ["git", "add", str(dest)],
+        ["git", "commit", "-m", f"teach: park {parked.name}"],
+        ["git", "push", "-u", "origin", "HEAD"],
+    ):
+        code, out, err = _run(cmd, cwd=root)
+        if code != 0 and "already exists" not in (err + out):
+            plan["status"] = "failed"
+            plan["open"] = MANUAL_PR
+            plan["error"] = (err or out or "git failed")[:300]
+            plan["assist"] = f"Finish by hand: {MANUAL_PR}"
+            return plan
+    plan["status"] = "pushed"
+    plan["open"] = f"https://github.com/{REPO}/compare/main...{branch}?expand=1"
+    return plan
+
+
+def _git_root() -> Path | None:
+    code, out, _err = _run(["git", "rev-parse", "--show-toplevel"])
+    if code != 0 or not out:
+        return None
+    return Path(out)

{walla_cli-0.1.13 → walla_cli-0.1.14}/walla/mcp/server.py

@@ -183,4 +183,26 @@ def build_server() -> Any:
     def me() -> dict[str, Any]:
         return _wrap(whoami)
 
+    @mcp.tool()
+    def teach(
+        text: str,
+        name: str | None = None,
+        method: str | None = None,
+        confirm: bool = False,
+    ) -> dict[str, Any]:
+        """Park a redacted transcript; with method+confirm, open a GitHub PR."""
+        from pathlib import Path
+
+        from walla.core.teach import park_transcript
+        from walla.core.teach_pr import ship_pr
+
+        def _run() -> dict[str, Any]:
+            parked = park_transcript(text, name=name)
+            if not method:
+                return parked
+            pr = ship_pr(Path(str(parked["path"])), method=method, yes=confirm)
+            return {**parked, "pr": pr}
+
+        return _wrap(_run)
+
     return mcp