makima-cli 0.1.0__tar.gz

makima_cli-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: makima-cli
+Version: 0.1.0
+Summary: AI coding assistant for your terminal
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: groq
+Requires-Dist: python-dotenv
+Requires-Dist: gitpython
+Requires-Dist: rich
+Requires-Dist: pyfiglet
+
+# Makima CLI 🤖
+
+An AI-powered coding assistant that runs in your terminal. Point it at any codebase and ask questions, make edits, and run commands — all from a clean CLI interface.
+
+## Features
+
+- Understands your entire codebase
+- Answers questions about your code
+- Edits files with auto git backup before changes
+- Creates new files
+- Runs terminal commands with confirmation
+- Works on any project
+- Clean terminal UI with syntax highlighting
+
+## Install
+
+git clone https://github.com/yourusername/makima-cli.git
+cd makima-cli
+pip install -r requirements.txt
+
+## Setup
+
+Create a .env file in the project root:
+GROQ_API_KEY=your_key_here
+
+Get a free API key at https://console.groq.com
+
+## Usage
+
+Point it at any project:
+python main.py /path/to/your/project
+
+Or run from inside a project folder:
+cd your-project
+python /path/to/makima-cli/main.py
+
+## Built With
+
+- Python
+- Groq API
+- Rich
+- GitPython

makima_cli-0.1.0/README.md

@@ -0,0 +1,42 @@
+# Makima CLI 🤖
+
+An AI-powered coding assistant that runs in your terminal. Point it at any codebase and ask questions, make edits, and run commands — all from a clean CLI interface.
+
+## Features
+
+- Understands your entire codebase
+- Answers questions about your code
+- Edits files with auto git backup before changes
+- Creates new files
+- Runs terminal commands with confirmation
+- Works on any project
+- Clean terminal UI with syntax highlighting
+
+## Install
+
+git clone https://github.com/yourusername/makima-cli.git
+cd makima-cli
+pip install -r requirements.txt
+
+## Setup
+
+Create a .env file in the project root:
+GROQ_API_KEY=your_key_here
+
+Get a free API key at https://console.groq.com
+
+## Usage
+
+Point it at any project:
+python main.py /path/to/your/project
+
+Or run from inside a project folder:
+cd your-project
+python /path/to/makima-cli/main.py
+
+## Built With
+
+- Python
+- Groq API
+- Rich
+- GitPython

makima_cli-0.1.0/makima/config.py

@@ -0,0 +1,13 @@
+import os
+import sys
+from dotenv import load_dotenv
+load_dotenv()
+
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+MODEL_NAME = "qwen/qwen3.6-27b"
+TOKEN_LIMIT = 10000
+# PROJECT_ROOT = os.getcwd()
+PROJECT_ROOT = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()
+
+if not GROQ_API_KEY:
+    raise ValueError("GROQ_API_KEY not set in .env file")

makima_cli-0.1.0/makima/core/agent.py

@@ -0,0 +1,133 @@
+import json
+from makima.config import PROJECT_ROOT,MODEL_NAME
+from makima.core.context import ContextManager
+from makima.core.memory import Memory
+from makima.tools import TOOL_REGISTRY
+from makima.tools.registry import TOOL_SCHEMAS
+from makima.providers.groq_provider import GroqProvider
+from rich.console import Console
+
+
+console = Console()
+
+ctx = ContextManager()
+context = ctx.build_context()
+
+SYSTEM_PROMPT = f"""
+You are a coding assistant. The project is at: {PROJECT_ROOT}
+
+Rules:
+- Always use list_files first to find exact paths
+- Always use read_file before editing any file
+- Use full absolute paths always
+- Be concise and direct
+- old_str must be an exact match of multiple lines from the file
+- Never explain what you are about to do. Never say "Let me..." or "I'll first...".
+- Just call the tool immediately and silently.
+- Only speak in plain text when you have a FINAL answer for the user.
+- Call only ONE tool per response. Wait for the tool result before calling the next tool.
+- Never output multiple tool calls in one response.
+"""
+
+import pyfiglet
+from rich.panel import Panel
+from rich.text import Text
+from rich.rule import Rule
+from rich.markdown import Markdown
+
+
+def run_agent():
+    provider = GroqProvider()
+    memory = Memory(system_prompt=SYSTEM_PROMPT)
+
+
+    ascii_art = pyfiglet.figlet_format("Makima", font="big")
+    console.print(f"[bold #FF6B35]{ascii_art}[/]")
+
+    # info line underneath, no box
+    console.print(f"[dim]  Your AI Coding Assistant[/]")
+    console.print(f"[green]  Project :[/] {PROJECT_ROOT}")
+    console.print(f"[green]  Files   :[/] {len(ctx.files)} files loaded")
+    console.print(f"[green]  Model   :[/] {MODEL_NAME}")
+    console.print(f"[dim]  Type 'exit' to quit[/]")
+    console.print(Rule(style="#FF6B35"))  # clean horizontal line separator
+    console.print()
+
+    while True:
+        user_input = console.input("[bold blue]You:[/] ")
+        if user_input.strip() == "exit":
+            break
+
+        memory.add_user(user_input)
+
+        while True:
+            try:
+                with console.status("[yellow]thinking...[/]"):
+                    stream = provider.stream_chat(
+                        messages=memory.get(),
+                        tools=TOOL_SCHEMAS
+                    )
+                    chunks = list(stream)
+            except Exception as e:
+                console.print(f"[red]Error: {e}[/]")
+                break
+
+            #variables to collect the response
+            text_buffer = ""
+            tool_name = ""
+            tool_args = ""
+            tool_call_id = ""
+            is_tool_call = False
+
+            # console.print("[bold green]Agent:[/] ", end="")
+
+            
+            for chunk in chunks:
+                delta = chunk.choices[0].delta
+
+                #text chunk
+                if delta.content:
+                    # print(delta.content, end="", flush=True)
+                    text_buffer += delta.content
+
+
+                # tool call chunk
+                if delta.tool_calls:
+                    is_tool_call = True
+                    tc = delta.tool_calls[0]
+                    if tc.id:
+                        tool_call_id = tc.id
+                    if tc.function.name:
+                        tool_name += tc.function.name
+                    if tc.function.arguments:
+                        tool_args += tc.function.arguments
+
+            # print()
+
+            if is_tool_call:
+                console.print(f"[dim]⚡ {tool_name}[/]")
+
+                with console.status(f"[yellow]calling {tool_name}...[/]"):
+                    args = json.loads(tool_args)
+                    tool_fn = TOOL_REGISTRY.get(tool_name)
+                    result = tool_fn(**args) if tool_fn else "Unknown tool"
+
+                # build the assistant message manually for memory
+                memory.add_raw({
+                    "role": "assistant",
+                    "tool_calls": [{
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": tool_name,
+                            "arguments": tool_args
+                        }
+                    }]
+                })
+                memory.add_tool_result(tool_call_id, str(result))
+
+            else:
+                console.print("[bold green]Agent:[/]")
+                console.print(Markdown(text_buffer))
+                memory.add_assistant(text_buffer)
+                break

makima_cli-0.1.0/makima/core/context.py

@@ -0,0 +1,47 @@
+from makima.config import PROJECT_ROOT,TOKEN_LIMIT
+from makima.tools.file_tools import read_file,list_files
+import os
+
+
+class ContextManager:
+    def __init__(self):
+        self.files = []
+        self.total_tokens = 0
+        self.scan_files()
+
+
+    def scan_files(self):
+        skip = {"__pycache__", ".git", "node_modules", ".env",".venv"}
+        skip_ext = {".pyc", ".png", ".jpg", ".jpeg", ".gif", ".ico"}
+        self.files = []
+
+        for folder, subfolders, files in os.walk(PROJECT_ROOT):
+            subfolders[:] = [f for f in subfolders if f not in skip]
+
+            for file in files:
+
+                if any(file.endswith(ext) for ext in skip_ext):
+                    continue
+                file_path = os.path.join(folder,file)
+                self.files.append(file_path)
+
+
+    def count_tokens(self,text):
+        return len(text) // 4
+
+
+    def build_context(self):
+
+        context = ""
+
+        for file in self.files:
+            content = read_file(file)
+
+            self.total_tokens += self.count_tokens(content)
+
+            if self.total_tokens > TOKEN_LIMIT:
+                return "TOO LARGE CONTEXT"
+            else:
+                context += f"\n--- {file} ---\n{content}\n"
+
+        return context

makima_cli-0.1.0/makima/core/memory.py

@@ -0,0 +1,23 @@
+class Memory:
+
+    def __init__(self, system_prompt: str):
+        self.messages = [{"role": "system", "content": system_prompt}]
+
+    def add_user(self, text: str):
+        self.messages.append({"role": "user", "content": text})
+
+    def add_assistant(self, text: str):
+        self.messages.append({"role": "assistant", "content": text})
+
+    def add_tool_result(self, tool_call_id: str, content: str):
+        self.messages.append({
+            "role": "tool",
+            "tool_call_id": tool_call_id,
+            "content": content
+        })
+
+    def add_raw(self, message):
+        self.messages.append(message)
+
+    def get(self) -> list:
+        return self.messages

makima_cli-0.1.0/makima/main.py

@@ -0,0 +1,8 @@
+from makima.core.agent import run_agent
+import sys
+
+def main():
+    run_agent()
+
+if __name__ == "__main__":
+    main()

makima_cli-0.1.0/makima/providers/base.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+class LLMProvider(ABC):
+
+    @abstractmethod
+    def chat(self, messages: list, tools: list) -> object:
+        pass

makima_cli-0.1.0/makima/providers/groq_provider.py

@@ -0,0 +1,25 @@
+from groq import Groq
+from makima.providers.base import LLMProvider
+from makima.config import GROQ_API_KEY, MODEL_NAME
+
+class GroqProvider(LLMProvider):
+
+    def __init__(self):
+        self.client = Groq(api_key=GROQ_API_KEY)
+
+    def chat(self, messages: list, tools: list) -> object:
+        return self.client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            tools=tools,
+            max_tokens=1024
+        )
+
+    def stream_chat(self, messages: list, tools: list):
+        return self.client.chat.completions.create(
+            model=MODEL_NAME,
+            messages=messages,
+            tools=tools,
+            max_tokens=1024,
+            stream=True
+        )

makima_cli-0.1.0/makima/tools/__init__.py

@@ -0,0 +1,10 @@
+from makima.tools.file_tools import read_file, list_files, edit_file, create_file
+from makima.tools.shell_tools import run_command
+
+TOOL_REGISTRY = {
+    "read_file": read_file,
+    "list_files": list_files,
+    "edit_file": edit_file,
+    "run_command": run_command,
+    "create_file": create_file,
+}

makima_cli-0.1.0/makima/tools/file_tools.py

@@ -0,0 +1,65 @@
+from makima.config import PROJECT_ROOT
+import os
+import git
+
+def read_file(path):
+    if not os.path.exists(path):
+        path = os.path.join(PROJECT_ROOT, path)
+    try:
+        with open(path, "r") as content:
+            return content.read()
+    except Exception as e:
+        return f"There is an Error while Reading your files. Error - {e}"
+
+
+def list_files():
+    skip = {"__pycache__", ".git", "node_modules", ".env",".venv"}
+    output = []
+
+    for folder, subfolders, files in os.walk(PROJECT_ROOT):
+
+        subfolders[:] = [f for f in subfolders if f not in skip]
+
+        output.append(folder)
+        for file in files:
+            output.append(" " + file)
+
+    return "\n".join(output)
+
+
+def edit_file(path, old_str, new_str):
+    auto_commit(path)
+    
+    if not os.path.exists(path):
+        path = os.path.join(PROJECT_ROOT,path)
+        
+    readed_content = read_file(path)
+    if old_str in readed_content:
+        new_contents = readed_content.replace(old_str,new_str,1)
+    else:
+        return f"content that i tried to change is missing"
+
+    with open(path,"w") as f:
+        f.write(new_contents)
+    return f"Done. Edited {path}"
+
+
+
+def create_file(path, content):
+    if os.path.exists(path):
+        return f"File already exists: {path}"
+
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+
+    with open(path, "w") as f:
+        f.write(content)
+    return f"Created path: {path}"
+
+
+def auto_commit(path):
+    try:
+        repo = git.Repo(PROJECT_ROOT)
+        repo.git.add(path)
+        repo.index.commit(f"auto-backup before edit: {path}")
+    except Exception as e:
+        pass

makima_cli-0.1.0/makima/tools/registry.py

@@ -0,0 +1,67 @@
+TOOL_SCHEMAS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read a file and return its contents",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "Full absolute path to the file"}
+                },
+                "required": ["path"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "list_files",
+            "description": "List all files in the project",
+            "parameters": {"type": "object", "properties": {}}
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "edit_file",
+            "description": "Edit a file by replacing old_str with new_str",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string"},
+                    "old_str": {"type": "string"},
+                    "new_str": {"type": "string"}
+                },
+                "required": ["path", "old_str", "new_str"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_command",
+            "description": "Run a terminal command and return output",
+            "parameters": {
+                "type": "object",
+                "properties": {"cmd": {"type": "string"}},
+                "required": ["cmd"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "create_file",
+            "description": "Create a new file with given content",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string"},
+                    "content": {"type": "string"}
+                },
+                "required": ["path", "content"]
+            }
+        }
+    }
+]

makima_cli-0.1.0/makima/tools/shell_tools.py

@@ -0,0 +1,20 @@
+import subprocess
+
+
+def run_command(cmd):
+    print(f"Commands going to Run: {cmd}")
+    User_answer = input("Run This? (Y/N): ")
+    User_answer = User_answer.lower()
+
+    if User_answer != "y":
+        return "Command cancelled"
+
+    result = subprocess.run(
+        cmd,
+        shell=True,
+        capture_output=True,
+        text=True,
+        timeout=30
+    )
+
+    return result.stdout + result.stderr

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

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: makima-cli
+Version: 0.1.0
+Summary: AI coding assistant for your terminal
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: groq
+Requires-Dist: python-dotenv
+Requires-Dist: gitpython
+Requires-Dist: rich
+Requires-Dist: pyfiglet
+
+# Makima CLI 🤖
+
+An AI-powered coding assistant that runs in your terminal. Point it at any codebase and ask questions, make edits, and run commands — all from a clean CLI interface.
+
+## Features
+
+- Understands your entire codebase
+- Answers questions about your code
+- Edits files with auto git backup before changes
+- Creates new files
+- Runs terminal commands with confirmation
+- Works on any project
+- Clean terminal UI with syntax highlighting
+
+## Install
+
+git clone https://github.com/yourusername/makima-cli.git
+cd makima-cli
+pip install -r requirements.txt
+
+## Setup
+
+Create a .env file in the project root:
+GROQ_API_KEY=your_key_here
+
+Get a free API key at https://console.groq.com
+
+## Usage
+
+Point it at any project:
+python main.py /path/to/your/project
+
+Or run from inside a project folder:
+cd your-project
+python /path/to/makima-cli/main.py
+
+## Built With
+
+- Python
+- Groq API
+- Rich
+- GitPython

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

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+makima/__init__.py
+makima/config.py
+makima/main.py
+makima/core/__init__.py
+makima/core/agent.py
+makima/core/context.py
+makima/core/memory.py
+makima/providers/base.py
+makima/providers/groq_provider.py
+makima/tools/__init__.py
+makima/tools/file_tools.py
+makima/tools/registry.py
+makima/tools/shell_tools.py
+makima_cli.egg-info/PKG-INFO
+makima_cli.egg-info/SOURCES.txt
+makima_cli.egg-info/dependency_links.txt
+makima_cli.egg-info/entry_points.txt
+makima_cli.egg-info/requires.txt
+makima_cli.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,5 @@
+groq
+python-dotenv
+gitpython
+rich
+pyfiglet

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

@@ -0,0 +1 @@
+makima

makima_cli-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "makima-cli"
+version = "0.1.0"
+description = "AI coding assistant for your terminal"
+readme = "README.md"
+license = {file = "LICENSE"}
+requires-python = ">=3.10"
+dependencies = [
+    "groq",
+    "python-dotenv",
+    "gitpython",
+    "rich",
+    "pyfiglet",
+]
+
+[project.scripts]
+makima = "makima.main:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["makima*"]

makima_cli-0.1.0/setup.cfg

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