azathoth 0.0.1__py3-none-any.whl

azathoth/__init__.py

@@ -0,0 +1,20 @@
+"""
+Azathoth: AI Architect & Development Framework
+"""
+
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load .env from azathoth's own directory, not the cwd
+load_dotenv(Path(__file__).parent.parent.parent / ".env")
+
+from azathoth.cli import init_cli
+
+
+def main() -> None:
+    """Main entry point for the Azathoth CLI."""
+    init_cli()
+
+
+if __name__ == "__main__":
+    main()

azathoth/cli/__init__.py

@@ -0,0 +1,6 @@
+# cli/__init__.py — just re-export, nothing else
+from azathoth.cli.main import app
+
+
+def init_cli():
+    app()

azathoth/cli/commands/i18n.py

@@ -0,0 +1,273 @@
+import asyncio
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from azathoth.core.i18n import (
+    InlangConfig,
+    resolve_paths,
+    load_all_translations,
+    diff_against_base,
+    translate_locale,
+    merge_translations,
+    write_translations,
+    prune_orphans,
+    build_matrix,
+    export_registry,
+    import_registry,
+)
+from azathoth.core.exceptions import I18nError
+
+app = typer.Typer(help="i18n translation automation commands.")
+console = Console()
+
+
+@app.command()
+def translate(
+    settings_path: Path = typer.Argument(
+        ..., help="Path to project.inlang/settings.json"
+    ),
+    full: bool = typer.Option(
+        False, "--full", help="Retranslate all keys, not just missing ones."
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Preview changes without writing to files."
+    ),
+    prune: bool = typer.Option(
+        False, "--prune", help="Remove orphan keys from target files."
+    ),
+):
+    """Translate missing keys using AI."""
+    try:
+        config = InlangConfig.from_json(settings_path)
+        paths = resolve_paths(settings_path, config)
+        translations = load_all_translations(paths)
+
+        base_locale = config.base_locale
+        if base_locale not in translations:
+            console.print(
+                f"[red]Error: Base locale '{base_locale}' not found in translations.[/red]"
+            )
+            raise typer.Exit(1)
+
+        base_set = translations[base_locale]
+        target_locales = [l for l in config.locales if l != base_locale]
+
+        async def run_translations():
+            tasks = []
+            results = {}
+
+            with Progress(
+                SpinnerColumn(),
+                TextColumn("[progress.description]{task.description}"),
+                console=console,
+            ) as progress:
+                for locale in target_locales:
+                    target_set = translations.get(locale)
+                    diff = diff_against_base(base_set, target_set)
+
+                    keys_to_translate = diff.missing_keys
+                    if full:
+                        keys_to_translate = list(base_set.messages.keys())
+
+                    if not keys_to_translate:
+                        console.print(
+                            f"[yellow]Skipping {locale}: No keys to translate.[/yellow]"
+                        )
+                        continue
+
+                    values_to_translate = [
+                        base_set.messages[k] for k in keys_to_translate
+                    ]
+
+                    # Style samples (first 5 existing translations)
+                    samples = []
+                    existing_keys = [
+                        k for k in base_set.messages.keys() if k in target_set.messages
+                    ]
+                    for k in existing_keys[:5]:
+                        samples.append((base_set.messages[k], target_set.messages[k]))
+
+                    task_id = progress.add_task(
+                        description=f"Translating {locale} ({len(keys_to_translate)} keys)...",
+                        total=None,
+                    )
+
+                    async def do_translate(
+                        l=locale,
+                        k=keys_to_translate,
+                        v=values_to_translate,
+                        s=samples,
+                        t_id=task_id,
+                    ):
+                        try:
+                            res = await translate_locale(l, k, v, s)
+                            progress.update(
+                                t_id,
+                                completed=True,
+                                description=f"[green]Finished {l}[/green]",
+                            )
+                            return l, k, res
+                        except Exception as e:
+                            progress.update(
+                                t_id,
+                                completed=True,
+                                description=f"[red]Failed {l}[/red]",
+                            )
+                            return l, k, e
+
+                    tasks.append(do_translate())
+
+                if not tasks:
+                    console.print("[green]All translations up to date.[/green]")
+                    return
+
+                batch_results = await asyncio.gather(*tasks)
+                for locale, keys, result in batch_results:
+                    if isinstance(result, Exception):
+                        console.print(
+                            f"[red]Error translating {locale}: {str(result)}[/red]"
+                        )
+                    else:
+                        results[locale] = (keys, result)
+            return results
+
+        results = asyncio.run(run_translations())
+
+        if not results:
+            return
+
+        # Apply changes
+        for locale, (keys, values) in results.items():
+            target_set = translations[locale]
+            new_set = merge_translations(target_set, keys, values)
+
+            if prune:
+                new_set = prune_orphans(new_set, base_set)
+
+            if not dry_run:
+                write_translations(paths[locale], new_set)
+                console.print(f"[green]Updated {paths[locale]}[/green]")
+            else:
+                console.print(
+                    f"[yellow][DRY RUN] Would update {paths[locale]}[/yellow]"
+                )
+
+    except I18nError as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def audit(
+    settings_path: Path = typer.Argument(
+        ..., help="Path to project.inlang/settings.json"
+    ),
+):
+    """Display a translation coverage matrix."""
+    try:
+        config = InlangConfig.from_json(settings_path)
+        paths = resolve_paths(settings_path, config)
+        translations = load_all_translations(paths)
+
+        locales = config.locales
+        matrix = build_matrix(translations, locales)
+
+        table = Table(title="i18n Translation Audit")
+        table.add_column("Key", style="cyan", no_wrap=True)
+        for locale in locales:
+            table.add_column(locale, justify="center")
+
+        for key in matrix.keys:
+            row = [key]
+            for locale in locales:
+                val = matrix.matrix[key][locale]
+                if val:
+                    row.append("[green]✓[/green]")
+                else:
+                    row.append("[red]✗[/red]")
+            table.add_row(*row)
+
+        # Totals row
+        totals = ["TOTAL"]
+        for locale in locales:
+            count = sum(1 for k in matrix.keys if matrix.matrix[k][locale])
+            percent = (count / len(matrix.keys)) * 100 if matrix.keys else 0
+            color = "green" if percent == 100 else "yellow" if percent > 80 else "red"
+            totals.append(
+                f"[{color}]{count}/{len(matrix.keys)} ({percent:.0f}%)[/{color}]"
+            )
+        table.add_section()
+        table.add_row(*totals)
+
+        console.print(table)
+
+    except I18nError as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def export(
+    settings_path: Path = typer.Argument(
+        ..., help="Path to project.inlang/settings.json"
+    ),
+    output: Path = typer.Option(
+        "registry.json", "--output", "-o", help="Output file path."
+    ),
+    fmt: str = typer.Option("json", "--format", "-f", help="Export format (json, py)."),
+):
+    """Export all translations to a master registry file."""
+    try:
+        config = InlangConfig.from_json(settings_path)
+        paths = resolve_paths(settings_path, config)
+        translations = load_all_translations(paths)
+
+        matrix = build_matrix(translations, config.locales)
+        export_registry(matrix, output, fmt)
+        console.print(f"[green]Exported registry to {output}[/green]")
+
+    except I18nError as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def sync(
+    registry_path: Path = typer.Argument(..., help="Path to registry.json"),
+    settings_path: Path = typer.Argument(
+        ..., help="Path to project.inlang/settings.json"
+    ),
+):
+    """Sync a registry file back to individual locale files."""
+    try:
+        matrix = import_registry(registry_path)
+        config = InlangConfig.from_json(settings_path)
+        paths = resolve_paths(settings_path, config)
+
+        for locale in matrix.locales:
+            if locale not in paths:
+                console.print(
+                    f"[yellow]Warning: Locale '{locale}' in registry not found in config. Skipping.[/yellow]"
+                )
+                continue
+
+            messages = {}
+            for key in matrix.keys:
+                val = matrix.matrix[key].get(locale)
+                if val:
+                    messages[key] = val
+
+            write_translations(
+                paths[locale], TranslationSet(locale=locale, messages=messages)
+            )
+            console.print(f"[green]Synced {paths[locale]}[/green]")
+
+    except I18nError as e:
+        console.print(f"[red]Error: {str(e)}[/red]")
+        raise typer.Exit(1)

azathoth/cli/commands/ingest.py

@@ -0,0 +1,316 @@
+import asyncio
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+import typer
+from rich.console import Console, RenderableType
+from rich.panel import Panel
+from rich.table import Table
+from rich import box
+from rich.progress import (
+    Progress,
+    SpinnerColumn,
+    BarColumn,
+    TextColumn,
+    TimeElapsedColumn,
+    MofNCompleteColumn,
+    ProgressColumn,
+    Task,
+)
+from rich.text import Text
+
+from azathoth.config import config
+from azathoth.core.ingest import (
+    ingest,
+    IngestionResult,
+    detect_type,
+    IngestType,
+    fetch_user_repos,
+    get_subpath_context,
+)
+from azathoth.core.utils import format_size
+
+# --- AGGRESSIVE LOG SILENCING ---
+try:
+    from loguru import logger
+
+    logger.remove()
+    logger.disable("gitingest")
+except ImportError:
+    pass
+
+console = Console()
+app = typer.Typer(help="Ingest codebases into a single file.", no_args_is_help=True)
+
+
+class StatusSpinnerColumn(ProgressColumn):
+    """Morphs from spinner to ✓/✗ on completion."""
+
+    def __init__(self):
+        super().__init__()
+        self.spinner = SpinnerColumn(spinner_name="dots")
+
+    def render(self, task: "Task") -> RenderableType:
+        if task.finished:
+            icon = task.fields.get("status_icon", "[bold green]✓[/]")
+            return Text.from_markup(icon)
+        return self.spinner.render(task)
+
+
+def _display_info_panel(
+    target: str, detected_type: IngestType, mode: str, ignore_gitignore: bool = False
+):
+    """The blue info panel at the start."""
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column(style="dim")
+    table.add_column(style="bold cyan")
+    table.add_row("Target:", target)
+    table.add_row("Type:", detected_type.name)
+    table.add_row("Mode:", mode)
+    if ignore_gitignore:
+        table.add_row("Ignore Gitignore:", "[bold yellow]Yes[/]")
+
+    panel = Panel(
+        table,
+        title="🚀 [bold]Ingestion Started[/bold]",
+        border_style="blue",
+        expand=False,
+    )
+    console.print(panel)
+
+
+def _display_metrics_panel(result: IngestionResult, save_path: Optional[Path]):
+    """The green summary panel at the end."""
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_column(style="dim")
+    table.add_column(style="bold cyan")
+
+    table.add_row("Files", str(result.metrics.file_count))
+    table.add_row("Tokens", f"{result.metrics.token_count:,}")
+    table.add_row("Size", format_size(result.metrics.size_bytes))
+    if save_path:
+        table.add_row("Saved to", f"@{save_path}")
+
+    panel = Panel(
+        table,
+        title="[bold green]✓ Ingestion Complete![/]",
+        expand=False,
+        border_style="green",
+    )
+    console.print(panel)
+
+
+def list_reports():
+    """List all saved ingestion reports."""
+    reports = sorted(
+        config.reports_dir.glob("*.*"), key=lambda p: p.stat().st_mtime, reverse=True
+    )
+
+    if not reports:
+        console.print("[yellow]No reports found.[/]")
+        return
+
+    table = Table(title="Ingestion Reports", box=box.SIMPLE)
+    table.add_column("Filename", style="cyan")
+    table.add_column("Date", style="dim")
+    table.add_column("Size", style="green")
+
+    for r in reports:
+        size = format_size(r.stat().st_size)
+        mtime = datetime.fromtimestamp(r.stat().st_mtime).strftime("%Y-%m-%d %H:%M")
+        table.add_row(r.name, mtime, size)
+
+    console.print(table)
+
+
+async def _ingest_single(
+    target: str,
+    list_only: bool,
+    save: bool,
+    output: Optional[Path],
+    fmt: str,
+    clipboard: bool,
+    ignore_gitignore: bool = False,
+):
+    """Handles ingestion for a single target."""
+    target_path = Path(target).resolve() if Path(target).exists() else None
+
+    # Determine mode string for display
+    if target_path and target_path.is_file():
+        mode = f"Single file → [bold]{target_path.name}[/]"
+    elif list_only:
+        mode = "Structure only [dim](--list)[/]"
+    else:
+        mode = "Full ingest"
+
+    ctx = await get_subpath_context(target)
+    if ctx:
+        root_name, rel_path = ctx
+        console.print(f"[dim]Context:[/dim] Detected Git Root at [bold]{root_name}[/]")
+        console.print(
+            f"[dim]Scope:[/dim]   Restricting ingestion to [bold]{rel_path}[/]"
+        )
+
+    itype = detect_type(target)
+    _display_info_panel(target, itype, mode, ignore_gitignore=ignore_gitignore)
+
+    with console.status(f"⠋ Ingesting [cyan]{target}[/cyan]...", spinner="dots"):
+        try:
+            result = await ingest(
+                target, list_only=list_only, ignore_gitignore=ignore_gitignore
+            )
+        except Exception as e:
+            console.print(f"[bold red]✗ Ingestion failed:[/] {e}")
+            raise typer.Exit(1)
+
+    # Determine save path
+    save_path = None
+    if save or output:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        list_tag = "-list" if list_only else ""
+        filename = f"{result.suggested_filename}{list_tag}-{timestamp}.{fmt}"
+        save_path = output or (config.reports_dir / filename)
+
+        full_report = result.format_report(fmt=fmt)
+        save_path.write_text(full_report, encoding="utf-8")
+
+    if clipboard:
+        try:
+            import pyperclip
+
+            pyperclip.copy(result.format_report(fmt=fmt))
+            console.print("[dim]→ Copied to clipboard[/]")
+        except ImportError:
+            console.print("[yellow]→ Clipboard failed: pyperclip not installed[/]")
+
+    _display_metrics_panel(result, save_path)
+
+
+async def _ingest_user(
+    target: str,
+    output_dir: Path,
+    fmt: str,
+    separate: bool,
+    ignore_gitignore: bool = False,
+):
+    """Concurrent multi-repo ingestion for GitHub users."""
+    username = target.rstrip("/").split("/")[-1]
+
+    try:
+        repos = await fetch_user_repos(username)
+    except Exception as e:
+        console.print(f"[bold red]✗ Error fetching repos for {username}:[/] {e}")
+        return
+
+    if not repos:
+        console.print(f"[yellow]No public source repositories found for {username}.[/]")
+        return
+
+    console.print(f"[bold green]✓[/] Found [bold]{len(repos)}[/] source repositories.")
+
+    semaphore = asyncio.Semaphore(5)
+    full_content = []
+
+    progress_cols = (
+        TextColumn("  "),
+        StatusSpinnerColumn(),
+        TextColumn("[bold blue]{task.description}[/]"),
+        BarColumn(bar_width=40),
+        MofNCompleteColumn(),
+        TimeElapsedColumn(),
+    )
+
+    with Progress(*progress_cols, console=console, expand=False) as progress:
+        main_task = progress.add_task(f"Ingesting {username}...", total=len(repos))
+
+        async def _work(repo: Dict[str, Any]):
+            async with semaphore:
+                try:
+                    res = await ingest(
+                        repo["clone_url"], ignore_gitignore=ignore_gitignore
+                    )
+                    if separate:
+                        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                        path = (
+                            output_dir / f"{res.suggested_filename}-{timestamp}.{fmt}"
+                        )
+                        path.write_text(res.format_report(fmt=fmt), encoding="utf-8")
+                    else:
+                        full_content.append(
+                            f"\n\n{'=' * 40}\nREPO: {res.suggested_filename}\n{'=' * 40}\n{res.content}"
+                        )
+                    progress.update(main_task, advance=1)
+                except Exception:
+                    progress.update(main_task, advance=1, status_icon="[bold red]✗[/]")
+
+        await asyncio.gather(*[_work(r) for r in repos])
+
+    if not separate and full_content:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        save_path = output_dir / f"{username}-profile-{timestamp}.{fmt}"
+        save_path.write_text("\n".join(full_content), encoding="utf-8")
+        console.print(
+            f"\n[bold green]✓[/] Profile digest saved to: [bold]{save_path}[/]"
+        )
+
+
+def main(
+    ctx: typer.Context,
+    target: Optional[str] = typer.Argument(None, help="Path, GitHub URL, or Username"),
+    list_only: bool = typer.Option(
+        False, "--list", "-l", help="Structure only, no file content"
+    ),
+    ignore_gitignore: bool = typer.Option(
+        False,
+        "--no-git-ignore",
+        help="Ignore .gitignore patterns and ingest everything",
+    ),
+    save: bool = typer.Option(True, "--save/--no-save", help="Save report to file"),
+    output: Optional[Path] = typer.Option(
+        None, "--output", "-o", help="Custom output path"
+    ),
+    format: str = typer.Option("txt", "--format", "-f", help="txt, md, xml"),
+    clipboard: bool = typer.Option(
+        False, "--clipboard", "-c", help="Copy to clipboard"
+    ),
+    separate: bool = typer.Option(
+        False, "--separate", "-s", help="Split user repos into files"
+    ),
+    list_reports_flag: bool = typer.Option(
+        False, "--reports", help="List saved reports"
+    ),
+):
+    """
+    Ingest codebases into a single file.
+    """
+    if list_reports_flag:
+        list_reports()
+        return
+
+    if not target:
+        console.print(ctx.get_help())
+        return
+
+    async def _run():
+        itype = detect_type(target)
+        if itype == IngestType.GITHUB_USER:
+            await _ingest_user(
+                target,
+                output or config.reports_dir,
+                format,
+                separate,
+                ignore_gitignore=ignore_gitignore,
+            )
+        else:
+            await _ingest_single(
+                target,
+                list_only,
+                save,
+                output,
+                format,
+                clipboard,
+                ignore_gitignore=ignore_gitignore,
+            )
+
+    asyncio.run(_run())