ziya 0.1.0__py3-none-any.whl

app/agents/agent.py

@@ -0,0 +1,114 @@
+import os
+from typing import Generator, List, Tuple, Set, Union
+
+import tiktoken
+from langchain.agents import AgentExecutor
+from langchain.agents.format_scratchpad import format_xml
+from langchain_aws import ChatBedrock
+from langchain_community.document_loaders import TextLoader
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.pydantic_v1 import BaseModel, Field
+
+from app.agents.prompts import conversational_prompt, parse_output
+from app.utils.directory_util import get_ignored_patterns, get_complete_file_list
+from app.utils.logging_utils import logger
+from app.utils.print_tree_util import print_file_tree
+
+
+def _format_chat_history(chat_history: List[Tuple[str, str]]) -> List[Union[HumanMessage, AIMessage]]:
+    buffer = []
+    for human, ai in chat_history:
+        buffer.append(HumanMessage(content=human))
+        buffer.append(AIMessage(content=ai))
+    return buffer
+
+aws_profile = os.environ.get("ZIYA_AWS_PROFILE")
+if aws_profile:
+    logger.info(f"Using AWS Profile: {aws_profile}")
+else:
+    logger.info("No AWS profile specified via --aws-profile flag, using default credentials")
+model_id = {
+    "sonnet": "anthropic.claude-3-sonnet-20240229-v1:0",
+    "haiku": "anthropic.claude-3-haiku-20240307-v1:0",
+    "opus": "anthropic.claude-3-opus-20240229-v1:0",
+}[os.environ.get("ZIYA_AWS_MODEL", "haiku")]
+logger.info(f"Using Claude Model: {model_id}")
+
+model = ChatBedrock(
+    model_id=model_id,
+    model_kwargs={"max_tokens": 4096},
+    credentials_profile_name=aws_profile if aws_profile else None,
+)
+
+
+def get_combined_document_contents() -> str:
+    user_codebase_dir: str = os.environ["ZIYA_USER_CODEBASE_DIR"]
+    print(f"Reading user's current codebase: {user_codebase_dir}")
+
+    combined_contents: str = ""
+    ignored_patterns: List[str] = get_ignored_patterns(user_codebase_dir)
+    all_files: List[str] = get_complete_file_list(user_codebase_dir, ignored_patterns)
+
+    print_file_tree(all_files)
+
+    seen_dirs: Set[str] = set()
+    for file_path in all_files:
+        try:
+            docs = TextLoader(file_path).load()
+            for doc in docs:
+                combined_contents += f"File: {file_path}\n{doc.page_content}\n\n"
+            dir_path = os.path.dirname(file_path)
+            if dir_path not in seen_dirs:
+                # print_file_tree(dir_path, ignored_patterns)
+                seen_dirs.add(dir_path)
+        except Exception as e:
+            print(f"Skipping file {file_path} due to error: {e}")
+
+    print("--------------------------------------------------------")
+    print(f"Ignoring following paths based on gitIgnore and other defaults: {ignored_patterns}")
+    print("--------------------------------------------------------")
+    print(f"Codebase word count: {len(combined_contents.split()):,}")
+    token_count = len(tiktoken.get_encoding("cl100k_base").encode(combined_contents))
+    print(f"Codebase token count: {token_count:,}")
+    print(f"Max Claude Token limit: 200,000")
+    print("--------------------------------------------------------")
+    return combined_contents
+
+
+def get_child_paths(directory: str) -> Generator[str, None, None]:
+    for entry in os.listdir(directory):
+        child_path = os.path.join(directory, entry)
+        yield child_path
+
+
+prompt = conversational_prompt.partial(
+    codebase=get_combined_document_contents,
+)
+llm_with_stop = model.bind(stop=["</tool_input>"])
+
+agent = (
+        {
+            "question": lambda x: x["question"],
+            "agent_scratchpad": lambda x: format_xml(x["intermediate_steps"]),
+            "chat_history": lambda x: _format_chat_history(x["chat_history"]),
+        }
+        | prompt
+        | llm_with_stop
+        | parse_output
+)
+
+
+class AgentInput(BaseModel):
+    question: str
+    chat_history: List[Tuple[str, str]] = Field(..., extra={"widget": {"type": "chat"}})
+
+
+agent_executor = AgentExecutor(
+    agent=agent, tools=[], verbose=True, handle_parsing_errors=True
+).with_types(input_type=AgentInput)
+
+agent_executor = agent_executor | (lambda x: x["output"])
+
+if __name__ == "__main__":
+    question = "How are you ?"
+    print(agent_executor.invoke({"question": question, "chat_history": []}))

app/agents/prompts.py

@@ -0,0 +1,47 @@
+from langchain_core.agents import AgentFinish
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+# import pydevd_pycharm
+
+template = """You are an excellent coder. Help the user with their coding tasks. You are given the entire codebase
+ of the user in your context. It is in the format like below where first line has the File path and then the content follows. 
+
+File: <filepath>
+<Content of the file>. 
+
+Now below is the current codebase of the user: 
+ 
+{codebase}
+"""
+
+conversational_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", template),
+        MessagesPlaceholder(variable_name="chat_history"),
+        ("user", "{question}"),
+        ("ai", "{agent_scratchpad}"),
+    ]
+)
+
+
+def parse_output(message):
+    text = message.content
+    # pydevd_pycharm.settrace('localhost', port=61565, stdoutToServer=True, stderrToServer=True)
+    # print('----TEXT START----')
+    # print(text)
+    # print('----TEXT END----')
+    # if "</tool>" in text:
+    #     tool, tool_input = text.split("</tool>")
+    #     _tool = tool.split("<tool>")[1]
+    #     _tool_input = tool_input.split("<tool_input>")[1]
+    #
+    #     if _tool == "write_file":
+    #         _tool_input = json.loads(_tool_input)
+    #         # newline_index = _tool_input.find('\n')
+    #         # file_path = _tool_input[:newline_index]
+    #         # text = _tool_input[newline_index + 1:]
+    #     if "</tool_input>" in _tool_input:
+    #         _tool_input = _tool_input.split("</tool_input>")[0]
+    #
+    #     return AgentAction(tool=_tool, tool_input=_tool_input, log=text)
+    # else:
+    return AgentFinish(return_values={"output": text}, log=text)

app/main.py

@@ -0,0 +1,33 @@
+import os
+from langchain_cli.cli import serve
+import argparse
+
+def main():
+    os.environ["ZIYA_USER_CODEBASE_DIR"] = os.getcwd()
+
+    parser = argparse.ArgumentParser(description="Run with custom options")
+    parser.add_argument("--exclude", default=[], type=lambda x: x.split(','),
+                        help="List of files or directories to exclude (e.g., --exclude 'tst,build,*.py')")
+    parser.add_argument("--profile", type=str, default=None,
+                        help="AWS profile to use (e.g., --profile ziya)")
+    parser.add_argument("--model", type=str, choices=["sonnet", "haiku", "opus"], default="haiku",
+                        help="AWS Bedrock Model to use  (e.g., --model sonnet)")
+    parser.add_argument("--port", type=int, default=6969,
+                        help="Port number to run Ziya frontend on (e.g., --port 8080)")
+    args = parser.parse_args()
+
+    additional_excluded_dirs = ','.join([item for item in args.exclude])
+    os.environ["ZIYA_ADDITIONAL_EXCLUDE_DIRS"] = additional_excluded_dirs
+
+    if args.profile:
+        os.environ["ZIYA_AWS_PROFILE"] = args.profile
+    if args.model:
+        os.environ["ZIYA_AWS_MODEL"] = args.model
+
+    langchain_serve_directory = os.path.dirname(os.path.abspath(__file__))
+    os.chdir(langchain_serve_directory)
+    serve(port=args.port)
+
+
+if __name__ == "__main__":
+    main()

app/server.py

@@ -0,0 +1,22 @@
+from fastapi import FastAPI, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from langserve import add_routes
+from app.agents.agent import agent_executor
+
+import uvicorn
+
+
+app = FastAPI()
+app.mount("/static", StaticFiles(directory="../static"), name="static")
+templates = Jinja2Templates(directory="../templates")
+
+# Add a route for the frontend
+add_routes(app, agent_executor, disabled_endpoints=["playground"], path="/ziya")
+
+@app.get("/")
+async def root(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/utils/directory_util.py

@@ -0,0 +1,57 @@
+import glob
+import os
+from typing import List, Set, Tuple
+
+from app.utils.gitignore_parser import parse_gitignore_patterns
+
+
+def get_ignored_patterns(directory: str) -> List[Tuple[str, str]]:
+    ignored_patterns: List[Tuple[str, str]] = [
+        ("poetry.lock", os.environ["ZIYA_USER_CODEBASE_DIR"]),
+        ("package-lock.json", os.environ["ZIYA_USER_CODEBASE_DIR"]),
+        (".DS_Store", os.environ["ZIYA_USER_CODEBASE_DIR"]),
+        (".git", os.environ["ZIYA_USER_CODEBASE_DIR"]),
+        *[(pattern, os.environ["ZIYA_USER_CODEBASE_DIR"])
+          for pattern in os.environ["ZIYA_ADDITIONAL_EXCLUDE_DIRS"].split(',')
+          if pattern]
+    ]
+
+    def read_gitignore(path: str) -> List[Tuple[str, str]]:
+        gitignore_patterns: List[Tuple[str, str]] = []
+        with open(path, "r") as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith("#"):
+                    gitignore_patterns.append((line, os.path.dirname(path)))
+        return gitignore_patterns
+
+    def get_patterns_recursive(path: str) -> List[Tuple[str, str]]:
+        patterns: List[Tuple[str, str]] = []
+        gitignore_path = os.path.join(path, ".gitignore")
+
+        if os.path.exists(gitignore_path):
+            patterns.extend(read_gitignore(gitignore_path))
+
+        for subdir in glob.glob(os.path.join(path, "*/")):
+            patterns.extend(get_patterns_recursive(subdir))
+
+        return patterns
+
+    ignored_patterns.extend(get_patterns_recursive(directory))
+    return ignored_patterns
+
+
+def get_complete_file_list(user_codebase_dir: str, ignored_patterns: List[str]) -> List[str]:
+    should_ignore = parse_gitignore_patterns(ignored_patterns, base_dir=user_codebase_dir)
+    file_set: Set[str] = set()
+
+    for root, dirs, files in os.walk(user_codebase_dir):
+        # Filter out ignored directories
+        dirs[:] = [d for d in dirs if not should_ignore(os.path.join(root, d))]
+
+        for file in files:
+            file_path = os.path.join(root, file)
+            if not should_ignore(file_path):
+                file_set.add(file_path)
+
+    return list(file_set)

app/utils/gitignore_parser.py

@@ -0,0 +1,217 @@
+import collections
+import os
+import re
+
+from os.path import abspath, dirname
+from pathlib import Path
+from typing import Reversible, Union, List, Tuple
+
+
+def handle_negation(file_path, rules: Reversible["IgnoreRule"]):
+    for rule in reversed(rules):
+        if rule.match(file_path):
+            return not rule.negation
+    return False
+
+
+def parse_gitignore_patterns(patterns: List[Tuple[str, str]], base_dir=None):
+    if base_dir is None:
+        base_dir = os.getcwd()
+    rules = []
+    for counter, (pattern, directory) in enumerate(patterns, start=1):
+        rule = rule_from_pattern(pattern, base_path=_normalize_path(directory),
+                                 source=('in-memory', counter))
+        if rule:
+            rules.append(rule)
+    if not any(r.negation for r in rules):
+        return lambda file_path: any(r.match(file_path) for r in rules)
+    else:
+        # We have negation rules. We can't use a simple "any" to evaluate them.
+        # Later rules override earlier rules.
+        return lambda file_path: handle_negation(file_path, rules)
+
+def rule_from_pattern(pattern, base_path=None, source=None):
+    """
+    Take a .gitignore match pattern, such as "*.py[cod]" or "**/*.bak",
+    and return an IgnoreRule suitable for matching against files and
+    directories. Patterns which do not match files, such as comments
+    and blank lines, will return None.
+    Because git allows for nested .gitignore files, a base_path value
+    is required for correct behavior. The base path should be absolute.
+    """
+    # Store the exact pattern for our repr and string functions
+    orig_pattern = pattern
+    # Early returns follow
+    # Discard comments and separators
+    if pattern.strip() == '' or pattern[0] == '#':
+        return
+    # Strip leading bang before examining double asterisks
+    if pattern[0] == '!':
+        negation = True
+        pattern = pattern[1:]
+    else:
+        negation = False
+    # Multi-asterisks not surrounded by slashes (or at the start/end) should
+    # be treated like single-asterisks.
+    pattern = re.sub(r'([^/])\*{2,}', r'\1*', pattern)
+    pattern = re.sub(r'\*{2,}([^/])', r'*\1', pattern)
+
+    # Special-casing '/', which doesn't match any files or directories
+    if pattern.rstrip() == '/':
+        return
+
+    directory_only = pattern[-1] == '/'
+    # A slash is a sign that we're tied to the base_path of our rule
+    # set.
+    anchored = '/' in pattern[:-1]
+    if pattern[0] == '/':
+        pattern = pattern[1:]
+    if pattern[0] == '*' and len(pattern) >= 2 and pattern[1] == '*':
+        pattern = pattern[2:]
+        anchored = False
+    if pattern[0] == '/':
+        pattern = pattern[1:]
+    if pattern[-1] == '/':
+        pattern = pattern[:-1]
+    # patterns with leading hashes or exclamation marks are escaped with a
+    # backslash in front, unescape it
+    if pattern[0] == '\\' and pattern[1] in ('#', '!'):
+        pattern = pattern[1:]
+    # trailing spaces are ignored unless they are escaped with a backslash
+    i = len(pattern)-1
+    striptrailingspaces = True
+    while i > 1 and pattern[i] == ' ':
+        if pattern[i-1] == '\\':
+            pattern = pattern[:i-1] + pattern[i:]
+            i = i - 1
+            striptrailingspaces = False
+        else:
+            if striptrailingspaces:
+                pattern = pattern[:i]
+        i = i - 1
+    regex = fnmatch_pathname_to_regex(
+        pattern, directory_only, negation, anchored=bool(anchored)
+    )
+    return IgnoreRule(
+        pattern=orig_pattern,
+        regex=regex,
+        negation=negation,
+        directory_only=directory_only,
+        anchored=anchored,
+        base_path=_normalize_path(base_path) if base_path else None,
+        source=source
+    )
+
+
+IGNORE_RULE_FIELDS = [
+    'pattern', 'regex',  # Basic values
+    'negation', 'directory_only', 'anchored',  # Behavior flags
+    'base_path',  # Meaningful for gitignore-style behavior
+    'source'  # (file, line) tuple for reporting
+]
+
+
+class IgnoreRule(collections.namedtuple('IgnoreRule_', IGNORE_RULE_FIELDS)):
+    def __str__(self):
+        return self.pattern
+
+    def __repr__(self):
+        return ''.join(['IgnoreRule(\'', self.pattern, '\')'])
+
+    def match(self, abs_path: Union[str, Path]):
+        matched = False
+        if self.base_path:
+            if str(abs_path).startswith(str(self.base_path)):
+                rel_path = str(_normalize_path(abs_path).relative_to(self.base_path))
+            else:
+                rel_path = str(_normalize_path(abs_path))
+        else:
+            rel_path = str(_normalize_path(abs_path))
+        # Path() strips the trailing slash, so we need to preserve it
+        # in case of directory-only negation
+        if self.negation and type(abs_path) == str and abs_path[-1] == '/':
+            rel_path += '/'
+        if rel_path.startswith('./'):
+            rel_path = rel_path[2:]
+        if re.search(self.regex, rel_path):
+            matched = True
+        return matched
+
+# Frustratingly, python's fnmatch doesn't provide the FNM_PATHNAME
+# option that .gitignore's behavior depends on.
+def fnmatch_pathname_to_regex(
+    pattern, directory_only: bool, negation: bool, anchored: bool = False
+):
+    """
+    Implements fnmatch style-behavior, as though with FNM_PATHNAME flagged;
+    the path separator will not match shell-style '*' and '.' wildcards.
+    """
+    i, n = 0, len(pattern)
+
+    seps = [re.escape(os.sep)]
+    if os.altsep is not None:
+        seps.append(re.escape(os.altsep))
+    seps_group = '[' + '|'.join(seps) + ']'
+    nonsep = r'[^{}]'.format('|'.join(seps))
+
+    res = []
+    while i < n:
+        c = pattern[i]
+        i += 1
+        if c == '*':
+            try:
+                if pattern[i] == '*':
+                    i += 1
+                    res.append('.*')
+                else:
+                    res.append(''.join([nonsep, '*']))
+            except IndexError:
+                res.append(''.join([nonsep, '*']))
+        elif c == '?':
+            res.append(nonsep)
+        elif c == '/':
+            res.append(seps_group)
+        elif c == '[':
+            j = i
+            if j < n and pattern[j] == '!':
+                j += 1
+            if j < n and pattern[j] == ']':
+                j += 1
+            while j < n and pattern[j] != ']':
+                j += 1
+            if j >= n:
+                res.append('\\[')
+            else:
+                stuff = pattern[i:j].replace('\\', '\\\\').replace('/', '')
+                i = j + 1
+                if stuff[0] == '!':
+                    stuff = ''.join(['^', stuff[1:]])
+                elif stuff[0] == '^':
+                    stuff = ''.join('\\' + stuff)
+                res.append('[{}]'.format(stuff))
+        else:
+            res.append(re.escape(c))
+    if anchored:
+        res.insert(0, '^')
+    else:
+        # Handle leading slash patterns
+        if pattern.startswith('/'):
+            res.insert(0, '^')
+        else:
+            res.insert(0, f"(^|{seps_group})")
+    if not directory_only:
+        res.append('$')
+    elif directory_only and negation:
+        res.append('/$')
+    else:
+        res.append('($|\\/)')
+    return ''.join(res)
+
+def _normalize_path(path: Union[str, Path]) -> Path:
+    """Normalize a path without resolving symlinks.
+
+    This is equivalent to `Path.resolve()` except that it does not resolve symlinks.
+    Note that this simplifies paths by removing double slashes, `..`, `.` etc. like
+    `Path.resolve()` does.
+    """
+    return Path(abspath(path))

app/utils/logging_utils.py

@@ -0,0 +1,10 @@
+import logging
+
+# Create and configure the logger
+formatter = logging.Formatter("\033[35mZIYA\033[0m:     %(message)s")
+handler = logging.StreamHandler()
+handler.setFormatter(formatter)
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.INFO)
+logger.addHandler(handler)

app/utils/print_tree_util.py

@@ -0,0 +1,43 @@
+import os
+
+def print_file_tree(file_paths):
+    # Create a dictionary to store files and directories
+    file_tree = {}
+
+    # Populate the file tree dictionary
+    for path in file_paths:
+        dir_path, file_name = os.path.split(path)
+        if dir_path not in file_tree:
+            file_tree[dir_path] = []
+        file_tree[dir_path].append(file_name)
+
+    # Sort directories and files
+    sorted_dirs = sorted(file_tree.keys())
+    for dir_path in sorted_dirs:
+        file_tree[dir_path].sort()
+
+    # Print the file tree recursively
+    def print_dir(dir_path, indent):
+        nonlocal printed_dirs
+        if dir_path in printed_dirs:
+            return
+
+        printed_dirs.add(dir_path)
+        print(f"{indent}{os.path.basename(dir_path)}")
+        if file_tree[dir_path]:
+            for i, file_name in enumerate(file_tree[dir_path]):
+                if i == len(file_tree[dir_path]) - 1:
+                    print(f"{indent}    └── {file_name}")
+                else:
+                    print(f"{indent}    ├── {file_name}")
+        else:
+            print(f"{indent}    (empty)")
+
+        # Recursively print subdirectories
+        subdirs = [subdir for subdir in sorted_dirs if subdir.startswith(dir_path + os.sep)]
+        for subdir in subdirs:
+            print_dir(subdir, indent + "    ")
+
+    printed_dirs = set()
+    for dir_path in sorted_dirs:
+        print_dir(dir_path, "")

pyproject.toml

@@ -0,0 +1,33 @@
+[tool.poetry]
+name = "ziya"
+version = "0.1.0"
+description = ""
+authors = ["Vishnu Krishnaprasad <vishnukool@gmail.com>"]
+readme = "README.md"
+include = ["static/**/*", "templates/**/*", "pyproject.toml"]
+packages = [
+    { include = "app" },
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9,<4.0"
+uvicorn = "^0.23.2"
+pydantic = "<2"
+jinja2 = "^3.1.3"
+tiktoken = "^0.6.0"
+boto3 = "^1.34.88"
+langchain-aws = "^0.1.0"
+langchain = "^0.1"
+langchainhub = ">=0.1.15"
+langchain-anthropic = "^0.1.4"
+langchain-cli = ">=0.0.15"
+
+[tool.poetry.group.dev.dependencies]
+pydevd-pycharm = "^241.15989.57"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.poetry.scripts]
+ziya = 'app.main:main'

static/app.js

@@ -0,0 +1,104 @@
+const {useState, useRef, useEffect} = React;
+
+const App = () => {
+    const [messages, setMessages] = useState([]);
+    const [question, setQuestion] = useState('');
+    const [streamedContent, setStreamedContent] = useState('');
+    const [isStreaming, setIsStreaming] = useState(false);
+    const inputTextareaRef = useRef(null);
+
+    useEffect(() => {
+        if (inputTextareaRef.current) {
+            inputTextareaRef.current.focus();
+        }
+    }, []);
+
+    const handleSendPayload = async () => {
+        setQuestion('');
+        setIsStreaming(true);
+        setMessages((messages) => [...messages, {content: question, role: 'human'}]);
+        setStreamedContent('');
+        await window.sendPayload(messages, question, setStreamedContent, setIsStreaming);
+        setStreamedContent((cont) => {
+            setMessages((messages) => [...messages, {content: cont, role: 'assistant'}]);
+            return ""
+        });
+        inputTextareaRef.current.focus();
+    };
+
+    const handleChange = (event) => {
+        setQuestion(event.target.value);
+    };
+
+    return (
+        <div><h2 style={{textAlign: "center"}}>Ziya: Code Assist</h2>
+            <div className="container">
+                <InputContainer
+                    inputTextareaRef={inputTextareaRef}
+                    question={question}
+                    handleChange={handleChange}
+                    sendPayload={handleSendPayload}
+                    isStreaming={isStreaming}
+                />
+                {streamedContent || messages.length > 0 ? <div className="chat-container">
+                    {streamedContent && <StreamedContent streamedContent={streamedContent}/>}
+                    {messages.length > 0 && <ChatContainer messages={messages}/>}
+                </div> : null}
+            </div>
+        </div>
+    );
+};
+
+const ChatContainer = ({messages}) => (
+    <div>
+        {messages.slice().reverse().map((msg, index) => (
+            <div key={index} className={`message ${msg.role}`}>
+                {msg.role === 'human' ? <div className="message-sender">You:</div> :
+                    <div className="message-sender">AI:</div>}
+                <MarkdownRenderer markdown={msg.content}/>
+            </div>
+        ))}
+    </div>
+);
+
+const isQuestionEmpty = (input) => input.trim().length === 0;
+
+const StreamedContent = ({streamedContent}) => (
+    <div className="message assistant">
+        <div className="message-sender">AI:</div>
+        <MarkdownRenderer markdown={streamedContent}/>
+    </div>
+);
+const InputContainer = ({question, handleChange, sendPayload, isStreaming, inputTextareaRef}) => (
+
+    <div className="input-container">
+    <textarea
+        ref={inputTextareaRef}
+        value={question}
+        onChange={handleChange}
+        placeholder="Enter your question.."
+        rows={3}
+        className="input-textarea"
+        onKeyDown={(event) => {
+            if (event.key === 'Enter' && !event.shiftKey && !isQuestionEmpty(question)) {
+                event.preventDefault(); // Prevent the default behavior of adding a new line
+                sendPayload();
+            }
+        }}
+    />
+        <button onClick={sendPayload} disabled={isStreaming || isQuestionEmpty(question)} className="send-button">
+            {isStreaming ? `Sending..` : `Send`}
+        </button>
+    </div>
+);
+
+const MarkdownRenderer = ({markdown}) => {
+    const renderMarkdown = () => {
+        const html = marked.parse(markdown);
+        return {__html: html};
+    };
+
+    return <div dangerouslySetInnerHTML={renderMarkdown()}/>;
+};
+
+ReactDOM.render(<App/>, document.getElementById('root'));

static/sendPayload.js

@@ -0,0 +1,62 @@
+async function getApiResponse(messages, question) {
+    const messageTuples = [];
+    let tempArray = [];
+    for (let i = 0; i < messages.length; i++) {
+        tempArray.push(messages[i].content);
+        if (tempArray.length === 2) {
+            messageTuples.push(tempArray);
+            tempArray = [];
+        }
+    }
+    const response = await fetch('/ziya/stream_log', {
+        method: 'POST', headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({
+            input: {
+                chat_history: messageTuples,
+                question: question,
+            },
+            config: {},
+        }),
+    });
+    return response;
+}
+
+const processLine = (line, setStreamedContent) => {
+    const data = JSON.parse(line.slice(6));
+    const streamedOutputOp = data.ops.find(
+        (op) => op.op === 'add' && op.path === '/logs/ChatBedrock/streamed_output_str/-'
+    );
+
+    if (streamedOutputOp) {
+        setStreamedContent((prevContent) => prevContent + streamedOutputOp.value);
+    }
+};
+
+window.sendPayload = async (messages, question, setStreamedContent, setIsStreaming) => {
+    try {
+        const response = await getApiResponse(messages, question);
+        const reader = response.body.getReader();
+
+        const processData = async ({done, value}) => {
+            if (done) {
+                setIsStreaming(false);
+                return;
+            }
+            let buffer = '';
+            buffer += new TextDecoder('utf-8').decode(value);
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    processLine(line, setStreamedContent);
+                }
+            }
+            await reader.read().then(processData);
+        };
+        await reader.read().then(processData);
+    } catch (error) {
+        console.error(error);
+        setIsStreaming(false);
+    }
+};

static/ziya.css

@@ -0,0 +1,88 @@
+/* General Styles */
+body {
+  font-family: Arial, sans-serif;
+  margin: 0;
+  padding: 0;
+  background-color: #f5f5f5;
+}
+
+.container {
+  max-width: 800px;
+  margin: 0 auto;
+  padding: 20px;
+  background-color: #fff;
+  border-radius: 8px;
+  box-shadow: 0 2px 6px rgba(0, 0, 0, 0.1);
+}
+
+/* Chat Container */
+.chat-container {
+  height: fit-content;
+  overflow-y: scroll;
+  padding: 10px;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  margin: 20px 0;
+}
+
+.message {
+  padding: 10px;
+  border-radius: 8px;
+}
+
+.message.human {
+  background-color: #efefef;
+  align-self: flex-start;
+  margin-right: auto;
+}
+
+.message.ai {
+  background-color: #f0f0f0;
+  align-self: flex-end;
+  margin-left: auto;
+}
+
+.message-sender {
+  font-weight: bold;
+  margin-bottom: 5px;
+}
+
+/* Input Container */
+.input-container {
+  display: flex;
+  align-items: center;
+}
+
+.input-textarea {
+  flex-grow: 1;
+  padding: 10px;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  resize: none;
+  font-size: 16px;
+}
+
+.send-button {
+  margin-left: 10px;
+  padding: 10px 20px;
+  background-color: #007bff;
+  color: #fff;
+  border: none;
+  border-radius: 4px;
+  cursor: pointer;
+  font-size: 16px;
+}
+
+.send-button:disabled {
+  background-color: #ccc;
+  cursor: not-allowed;
+}
+
+/* Streamed Content */
+.streamed-content {
+  margin-top: 20px;
+  padding: 10px;
+  border: 1px solid #ccc;
+  border-radius: 4px;
+  background-color: #f0f0f0;
+}

templates/index.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Ziya - Code Assistant</title>
+    <link rel="stylesheet" href="/static/ziya.css">
+    <link rel="icon" href="/static/favicon.ico" type="image/x-icon">
+</head>
+<body>
+<div id="root"/>
+<script src="https://cdn.jsdelivr.net/npm/@babel/standalone@7/babel.min.js"></script>
+<script src="https://unpkg.com/react@17/umd/react.production.min.js"></script>
+<script src="https://unpkg.com/react-dom@17/umd/react-dom.production.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+<script type="text/babel" src="/static/sendPayload.js"></script>
+<script type="text/babel" src="/static/app.js"></script>
+</body>
+</html>

ziya-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 LangChain, Inc.
+
+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.

ziya-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.1
+Name: ziya
+Version: 0.1.0
+Summary: 
+Author: Vishnu Krishnaprasad
+Author-email: vishnukool@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: boto3 (>=1.34.88,<2.0.0)
+Requires-Dist: jinja2 (>=3.1.3,<4.0.0)
+Requires-Dist: langchain (>=0.1,<0.2)
+Requires-Dist: langchain-anthropic (>=0.1.4,<0.2.0)
+Requires-Dist: langchain-aws (>=0.1.0,<0.2.0)
+Requires-Dist: langchain-cli (>=0.0.15)
+Requires-Dist: langchainhub (>=0.1.15)
+Requires-Dist: pydantic (<2)
+Requires-Dist: tiktoken (>=0.6.0,<0.7.0)
+Requires-Dist: uvicorn (>=0.23.2,<0.24.0)
+Description-Content-Type: text/markdown
+
+# Ziya
+
+Ziya is a code assist tool for AWS Bedrock models. It can read your entire codebase and answer questions.
+
+The current version only performs read operations. However, future versions will be able to:
+
+1. Write and edit code.
+2. Search the web for resources.
+3. Run commands locally.
+4. Iteratively continue to do 1,2,3 for a given objective. 
+
+## Pre-requisites
+### Setup AWS credentials:
+The easiest way is to set the env variables with access to AWS Bedrock claude models.
+
+```bash
+export AWS_ACCESS_KEY_ID=<YOUR-KEY>
+export AWS_SECRET_ACCESS_KEY=<YOUR-SECRET>
+```
+### Installation
+
+```bash
+pip install ziya
+```
+
+## Run Ziya
+
+```bash 
+ziya
+```
+Then navigate to http://localhost:6969 in your browser and start chatting with your codebase. 
+
+When you ask a question Ziya sends your entire codebase as context to the LLM, along with your question and any chat history.
+```
+> Entering new AgentExecutor chain...
+Reading user's current codebase: /Users/vkrishnaprasad/personal_projects/ziya
+ziya
+    ├── .gitignore
+    ├── DEVELOPMENT.md
+    ├── LICENSE
+    ├── README.md
+    └── pyproject.toml
+    app
+        ├── __init__.py
+        ├── main.py
+        └── server.py
+...
+```
+
+### Options
+
+`--exclude`: Comma-separated list of files or directories to exclude from the codebase.
+
+`--profile`: AWS profile to use for the Bedrock LLM.
+
+`--model`: The AWS Bedrock Model to use, one of `haiku`(default), `sonnet` or `opus`.
+
+`--port`: The port number for frontend app. Default is `6969`.
+
+```bash
+ziya --exclude='tst,build,*.py' --profile=ziya --model=sonnet --port=8080
+```

ziya-0.1.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/agents/agent.py,sha256=k0e0GMKFfU6-3e-GyAX95R9iV3sWwvLknL1gxd3TO88,4181
+app/agents/prompts.py,sha256=O54rH2KupyY7ZSjPEvm3j9DSGjdL3jJOz8F9PTcePQQ,1674
+app/main.py,sha256=blgAdLjoMa2HRqlr17lwbZ3hQYz2jUZJwu18KLI9FiQ,1359
+app/server.py,sha256=YTEHYUsFQhgkGRHZ_y7K3Ju3SmUIbVxLSdgrgi1BuEU,676
+app/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+app/utils/directory_util.py,sha256=XOImpzqVa2NrIAPl054VN2WC4kk1QUIE4COEL062ULw,2132
+app/utils/gitignore_parser.py,sha256=ksAAvXr8_GFh94cvOdkLmES5k3xxNxW2_tQuQtialIA,7496
+app/utils/logging_utils.py,sha256=8JEcc1t7L-a0G4HLmM8zFydNNSOd5l2-gkTxviLQUns,280
+app/utils/print_tree_util.py,sha256=O4Rb-GS8UODxfH7Z6bZGsr-opG6QLmvdaU1im5kh4IA,1419
+pyproject.toml,sha256=p35kypx9MscMQR1a_MWhgKOr764YZJOlNa9FW7s0Wrw,716
+static/app.js,sha256=qz2F0e5LxuVFI3MXWvcON9l1cN0J_ODdQOwbgT3ZqWA,3622
+static/favicon.ico,sha256=HgB8xAZdDHFK2lODUsp2H_Dds_i14pnpydx7NEJrNrU,15086
+static/sendPayload.js,sha256=VnypSWF7t8bv83026LGU3GMyr9tMrp05hmWATcbCG4k,1956
+static/ziya.css,sha256=OaieSXw_7LOk0WNNi-1mPsAaS3rOxhHycKFgFDoiZB0,1395
+templates/index.html,sha256=8auy9lGLdcDzBkzpjYB1ygrAVbXpo0rqQ8p1FgMEeck,800
+ziya-0.1.0.dist-info/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
+ziya-0.1.0.dist-info/METADATA,sha256=V8cWv_zwPjFzBheptnTXc7wimA2x3Pdz8iu4ApLJNgk,2472
+ziya-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+ziya-0.1.0.dist-info/entry_points.txt,sha256=1HspxMqCYRli3SqM6CqmT6gsW_G14G4ab3sHlrYUCAA,38
+ziya-0.1.0.dist-info/RECORD,,

ziya-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any

ziya-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+ziya=app.main:main
+