nlsql-coder 0.0.1__py3-none-any.whl

nlsql_coder/app/agent/helpers/get_agent.py

@@ -0,0 +1,23 @@
+from pathlib import Path
+from nlsql_coder.app.providers.config import ProviderConfig
+from nlsql_coder.app.agent.model.agent import Agent
+from nlsql_coder.app.agent.tools.tool_specs import read_file_spec, write_file_spec, get_project_tree_spec, edit_file_spec, insert_relative_spec, insert_to_file_spec
+from nlsql_coder.app.cli.arg_parsing import args
+
+provider_config = ProviderConfig()
+agent = None
+system_prompt = ""
+with open(Path(__file__).resolve().parent / "system_prompt.md", "r") as f:
+    system_prompt = f.read()
+agents_md = Path(args.workspace, "AGENTS.md")
+if agents_md.exists():
+    with open(agents_md, "r") as f:
+        content = f.read()
+    system_prompt += content
+tools = [read_file_spec, write_file_spec, get_project_tree_spec, edit_file_spec, insert_to_file_spec, insert_relative_spec]
+
+if provider_config.model_provider == "aws":
+    from nlsql_coder.app.providers.aws.provider import AWSBedrockProvider
+    model_id = provider_config.model_name
+    llm = AWSBedrockProvider(model_id)
+    agent = Agent(llm, system_prompt, tools)

nlsql_coder/app/agent/helpers/memory_manager.py

@@ -0,0 +1,6 @@
+# from app.providers.base import Message
+
+# class AgentMemory:
+
+
+# def summarize_conversation():

nlsql_coder/app/agent/helpers/project_details.py

@@ -0,0 +1,32 @@
+import os
+from pathlib import Path
+
+
+class Project:
+    """
+    Project class to gather context about the current project.
+    """
+    def __init__(self, root):
+        self.root = root
+        self.ignore_paths = [".venv", "venv", "__pycache__", ".git"]
+
+
+    def generate_tree(self, path: Path = None, indent: str = "", lines=None):
+        if lines is None:
+            lines = []
+            path = Path(self.root)
+            lines.append(f"{path.name}/")
+
+        try:
+            items = sorted([i for i in os.listdir(path) if i not in self.ignore_paths])
+            for item in items:
+                full_path = path / item
+                if full_path.is_dir():
+                    lines.append(f"{indent}    {item}/")
+                    self.generate_tree(full_path, indent + "    ", lines)
+                else:
+                    lines.append(f"{indent}    {item}")
+        except PermissionError:
+            lines.append(f"{indent}    [Access Denied]")
+        return "\n".join(lines)
+

nlsql_coder/app/agent/model/agent.py

@@ -0,0 +1,99 @@
+"""
+Planner agent class.
+Implements the functionallity for the planner agent.
+"""
+from nlsql_coder.app.providers.base import BaseProvider, Message
+from typing import Type, Iterator
+
+from nlsql_coder.app.agent.tools.tool_specs import ToolSpecification
+
+class Agent:
+    """
+    Main agent class, highest level class - first point of call for user messages.
+    Responsible for planning the steps involved in completing the give task and invoking other agents if needed.
+    """
+    def __init__(self, provider_class: Type[BaseProvider], system_prompt: str, tools: list[ToolSpecification] = None):
+        self.llm = provider_class
+        self.messages = []
+
+        self.kwargs = {
+            "system_prompt": system_prompt,
+            "tools": tools
+        }
+        if not tools:
+            self.kwargs.pop("tools")
+
+    def chat(self, message: str | list) -> Iterator[str | dict]:
+        if not message:
+            raise ValueError("Message is empty.")
+        
+        # results = []
+        if isinstance(message, str):
+            user_message = Message(role="user", content=message)
+            self.messages.append(self.llm.form_message(user_message))
+        elif isinstance(message, list):
+            tool_result_messages = self.llm.form_message(message)
+            # content = tool_result_messages["content"]
+            # for item in content:
+            #     results.append((item["toolResult"]["toolUseId"], item["toolResult"]["content"]))
+            self.messages.append(tool_result_messages)
+
+        response = self.llm.stream_chat(self.messages, **self.kwargs)
+
+        accumulated = ""
+        tools_used = []
+        usage_data = None
+        for chunk in response:
+            if isinstance(chunk, str):
+                if not "**Using tool:**" in chunk:
+                    accumulated += chunk
+                yield chunk
+            elif isinstance(chunk, dict):
+                if chunk.get("input_tokens"):
+                    usage_data = chunk
+                else:
+                    for v in chunk.values():
+                        tools_used.append(v)
+        
+        if accumulated:
+            assistant_message = Message(role="assistant", content=accumulated.strip())
+            self.messages.append(self.llm.form_message(assistant_message))
+        if tools_used:
+            tool_message = {
+                "role": "assistant",
+                "content": [{"toolUse": tool} for tool in tools_used]
+            }
+            self.messages.append(tool_message)
+            yield tools_used
+            # else:
+            #     assistant_message = Message(role="assistant", content=accumulated.strip())
+            #     self.messages.append(self.llm.form_message(assistant_message))
+
+        # if results:
+        #     kwargs = {
+        #         "system_prompt": "You specialize in writing the shortest possible summaries of tool call results, respond ONLY with the summary and no other text."
+        #     }
+
+        #     for tool_id, result in results:
+        #         msg = Message(role="user", content=f"Summarize the following tool result: {result}")
+        #         msg = self.llm.form_message(msg)
+
+        #         summary_stream = self.llm.stream_chat([msg], **kwargs)
+
+        #         summary_text = ""
+        #         for chunk in summary_stream:
+        #             if isinstance(chunk, str):
+        #                 summary_text += chunk
+
+        #         summary_text = summary_text.strip()
+
+        #         # Replace the original tool result content with the summary
+        #         for m in self.messages:
+        #             if m["role"] == "user":
+        #                 for item in m.get("content", []):
+        #                     tool_result = item.get("toolResult")
+        #                     if tool_result and tool_result["toolUseId"] == tool_id:
+        #                         tool_result["content"] = [{"text": summary_text}]
+
+        if usage_data:
+            yield usage_data

nlsql_coder/app/agent/tools/file_tools.py

@@ -0,0 +1,147 @@
+from nlsql_coder.app.agent.helpers.project_details import Project
+from pathlib import Path
+from nlsql_coder.app.cli.arg_parsing import args
+
+FILE_TOOL_REGISTRY = {}
+
+project = Project(args.workspace)
+
+def get_project_tree():
+    """
+    Get's the current project's file tree
+    """
+    return project.generate_tree()
+
+
+def read_file(file_path: str, from_line: int = 1, to_line: int = 100):
+    """
+    Reads a given file starting at from_line ending at to_line and returns its contents.
+    """
+    try:
+        root_path = Path(project.root).resolve()
+        target_path = (root_path / file_path).resolve()
+
+        if not str(target_path).startswith(str(root_path)):
+            return "error: access outside workspace is not allowed."
+        if from_line > to_line:
+            return "error: from_line must be less than or equal to to_line."
+        
+        contents = []
+        with open(target_path, "r", encoding="utf-8") as f:
+            for i, line in enumerate(f, start=1):
+                if i > to_line:
+                    break
+                if i >= from_line:
+                    contents.append(line)
+        return "".join(contents)
+    except FileNotFoundError:
+        return "error: the file does not exist."
+    except IsADirectoryError:
+        return f"error: {file_path} is a directory."
+    except PermissionError:
+        return "error: you do not have permission to read this file."
+    
+
+def write_file(file_path: str, content: str):
+    """
+    Writes the given content to a new file at the specified file path.
+    """
+    try:
+        if not file_path:
+            return "error: file_path not given."
+        if not content:
+            return "error: no content given."
+        root_path = Path(project.root).resolve()
+        target_path = (root_path / file_path).resolve()
+        if not str(target_path).startswith(str(root_path)):
+            return "error: access outside workspace is not allowed."
+        with open(target_path, "w") as f:
+            f.write(content)
+        return "success"
+    except PermissionError:
+        return "error: you do not have permission to write to this file."
+    except Exception as e:
+        return f"error: there was an error writing the file: {e}"
+
+
+def edit_file(file_path: str, edits: list[dict[str, str]]):
+    """Apply the given edits to a file."""
+    # TODO: This tool needs work, using replace will replace all instances (it's dangerous)
+    try:
+        root_path = Path(project.root).resolve()
+        target_path = (root_path / file_path).resolve()
+        contents = ""
+        with open(target_path, "r") as f:
+            contents = f.read()
+        for edit in edits:
+            if not edit["search"].endswith("\n"):
+                edit["search"] += "\n"
+            contents = contents.replace(edit["search"], edit["replace"])
+        with open(target_path, "w") as f:
+            f.write(contents)
+        return "success"
+    except FileNotFoundError:
+        return "error: the file does not exist."
+    except IsADirectoryError:
+        return f"error: {file_path} is a directory."
+    except PermissionError:
+        return "error: you do not have permission to edit this file."
+    
+
+def insert_to_file(file_path: str, code: str, mode: str = "append"):
+    """
+    mode:
+      - append
+      - prepend
+    """
+    root_path = Path(project.root).resolve()
+    target_path = (root_path / file_path).resolve()
+
+    with open(target_path, "r") as f:
+        contents = f.read()
+
+    if mode == "append":
+        contents = contents.rstrip() + "\n\n" + code + "\n"
+    elif mode == "prepend":
+        contents = code.rstrip() + "\n\n" + contents
+    else:
+        raise ValueError("Invalid mode")
+
+    with open(target_path, "w") as f:
+        f.write(contents)
+
+    return "success"
+
+
+def insert_relative(file_path: str, anchor: str, code: str, position: str = "after"):
+    root_path = Path(project.root).resolve()
+    target_path = (root_path / file_path).resolve()
+
+    with open(target_path, "r") as f:
+        lines = f.readlines()
+
+    for i, line in enumerate(lines):
+        if anchor in line:
+            if position == "after":
+                lines.insert(i + 1, code + "\n")
+            elif position == "before":
+                lines.insert(i, code + "\n")
+            else:
+                raise ValueError("position must be before or after")
+            break
+    else:
+        raise ValueError("Anchor not found")
+
+    with open(target_path, "w") as f:
+        f.writelines(lines)
+
+    return "success"
+
+
+
+FILE_TOOL_REGISTRY["read_file"] = read_file
+FILE_TOOL_REGISTRY["write_file"] = write_file
+FILE_TOOL_REGISTRY["get_project_tree"] = get_project_tree
+FILE_TOOL_REGISTRY["edit_file"] = edit_file
+FILE_TOOL_REGISTRY["insert_to_file"] = insert_to_file
+FILE_TOOL_REGISTRY["insert_relative"] = insert_relative

nlsql_coder/app/agent/tools/tool_specs.py

@@ -0,0 +1,161 @@
+"""
+Tool specifications & provider convertion functions
+Current tools:
+    file_tools.py
+        read_file(file_path: str, from_line: int = 0, to_line: int = 100)
+"""
+from nlsql_coder.app.providers.base import ToolSpecification, ToolSchema, ToolProperty
+
+
+############### Tools Specifications ###################
+
+read_file_spec = ToolSpecification(
+    name="read_file",
+    description="Reads a given file starting at from_line ending at to_line and returns its contents.",
+    schema=ToolSchema(
+        type="object",
+        properties={
+            "file_path": ToolProperty(
+                type="string",
+                description="Path to the file to read (relative to the workspace root)."
+            ),
+            "from_line": ToolProperty(
+                type="integer",
+                description="Line number to start reading from (1-indexed). Defaults to 1.",
+                default=1
+            ),
+            "to_line": ToolProperty(
+                type="integer",
+                description="Line number to stop reading at (inclusive). Defaults to 100.",
+                default=100
+            )
+        },
+        required=["file_path"]
+    )
+)
+
+write_file_spec = ToolSpecification(
+    name="write_file",
+    description="Writes the contents to a new file at the given location",
+    schema=ToolSchema(
+        type="object",
+        properties={
+            "file_path": ToolProperty(
+                type="string",
+                description="Path to the file to write (relative to the workspace root (must include file name))."
+            ),
+            "content": ToolProperty(
+                type="string",
+                description="The content to write to the file.",
+            ),
+        },
+        required=["file_path", "content"]
+    )
+)
+
+edit_file_spec = ToolSpecification(
+    name="edit_file",
+    description="Apply one or more edits to a file.",
+    schema=ToolSchema(
+        properties={
+            "file_path": ToolProperty(
+                type="string",
+                description="File path"
+            ),
+            "edits": ToolProperty(
+                type="array",
+                description="List of edits",
+                items=ToolProperty(
+                    type="object",
+                    description="Single edit",
+                    properties={
+                        "search": ToolProperty(
+                            type="string",
+                            description="Text to find"
+                        ),
+                        "replace": ToolProperty(
+                            type="string",
+                            description="Replacement text"
+                        ),
+                    },
+                    required=["search", "replace"]
+                )
+            )
+        },
+        required=["file_path", "edits"]
+    )
+)
+
+insert_to_file_spec = ToolSpecification(
+    name="insert_to_file",
+    description="Insert code into a file by appending or prepending it.",
+    schema=ToolSchema(
+        properties={
+            "file_path": ToolProperty(
+                type="string",
+                description="Path to the file"
+            ),
+            "code": ToolProperty(
+                type="string",
+                description="Code to insert into the file"
+            ),
+            "mode": ToolProperty(
+                type="string",
+                description="Where to insert the code: append or prepend",
+            )
+        },
+        required=["file_path", "code", "mode"]
+    )
+)
+
+insert_relative_spec = ToolSpecification(
+    name="insert_relative",
+    description="Insert code before or after a matching anchor line in a file.",
+    schema=ToolSchema(
+        properties={
+            "file_path": ToolProperty(
+                type="string",
+                description="Path to the file"
+            ),
+            "anchor": ToolProperty(
+                type="string",
+                description="Text to search for in a line (anchor point)"
+            ),
+            "code": ToolProperty(
+                type="string",
+                description="Code to insert"
+            ),
+            "position": ToolProperty(
+                type="string",
+                description="Where to insert relative to anchor: before or after",
+            )
+        },
+        required=["file_path", "anchor", "code", "position"]
+    )
+)
+
+get_project_tree_spec = ToolSpecification(
+    name="get_project_tree",
+    description="Gets the current project's file tree.",
+    schema=ToolSchema(
+        type="object",
+        properties={},
+        required=[]
+    )
+)
+
+#################################################
+
+
+########### Conversion functions ##################
+
+def tool_aws_bedrock(tool: ToolSpecification):
+    return {
+        "toolSpec": {
+            "name": tool.name,
+            "description": tool.description,
+            "inputSchema": {
+                "json": tool.schema.serialize()
+            }
+        }
+    }

nlsql_coder/app/cli/arg_parsing.py

@@ -0,0 +1,7 @@
+import argparse
+
+arg_parser = argparse.ArgumentParser()
+arg_parser.add_argument("-w", "--workspace", default=".", help="Path to the targe project's workspace.")
+arg_parser.add_argument("-u", "--usage", action="store_true", help="Displayed usage data after each conversation turn.")
+
+args = arg_parser.parse_args()

nlsql_coder/app/cli/interface.py

@@ -0,0 +1,96 @@
+from nlsql_coder.app.agent.helpers.get_agent import agent
+from nlsql_coder.app.cli.tool_calling import call_tools
+from nlsql_coder.app.cli.arg_parsing import args
+
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.live import Live
+from rich.align import Align
+from nlsql_coder.data.create_agent_md import create_md
+import time
+
+
+console = Console()
+
+welcome_message = """[blue bold]\n
+Welcome      _   _  _      ____   ___  _     
+            | \ | || |    / ___| / _ \| |    
+       to   |  \| || |    \___ \| | | | |    
+            | |\  || |___  ___) | |_| | |___ 
+            |_| \_||_____||____/ \__\_\_____|   Code\n\n[/blue bold]
+"""
+
+
+
+def main_loop():
+    try:
+        usage_data = {}
+        console.clear()
+        with console.status("[bold]Creating AGENTS.md file...\n[/bold]", spinner="dots"):
+            success = create_md()
+        if success == "created":
+            console.print("[bold]AGENTS.md file created at project root.\n[/bold]")
+        elif success == "exists":
+            console.print("[bold]AGENTS.md file already exists at project root.\n[/bold]")
+        elif success == "empty":
+            console.print("[bold]Starting from scratch!\n[/bold]")
+        else:
+            console.print("[bold]Failed to create AGENTS.md file.\n[/bold]")
+        time.sleep(2)
+        console.clear()
+        console.print(Align.center(welcome_message))
+
+        while True:
+
+            if args.usage and usage_data:
+                table = (
+                    "| Input Tokens | Output Tokens | Total Tokens |\n"
+                    "|--------------|---------------|---------------|\n"
+                    f"| {usage_data.get('input_tokens')} | {usage_data.get('output_tokens')} | {usage_data.get('total_tokens')} |\n"
+                )
+                console.print("[bold]\n\nUsage Data[/bold]")
+                console.print(Markdown(table))
+
+            messages = console.input("\n[bold green][You]:[/bold green] ")
+
+            if messages.lower() in ["quit", "exit"]:
+                console.print("\n\n[bold purple]Goodbye[/bold purple]\n")
+                break
+
+            console.print("\n[bold cyan][Assistant]:[/bold cyan]")
+
+            while True:
+                usage_data = {}
+
+                found_tool_calls = False
+                buffer = ""
+                with Live(console=console, refresh_per_second=1) as live:
+                    for chunk in agent.chat(messages):
+                        if isinstance(chunk, str):
+                            # Chat message chunk
+                            buffer += chunk
+                            live.update(Markdown(buffer))
+                        elif isinstance(chunk, list):
+                            # Tool execution
+                            found_tool_calls = True
+                            tool_results = call_tools(chunk)
+                            messages = tool_results
+                        elif isinstance(chunk, dict):
+                            # Usage data
+                            if args.usage:
+                                if not usage_data:
+                                    usage_data["input_tokens"] = chunk["input_tokens"]
+                                    usage_data["output_tokens"] = chunk["output_tokens"]
+                                    usage_data["total_tokens"] = chunk["total_tokens"]
+                                else:
+                                    usage_data["input_tokens"] += chunk["input_tokens"]
+                                    usage_data["output_tokens"] += chunk["output_tokens"]
+                                    usage_data["total_tokens"] += chunk["total_tokens"]
+
+
+                if not found_tool_calls:
+                    break
+    except KeyboardInterrupt:
+        console.print("\n\n[bold purple]Goodbye[/bold purple]\n")
+    except Exception as e:
+        console.print(f"\n\n[bold red]Oh no! Something went wrong. Here's the error:\n\n{e}[/bold red]\n")

nlsql_coder/app/cli/tool_calling.py

@@ -0,0 +1,27 @@
+from nlsql_coder.app.agent.tools.file_tools import FILE_TOOL_REGISTRY
+
+def call_tools(tool_calls: list[dict]) -> list[dict]:
+    tool_results = []
+    for tool in tool_calls:
+        tool_id = tool["toolUseId"]
+        tool_name = tool["name"]
+        tool_input = tool["input"]
+
+        tool_function = FILE_TOOL_REGISTRY.get(tool_name)
+
+        if tool_function:
+            tool_results.append({
+                "toolUseId": tool_id,
+                "name": tool_name,
+                "result": tool_function(**tool_input),
+                "status": "success"
+            })
+        else:
+            tool_results.append({
+                "toolUseId": tool_id,
+                "name": tool_name,
+                "result": "error: Unknown tool.",
+                "status": "error"
+            })
+            
+    return tool_results

nlsql_coder/app/providers/aws/provider.py

@@ -0,0 +1,139 @@
+from nlsql_coder.app.providers.base import BaseProvider, Message
+from typing import Iterator
+from nlsql_coder.app.providers.config import AWSConfig
+from nlsql_coder.app.agent.tools.tool_specs import ToolSpecification, tool_aws_bedrock
+import boto3
+import json
+
+
+class AWSBedrockProvider(BaseProvider):
+    
+    def __init__(self, model_id: str):
+        config = AWSConfig()
+
+        self.model_id = model_id
+        self.client = boto3.client(
+            "bedrock-runtime",
+            region_name=config.region,
+            aws_access_key_id=config.access_key_id,
+            aws_secret_access_key=config.secret_access_key,
+        )
+
+    def form_message(self, message: Message | list[dict]) -> dict:
+        if isinstance(message, Message):
+            if isinstance(message.content, str): # Standard chat message
+                return {"role": message.role, "content": [{"text": message.content}]}
+            if isinstance(message.content, dict): 
+                if message.content["type"] == "tool_use":
+                    return {"role": message.role, "content": [{"toolUse": message.content}]} # Tool call message
+        else:
+            results = {
+                "role": "user", 
+                "content": [
+                    {
+                        "toolResult": {
+                            "toolUseId": m["toolUseId"], 
+                            "content": [{"text": m["result"]}], 
+                            "status": m["status"]
+                        }
+                    } 
+                    for m in message
+                ]
+            }
+            return results
+                    
+
+    def stream_chat(self, messages: list[Message], 
+                    max_tokens: int = 8192, 
+                    temperature: float = 0.7,
+                    system_prompt: str = "",
+                    tools: list[ToolSpecification] | None = None) -> Iterator[str]:
+
+        system_message = [{"text": system_prompt}]
+        inference_config = {"maxTokens": max_tokens}
+        
+        if not "opus-4-7" in self.model_id:
+            inference_config["temperature"] = temperature
+
+        kwargs = {
+            "modelId": self.model_id,
+            "messages": messages,
+            "system": system_message,
+            "inferenceConfig": inference_config,
+        }
+
+        if tools:
+            tools = [tool_aws_bedrock(tool) for tool in tools]
+            kwargs["toolConfig"] = {"tools": tools}
+        
+        response = self.client.converse_stream(**kwargs)
+
+        tool_calls = {}
+        usage_data = {}
+
+        for event in response["stream"]:
+            if "contentBlockStart" in event:
+                idx = event["contentBlockStart"]["contentBlockIndex"]
+                start_event = event["contentBlockStart"]["start"]
+                if "toolUse" in start_event:
+                    tool_use = start_event['toolUse']
+                    tool_calls[idx] = {
+                        "toolUseId": tool_use["toolUseId"] ,
+                        "name": tool_use["name"],
+                        "input": "",
+                        "type": tool_use["type"]
+                    }
+                    yield f"\n\n**Using tool:** {tool_use['name']}\n" # User-facing tool call message
+            
+            if "contentBlockDelta" in event:
+                delta_event = event["contentBlockDelta"]
+                idx = delta_event["contentBlockIndex"]
+                if "delta" in delta_event:
+                    delta = delta_event["delta"]
+                    if "text" in delta:
+                        yield delta["text"] # Message chunk output
+                    if "toolUse" in delta:
+                        tool_input_chunk = delta["toolUse"]["input"] # Tool input chunks
+                        if idx in tool_calls:
+                            tool_calls[idx]["input"] += tool_input_chunk
+
+            if "contentBlockStop" in event:
+                idx = event["contentBlockStop"]["contentBlockIndex"]
+                if tool_calls:
+                    # Turn tool input json string to dict
+                    for v in tool_calls.values():
+                        if isinstance(v.get("input"), str):
+                            raw_val = v["input"].strip()
+                            if raw_val:
+                                try:
+                                    v["input"] = json.loads(raw_val)
+                                    if v.get("name") == "read_file":
+                                        yield f"**Reading {v['input'].get('file_path')}**\n\n"
+                                    if v.get("name") in ["edit_file", "insert_to_file", "insert_relative"]:
+                                        yield f"**Editing {v['input'].get('file_path')}**\n\n"
+                                    if v.get("name") == "write_file":
+                                        yield f"**Writing {v['input'].get('file_path')}**\n\n"
+                                except json.JSONDecodeError:
+                                    v["input"] = {}
+                            else:
+                                v["input"] = {}
+
+            if "metadata" in event:
+                metadata = event["metadata"]
+                if "usage" in metadata:
+                    usage = metadata["usage"]
+                    usage_data = {
+                        "input_tokens": usage["inputTokens"],
+                        "output_tokens": usage["outputTokens"],
+                        "total_tokens": usage["totalTokens"]
+                    }
+
+        # If tools were called yield the calls and execute them in the agent class
+        if tool_calls:
+            yield tool_calls
+        if usage_data:
+            yield usage_data
+    
+
+
+    

nlsql_coder/app/providers/base.py

@@ -0,0 +1,81 @@
+"""
+Base provider class.
+Normalizes LLM interaction and responses amoung the different LLM providers.
+"""
+from abc import ABC, abstractmethod
+from typing import Iterator, Literal, Dict, Optional, Any, List
+from dataclasses import dataclass, field
+
+@dataclass
+class Message:
+    role: Literal["user", "assistant", "system"]
+    content: str | dict
+
+
+@dataclass
+class ToolProperty:
+    type: str
+    description: str
+    default: Optional[Any] = None
+    items: Optional["ToolProperty"] = None
+    properties: Optional[Dict[str, "ToolProperty"]] = None
+    required: Optional[List[str]] = None
+
+@dataclass
+class ToolSchema:
+    type: str = "object"
+    properties: Dict[str, ToolProperty] = field(default_factory=dict)
+    required: List[str] = field(default_factory=list)
+
+    def serialize(self):
+        return serialize_schema(self)
+
+@dataclass
+class ToolSpecification:
+    name: str
+    description: str
+    schema: ToolSchema
+
+
+def serialize_property(prop: ToolProperty):
+    result = {
+        "type": prop.type,
+        "description": prop.description
+    }
+
+    if prop.default is not None:
+        result["default"] = prop.default
+
+    if prop.type == "array" and prop.items:
+        result["items"] = serialize_property(prop.items)
+
+    if prop.type == "object" and prop.properties:
+        result["properties"] = {
+            k: serialize_property(v) for k, v in prop.properties.items()
+        }
+        result["required"] = prop.required or []
+        result["additionalProperties"] = False
+
+    return result
+
+def serialize_schema(schema: ToolSchema):
+    result = {
+        "type": schema.type,
+        "properties": {
+            k: serialize_property(v)
+            for k, v in schema.properties.items()
+        },
+        "required": schema.required or [],
+        "additionalProperties": False
+    }
+    return result
+
+
+class BaseProvider(ABC):
+    @abstractmethod
+    def stream_chat(self, messages: list[Message], **kwargs) -> Iterator[str]:
+        pass
+
+    @abstractmethod
+    def form_message(self, message: Message):
+        pass

nlsql_coder/app/providers/config.py

@@ -0,0 +1,22 @@
+"""
+Provider configuration.
+"""
+from dataclasses import dataclass
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+# Provider & Model config
+@dataclass
+class ProviderConfig:
+    model_provider: str = os.getenv("MODEL_PROVIDER", "")
+    model_name: str = os.getenv("MODEL_NAME", "")
+
+
+# AWS Config
+@dataclass
+class AWSConfig:
+    access_key_id: str = os.getenv("AWS_ACCESS_KEY_ID", "")
+    secret_access_key: str = os.getenv("AWS_SECRET_ACCESS_KEY", "")
+    region: str = os.getenv("AWS_DEFAULT_REGION", "")

nlsql_coder/data/create_agent_md.py

@@ -0,0 +1,76 @@
+from nlsql_coder.app.agent.helpers.project_details import Project
+from nlsql_coder.app.cli.arg_parsing import args
+from nlsql_coder.app.agent.helpers.get_agent import llm
+from nlsql_coder.app.agent.model.agent import Agent
+from pathlib import Path
+
+# Get relevant project files for context
+def create_md():
+    try:
+        root = Path(args.workspace)
+        if Path(root, "AGENTS.md").exists():
+            return "exists"
+        patterns = ["README*", "readme*", "requirements*", "package.json", "*.md", "*.txt", "main.*", "run.*", "Dockerfile", "*compose*.yml", "*compose*.yaml", "index.html"]
+        exclude_dirs = {".venv", "node_modules", ".git", "__pycache__"}
+
+        files = []
+        for pattern in patterns:
+            for f in root.rglob(pattern):
+                if not any(part in exclude_dirs for part in f.parts):
+                    files.append(f)
+        if not files:
+            return "empty"
+
+        project = Project(args.workspace)
+
+        project_tree = project.generate_tree()
+
+        overview_creator_prompt = """
+        # Role
+        You are a coding project summerizer
+
+        # Task
+        Summarize the project based on the given context and extract any important information for the development agent's context.
+
+        Your summary should include:
+        - Brief overview of the project (i.e. name, what it does, who it's for.)
+        - Commands/steps to buidl and run the application (if applicable)
+        - Project archetecture (i.e. main components, frontend, backend, languages used)
+        - Any other relevant observations or notes
+
+        # Response rules
+        - Respond ONLY with the project summary
+        - Respond in Markdown format
+        - Keep the summary consice and on-topic
+        """
+        overview_creator = Agent(llm, overview_creator_prompt)
+
+        file_contents = ""
+        for file in files:
+            with open(Path(root, file), "r") as f:
+                file_contents += f"{str(file)}:\n{f.read()}"
+
+        context_message = f"""
+        CONTEXT:
+        {file_contents}
+        """
+        accumulated = ""
+        response = overview_creator.chat(context_message)
+        for chunk in response:
+            if isinstance(chunk, str):
+                accumulated += chunk
+
+        md = f"""
+        # Project Tree
+        ```
+        {project_tree}
+        ```
+        {accumulated}
+        """
+
+        with open(Path(root, "AGENTS.md"), "w") as f:
+            f.write(md)
+        
+        return "created"
+    except Exception as e:
+        return False

nlsql_coder-0.0.1.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: nlsql-coder
+Version: 0.0.1
+Summary: NLSQL's internal AI coding agent CLI tool for interacting with codebases
+Author: NLSQL
+License: MIT
+Keywords: ai,agent,cli,coding,llm
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: boto3<2.0,>=1.34
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: faiss-cpu>=1.7.0
+Dynamic: license-file
+
+# NLSQL Internal Coding Agent
+
+NLSQL's internal coding agent is a private, tool-driven, workspace-aware AI system designed to help with both internal and client-based development tasks in the NLSQL ecosystem.
+
+# Features
+
+- User-friendly command line interface.
+- Wide array of LLM/provider support acorss many cloud ecosystems.
+- Primary privacy & security focus.
+- Parallel tool calling ability for speed and efficency.
+
+# How it Works
+
+The agent operates using a ReAct-style loop. A user submits a prompt, and the agent processes it by reasoning about the task, performing actions using available tools, and evaluating the results.
+
+If the outcome is insufficient or incomplete, the agent continues this cycle, refining its approach and taking further actions until it can produce a final response.
+
+# Usage
+
+To use the application, follow the steps below:
+
+1. Clone this repo to your local system: `git clone <repo-link-here>`
+2. Make sure you are at `cd internal-coding-agent`
+3. Create a virtual environment: `python3 -m venv .venv`
+4. Activate the venv: `source .venv/bin/activate`
+6. Install requirements: (if venv is activated correctly you should see "(venv)" in your terminal) `pip install -r requirements.txt`
+7. Add .env file into `cd internal-coding-agent` root folder
+8. Run the application: `python3 run.py -u --workspace path/to/your/project`
+
+## Arguments
+
+| Short | Long | Description | Defaults to | Required |
+|-|-|-|-|-|
+| `-w` | `--workspace` | The root directory of the project you want to work on. | `.` | ✔ |
+| `-u` | `--usage` | Displays usage data after each conversation turn (input & output tokens) | `False` | ✗ |

nlsql_coder-0.0.1.dist-info/RECORD

@@ -0,0 +1,30 @@
+nlsql_coder/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/agent/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/agent/helpers/get_agent.py,sha256=z10raBVCj_lyvqJdxQoR1GzCXn28eLzKYvqylGNJf3k,1052
+nlsql_coder/app/agent/helpers/memory_manager.py,sha256=0glsSiXsmQeICKCMADUDG4oPjd5WuB5n2J0JKZEBOPE,96
+nlsql_coder/app/agent/helpers/project_details.py,sha256=82lCMZSINTkGKcWn2XVeIDK61m7ulba5ZkdCzr1xABE,1004
+nlsql_coder/app/agent/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/agent/model/agent.py,sha256=0FLqfSC_WIN798X31tyVryTYRdS_sAWGEzVFdeD8O1s,3989
+nlsql_coder/app/agent/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/agent/tools/file_tools.py,sha256=1MFW1rjJaaKBReyvCQUFzsf3hMia6uFx8krL-enY2is,4832
+nlsql_coder/app/agent/tools/tool_specs.py,sha256=Fqj-mn8D-gsopuXONO3Q8FsHqSnKX8lyMSMlIYZrkVQ,4977
+nlsql_coder/app/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/cli/arg_parsing.py,sha256=NLI7zRjLeMi5gQ7nCwj98xYRbksnKk9pf2U3ItCAM6U,313
+nlsql_coder/app/cli/interface.py,sha256=L9DW60tev4I2Ubz7op77-vigqMuEwUgK26QbCSAj0dU,3968
+nlsql_coder/app/cli/tool_calling.py,sha256=DhnKnTiGHesh1Wr8nVHPduCpjeSTSM6ZyATbNbepoTk,835
+nlsql_coder/app/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/providers/base.py,sha256=bYcoU5KLfZ0GYECwlmQfTFMXv6G8MinP1wV_71R82Wc,2056
+nlsql_coder/app/providers/config.py,sha256=y8VavW7eVhmaGxg2dVFBYBi_HR7dEOm9BapDaJBU8nE,515
+nlsql_coder/app/providers/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/app/providers/aws/provider.py,sha256=M0JigWjybTcVOjth44d_V2hk74bCm2xaafvOn4-gsBc,5712
+nlsql_coder/app/providers/gcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlsql_coder/data/create_agent_md.py,sha256=f-bP5DGAILP7jlf5dmvZHhjewZFl3TZxKlwHoNVxBL8,2550
+nlsql_coder-0.0.1.dist-info/licenses/LICENSE,sha256=GNO7NFi7navN9edNrPJWozm4pkhjOKsJqXuoZdMhSSg,1072
+nlsql_coder-0.0.1.dist-info/METADATA,sha256=0y-QUYp_VtYB1Qb6QECChZOUISHLJUSrNuUPeoa9GT4,2263
+nlsql_coder-0.0.1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+nlsql_coder-0.0.1.dist-info/entry_points.txt,sha256=BK04QmRGok7YDWL-dBySr-gghDPK-iQcJ3S7PoifNwM,72
+nlsql_coder-0.0.1.dist-info/top_level.txt,sha256=J16-Bz42sGpUXjB1uWqE66v4JPIiymCnGc7LhJkt_60,12
+nlsql_coder-0.0.1.dist-info/RECORD,,

nlsql_coder-0.0.1.dist-info/WHEEL

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

nlsql_coder-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nlsql-coder = nlsql_coder.app.cli.interface:main_loop

nlsql_coder-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Microsoft Corporation.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE

nlsql_coder-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+nlsql_coder