freeai-code 0.1.0__py3-none-any.whl

free_code/__init__.py

@@ -0,0 +1,3 @@
+"""Free.ai Coder CLI — Free AI coding assistant."""
+
+__version__ = "0.1.0"

free_code/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for `python -m free_code`."""
+
+from free_code.cli import main
+
+if __name__ == "__main__":
+    main()

free_code/agent.py

@@ -0,0 +1,262 @@
+"""Local agent loop — plan, execute, observe."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from rich.console import Console
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
+
+from free_code.client import CoderClient
+from free_code.config import load_config
+from free_code.context.repo_map import generate_repo_map
+from free_code.context.window import build_context
+from free_code.tools import TOOL_DEFINITIONS, TOOL_REGISTRY
+from free_code.tools.shell import is_dangerous
+from free_code.ui.terminal import (
+    confirm,
+    print_error,
+    print_markdown,
+    print_tool_call,
+    print_tool_result,
+)
+
+console = Console()
+
+SYSTEM_PROMPT = """\
+You are Free.ai Coder, an expert AI coding assistant running in the user's terminal.
+You have access to their local filesystem and can read, write, and edit files.
+
+## Tools Available
+You can use these tools to help the user:
+- file_read: Read file contents
+- file_write: Write/create files
+- apply_patch: Search/replace edit in a file
+- shell_command: Execute shell commands
+- grep_search: Search for patterns in code
+- git_status, git_diff, git_commit, git_log: Git operations
+- run_tests: Run the project's test suite
+- list_files: List project files
+
+## Guidelines
+- Read files before editing them to understand the full context
+- Make minimal, focused changes
+- Show diffs for significant edits
+- Run tests after making changes when appropriate
+- Use grep_search to find relevant code before making changes
+- Prefer apply_patch over file_write for editing existing files
+- Ask for confirmation before destructive operations
+- Be concise in explanations, verbose in code
+
+When you need to use a tool, respond with a JSON tool call in this format:
+{"tool": "tool_name", "args": {"arg1": "value1"}}
+
+After each tool result, analyze the output and decide the next step.
+When you're done, provide a final summary of what was accomplished.
+"""
+
+MAX_AGENT_STEPS = 30
+
+
+class Agent:
+    """The coding agent — runs a plan/execute/observe loop."""
+
+    def __init__(
+        self,
+        project_root: Path,
+        config: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self.project_root = project_root.resolve()
+        self.config = config or load_config()
+        self.client = CoderClient(self.config)
+        self.messages: List[Dict[str, str]] = []
+        self.safe_mode = self.config.get("safe_mode", True)
+
+    async def chat(self, user_message: str) -> None:
+        """Process a user message through the agent loop."""
+        # Build context on first message
+        if not self.messages:
+            context, included = build_context(
+                self.project_root,
+                user_message,
+                max_tokens=self.config.get("max_context_tokens", 32000),
+            )
+            system = SYSTEM_PROMPT + f"\n\n## Project Context\n\n{context}"
+        else:
+            system = None
+
+        self.messages.append({"role": "user", "content": user_message})
+
+        for step in range(MAX_AGENT_STEPS):
+            # Get LLM response
+            response_text = await self._get_response(system)
+            system = None  # Only send system on first turn
+
+            if not response_text:
+                break
+
+            # Check for tool calls in the response
+            tool_call = self._extract_tool_call(response_text)
+
+            if tool_call:
+                tool_name = tool_call["tool"]
+                tool_args = tool_call.get("args", {})
+
+                # Print any text before the tool call
+                pre_text = response_text[:response_text.find('{"tool"')].strip()
+                if pre_text:
+                    print_markdown(pre_text)
+
+                # Execute the tool
+                result = await self._execute_tool(tool_name, tool_args)
+
+                if result is None:
+                    # Tool was cancelled by user
+                    self.messages.append({
+                        "role": "assistant",
+                        "content": response_text,
+                    })
+                    self.messages.append({
+                        "role": "user",
+                        "content": "(Tool execution cancelled by user)",
+                    })
+                    continue
+
+                # Add assistant message and tool result
+                self.messages.append({
+                    "role": "assistant",
+                    "content": response_text,
+                })
+                self.messages.append({
+                    "role": "user",
+                    "content": f"[Tool result for {tool_name}]:\n{result}",
+                })
+            else:
+                # No tool call — this is the final response
+                print_markdown(response_text)
+                self.messages.append({
+                    "role": "assistant",
+                    "content": response_text,
+                })
+                break
+
+    async def _get_response(self, system: Optional[str] = None) -> str:
+        """Get a streaming response from the LLM."""
+        chunks: List[str] = []
+        spinner = Spinner("dots", text="Thinking...")
+
+        with Live(spinner, console=console, refresh_per_second=10, transient=True):
+            first_chunk = True
+            async for event in self.client.chat_stream(self.messages, system=system):
+                event_type = event.get("type", "")
+
+                if event_type == "text":
+                    content = event.get("content", "")
+                    if first_chunk:
+                        first_chunk = False
+                    chunks.append(content)
+
+                elif event_type == "error":
+                    print_error(event.get("content", "Unknown error"))
+                    return ""
+
+                elif event_type == "done":
+                    break
+
+        return "".join(chunks)
+
+    def _extract_tool_call(self, text: str) -> Optional[Dict[str, Any]]:
+        """Extract a tool call JSON from the response text."""
+        # Look for {"tool": "..."} pattern
+        start = text.find('{"tool"')
+        if start == -1:
+            return None
+
+        # Find the matching closing brace
+        depth = 0
+        for i in range(start, len(text)):
+            if text[i] == "{":
+                depth += 1
+            elif text[i] == "}":
+                depth -= 1
+                if depth == 0:
+                    try:
+                        data = json.loads(text[start:i + 1])
+                        if "tool" in data:
+                            return data
+                    except json.JSONDecodeError:
+                        pass
+                    break
+        return None
+
+    async def _execute_tool(
+        self,
+        tool_name: str,
+        tool_args: Dict[str, Any],
+    ) -> Optional[str]:
+        """Execute a tool and return the result. Returns None if cancelled."""
+        if tool_name not in TOOL_REGISTRY:
+            return f"Error: Unknown tool: {tool_name}"
+
+        # Safety checks
+        if self.safe_mode:
+            if tool_name in ("file_write", "apply_patch", "git_commit"):
+                print_tool_call(tool_name, tool_args)
+                if not confirm("Apply this change?"):
+                    return None
+
+            if tool_name == "shell_command":
+                cmd = tool_args.get("command", "")
+                print_tool_call(tool_name, tool_args)
+                if is_dangerous(cmd):
+                    console.print("[warning]This command could be dangerous.[/warning]")
+                if not confirm(f"Run: {cmd}"):
+                    return None
+        else:
+            # Even in non-safe mode, confirm dangerous shell commands
+            if tool_name == "shell_command" and is_dangerous(tool_args.get("command", "")):
+                print_tool_call(tool_name, tool_args)
+                if not confirm("This command could be dangerous. Run anyway?"):
+                    return None
+
+        if tool_name not in ("file_write", "apply_patch", "shell_command", "git_commit") or not self.safe_mode:
+            print_tool_call(tool_name, tool_args)
+
+        # Inject project root
+        tool_args["_project_root"] = str(self.project_root)
+
+        # Execute
+        func = TOOL_REGISTRY[tool_name]
+        try:
+            result = func(**tool_args)
+        except TypeError as e:
+            # Handle unexpected keyword arguments
+            tool_args_clean = {k: v for k, v in tool_args.items() if not k.startswith("_")}
+            tool_args_clean["_project_root"] = str(self.project_root)
+            try:
+                result = func(**tool_args_clean)
+            except Exception as e2:
+                result = f"Error executing {tool_name}: {e2}"
+        except Exception as e:
+            result = f"Error executing {tool_name}: {e}"
+
+        print_tool_result(result, collapsed=len(str(result)) > 1000)
+        return str(result)
+
+    def clear_history(self) -> None:
+        """Clear conversation history."""
+        self.messages.clear()
+
+    def compact_history(self) -> None:
+        """Summarize conversation to save context."""
+        if len(self.messages) <= 2:
+            return
+        # Keep first and last 4 messages, summarize the middle
+        kept = self.messages[:1] + self.messages[-4:]
+        summary = f"(Previous conversation with {len(self.messages)} messages was compacted)"
+        self.messages = [{"role": "user", "content": summary}] + kept

free_code/auth.py

@@ -0,0 +1,74 @@
+"""Authentication flow for Free.ai and BYOK providers."""
+
+from __future__ import annotations
+
+import sys
+from typing import Optional
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+from free_code.config import load_config, save_config, set_config_value
+
+console = Console()
+
+
+def check_auth(config: Optional[dict] = None) -> bool:
+    """Check if the user has valid authentication configured."""
+    if config is None:
+        config = load_config()
+    provider = config.get("provider", "free.ai")
+    if provider == "free.ai":
+        # Free.ai allows anonymous usage with daily limits
+        return True
+    # BYOK providers need an API key
+    return bool(config.get("api_key"))
+
+
+def login_flow() -> None:
+    """Interactive login flow."""
+    config = load_config()
+    console.print()
+    console.print("[bold]Free.ai Coder — Login[/bold]")
+    console.print()
+
+    provider = Prompt.ask(
+        "Provider",
+        choices=["free.ai", "openai", "anthropic", "google", "openrouter"],
+        default="free.ai",
+    )
+
+    if provider == "free.ai":
+        console.print()
+        console.print("Free.ai offers free daily limits with no account required.")
+        console.print("For higher limits, get a token at [link=https://free.ai/pricing]https://free.ai/pricing[/link]")
+        console.print()
+        token = Prompt.ask("Free.ai token (press Enter to skip)", default="")
+        if token:
+            set_config_value("token", token)
+            console.print("[green]Token saved.[/green]")
+        else:
+            console.print("[dim]Using free anonymous tier.[/dim]")
+        set_config_value("provider", "free.ai")
+    else:
+        console.print()
+        key_name = "API key"
+        if provider == "openrouter":
+            console.print("Get an API key at [link=https://openrouter.ai/keys]https://openrouter.ai/keys[/link]")
+        elif provider == "openai":
+            console.print("Get an API key at [link=https://platform.openai.com/api-keys]https://platform.openai.com/api-keys[/link]")
+        elif provider == "anthropic":
+            console.print("Get an API key at [link=https://console.anthropic.com/settings/keys]https://console.anthropic.com/settings/keys[/link]")
+        elif provider == "google":
+            console.print("Get an API key at [link=https://aistudio.google.com/apikey]https://aistudio.google.com/apikey[/link]")
+
+        api_key = Prompt.ask(f"\n{key_name}")
+        if not api_key:
+            console.print("[red]API key is required for {provider}.[/red]")
+            sys.exit(1)
+
+        set_config_value("provider", provider)
+        set_config_value("api_key", api_key)
+        console.print(f"[green]Configured {provider} provider.[/green]")
+
+    console.print("[green]Login complete. Run [bold]free-code[/bold] to start coding.[/green]")

free_code/cli.py

@@ -0,0 +1,305 @@
+"""CLI entry point — Click commands for free-code."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from free_code import __version__
+from free_code.config import (
+    CONFIG_FILE,
+    get_config_value,
+    load_config,
+    save_config,
+    set_config_value,
+)
+
+console = Console()
+
+
+def get_project_root() -> Path:
+    """Determine the project root directory."""
+    from free_code.tools.git_ops import git_root
+
+    cwd = Path.cwd()
+    root = git_root(str(cwd))
+    if root:
+        return Path(root)
+    return cwd
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="free-code")
+@click.pass_context
+def main(ctx: click.Context) -> None:
+    """Free.ai Coder -- AI coding assistant for your terminal."""
+    if ctx.invoked_subcommand is None:
+        # Default: interactive chat
+        ctx.invoke(chat)
+
+
+@main.command()
+def chat() -> None:
+    """Start an interactive coding session."""
+    from free_code.agent import Agent
+    from free_code.context.repo_map import generate_repo_map
+    from free_code.models import get_model
+    from free_code.ui.prompt import get_input, setup_history, show_help
+    from free_code.ui.terminal import (
+        print_error,
+        print_info,
+        print_markdown,
+        print_model_info,
+        print_success,
+        print_welcome,
+    )
+
+    config = load_config()
+    project_root = get_project_root()
+    agent = Agent(project_root, config)
+
+    print_welcome()
+    print_model_info(config.get("provider", "free.ai"), get_model(config))
+    console.print(f"  [dim]Project:[/dim] {project_root}")
+    console.print()
+
+    setup_history()
+
+    while True:
+        try:
+            user_input = get_input("you> ")
+        except KeyboardInterrupt:
+            console.print("\n[dim]Goodbye![/dim]")
+            break
+
+        if user_input is None:
+            console.print("\n[dim]Goodbye![/dim]")
+            break
+
+        if not user_input:
+            continue
+
+        # Handle slash commands
+        if user_input.startswith("/"):
+            cmd = user_input.split()[0].lower()
+
+            if cmd in ("/quit", "/exit", "/q"):
+                console.print("[dim]Goodbye![/dim]")
+                break
+            elif cmd == "/help":
+                show_help()
+                continue
+            elif cmd == "/clear":
+                agent.clear_history()
+                print_success("Conversation cleared.")
+                continue
+            elif cmd == "/compact":
+                agent.compact_history()
+                print_success("Conversation compacted.")
+                continue
+            elif cmd == "/model":
+                parts = user_input.split(maxsplit=1)
+                if len(parts) > 1:
+                    set_config_value("model", parts[1])
+                    config = load_config()
+                    agent.client = __import__(
+                        "free_code.client", fromlist=["CoderClient"]
+                    ).CoderClient(config)
+                    print_success(f"Model set to: {parts[1]}")
+                else:
+                    print_info(f"Current model: {get_model(config)}")
+                continue
+            elif cmd == "/config":
+                _show_config()
+                continue
+            elif cmd == "/files":
+                from free_code.tools.list_files import list_files
+                result = list_files(_project_root=str(project_root), max_depth=2)
+                console.print(f"[dim]{result}[/dim]")
+                continue
+            elif cmd == "/repo":
+                repo_map = generate_repo_map(project_root)
+                console.print(f"[dim]{repo_map}[/dim]")
+                continue
+            elif cmd == "/diff":
+                from free_code.tools.git_ops import git_diff
+                result = git_diff(_project_root=str(project_root))
+                console.print(f"[dim]{result}[/dim]")
+                continue
+            elif cmd == "/status":
+                from free_code.tools.git_ops import git_status
+                result = git_status(_project_root=str(project_root))
+                console.print(f"[dim]{result}[/dim]")
+                continue
+            elif cmd == "/test":
+                from free_code.tools.test_runner import run_tests
+                parts = user_input.split(maxsplit=1)
+                path = parts[1] if len(parts) > 1 else None
+                with console.status("Running tests..."):
+                    result = run_tests(path=path, _project_root=str(project_root))
+                console.print(result)
+                continue
+            else:
+                print_error(f"Unknown command: {cmd}. Type /help for available commands.")
+                continue
+
+        # Send to agent
+        try:
+            asyncio.run(agent.chat(user_input))
+        except KeyboardInterrupt:
+            console.print("\n[dim]Interrupted.[/dim]")
+        except Exception as e:
+            print_error(f"Agent error: {e}")
+
+
+@main.command()
+@click.argument("question", nargs=-1, required=True)
+def ask(question: tuple) -> None:
+    """Ask a one-shot question about your codebase."""
+    from free_code.agent import Agent
+    from free_code.ui.terminal import print_error
+
+    question_str = " ".join(question)
+    config = load_config()
+    project_root = get_project_root()
+    agent = Agent(project_root, config)
+
+    # In ask mode, disable safe_mode for reads (it's one-shot)
+    agent.safe_mode = config.get("safe_mode", True)
+
+    try:
+        asyncio.run(agent.chat(question_str))
+    except KeyboardInterrupt:
+        console.print("\n[dim]Interrupted.[/dim]")
+    except Exception as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@main.command()
+@click.argument("task", nargs=-1, required=True)
+def run(task: tuple) -> None:
+    """Execute a coding task (e.g., 'add unit tests for auth module')."""
+    from free_code.agent import Agent
+    from free_code.ui.terminal import print_error
+
+    task_str = " ".join(task)
+    config = load_config()
+    project_root = get_project_root()
+    agent = Agent(project_root, config)
+
+    console.print(f"\n[bold]Task:[/bold] {task_str}")
+    console.print(f"[dim]Project: {project_root}[/dim]\n")
+
+    try:
+        asyncio.run(agent.chat(
+            f"Execute this task: {task_str}\n\n"
+            "Work through it step by step. Read relevant files first, "
+            "make the changes, then verify they work."
+        ))
+    except KeyboardInterrupt:
+        console.print("\n[dim]Interrupted.[/dim]")
+    except Exception as e:
+        print_error(str(e))
+        sys.exit(1)
+
+
+@main.command()
+def init() -> None:
+    """Initialize free-code in the current project."""
+    from free_code.context.discovery import discover_files
+    from free_code.context.repo_map import generate_repo_map
+    from free_code.tools.git_ops import is_git_repo
+    from free_code.tools.test_runner import detect_test_framework
+    from free_code.ui.terminal import print_info, print_success, print_warning
+
+    project_root = get_project_root()
+    console.print(f"\n[bold]Initializing free-code[/bold] in {project_root}\n")
+
+    # Check git
+    if is_git_repo(str(project_root)):
+        print_success("Git repository detected")
+    else:
+        print_warning("Not a git repository")
+
+    # Discover files
+    with console.status("Scanning files..."):
+        files = discover_files(project_root)
+    print_info(f"Found {len(files)} code files")
+
+    # Detect test framework
+    framework = detect_test_framework(str(project_root))
+    if framework:
+        print_info(f"Test framework: {framework}")
+    else:
+        print_info("No test framework detected")
+
+    # Generate repo map
+    with console.status("Generating repository map..."):
+        repo_map = generate_repo_map(project_root)
+
+    console.print(f"\n[dim]{repo_map}[/dim]")
+    console.print(f"\n[success]Initialization complete. Run [bold]free-code[/bold] to start coding.[/success]\n")
+
+
+@main.group(invoke_without_command=True)
+@click.pass_context
+def config(ctx: click.Context) -> None:
+    """View or edit configuration."""
+    if ctx.invoked_subcommand is None:
+        _show_config()
+
+
+@config.command("set")
+@click.argument("key")
+@click.argument("value")
+def config_set(key: str, value: str) -> None:
+    """Set a configuration value."""
+    from free_code.ui.terminal import print_success
+
+    set_config_value(key, value)
+    print_success(f"Set {key} = {value}")
+
+
+@config.command("get")
+@click.argument("key")
+def config_get(key: str) -> None:
+    """Get a configuration value."""
+    value = get_config_value(key)
+    if value is not None:
+        console.print(f"{key} = {value}")
+    else:
+        console.print(f"[dim]{key} is not set[/dim]")
+
+
+@main.command()
+def login() -> None:
+    """Authenticate with Free.ai or configure a BYOK provider."""
+    from free_code.auth import login_flow
+
+    login_flow()
+
+
+def _show_config() -> None:
+    """Display current configuration as a table."""
+    cfg = load_config()
+    table = Table(title="Configuration", show_header=True, header_style="bold")
+    table.add_column("Key", style="cyan")
+    table.add_column("Value")
+
+    for key, value in sorted(cfg.items()):
+        display = str(value)
+        # Mask sensitive values
+        if key in ("token", "api_key") and value:
+            display = display[:8] + "..." if len(display) > 8 else "***"
+        table.add_row(key, display)
+
+    table.add_row("[dim]config file[/dim]", f"[dim]{CONFIG_FILE}[/dim]")
+    console.print(table)