AntGravityCLI 1.0.2__py3-none-any.whl

antgravity_cli/config.py

@@ -0,0 +1,68 @@
+import os
+import click
+from colorama import Fore, Style
+from google.antigravity import LocalAgentConfig
+from google.antigravity.hooks import policy
+
+from . import i18n
+from .handlers import cli_ask_user_handler
+
+def setup_agent_config(model, yolo, workspace, system_instruction, api_key, skills_path) -> LocalAgentConfig:
+    """Configures and returns the agent's LocalAgentConfig, resolving keys, paths, and policies."""
+    # 1. Resolve API Key
+    resolved_api_key = api_key or os.environ.get("GEMINI_API_KEY")
+    if not resolved_api_key:
+        raise ValueError(i18n.t("config", "api_key_not_found"))
+
+    # 2. Configure Permission Policies
+    resolved_workspace = [os.path.abspath(w) for w in workspace] if workspace else [os.path.abspath(".")]
+    policies_list = []
+    for p in policy.workspace_only(resolved_workspace):
+        policies_list.append(p)
+
+    if yolo:
+        policies_list.append(policy.allow_all())
+        click.echo(f"{Fore.LIGHTRED_EX}{i18n.t('config', 'yolo_warning')}{Style.RESET_ALL}")
+    else:
+        for p in policy.confirm_run_command(handler=cli_ask_user_handler):
+            policies_list.append(p)
+
+    # 3. Resolve System Instructions
+    sys_inst = None
+    if system_instruction:
+        if os.path.isfile(system_instruction):
+            try:
+                with open(system_instruction, "r", encoding="utf-8") as f:
+                    sys_inst = f.read()
+            except Exception as e:
+                raise IOError(i18n.t("config", "error_reading_instructions", error=str(e)))
+        else:
+            sys_inst = system_instruction
+
+    # 4. Resolve Skills
+    raw_skills = list(skills_path) if skills_path else []
+    
+    # Always include the script's physical installation directory's .agents/skills folder
+    from .utils import get_base_path
+    base_dir = get_base_path()
+    cli_skills_dir = os.path.join(base_dir, ".agents", "skills")
+    if os.path.isdir(cli_skills_dir) and cli_skills_dir not in raw_skills:
+        raw_skills.append(cli_skills_dir)
+
+    # Normalize paths to absolute normalized format and deduplicate (preserving order)
+    resolved_skills = []
+    for path in raw_skills:
+        if path:
+            abs_path = os.path.abspath(os.path.normpath(path))
+            if abs_path not in resolved_skills:
+                resolved_skills.append(abs_path)
+
+    # 5. Build Agent Configuration
+    return LocalAgentConfig(
+        model=model,
+        api_key=resolved_api_key,
+        policies=policies_list,
+        system_instructions=sys_inst,
+        workspaces=resolved_workspace,
+        skills_paths=resolved_skills if resolved_skills else None
+    )

antgravity_cli/console_io.py

@@ -0,0 +1,167 @@
+import asyncio
+import re
+import colorama
+from colorama import Fore, Style
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.live import Live
+from . import i18n
+from .interfaces import OutputWriter, InputReader
+
+try:
+    from prompt_toolkit import PromptSession
+    from prompt_toolkit.completion import WordCompleter
+    from prompt_toolkit.formatted_text import ANSI
+    HAS_PROMPT_TOOLKIT = True
+except ImportError:
+    HAS_PROMPT_TOOLKIT = False
+
+if HAS_PROMPT_TOOLKIT:
+    # Pattern to match slash commands as a single word in prompt-toolkit
+    _PATTERN_CMD = re.compile(r'/[a-zA-Z0-9_-]*')
+
+    class CommandCompleter(WordCompleter):
+        """Custom WordCompleter that triggers only when the word before cursor starts with a slash '/'."""
+        def get_completions(self, document, complete_event):
+            word_before_cursor = ""
+            if self.pattern:
+                matches = list(self.pattern.finditer(document.text_before_cursor))
+                if matches:
+                    match = matches[-1]
+                    if match.end() == len(document.text_before_cursor):
+                        word_before_cursor = match.group()
+            
+            if not word_before_cursor.startswith('/'):
+                return
+                
+            yield from super().get_completions(document, complete_event)
+
+# Initialize colorama for console color support (especially Windows)
+colorama.init()
+
+class ConsoleOutputWriter(OutputWriter):
+    """Concrete terminal output writer using colorama and rich for Markdown (SRP)."""
+    def __init__(self):
+        self._first_text = True
+        self._console = Console(force_terminal=True)
+        self._text_buffer = ""
+        self._live = None
+        self._loading_active = False
+        self._loading_task = None
+
+    def _stop_live(self) -> None:
+        if self._live:
+            try:
+                self._live.stop()
+            except Exception:
+                pass
+            self._live = None
+
+    def start_loading(self, message: str = None) -> None:
+        """Starts the visual processing indicator (animated via asyncio with static fallback)."""
+        self._stop_live()
+        self.stop_loading()
+        
+        if message is None:
+            message = i18n.t("console_io", "thinking")
+        
+        # Remove trailing periods from the message so the animation controls the flow of dots
+        message = message.rstrip(".")
+        self._loading_active = True
+        try:
+            self._loading_task = asyncio.create_task(self._animate_loading(message))
+        except RuntimeError:
+            print(f"{Fore.GREEN}{Style.BRIGHT}{message}...{Style.RESET_ALL}", end="", flush=True)
+            self._loading_task = None
+
+    async def _animate_loading(self, message: str) -> None:
+        """Coroutine that animates the growing loading dots."""
+        dots = 0
+        try:
+            while self._loading_active:
+                dots_str = "." * dots + " " * (3 - dots)
+                print(f"\r{Fore.GREEN}{Style.BRIGHT}{message}{dots_str}{Style.RESET_ALL}", end="", flush=True)
+                await asyncio.sleep(0.5)
+                dots = (dots + 1) % 4
+        except asyncio.CancelledError:
+            pass
+
+    def stop_loading(self) -> None:
+        """Stops the visual processing indicator and clears the line."""
+        if self._loading_active:
+            self._loading_active = False
+            if self._loading_task:
+                self._loading_task.cancel()
+                self._loading_task = None
+            # Clear the line by overwriting it with spaces using carriage return
+            print("\r" + " " * 40 + "\r", end="", flush=True)
+
+    def write_thought(self, text: str) -> None:
+        self.stop_loading()
+        self._stop_live()
+        # Thoughts in dim/italic tone using rich
+        self._console.print(f"[dim]{text}[/dim]", end="", highlight=False)
+
+    def write_text(self, text: str) -> None:
+        self.stop_loading()
+        if self._first_text:
+            self._console.print(f"\n[bold magenta]AntGravity > [/bold magenta]")
+            self._first_text = False
+            self._text_buffer = ""
+            # Initializes real-time (Live) Markdown rendering
+            self._live = Live(Markdown(self._text_buffer), console=self._console, auto_refresh=True)
+            self._live.start()
+        
+        self._text_buffer += text
+        if self._live:
+            self._live.update(Markdown(self._text_buffer))
+
+    def write_tool_call(self, name: str, args: dict) -> None:
+        self.stop_loading()
+        self._stop_live()
+        self._console.print(f"\n[yellow]{i18n.t('console_io', 'tool_calling', name=name, args=args)}[/yellow]")
+
+    def write_tool_result(self, name: str, result: str, error: str = None) -> None:
+        self.stop_loading()
+        self._stop_live()
+        if error:
+            self._console.print(f"\n[red]{i18n.t('console_io', 'tool_error', name=name, error=error)}[/red]")
+        else:
+            self._console.print(f"\n[blue]{i18n.t('console_io', 'tool_result', name=name, result=result)}[/blue]")
+
+    def reset(self) -> None:
+        """Resets the writer state for a new text stream."""
+        self.stop_loading()
+        self._stop_live()
+        self._first_text = True
+        self._text_buffer = ""
+
+
+class ConsoleInputReader(InputReader):
+    """Concrete terminal input reader using input() or prompt_toolkit (SRP)."""
+    def __init__(self):
+        self._session = None
+
+    async def read_input(self, prompt_text: str, suggestions: list[str] = None) -> str:
+        prompt_with_color = f"\n{Fore.CYAN}{prompt_text}{Style.RESET_ALL}"
+        
+        if HAS_PROMPT_TOOLKIT and suggestions:
+            try:
+                # Initialize the session on-demand to avoid failure during instantiation in tests or CI/CD
+                if self._session is None:
+                    self._session = PromptSession()
+                
+                completer = CommandCompleter(suggestions, ignore_case=True, pattern=_PATTERN_CMD)
+                # Use prompt_toolkit's async session integrated with asyncio
+                return (await self._session.prompt_async(
+                    ANSI(prompt_with_color),
+                    completer=completer,
+                    complete_while_typing=True
+                )).strip()
+            except (KeyboardInterrupt, EOFError):
+                raise
+            except Exception:
+                # Safe fallback to native input() in case of prompt_toolkit errors (e.g. NoConsoleScreenBufferError)
+                return input(prompt_with_color).strip()
+        else:
+            return input(prompt_with_color).strip()

antgravity_cli/handlers.py

@@ -0,0 +1,18 @@
+import colorama
+from colorama import Fore, Style
+
+from . import i18n
+
+# Initialize colorama for console color support (especially Windows)
+colorama.init()
+
+def cli_ask_user_handler(tool_call) -> bool:
+    """Handler to request user approval in the terminal in safe mode."""
+    print(f"\n{Fore.LIGHTYELLOW_EX}{i18n.t('handlers', 'agent_wants_to_execute', name=tool_call.name)}{Style.RESET_ALL}")
+    print(f"{i18n.t('handlers', 'arguments', args=tool_call.args)}")
+    try:
+        ans = input(f"{Fore.CYAN}{i18n.t('handlers', 'allow_execution')}{Style.RESET_ALL}").strip().lower()
+        return ans in ('y', 'yes', 'sim', 's')
+    except (KeyboardInterrupt, EOFError):
+        print(f"\n{i18n.t('handlers', 'denied_by_interruption')}")
+        return False

antgravity_cli/i18n.py

@@ -0,0 +1,73 @@
+import os
+import json
+from typing import Dict, Any
+
+_current_language = "en-us"
+_translation_cache: Dict[str, Dict[str, str]] = {}
+
+def set_language(lang: str) -> None:
+    """Sets the active language for CLI output messages."""
+    global _current_language
+    if lang:
+        _current_language = lang.lower().strip()
+
+def get_language() -> str:
+    """Returns the currently active language code."""
+    return _current_language
+
+def _load_translations(lang: str, module: str) -> Dict[str, str]:
+    """Loads translations from translate/{lang}/{module}.json with caching."""
+    cache_key = f"{lang}/{module}"
+    if cache_key in _translation_cache:
+        return _translation_cache[cache_key]
+
+    # Resolve translations directory relative to this file, compatible with PyInstaller
+    from .utils import get_base_path
+    base_dir = get_base_path()
+    json_path = os.path.join(base_dir, "translate", lang, f"{module}.json")
+
+    translations = {}
+    if os.path.isfile(json_path):
+        try:
+            with open(json_path, "r", encoding="utf-8") as f:
+                translations = json.load(f)
+        except Exception:
+            # Fallback to empty dict on load errors
+            translations = {}
+            
+    _translation_cache[cache_key] = translations
+    return translations
+
+def t(module: str, key: str, **kwargs: Any) -> str:
+    """
+    Returns the translated string for a given module and key.
+    Falls back to en-us if the key is missing in the current language, 
+    and returns the key itself if not found anywhere.
+    """
+    # 1. Try to get translation in active language
+    lang_translations = _load_translations(_current_language, module)
+    message = lang_translations.get(key)
+
+    # 2. Fall back to en-us if not found and current is not en-us
+    if message is None and _current_language != "en-us":
+        en_translations = _load_translations("en-us", module)
+        message = en_translations.get(key)
+
+    # 3. Fall back to the key itself if still not found
+    if message is None:
+        message = key
+
+    # 4. Format string if arguments are passed
+    if kwargs:
+        try:
+            return message.format(**kwargs)
+        except (KeyError, ValueError, IndexError) as e:
+            import warnings
+            warnings.warn(
+                f"Translation formatting failed for key '{module}.{key}' (lang: '{_current_language}'). "
+                f"Format arguments mismatch. Error: {e}",
+                UserWarning,
+                stacklevel=2
+            )
+
+    return message

antgravity_cli/interfaces.py

@@ -0,0 +1,44 @@
+from abc import ABC, abstractmethod
+from typing import Tuple, List
+
+class DirectiveProcessor(ABC):
+    """Base interface for prompt directive processors (LSP/OCP)."""
+    @abstractmethod
+    def process(self, prompt: str, skills_paths: list[str] = None) -> Tuple[str, list[str]]:
+        """
+        Processes the prompt and returns a tuple containing the updated prompt and a list
+        of strings containing the extra context to be injected.
+        """
+        pass
+
+class OutputWriter(ABC):
+    """Base interface for agent communication outputs (DIP/ISP)."""
+    @abstractmethod
+    def write_thought(self, text: str) -> None:
+        pass
+
+    @abstractmethod
+    def write_text(self, text: str) -> None:
+        pass
+
+    @abstractmethod
+    def write_tool_call(self, name: str, args: dict) -> None:
+        pass
+
+    @abstractmethod
+    def write_tool_result(self, name: str, result: str, error: str = None) -> None:
+        pass
+
+    def start_loading(self, message: str = "Thinking...") -> None:
+        """Starts a visual processing indicator (optional)."""
+        pass
+
+    def stop_loading(self) -> None:
+        """Stops the visual processing indicator (optional)."""
+        pass
+
+class InputReader(ABC):
+    """Base interface for user text input (DIP/ISP)."""
+    @abstractmethod
+    async def read_input(self, prompt_text: str, suggestions: list[str] = None) -> str:
+        pass

antgravity_cli/list_skills.py

@@ -0,0 +1,53 @@
+import os
+from . import i18n
+
+def discover_skills_in_paths(paths: list[str]) -> list[str]:
+    """Scans the provided directories for subfolders containing a SKILL.md file and returns sorted skill names."""
+    skills = []
+    if not paths:
+        return []
+    for path in paths:
+        if path and os.path.exists(path) and os.path.isdir(path):
+            try:
+                for entry in os.listdir(path):
+                    entry_path = os.path.join(path, entry)
+                    if os.path.isdir(entry_path):
+                        if os.path.exists(os.path.join(entry_path, "SKILL.md")):
+                            skills.append(entry)
+            except Exception:
+                pass
+    return sorted(list(set(skills)))
+
+def get_skills() -> list[str]:
+    """Returns a sorted list of directory names inside .agents/skills."""
+    from .utils import get_base_path
+    base_dir = get_base_path()
+    skills_dir = os.path.join(base_dir, ".agents", "skills")
+    return discover_skills_in_paths([skills_dir])
+
+def main() -> None:
+    """Lists the names of the directories (skills) located in .agents/skills."""
+    # Resolve the active language from ANTGRAVITY_LANG env var if present
+    lang = os.environ.get("ANTGRAVITY_LANG", "en-us")
+    i18n.set_language(lang)
+
+    # Path to the local agent skills directory
+    from .utils import get_base_path
+    base_dir = get_base_path()
+    skills_dir = os.path.join(base_dir, ".agents", "skills")
+
+    if not os.path.isdir(skills_dir):
+        print(i18n.t("list_skills", "directory_not_found", directory=skills_dir))
+        return
+
+    skills = get_skills()
+    if not skills:
+        print(i18n.t("list_skills", "no_skills_found"))
+        return
+
+    print(i18n.t("list_skills", "skills_header"))
+    for skill in skills:
+        print(f"  - {skill}")
+
+if __name__ == "__main__":
+    main()

antgravity_cli/main.py

@@ -0,0 +1,52 @@
+import asyncio
+import os
+import sys
+import click
+from dotenv import load_dotenv
+from .utils import get_base_path
+
+# Load API keys and configurations from .env files
+# Check if a custom env file was specified via CLI arguments before processing options
+custom_env_path = None
+for i, arg in enumerate(sys.argv):
+    if arg in ("--env-file", "-e") and i + 1 < len(sys.argv):
+        custom_env_path = sys.argv[i + 1]
+        break
+
+if custom_env_path:
+    # If a custom .env path is provided, we load only it and let it override existing variables
+    if os.path.exists(custom_env_path):
+        load_dotenv(custom_env_path, override=True)
+else:
+    # 1. Load configuration from the script's installation directory .env (global defaults)
+    base_env = os.path.join(get_base_path(), ".env")
+    if os.path.exists(base_env):
+        load_dotenv(base_env)
+
+    # 2. Load configuration from the current working directory (CWD) .env (workspace-specific override)
+    cwd_env = os.path.abspath(".env")
+    if os.path.exists(cwd_env) and os.path.normcase(cwd_env) != os.path.normcase(os.path.abspath(base_env)):
+        load_dotenv(cwd_env, override=True)
+
+from .runner import run_cli
+
+@click.command()
+@click.argument('prompt', required=False)
+@click.option('--model', '-m', envvar='GEMINI_MODEL', default='gemini-3.1-flash-lite', help='Gemini model to be used.')
+@click.option('--yolo', '-y', is_flag=True, envvar='ANTGRAVITY_YOLO', help='Bypass safety confirmations and execute all actions automatically.')
+@click.option('--workspace', '-w', multiple=True, type=click.Path(exists=True, file_okay=False, dir_okay=True), envvar='ANTGRAVITY_WORKSPACE', help='Restrict file tools to these directories (default: current directory).')
+@click.option('--system-instruction', '-s', envvar='ANTGRAVITY_SYSTEM_INSTRUCTION', help='System instructions text or path to a file with instructions.')
+@click.option('--api-key', envvar='GEMINI_API_KEY', help='Gemini API key.')
+@click.option('--skills-path', '-k', multiple=True, type=click.Path(exists=True, file_okay=False, dir_okay=True), envvar='ANTGRAVITY_SKILLS_PATH', help='Path to skills folders (can be repeated).')
+@click.option('--silent', is_flag=True, envvar='ANTGRAVITY_SILENT', help='Hide thoughts and tool executions in the terminal.')
+@click.option('--verbose', '-v', is_flag=True, envvar='ANTGRAVITY_VERBOSE', help='Display the agent\'s internal reasoning thoughts in the console.')
+@click.option('--language', '-l', envvar='ANTGRAVITY_LANG', default='en-us', help='Output language (e.g. en-us, pt-br).')
+@click.option('--env-file', '-e', type=click.Path(exists=True, file_okay=True, dir_okay=False), help='Path to a custom .env file to load configurations from.')
+def main(prompt, model, yolo, workspace, system_instruction, api_key, skills_path, silent, verbose, language, env_file):
+    """AntGravity CLI - Terminal-based interface for Google Antigravity agents."""
+    asyncio.run(run_cli(prompt, model, yolo, workspace, system_instruction, api_key, skills_path, silent=silent, verbose=verbose, language=language))
+
+if __name__ == "__main__":
+    main()
+
+

antgravity_cli/parser.py

@@ -0,0 +1,106 @@
+import os
+import re
+from typing import Tuple, List
+from . import i18n
+from .interfaces import DirectiveProcessor
+
+class FileDirectiveProcessor(DirectiveProcessor):
+    """File and folder directive processor with the '@' prefix (SRP/OCP/LSP)."""
+    
+    def process(self, prompt: str, skills_paths: list[str] = None) -> Tuple[str, list[str]]:
+        extra_context = []
+        # Accepts @[path with spaces] or @path_without_spaces (avoids emails)
+        file_matches = re.finditer(r'(?<!\w)@(?:\[([^\]]+)\]|([^\s\x00-\x1F\x7F]+))', prompt)
+        files_to_inject = []
+        for match in file_matches:
+            path = match.group(1) or match.group(2)
+            # Clean common punctuation at the end of the path without brackets
+            if not match.group(1):
+                path = re.sub(r'[.,;:!?)]+$', '', path)
+            files_to_inject.append(path)
+
+        for filepath in files_to_inject:
+            if os.path.isfile(filepath):
+                try:
+                    with open(filepath, "r", encoding="utf-8") as f:
+                        content = f.read()
+                    extra_context.append(f"{i18n.t('parser', 'file_content_header', filename=os.path.basename(filepath), filepath=filepath)}\n{content}\n")
+                except Exception as e:
+                    extra_context.append(f"{i18n.t('parser', 'error_reading_file', filepath=filepath, error=str(e))}\n")
+            elif os.path.isdir(filepath):
+                try:
+                    entries = os.listdir(filepath)
+                    content = "\n".join(entries)
+                    extra_context.append(f"{i18n.t('parser', 'directory_listing_header', filepath=filepath)}\n{content}\n")
+                except Exception as e:
+                    extra_context.append(f"{i18n.t('parser', 'error_listing_directory', filepath=filepath, error=str(e))}\n")
+                    
+        return prompt, extra_context
+
+
+class SkillDirectiveProcessor(DirectiveProcessor):
+    """Skill directive processor with the '/' prefix (SRP/OCP/LSP)."""
+    
+    def process(self, prompt: str, skills_paths: list[str] = None) -> Tuple[str, list[str]]:
+        extra_context = []
+        # Ignores special REPL commands (/exit, /quit, /reset)
+        skill_matches = re.finditer(r'(?<!\w)/([a-zA-Z0-9_-]+)', prompt)
+        skills_to_inject = []
+        for match in skill_matches:
+            skill_name = match.group(1)
+            if skill_name in ("exit", "quit", "reset"):
+                continue
+            skills_to_inject.append(skill_name)
+
+        from .list_skills import discover_skills_in_paths
+
+        for skill_name in skills_to_inject:
+            paths_to_search = list(skills_paths) if skills_paths else []
+            if not paths_to_search:
+                from .utils import get_base_path
+                base_dir = get_base_path()
+                cli_skills_dir = os.path.join(base_dir, ".agents", "skills")
+                paths_to_search = ["skills", ".agents/skills", cli_skills_dir]
+            
+            # Unified dry discovery check
+            if skill_name in discover_skills_in_paths(paths_to_search):
+                for base_path in paths_to_search:
+                    skill_dir = os.path.join(base_path, skill_name)
+                    skill_md_path = os.path.join(skill_dir, "SKILL.md")
+                    if os.path.isfile(skill_md_path):
+                        try:
+                            with open(skill_md_path, "r", encoding="utf-8") as f:
+                                content = f.read()
+                            extra_context.append(f"{i18n.t('parser', 'skill_instructions_header', skill_name=skill_name)}\n{content}\n")
+                            break
+                        except Exception as e:
+                            extra_context.append(f"{i18n.t('parser', 'error_loading_skill', skill_name=skill_name, error=str(e))}\n")
+                        
+        return prompt, extra_context
+
+
+class PromptPreprocessor:
+    """Orchestrator for prompt preprocessing (SRP/OCP)."""
+    
+    def __init__(self, processors: list[DirectiveProcessor] = None):
+        self._processors = processors if processors is not None else [
+            FileDirectiveProcessor(),
+            SkillDirectiveProcessor()
+        ]
+
+    def preprocess(self, prompt: str, skills_paths: list[str] = None) -> str:
+        aggregated_context = []
+        current_prompt = prompt
+        for processor in self._processors:
+            current_prompt, extra_context = processor.process(current_prompt, skills_paths)
+            aggregated_context.extend(extra_context)
+            
+        if aggregated_context:
+            return current_prompt + "\n\n" + "\n".join(aggregated_context)
+        return current_prompt
+
+
+# Functional compatibility wrapper
+def preprocess_prompt(prompt: str, skills_paths: list[str] = None) -> str:
+    """Functional wrapper compatible with previous versions."""
+    return PromptPreprocessor().preprocess(prompt, skills_paths)

antgravity_cli/repl.py

@@ -0,0 +1,126 @@
+import sys
+try:
+    sys.stdout.reconfigure(encoding='utf-8')
+except Exception:
+    pass
+
+import asyncio
+import os
+import click
+from colorama import Fore, Style
+from google.antigravity.types import Thought, Text, ToolCall, ToolResult
+from . import i18n
+from .interfaces import OutputWriter, InputReader
+from .console_io import ConsoleOutputWriter, ConsoleInputReader
+from .parser import preprocess_prompt
+
+async def stream_chat_response(agent, prompt, writer: OutputWriter = None, silent=False, verbose=False):
+    """Runs the chat and streams the response (thoughts, tools, and text) in real time."""
+    if writer is None:
+        writer = ConsoleOutputWriter()
+        
+    try:
+        writer.reset()
+        writer.start_loading()
+        response = await agent.chat(prompt)
+        
+        async for chunk in response.chunks:
+            if isinstance(chunk, Thought):
+                if verbose and not silent:
+                    writer.write_thought(chunk.text)
+            elif isinstance(chunk, Text):
+                writer.write_text(chunk.text)
+            elif isinstance(chunk, ToolCall):
+                if not silent:
+                    writer.write_tool_call(chunk.name, chunk.args)
+            elif isinstance(chunk, ToolResult):
+                if not silent:
+                    writer.write_tool_result(chunk.name, chunk.result, chunk.error)
+        
+        writer.stop_loading()
+        writer.reset()
+        print() # Final line break for alignment
+    except Exception as e:
+        writer.stop_loading()
+        click.echo(i18n.t("repl", "error_during_conversation", error=str(e)), err=True)
+
+def _get_repl_suggestions(skills_paths: list[str]) -> list[str]:
+    """Scans registered skills folders and returns formatted skill commands and triggers."""
+    from .list_skills import discover_skills_in_paths
+    
+    suggestions = ["/exit", "/quit", "/reset"]
+    
+    # Resolve script's installation folder directory to load internal CLI skills
+    from .utils import get_base_path
+    base_dir = get_base_path()
+    cli_skills_dir = os.path.join(base_dir, ".agents", "skills")
+    
+    paths_to_search = list(skills_paths) if skills_paths else []
+    if not paths_to_search:
+        paths_to_search = ["skills", ".agents/skills", cli_skills_dir]
+        
+    discovered = discover_skills_in_paths(paths_to_search)
+    for s in discovered:
+        suggestions.append(f"/{s}")
+        
+    return sorted(list(set(suggestions)))
+
+async def run_repl(agent, resolved_skills, reader: InputReader = None, writer: OutputWriter = None, silent=False, verbose=False):
+    """Runs the interactive terminal (REPL) conversing with the agent."""
+    if reader is None:
+        reader = ConsoleInputReader()
+    if writer is None:
+        writer = ConsoleOutputWriter()
+        
+    suggestions = _get_repl_suggestions(resolved_skills)
+    
+    # Render Option 1 colorized solid block ant art logo
+    click.echo("")
+    click.echo(f"  {Fore.CYAN}▄▀▀▄       ▄▀▀▄{Style.RESET_ALL}")
+    click.echo(f"   {Fore.CYAN}▀▄ ▀▄   ▄▀ ▄▀{Style.RESET_ALL}")
+    click.echo(f"    {Fore.BLUE}▄█████████▄{Style.RESET_ALL}")
+    click.echo(f"   {Fore.BLUE}██{Fore.GREEN}███{Fore.BLUE}███{Fore.GREEN}███{Fore.BLUE}██{Style.RESET_ALL}")
+    click.echo(f"   {Fore.BLUE}█████████████{Style.RESET_ALL}")
+    click.echo(f"    {Fore.BLUE}▀█████████▀{Style.RESET_ALL}")
+    click.echo(f"      {Fore.CYAN}▄█▀ ▀█▄{Style.RESET_ALL}")
+        
+    click.echo(f"\n{Fore.MAGENTA}{Style.BRIGHT}{i18n.t('repl', 'repl_title')}{Style.RESET_ALL}")
+    click.echo(f"{Fore.CYAN}{i18n.t('repl', 'special_commands_label')}{Style.RESET_ALL}")
+    click.echo(f"  {Fore.GREEN}/exit{Style.RESET_ALL} or {Fore.GREEN}/quit{Style.RESET_ALL} - {i18n.t('repl', 'command_exit_desc')}")
+    click.echo(f"  {Fore.GREEN}/reset{Style.RESET_ALL}         - {i18n.t('repl', 'command_reset_desc')}")
+    
+    # Display active skills limited to 5 with an "and more" suffix
+    skills = [s.lstrip("/") for s in suggestions if s not in ("/exit", "/quit", "/reset")]
+    if skills:
+        formatted_skills = [f"  {Fore.GREEN}/{s}{Style.RESET_ALL}" for s in skills]
+        if len(formatted_skills) > 5:
+            for fs in formatted_skills[:5]:
+                click.echo(fs)
+            click.echo(f"  ... {i18n.t('repl', 'and_more')}")
+        else:
+            for fs in formatted_skills:
+                click.echo(fs)
+
+    click.echo(f"{Fore.MAGENTA}{'-' * 40}{Style.RESET_ALL}")
+
+    while True:
+        try:
+            user_input = await reader.read_input(i18n.t("repl", "prompt_you"), suggestions=suggestions)
+        except (KeyboardInterrupt, EOFError):
+            click.echo(f"\n{Fore.YELLOW}{i18n.t('repl', 'exiting')}{Style.RESET_ALL}")
+            break
+
+        if not user_input:
+            continue
+
+        if user_input in ("/exit", "/quit"):
+            click.echo(f"{Fore.YELLOW}{i18n.t('repl', 'exiting')}{Style.RESET_ALL}")
+            break
+
+        if user_input == "/reset":
+            agent.conversation.clear_history()
+            click.echo(i18n.t("repl", "conversation_history_cleared"))
+            continue
+
+        processed_input = preprocess_prompt(user_input, resolved_skills)
+        await stream_chat_response(agent, processed_input, writer, silent=silent, verbose=verbose)

antgravity_cli/runner.py

@@ -0,0 +1,31 @@
+import click
+from colorama import Fore, Style
+from google.antigravity import Agent
+
+from . import i18n
+from .config import setup_agent_config
+from .repl import run_repl, stream_chat_response
+from .parser import preprocess_prompt
+from .console_io import ConsoleOutputWriter, ConsoleInputReader
+
+async def run_cli(prompt, model, yolo, workspace, system_instruction, api_key, skills_path, silent=False, verbose=False, language="en-us"):
+    """Initializes the agent configurations and starts either a single execution or the REPL."""
+    i18n.set_language(language)
+    try:
+        config = setup_agent_config(model, yolo, workspace, system_instruction, api_key, skills_path)
+    except (ValueError, IOError) as e:
+        click.echo(f"{Fore.RED}{e}{Style.RESET_ALL}", err=True)
+        return
+
+    writer = ConsoleOutputWriter()
+    reader = ConsoleInputReader()
+
+    if prompt:
+        # Single Prompt
+        async with Agent(config) as agent:
+            processed_prompt = preprocess_prompt(prompt, config.skills_paths)
+            await stream_chat_response(agent, processed_prompt, writer, silent=silent, verbose=verbose)
+    else:
+        # Interactive Mode (REPL)
+        async with Agent(config) as agent:
+            await run_repl(agent, config.skills_paths, reader, writer, silent=silent, verbose=verbose)

antgravity_cli/translate/en-us/config.json

@@ -0,0 +1,5 @@
+{
+  "api_key_not_found": "Error: Gemini API key not found.\nSet the GEMINI_API_KEY environment variable or use the --api-key flag.",
+  "yolo_warning": "[WARNING] Running in YOLO mode. All tools will be allowed without confirmation.",
+  "error_reading_instructions": "Error reading system instructions file: {error}"
+}

antgravity_cli/translate/en-us/console_io.json

@@ -0,0 +1,6 @@
+{
+  "thinking": "Thinking",
+  "tool_calling": "[Tool] Calling: {name} with {args}",
+  "tool_error": "[Tool] Error in {name}: {error}",
+  "tool_result": "[Tool] Result from {name}: {result}"
+}

antgravity_cli/translate/en-us/handlers.json

@@ -0,0 +1,6 @@
+{
+  "agent_wants_to_execute": "[?] The agent wants to execute the tool: {name}",
+  "arguments": "    Arguments: {args}",
+  "allow_execution": "    Allow execution? [y/N]: ",
+  "denied_by_interruption": "    Denied by interruption."
+}

antgravity_cli/translate/en-us/interfaces.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/en-us/list_skills.json

@@ -0,0 +1,5 @@
+{
+  "skills_header": "Available Skills in .agents/skills:",
+  "no_skills_found": "No skills found in .agents/skills.",
+  "directory_not_found": "Directory not found: {directory}"
+}

antgravity_cli/translate/en-us/main.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/en-us/parser.json

@@ -0,0 +1,8 @@
+{
+  "file_content_header": "=== FILE CONTENT: {filename} ({filepath}) ===",
+  "error_reading_file": "[Error reading file {filepath}: {error}]",
+  "directory_listing_header": "=== DIRECTORY LISTING: {filepath} ===",
+  "error_listing_directory": "[Error listing directory {filepath}: {error}]",
+  "skill_instructions_header": "=== SKILL INSTRUCTIONS: {skill_name} ===",
+  "error_loading_skill": "[Error loading skill {skill_name}: {error}]"
+}

antgravity_cli/translate/en-us/repl.json

@@ -0,0 +1,12 @@
+{
+  "repl_title": "=== AntGravity CLI (Interactive Mode) ===",
+  "special_commands_label": "Type your messages. Special commands:",
+  "command_exit_desc": "Exit the CLI",
+  "command_reset_desc": "Reset conversation history",
+  "prompt_you": "You > ",
+  "exiting": "Exiting...",
+  "conversation_history_cleared": "Conversation history cleared!",
+  "error_during_conversation": "Error during conversation: {error}",
+  "and_more": "and more",
+  "skills_label": "Skills"
+}

antgravity_cli/translate/en-us/runner.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/en-us/test_cli.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/pt-br/config.json

@@ -0,0 +1,5 @@
+{
+  "api_key_not_found": "Erro: A chave de API do Gemini não foi encontrada.\nDefina a variável de ambiente GEMINI_API_KEY ou use a flag --api-key.",
+  "yolo_warning": "[AVISO] Executando em modo YOLO. Todas as ferramentas serão permitidas sem confirmação.",
+  "error_reading_instructions": "Erro ao ler arquivo de instruções: {error}"
+}

antgravity_cli/translate/pt-br/console_io.json

@@ -0,0 +1,6 @@
+{
+  "thinking": "Pensando",
+  "tool_calling": "[Ferramenta] Chamando: {name} com {args}",
+  "tool_error": "[Ferramenta] Erro em {name}: {error}",
+  "tool_result": "[Ferramenta] Resultado de {name}: {result}"
+}

antgravity_cli/translate/pt-br/handlers.json

@@ -0,0 +1,6 @@
+{
+  "agent_wants_to_execute": "[?] O agente deseja executar a ferramenta: {name}",
+  "arguments": "    Argumentos: {args}",
+  "allow_execution": "    Permitir execução? [y/N]: ",
+  "denied_by_interruption": "    Negado por interrupção."
+}

antgravity_cli/translate/pt-br/interfaces.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/pt-br/list_skills.json

@@ -0,0 +1,5 @@
+{
+  "skills_header": "Skills disponíveis em .agents/skills:",
+  "no_skills_found": "Nenhuma skill encontrada em .agents/skills.",
+  "directory_not_found": "Diretório não encontrado: {directory}"
+}

antgravity_cli/translate/pt-br/main.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/pt-br/parser.json

@@ -0,0 +1,8 @@
+{
+  "file_content_header": "=== CONTEÚDO DO ARQUIVO: {filename} ({filepath}) ===",
+  "error_reading_file": "[Erro ao ler o arquivo {filepath}: {error}]",
+  "directory_listing_header": "=== LISTAGEM DO DIRETÓRIO: {filepath} ===",
+  "error_listing_directory": "[Erro ao listar diretório {filepath}: {error}]",
+  "skill_instructions_header": "=== INSTRUÇÕES DA SKILL: {skill_name} ===",
+  "error_loading_skill": "[Erro ao carregar a skill {skill_name}: {error}]"
+}

antgravity_cli/translate/pt-br/repl.json

@@ -0,0 +1,12 @@
+{
+  "repl_title": "=== AntGravity CLI (Modo Interativo) ===",
+  "special_commands_label": "Digite suas mensagens. Comandos especiais:",
+  "command_exit_desc": "Sair do CLI",
+  "command_reset_desc": "Reiniciar o histórico da conversa",
+  "prompt_you": "Você > ",
+  "exiting": "Saindo...",
+  "conversation_history_cleared": "Histórico da conversa limpo!",
+  "error_during_conversation": "Erro durante a conversação: {error}",
+  "and_more": "e mais",
+  "skills_label": "Skills"
+}

antgravity_cli/translate/pt-br/runner.json

@@ -0,0 +1 @@
+{}

antgravity_cli/translate/pt-br/test_cli.json

@@ -0,0 +1 @@
+{}

antgravity_cli/utils.py

@@ -0,0 +1,10 @@
+import os
+import sys
+
+def get_base_path() -> str:
+    """Returns the base path of the project, compatible with PyInstaller standalone executable format."""
+    if getattr(sys, 'frozen', False):
+        # PyInstaller temp folder where execution assets are unpacked
+        return sys._MEIPASS
+    # Normal execution, resolve folder relative to utils.py location
+    return os.path.dirname(os.path.abspath(__file__))

antgravitycli-1.0.2.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: AntGravityCLI
+Version: 1.0.2
+Summary: A portable and interactive command-line interface (CLI) for the Google Antigravity ecosystem.
+Author-email: Henrique Fazolo <henriquefazolo@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/henriquefazolo/AntGravityCLI
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.4.2
+Requires-Dist: colorama>=0.4.6
+Requires-Dist: python-dotenv>=1.2.2
+Requires-Dist: google-antigravity>=0.1.5
+Requires-Dist: rich>=13.7.1
+Requires-Dist: prompt-toolkit>=3.0.43
+
+# AntGravity CLI
+
+<p align="center">
+  <img src=".img/ant%20gravity.png" alt="AntGravity CLI Logo" width="400">
+</p>
+
+A portable and interactive command-line interface (CLI) developed in Python to flexibly interact with agents from the **Google Antigravity** ecosystem.
+
+## Requirements
+
+- Python 3.11.7 (as configured in the development environment).
+- Installed dependencies (including `google-antigravity`, `click`, `colorama`, `python-dotenv`).
+
+## Installation and Setup
+
+1. Make sure the virtual environment is activated:
+   ```powershell
+   .\.venv\Scripts\activate
+   ```
+2. Configure your environment using a `.env` file. You can copy the template from [.env.example](file:///.env.example) to get started:
+   ```powershell
+   cp .env.example .env
+   ```
+
+### Environment Resolution and Default Values
+
+The CLI resolves configuration by loading `.env` files. By default, it loads them in two stages:
+1. **Physical CLI script installation folder**: Loads `.env` for global default configuration.
+2. **Current Working Directory (CWD)**: Loads `.env` for workspace-specific configurations (which override the global ones).
+
+Alternatively, you can load a custom `.env` file using the `--env-file` / `-e` option. When a custom `.env` file is specified, the default `.env` files (global and CWD) are **not** loaded automatically, giving you full control over the variables.
+
+If a `.env` file is not present or a specific variable is not set, the CLI falls back to the following default values:
+
+| Environment Variable | CLI Option | Description | Default Value |
+| :--- | :--- | :--- | :--- |
+| `GEMINI_API_KEY` | `--api-key` | Gemini API Key | *None (Required)* |
+| `GEMINI_MODEL` | `--model` / `-m` | Gemini Model to be used | `gemini-3.1-flash-lite` |
+| `ANTGRAVITY_LANG` | `--language` / `-l` | CLI UI Language | `en-us` |
+| `ANTGRAVITY_YOLO` | `--yolo` / `-y` | Run in YOLO (Safe-bypass) Mode | `False` (Safe Mode) |
+| `ANTGRAVITY_WORKSPACE` | `--workspace` / `-w` | Restricted workspace paths | *None (Current CWD)* |
+| `ANTGRAVITY_SYSTEM_INSTRUCTION` | `--system-instruction` / `-s` | System instruction or path | *None* |
+| `ANTGRAVITY_SKILLS_PATH` | `--skills-path` / `-k` | Custom workspace skills folders | *None* |
+| `ANTGRAVITY_SILENT` | `--silent` | Hide thoughts and tool execution logs | `False` |
+| `ANTGRAVITY_VERBOSE` | `--verbose` / `-v` | Show internal reasoning details | `False` |
+
+*(You can always override these values dynamically by passing their respective flags on the command line).*
+
+
+---
+
+## How to Use
+
+### 1. Single Prompt Mode
+To send a prompt and receive the response directly:
+```powershell
+python main.py "Write a greeting in Python"
+```
+
+### 2. Interactive Mode (REPL)
+To start a continuous chat with the agent (which maintains session history):
+```powershell
+python main.py
+```
+**Useful commands in Interactive Mode:**
+- `/reset`: Clears conversation history and resets agent context.
+- `/exit` or `/quit`: Closes the interactive terminal.
+
+**Auto-completion and Active Skills:**
+* **Real-time Auto-completion**: As you type `/` in the prompt (either at the start or mid-sentence), a dynamic dropdown menu displaying all special commands and active skills will instantly pop up. The auto-completion is case-insensitive, stays open stably when you delete characters (Backspace), and ignores regular chat text and trailing spaces to maintain a clean console.
+* **Banner Skills Listing**: At REPL startup, a welcome banner displays all available active workspace skills one per line, limited to 5. If more than 5 exist, a localized ellipsis (`... and more` or `... e mais`) is appended.
+* **Hybrid Skills Resolution**: By default (when `--skills-path` / `-k` is not specified), the welcome banner list, autocomplete menu, and prompt parser strictly load active skills from the CLI script's physical installation directory (`.agents/skills`), even when executing the CLI from or targeting a different CWD/workspace. This ensures that internal CLI utility skills (like `/gerar_skill_template` and `/gerenciar_deploy`) are always loaded and executable. If you explicitly pass one or more custom paths via the `--skills-path` / `-k` flag, the CLI dynamically loads **both** your custom/local workspace skills and the physical Ant installation skills simultaneously, giving you access to both sets of tools in the REPL session.
+
+### 3. Safe Mode vs YOLO Mode
+- **Safe Mode (Default)**: Whenever the agent tries to run risky terminal commands (like the `RUN_COMMAND` tool), the CLI will request your permission in the console (`[y/N]`) before proceeding.
+- **YOLO Mode (`-y` / `--yolo`)**: Disables all safety confirmations and executes all actions autonomously.
+  ```powershell
+  python main.py -y "Create a folder named test and list the directory"
+  ```
+
+### 4. Listing Available Skills
+You can quickly scan and list the names of all active local agent skills folders registered in `.agents/skills/` using the utility script:
+```powershell
+python list_skills.py
+```
+*(This script supports localization, reading the system language from the `ANTGRAVITY_LANG` environment variable).*
+
+---
+
+## Available Options
+
+You can customize the CLI behavior using flags:
+
+| Flag | Shortcut | Env Variable | Description |
+| :--- | :--- | :--- | :--- |
+| `--model` | `-m` | `GEMINI_MODEL` | Specifies the Gemini model (default: `gemini-3.1-flash-lite`). |
+| `--yolo` | `-y` | `ANTGRAVITY_YOLO` | Skips all permissions/confirmations and runs everything freely. |
+| `--workspace` | `-w` | `ANTGRAVITY_WORKSPACE` | Restricts file tools to a specific directory (can be repeated). |
+| `--system-instruction` | `-s` | `ANTGRAVITY_SYSTEM_INSTRUCTION` | Text with custom system instructions or path to a text file. |
+| `--api-key` | | `GEMINI_API_KEY` | Passes the API key directly on the command line. |
+| `--skills-path` | `-k` | `ANTGRAVITY_SKILLS_PATH` | Path to skills folders (can be repeated). If not provided and the `./skills` folder exists, it will be loaded by default. |
+| `--silent` | | `ANTGRAVITY_SILENT` | Hides internal thoughts and tool calls in the terminal. |
+| `--verbose` | `-v` | `ANTGRAVITY_VERBOSE` | Displays the AI's internal reasoning thoughts (Chain of Thought) in gray on the console. |
+| `--language` | `-l` | `ANTGRAVITY_LANG` | Specifies the output translation language (default: `en-us`, e.g. `pt-br`, `en-us`). |
+| `--env-file` | `-e` | | Path to a custom `.env` file to load configurations from (bypasses default global and local .env files). |
+
+Advanced usage example:
+```powershell
+python main.py -m gemini-3.5-flash -y -s "You are a concise assistant speaking Spanish" "Hello!"
+```
+
+---
+
+## Localization (i18n)
+
+The AntGravity CLI features built-in internationalization (i18n). Output messages, error states, and terminal prompts are decoupled from the core source code and stored as localized translation files inside the `translate/` directory.
+
+### Structure of `translate/`
+```text
+translate/
+├── pt-br/                         # Brazilian Portuguese translations
+│   ├── config.json
+│   ├── console_io.json
+│   ├── handlers.json
+│   ├── parser.json
+│   └── repl.json
+└── en-us/                         # English translations (Default)
+    ├── config.json
+    ├── console_io.json
+    ├── handlers.json
+    ├── parser.json
+    └── repl.json
+```
+
+### Adding New Languages
+To support a new language (e.g. `es-es` for Spanish):
+1. Create a new directory named after the locale code inside `translate/` (e.g. `translate/es-es/`).
+2. Copy the JSON files from `translate/en-us/` into the new folder and translate their text values.
+3. Switch the CLI runtime language using the `--language es-es` flag.
+
+---
+
+## Customization and Settings (`.agents`)
+
+The `.agents` folder at the root of your project is the **Local Workspace Customization** folder. Through it, you can define rules, create new skills, and customize agent responses.
+
+### Complete Structure of `.agents`
+
+```text
+my-project/
+└── .agents/
+    ├── AGENTS.md                  # Project rules and guidelines
+    ├── skills.json                # (Optional) Skills configuration and registration
+    └── skills/                    # Folder containing specific skills
+        └── gerenciar_deploy/      # Example of a skill
+            ├── SKILL.md           # Skill instructions and triggers (Required)
+            ├── scripts/           # Supporting scripts
+            ├── examples/          # Usage/code examples
+            └── references/        # Reference documentation
+```
+
+### 1. Project Rules (`AGENTS.md`)
+The `.agents/AGENTS.md` file defines the general rules of behavior, style, and technical constraints that the agent must follow in this project (e.g., code pattern, language, preferred frameworks).
+
+*There is also the global scope at `C:\Users\<user>\.gemini\config\AGENTS.md` for rules that apply to the entire machine.*
+
+### 2. Skills (`skills/`)
+**Skills** are packages of behavior and tools dynamically loaded depending on conversation context or user request.
+
+*   **The `SKILL.md` file (Required)**:
+    Defines YAML metadata (used by the AI for auto-activation) and the body with the skill instructions:
+    ```markdown
+    ---
+    name: "Utility Development Tools"
+    description: "Useful for any general development, automation, scripting, or workspace query task."
+    ---
+
+    # Skill Instructions
+    Whenever the user requests an automation or script execution:
+    1. Analyze the prompt and use the corresponding tools in `scripts/`.
+    2. Explain the execution result at the end.
+    ```
+*   **Scripts (`scripts/`)**:
+    Any executable script inserted in the `scripts/` folder will be automatically exposed as a tool that the agent can run (e.g., `gerenciar_deploy.script_name`).
+
+### 3. Skills Registration (`skills.json`)
+The `skills.json` file at the root of the `.agents/` folder allows inheriting skills from other shared directories or disabling default skills:
+```json
+{
+  "entries": [
+    { "path": "path/to/external/skills" }
+  ],
+  "exclude": [
+    "skill_name_to_ignore"
+  ]
+}
+```
+
+---
+
+## Agent Personality and Instructions
+
+The agent's personality, tone of voice, and behavioral guidelines are resolved at multiple levels of precedence:
+
+1. **Initialization Flag (`-s` / `--system-instruction`)**:
+   Defines system instructions directly in command execution (free text or file path).
+2. **Local and Global Rules (`AGENTS.md`)**:
+   Read from `.agents/AGENTS.md` (local) and `C:\Users\<user>\.gemini\config\AGENTS.md` (global).
+3. **Skill Instructions (`SKILL.md`)**:
+   Merged into the chat context when the corresponding skill is activated.
+4. **Default Personality (Fallback)**:
+   If no instruction is provided, assumes the default profile of the Google Antigravity ecosystem.

antgravitycli-1.0.2.dist-info/RECORD

@@ -0,0 +1,37 @@
+antgravity_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+antgravity_cli/config.py,sha256=OFoDKgC8QAN-x9VFuc50w00u_teKEumxPtvowqs66Nw,2635
+antgravity_cli/console_io.py,sha256=-MBiKfMAQqt3FlBu5XPgB7jR0gukUrV0P3i0ZoZnOgw,6692
+antgravity_cli/handlers.py,sha256=nTUxxXqeOrnx2oKnAugo2sHAYcl9qJO4P5ZPM7IyMOY,759
+antgravity_cli/i18n.py,sha256=DOuWah-phrj3cNbAFpWX7KzHoe5vDA_BY9myhqP03qo,2538
+antgravity_cli/interfaces.py,sha256=mInXwjWvCVbaAoB0dlulQ9f9oaz8H3oav1rN14_4EI4,1399
+antgravity_cli/list_skills.py,sha256=n9EAGmbokBlwz5ItA3lJXOquxqpKm3AeQlbtQPKAwlw,1856
+antgravity_cli/main.py,sha256=tb_d7E2ZhISyjSevo8D_AjG_wCp0tmIt-VazLI2qfZ4,3103
+antgravity_cli/parser.py,sha256=d4z52Kk9N9Il99u4BF_Q2TIDbho-5XvF2nO4YO4cFs0,4978
+antgravity_cli/repl.py,sha256=f-6l1HWxU3B0Lv8OqH_mZ0jTDvBq6v9z7EO0LSaqhUo,5411
+antgravity_cli/runner.py,sha256=fuZolo8vVDj1SxLeKhXboGMSyi1hebIUvjbBc40Hj6I,1317
+antgravity_cli/utils.py,sha256=OsCOV6Jiqv9r--r1VjL5I-zCshOSkU-oK8NBLYndVCM,415
+antgravity_cli/translate/en-us/config.json,sha256=2aBF4VFJ-42yBBDC_cKHCeiYeuvm6ZtPr3htif_yLcQ,318
+antgravity_cli/translate/en-us/console_io.json,sha256=8s8SSd-xR-0gtbvR4lm4mJ69pF8mwFV-iGpQpdJmK4M,192
+antgravity_cli/translate/en-us/handlers.json,sha256=7YZ87aMaLAi0tEDQUxrgAVu9pZr7Dmomi35N0TvyGv0,234
+antgravity_cli/translate/en-us/interfaces.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/en-us/list_skills.json,sha256=I4JaubRVcb4DZP3o5No6DD_I0ETY0-gfNkQqIXw8t8A,181
+antgravity_cli/translate/en-us/main.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/en-us/parser.json,sha256=Lo4Ytm1-xuwXiDyO4FAh0fovf-0thHBZgKKpMCaptmA,441
+antgravity_cli/translate/en-us/repl.json,sha256=0qw-nz5sAxo--a7EHXeUf2gk_uLwfeXnHyQp8VglCLE,469
+antgravity_cli/translate/en-us/runner.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/en-us/test_cli.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/pt-br/config.json,sha256=01WnE9g5XkoV_0wWY7yn33cIsAH4yYXMYqqRv5P34F8,345
+antgravity_cli/translate/pt-br/console_io.json,sha256=3fQrzAwNHZz1hBSUwulIwfrBC_eKKyJj34eSzFQtu_8,210
+antgravity_cli/translate/pt-br/handlers.json,sha256=r1B6VmZgCHyh6nvw5LxBFgnfV0Rkq_PhBely2_9a0pw,243
+antgravity_cli/translate/pt-br/interfaces.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/pt-br/list_skills.json,sha256=LVBQCfj0yAYxDnCJCLUicoczxwEsztB7XRThO8ZsmRc,200
+antgravity_cli/translate/pt-br/main.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/pt-br/parser.json,sha256=zZn5NzwifjF8LW3e-pSzk5JvkfVmBWRE3Wm4KJFFHQQ,467
+antgravity_cli/translate/pt-br/repl.json,sha256=bp0uymet8QM8rVdJJvvXAXh8N-vhdY0IikXxp3-psII,482
+antgravity_cli/translate/pt-br/runner.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravity_cli/translate/pt-br/test_cli.json,sha256=yj0WO6sFU4GCciYUBWjzvvfqrBh869doeOC2Pp5EI1Y,3
+antgravitycli-1.0.2.dist-info/METADATA,sha256=elU7qQnC9MDqJ_h1i3rFLEXS2RmfI2DOtQ6mbF10cmY,11638
+antgravitycli-1.0.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+antgravitycli-1.0.2.dist-info/entry_points.txt,sha256=XP9NCKyiDhNKC_riEIxtFoNJhtN14PZNRTuYIdplJmc,56
+antgravitycli-1.0.2.dist-info/top_level.txt,sha256=VPnvmi_6wOwpIs5yjQb7id4AKM3HhExHtIv9xPN82YM,15
+antgravitycli-1.0.2.dist-info/RECORD,,

antgravitycli-1.0.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

antgravitycli-1.0.2.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+antgravity = antgravity_cli.main:main

antgravitycli-1.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+antgravity_cli