docwright 0.1.5__tar.gz → 0.1.7__tar.gz

{docwright-0.1.5 → docwright-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: docwright
-Version: 0.1.5
+Version: 0.1.7
 Summary: AI-powered documentation agent: auto-generates and maintains README & wiki on every commit
 License: MIT
 License-File: LICENSE

docwright-0.1.7/docwright/cli.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+from pathlib import Path
+from urllib.parse import urlparse
+
+import click
+import yaml
+from rich.console import Console
+
+from docwright.config import Config
+from docwright.engine import DocsEngine
+from docwright.outputs.factory import build_output
+from docwright.providers.factory import build_provider
+
+console = Console()
+
+
+def get_repo_root() -> Path:
+    return Path.cwd()
+
+
+def build_engine(repo_root: Path) -> DocsEngine:
+    config = Config.load(repo_root)
+    provider = build_provider(config.provider)
+    output = build_output(config.output, repo_root)
+    return DocsEngine(repo_root=repo_root, provider=provider, output=output)
+
+
+def ensure_gitignore_has_env(repo_root: Path) -> None:
+    gitignore = repo_root / ".gitignore"
+    if gitignore.exists():
+        content = gitignore.read_text()
+        if ".env" in content.splitlines():
+            return
+        gitignore.write_text(content.rstrip("\n") + "\n.env\n")
+    else:
+        gitignore.write_text(".env\n")
+
+
+def append_env_var(repo_root: Path, key: str, value: str) -> None:
+    env_file = repo_root / ".env"
+    existing = env_file.read_text() if env_file.exists() else ""
+    lines = existing.splitlines()
+    filtered = [ln for ln in lines if not ln.startswith(f"{key}=")]
+    filtered.append(f"{key}={value}")
+    env_file.write_text("\n".join(filtered) + "\n")
+    ensure_gitignore_has_env(repo_root)
+
+
+def ask_int_choice(prompt: str, max_choice: int, default: int = 1) -> int:
+    while True:
+        raw = input(f"{prompt} [{default}]: ").strip()
+        if raw == "":
+            return default
+        if raw.isdigit() and 1 <= int(raw) <= max_choice:
+            return int(raw)
+        console.print(f"[red]✗ Enter a number from 1 to {max_choice}.[/red]")
+
+
+def run_interactive_setup(repo_root: Path) -> None:
+    """Run interactive setup wizard and write .docwright/docwright.yml."""
+    console.print()
+    console.print(
+        "[bold green]Welcome to docwright!"
+        " Let's set up documentation for this project.[/bold green]"
+    )
+
+    # ── Step 1: Provider ──────────────────────────────────────────────────────
+    console.rule("[bold]Step 1 of 4: AI Provider[/bold]")
+    console.print("\nWhich AI provider do you want to use?\n")
+    console.print("  1. OpenAI (GPT-4o)  — recommended")
+    console.print("  2. Claude (Anthropic)")
+    console.print("  3. Ollama (local or corporate server)\n")
+
+    provider_choice = ask_int_choice("Choose", 3, default=1)
+    provider_map = {1: "openai", 2: "claude", 3: "ollama"}
+    provider = provider_map[provider_choice]
+
+    # ── Step 2: API Key / Base URL ────────────────────────────────────────────
+    console.rule("[bold]Step 2 of 4: API credentials[/bold]")
+
+    api_key_env: str | None = None
+    base_url: str | None = None
+
+    if provider == "openai":
+        console.print("\nYou need an OpenAI API key.\n")
+        console.print("  Get it here → [link]https://platform.openai.com/api-keys[/link]")
+        console.print("  (Sign in → API Keys → Create new secret key)\n")
+        while True:
+            key = input("Paste your API key: ").strip()
+            if key.startswith("sk-"):
+                break
+            console.print(
+                "[red]✗ That doesn't look like an OpenAI key"
+                " (should start with sk-). Try again:[/red]"
+            )
+        append_env_var(repo_root, "OPENAI_API_KEY", key)
+        console.print("[green]✓ Key saved to .env (this file will NOT be committed to git)[/green]")
+        api_key_env = "OPENAI_API_KEY"
+        model = "gpt-4o"
+
+    elif provider == "claude":
+        console.print("\nYou need an Anthropic API key.\n")
+        console.print("  Get it here → [link]https://console.anthropic.com/settings/keys[/link]")
+        console.print("  (Sign in → API Keys → Create new secret key)\n")
+        while True:
+            key = input("Paste your API key: ").strip()
+            if key.startswith("sk-ant-"):
+                break
+            console.print(
+                "[red]✗ That doesn't look like an Anthropic key"
+                " (should start with sk-ant-). Try again:[/red]"
+            )
+        append_env_var(repo_root, "ANTHROPIC_API_KEY", key)
+        console.print("[green]✓ Key saved to .env (this file will NOT be committed to git)[/green]")
+        api_key_env = "ANTHROPIC_API_KEY"
+        model = "claude-sonnet-4-6"
+
+    else:  # ollama
+        console.print()
+        raw_url = input("Base URL [http://localhost:11434]: ").strip()
+        base_url = raw_url or "http://localhost:11434"
+        raw_model = input("Model name [llama3]: ").strip()
+        model = raw_model or "llama3"
+        api_key_env = None
+
+    # ── Step 3: Language ──────────────────────────────────────────────────────
+    console.rule("[bold]Step 3 of 4: Documentation language[/bold]")
+    console.print()
+    console.print("  1. English")
+    console.print("  2. Russian")
+    console.print("  3. Other (enter manually)\n")
+
+    lang_choice = ask_int_choice("Choose", 3, default=1)
+    if lang_choice == 1:
+        language = "en"
+    elif lang_choice == 2:
+        language = "ru"
+    else:
+        language = input("Enter language code (e.g. de, fr, es): ").strip() or "en"
+
+    # ── Step 4: Output mode ───────────────────────────────────────────────────
+    console.rule("[bold]Step 4 of 4: How to publish docs?[/bold]")
+    console.print()
+    console.print("  1. Commit directly to branch  (simplest, good for solo projects)")
+    console.print("  2. Create a Pull/Merge Request (requires human review)")
+    console.print("  3. Push to GitLab Wiki\n")
+
+    output_choice = ask_int_choice("Choose", 3, default=1)
+    output_mode_map = {1: "direct", 2: "pull_request", 3: "gitlab_wiki"}
+    output_mode = output_mode_map[output_choice]
+
+    wiki_url: str | None = None
+    gitlab_token_env: str | None = None
+
+    if output_mode == "gitlab_wiki":
+        console.print("\nGitLab Wiki URL:")
+        console.print("  → Take your project URL and add .wiki.git at the end")
+        console.print("  → Example: https://gitlab.com/mygroup/myproject.wiki.git\n")
+
+        while True:
+            wiki_url = input("URL: ").strip()
+            if wiki_url.endswith(".wiki.git"):
+                break
+            console.print(
+                "[red]✗ URL should end with .wiki.git. "
+                "Example: https://gitlab.com/group/project.wiki.git[/red]"
+            )
+
+        parsed = urlparse(wiki_url)
+        gitlab_host = f"{parsed.scheme}://{parsed.netloc}"
+        console.print("\nGitLab Personal Access Token:")
+        console.print(f"  Get it here → {gitlab_host}/-/user_settings/personal_access_tokens")
+        console.print("  Required scopes: read_repository  write_repository\n")
+
+        while True:
+            token = input("Paste your token: ").strip()
+            if token:
+                break
+            console.print("[red]✗ Token cannot be empty.[/red]")
+
+        append_env_var(repo_root, "GITLAB_TOKEN", token)
+        console.print(
+            "[green]✓ Token saved to .env (this file will NOT be committed to git)[/green]"
+        )
+        gitlab_token_env = "GITLAB_TOKEN"
+
+    # ── Write config ──────────────────────────────────────────────────────────
+    from docwright.config import CONFIG_DIR, CONFIG_FILE
+
+    config_dir = repo_root / CONFIG_DIR
+    config_dir.mkdir(parents=True, exist_ok=True)
+    config_path = config_dir / CONFIG_FILE
+
+    provider_section: dict[str, object] = {
+        "type": provider,
+        "model": model,
+    }
+    if api_key_env:
+        provider_section["api_key_env"] = api_key_env
+    if base_url:
+        provider_section["base_url"] = base_url
+
+    output_section: dict[str, object] = {"mode": output_mode}
+    if wiki_url:
+        output_section["wiki_url"] = wiki_url
+    if gitlab_token_env:
+        output_section["token_env"] = gitlab_token_env
+
+    config_data: dict[str, object] = {
+        "provider": provider_section,
+        "output": output_section,
+        "language": language,
+    }
+
+    config_path.write_text(yaml.dump(config_data, default_flow_style=False, allow_unicode=True))
+
+    console.print()
+    console.rule()
+    console.print(f"[green]✓ Config saved to {config_path.relative_to(repo_root)}[/green]")
+    console.print("\nStarting documentation generation...")
+    console.rule()
+
+
+@click.group()
+def cli() -> None:
+    """AI-powered documentation agent."""
+
+
+@cli.command()
+def init() -> None:
+    """Generate documentation from scratch."""
+    repo_root = get_repo_root()
+    Config.migrate_if_needed(repo_root)
+    from docwright.config import CONFIG_DIR, CONFIG_FILE
+
+    config_exists = (repo_root / CONFIG_DIR / CONFIG_FILE).exists()
+    if not config_exists:
+        run_interactive_setup(repo_root)
+    engine = build_engine(repo_root)
+    asyncio.run(engine.init())
+    click.echo("Documentation initialized.")
+
+
+@cli.command()
+@click.option("--dry-run", is_flag=True, help="Show what would change without writing files.")
+def run(dry_run: bool) -> None:
+    """Incrementally update documentation based on recent git diff."""
+    repo_root = get_repo_root()
+    Config.migrate_if_needed(repo_root)
+    base_sha = os.environ.get("AI_DOCGEN_BASE_SHA", "HEAD~1")
+    try:
+        diff_text = subprocess.check_output(
+            ["git", "diff", f"{base_sha}..HEAD"], cwd=repo_root
+        ).decode()
+    except subprocess.CalledProcessError:
+        diff_text = ""
+    if dry_run:
+        config = Config.load(repo_root)
+        triggers = config.triggers
+        from docwright.analyzer import DiffAnalyzer
+
+        analyzer = DiffAnalyzer(
+            diff_text=diff_text,
+            trigger_paths=triggers.paths if triggers else [],
+            ignore_paths=triggers.ignore if triggers else [],
+        )
+        if analyzer.has_relevant_changes():
+            click.echo("Relevant changes detected — documentation would be updated.")
+        else:
+            click.echo("No relevant changes — documentation would be skipped.")
+        return
+    engine = build_engine(repo_root)
+    skipped = asyncio.run(engine.run(diff_text=diff_text))
+    click.echo(
+        "No relevant changes — documentation up to date." if skipped else "Documentation updated."
+    )
+
+
+@cli.command()
+def sync() -> None:
+    """Force re-sync all documentation against current templates."""
+    repo_root = get_repo_root()
+    Config.migrate_if_needed(repo_root)
+    engine = build_engine(repo_root)
+    asyncio.run(engine.sync())
+    click.echo("Documentation synced.")
+
+
+@cli.command("install")
+@click.option("--auto", is_flag=True, help="Non-interactive mode with auto-detected defaults.")
+@click.option("--provider", default=None, type=click.Choice(["claude", "openai", "ollama"]))
+@click.option("--output", "output_mode", default=None, type=click.Choice(["pr", "direct"]))
+def install(auto: bool, provider: str | None, output_mode: str | None) -> None:
+    """Bootstrap this repo with docwright configuration."""
+    from docwright.scaffolder import Scaffolder
+
+    repo_root = get_repo_root()
+    scaffolder = Scaffolder(repo_root=repo_root)
+    profile = scaffolder.detect_profile()
+
+    if auto:
+        final_provider = provider or "claude"
+        final_output = output_mode or "pr"
+    else:
+        click.echo(
+            f"Detected: {profile.language} project '{profile.service_name}', CI: {profile.ci}"
+        )
+        final_provider = provider or click.prompt(
+            "LLM provider",
+            type=click.Choice(["claude", "openai", "ollama"]),
+            default="claude",
+        )
+        final_output = output_mode or click.prompt(
+            "Output mode",
+            type=click.Choice(["pr", "direct"]),
+            default="pr",
+        )
+
+    scaffolder.generate(profile, provider_type=final_provider, output_mode=final_output)
+    click.echo(f"Installed docwright for '{profile.service_name}'.")
+    click.echo("Next: set your API key env var, then run 'make docs'.")
+
+
+@cli.command()
+@click.option("--registry", "registry_path", default=None, help="Path to registry.yml")
+def dashboard(registry_path: str | None) -> None:
+    """Show status of all registered projects."""
+    from docwright.reporters.terminal import render_dashboard
+
+    path = Path(registry_path) if registry_path else Path.cwd() / ".docwright" / "registry.yml"
+    render_dashboard(path)
+
+
+@cli.command()
+@click.option("--registry", "registry_path", default=None, help="Path to registry.yml")
+@click.option("--output", "output_file", default="docwright-report.html", help="Output HTML file")
+def report(registry_path: str | None, output_file: str) -> None:
+    """Generate a static HTML status report."""
+    from docwright.reporters.html import render_html_report
+
+    reg_path = Path(registry_path) if registry_path else Path.cwd() / ".docwright" / "registry.yml"
+    render_html_report(reg_path, Path(output_file))
+    click.echo(f"Report saved to {output_file}")

{docwright-0.1.5 → docwright-0.1.7}/docwright/config.py

@@ -6,8 +6,8 @@ from typing import Literal
 import yaml
 from pydantic import BaseModel, Field
 
-CONFIG_DIR = ".ai-docgen"
-CONFIG_FILE = "ai-docgen.yml"
+CONFIG_DIR = ".docwright"
+CONFIG_FILE = "docwright.yml"
 INITIALIZED_MARKER = ".initialized"
 
 
@@ -19,14 +19,16 @@ class ProviderConfig(BaseModel):
 
 
 class OutputConfig(BaseModel):
-    mode: Literal["direct", "pr"] = "pr"
+    mode: str = "direct"
     pr_title: str = "docs: auto-update documentation"
     branch_prefix: str = "docs/auto-"
+    wiki_url: str | None = None
+    token_env: str | None = None
 
 
 class TemplatesConfig(BaseModel):
     source: Literal["builtin", "local"] = "builtin"
-    local_path: str = ".ai-docgen/templates"
+    local_path: str = ".docwright/templates"
 
 
 class TriggersConfig(BaseModel):
@@ -41,7 +43,7 @@ class DocumentConfig(BaseModel):
 
 
 class RegistryConfig(BaseModel):
-    path: str = "../.ai-docgen/registry.yml"
+    path: str = "../.docwright/registry.yml"
 
 
 class Config(BaseModel):
@@ -53,6 +55,16 @@ class Config(BaseModel):
     registry: RegistryConfig = Field(default_factory=RegistryConfig)
     language: str = "en"
 
+    @classmethod
+    def migrate_if_needed(cls, repo_root: Path) -> None:
+        old = repo_root / ".ai-docgen"
+        new = repo_root / ".docwright"
+        if old.exists() and not new.exists():
+            old.rename(new)
+            from rich.console import Console
+
+            Console().print("[yellow]⚠ Migrated .ai-docgen → .docwright[/yellow]")
+
     @classmethod
     def load(cls, repo_root: Path) -> Config:
         config_path = repo_root / CONFIG_DIR / CONFIG_FILE

docwright-0.1.7/docwright/outputs/factory.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from docwright.config import OutputConfig
+from docwright.outputs.base import Output
+from docwright.outputs.direct import DirectOutput
+from docwright.outputs.pull_request import PullRequestOutput
+
+
+def build_output(config: OutputConfig, repo_root: Path) -> Output:
+    if config.mode == "direct":
+        return DirectOutput(repo_root=repo_root)
+    elif config.mode == "gitlab_wiki":
+        token = os.getenv(config.token_env or "CI_JOB_TOKEN", "")
+        if not token:
+            raise OSError("GitLab token not found. Set CI_JOB_TOKEN or configure token_env.")
+        if not config.wiki_url:
+            raise ValueError("output.wiki_url is required for gitlab_wiki mode.")
+        from docwright.outputs.gitlab_wiki import GitLabWikiOutput
+
+        return GitLabWikiOutput(wiki_url=config.wiki_url, token=token, repo_root=repo_root)
+    return PullRequestOutput(repo_root=repo_root, config=config)

docwright-0.1.7/docwright/outputs/gitlab_wiki.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import shutil
+import tempfile
+from pathlib import Path
+from urllib.parse import urlparse, urlunparse
+
+from git import Repo
+
+from docwright.outputs.base import Output
+
+
+class GitLabWikiOutput(Output):
+    def __init__(self, wiki_url: str, token: str, repo_root: Path) -> None:
+        self.wiki_url = wiki_url
+        self.token = token
+        self.repo_root = repo_root
+
+    def build_auth_url(self) -> str:
+        parsed = urlparse(self.wiki_url)
+        auth_netloc = f"oauth2:{self.token}@{parsed.netloc}"
+        return urlunparse(parsed._replace(netloc=auth_netloc))
+
+    def apply(self, changed_files: list[Path], message: str) -> None:
+        auth_url = self.build_auth_url()
+        tmp_dir = tempfile.mkdtemp()
+        try:
+            repo = Repo.clone_from(auth_url, tmp_dir)
+            for file in changed_files:
+                dest = Path(tmp_dir) / file.name
+                dest.write_bytes(file.read_bytes())
+            repo.index.add("*")
+            repo.index.commit(message)
+            repo.remotes.origin.push()
+        finally:
+            shutil.rmtree(tmp_dir, ignore_errors=True)

{docwright-0.1.5 → docwright-0.1.7}/docwright/scaffolder.py

@@ -28,8 +28,8 @@ jobs:
       - uses: actions/setup-python@v5
         with:
           python-version: "3.12"
-      - run: pip install ai-docgen
-      - run: ai-docgen run
+      - run: pip install docwright
+      - run: docwright run
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
           OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
@@ -43,21 +43,21 @@ docs:
   stage: docs
   image: python:3.12
   script:
-    - pip install ai-docgen
-    - ai-docgen run
+    - pip install docwright
+    - docwright run
   variables:
     AI_DOCGEN_BASE_SHA: $CI_MERGE_REQUEST_DIFF_BASE_SHA
 """
 
 MAKEFILE_TARGETS = """
 docs:  ## init if not initialized, otherwise update
-\tai-docgen run
+\tdocwright run
 
 docs-sync:  ## force re-sync all docs against current templates
-\tai-docgen sync
+\tdocwright sync
 
 docs-check:  ## dry-run: show what would change
-\tai-docgen run --dry-run
+\tdocwright run --dry-run
 """
 
 
@@ -114,9 +114,9 @@ class Scaffolder:
         self.write_ci_workflow(profile)
 
     def write_config(self, provider_type: str, output_mode: str) -> None:
-        config_dir = self.repo_root / ".ai-docgen"
+        config_dir = self.repo_root / ".docwright"
         config_dir.mkdir(parents=True, exist_ok=True)
-        config_file = config_dir / "ai-docgen.yml"
+        config_file = config_dir / "docwright.yml"
         if config_file.exists():
             return
         api_key_env = {
@@ -138,7 +138,7 @@ class Scaffolder:
             "documents": [
                 {"type": "readme", "template": "readme/default", "target": "README.md"},
             ],
-            "registry": {"path": "../.ai-docgen/registry.yml"},
+            "registry": {"path": "../.docwright/registry.yml"},
         }
         config_file.write_text(yaml.dump(config, default_flow_style=False, allow_unicode=True))
 
@@ -159,5 +159,5 @@ class Scaffolder:
         elif profile.ci == "gitlab":
             gitlab_ci = self.repo_root / ".gitlab-ci.yml"
             content = gitlab_ci.read_text() if gitlab_ci.exists() else ""
-            if "ai-docgen run" not in content:
+            if "docwright run" not in content:
                 gitlab_ci.write_text(content + GITLAB_CI_BLOCK)

{docwright-0.1.5 → docwright-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "docwright"
-version = "0.1.5"
+version = "0.1.7"
 description = "AI-powered documentation agent: auto-generates and maintains README & wiki on every commit"
 authors = ["Artem Gotlib <gotlib.artem.m@gmail.com>"]
 license = "MIT"

docwright-0.1.5/docwright/cli.py

@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import os
-import subprocess
-from pathlib import Path
-
-import click
-
-from docwright.config import Config
-from docwright.engine import DocsEngine
-from docwright.outputs.factory import build_output
-from docwright.providers.factory import build_provider
-
-
-def get_repo_root() -> Path:
-    return Path.cwd()
-
-
-def build_engine(repo_root: Path) -> DocsEngine:
-    config = Config.load(repo_root)
-    provider = build_provider(config.provider)
-    output = build_output(config.output, repo_root)
-    return DocsEngine(repo_root=repo_root, provider=provider, output=output)
-
-
-@click.group()
-def cli() -> None:
-    """AI-powered documentation agent."""
-
-
-@cli.command()
-def init() -> None:
-    """Generate documentation from scratch."""
-    engine = build_engine(get_repo_root())
-    asyncio.run(engine.init())
-    click.echo("Documentation initialized.")
-
-
-@cli.command()
-@click.option("--dry-run", is_flag=True, help="Show what would change without writing files.")
-def run(dry_run: bool) -> None:
-    """Incrementally update documentation based on recent git diff."""
-    repo_root = get_repo_root()
-    base_sha = os.environ.get("AI_DOCGEN_BASE_SHA", "HEAD~1")
-    try:
-        diff_text = subprocess.check_output(
-            ["git", "diff", f"{base_sha}..HEAD"], cwd=repo_root
-        ).decode()
-    except subprocess.CalledProcessError:
-        diff_text = ""
-    if dry_run:
-        config = Config.load(repo_root)
-        triggers = config.triggers
-        from docwright.analyzer import DiffAnalyzer
-
-        analyzer = DiffAnalyzer(
-            diff_text=diff_text,
-            trigger_paths=triggers.paths if triggers else [],
-            ignore_paths=triggers.ignore if triggers else [],
-        )
-        if analyzer.has_relevant_changes():
-            click.echo("Relevant changes detected — documentation would be updated.")
-        else:
-            click.echo("No relevant changes — documentation would be skipped.")
-        return
-    engine = build_engine(repo_root)
-    skipped = asyncio.run(engine.run(diff_text=diff_text))
-    click.echo(
-        "No relevant changes — documentation up to date." if skipped else "Documentation updated."
-    )
-
-
-@cli.command()
-def sync() -> None:
-    """Force re-sync all documentation against current templates."""
-    engine = build_engine(get_repo_root())
-    asyncio.run(engine.sync())
-    click.echo("Documentation synced.")
-
-
-@cli.command("install")
-@click.option("--auto", is_flag=True, help="Non-interactive mode with auto-detected defaults.")
-@click.option("--provider", default=None, type=click.Choice(["claude", "openai", "ollama"]))
-@click.option("--output", "output_mode", default=None, type=click.Choice(["pr", "direct"]))
-def install(auto: bool, provider: str | None, output_mode: str | None) -> None:
-    """Bootstrap this repo with ai-docgen configuration."""
-    from docwright.scaffolder import Scaffolder
-
-    repo_root = get_repo_root()
-    scaffolder = Scaffolder(repo_root=repo_root)
-    profile = scaffolder.detect_profile()
-
-    if auto:
-        final_provider = provider or "claude"
-        final_output = output_mode or "pr"
-    else:
-        click.echo(
-            f"Detected: {profile.language} project '{profile.service_name}', CI: {profile.ci}"
-        )
-        final_provider = provider or click.prompt(
-            "LLM provider",
-            type=click.Choice(["claude", "openai", "ollama"]),
-            default="claude",
-        )
-        final_output = output_mode or click.prompt(
-            "Output mode",
-            type=click.Choice(["pr", "direct"]),
-            default="pr",
-        )
-
-    scaffolder.generate(profile, provider_type=final_provider, output_mode=final_output)
-    click.echo(f"Installed ai-docgen for '{profile.service_name}'.")
-    click.echo("Next: set your API key env var, then run 'make docs'.")
-
-
-@cli.command()
-@click.option("--registry", "registry_path", default=None, help="Path to registry.yml")
-def dashboard(registry_path: str | None) -> None:
-    """Show status of all registered projects."""
-    from docwright.reporters.terminal import render_dashboard
-
-    path = Path(registry_path) if registry_path else Path.cwd() / ".ai-docgen" / "registry.yml"
-    render_dashboard(path)
-
-
-@cli.command()
-@click.option("--registry", "registry_path", default=None, help="Path to registry.yml")
-@click.option("--output", "output_file", default="ai-docgen-report.html", help="Output HTML file")
-def report(registry_path: str | None, output_file: str) -> None:
-    """Generate a static HTML status report."""
-    from docwright.reporters.html import render_html_report
-
-    reg_path = Path(registry_path) if registry_path else Path.cwd() / ".ai-docgen" / "registry.yml"
-    render_html_report(reg_path, Path(output_file))
-    click.echo(f"Report saved to {output_file}")

docwright-0.1.5/docwright/outputs/factory.py

@@ -1,12 +0,0 @@
-from pathlib import Path
-
-from docwright.config import OutputConfig
-from docwright.outputs.base import Output
-from docwright.outputs.direct import DirectOutput
-from docwright.outputs.pull_request import PullRequestOutput
-
-
-def build_output(config: OutputConfig, repo_root: Path) -> Output:
-    if config.mode == "direct":
-        return DirectOutput(repo_root=repo_root)
-    return PullRequestOutput(repo_root=repo_root, config=config)