| """Command-line entry point: ``ycode`` / ``python -m ycode``.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import contextlib |
| import os |
| import sys |
| import time |
| import traceback |
| from pathlib import Path |
|
|
| from ycode import __version__ |
| from ycode.agent.context import detect_project |
| from ycode.agent.loop import TaskStatus |
| from ycode.config import APPROVAL_MODES, Config, load_config, load_env_files, ycode_home |
| from ycode.errors import YCodeError |
| from ycode.llm import create_provider |
| from ycode.ui.console import ConsoleUI, make_console |
|
|
|
|
| def build_parser() -> argparse.ArgumentParser: |
| parser = argparse.ArgumentParser( |
| prog="ycode", |
| description="YCode - an AI coding agent for your terminal.", |
| ) |
| parser.add_argument("task", nargs="*", help="Run a single task non-interactively, then exit.") |
| parser.add_argument("-p", "--prompt", help="Same as passing a task: run it and exit.") |
| parser.add_argument("-m", "--model", help="Model ID (overrides YCODE_MODEL and config files).") |
| parser.add_argument("--provider", choices=("local", "anthropic"), |
| help="LLM provider: YCode's own model (default, no API key) or Claude " |
| "(anthropic, needs ANTHROPIC_API_KEY).") |
| parser.add_argument("--local", nargs="?", const="", default=None, metavar="MODEL", |
| help="Use YCode's own model (the default). Optionally pick one: v2, v3, v4, v5, " |
| "or a model directory. Default: your trained model if you have one, else v5 " |
| "(v4 with less than 4 GB of free memory).") |
| parser.add_argument("--max-steps", type=int, help="Maximum agent steps per task.") |
| parser.add_argument("--approval-mode", choices=APPROVAL_MODES, help="How risky actions are approved.") |
| parser.add_argument("--yes", action="store_true", |
| help="Shortcut for --approval-mode auto (blocked commands stay blocked).") |
| parser.add_argument("-C", "--directory", help="Project directory (default: current directory).") |
| parser.add_argument("--no-banner", action="store_true", help="Skip the start-up banner.") |
| parser.add_argument("--version", action="version", version=f"YCode {__version__}") |
| return parser |
|
|
|
|
| def _debug() -> bool: |
| return os.environ.get("YCODE_DEBUG", "").lower() in ("1", "true", "yes") |
|
|
|
|
| def main(argv: list[str] | None = None) -> int: |
| args = build_parser().parse_args(argv) |
| console = make_console() |
| ui = ConsoleUI(console) |
|
|
| workspace = Path(args.directory or os.getcwd()).expanduser() |
| if not workspace.is_dir(): |
| ui.print_error(YCodeError(f"Directory not found: {workspace}")) |
| return 2 |
| workspace = workspace.resolve() |
|
|
| load_env_files(workspace) |
| try: |
| config = load_config( |
| workspace, |
| cli_overrides={ |
| "model": args.model, |
| "provider": "local" if args.local is not None else args.provider, |
| "local_model": args.local or None, |
| "max_steps": args.max_steps, |
| "approval_mode": "auto" if args.yes else args.approval_mode, |
| }, |
| ) |
| except YCodeError as exc: |
| ui.print_error(exc) |
| return 2 |
|
|
| if config.theme != "default": |
| console = make_console(config.theme) |
| ui = ConsoleUI(console) |
|
|
| task = args.prompt or " ".join(args.task).strip() or None |
| try: |
| return run(config, workspace, ui, task=task, show_banner=not args.no_banner) |
| except KeyboardInterrupt: |
| ui.stop() |
| console.print() |
| return 130 |
|
|
|
|
| def run(config: Config, workspace: Path, ui: ConsoleUI, *, task: str | None, show_banner: bool) -> int: |
| from ycode.app import YCodeApp |
|
|
| with ui.console.status("Inspecting project...", spinner="dots") if ui.console.is_terminal else contextlib.nullcontext(): |
| context = detect_project(workspace, config.ignore_dirs) |
|
|
| try: |
| provider = create_provider(config) |
| except YCodeError as exc: |
| if show_banner: |
| from ycode.ui.banner import BannerInfo |
|
|
| ui.print_banner(BannerInfo(version=__version__, model=config.model, directory=str(workspace), |
| branch=context.branch, project_types=tuple(context.project_types), |
| approval_mode=config.approval_mode), show_hint=False) |
| ui.print_error(exc) |
| return 1 |
|
|
| app = YCodeApp(config=config, workspace=workspace, provider=provider, ui=ui, context=context) |
| if show_banner: |
| ui.print_banner(app.banner_info()) |
| if not provider.supports_tools: |
| ui.on_notice("Local model: answer-only mode. It answers questions and writes code in its reply, " |
| "but cannot read, edit or run files in your project.", "warning") |
| ui.console.print() |
|
|
| if task is not None: |
| result = app.run_task(task) |
| return 0 if result.status is TaskStatus.COMPLETED else 1 |
| return repl(app) |
|
|
|
|
| def repl(app) -> int: |
| from ycode.commands import command_names |
| from ycode.ui.prompts import InputReader |
|
|
| reader = InputReader(ycode_home() / "history", commands=command_names()) |
| ui = app.ui |
| last_interrupt = 0.0 |
| while not app.should_exit: |
| try: |
| line = reader.read() |
| except KeyboardInterrupt: |
| now = time.monotonic() |
| if now - last_interrupt < 2.0: |
| break |
| last_interrupt = now |
| ui.info("(Press Ctrl+C again or Ctrl+D to exit)") |
| continue |
| except EOFError: |
| break |
| try: |
| app.handle_line(line) |
| except KeyboardInterrupt: |
| ui.stop() |
| ui.info("Interrupted.") |
| except YCodeError as exc: |
| ui.print_error(exc) |
| except Exception as exc: |
| ui.stop() |
| if _debug(): |
| traceback.print_exc() |
| ui.print_error(YCodeError( |
| f"Internal error: {type(exc).__name__}: {exc}", |
| hint="Set YCODE_DEBUG=1 to see the full traceback.", |
| )) |
| ui.stop() |
| ui.info("Goodbye.") |
| return 0 |
|
|
|
|
| if __name__ == "__main__": |
| sys.exit(main()) |
|
|
