xdog-coding 0.57.1__py3-none-any.whl

xdog/coding/__init__.py

@@ -0,0 +1,3 @@
+"""coding - Interactive coding agent CLI."""
+
+__version__ = "0.57.1"

xdog/coding/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI sub-package for argument parsing and interactive selectors."""

xdog/coding/cli/args.py

@@ -0,0 +1,148 @@
+"""CLI argument parsing via click."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import click
+from xdog.coding.cli.list_models import list_models_command
+from xdog.coding.cli.session_picker import pick_session_command
+
+
+@click.command(context_settings={"help_option_names": ["-h", "--help"]})
+@click.option(
+    "-m", "--model",
+    default=None,
+    help="Model to use (e.g. sonnet, opus, haiku, or a full model id).",
+)
+@click.option(
+    "-r", "--resume",
+    is_flag=True,
+    default=False,
+    help="Resume the most recent session.",
+)
+@click.option(
+    "--resume-id",
+    default=None,
+    help="Resume a specific session by ID.",
+)
+@click.option(
+    "-p", "--prompt",
+    default=None,
+    help="Initial prompt to send (non-interactive).",
+)
+@click.option(
+    "--print",
+    "print_mode",
+    is_flag=True,
+    default=False,
+    help="Run in non-interactive print mode.",
+)
+@click.option(
+    "--output-format",
+    type=click.Choice(["text", "json", "markdown"]),
+    default="text",
+    help="Output format for print mode.",
+)
+@click.option(
+    "--working-dir",
+    type=click.Path(exists=True, file_okay=False, path_type=Path),
+    default=None,
+    help="Working directory for the agent.",
+)
+@click.option(
+    "--config",
+    "config_path",
+    type=click.Path(exists=True, dir_okay=False, path_type=Path),
+    default=None,
+    help="Path to a config file.",
+)
+@click.option(
+    "--thinking-level",
+    type=click.Choice(["none", "normal", "deep", "ultrathink"]),
+    default=None,
+    help="Thinking / reasoning level.",
+)
+@click.option(
+    "--list-models",
+    is_flag=True,
+    default=False,
+    help="List available models and exit.",
+)
+@click.option(
+    "--pick-session",
+    is_flag=True,
+    default=False,
+    help="Interactively pick a session to resume.",
+)
+@click.option(
+    "--rpc",
+    is_flag=True,
+    default=False,
+    help="Run in RPC mode for IDE integration.",
+)
+@click.option(
+    "--verbose",
+    is_flag=True,
+    default=False,
+    help="Enable verbose logging.",
+)
+@click.argument("files", nargs=-1, type=click.Path(exists=True, path_type=Path))
+def cli(
+    model: str | None,
+    resume: bool,
+    resume_id: str | None,
+    prompt: str | None,
+    print_mode: bool,
+    output_format: str,
+    working_dir: Path | None,
+    config_path: Path | None,
+    thinking_level: str | None,
+    list_models: bool,
+    pick_session: bool,
+    rpc: bool,
+    verbose: bool,
+    files: tuple[Path, ...],
+) -> None:
+    """pi - Interactive coding agent CLI.
+
+    Optionally pass FILES to include their contents in the initial context.
+    """
+    # Early-exit commands
+    if list_models:
+        list_models_command()
+        return
+
+    if pick_session:
+        pick_session_command()
+        return
+
+    # Build overrides dict from CLI flags
+    overrides: dict[str, Any] = {}
+    if model is not None:
+        overrides["model"] = model
+    if thinking_level is not None:
+        overrides["thinking_level"] = thinking_level
+
+    # Defer to the main entry-point for actual execution
+    from xdog.coding.main import run_agent
+
+    run_agent(
+        overrides=overrides,
+        resume=resume,
+        resume_id=resume_id,
+        prompt=prompt,
+        print_mode=print_mode,
+        output_format=output_format,
+        working_dir=working_dir,
+        config_path=config_path,
+        rpc=rpc,
+        verbose=verbose,
+        files=files,
+    )
+
+
+def parse_args() -> None:
+    """Parse CLI arguments and run the application."""
+    cli(standalone_mode=True)

xdog/coding/cli/config_selector.py

@@ -0,0 +1,74 @@
+"""Interactive config selector: set default model, thinking level, etc."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from xdog.coding.config import GlobalConfig, get_global_settings_path
+
+
+def _prompt_provider() -> str:
+    """Ask the user which provider to configure."""
+    providers = ["anthropic", "openai", "google"]
+    print("\nAvailable providers:")
+    for idx, name in enumerate(providers, 1):
+        print(f"  {idx}. {name}")
+    while True:
+        choice = input("\nSelect provider [1-3]: ").strip()
+        if choice.isdigit() and 1 <= int(choice) <= len(providers):
+            return providers[int(choice) - 1]
+        print("Invalid selection, try again.")
+
+
+def _prompt_api_key(provider: str) -> str:
+    """Show environment variable instructions for a provider.
+
+    API keys are managed by the ai package via environment variables,
+    not stored in the coding agent's config file.
+    """
+    env_vars = {
+        "anthropic": "ANTHROPIC_API_KEY",
+        "openai": "OPENAI_API_KEY",
+        "google": "GOOGLE_API_KEY",
+    }
+    var = env_vars.get(provider, f"{provider.upper()}_API_KEY")
+    print(f"\n  Set the {var} environment variable to use {provider}.")
+    print(f"  Example: export {var}=your-key-here")
+    return provider
+
+
+def config_selector(config_path: Path | None = None) -> GlobalConfig:
+    """Interactive configuration wizard.
+
+    Lets the user set the default model and other preferences.
+    API keys are managed by the ai package via environment variables.
+
+    Returns the updated :class:`GlobalConfig`.
+    """
+    cfg = GlobalConfig.load(config_path)
+
+    print("=== Pi Coding Agent - Configuration ===\n")
+    print("Note: API keys are set via environment variables")
+    print("  (ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_API_KEY)\n")
+
+    # Default model
+    new_model = input(f"Default model [{cfg.default_model}]: ").strip()
+    if new_model:
+        cfg = cfg.model_copy(update={"default_model": new_model})
+
+    # Thinking level
+    new_thinking = input(f"Thinking level [{cfg.thinking_level}] (off/normal/high): ").strip()
+    if new_thinking:
+        cfg = cfg.model_copy(update={"thinking_level": new_thinking})
+
+    # Custom instructions
+    if cfg.custom_instructions:
+        print(f"\nCurrent custom instructions: {cfg.custom_instructions[:80]}...")
+    new_instructions = input("Custom instructions (leave empty to keep): ").strip()
+    if new_instructions:
+        cfg = cfg.model_copy(update={"custom_instructions": new_instructions})
+
+    save_path = config_path or get_global_settings_path()
+    cfg.save(save_path)
+    print(f"\nConfiguration saved to {save_path}")
+    return cfg

xdog/coding/cli/file_processor.py

@@ -0,0 +1,80 @@
+"""Process files passed as CLI arguments into context messages."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+# Binary / image extensions that should be handled differently
+_IMAGE_EXTENSIONS = frozenset({".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".svg"})
+_BINARY_EXTENSIONS = frozenset({
+    ".zip", ".tar", ".gz", ".bz2", ".xz",
+    ".pdf", ".doc", ".docx", ".xls", ".xlsx",
+    ".exe", ".dll", ".so", ".dylib",
+})
+
+MAX_FILE_SIZE = 512 * 1024  # 512 KiB
+
+
+def _is_image(path: Path) -> bool:
+    return path.suffix.lower() in _IMAGE_EXTENSIONS
+
+
+def _is_binary(path: Path) -> bool:
+    return path.suffix.lower() in _BINARY_EXTENSIONS
+
+
+def process_file(path: Path) -> dict[str, Any] | None:
+    """Read a single file and return a context dict for the system prompt.
+
+    Returns ``None`` when the file cannot be processed (binary, too large, etc.).
+    """
+    resolved = path.resolve()
+    if not resolved.is_file():
+        return None
+
+    if _is_binary(resolved):
+        return {
+            "type": "file_reference",
+            "path": str(resolved),
+            "note": "Binary file - contents not included.",
+        }
+
+    if _is_image(resolved):
+        return {
+            "type": "image",
+            "path": str(resolved),
+        }
+
+    try:
+        stat = resolved.stat()
+    except OSError:
+        return None
+
+    if stat.st_size > MAX_FILE_SIZE:
+        return {
+            "type": "file_reference",
+            "path": str(resolved),
+            "note": f"File too large ({stat.st_size:,} bytes) - contents not included.",
+        }
+
+    try:
+        content = resolved.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+
+    return {
+        "type": "file_content",
+        "path": str(resolved),
+        "content": content,
+    }
+
+
+def process_files(paths: tuple[Path, ...] | list[Path]) -> list[dict[str, Any]]:
+    """Process multiple files and return a list of context dicts."""
+    results: list[dict[str, Any]] = []
+    for p in paths:
+        entry = process_file(Path(p))
+        if entry is not None:
+            results.append(entry)
+    return results

xdog/coding/cli/initial_message.py

@@ -0,0 +1,55 @@
+"""Initial message builder: construct the first message from CLI args and piped stdin."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from xdog.coding.cli.file_processor import process_files
+
+
+def build_initial_message(
+    *,
+    prompt: str | None = None,
+    files: tuple[Path, ...] = (),
+    read_stdin: bool = False,
+) -> str | None:
+    """Build the initial user message from CLI arguments.
+
+    Combines prompt text, file contents, and piped stdin into
+    a single message string. Returns None if no input is provided.
+    """
+    parts: list[str] = []
+
+    # Read piped stdin
+    if read_stdin and not sys.stdin.isatty():
+        try:
+            stdin_content = sys.stdin.read()
+            if stdin_content.strip():
+                parts.append(stdin_content.strip())
+        except Exception:
+            pass
+
+    # Process file arguments
+    if files:
+        file_entries = process_files(files)
+        for entry in file_entries:
+            etype = entry.get("type", "")
+            path = entry.get("path", "")
+            if etype == "file_content":
+                content = entry.get("content", "")
+                parts.append(f"File: {path}\n```\n{content}\n```")
+            elif etype == "image":
+                parts.append(f"[Image: {path}]")
+            elif etype == "file_reference":
+                note = entry.get("note", "")
+                parts.append(f"File: {path} ({note})")
+
+    # Add the explicit prompt last
+    if prompt:
+        parts.append(prompt)
+
+    if not parts:
+        return None
+
+    return "\n\n".join(parts)

xdog/coding/cli/list_models.py

@@ -0,0 +1,27 @@
+"""List available models in a user-friendly table."""
+
+from __future__ import annotations
+
+
+def list_models_command() -> None:
+    """Print a table of all registered models and exit."""
+    import xdog.ai as ai
+    runtime = ai.load()
+    models = sorted(
+        (m for m in runtime.models() if m.model_type == "chat"),
+        key=lambda m: (m.provider, m.id),
+    )
+
+    if not models:
+        print("No models available. Run 'xdog-ai login copilot' first.")
+        return
+
+    header = f"  {'Model ID':<45s}  {'Provider':<15s}  {'Protocol':<20s}"
+    separator = "  " + "-" * 84
+
+    print("\nAvailable models:\n")
+    print(header)
+    print(separator)
+    for m in models:
+        print(f"  {m.id:<45s}  {m.provider:<15s}  {m.api:<20s}")
+    print()

xdog/coding/cli/session_picker.py

@@ -0,0 +1,45 @@
+"""Interactive session picker for resuming previous sessions."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from xdog.coding.core.session_manager import SessionManager, SessionMeta
+
+
+def _format_session(meta: SessionMeta, idx: int) -> str:
+    """Format one session line for display."""
+    ts = datetime.fromtimestamp(meta.updated_at, tz=timezone.utc)
+    time_str = ts.strftime("%Y-%m-%d %H:%M")
+    summary = meta.summary[:60] if meta.summary else "(no summary)"
+    return f"  {idx:>3d}. [{time_str}]  {meta.session_id[:8]}  {summary}"
+
+
+def pick_session_command() -> str | None:
+    """Show recent sessions and let the user pick one.
+
+    Returns the chosen session ID or ``None`` if the user cancels.
+    """
+    manager = SessionManager()
+    sessions = manager.list_sessions(limit=20)
+
+    if not sessions:
+        print("No sessions found.")
+        return None
+
+    print("\nRecent sessions:\n")
+    for idx, meta in enumerate(sessions, 1):
+        print(_format_session(meta, idx))
+    print()
+
+    while True:
+        choice = input("Pick a session number (or 'q' to cancel): ").strip()
+        if choice.lower() == "q":
+            return None
+        if choice.isdigit():
+            num = int(choice)
+            if 1 <= num <= len(sessions):
+                selected = sessions[num - 1]
+                print(f"\nResuming session {selected.session_id[:8]}...")
+                return selected.session_id
+        print("Invalid selection, try again.")