anyscribecli 0.3.1__py3-none-any.whl

anyscribecli/__init__.py

@@ -0,0 +1,3 @@
+"""anyscribecli — download, transcribe, and convert video/audio to structured markdown."""
+
+__version__ = "0.3.1"

anyscribecli/cli/batch.py

@@ -0,0 +1,160 @@
+"""Batch processing command — transcribe multiple URLs from a file."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, MofNCompleteColumn
+from rich.table import Table
+
+from anyscribecli.config.settings import load_config, load_env
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def batch(
+    file: Path = typer.Argument(..., help="File containing URLs (one per line)."),
+    provider: str | None = typer.Option(None, "--provider", "-p", help="Override provider."),
+    language: str | None = typer.Option(None, "--language", "-l", help="Override language."),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output results as JSON."),
+    keep_media: bool = typer.Option(False, "--keep-media", help="Keep audio files."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress progress."),
+    stop_on_error: bool = typer.Option(False, "--stop-on-error", help="Stop at first failure."),
+) -> None:
+    """[bold magenta]Batch transcribe[/bold magenta] URLs from a file.
+
+    Reads a file with one URL per line (blank lines and #comments are skipped).
+    Processes each URL sequentially and reports results.
+    """
+    if not file.exists():
+        err_console.print(f"[red]File not found:[/red] {file}")
+        raise typer.Exit(code=1)
+
+    # Parse URLs from file
+    urls: list[str] = []
+    for line in file.read_text().splitlines():
+        line = line.strip()
+        if line and not line.startswith("#"):
+            urls.append(line)
+
+    if not urls:
+        err_console.print("[yellow]No URLs found in file.[/yellow]")
+        raise typer.Exit()
+
+    load_env()
+    settings = load_config()
+    if provider:
+        settings.provider = provider
+    if language:
+        settings.language = language
+    if keep_media:
+        settings.keep_media = True
+
+    results: list[dict] = []
+    succeeded = 0
+    failed = 0
+
+    if quiet or output_json:
+        # No progress display
+        for url in urls:
+            succeeded, failed = _process_url(
+                url, settings, results, succeeded, failed, quiet=True
+            )
+            if failed and stop_on_error:
+                break
+    else:
+        # Rich progress bar
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[bold]{task.description}"),
+            BarColumn(),
+            MofNCompleteColumn(),
+            console=err_console,
+        ) as progress:
+            task = progress.add_task("Transcribing", total=len(urls))
+
+            for url in urls:
+                progress.update(task, description=f"[bold]{_shorten_url(url)}")
+                succeeded, failed = _process_url(
+                    url, settings, results, succeeded, failed, quiet=True
+                )
+                progress.advance(task)
+                if failed and stop_on_error:
+                    err_console.print("[red]Stopping on error (--stop-on-error).[/red]")
+                    break
+
+    # Summary
+    if output_json:
+        json.dump({
+            "total": len(urls),
+            "succeeded": succeeded,
+            "failed": failed,
+            "results": results,
+        }, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        console.print(f"\n[bold]Batch complete:[/bold] {succeeded} succeeded, {failed} failed, {len(urls)} total")
+
+        if results:
+            table = Table(title="Results")
+            table.add_column("#", style="dim")
+            table.add_column("Status")
+            table.add_column("Title / Error")
+
+            for i, r in enumerate(results, 1):
+                if r["success"]:
+                    table.add_row(str(i), "[green]OK[/green]", r["title"])
+                else:
+                    table.add_row(str(i), "[red]FAIL[/red]", r["error"][:80])
+
+            console.print(table)
+
+    if failed > 0:
+        raise typer.Exit(code=1)
+
+
+def _shorten_url(url: str, max_len: int = 50) -> str:
+    """Shorten a URL for display in progress bar."""
+    url = url.replace("https://", "").replace("http://", "").replace("www.", "")
+    if len(url) > max_len:
+        return url[: max_len - 3] + "..."
+    return url
+
+
+def _process_url(
+    url: str,
+    settings,
+    results: list[dict],
+    succeeded: int,
+    failed: int,
+    quiet: bool,
+) -> tuple[int, int]:
+    """Process a single URL, append to results. Returns (succeeded, failed)."""
+    from anyscribecli.core.orchestrator import process
+
+    try:
+        result = process(url, settings, quiet=quiet)
+        succeeded += 1
+        results.append({
+            "success": True,
+            "url": url,
+            "file": str(result.file_path),
+            "title": result.title,
+            "platform": result.platform,
+            "duration": result.duration,
+            "language": result.language,
+            "word_count": result.word_count,
+        })
+    except Exception as e:
+        failed += 1
+        results.append({
+            "success": False,
+            "url": url,
+            "error": str(e),
+        })
+    return succeeded, failed

anyscribecli/cli/config_cmd.py

@@ -0,0 +1,187 @@
+"""Config and providers CLI commands."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from typing import Optional
+
+import typer
+import yaml
+from rich.console import Console
+from rich.table import Table
+
+from anyscribecli.config.paths import CONFIG_FILE
+from anyscribecli.config.settings import load_config, save_config, load_env
+from anyscribecli.providers import list_providers, get_provider
+
+console = Console()
+err_console = Console(stderr=True)
+
+# ── Config subcommands ────────────────────────────────────────
+
+config_app = typer.Typer(
+    name="config",
+    help="View and change ascli settings.",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+
+@config_app.command("show")
+def config_show(
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON."),
+) -> None:
+    """[bold]Show[/bold] current configuration."""
+    settings = load_config()
+    data = settings.to_dict()
+
+    if output_json:
+        json.dump(data, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        console.print(f"[dim]Config file: {CONFIG_FILE}[/dim]\n")
+        console.print(yaml.dump(data, default_flow_style=False, sort_keys=False).strip())
+
+
+@config_app.command("set")
+def config_set(
+    key: str = typer.Argument(..., help="Setting key (e.g., 'provider', 'language', 'instagram.username')."),
+    value: str = typer.Argument(..., help="New value."),
+) -> None:
+    """[bold]Change[/bold] a configuration setting.
+
+    Use dot-notation for nested keys: `ascli config set instagram.username myuser`
+    """
+    settings = load_config()
+    data = settings.to_dict()
+
+    # Handle dot-notation (e.g., instagram.username)
+    keys = key.split(".")
+    target = data
+    for k in keys[:-1]:
+        if k not in target or not isinstance(target[k], dict):
+            err_console.print(f"[red]Invalid key: {key}[/red]")
+            raise typer.Exit(code=1)
+        target = target[k]
+
+    final_key = keys[-1]
+    if final_key not in target:
+        err_console.print(f"[red]Unknown key: {key}[/red]")
+        err_console.print(f"Available: {', '.join(_flat_keys(settings.to_dict()))}")
+        raise typer.Exit(code=1)
+
+    # Type coercion
+    old_value = target[final_key]
+    if isinstance(old_value, bool):
+        value_typed = value.lower() in ("true", "1", "yes")
+    elif isinstance(old_value, int):
+        value_typed = int(value)
+    else:
+        value_typed = value
+
+    target[final_key] = value_typed
+
+    from anyscribecli.config.settings import Settings
+    new_settings = Settings.from_dict(data)
+    save_config(new_settings)
+    console.print(f"[green]Set[/green] {key} = {value_typed}")
+
+
+@config_app.command("path")
+def config_path() -> None:
+    """[bold]Print[/bold] the config file location."""
+    console.print(str(CONFIG_FILE))
+
+
+def _flat_keys(d: dict, prefix: str = "") -> list[str]:
+    """Flatten a dict into dot-notation keys."""
+    keys = []
+    for k, v in d.items():
+        full = f"{prefix}{k}" if not prefix else f"{prefix}.{k}"
+        if isinstance(v, dict):
+            keys.extend(_flat_keys(v, full))
+        else:
+            keys.append(full)
+    return keys
+
+
+# ── Providers subcommands ─────────────────────────────────────
+
+providers_app = typer.Typer(
+    name="providers",
+    help="Manage transcription providers.",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+
+@providers_app.command("list")
+def providers_list(
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output as JSON."),
+) -> None:
+    """[bold]List[/bold] available transcription providers."""
+    settings = load_config()
+    active = settings.provider
+    providers = list_providers()
+
+    if output_json:
+        result = [
+            {"name": p, "active": p == active}
+            for p in providers
+        ]
+        json.dump(result, sys.stdout, indent=2)
+        sys.stdout.write("\n")
+    else:
+        table = Table(title="Transcription Providers")
+        table.add_column("Provider", style="bold")
+        table.add_column("Status")
+        table.add_column("Active")
+
+        for p in providers:
+            is_active = "[green]Active[/green]" if p == active else ""
+            table.add_row(p, "Available", is_active)
+
+        console.print(table)
+        console.print("\n[dim]Change with: ascli config set provider <name>[/dim]")
+
+
+@providers_app.command("test")
+def providers_test(
+    name: Optional[str] = typer.Argument(None, help="Provider to test (default: active provider)."),
+) -> None:
+    """[bold]Test[/bold] a provider's API key and connectivity."""
+    load_env()
+    settings = load_config()
+    provider_name = name or settings.provider
+
+    console.print(f"Testing provider: [bold]{provider_name}[/bold]")
+
+    try:
+        provider = get_provider(provider_name)
+    except ValueError as e:
+        err_console.print(f"[red]{e}[/red]")
+        raise typer.Exit(code=1)
+
+    # Check if API key is set
+    key_map = {
+        "openai": "OPENAI_API_KEY",
+        "openrouter": "OPENROUTER_API_KEY",
+        "elevenlabs": "ELEVENLABS_API_KEY",
+        "sargam": "SARGAM_API_KEY",
+    }
+    env_var = key_map.get(provider_name)
+    if env_var:
+        if os.environ.get(env_var):
+            console.print(f"  API key ({env_var}): [green]Set[/green]")
+        else:
+            console.print(f"  API key ({env_var}): [red]Not set[/red]")
+            console.print("  Add it to ~/.anyscribecli/.env")
+            raise typer.Exit(code=1)
+
+    if provider_name == "local":
+        console.print("  [green]Local provider — no API key needed.[/green]")
+
+    console.print(f"  Provider class: {provider.__class__.__name__}")
+    console.print("  [green]Provider loaded successfully.[/green]")

anyscribecli/cli/download.py

@@ -0,0 +1,160 @@
+"""Download command — download video only, no transcription."""
+
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from anyscribecli.config.paths import TMP_DIR, VIDEO_DIR, AUDIO_DIR
+from anyscribecli.config.settings import load_env
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def download(
+    url: Optional[str] = typer.Argument(None, help="YouTube or Instagram URL to download."),
+    video: bool = typer.Option(True, "--video/--audio-only", help="Download video (default) or audio only."),
+    output_json: bool = typer.Option(False, "--json", "-j", help="Output result as JSON."),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Suppress progress output."),
+    clipboard: bool = typer.Option(False, "--clipboard", "-c", help="Read URL from clipboard."),
+) -> None:
+    """[bold green]Download[/bold green] video or audio from a URL — no transcription.
+
+    Saves to ~/.anyscribecli/media/video/ or ~/.anyscribecli/media/audio/.
+
+    [dim]Tip: Wrap URLs in quotes to avoid shell issues.[/dim]
+    """
+    from anyscribecli.cli.transcribe import _read_clipboard, _validate_url
+    from anyscribecli.downloaders.registry import get_downloader, detect_platform
+
+    # Resolve URL
+    if clipboard:
+        url = _read_clipboard()
+        if not url:
+            err_console.print("[red]Error:[/red] No URL found in clipboard.")
+            raise typer.Exit(code=1)
+
+    if not url:
+        console.print("  Paste a YouTube or Instagram URL:")
+        url = typer.prompt("  URL")
+
+    if not url:
+        err_console.print("[red]Error:[/red] No URL provided.")
+        raise typer.Exit(code=1)
+
+    url = _validate_url(url)
+    load_env()
+
+    from datetime import date
+    from anyscribecli.vault.writer import slugify
+
+    TMP_DIR.mkdir(parents=True, exist_ok=True)
+    tmp_dir = Path(tempfile.mkdtemp(dir=TMP_DIR))
+
+    try:
+        if not quiet:
+            err_console.print("[bold blue]Downloading...[/bold blue]")
+
+        downloader = get_downloader(url)
+        platform = detect_platform(url)
+
+        if video:
+            # Download full video
+            result = _download_video(url, platform, tmp_dir, quiet)
+        else:
+            # Download audio only (same as transcribe pipeline)
+            dl_result = downloader.download(url, tmp_dir)
+            today = date.today().isoformat()
+            slug = slugify(dl_result.title) or "untitled"
+            dest_dir = AUDIO_DIR / platform / today
+            dest_dir.mkdir(parents=True, exist_ok=True)
+            dest = dest_dir / f"{slug}{dl_result.audio_path.suffix}"
+            shutil.copy2(dl_result.audio_path, dest)
+            result = {
+                "file": str(dest),
+                "title": dl_result.title,
+                "platform": platform,
+                "type": "audio",
+                "duration": dl_result.duration,
+            }
+
+        if output_json:
+            json.dump({"success": True, **result}, sys.stdout, indent=2)
+            sys.stdout.write("\n")
+        else:
+            console.print(f"\n[green]Downloaded:[/green] {result['file']}")
+            console.print(f"  Title: {result['title']}")
+            console.print(f"  Type:  {result['type']}")
+
+    except Exception as e:
+        if output_json:
+            json.dump({"success": False, "error": str(e)}, sys.stdout, indent=2)
+            sys.stdout.write("\n")
+        else:
+            err_console.print(f"[red]Error:[/red] {e}")
+        raise typer.Exit(code=1)
+    finally:
+        if tmp_dir.exists():
+            shutil.rmtree(tmp_dir, ignore_errors=True)
+
+
+def _download_video(url: str, platform: str, tmp_dir: Path, quiet: bool) -> dict:
+    """Download full video using yt-dlp (works for both YouTube and Instagram)."""
+    from datetime import date
+    from anyscribecli.vault.writer import slugify
+
+    # yt-dlp can handle both YouTube and Instagram video URLs
+    output_template = str(tmp_dir / "%(title).80s.%(ext)s")
+    cmd = [
+        "yt-dlp",
+        "--format", "bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best",
+        "--merge-output-format", "mp4",
+        "--output", output_template,
+        "--no-playlist",
+        "--print-json",
+    ]
+    if quiet:
+        cmd.append("--quiet")
+    cmd.append(url)
+
+    result = subprocess.run(cmd, capture_output=True, text=True, timeout=600)
+    if result.returncode != 0:
+        raise RuntimeError(f"Download failed: {result.stderr.strip()[:300]}")
+
+    import json as _json
+    metadata = _json.loads(result.stdout.split("\n")[0])
+    title = metadata.get("title", "untitled")
+
+    # Find the downloaded video
+    video_files = list(tmp_dir.glob("*.mp4")) + list(tmp_dir.glob("*.mkv")) + list(tmp_dir.glob("*.webm"))
+    if not video_files:
+        raise RuntimeError("Download completed but no video file found.")
+    video_path = video_files[0]
+
+    # Move to media/video/<platform>/YYYY-MM-DD/<slug>.mp4
+    today = date.today().isoformat()
+    slug = slugify(title) or "untitled"
+    dest_dir = VIDEO_DIR / platform / today
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / f"{slug}{video_path.suffix}"
+    shutil.move(str(video_path), str(dest))
+
+    if not quiet:
+        err_console.print(f"  [green]Saved:[/green] {title}")
+
+    return {
+        "file": str(dest),
+        "title": title,
+        "platform": platform,
+        "type": "video",
+        "duration": metadata.get("duration"),
+    }

anyscribecli/cli/main.py

@@ -0,0 +1,122 @@
+"""ascli — main CLI entry point."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from anyscribecli import __version__
+
+app = typer.Typer(
+    name="ascli",
+    help="Download, transcribe, and convert video/audio to structured markdown.",
+    rich_markup_mode="rich",
+    no_args_is_help=True,
+)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def version_callback(value: bool) -> None:
+    if value:
+        console.print(f"ascli v{__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: Optional[bool] = typer.Option(
+        None,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=version_callback,
+        is_eager=True,
+    ),
+) -> None:
+    """[bold]ascli[/bold] — download, transcribe, and convert video/audio to structured markdown."""
+
+
+# Register commands
+from anyscribecli.cli.onboard import onboard  # noqa: E402
+from anyscribecli.cli.transcribe import transcribe  # noqa: E402
+from anyscribecli.cli.config_cmd import config_app, providers_app  # noqa: E402
+from anyscribecli.cli.batch import batch  # noqa: E402
+from anyscribecli.cli.download import download  # noqa: E402
+
+app.command()(onboard)
+app.command()(transcribe)
+app.command()(batch)
+app.command()(download)
+app.add_typer(config_app, name="config")
+app.add_typer(providers_app, name="providers")
+
+
+@app.command()
+def update(
+    force: bool = typer.Option(False, "--force", "-f", help="Force update even with local changes."),
+    check: bool = typer.Option(False, "--check", "-c", help="Only check for updates, don't install."),
+) -> None:
+    """[bold yellow]Update[/bold yellow] ascli to the latest version.
+
+    Pulls the latest changes from git and reinstalls the package.
+    """
+    from anyscribecli.core.updater import check_for_updates, update as do_update
+
+    if check:
+        check_for_updates(quiet=False)
+    else:
+        success = do_update(force=force)
+        if not success:
+            raise typer.Exit(code=1)
+
+
+@app.command()
+def doctor() -> None:
+    """[bold]Check[/bold] system health — dependencies, config, and workspace.
+
+    Runs all diagnostic checks and reports status.
+    """
+    from anyscribecli.core.deps import check_dependencies, print_dependency_status
+    from anyscribecli.config.paths import APP_HOME, CONFIG_FILE, ENV_FILE, WORKSPACE_DIR
+    from anyscribecli.core.updater import get_install_path, check_for_updates
+
+    console.print("[bold]ascli doctor[/bold]\n")
+
+    # Dependencies
+    console.print("[bold]1. System Dependencies[/bold]\n")
+    results = check_dependencies()
+    print_dependency_status(results)
+
+    # Config
+    console.print("\n[bold]2. Configuration[/bold]\n")
+    checks = [
+        ("App directory", APP_HOME.exists()),
+        ("Config file", CONFIG_FILE.exists()),
+        ("API keys file", ENV_FILE.exists()),
+        ("Workspace vault", WORKSPACE_DIR.exists()),
+        ("Workspace index", (WORKSPACE_DIR / "_index.md").exists()),
+    ]
+    for name, ok in checks:
+        status = "[green]OK[/green]" if ok else "[red]Missing[/red]"
+        console.print(f"  {name}: {status}")
+
+    if not CONFIG_FILE.exists():
+        console.print("\n  [yellow]Run [bold]ascli onboard[/bold] to set up.[/yellow]")
+
+    # Install info
+    console.print("\n[bold]3. Installation[/bold]\n")
+    console.print(f"  Version: v{__version__}")
+    repo = get_install_path()
+    if repo:
+        console.print("  Install type: git (editable)")
+        console.print(f"  Repo path: {repo}")
+    else:
+        console.print("  Install type: pip package")
+
+    # Updates
+    console.print()
+    check_for_updates(quiet=True)