forgecodecli 0.1.0__py3-none-any.whl

forgecodecli/agent.py

@@ -0,0 +1,144 @@
+# from dotenv import load_dotenv
+from openai import OpenAI
+# import os
+import json
+from json import JSONDecoder
+from openai import RateLimitError
+from forgecodecli.config import load_config
+from forgecodecli.secrets import load_api_key
+
+# Load env
+# load_dotenv()
+
+def get_client():
+    config = load_config()
+    api_key = load_api_key()
+
+    if not config:
+        raise RuntimeError(
+            "ForgeCodeCLI is not set up. Run `forgecodecli init`."
+        )
+
+    if not api_key:
+        raise RuntimeError(
+            "API key not found. Run `forgecodecli init` again."
+        )
+
+    provider = config.get("provider")
+
+    if provider == "gemini":
+        return OpenAI(
+            api_key=api_key,
+            base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+        )
+
+    raise RuntimeError(f"Unsupported provider: {provider}")
+
+
+# client = OpenAI(
+#     api_key=os.getenv("GEMINI_API_KEY"),
+#     base_url="https://generativelanguage.googleapis.com/v1beta/openai/"
+# )
+
+SYSTEM_PROMPT = """
+You are an agent that decides what action to take.
+
+CRITICAL RULES:
+1. Each user request requires AT MOST TWO action that makes a change (write_file, create_dir, read_file, or list_files)
+2. After you have completed all required actions
+(up to the allowed limit), respond with "answer"
+3. Do NOT take multiple write_file or create_dir actions
+4. Do NOT repeat actions
+
+Actions available:
+- "read_file": read a file
+- "list_files": list directory contents
+- "write_file": write/create a file
+- "create_dir": create a directory
+- "answer": respond to the user (use this after task is complete)
+
+RESPONSE FORMAT - You MUST respond ONLY with valid JSON, nothing else:
+{
+  "action": "answer",
+  "args": {
+    "text": "Your message here"
+  }
+}
+
+Examples:
+- User: "create file.py with print('hello')" → write_file → ✅ appears → immediately return answer
+- User: "read file.py" → read_file → content appears → immediately return answer
+- User: "what's in src?" → list_files → files appear → immediately return answer
+
+
+"""
+
+def think(messages: list[dict]) -> dict:
+    config = load_config()
+    model = config.get("model", "gemini-2.5-flash")
+    try:
+      client = get_client()
+      response = client.chat.completions.create(
+        model=model,
+        messages=[{"role": "system", "content": SYSTEM_PROMPT}] + messages
+    )
+    except RateLimitError as e:
+      return {
+        "action": "answer",
+        "args": {
+            "text": "⚠️ Rate limit hit. Please wait a few seconds and try again."
+        }
+    }
+    except Exception as e:
+      return {
+        "action": "answer",
+        "args": {
+            "text": f"❌ LLM error: {str(e)}"
+        }
+    }
+
+
+    content = response.choices[0].message.content
+    
+    # Handle empty response
+    if content is None or not content.strip():
+        return {
+            "action": "answer",
+            "args": {
+                "text": "Task completed successfully!"
+            }
+        }
+    
+    cleaned = content.strip()
+
+    # Robust JSON extraction
+    decoder = JSONDecoder()
+    
+    # Try to find JSON object in the content
+    idx = cleaned.find("{")
+    if idx == -1:
+        return {
+        "action": "answer",
+        "args": {
+            "text": cleaned
+        }
+    }
+    
+    # Extract from first { onwards
+    cleaned = cleaned[idx:]
+    
+    # Try to decode JSON, handling partial/malformed content
+    try:
+        obj, _ = decoder.raw_decode(cleaned)
+        return obj
+    except json.JSONDecodeError:
+        # If it fails, try to find the end of a valid JSON object
+        # by trying progressively shorter strings from the end
+        for end_pos in range(len(cleaned), idx, -1):
+            try:
+                obj, _ = decoder.raw_decode(cleaned[:end_pos])
+                return obj
+            except json.JSONDecodeError:
+                continue
+        
+        raise ValueError(f"Could not parse JSON from LLM output: {cleaned[:100]}...")

forgecodecli/cli.py

@@ -0,0 +1,210 @@
+import typer
+from forgecodecli.agent import think
+from forgecodecli.tools import read_file, list_files, write_file, create_dir
+import getpass
+
+from forgecodecli.secrets import save_api_key, delete_api_key
+from forgecodecli.config import save_config, config_exists, delete_config
+
+app = typer.Typer()
+
+import os
+
+def show_logo():
+    cwd = os.getcwd()
+
+    print(f"""
+███████╗ ██████╗ ██████╗  ██████╗ ███████╗
+██╔════╝██╔═══██╗██╔══██╗██╔════╝ ██╔════╝
+█████╗  ██║   ██║██████╔╝██║  ███╗█████╗  
+██╔══╝  ██║   ██║██╔══██╗██║   ██║██╔══╝  
+██║     ╚██████╔╝██║  ██║╚██████╔╝███████╗
+╚═╝      ╚═════╝ ╚═╝  ╚═╝ ╚═════╝ ╚══════╝
+
+ForgeCode CLI • Agentic File Assistant
+Safe • Deterministic • File-aware
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+Agent Mode : Code Agent
+Model      : Gemini 2.5 Flash
+Workspace  : {cwd}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Type natural language commands to manage files.
+(type 'quit' or Ctrl+C to exit)\n
+""")
+
+@app.command()
+def init() :
+    """
+    Initialize ForgeCode CLI configuration
+    """
+    if config_exists():
+        typer.echo("ForgeCodeCLI is already set up.")
+        typer.echo("Use `forgecodecli reset` to reconfigure.")
+        return
+    
+    typer.echo("Welcome to ForgeCodeCLI ✨")
+    typer.echo("Let's set things up.\n")
+
+    typer.echo("Select LLM provider:")
+    typer.echo("  1) Gemini")
+    typer.echo("  2) Exit")
+    
+    choice = typer.prompt(">")
+    if choice != "1":
+        typer.echo("Exiting setup.")
+        return
+    
+    api_key = getpass.getpass("Enter your Gemini API Key: ")
+    if not api_key.strip():
+        typer.echo("API Key cannot be empty. Exiting setup.")
+        return
+    save_api_key(api_key)
+    
+    config = {
+        "provider": "gemini",
+        "model": "gemini-2.5-flash"
+    }
+    
+    save_config(config)
+    
+    typer.echo("\n✓ API key saved securely")
+    typer.echo("✓ Provider set to Gemini")
+    typer.echo("✓ Model set to gemini-2.5-flash")
+    typer.echo("\nSetup complete.")
+    typer.echo("Run `forgecodecli` to start.")
+    
+@app.command()
+def reset():
+    """
+    Reset ForgeCodeCLI configuration and API key
+    """
+    if not config_exists():
+        typer.echo("ForgeCodeCLI is not set up.")
+        return
+
+    typer.echo(
+        "This will remove your ForgeCodeCLI configuration and API key."
+    )
+    confirm = typer.prompt("Are you sure? (y/N)", default="n")
+
+    if confirm.lower() != "y":
+        typer.echo("Reset cancelled.")
+        return
+
+    try:
+        delete_api_key()
+        typer.echo("✓ API key removed")
+    except Exception:
+        typer.echo("⚠️ No API key found")
+
+    delete_config()
+    typer.echo("✓ Configuration deleted")
+
+    typer.echo("\nForgeCodeCLI has been reset.")
+    typer.echo("Run `forgecodecli init` to set it up again.")
+
+
+def describe_action(action: str, args: dict):
+    if action == "read_file":
+        print(f"📂 Reading file: {args.get('path')}")
+    elif action == "list_files":
+        print(f"📄 Listing files in: {args.get('path', '.')}")
+    elif action == "create_dir":
+        print(f"📁 Creating directory: {args.get('path')}")
+    elif action == "write_file":
+        print(f"✍️ Writing file: {args.get('path')}")
+
+
+@app.callback(invoke_without_command=True)
+def run(ctx: typer.Context):
+    """
+    ForgeCode CLI — agent with actions
+    """
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if not config_exists():
+        typer.echo("ForgeCodeCLI is not set up yet.")
+        typer.echo("Run `forgecodecli init` first.")
+        return
+
+    # ===============================
+    # INTERACTIVE MODE
+    # ===============================
+    show_logo()
+    messages = []
+
+    try:
+        while True:
+                user_input = input("forgecode (agent) >  ").strip()
+
+                if user_input.lower() in ("quit", "exit"):
+                    print("Bye")
+                    break
+
+                messages.append({"role": "user", "content": user_input})
+                # print("🤔 Planning actions...")
+                answered = False
+
+                for _ in range(5):
+                    decision = think(messages)
+                    action = decision.get("action")
+                    args = decision.get("args", {})
+
+                    if action == "read_file":
+                        describe_action(action, args)
+                        result = read_file(args.get("path"))
+                        print(result)
+                        messages.append({"role": "assistant", "content": result})
+                    
+                    elif action == "list_files":
+                        describe_action(action, args)
+                        result = list_files(args.get("path", "."))
+                        print(result)
+                        messages.append({"role": "assistant", "content": result})
+
+                    elif action == "create_dir":
+                        describe_action(action, args)
+                        result = create_dir(args.get("path"))
+                        print(result)
+                        messages.append({"role": "assistant", "content": result})
+
+                    elif action == "write_file":
+                        describe_action(action, args)
+                        result = write_file(
+                            args.get("path"),
+                            args.get("content")
+                        )
+                        print(result)
+                        messages.append({"role": "assistant", "content": result})
+
+                    elif action == "answer":
+                        print(args.get("text", ""))
+                        answered = True
+                        # Keep only last 10 messages to avoid context overflow
+                        if len(messages) > 20:
+                            messages = messages[-20:]
+                        break
+
+                if not answered:
+                    print("⚠️ I couldn't complete this request.")
+                    print("✅ Done")
+                    # Keep only last 10 messages to avoid context overflow
+                    if len(messages) > 20:
+                        messages = messages[-20:]
+
+    except KeyboardInterrupt:
+            print("\nBye")
+
+    return
+
+
+
+def main():
+    app()
+
+
+if __name__ == "__main__":
+    main()

forgecodecli/config.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+import json
+
+
+CONFIG_DIR = Path.home() / ".forgecodecli"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+def config_exists()-> bool:
+    return CONFIG_FILE.exists()
+
+def load_config()-> dict:
+    if not config_exists():
+        return {}
+    
+    with open(CONFIG_FILE, "r") as f:
+        return json.load(f)
+    
+
+def save_config(config: dict):
+    CONFIG_DIR.mkdir(exist_ok=True)
+    with open(CONFIG_FILE, "w") as f:
+        json.dump(config, f, indent=2)
+        
+def delete_config():
+    if config_exists():
+        CONFIG_FILE.unlink()
+        

forgecodecli/secrets.py

@@ -0,0 +1,13 @@
+import keyring
+
+SERVICE_NAME = "forgecodecli"
+
+def save_api_key(api_key: str):
+    keyring.set_password(SERVICE_NAME, "api_key", api_key)
+    
+def load_api_key() -> str | None:
+    return keyring.get_password(SERVICE_NAME, "api_key")
+
+def delete_api_key():
+    keyring.delete_password(SERVICE_NAME, "api_key")
+    

forgecodecli/tools.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+import os
+
+def is_safe_path(path: str) -> bool:
+    if not path:
+        return False
+    if os.path.isabs(path):
+        return False
+    if ".." in path:
+        return False
+    return True
+
+
+def read_file(path: str) -> str:
+    """Read a file and return its contents"""
+    file_path = Path(path)
+ 
+    if not file_path.exists():
+     return f"Error: File '{path}' does not exist."
+ 
+    return file_path.read_text()
+
+
+def list_files(path:str = ".")-> str:
+    if not is_safe_path(path):
+        return "Error: Unsafe path detected."
+    
+    full_path = os.path.join(os.getcwd(), path)
+    
+    if not os.path.exists(full_path):
+        return "❌ Path does not exist."
+
+    if not os.path.isdir(full_path):
+        return "❌ Path is not a directory."
+    
+    try:
+        items = os.listdir(full_path)
+        if not items:
+            return "📂 Directory is empty."
+        
+        return "\n".join(sorted(items))
+    except Exception as e:
+        return f"❌ Error reading directory: {str(e)}"
+    
+def write_file(path: str, content: str) -> str:
+    if not is_safe_path(path):
+        return "❌ Invalid path."
+
+    full_path = os.path.join(os.getcwd(), path)
+
+    # Prevent overwriting existing files (for now)
+    if os.path.exists(full_path):
+        return "❌ File already exists. Overwrite not allowed."
+
+    parent = os.path.dirname(full_path)
+    if parent and not os.path.exists(parent):
+        return "❌ Parent directory does not exist."
+
+    try:
+        with open(full_path, "w", encoding="utf-8") as f:
+            f.write(content)
+        return f"✅ File written: {path}"
+    except Exception:
+        return "❌ Failed to write file."
+
+def create_dir(path: str)-> str:
+    if not is_safe_path(path):
+        return "❌ Invalid path."
+    full_path = os.path.join(os.getcwd(), path)
+    try:
+        os.makedirs(full_path, exist_ok=True)
+        return f"✅ Directory created: {path}"
+    except Exception:
+        return "❌ Failed to create directory."

forgecodecli-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: forgecodecli
+Version: 0.1.0
+Summary: A minimal agentic CLI for forging code
+Author: Sudhanshu
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: keyring>=24.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+
+# ForgeCodeCLI
+
+An agentic, file-aware command-line tool that lets you manage and modify your codebase using natural language — powered by LLMs.
+
+It acts as a safe, deterministic AI agent that can read files, create directories, and write code only through explicit tools, not raw hallucination.
+
+## Features
+
+- Agentic workflow (LLM decides actions, CLI executes them)
+- File-aware (read, list, create, write files & directories)
+- Secure API key storage (no env vars required after setup)
+- Deterministic and rule-based execution
+- Interactive CLI experience
+- Built to support multiple LLM providers (Gemini first)
+
+## Installation
+
+Requires Python 3.9+
+
+```bash
+pip install forgecodecli
+```
+
+## Quick Start
+
+### Initialize (one-time setup)
+
+```bash
+forgecodecli init
+```
+
+You will be prompted to:
+- Select an LLM provider
+- Enter your API key (stored securely)
+
+### Start the agent
+
+```bash
+forgecodecli
+```
+
+You are now in interactive agent mode. Example commands:
+
+```
+create a folder src/app and add a main.py file that prints hello
+read the README.md file
+list all files in the src directory
+quit
+```
+
+Or press `Ctrl + C` to exit.
+
+## Reset Configuration
+
+To remove all configuration and API keys:
+
+```bash
+forgecodecli reset
+```
+
+## Security
+
+- API keys are stored using the system keyring
+- No API keys are written to config files or environment variables
+- Config files contain only non-sensitive metadata
+
+## How It Works
+
+1. You enter a natural language command
+2. The LLM decides the next valid action
+3. ForgeCodeCLI executes the action safely
+4. The agent responds with the result
+
+The agent is strictly limited to predefined tools, ensuring predictable and safe behavior.
+
+## Supported Actions
+
+- `read_file`
+- `list_files`
+- `create_dir`
+- `write_file`
+
+No action outside these tools is permitted.
+
+## Status
+
+This project is in active development.
+
+**Current version supports:**
+- Gemini LLM
+- Interactive agent mode
+
+**Planned features:**
+- Multiple LLM providers
+- Model switching
+- Streaming responses
+- Session memory
+
+## License
+
+MIT License
+
+## Author
+
+Built by Sudhanshu
+
+
+
+
+
+

forgecodecli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+forgecodecli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+forgecodecli/agent.py,sha256=ta-Ab8ORFzEQ0pbnCjf7CR6g4itBzZtjD6XMmay5Vgg,4124
+forgecodecli/cli.py,sha256=h1ip6kRoDLwco5558vYfyCEp8XMQDNvTVt8cqBRhuJA,7116
+forgecodecli/config.py,sha256=VFl21RTu0aTkYS3ConcgLoHD7LuV890d9LoXsAaYs5M,595
+forgecodecli/secrets.py,sha256=ZEaHYF9TkibST0IwEBHZbbazaLWJZR04n4FyGx9n1gU,328
+forgecodecli/tools.py,sha256=f6_bsblRpbYerHussznXNdnF93j3G6ppYWCHUgveoAI,2096
+forgecodecli-0.1.0.dist-info/METADATA,sha256=4w3PTAFjS7q-n8FeJ16PoMutA_-YxMqZ2WyIAlOpKAE,2677
+forgecodecli-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+forgecodecli-0.1.0.dist-info/entry_points.txt,sha256=KQDckJoVfVJtVxu3icUI99k-gpbIn_tihUG_ZwU4BAw,55
+forgecodecli-0.1.0.dist-info/top_level.txt,sha256=OJLRIfDbRvaNKg55kSvPDagGlTxajt3m1jnI3X5x204,13
+forgecodecli-0.1.0.dist-info/RECORD,,

forgecodecli-0.1.0.dist-info/WHEEL

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

forgecodecli-0.1.0.dist-info/entry_points.txt

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

forgecodecli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+forgecodecli