moma-cli 0.0.1__tar.gz

moma_cli-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+env/
+venv/
+.env
+__pycache__/
+*.pyc
+*.pyo
+.DS_Store

moma_cli-0.0.1/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: moma-cli
+Version: 0.0.1
+Summary: MOMA CLI - A terminal-based AI coding assistant
+Author-email: MOMA CLI <dev@moma-cli.com>
+License: MIT
+Keywords: ai,cli,coding-assistant,llm
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: litellm>=1.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer[all]>=0.9.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# moma-cli
+
+A terminal‑based AI coding assistant powered by `litellm`.  It lets you chat with your codebase, automatically read context, and apply changes manually.
+
+## Overview
+
+<img src="asset/image.png" alt="moma-cli screenshot" width="800">
+
+## Installation
+
+```bash
+pip install moma-cli   # or install from the repository
+```
+
+## Quick start
+
+```bash
+# Start an interactive chat (default command)
+moma
+```
+
+The CLI will launch a welcome screen and you can start typing messages.  Commands are prefixed with `/`:
+
+| Command | Description |
+|---------|-------------|
+| `/clear` | Clear conversation history |
+| `/model list` | List available models |
+| `/model change` | Choose a different model |
+| `/security` | Change security mode (smart/strict/permissive) |
+| `/status` | Show current session status |
+| `/config …` | View or edit configuration |
+| `/help` | Show help panel |
+| `/quit` or `Ctrl‑D` | Exit the program |
+
+## Chat command
+
+You can also invoke the chat directly with arguments:
+
+```bash
+moma chat "Explain this function"            # send an initial message
+moma chat -m gpt-4 "Generate a unit test"    # override model for this session
+moma chat -c                               # clear history before starting
+moma chat -t 0.7 -max-tokens 500            # set temperature and max tokens
+```
+
+## Configuration
+
+Configuration is stored in `~/.moma-cli/config.json`.  Manage it via the `config` sub‑command:
+
+```bash
+# Show all configuration
+moma config show
+
+# Set a value (e.g., default model)
+moma config set default_model ollama/llama3
+
+# Set your API key
+moma config set api_key sk-xxxxxxxxxxxx
+
+# Reset system prompt to default
+moma config reset
+```
+
+## Security modes
+
+- **smart** – read‑only shell commands are auto‑executed, mutating commands require confirmation.
+- **strict** – all shell commands require confirmation.
+- **permissive** – all commands run without prompts.
+
+Change the mode with:
+
+```bash
+moma /security
+```
+
+## Example workflow
+
+1. **Start chat** – `moma`
+2. **Ask a question** – e.g., `How can I improve this function?`
+3. **Review suggestions** – the assistant may propose a diff.
+4. **Apply changes** – confirm the diff when prompted.
+
+Enjoy coding with AI assistance!

moma_cli-0.0.1/README.md

@@ -0,0 +1,83 @@
+# moma-cli
+
+A terminal‑based AI coding assistant powered by `litellm`.  It lets you chat with your codebase, automatically read context, and apply changes manually.
+
+## Overview
+
+<img src="asset/image.png" alt="moma-cli screenshot" width="800">
+
+## Installation
+
+```bash
+pip install moma-cli   # or install from the repository
+```
+
+## Quick start
+
+```bash
+# Start an interactive chat (default command)
+moma
+```
+
+The CLI will launch a welcome screen and you can start typing messages.  Commands are prefixed with `/`:
+
+| Command | Description |
+|---------|-------------|
+| `/clear` | Clear conversation history |
+| `/model list` | List available models |
+| `/model change` | Choose a different model |
+| `/security` | Change security mode (smart/strict/permissive) |
+| `/status` | Show current session status |
+| `/config …` | View or edit configuration |
+| `/help` | Show help panel |
+| `/quit` or `Ctrl‑D` | Exit the program |
+
+## Chat command
+
+You can also invoke the chat directly with arguments:
+
+```bash
+moma chat "Explain this function"            # send an initial message
+moma chat -m gpt-4 "Generate a unit test"    # override model for this session
+moma chat -c                               # clear history before starting
+moma chat -t 0.7 -max-tokens 500            # set temperature and max tokens
+```
+
+## Configuration
+
+Configuration is stored in `~/.moma-cli/config.json`.  Manage it via the `config` sub‑command:
+
+```bash
+# Show all configuration
+moma config show
+
+# Set a value (e.g., default model)
+moma config set default_model ollama/llama3
+
+# Set your API key
+moma config set api_key sk-xxxxxxxxxxxx
+
+# Reset system prompt to default
+moma config reset
+```
+
+## Security modes
+
+- **smart** – read‑only shell commands are auto‑executed, mutating commands require confirmation.
+- **strict** – all shell commands require confirmation.
+- **permissive** – all commands run without prompts.
+
+Change the mode with:
+
+```bash
+moma /security
+```
+
+## Example workflow
+
+1. **Start chat** – `moma`
+2. **Ask a question** – e.g., `How can I improve this function?`
+3. **Review suggestions** – the assistant may propose a diff.
+4. **Apply changes** – confirm the diff when prompted.
+
+Enjoy coding with AI assistance!

moma_cli-0.0.1/moma/__init__.py

@@ -0,0 +1,4 @@
+"""MOMA CLI - A terminal-based AI coding assistant."""
+
+__version__ = "0.0.1"
+__author__ = "MOMA CLI, Moma Team"

moma_cli-0.0.1/moma/agent.py

@@ -0,0 +1,360 @@
+"""Agent module for MOMA CLI.
+
+Manages conversation history, system prompts, and handles the litellm
+completion loop including tool calling/function execution.
+"""
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Generator
+
+import litellm
+from rich.console import Console
+from rich.prompt import Prompt
+
+from moma.config import ConfigManager, get_config
+from moma.security import SecurityPolicy, confirm_command
+from moma.tools import TOOLS, execute_tool_call, TOOL_FUNCTIONS
+from moma.diff_applier import propose_file_write, CodeProposal, apply_proposal
+
+
+class ConversationHistory:
+    """Manages the conversation history with the LLM."""
+
+    def __init__(self):
+        """Initialize the conversation history."""
+        self.messages: List[Dict[str, Any]] = []
+
+    def add_system(self, prompt: str) -> None:
+        """Add a system message."""
+        self.messages.append({"role": "system", "content": prompt})
+
+    def add_user(self, content: str) -> None:
+        """Add a user message."""
+        self.messages.append({"role": "user", "content": content})
+
+    def add_assistant(self, content: Optional[str], tool_calls: Optional[List[Dict]] = None) -> None:
+        """Add an assistant message."""
+        msg: Dict[str, Any] = {"role": "assistant"}
+        msg["content"] = content if content is not None else ""
+        if tool_calls:
+            msg["tool_calls"] = tool_calls
+        self.messages.append(msg)
+
+    def add_tool_result(self, tool_call_id: str, name: str, content: str, is_error: bool = False) -> None:
+        """Add a tool result message."""
+        self.messages.append({
+            "role": "tool",
+            "tool_call_id": tool_call_id,
+            "name": name,
+            "content": content,
+        })
+
+    def get_messages(self) -> List[Dict[str, Any]]:
+        """Get all messages."""
+        return self.messages.copy()
+
+    def clear(self) -> None:
+        """Clear all messages (keeps system message if any)."""
+        system_msgs = [m for m in self.messages if m["role"] == "system"]
+        self.messages.clear()
+        for msg in system_msgs:
+            self.messages.append(msg)
+
+    def __len__(self) -> int:
+        return len(self.messages)
+
+
+class Agent:
+    """The main agent that handles LLM interaction."""
+
+    MAX_TOOL_DEPTH = 10
+
+    def __init__(self, config: Optional[ConfigManager] = None, console: Optional[Console] = None):
+        """Initialize the agent."""
+        self.config = config or get_config()
+        self.console = console or Console()
+        self.history = ConversationHistory()
+        self.security = SecurityPolicy(mode=self.config.get_security_mode())
+        self._task_completed = False
+        self._tools_supported = True  # flipped off if backend rejects tool_choice
+        self._setup()
+
+    def _setup(self) -> None:
+        """Set up the agent with system prompt and defaults."""
+        system_prompt = self.config.get_system_prompt()
+        self.history.add_system(system_prompt)
+
+    def _get_model(self) -> str:
+        """Get the LLM model to use, auto-prefixing with 'openai/' for the proxy."""
+        model = self.config.get("default_model", "openai/gpt-4o")
+        if "/" not in model:
+            model = f"openai/{model}"
+        return model
+
+    def _get_temperature(self) -> float:
+        """Get the temperature setting."""
+        return self.config.get("temperature", 0.7)
+
+    def _get_max_tokens(self) -> int:
+        """Get the max tokens setting."""
+        return self.config.get("max_tokens", 4096)
+
+    def _resolve_api_key(self) -> str:
+        """Return the configured API key, falling back to env vars."""
+        import os
+        key = self.config.get("api_key")
+        if key:
+            return key
+        return os.environ.get("LITELLM_API_KEY") or os.environ.get("OPENAI_API_KEY") or "sk-no-key"
+
+    def _build_environment_details(self) -> str:
+        """Build environment context with the current directory file tree."""
+        cwd = Path.cwd()
+        IGNORE = {"__pycache__", ".git", "node_modules", ".venv", "venv", "env",
+                  "dist", "build", ".pytest_cache", ".mypy_cache", ".ruff_cache"}
+        try:
+            entries = []
+            for item in sorted(cwd.rglob("*")):
+                parts = item.relative_to(cwd).parts
+                if any(p in IGNORE or p.startswith(".") for p in parts):
+                    continue
+                rel = str(item.relative_to(cwd))
+                entries.append(f"{rel}{'/' if item.is_dir() else ''}")
+            file_list = "\n".join(entries[:500])
+            return (
+                f"<environment_details>\n"
+                f"Current Working Directory: {cwd}\n\n"
+                f"File Tree:\n{file_list}\n"
+                f"</environment_details>"
+            )
+        except Exception:
+            return f"<environment_details>\nCurrent Working Directory: {cwd}\n</environment_details>"
+
+    def chat(self, user_message: str) -> Generator[str, None, None]:
+        """Process a user message and yield the response.
+
+        Yields:
+            Text chunks of the response.
+        """
+        # Inject file tree context on the first user message
+        if len(self.history.messages) <= 1:
+            env = self._build_environment_details()
+            full_message = f"{user_message}\n\n{env}"
+        else:
+            full_message = user_message
+        self.history.add_user(full_message)
+        self._task_completed = False
+        self.console.print("\n[bold blue]🤔 MOMA Assistant is thinking...[/bold blue]")
+        yield from self._run_round()
+
+    def _run_round(self, depth: int = 0) -> Generator[str, None, None]:
+        """Make one LLM API call and handle the full response including tool calls.
+
+        Recurses up to MAX_TOOL_DEPTH times to handle chained tool use.
+        """
+        if depth >= self.MAX_TOOL_DEPTH:
+            self.console.print("\n[yellow]⚠️ Maximum tool call depth reached.[/yellow]")
+            return
+
+        model = self._get_model()
+        temperature = self._get_temperature()
+        max_tokens = self._get_max_tokens()
+        api_key = self._resolve_api_key()
+        api_base = self.config.get("api_base")
+        messages = self.history.get_messages()
+
+        def _call_llm(with_tools: bool):
+            return litellm.completion(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                api_key=api_key,
+                api_base=api_base,
+                stream=True,
+                tools=TOOLS if with_tools else None,
+            )
+
+        try:
+            try:
+                response = _call_llm(self._tools_supported)
+            except litellm.BadRequestError as e:
+                if self._tools_supported and "tool choice" in str(e).lower():
+                    self._tools_supported = False
+                    self.console.print("[yellow]⚠️  Tool calling disabled (model doesn't support it)[/yellow]")
+                    response = _call_llm(False)
+                else:
+                    raise
+
+            response_content = ""
+            response_tool_calls: List[Dict] = []
+            has_tool_calls = False
+
+            for chunk in response:
+                if chunk.choices:
+                    choice = chunk.choices[0]
+                    if choice.delta.content:
+                        response_content += choice.delta.content
+                        yield choice.delta.content
+                    if choice.delta.tool_calls:
+                        has_tool_calls = True
+                        for tc in choice.delta.tool_calls:
+                            if tc.index is not None:
+                                while len(response_tool_calls) <= tc.index:
+                                    response_tool_calls.append({"id": "", "function": {"name": "", "arguments": ""}})
+                                # Capture id whenever it appears (not just on first/name chunk)
+                                if tc.id:
+                                    response_tool_calls[tc.index]["id"] = tc.id
+                                if tc.function:
+                                    if tc.function.name:
+                                        response_tool_calls[tc.index]["function"]["name"] = tc.function.name
+                                    if tc.function.arguments:
+                                        response_tool_calls[tc.index]["function"]["arguments"] += tc.function.arguments
+
+            if has_tool_calls:
+                # API protocol: assistant message with tool_calls must precede tool result messages
+                formatted_tool_calls = [
+                    {"id": tc["id"], "type": "function", "function": tc["function"]}
+                    for tc in response_tool_calls
+                ]
+                self.history.add_assistant(response_content, tool_calls=formatted_tool_calls)
+
+                self._process_tool_calls(response_tool_calls)
+
+                if not self._task_completed:
+                    self.console.print("\n[bold blue]🔄 Processing tool results...[/bold blue]")
+                    yield from self._run_round(depth + 1)
+            else:
+                self.history.add_assistant(response_content)
+
+        except litellm.exceptions.AuthenticationError as e:
+            self.console.print(f"\n[bold red]❌ Authentication Error:[/bold red] {e}")
+        except litellm.exceptions.ContextWindowExceededError:
+            self.console.print("\n[bold red]❌ Context window exceeded.[/bold red] Try /clear to reset history.")
+        except Exception as e:
+            self.console.print(f"\n[bold red]❌ Error:[/bold red] {e}")
+
+    def _process_tool_calls(self, response_tool_calls: List[Dict]) -> None:
+        """Execute tool calls and record results in history.
+
+        Sets self._task_completed = True and returns early if attempt_completion is called.
+        """
+        for tc in response_tool_calls:
+            tool_call = {
+                "id": tc.get("id", ""),
+                "name": tc["function"]["name"],
+                "arguments": tc["function"]["arguments"],
+            }
+
+            try:
+                args = json.loads(tc["function"]["arguments"]) if tc["function"]["arguments"] else {}
+            except json.JSONDecodeError:
+                args = {}
+
+            tool_name = tool_call["name"]
+            tool_result = ""
+
+            if tool_name == "execute_command":
+                command = args.get("command", "")
+                requires_approval = args.get("requires_approval", True)
+
+                self.console.print(f"\n[bold]🔧 Executing command:[/bold] [cyan]{command}[/cyan]")
+
+                validation = self.security.validate_command(command)
+
+                if not validation["allowed"]:
+                    # Hard block — never execute regardless of user input
+                    self.console.print(f"\n[bold red]⛔ BLOCKED:[/bold red] Security policy forbids: [cyan]{command}[/cyan]")
+                    tool_result = json.dumps({
+                        "success": False,
+                        "error": "Command is blocked by security policy",
+                        "command": command,
+                    })
+                elif requires_approval and validation["requires_confirmation"]:
+                    confirmed = confirm_command(command, validation.get("category", "mutating"))
+                    if not confirmed:
+                        tool_result = json.dumps({
+                            "success": False,
+                            "error": "Command was rejected by user",
+                            "command": command,
+                        })
+                    else:
+                        result = TOOL_FUNCTIONS["execute_command"](command=command, requires_approval=False)
+                        tool_result = json.dumps(result)
+                else:
+                    result = TOOL_FUNCTIONS["execute_command"](command=command, requires_approval=False)
+                    tool_result = json.dumps(result)
+
+            elif tool_name == "propose_file_write":
+                file_path = args.get("path", "")
+                content = args.get("content", "")
+
+                if file_path and content:
+                    confirmed = propose_file_write(file_path, content, _console=self.console)
+                    if confirmed:
+                        # Actually write the file after user approval
+                        write_result = apply_proposal(CodeProposal(file_path, content))
+                        tool_result = json.dumps(write_result)
+                    else:
+                        tool_result = json.dumps({
+                            "success": False,
+                            "error": "Changes were rejected by user",
+                        })
+                else:
+                    tool_result = json.dumps({
+                        "success": False,
+                        "error": "Missing path or content",
+                    })
+
+            elif tool_name == "attempt_completion":
+                result_text = args.get("result", "")
+                self.console.print("\n[bold green]✅ Task completed:[/bold green]")
+                if result_text:
+                    from rich.markdown import Markdown as _Markdown
+                    self.console.print(_Markdown(result_text))
+                self._task_completed = True
+                return  # Don't add to history; stop processing further tool calls
+
+            elif tool_name == "ask_followup_question":
+                question = args.get("question", "")
+                options = args.get("options")
+
+                if options:
+                    self.console.print(f"\n[bold]{question}[/bold]")
+                    for i, opt in enumerate(options, 1):
+                        self.console.print(f"  [{i}] {opt}")
+                    answer = Prompt.ask("Select option", console=self.console, choices=[str(i) for i in range(1, len(options) + 1)])
+                    answer = options[int(answer) - 1]
+                else:
+                    self.console.print(f"\n[bold]{question}[/bold]")
+                    answer = Prompt.ask("Your answer", console=self.console)
+
+                tool_result = json.dumps({"success": True, "answer": answer})
+
+            else:
+                result = execute_tool_call(tool_call)
+                tool_result = result["content"]
+
+            # Derive is_error from the "success" key (not the absent "is_error" key)
+            try:
+                is_error = not json.loads(tool_result).get("success", True) if tool_result.startswith("{") else False
+            except (json.JSONDecodeError, AttributeError):
+                is_error = False
+
+            self.history.add_tool_result(tool_call["id"], tool_name, tool_result, is_error=is_error)
+
+    def clear_history(self) -> None:
+        """Clear the conversation history."""
+        self.history.clear()
+        self.console.print("[green]✅ Conversation history cleared.[/green]")
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get the current agent status."""
+        return {
+            "model": self._get_model(),
+            "security_mode": self.config.get_security_mode(),
+            "history_length": len(self.history),
+            "temperature": self._get_temperature(),
+            "max_tokens": self._get_max_tokens(),
+        }