pyrepowiki-cli 0.1.0__py3-none-any.whl

pyrepowiki_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+repowiki/__init__.py,sha256=macC4owSJgzDJZuZoTRKZ3Uav8-4JtVBAT7n3i0zXHM,92
+repowiki/cli.py,sha256=-WhNtcsIRdUOl9ZNUtjqD4QK_hPXcaSqeh0zFmImdbw,885
+repowiki/services/__init__.py,sha256=yHeMArTg_nkffFPw7BsPj6TJJe7AzhQTWJA8jXpkN8o,50
+repowiki/services/codewiki/__init__.py,sha256=AR_m_WhuNvzZCOGkYAs2JSBHS4TX78j3u9u7glMQzro,101
+repowiki/services/codewiki/boq.py,sha256=1Td8GzN2vwb-5KTzVvgB6my0KEdlyN2VY9ySJoIVSSo,1997
+repowiki/services/codewiki/cli.py,sha256=g0cb_8p-ZXOyDe5KT0M4trOhHq0n9Y-6hsXm50nGWC0,10691
+repowiki/services/codewiki/client.py,sha256=GyMFmylMh8f9fu_7EzVfFT-kaZdT18QZlnk-ExF3qJc,7973
+repowiki/services/codewiki/wiki.py,sha256=ZVikuguFPlOdvP8_m8Ii5wZ1WeLZHELhaSI9TZD4nJ0,5203
+repowiki/services/deepwiki/__init__.py,sha256=I_6UP9UxVOZ5EYUcEpWSBwBLbkO79YszlvgI3c-mkK4,101
+repowiki/services/deepwiki/cli.py,sha256=B6L-0V4YmOKIoECiYoHOyQZqcV91OVTatHyWyGiMLXc,29299
+repowiki/services/deepwiki/client.py,sha256=6WsJR5G8WXJicBdPKOIBtzA016-cJ-7YdmCST_C9ETY,5782
+repowiki/services/deepwiki/codemap.py,sha256=tOh0xP57JP4sNIsMs2JN543gc1cyxUYqKXHU-dLSUhw,2576
+repowiki/services/deepwiki/devin.py,sha256=E7uPP2cy50-WjYr1rZTDBGko4uxCMNfm5VYYT6hvf-Y,13420
+repowiki/services/zread/__init__.py,sha256=u-74WtrivibwhPN7h7q5fqR4f44MSLbP7S3s6E6MCrQ,147
+repowiki/services/zread/cli.py,sha256=KVtTLmQE5LaOrH4xnuZFsLgEG2nnAEM5w9OsmT1wOTg,23664
+repowiki/services/zread/client.py,sha256=majl4AxhmXJSgKR7geV-RpYufW4bKBMF8oBwvhhGItE,15701
+repowiki/services/zread/flight.py,sha256=YlTXiu_b9m4erapXSSCq7x9_WAPPnyFmwEUs6PBEVLg,3261
+repowiki/shared/__init__.py,sha256=gmmylKO0R13Zq83Jcyq2ZkwDI-ejalZwtYwmygELgbE,49
+repowiki/shared/async_.py,sha256=NS6TDblljY_ebz5E3LAkMs7u7dXkPyPTpUsxod0uV0U,389
+repowiki/shared/export.py,sha256=t-APTy3FxyjYKcVIiHFSeKWWBHs18ozI99XZv7FiRIw,1475
+repowiki/shared/model.py,sha256=cq8xHQooxRbxn9AJtvnVWk8gKTc5Y7_fveWIPs0O8xc,600
+repowiki/shared/output.py,sha256=3AFMi4iOcTkvVRjB06nuzWa8kia8LFSfkpWiRHYqRvw,7249
+repowiki/shared/repo.py,sha256=vZww60m9zdN4FYbl1hTlXQlJeXbHUAnpr64069847q0,1498
+repowiki/shared/save.py,sha256=u3TL5bMlmpVeNjPjt6TGXGfi59W7VYNB6RJ9ydfU9JU,879
+pyrepowiki_cli-0.1.0.dist-info/METADATA,sha256=Zon4gJ_iMsLWSuPGoGvqzPG1N4Odap9mlSF5PquukKU,33006
+pyrepowiki_cli-0.1.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+pyrepowiki_cli-0.1.0.dist-info/entry_points.txt,sha256=1ivpGqPt4xHlrgt8xBRpOBp90Dt7pjq9HJMKnzTg9pk,51
+pyrepowiki_cli-0.1.0.dist-info/RECORD,,

pyrepowiki_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any

pyrepowiki_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+repowiki-cli = repowiki.cli:main

repowiki/__init__.py

@@ -0,0 +1,3 @@
+"""repowiki-cli - query DeepWiki documentation from the terminal."""
+
+__version__ = "0.1.0"

repowiki/cli.py

@@ -0,0 +1,43 @@
+"""CLI entry point for repowiki-cli."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+
+from repowiki import __version__
+from repowiki.services.codewiki import register as register_codewiki
+from repowiki.services.deepwiki import register as register_deepwiki
+from repowiki.services.zread import register as register_zread
+
+app = typer.Typer(add_completion=False)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        typer.echo(f"repowiki-cli {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def _main(
+    version: Optional[bool] = typer.Option(
+        None, "--version", callback=_version_callback, is_eager=True,
+        help="Show the version and exit.",
+    ),
+) -> None:
+    pass
+
+
+register_deepwiki(app)
+register_codewiki(app)
+register_zread(app)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()

repowiki/services/__init__.py

@@ -0,0 +1 @@
+"""Wiki services, one subpackage per provider."""

repowiki/services/codewiki/__init__.py

@@ -0,0 +1,5 @@
+"""CodeWiki service."""
+
+from repowiki.services.codewiki.cli import register
+
+__all__ = ["register"]

repowiki/services/codewiki/boq.py

@@ -0,0 +1,57 @@
+"""Boq batchexecute request/response framing for CodeWiki."""
+
+from __future__ import annotations
+
+import json
+from urllib.parse import quote
+
+_PREFIX = ")]}'"
+
+
+def encode_request(rpc_id: str, inner_json: str) -> str:
+    """Return the ``f.req=...&`` form body for a batchexecute call."""
+    envelope = [[[rpc_id, inner_json, None, "generic"]]]
+    serialized = json.dumps(envelope)
+    return f"f.req={quote(serialized, safe='')}&"
+
+
+def decode_response(body: str, rpc_id: str) -> object:
+    """Strip the ``)]}'`` prefix, skip length headers, and return the inner
+    payload of the ``wrb.fr`` frame whose id matches ``rpc_id``."""
+    trimmed = body.lstrip("")
+    if not trimmed.startswith(_PREFIX):
+        raise ValueError("response missing `)]}'` prefix")
+    cursor = trimmed[len(_PREFIX):]
+
+    decoder = json.JSONDecoder()
+    while True:
+        start = next((i for i, ch in enumerate(cursor) if ch in "[{"), None)
+        if start is None:
+            break
+        cursor = cursor[start:]
+        frame, consumed = decoder.raw_decode(cursor)
+        cursor = cursor[consumed:]
+        payload = _find_rpc_payload(frame, rpc_id)
+        if payload is not None:
+            return payload
+
+    raise ValueError(f"no `wrb.fr` frame found for rpc id `{rpc_id}`")
+
+
+def _find_rpc_payload(frames: object, rpc_id: str) -> object | None:
+    if not isinstance(frames, list):
+        raise ValueError("frame is not an array")
+    for frame in frames:
+        if not isinstance(frame, list):
+            continue
+        tag = frame[0] if frame and isinstance(frame[0], str) else ""
+        if tag != "wrb.fr":
+            continue
+        fid = frame[1] if len(frame) > 1 and isinstance(frame[1], str) else ""
+        if fid != rpc_id:
+            continue
+        inner = frame[2] if len(frame) > 2 and isinstance(frame[2], str) else None
+        if inner is None:
+            raise ValueError("`wrb.fr` frame missing inner JSON string")
+        return json.loads(inner)
+    return None

repowiki/services/codewiki/cli.py

@@ -0,0 +1,315 @@
+"""CLI commands for the CodeWiki service."""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import NoReturn, Optional
+
+import typer
+
+from repowiki.services.codewiki.client import (
+    CodeWikiClient,
+    CodeWikiConnectionError,
+    CodeWikiError,
+)
+from repowiki.services.codewiki.wiki import render_markdown, render_page, render_section, render_structure
+from repowiki.shared.async_ import run_async
+from repowiki.shared.export import export_pages
+from repowiki.shared.model import Answer
+from repowiki.shared.output import (
+    filter_page,
+    format_answer,
+    format_error_json,
+    format_header,
+    format_json,
+    format_result,
+    render_markdown as render_rich,
+    status,
+)
+from repowiki.shared.repo import normalize_repo
+from repowiki.shared.save import append_entry
+
+codewiki_app = typer.Typer(add_completion=False, help="Query Google Code Wiki documentation.")
+
+
+def register(app: typer.Typer) -> None:
+    """Mount the CodeWiki service commands on the root app."""
+    app.add_typer(codewiki_app, name="codewiki")
+
+
+def _mock_text() -> Optional[str]:
+    return os.environ.get("REPOWIKI_CODEWIKI_MOCK") or None
+
+
+def _resolve_repo(raw: str, json_mode: bool) -> str:
+    try:
+        return normalize_repo(raw)
+    except ValueError as exc:
+        _fail(str(exc), "invalid_repo", json_mode)
+
+
+def _fail(message: str, kind: str, json_mode: bool) -> NoReturn:
+    if json_mode:
+        typer.echo(format_error_json(kind, message), err=True)
+    else:
+        typer.secho(f"Error: {message}", fg=typer.colors.RED, err=True)
+    raise typer.Exit(code={"connection": 3}.get(kind, 1))
+
+
+def _handle_exception(exc: Exception, json_mode: bool) -> NoReturn:
+    if isinstance(exc, CodeWikiConnectionError):
+        _fail(str(exc), "connection", json_mode)
+    elif isinstance(exc, CodeWikiError):
+        _fail(str(exc), "error", json_mode)
+    _fail(f"Unexpected error: {exc}", "unexpected", json_mode)
+
+
+def _emit(
+    repo: str,
+    command: str,
+    text: str,
+    rich: bool,
+    json_mode: bool,
+    **json_fields: object,
+) -> None:
+    if json_mode:
+        typer.echo(format_json(repo, command, **json_fields))
+        return
+    rendered = format_result("CodeWiki", repo, command, text)
+    if rich:
+        render_rich(rendered)
+    else:
+        typer.echo(rendered)
+
+
+def _repl_prompt() -> str:
+    """Return the REPL input prompt, colored only on a terminal."""
+    if not sys.stdout.isatty():
+        return ">> "
+    return typer.style(">> ", fg=typer.colors.CYAN, bold=True)
+
+
+def _print_error(exc: Exception) -> None:
+    if isinstance(exc, CodeWikiError):
+        message = str(exc)
+    else:
+        message = f"Unexpected error: {exc}"
+    typer.secho(f"Error: {message}", fg=typer.colors.RED, err=True)
+
+
+def _append_save(
+    path: Optional[str], repo: str, question: str, answer: str
+) -> None:
+    if path is None:
+        return
+    try:
+        append_entry(path, repo, question, answer)
+    except OSError as exc:
+        typer.secho(
+            f"Warning: could not save to {path}: {exc}",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+
+
+async def _repl(resolved: str, rich: bool, save_path: Optional[str]) -> None:
+    prompt = _repl_prompt()
+    client = CodeWikiClient()
+    while True:
+        try:
+            line = input(prompt)
+        except (EOFError, KeyboardInterrupt):
+            typer.echo()
+            break
+        q = line.strip()
+        if not q:
+            continue
+        if q in ("/exit", "/quit", "/q"):
+            break
+        try:
+            with status("Thinking..."):
+                answer = await client.ask(resolved, q)
+        except Exception as exc:
+            _print_error(exc)
+            continue
+        _append_save(save_path, resolved, q, answer)
+        typer.echo()
+        if rich:
+            render_rich(answer.strip())
+        else:
+            typer.echo(answer.strip())
+        typer.echo()
+
+
+@codewiki_app.command()
+def structure(
+    repo: str = typer.Argument(..., help="Repository (owner/repo or GitHub URL)"),
+    json: bool = typer.Option(False, "--json", help="Emit machine-readable JSON"),
+) -> None:
+    """Show the CodeWiki table of contents for a repository."""
+    resolved = _resolve_repo(repo, json)
+    if (mock := _mock_text()) is not None:
+        _emit(resolved, "structure", mock, False, json, content=mock)
+        return
+    client = CodeWikiClient()
+    try:
+        with status("Fetching table of contents..."):
+            wiki = run_async(client.read_wiki(resolved))
+        text = render_structure(wiki)
+    except Exception as exc:
+        _handle_exception(exc, json)
+    _emit(resolved, "structure", text, False, json, content=text)
+
+
+@codewiki_app.command()
+def contents(
+    repo: str = typer.Argument(..., help="Repository (owner/repo or GitHub URL)"),
+    page: Optional[str] = typer.Option(None, "--page", help="Show only the page with this title"),
+    rich: bool = typer.Option(False, "--rich", help="Render Markdown with rich"),
+    json: bool = typer.Option(False, "--json", help="Emit machine-readable JSON"),
+) -> None:
+    """Show the full CodeWiki documentation for a repository."""
+    resolved = _resolve_repo(repo, json)
+    if (mock := _mock_text()) is not None:
+        text = mock
+        if page is not None:
+            try:
+                text = filter_page(text, page)
+            except ValueError as exc:
+                _fail(str(exc), "page_not_found", json)
+    else:
+        client = CodeWikiClient()
+        try:
+            with status("Fetching documentation..."):
+                wiki = run_async(client.read_wiki(resolved))
+        except Exception as exc:
+            _handle_exception(exc, json)
+        try:
+            text = render_page(wiki, page) if page is not None else render_markdown(wiki)
+        except ValueError as exc:
+            _fail(str(exc), "page_not_found", json)
+    fields: dict[str, object] = {"content": text}
+    if page is not None:
+        fields["page"] = page
+    _emit(resolved, "contents", text, rich, json, **fields)
+
+
+@codewiki_app.command()
+def ask(
+    repo: str = typer.Argument(..., help="Repository (owner/repo or GitHub URL)"),
+    question: Optional[str] = typer.Argument(
+        None, help="Question (omit for interactive mode)"
+    ),
+    rich: bool = typer.Option(False, "--rich", help="Render Markdown with rich"),
+    json: bool = typer.Option(False, "--json", help="Emit machine-readable JSON"),
+    save: Optional[str] = typer.Option(
+        None, "--save", help="Save the answer to a Markdown file (appends)."
+    ),
+) -> None:
+    """Ask a question about a repository (single-shot or interactive)."""
+    resolved = _resolve_repo(repo, json)
+    if question is not None:
+        if not question.strip():
+            _fail("Question must not be empty.", "invalid_input", json)
+        if (mock := _mock_text()) is not None:
+            answer = Answer(body=mock)
+        else:
+            client = CodeWikiClient()
+            try:
+                with status("Thinking..."):
+                    answer = Answer(body=run_async(client.ask(resolved, question)))
+            except Exception as exc:
+                _handle_exception(exc, json)
+        if json:
+            typer.echo(format_json(resolved, "ask", question=question, answer=answer.body))
+        else:
+            _emit(resolved, "ask", format_answer(answer), rich, False)
+        _append_save(save, resolved, question, answer.body)
+        return
+
+    if json:
+        typer.secho(
+            "Warning: --json has no effect in interactive mode.",
+            fg=typer.colors.YELLOW,
+            err=True,
+        )
+    typer.echo(format_header("CodeWiki", resolved, "ask"))
+    typer.echo()
+    typer.echo("Ask a question, or /exit to quit.")
+    typer.echo()
+    try:
+        run_async(_repl(resolved, rich, save))
+    except Exception as exc:
+        _handle_exception(exc, False)
+
+
+def _format_stale(info: dict) -> str:
+    wiki_sha = info.get("wiki_sha") or ""
+    github_sha = info.get("github_sha") or ""
+    when = info.get("github_when") or ""
+    if not github_sha:
+        return "Could not fetch GitHub HEAD."
+    if not wiki_sha:
+        return "No commit sha in the wiki."
+    if github_sha.startswith(wiki_sha):
+        return f"最新 (up-to-date): {wiki_sha}"
+    suffix = f" ({when})" if when else ""
+    return f"过期 (stale): wiki {wiki_sha[:7]} != github {github_sha[:7]}{suffix}"
+
+
+@codewiki_app.command()
+def stat(
+    repo: str = typer.Argument(..., help="Repository (owner/repo or GitHub URL)"),
+    stale: bool = typer.Option(False, "--stale", help="Compare the wiki commit against GitHub HEAD"),
+    json: bool = typer.Option(False, "--json", help="Emit machine-readable JSON"),
+) -> None:
+    """Show the commit the CodeWiki documentation was generated from."""
+    resolved = _resolve_repo(repo, json)
+    client = CodeWikiClient()
+    wiki_sha: str = ""
+    stale_info: dict | None = None
+    try:
+        with status("Fetching wiki..."):
+            wiki = run_async(client.read_wiki(resolved))
+        wiki_sha = wiki.commit_sha
+        if stale:
+            with status("Checking GitHub HEAD..."):
+                head = run_async(client.github_head(resolved))
+            stale_info = {
+                "wiki_sha": wiki_sha,
+                "github_sha": head.get("sha") or "",
+                "github_when": head.get("when") or "",
+            }
+    except Exception as exc:
+        _handle_exception(exc, json)
+    if json:
+        fields: dict[str, object] = {"commit": wiki_sha}
+        if stale_info is not None:
+            fields["stale"] = stale_info
+        typer.echo(format_json(resolved, "stat", **fields))
+        return
+    text = f"- commit: {wiki_sha}" if wiki_sha else "No data."
+    if stale_info is not None:
+        text += "\n\n" + _format_stale(stale_info)
+    typer.echo(format_result("CodeWiki", resolved, "stat", text))
+
+
+@codewiki_app.command()
+def cp(
+    repo: str = typer.Argument(..., help="Repository (owner/repo or GitHub URL)"),
+    output_dir: Optional[str] = typer.Argument(None, help="Output directory"),
+) -> None:
+    """Export the whole wiki as Markdown files plus llms.txt."""
+    resolved = _resolve_repo(repo, False)
+    client = CodeWikiClient()
+    out = output_dir or resolved.replace("/", "_")
+    try:
+        with status("Exporting wiki..."):
+            wiki = run_async(client.read_wiki(resolved))
+        pages = [(s.title, render_section(s)) for s in wiki.sections]
+        full = render_markdown(wiki)
+        count = export_pages(out, resolved, pages, full)
+    except Exception as exc:
+        _handle_exception(exc, False)
+    typer.echo(f"Exported {count} pages to {out}")