kick-agent 0.1.0__tar.gz

kick_agent-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: kick-agent
+Version: 0.1.0
+Summary: A simple CLI coding agent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic-ai>=1.105.0
+Requires-Dist: textual-dev>=1.8.0
+Requires-Dist: textual[syntax]>=8.2.7
+Requires-Dist: tomli-w>=1.2.0
+
+# KICK - Coding Agent
+
+Kick is an simple coding agent that uses pydantic ai. It can read, write, and edit code.
+<img width="400" height="225" alt="Screen Recording 2026-05-18 184310" src="https://github.com/user-attachments/assets/11fa0c41-5fda-4f71-8c71-7724b3e7e604" />
+
+## Features
+
+- **File Operations**: Read, write, edit and list files in the workspace
+- supports multiple providers
+
+## Installation
+
+1. Clone the repository
+2. Install dependencies: `uv sync`
+3. Set your api key:
+
+ example:
+
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+4. setup a model:
+
+    example:
+    ```
+
+    MODEL=groq:openai/gpt-oss-120b   
+    ```
+    ```
+## Usage
+
+Run the agent with a prompt:
+
+```bash
+uv run main.py "Your prompt here"
+```
+
+Run the agent in multiturn conversation:
+
+```bash
+uv run main.py
+```
+
+## How It Works
+
+The agent uses ai models to call several functions which will help the llm to interact with the file system.
+- `read`: Read file contents
+- `ls`: List files and directories
+- `write`: Create or modify files
+- `edit`: edit a file
+
+> Note: This is a learning project with a simple implementation, Not recommended to use for serious stuff.

kick_agent-0.1.0/README.md

@@ -0,0 +1,52 @@
+# KICK - Coding Agent
+
+Kick is an simple coding agent that uses pydantic ai. It can read, write, and edit code.
+<img width="400" height="225" alt="Screen Recording 2026-05-18 184310" src="https://github.com/user-attachments/assets/11fa0c41-5fda-4f71-8c71-7724b3e7e604" />
+
+## Features
+
+- **File Operations**: Read, write, edit and list files in the workspace
+- supports multiple providers
+
+## Installation
+
+1. Clone the repository
+2. Install dependencies: `uv sync`
+3. Set your api key:
+
+ example:
+
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+4. setup a model:
+
+    example:
+    ```
+
+    MODEL=groq:openai/gpt-oss-120b   
+    ```
+    ```
+## Usage
+
+Run the agent with a prompt:
+
+```bash
+uv run main.py "Your prompt here"
+```
+
+Run the agent in multiturn conversation:
+
+```bash
+uv run main.py
+```
+
+## How It Works
+
+The agent uses ai models to call several functions which will help the llm to interact with the file system.
+- `read`: Read file contents
+- `ls`: List files and directories
+- `write`: Create or modify files
+- `edit`: edit a file
+
+> Note: This is a learning project with a simple implementation, Not recommended to use for serious stuff.

kick_agent-0.1.0/kick/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

kick_agent-0.1.0/kick/agent.py

@@ -0,0 +1,28 @@
+from pydantic_ai import Agent, Tool
+from kick.prompts import SYSTEM_PROMPT
+from kick.functions.bash import bash
+from kick.functions.edit import edit
+from kick.functions.ls import ls
+from kick.functions.read import read
+from kick.functions.write import write
+
+
+def create_agent(cf):
+    MODEL = cf.agent.model
+    tools = [bash, edit, ls, write, read]
+
+    if not MODEL:
+        raise Exception("Setup a proper Model")
+    agent = Agent(
+        model=MODEL,
+        system_prompt=SYSTEM_PROMPT,
+        retries=3,
+        tools=[
+            Tool(ls, takes_ctx=True),
+            Tool(read, takes_ctx=True),
+            Tool(write, takes_ctx=True),
+            Tool(edit, takes_ctx=True),
+            Tool(bash, takes_ctx=True),
+        ],
+    )
+    return agent

kick_agent-0.1.0/kick/config.py

@@ -0,0 +1,45 @@
+import tomllib
+import tomli_w
+from pathlib import Path
+from dataclasses import dataclass, asdict, field
+
+CONFIG_PATH = Path.home() / ".kick" / "config.toml"
+
+
+@dataclass
+class UIConfig:
+    theme: str = "rose-pine"
+
+
+@dataclass
+class AgentConfig:
+    model: str = "groq:openai/gpt-oss-120b"
+    max_steps: int = 20
+    recent_models: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Config:
+    ui: UIConfig = field(default_factory=UIConfig)
+    agent: AgentConfig = field(default_factory=AgentConfig)
+
+
+def load_config():
+    if not CONFIG_PATH.exists():
+        write_config(Config())
+    with open(CONFIG_PATH, "rb") as file:
+        data = tomllib.load(file)
+        return Config(
+            ui=UIConfig(**data.get("ui", {})),
+            agent=AgentConfig(**data.get("agent", {})),
+        )
+
+
+def write_config(config: Config):
+    CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_PATH, mode="wb") as file:
+        tomli_w.dump(asdict(config), file)
+    return config
+
+
+config = load_config()

kick_agent-0.1.0/kick/examples/calculator/main.py

@@ -0,0 +1,27 @@
+import sys
+from pkg.calculator import Calculator
+from pkg.render import format_json_output
+
+
+def main():
+    calculator = Calculator()
+    if len(sys.argv) <= 1:
+        print("Calculator App")
+        print('Usage: python main.py "<expression>"')
+        print('Example: python main.py "3 + 5"')
+        return
+
+    expression = " ".join(sys.argv[1:])
+    try:
+        result = calculator.evaluate(expression)
+        if result is not None:
+            to_print = format_json_output(expression, result)
+            print(to_print)
+        else:
+            print("Error: Expression is empty or contains only whitespace.")
+    except Exception as e:
+        print(f"Error: {e}")
+
+
+if __name__ == "__main__":
+    main()

kick_agent-0.1.0/kick/examples/calculator/pkg/calculator.py

@@ -0,0 +1,59 @@
+class Calculator:
+    def __init__(self):
+        self.operators = {
+            "+": lambda a, b: a + b,
+            "-": lambda a, b: a - b,
+            "*": lambda a, b: a * b,
+            "/": lambda a, b: a / b,
+        }
+        self.precedence = {
+            "+": 1,
+            "-": 1,
+            "*": 2,
+            "/": 2,
+        }
+
+    def evaluate(self, expression):
+        if not expression or expression.isspace():
+            return None
+        tokens = expression.strip().split()
+        return self._evaluate_infix(tokens)
+
+    def _evaluate_infix(self, tokens):
+        values = []
+        operators = []
+
+        for token in tokens:
+            if token in self.operators:
+                while (
+                    operators
+                    and operators[-1] in self.operators
+                    and self.precedence[operators[-1]] >= self.precedence[token]
+                ):
+                    self._apply_operator(operators, values)
+                operators.append(token)
+            else:
+                try:
+                    values.append(float(token))
+                except ValueError:
+                    raise ValueError(f"invalid token: {token}")
+
+        while operators:
+            self._apply_operator(operators, values)
+
+        if len(values) != 1:
+            raise ValueError("invalid expression")
+
+        return values[0]
+
+    def _apply_operator(self, operators, values):
+        if not operators:
+            return
+
+        operator = operators.pop()
+        if len(values) < 2:
+            raise ValueError(f"not enough operands for operator {operator}")
+
+        b = values.pop()
+        a = values.pop()
+        values.append(self.operators[operator](a, b))

kick_agent-0.1.0/kick/examples/calculator/pkg/render.py

@@ -0,0 +1,14 @@
+import json
+
+
+def format_json_output(expression: str, result: float, indent: int = 2) -> str:
+    if isinstance(result, float) and result.is_integer():
+        result_to_dump = int(result)
+    else:
+        result_to_dump = result
+
+    output_data = {
+        "expression": expression,
+        "result": result_to_dump,
+    }
+    return json.dumps(output_data, indent=indent)

kick_agent-0.1.0/kick/examples/calculator/tests.py

@@ -0,0 +1,47 @@
+import unittest
+from pkg.calculator import Calculator
+
+
+class TestCalculator(unittest.TestCase):
+    def setUp(self):
+        self.calculator = Calculator()
+
+    def test_addition(self):
+        result = self.calculator.evaluate("3 + 5")
+        self.assertEqual(result, 8)
+
+    def test_subtraction(self):
+        result = self.calculator.evaluate("10 - 4")
+        self.assertEqual(result, 6)
+
+    def test_multiplication(self):
+        result = self.calculator.evaluate("3 * 4")
+        self.assertEqual(result, 12)
+
+    def test_division(self):
+        result = self.calculator.evaluate("10 / 2")
+        self.assertEqual(result, 5)
+
+    def test_nested_expression(self):
+        result = self.calculator.evaluate("3 * 4 + 5")
+        self.assertEqual(result, 17)
+
+    def test_complex_expression(self):
+        result = self.calculator.evaluate("2 * 3 - 8 / 2 + 5")
+        self.assertEqual(result, 7)
+
+    def test_empty_expression(self):
+        result = self.calculator.evaluate("")
+        self.assertIsNone(result)
+
+    def test_invalid_operator(self):
+        with self.assertRaises(ValueError):
+            self.calculator.evaluate("$ 3 5")
+
+    def test_not_enough_operands(self):
+        with self.assertRaises(ValueError):
+            self.calculator.evaluate("+ 3")
+
+
+if __name__ == "__main__":
+    unittest.main()

kick_agent-0.1.0/kick/examples/welcomepage/serve.py

@@ -0,0 +1,19 @@
+import http.server
+import socketserver
+import os
+
+PORT = 8000
+
+# Change directory to the folder containing the site files (assumes this script is in the project root)
+web_dir = os.path.abspath('.')
+os.chdir(web_dir)
+
+Handler = http.server.SimpleHTTPRequestHandler
+
+with socketserver.TCPServer(("", PORT), Handler) as httpd:
+    print(f"Serving at http://localhost:{PORT}")
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\nServer stopped.")
+        httpd.server_close()

kick_agent-0.1.0/kick/functions/bash.py

@@ -0,0 +1,51 @@
+from pydantic_ai import RunContext
+import asyncio
+
+
+async def bash(ctx: RunContext[str], command: str, timeout: int = 30) -> str:
+    """
+    Execute a shell command in the workspace and return its output.
+
+    Args:
+        command: The shell command to execute.
+        timeout: Maximum execution time in seconds(Optional).
+
+    Returns:
+        The command's exit code, standard output, standard error, or an error message if execution fails.
+    """
+    print(f"-- calling bash({ctx.deps}, {command}, timeout = {timeout})")
+
+    process = await asyncio.create_subprocess_shell(
+        command,
+        cwd=ctx.deps,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.STDOUT,
+    )
+
+    output = []
+
+    async def readoutput():
+        while True:
+            line = await process.stdout.readline()
+            if not line:
+                break
+            print(line.decode(), end="", flush=True)
+            output.append(line.decode())
+
+    reader = asyncio.create_task(readoutput())
+
+    try:
+        await asyncio.wait_for(process.wait(), timeout=timeout)
+    except asyncio.TimeoutError:
+        process.kill()
+        await process.wait()
+        await reader
+        return f"Command timed out after : {timeout} seconds"
+    except asyncio.CancelledError:
+        process.kill()
+        await process.wait()
+        raise
+    await reader
+    if len(output) > 100:
+        output = output[-100:]
+    return f"Exit Code:\n{process.returncode}\n" + "STDOUT: \n".join(output)

kick_agent-0.1.0/kick/functions/config.py

@@ -0,0 +1,2 @@
+class Config:
+    MAX_CHARS: int = 10000

kick_agent-0.1.0/kick/functions/edit.py

@@ -0,0 +1,68 @@
+import os
+
+from pydantic_ai import RunContext
+import difflib
+
+
+def edit(ctx: RunContext[str], file_path: str, old_string: str, new_string: str) -> str:
+    """
+    Replace an exact text block in a file.
+
+    The file must be inside the working directory. The tool
+    finds `old_string` and replaces it with `new_string`.
+    For safety, `old_string` must appear exactly once in
+    the file.
+
+    Args:
+        file_path: Path to the file to edit.
+        old_string: Text to replace.
+        new_string: Replacement text.
+
+    Returns:
+        A success message or an error message if the edit
+        could not be applied.
+    """
+    working_dir = ctx.deps if type(ctx) is not str else ctx
+    print(f"--calling edit({file_path}, {old_string}, {new_string})")
+    if old_string == new_string:
+        return "Error: old_string and new_string cannot be same"
+    abs_path: str = os.path.abspath(working_dir)
+    full_path: str = os.path.join(abs_path, file_path)
+    target_path: str = os.path.normpath(full_path)
+
+    try:
+        valid_target: bool = os.path.commonpath([target_path, abs_path]) == abs_path
+    except:
+        valid_target = False
+
+    if not valid_target:
+        return f'Error: Cannot edit "{file_path}" as it is outside the permitted working directory'
+    if os.path.isdir(target_path):
+        return f'Error: Cannot edit "{file_path}" as it is a directory'
+    content = ""
+    new_content = ""
+    with open(target_path, "r", encoding="utf-8") as file:
+        content = file.read()
+        start = content.find(old_string)
+        if content.count(old_string) > 1:
+            return f"Error: The edit cannot be performed as more than one match of the {old_string} is found."
+        if start == -1:
+            return f"Error: The edit cannot be applied as the old_string: {old_string} is not found in {file_path}"
+        end = start + len(old_string)
+
+        new_content = content[:start] + new_string + content[end:]
+    with open(target_path, "w", encoding="utf-8") as file:
+        file.write(new_content)
+    diff = "\n".join(
+        list(
+            difflib.unified_diff(
+                content.splitlines(),
+                new_content.splitlines(),
+                fromfile="before",
+                tofile="after",
+            )
+        )
+    )
+    output = "EDIT Successfully applied\n" + diff
+    print(output)
+    return output

kick_agent-0.1.0/kick/functions/ls.py

@@ -0,0 +1,41 @@
+import os
+from pydantic_ai import RunContext
+
+
+def ls(ctx: RunContext[str], dir="."):
+    """
+    List files and directories in a workspace directory.
+
+    Args:
+        working_dir: Workspace root directory.
+        dir: Directory to inspect, relative to the workspace root.
+
+    Returns:
+        Names, sizes, and directory status of items in the directory,
+        or an error message if the directory is invalid or outside the workspace.
+    """
+    working_dir = ctx.deps
+    print(f"--calling get_files_info({working_dir}, {dir})")
+    abs_path = os.path.abspath(working_dir)
+    full_path = os.path.join(abs_path, dir)
+    target_dir = os.path.normpath(full_path)
+    try:
+        valid_target_dir = os.path.commonpath([target_dir, abs_path]) == abs_path
+    except ValueError:
+        valid_target_dir = False
+    if not valid_target_dir:
+        return f'Error: Cannot list "{dir}" as it is outside the permitted working directory'
+    if not os.path.isdir(target_dir):
+        return f'Error: directory "{dir}" is not a directory'
+
+    file_info = [f"Result for {dir if dir != '.' else 'current'} directory:"]
+
+    contents = os.listdir(target_dir)
+    for content in contents:
+        content_path = os.path.join(target_dir, content)
+        file_info.append(
+            f"- {content}: file_size = {
+                os.path.getsize(content_path)
+            } bytes , is_dir = {os.path.isdir(content_path)}"
+        )
+    return "\n".join(file_info)

kick_agent-0.1.0/kick/functions/read.py

@@ -0,0 +1,49 @@
+import os
+from pydantic_ai import RunContext
+
+MAX_CHARS = 10000
+
+
+def read(ctx: RunContext[str], file_path: str) -> str:
+    """
+    Read the contents of a file in the project workspace.
+
+    Use this tool when you need to inspect source code, configuration files,
+    logs, or other project files. The file path must be relative to the
+    workspace root. Files outside the workspace cannot be accessed.
+
+    Args:
+        working_dir: Absolute path to the workspace root.
+        file_path: Relative path of the file to read.
+
+    Returns:
+        The file contents as text. Large files may be truncated. Returns an
+        error message if the file does not exist, is not a regular file, is
+        outside the workspace, or cannot be read.
+    """
+    working_dir = ctx.deps
+
+    print(f"--calling get_file_content({working_dir}, {file_path})")
+    try:
+        abs_path = os.path.abspath(working_dir)
+        full_path = os.path.join(abs_path, file_path)
+        target_file = os.path.normpath(full_path)
+
+        try:
+            valid_target_file = os.path.commonpath([target_file, abs_path]) == abs_path
+        except ValueError:
+            valid_target_file = False
+        if not valid_target_file:
+            return f'Error: Cannot read "{file_path}" as it is outside the permitted working directory'
+        if not os.path.isfile(target_file):
+            return f'Error: file "{file_path}" is not a file'
+        content = ""
+        with open(target_file, "r") as f:
+            content = f.read(MAX_CHARS)
+            if f.read(1):
+                content += (
+                    f'\n[...File "{file_path}" truncated at {MAX_CHARS} characters]'
+                )
+        return content
+    except Exception:
+        return "Error: Cannot open or read the file"

kick_agent-0.1.0/kick/functions/test_edit.py

@@ -0,0 +1,3 @@
+from edit import edit
+
+print(edit("../examples/calculator/", "./lorem.txt", "wait", "hello"))

kick_agent-0.1.0/kick/functions/test_ls.py

@@ -0,0 +1,7 @@
+from get_files_info import get_files_info
+
+print(get_files_info("../examples/calculator", "."))
+print(get_files_info("../examples/calculator", "/bin"))
+print(get_files_info("../examples/calculator", "../"))
+print(get_files_info("../examples/calculator", "main.py"))
+print(get_files_info("../examples/calculator", "pkg"))

kick_agent-0.1.0/kick/functions/test_read.py

@@ -0,0 +1,7 @@
+from read import read
+
+print(read("../examples/calculator", "lorem.txt"))
+print(read("../examples/calculator", "main.py"))
+print(read("../examples/calculator", "pkg/calculator.py"))
+print(read("../examples/calculator", "/bin/cat"))
+print(read("../examples/calculator", "pkg/not_found.py"))

kick_agent-0.1.0/kick/functions/test_write.py

@@ -0,0 +1,16 @@
+from write_file import write_file
+
+print(write_file("../examples/calculator", "lorem.txt", "wait, this isn't lorem ipsum"))
+print(
+    write_file(
+        "../examples/calculator", "pkg/morelorem.txt", "lorem ipsum dolor sit amet"
+    )
+)
+print(
+    write_file(
+        "../examples/calculator", "pkg/test/morelorem.txt", "lorem ipsum dolor sit amet"
+    )
+)
+print(
+    write_file("../examples/calculator", "/tmp/temp.txt", "this should not be allowed")
+)

kick_agent-0.1.0/kick/functions/write.py

@@ -0,0 +1,41 @@
+import os
+from pydantic_ai import RunContext
+
+
+def write(ctx: RunContext[str], file_path, content):
+    """
+    Write content to a file in the workspace, creating parent directories if needed.
+
+    Args:
+        file_path: Path to the file relative to the workspace.
+        content: Text to write to the file.
+
+    Returns:
+        A success message or an error message.
+    """
+    working_dir = ctx.deps
+    print(f"--calling write({working_dir}, {file_path}, {content})")
+    try:
+        abs_path = os.path.abspath(working_dir)
+        full_path = os.path.join(abs_path, file_path)
+        target_path = os.path.normpath(full_path)
+
+        try:
+            valid_target = os.path.commonpath([target_path, abs_path]) == abs_path
+        except:
+            valid_target = False
+
+        if not valid_target:
+            return f'Error: Cannot write "{file_path}" as it is outside the permitted working directory'
+        if os.path.isdir(target_path):
+            return f'Error: Cannot write to "{file_path}" as it is a directory'
+        parent_dir = os.path.dirname(target_path)
+
+        os.makedirs(parent_dir, exist_ok=True)
+        with open(target_path, "w") as f:
+            f.write(content)
+        return (
+            f'Successfully wrote to "{file_path}" ({len(content)} characters written)'
+        )
+    except:
+        return f'Error: Cannot write to "{file_path}"'

kick_agent-0.1.0/kick/main.py

@@ -0,0 +1,10 @@
+from kick.ui.app import Kick
+
+
+def main():
+    app = Kick()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

kick_agent-0.1.0/kick/prompts.py

@@ -0,0 +1,57 @@
+SYSTEM_PROMPT = """
+You are Kick, an autonomous AI coding agent.
+
+Your job is to help users understand, modify, debug, and build software projects.
+
+You have access to tools that allow you to:
+
+- List files and directories
+- Read file contents
+- Write and overwrite files
+- Edit file content
+- Execute commands
+General behavior rules:
+
+1. Always analyze the user's request carefully before making tool calls.
+
+2. Prefer inspecting relevant files before modifying them.
+
+3. When debugging:
+   - Identify the root cause
+   - Explain the issue briefly
+   - Apply the smallest reasonable fix
+   - Avoid unnecessary rewrites
+
+4. When writing code:
+   - Produce clean, readable, maintainable code
+   - Follow existing project style and structure
+   - Add comments only when they improve clarity
+   - Avoid overengineering
+
+5. Before executing code:
+   - Ensure required files exist
+   - Avoid destructive operations unless explicitly requested
+
+6. When editing files:
+   - Preserve unrelated code
+   - Modify only what is necessary
+
+7. If the task is ambiguous:
+   - Inspect the repository structure
+   - Infer intent from existing code before asking questions
+
+8. Always think step-by-step and make a short execution plan before tool usage.
+
+9. After completing a task:
+   - Summarize what was changed
+   - Mention important files modified
+   - Mention any remaining issues if applicable
+
+Path rules:
+- All paths must be relative to the working directory
+- Never use absolute paths
+- The working directory is automatically provided to tools
+
+You are an engineering assistant, not just a chatbot.
+Act carefully, precisely, and systematically.
+"""

kick_agent-0.1.0/kick/ui/app.py

@@ -0,0 +1,155 @@
+from textual.app import App, ComposeResult
+from textual.containers import Vertical, VerticalScroll, Center, Middle
+from textual.widgets import (
+    Header,
+    Input,
+    Markdown,
+)
+import os
+
+from kick.config import config, write_config
+from kick.ui.utils import switch_model
+from kick.ui.screens import ModelSelectionModal
+from kick.ui.widgets import Spinner, Welcome
+from kick.ui.providers import CommandProvider
+from kick.agent import create_agent
+
+agent = create_agent(config)
+
+
+class Kick(App):
+    BINDINGS = [
+        ("escape", "cancel_stream", "stop agent"),
+    ]
+    CSS = """
+    #welcome_container {
+            width: 100%;
+            align: center middle;
+        }
+    #welcome {
+        text-align: center;
+        width: 100%;
+    }
+    """
+    COMMANDS = App.COMMANDS | {CommandProvider}
+
+    def __init__(self):
+        super().__init__()
+        self.message_history = []
+        self.current_stream = None
+        self.current_spinner = None
+        self.is_response_loading = False
+        self.agent = agent
+        self.config = config
+
+    async def run_agent(self, prompt: str, message_widget: Spinner):
+        response = ""
+        first_chunk = True
+        try:
+            async with self.agent.run_stream(
+                prompt,
+                deps=os.getcwd(),
+                message_history=self.message_history,
+            ) as stream:
+                self.current_stream = stream
+                async for chunk in stream.stream_text(delta=True):
+                    if first_chunk:
+                        message_widget.stop()
+                        first_chunk = False
+                    response += chunk
+                    message_widget.update(f"### Kick\n\n{response}")
+                self.message_history = stream.all_messages()
+        except:
+            message_widget.stop()
+            message_widget.update("> Encountered an error during generation ❌")
+
+    async def on_input_submitted(self, event: Input.Submitted):
+        if event.input.id != "prompt":
+            return
+        prompt = event.value
+        event.input.value = ""
+        messages = self.query_one("#messages", VerticalScroll)
+        user_message = Markdown(f"> ### {prompt}")
+        assistant_message = Spinner()
+        self.current_spinner = assistant_message
+        welcome = self.query("#welcome")
+        if welcome:
+            await welcome.first().remove()
+        await messages.mount(user_message)
+        await messages.mount(assistant_message)
+        self.run_worker(self.run_agent(prompt, assistant_message))
+
+        messages.scroll_end(animate=True)
+        if prompt.strip() == "/exit":
+            self.exit()
+
+    def compose(self) -> ComposeResult:
+        """Create child widgets for the app."""
+        with Vertical():
+            yield Header()
+            with VerticalScroll(id="messages"):
+                with Middle():
+                    with Center():
+                        with Vertical(id="welcome_container"):
+                            yield Welcome(
+                                """
+[yellow]Kick[/]
+
+       ░[#FE0000]▒▒▒▒▒[/]       
+     █[#FE0000]▒▒▒▒[/]█████░    
+   ░█[#FE0000]▓▒▒▒[/]████████   
+   ██[#FE0000]▒▒▒▒[/]█████████  
+  ░██[#FE0000]▒▒▒▒[/]█████████  
+           [#FE0000]░[/]█████▒  
+            █████   
+             ░░     
+
+Autonomous Coding Agent
+
+    • Analyze repositories
+    • Edit files
+    • Execute commands
+    • Run tests
+
+    [red] /exit [/] - [yellow] exit the agent [/]
+    [red] esc [/] - [yellow] stop the agent execution [/]
+    [red] ctrl + p [/]  - [yellow] open command pallete [/]
+
+Type a prompt below to begin.
+                            """,
+                                id="welcome",
+                            )
+            yield Input(placeholder="Build anything cool ..", id="prompt")
+
+    async def on_mount(self):
+        self.theme = config.ui.theme
+        ip = self.query_one("#prompt", Input)
+        ip.focus()
+
+    async def watch_theme(self, theme: str):
+        config.ui.theme = theme
+        write_config(config)
+
+    def show_model_selector(self):
+        self.push_screen(
+            ModelSelectionModal(
+                self.config.agent.recent_models, self.config.agent.model
+            ),
+            self.on_model_selected,
+        )
+
+    def on_model_selected(self, model):
+        switch_model(self, model)
+
+    async def action_cancel_stream(self) -> None:
+        if self.current_stream:
+            await self.current_stream.cancel()
+            messages = self.query_one("#messages")
+            if self.current_spinner:
+                self.current_spinner.stop()
+            messages.mount(Markdown("> Agent Cancelled"))
+
+
+if __name__ == "__main__":
+    app = Kick()
+    app.run()

kick_agent-0.1.0/kick/ui/providers.py

@@ -0,0 +1,19 @@
+from textual.command import Provider, Hit, Hits
+
+
+class CommandProvider(Provider):
+    async def search(self, query: str) -> Hits:
+
+        matcher = self.matcher(query)
+
+        app = self.app
+        current_model = app.config.agent.model
+        command = f"Model: {current_model}"
+        score = matcher.match(command)
+        if score > 0:
+            yield Hit(
+                score,
+                matcher.highlight(command),
+                app.show_model_selector,
+                help="Change the current model",
+            )

kick_agent-0.1.0/kick/ui/screens.py

@@ -0,0 +1,45 @@
+from textual.screen import ModalScreen
+from textual.app import ComposeResult
+from textual.containers import Vertical
+from textual.widgets import ListItem, ListView, Label, Input
+
+
+class ModelSelectionModal(ModalScreen[str]):
+    def __init__(self, recent_models: list[str], current_model: str):
+        super().__init__()
+        self.current_model = current_model
+        self.recent_models = recent_models
+        if not self.recent_models:
+            self.recent_models.append(self.current_model)
+
+    def compose(self) -> ComposeResult:
+        with Vertical():
+            yield Label("Select a Model:")
+            yield Input(value=self.current_model, id="model_input")
+            yield ListView(
+                *[ListItem(Label(model)) for model in self.recent_models],
+                id="recent_models",
+            )
+
+    def on_input_submitted(self, event: Input.Submitted):
+        event.stop()
+        self.dismiss(event.value)
+
+    async def on_input_changed(self, event: Input.Changed):
+        query = event.value.lower()
+        list_view = self.query_one("#recent_models", ListView)
+        filtered_models = [
+            model for model in self.recent_models if query in model.lower()
+        ]
+        list_view.clear()
+
+        for model in filtered_models:
+            await list_view.append(ListItem(Label(model)))
+
+    def on_list_view_selected(
+        self,
+        event: ListView.Selected,
+    ):
+        label = event.item.query_one(Label)
+
+        self.dismiss(str(label.content))

kick_agent-0.1.0/kick/ui/utils.py

@@ -0,0 +1,15 @@
+from kick.config import write_config
+from kick.agent import create_agent
+
+
+def switch_model(app, model):
+    if not model:
+        return
+    recents = app.config.agent.recent_models
+    if model in recents:
+        recents.remove(model)
+    recents.insert(0, model)
+    app.config.agent.model = model
+    write_config(app.config)
+    app.agent = create_agent(app.config)
+    app.notify(f"Model changed to {app.config.agent.model}")

kick_agent-0.1.0/kick/ui/widgets.py

@@ -0,0 +1,41 @@
+from textual.widgets import Static, Markdown
+import random
+
+
+class Welcome(Static):
+    pass
+
+
+class Spinner(Markdown):
+    FRAMES = ["{/////}", "{~////}", "{/~///}", "{//~//}", "{////~}"]
+    MESSAGES = [
+        "Thinking ...",
+        "Building a ramp...",
+        "Launching stunt...",
+        "Defying physics...",
+        "Revving engines...",
+        "Helmet on...",
+        "Daredevil mode...",
+        "Aiming for awesome...",
+        "Full send...",
+        "What could possibly go wrong?",
+    ]
+    FRAME_INTERVAL = 0.2
+    MESSAGE_TICK_RATE = 50
+
+    def on_mount(self):
+        self.frame = -1
+        self.tick = 0
+        self.current_message = random.choice(self.MESSAGES)
+        self.update(f"{self.FRAMES[self.frame]} {self.current_message}")
+        self.timer = self.set_interval(self.FRAME_INTERVAL, self.animate)
+
+    def animate(self):
+        self.frame = (self.frame + 1) % len(self.FRAMES)
+        if self.tick % self.MESSAGE_TICK_RATE == 0:
+            self.current_message = random.choice(self.MESSAGES)
+        self.update(f"{self.FRAMES[self.frame]} {self.current_message}")
+        self.tick += 1
+
+    def stop(self):
+        self.timer.stop()

kick_agent-0.1.0/kick_agent.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: kick-agent
+Version: 0.1.0
+Summary: A simple CLI coding agent
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: pydantic-ai>=1.105.0
+Requires-Dist: textual-dev>=1.8.0
+Requires-Dist: textual[syntax]>=8.2.7
+Requires-Dist: tomli-w>=1.2.0
+
+# KICK - Coding Agent
+
+Kick is an simple coding agent that uses pydantic ai. It can read, write, and edit code.
+<img width="400" height="225" alt="Screen Recording 2026-05-18 184310" src="https://github.com/user-attachments/assets/11fa0c41-5fda-4f71-8c71-7724b3e7e604" />
+
+## Features
+
+- **File Operations**: Read, write, edit and list files in the workspace
+- supports multiple providers
+
+## Installation
+
+1. Clone the repository
+2. Install dependencies: `uv sync`
+3. Set your api key:
+
+ example:
+
+   ```
+   GEMINI_API_KEY=your_api_key_here
+   ```
+4. setup a model:
+
+    example:
+    ```
+
+    MODEL=groq:openai/gpt-oss-120b   
+    ```
+    ```
+## Usage
+
+Run the agent with a prompt:
+
+```bash
+uv run main.py "Your prompt here"
+```
+
+Run the agent in multiturn conversation:
+
+```bash
+uv run main.py
+```
+
+## How It Works
+
+The agent uses ai models to call several functions which will help the llm to interact with the file system.
+- `read`: Read file contents
+- `ls`: List files and directories
+- `write`: Create or modify files
+- `edit`: edit a file
+
+> Note: This is a learning project with a simple implementation, Not recommended to use for serious stuff.

kick_agent-0.1.0/kick_agent.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+README.md
+pyproject.toml
+kick/__init__.py
+kick/agent.py
+kick/config.py
+kick/main.py
+kick/prompts.py
+kick/examples/calculator/main.py
+kick/examples/calculator/tests.py
+kick/examples/calculator/pkg/calculator.py
+kick/examples/calculator/pkg/render.py
+kick/examples/welcomepage/serve.py
+kick/functions/bash.py
+kick/functions/config.py
+kick/functions/edit.py
+kick/functions/ls.py
+kick/functions/read.py
+kick/functions/test_edit.py
+kick/functions/test_ls.py
+kick/functions/test_read.py
+kick/functions/test_write.py
+kick/functions/write.py
+kick/ui/app.py
+kick/ui/providers.py
+kick/ui/screens.py
+kick/ui/utils.py
+kick/ui/widgets.py
+kick_agent.egg-info/PKG-INFO
+kick_agent.egg-info/SOURCES.txt
+kick_agent.egg-info/dependency_links.txt
+kick_agent.egg-info/entry_points.txt
+kick_agent.egg-info/requires.txt
+kick_agent.egg-info/top_level.txt

kick_agent-0.1.0/kick_agent.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kick_agent-0.1.0/kick_agent.egg-info/entry_points.txt

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

kick_agent-0.1.0/kick_agent.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pydantic-ai>=1.105.0
+textual-dev>=1.8.0
+textual[syntax]>=8.2.7
+tomli-w>=1.2.0

kick_agent-0.1.0/kick_agent.egg-info/top_level.txt

@@ -0,0 +1 @@
+kick

kick_agent-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "kick-agent"
+version = "0.1.0"
+description = "A simple CLI coding agent"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pydantic-ai>=1.105.0",
+    "textual-dev>=1.8.0",
+    "textual[syntax]>=8.2.7",
+    "tomli-w>=1.2.0",
+]
+
+[project.scripts]
+kick = "kick.main:main"

kick_agent-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+