makima-cli 0.2.1__tar.gz → 1.2.2__tar.gz

{makima_cli-0.2.1 → makima_cli-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makima-cli
-Version: 0.2.1
+Version: 1.2.2
 Summary: AI coding assistant for your terminal
 Author: Kanhaiya
 License: MIT License
@@ -52,7 +52,7 @@ An AI-powered coding assistant that runs in your terminal. Point it at any codeb
 
 ## Install
 
-git clone https://github.com/yourusername/makima-cli.git
+git clone https://github.com/kanhaiya-ML/makima-cli.git
 cd makima-cli
 pip install -r requirements.txt
 

{makima_cli-0.2.1 → makima_cli-1.2.2}/README.md

@@ -14,7 +14,7 @@ An AI-powered coding assistant that runs in your terminal. Point it at any codeb
 
 ## Install
 
-git clone https://github.com/yourusername/makima-cli.git
+git clone https://github.com/kanhaiya-ML/makima-cli.git
 cd makima-cli
 pip install -r requirements.txt
 

makima_cli-1.2.2/makima/config.py

@@ -0,0 +1,18 @@
+
+import os
+import sys
+import json
+from pathlib import Path
+from dotenv import load_dotenv
+load_dotenv()
+
+config_file = Path.home() / ".makima" / "config.json"
+config = {}
+if config_file.exists():
+    with open(config_file, "r") as f:
+        config = json.load(f)
+
+GROQ_API_KEY = config.get("groq_api_key") or os.getenv("GROQ_API_KEY")
+MODEL_NAME = config.get("model") or "qwen/qwen3.6-27b"
+TOKEN_LIMIT = 6000
+PROJECT_ROOT = sys.argv[1] if len(sys.argv) > 1 else os.getcwd()

{makima_cli-0.2.1 → makima_cli-1.2.2}/makima/core/config_manager.py

@@ -122,4 +122,55 @@ def handle_config():
     if choice == "Change model":
         change_model()
     elif choice == "Change API key":
-        change_api_key()
+        change_api_key()
+
+
+from makima.tools.git_tools import get_git_diff, generate_commit_message, clean_message
+import subprocess
+import os
+
+def commit_only(message):
+    message = clean_message(message)
+    cmd = f'git add -A && git commit -m "{message}"'
+    result = subprocess.run(cmd, shell=True, text=True, capture_output=True)
+    if result.returncode == 0:
+        return "✓ Committed locally"
+    return f"✗ Failed: {result.stderr}"
+
+
+def analyze_changes():
+    diff = get_git_diff()
+
+    if not diff.strip():
+        return None, None
+    message = generate_commit_message(diff)
+    return  diff, message
+
+
+def handle_commit():
+    diff = get_git_diff()
+
+    if not diff.strip():
+        console.print("[yellow]No changes to commit.[/]")
+        return
+    
+    commit_message = generate_commit_message(diff=diff)
+    console.print(f"[white] {commit_message}")
+
+    # choice = questionary.select(
+    #     "What action you want?: ",
+    #     choices = [
+    #         "commit_and_push",
+    #         "commit only",
+    #         "cancle"
+    #     ]
+    # ).ask()
+
+    # if choice == "commit_and_push":
+    #     result = commit_and_push(message=commit_message)
+    #     console.print(f"[green]{result}[/]")
+    # elif choice == "commit only":
+    #     result = commit_only(diff)
+    #     console.print(f"[green]{result}[/]")
+
+        

makima_cli-1.2.2/makima/main.py

@@ -0,0 +1,14 @@
+from makima.core.agent import run_agent
+import sys
+from makima.ui.app import run_ui
+from makima.setup import setup_api_key, setup_model
+
+
+def main():
+    # run_agent()
+    setup_model()
+    setup_api_key()
+    run_ui()
+
+if __name__ == "__main__":
+    main()

{makima_cli-0.2.1 → makima_cli-1.2.2}/makima/providers/groq_provider.py

@@ -1,11 +1,26 @@
 from groq import Groq
 from makima.providers.base import LLMProvider
-from makima.config import GROQ_API_KEY, MODEL_NAME
+from makima.config import MODEL_NAME
+import os
+import json
+from pathlib import Path
 
 class GroqProvider(LLMProvider):
 
     def __init__(self):
-        self.client = Groq(api_key=GROQ_API_KEY)
+        # read fresh from config file
+        key = self._load_key()
+        self.client = Groq(api_key=key)
+
+    def _load_key(self):
+        config_file = Path.home() / ".makima" / "config.json"
+        if config_file.exists():
+            with open(config_file, "r") as f:
+                data = json.load(f)
+                key = data.get("groq_api_key")
+                if key:
+                    return key
+        return os.getenv("GROQ_API_KEY")
 
     def chat(self, messages: list, tools: list) -> object:
         return self.client.chat.completions.create(

{makima_cli-0.2.1 → makima_cli-1.2.2}/makima/setup.py

@@ -28,7 +28,7 @@ def setup_api_key():
         with open(config_file, "r") as f:
             data = json.load(f)
             key = data.get("groq_api_key")
-            if key:
+            if key and validate_key(key):
                 return key
 
     import os
@@ -83,6 +83,7 @@ def setup_model():
 
     existing["model"] = model
 
+    config_dir.mkdir(exist_ok=True)
     with open(config_file,"w") as f:
         json.dump(existing,f)
 

makima_cli-1.2.2/makima/test.py

@@ -0,0 +1,49 @@
+from textual.app import App
+from textual.widgets import Header, Footer, Input, RichLog
+from rich.text import Text
+
+from makima.providers.groq_provider import GroqProvider
+from makima.core.memory import Memory
+
+SYSTEM_PROMPT = "..."
+class Makima(App):
+
+    def on_mount(self):
+        self.provider = GroqProvider()
+        self.memory = Memory(system_prompt=SYSTEM_PROMPT)
+
+    def compose(self):
+        yield Header()
+
+        yield RichLog(id="chat")
+
+        yield Input(
+            placeholder="Ask Makima...",
+            id="input"
+        )
+
+        yield Footer()
+
+    def on_input_submitted(self, event: Input.Submitted):
+        chat = self.query_one("#chat", RichLog)
+
+        user_input = event.value.strip()
+
+        if not user_input:
+            return
+
+        chat.write(
+            Text(f"You: {user_input}",style="bold cyan")
+        )
+        
+
+        event.input.value = ""
+
+        chat.write(
+            Text("Makima: Hello! I'm alive", style="bold green")
+        )
+        # chat.write("[bold green]Makima:[/] Hello! I'm alive")
+
+if __name__ == "__main__":
+    app = Makima()
+    app.run()

makima_cli-1.2.2/makima/tools/git_tools.py

@@ -0,0 +1,72 @@
+import subprocess
+from groq import Groq
+from makima.config import GROQ_API_KEY, PROJECT_ROOT
+import re
+
+
+def get_git_diff():
+    diff = subprocess.run("git diff", shell=True, text=True, capture_output=True)
+    status = subprocess.run("git status", shell=True, text=True, capture_output=True)
+
+    return f"STATUS:\n{status.stdout}\n\nDIFF:\n{diff.stdout}"
+
+
+def generate_commit_message(diff):
+    prompt = f"""Generate ONE git commit message for this diff.
+    Format: type(scope): description
+    Types: feat/fix/refactor/docs/chore
+    Rules: max 72 chars, no quotes, no backticks, no explanation
+    Return ONLY the commit message line, nothing else.
+
+    {diff[:3000]}"""
+    
+    try:
+        client = Groq(api_key=GROQ_API_KEY)
+        result = client.chat.completions.create(
+            model="qwen/qwen3.6-27b",
+            messages=[{
+                "role": "user",
+                "content": prompt
+            }]
+        )
+    except Exception as e:
+        print(f"Message Generator Failed!\n {e}")
+        return f"Failed to generate message: {e}"
+
+    content = result.choices[0].message.content
+    if "</think>" in content:
+        content = content.split("</think>")[-1].strip()
+    content = re.sub(r'[`\n]', '', content).strip()
+    return content
+
+
+def commit_and_push(message):
+    try:
+        message = clean_message(message)
+        cmd = f'git add -A && git commit -m "{message}" && git push origin main'
+        result = subprocess.run(
+            cmd,
+            shell=True,
+            text=True,
+            capture_output=True,
+            timeout=120,
+            cwd=PROJECT_ROOT
+        )
+        if result.returncode == 0:
+            return f"✓ Committed and pushed: {message}"
+        else:
+            return f"✗ Failed: {result.stderr}"
+    except Exception as e:
+        return f"✗ Error: {e}"
+
+
+
+def clean_message(message):
+    # remove thinking blocks
+    if "</think>" in message:
+        message = message.split("</think>")[-1].strip()
+    # remove backticks, quotes, special shell characters
+    message = re.sub(r'[`"\'\n]', '', message)
+    # remove any remaining markdown
+    message = message.strip()
+    return message

makima_cli-1.2.2/makima/tools/shell_tools.py

@@ -0,0 +1,13 @@
+import subprocess
+
+
+def run_command(cmd):
+    result = subprocess.run(
+        cmd,
+        shell=True,
+        capture_output=True,
+        text=True,
+        timeout=30
+    )
+
+    return result.stdout + result.stderr

makima_cli-1.2.2/makima/ui/app.py

@@ -0,0 +1,175 @@
+from textual.app import App, ComposeResult
+from textual.widgets import Header, Footer, Input, RichLog
+from makima.config import PROJECT_ROOT
+from makima.tools import TOOL_REGISTRY
+from makima.tools.registry import TOOL_SCHEMAS
+from makima.core.config_manager import handle_config, analyze_changes, commit_only
+from makima.tools.git_tools import commit_and_push
+from rich.text import Text
+import asyncio
+import json
+
+from makima.providers.groq_provider import GroqProvider
+from makima.core.memory import Memory
+
+from pathlib import Path
+
+
+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.
+"""
+
+
+class MakimaApp(App):
+    CSS_PATH = Path(__file__).parent / "app.tcss"
+    
+    def __init__(self):
+        super().__init__()
+        self.memory = Memory(system_prompt=SYSTEM_PROMPT)
+        self.provider = GroqProvider()
+        self.pending_commit = None
+
+    
+    def compose(self) -> ComposeResult:
+        yield Header()
+        yield RichLog(id="chat",markup=True, highlight=True)
+        yield Input(placeholder="Ask anything... (type 'exit' to quit)")
+        yield Footer()
+    
+    def on_mount(self):
+        # focus the input so user can type immediately
+        self.query_one(Input).focus()
+
+
+    async def on_input_submitted(self, event: Input.Submitted) -> None:
+        user_input = event.value.strip()
+
+        if not user_input:
+            return
+
+        chat = self.query_one(RichLog)
+        input_box = self.query_one(Input)
+
+        chat.write(Text.from_markup(f"[bold blue]You:[/] {user_input}"))
+        input_box.clear()
+
+        if user_input == "exit":
+            self.exit()
+            return
+
+        if user_input == "/config":
+            # config runs in background thread
+            await asyncio.to_thread(handle_config)
+            return
+
+        if user_input == "/commit":
+            chat.write("[dim]Analyzing changes...[/]")
+            diff, message = await asyncio.to_thread(analyze_changes)
+
+            if not diff:
+                chat.write("[yellow]No changes to commit.[/]")
+                return
+
+            chat.write(Text.from_markup(f"[white]Generated message: {message}[/]"))
+            chat.write(Text.from_markup(f"[yellow]Type 'push' to commit and push, 'commit' to commit only, or 'cancel'[/]"))
+
+            self.pending_commit = {"diff": diff, "message": message}
+            return
+
+        if user_input == "push" and self.pending_commit:
+            result = await asyncio.to_thread(commit_and_push, self.pending_commit["message"])
+            chat.write(Text.from_markup(f"[green]{result}[/]"))
+            self.pending_commit = None
+            return
+
+        if user_input == "commit" and self.pending_commit:
+            result = await asyncio.to_thread(commit_only, self.pending_commit["message"])
+            chat.write(f"[green]{result}[/]")
+            self.pending_commit = None
+            return
+
+        if user_input == "cancel" and self.pending_commit:
+            chat.write("[yellow]Commit cancelled.[/]")
+            self.pending_commit = None
+            return
+        
+        
+        # show thinking indicator
+        chat.write(Text.from_markup("[dim]thinking...[/]"))
+        
+        # run agent in background thread
+        response = await asyncio.to_thread(self.process_message, user_input)
+        
+        # remove "thinking..." and show response
+        from rich.markdown import Markdown
+        chat.write(Text.from_markup(f"[bold green]Agent:[/]"))
+        chat.write(Markdown(response))
+
+
+    def process_message(self, user_input):
+        self.memory.add_user(user_input)
+        
+        while True:
+            stream = self.provider.stream_chat(
+                messages=self.memory.get(),
+                tools=TOOL_SCHEMAS
+            )
+            chunks = list(stream)
+            
+            # collect chunks
+            text_buffer = ""
+            tool_name = ""
+            tool_args = ""
+            tool_call_id = ""
+            is_tool_call = False
+            
+            for chunk in chunks:
+                delta = chunk.choices[0].delta
+                if delta.content:
+                    text_buffer += delta.content
+                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
+            
+            if is_tool_call:
+                args = json.loads(tool_args)
+                tool_fn = TOOL_REGISTRY.get(tool_name)
+                result = tool_fn(**args) if tool_fn else "Unknown tool"
+                
+                self.memory.add_raw({
+                    "role": "assistant",
+                    "tool_calls": [{
+                        "id": tool_call_id,
+                        "type": "function",
+                        "function": {
+                            "name": tool_name,
+                            "arguments": tool_args
+                        }
+                    }]
+                })
+                self.memory.add_tool_result(tool_call_id, str(result))
+            
+            else:
+                self.memory.add_assistant(text_buffer)
+                return text_buffer
+def run_ui():
+    app = MakimaApp()
+    app.run()

{makima_cli-0.2.1 → makima_cli-1.2.2}/makima_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: makima-cli
-Version: 0.2.1
+Version: 1.2.2
 Summary: AI coding assistant for your terminal
 Author: Kanhaiya
 License: MIT License
@@ -52,7 +52,7 @@ An AI-powered coding assistant that runs in your terminal. Point it at any codeb
 
 ## Install
 
-git clone https://github.com/yourusername/makima-cli.git
+git clone https://github.com/kanhaiya-ML/makima-cli.git
 cd makima-cli
 pip install -r requirements.txt
 

{makima_cli-0.2.1 → makima_cli-1.2.2}/makima_cli.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ makima/__init__.py
 makima/config.py
 makima/main.py
 makima/setup.py
+makima/test.py
 makima/core/__init__.py
 makima/core/agent.py
 makima/core/config_manager.py
@@ -14,8 +15,11 @@ makima/providers/base.py
 makima/providers/groq_provider.py
 makima/tools/__init__.py
 makima/tools/file_tools.py
+makima/tools/git_tools.py
 makima/tools/registry.py
 makima/tools/shell_tools.py
+makima/ui/__init__.py
+makima/ui/app.py
 makima_cli.egg-info/PKG-INFO
 makima_cli.egg-info/SOURCES.txt
 makima_cli.egg-info/dependency_links.txt

{makima_cli-0.2.1 → makima_cli-1.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "makima-cli"
-version = "0.2.1"
+version = "1.2.2"
 description = "AI coding assistant for your terminal"
 readme = "README.md"
 license = {file = "LICENSE"}

makima_cli-0.2.1/makima/config.py

@@ -1,20 +0,0 @@
-import os
-import sys
-from makima.setup import setup_api_key,setup_model
-from dotenv import load_dotenv
-load_dotenv()
-
-GROQ_API_KEY = setup_api_key()
-# GROQ_API_KEY = os.getenv("GROQ_API_KEY")
-MODEL_NAME = setup_model()
-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:
-    print("Error: GROQ_API_KEY not set.")
-    print("Run this command first:")
-    print('  Windows: setx GROQ_API_KEY "your-key-here"')
-    print('  Linux/Mac: export GROQ_API_KEY="your-key-here"')
-    print("Get a free key at: https://console.groq.com")
-    sys.exit(1)

makima_cli-0.2.1/makima/main.py

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

makima_cli-0.2.1/makima/tools/shell_tools.py

@@ -1,20 +0,0 @@
-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