Merge pull request #76 from Grigorij-Dudnik/dev

Dev

Author: Grigorij-Dudnik

.github/readme.md

@@ -1,11 +1,11 @@
 <div align="center">
   <img src="/non_src/assets/starting_video.gif" alt="Demo">
   <br>
-  <img src="/non_src/assets/logo_wide_2.png" alt="Logo">
+  <img src="/non_src/assets/logo_wide_3.jpg" alt="Logo">
   <br> 
   <h2>Probably the most intelligent AI coder out there.</h2>
   <br>
-  Clean Coder is your 2-in-1 AI Scrum Master and Developer. Delegate planning, managing, and coding to AI. Agents create tasks within Todoist, write code, and test it, helping you create great projects with minimal effort!
+  Clean Coder is your 2-in-1 AI Scrum Master and Developer. Equipped with most intelligent reasoning system and most andvanced codebase research tool, it makes your code written with absolute minimum time investment on your part!
   <br>
   <br>
     <h3>⭐️ Your star motivates us to introduce new cool features! ⭐️</h3>  
@@ -50,6 +50,12 @@ Create an entire web app ~~with~~ by Clean Coder:
 
 ## 📊 Why Clean Coder?
 
+Our dream is to create a fully autonomous programmer one day, letting you relax (or at least do another job 😜) while your coding job will be done by AI.
+
+That's why we care about making Clean Coder have top intelligence level and be equipped with most modern automation tools.
+
+Learn more about Clean Coder's idea [here](https://clean-coder.dev/faq/why_clean_coder/).
+
 | Feature | Clean Coder | Cline | Aider | Cursor |
 |---------|-------------|--------|-------|---------|
 | **Intelligence** | ✅ Two-step Planer agent for thinking only  | 🟡 One-step plan mode | 🟡 One-step Architect agent | ❌ No thinking agent |
@@ -61,7 +67,7 @@ Create an entire web app ~~with~~ by Clean Coder:
 
 ## ✨ Key advantages:
 
-- Get project supervised by [Manager agent](https://clean-coder.dev/usage/manager/) with thoroughly-described tasks organized in Todoist, just like with a human scrum master.
+- Get project supervised by [Manager agent](https://clean-coder.dev/usage/manager/) with tasks organized in Todoist, just like with a human scrum master.
 - Two-step planning module makes Clean Coder probably most intelligent [AI coder](https://clean-coder.dev/usage/programmer_pipeline/) available.
 - [Semantic search (RAG)](https://clean-coder.dev/advanced_features_installation/similarity_search_for_researcher/) for effective navigating even large codebases.
 - Allow AI to see frontend it creates with [frontend feedback feature](https://clean-coder.dev/features/frontend_feedback/). At the day of writing no other AI coder has that feature.

manager.py

@@ -13,12 +13,13 @@
     add_todoist_envs()
 
 from typing import TypedDict, Sequence
-from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
 from langchain_core.load import dumps
 from langgraph.graph import StateGraph
 from src.tools.tools_project_manager import add_task, modify_task, finish_project_planning, reorder_tasks
-from src.tools.tools_coder_pipeline import prepare_list_dir_tool, prepare_see_file_tool, ask_human_tool
+from src.tools.tools_coder_pipeline import prepare_list_dir_tool, prepare_see_file_tool, ask_human_tool, retrieve_files_by_semantic_query
 from src.tools.rag.index_file_descriptions import prompt_index_project_files
+from src.utilities.util_functions import save_state_history_to_disk, join_paths
 from src.utilities.manager_utils import (
     actualize_tasks_list_and_progress_description,
     setup_todoist_project_if_needed,
@@ -29,14 +30,14 @@
     call_tool,
     multiple_tools_msg,
     no_tools_msg,
-    empty_message_msg,
 )
 from src.utilities.start_project_functions import set_up_dot_clean_coder_dir
-from src.utilities.util_functions import join_paths
 from src.utilities.llms import init_llms_medium_intelligence
 from src.utilities.print_formatters import print_formatted
+from src.tools.rag.retrieval import vdb_available
 import json
 import os
+import uuid
 
 
 class AgentState(TypedDict):
@@ -58,21 +59,34 @@ def __init__(self):
         self.saved_messages_path = join_paths(self.work_dir, ".clean_coder/manager_messages.json")
 
     def call_model_manager(self, state):
-        self.save_messages_to_disk(state)
+        save_state_history_to_disk(state, self.saved_messages_path)
         state = call_model(state, self.llms)
         state = self.cut_off_context(state)
-        state = call_tool(state, self.tools)
-        messages = [msg for msg in state["messages"] if msg.type == "ai"]
-        last_ai_message = messages[-1]
+
+        ai_messages = [msg for msg in state["messages"] if msg.type == "ai"]
+        last_ai_message = ai_messages[-1]
+        # in case model will return empty message (that strange thing happens for 3.5 and 3.7 sonnet after task execution),
+        # we will replace it with tool call message to go with next task
         if not last_ai_message.content and not last_ai_message.tool_calls:
             state["messages"].pop()
-            state["messages"].append(HumanMessage(content=empty_message_msg))
-        elif len(last_ai_message.tool_calls) == 0:
+            state["messages"].append(AIMessage(
+                content="Proceeding with next task.",
+                tool_calls=[
+                    {
+                        "name": "finish_project_planning",
+                        "args": {"dummy": "ok"},
+                        "id": str(uuid.uuid4()),
+                        "type": "tool_call",
+                    }
+                ]
+            ))
+        state = call_tool(state, self.tools)
+        if len(last_ai_message.tool_calls) == 0:
             state["messages"].append(HumanMessage(content=no_tools_msg))
-
         state = actualize_tasks_list_and_progress_description(state)
         return state
 
+
     # Logic for conditional edges
     def after_agent_condition(self, state):
         last_message = state["messages"][-1]
@@ -116,11 +130,13 @@ def prepare_tools(self):
             add_task,
             modify_task,
             reorder_tasks,
-            list_dir,
-            see_file,
             ask_human_tool,
             finish_project_planning,
+            list_dir,
+            see_file,
         ]
+        if vdb_available():
+            tools.append(retrieve_files_by_semantic_query)
         return tools
 
     # workflow definition
@@ -133,7 +149,7 @@ def setup_workflow(self):
 
     def run(self):
         print_formatted("😀 Hello! I'm Manager agent. Let's plan your project together!", color="green")
-
+        
         messages = get_manager_messages(self.saved_messages_path)
         inputs = {"messages": messages}
         self.manager.invoke(inputs, {"recursion_limit": 1000})

non_src/assets/logo_wide_3.jpg

@@ -0,0 +1,39 @@
+"""
+This file contains a manual test scenario for the Manager agent.
+It uses a dummy finish_project_planning tool to simulate task completion without running the actual coding pipeline.
+"""
+
+from src.tools.tools_project_manager import add_task, modify_task, reorder_tasks
+from src.tools.tools_coder_pipeline import prepare_list_dir_tool, prepare_see_file_tool, ask_human_tool
+from manager import Manager
+from langchain.tools import tool
+from typing_extensions import Annotated
+from src.utilities.print_formatters import print_formatted
+
+@tool
+def dummy_finish_project_planning(dummy: Annotated[str, "Type 'ok' to proceed."]):
+    """Dummy version of finish_project_planning that simulates task completion without running the actual pipeline."""
+    print_formatted("🔄 Simulating task completion...", color="yellow")
+    return "Task completed successfully"
+
+class TestManager(Manager):
+    def prepare_tools(self):
+        """Override prepare_tools to use dummy finish_project_planning"""
+        list_dir = prepare_list_dir_tool(self.work_dir)
+        see_file = prepare_see_file_tool(self.work_dir)
+        tools = [
+            add_task,
+            modify_task,
+            reorder_tasks,
+            ask_human_tool,
+            dummy_finish_project_planning,
+            list_dir,
+            see_file,
+        ]
+        return tools
+
+if __name__ == "__main__":
+    print_formatted("🧪 Starting Manager Test Scenario 1", color="green")
+    test_manager = TestManager()
+    test_manager.run()
+    print_formatted("✅ Test scenario completed", color="green")

non_src/tests/manual_tests/manager_scenario_1.py

@@ -19,24 +19,18 @@
 from src.utilities.start_project_functions import set_up_dot_clean_coder_dir
 from src.utilities.util_functions import create_frontend_feedback_story
 from src.tools.rag.rag_utils import update_descriptions
-from src.tools.rag.index_file_descriptions import prompt_index_project_files, upsert_file_list, write_file_descriptions, write_file_chunks_descriptions
-from src.tools.rag.retrieval import vdb_available
+from src.tools.rag.index_file_descriptions import prompt_index_project_files
 from src.linters.static_analisys import python_static_analysis
 
 
 use_frontend_feedback = bool(os.getenv("FRONTEND_URL"))
 
 
-
-def run_clean_coder_pipeline(task: str, work_dir: str, doc_harvest: bool = False):
-    researcher = Researcher(work_dir)
+def run_clean_coder_pipeline(task: str, work_dir: str, task_id: str=None):
+    researcher = Researcher(task_id=task_id)
     files, image_paths = researcher.research_task(task)
-    documentation = None
-    if doc_harvest:
-        harvester = Doc_harvester()
-        documentation = harvester.find_documentation(task, work_dir)
 
-    plan = planning(task, files, image_paths, work_dir, documentation=documentation)
+    plan = planning(task, files, image_paths, work_dir)
 
     executor = Executor(files, work_dir)
 
@@ -72,7 +66,7 @@ def run_clean_coder_pipeline(task: str, work_dir: str, doc_harvest: bool = False
 if __name__ == "__main__":
     work_dir = os.getenv("WORK_DIR")
     if not work_dir:
-        raise Exception("WORK_DIR variable not provided. Please add WORK_DIR to .env file")
+        raise Exception("WORK_DIR variable is not provided. Please add WORK_DIR to .env file")
     set_up_dot_clean_coder_dir(work_dir)
     prompt_index_project_files()
     task = user_input("Provide task to be executed. ")

single_task_coder.py

@@ -2,7 +2,7 @@
 from src.utilities.objects import CodeFile
 from typing_extensions import Annotated
 from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
-from langgraph.graph import StateGraph
+from langgraph.graph import StateGraph, END
 from dotenv import load_dotenv, find_dotenv
 from langchain_core.tools import tool
 from src.tools.tools_coder_pipeline import (
@@ -11,7 +11,14 @@
     retrieve_files_by_semantic_query,
 )
 from src.tools.rag.retrieval import vdb_available
-from src.utilities.util_functions import list_directory_tree, read_coderrules, load_prompt
+from src.utilities.util_functions import (
+    list_directory_tree,
+    read_coderrules,
+    load_prompt,
+    save_state_history_to_disk,
+    load_state_history_from_disk,
+    join_paths,
+)
 from src.utilities.langgraph_common_functions import (
     call_model,
     call_tool,
@@ -21,6 +28,7 @@
 )
 from src.utilities.print_formatters import print_formatted
 from src.utilities.llms import init_llms_medium_intelligence
+
 import os
 
 
@@ -52,27 +60,22 @@ class AgentState(TypedDict):
     messages: Sequence[BaseMessage]
 
 
-# Logic for conditional edges
-def after_agent_condition(state):
-    messages = [msg for msg in state["messages"] if msg.type in ["ai", "human"]]
-    last_message = messages[-1]
-
-    if last_message.content == no_tools_msg:
-        return "agent"
-    elif last_message.tool_calls[0]["name"] == "final_response_researcher":
-        return "human"
-    else:
-        return "agent"
-
-
 class Researcher:
-    def __init__(self, work_dir):
+    def __init__(self, silent=False, task_id=None):
+        self.task_id = task_id
+        self.silent = silent
         see_file = prepare_see_file_tool(work_dir)
         list_dir = prepare_list_dir_tool(work_dir)
         self.tools = [see_file, list_dir, final_response_researcher]
         if vdb_available():
             self.tools.append(retrieve_files_by_semantic_query)
         self.llms = init_llms_medium_intelligence(self.tools, "Researcher")
+        # Try to load previous research session for this task (if any)
+        self.prev_messages: List[BaseMessage] = []
+        if task_id:
+            history_file = join_paths(work_dir, ".clean_coder", f"research_history_task_{task_id}.json")
+            if os.path.exists(history_file):
+                self.prev_messages = load_state_history_from_disk(history_file)
 
         # workflow definition
         researcher_workflow = StateGraph(AgentState)
@@ -82,14 +85,14 @@ def __init__(self, work_dir):
 
         researcher_workflow.set_entry_point("agent")
 
-        researcher_workflow.add_conditional_edges("agent", after_agent_condition)
+        researcher_workflow.add_conditional_edges("agent", self.after_agent_condition)
         researcher_workflow.add_conditional_edges("human", after_ask_human_condition)
 
         self.researcher = researcher_workflow.compile()
 
     # node functions
     def call_model_researcher(self, state):
-        state = call_model(state, self.llms)
+        state = call_model(state, self.llms, printing=not self.silent)
         last_message = state["messages"][-1]
         if len(last_message.tool_calls) == 0:
             state["messages"].append(HumanMessage(content=no_tools_msg))
@@ -102,16 +105,41 @@ def call_model_researcher(self, state):
         state = call_tool(state, self.tools)
         return state
 
+    # condition functions
+    def after_agent_condition(self, state):
+        messages = [msg for msg in state["messages"] if msg.type in ["ai", "human"]]
+        last_message = messages[-1]
+
+        if last_message.content == no_tools_msg:
+            return "agent"
+        elif last_message.tool_calls[0]["name"] == "final_response_researcher":
+            if self.silent:
+                state["messages"].append(HumanMessage(content="Approved automatically"))    # Dummy message to fullfil state, to align with "Approved by human" message in loun mode
+                # Save research history to file
+                history_file = os.path.join(work_dir, ".clean_coder", f"research_history_task_{self.task_id}.json")
+                save_state_history_to_disk(state, history_file)
+                return END  # Skip human approval in silent mode
+            return "human"
+        else:
+            return "agent"
+
     # just functions
     def research_task(self, task):
-        print_formatted("Researcher starting its work", color="green")
-        print_formatted("👋 Hey! I'm looking for files on which we will work on together!", color="light_blue")
+        if not self.silent:
+            print_formatted("Researcher starting its work", color="green")
+            print_formatted("👋 Hey! I'm looking for files on which we will work on together!", color="light_blue")
 
         system_prompt_template = load_prompt("researcher_system")
-        system_message = system_prompt_template.format(task=task, project_rules=read_coderrules())
-        inputs = {
-            "messages": [SystemMessage(content=system_message), HumanMessage(content=list_directory_tree(work_dir))]
-        }
+        system_message = SystemMessage(
+            content=system_prompt_template.format(task=task, project_rules=read_coderrules())
+        )
+
+        # Continue previous dialogue if available; otherwise start fresh
+        if self.prev_messages:
+            messages = [system_message] + self.prev_messages
+        else:
+            messages = [system_message, HumanMessage(content=list_directory_tree(work_dir))]
+        inputs = {"messages": messages}
         researcher_response = self.researcher.invoke(inputs, {"recursion_limit": 100})["messages"][-3]
         response_args = researcher_response.tool_calls[0]["args"]
         text_files = set(CodeFile(f) for f in response_args["files_to_work_on"] + response_args["reference_files"])
@@ -122,5 +150,5 @@ def research_task(self, task):
 
 if __name__ == "__main__":
     task = """Check all system"""
-    researcher = Researcher(work_dir)
+    researcher = Researcher()
     researcher.research_task(task)