Upload folder using huggingface_hub

CriticalThinking/app/api/router.py

@@ -37,7 +37,7 @@ def run_analysis_task(task_id: str, repo_url: Optional[str], project_description
             indexer.index_repository(repo_url)
 
         # 2. Analyze
-        analysis_results = orchestrator.run_analysis(project_description)
+        analysis_results = orchestrator.run_analysis(project_description, has_code=bool(repo_url))
         weaknesses = analysis_results.get("weaknesses", [])
 
         # 3. Improvements

CriticalThinking/app/services/agent_orchestrator.py

@@ -50,25 +50,33 @@ class BaseAgent:
         return "Mocked response"
 
 class Planner(BaseAgent):
-    def plan(self, project_overview: str) -> Dict[str, Any]:
-        system_prompt = """You are an expert query planner for a deep-thinking codebase analysis system.
+    def plan(self, project_overview: str, has_code: bool = True) -> Dict[str, Any]:
+        if has_code:
+            system_prompt = """You are an expert query planner for a deep-thinking codebase analysis system.
 Your task is to decompose complex codebase investigations into sequential execution plans.
 Guidelines:
 - Create 2-5 steps that build on each other.
 - Each step should have a clear sub-question targeting a specific architectural or logic component.
 - Specify tool_type: doc_search (for code retrieval)."""
+        else:
+            system_prompt = """You are an expert architect planning the design of a new modular software system.
+Your task is to decompose the project description into sequential design steps.
+Guidelines:
+- Create 2-5 steps focusing on component decomposition and external service discovery.
+- Each step should target a specific functional module or API integration.
+- Specify tool_type: doc_search (for documentation or concept search)."""
         user_prompt = f"Decompose the following project overview into a sequential execution plan:\n\nProject Overview: {project_overview}\n\nRespond with valid JSON in this EXACT format:\n{{\n  'steps': [\n    {{\n      'index': 0,\n      'sub_question': 'What specific architectural component needs analysis?',\n      'tool_type': 'doc_search',\n      'expected_outputs': ['finding 1', 'finding 2']\n    }}\n  ],\n  'reasoning': 'Explain why this plan will effectively find weaknesses.'\n}}"
         return self._get_response(system_prompt, user_prompt, response_format={"type": "json_object"})
 
 class WeaknessAnalyzer(BaseAgent):
-    def analyze(self, code_context: str) -> Dict[str, Any]:
-        system_prompt = """You are an AI senior engineer reviewing a project for critical weaknesses.
+    def analyze(self, context: str) -> Dict[str, Any]:
+        system_prompt = """You are an AI senior engineer and architect reviewing a project or requirements for critical weaknesses.
 Be critical and cautious. Focus on:
-- Architectural flaws (circular dependencies, lack of modularity).
-- Security risks.
-- Performance bottlenecks.
+- Architectural flaws (circular dependencies, lack of modularity, tight coupling).
+- Missing high-value external integrations.
+- Potential performance bottlenecks.
 - Redundant custom logic that could be replaced by standard libraries or models."""
-        user_prompt = f"Analyze the following code snippets for weaknesses:\n\n{code_context}\n\nRespond in JSON format with fields: 'summary', 'weaknesses' (list of strings), 'severity' (high/medium/low)."
+        user_prompt = f"Analyze the following context (code or requirements) for weaknesses or missing components:\n\n{context}\n\nRespond in JSON format with fields: 'summary', 'weaknesses' (list of strings), 'severity' (high/medium/low)."
         return self._get_response(system_prompt, user_prompt, response_format={"type": "json_object"})
 
 class AgentOrchestrator:
@@ -77,9 +85,9 @@ class AgentOrchestrator:
         self.planner = Planner(openai_api_key=openai_api_key)
         self.analyzer = WeaknessAnalyzer(openai_api_key=openai_api_key)
 
-    def run_analysis(self, project_overview: str) -> Dict[str, Any]:
+    def run_analysis(self, project_overview: str, has_code: bool = True) -> Dict[str, Any]:
         # 1. Plan
-        plan = self.planner.plan(project_overview)
+        plan = self.planner.plan(project_overview, has_code=has_code)
 
         all_weaknesses = []
         # 2. Execute steps

CriticalThinking/app/services/improvement_agent.py

@@ -3,28 +3,34 @@ from app.services.agent_orchestrator import BaseAgent
 
 class ImprovementAgent(BaseAgent):
     def generate_improvements(self, weaknesses: List[str]) -> Dict[str, Any]:
-        system_prompt = """You are an AI research scientist and senior architect.
-Your goal is to generate impactful and creative ideas for improving a codebase or designing a new one.
-Consider:
-- Decomposing the project into independent, modular components.
-- Suggesting state-of-the-art Hugging Face models (Spaces/Models) or GitHub projects to serve as functional components.
-- Ensuring components communicate via FastAPI endpoints.
-- Replacing custom implementations with existing open-source projects to reduce maintenance."""
-        user_prompt = f"Given these weaknesses:\n{weaknesses}\n\nPropose a next-step improvement roadmap. Respond in JSON with format:\n{{\n  'improvements': [\n    {{\n      'weakness': 'the identified weakness',\n      'proposal': 'detailed improvement plan',\n      'replacement_search_query': 'query for Hugging Face or GitHub',\n      'interestingness': 1-10,\n      'feasibility': 1-10\n    }}\n  ]\n}}"
+        system_prompt = """You are an AI research scientist and senior architect with a focus on modular, API-driven design.
+Your goal is to generate impactful ideas for improving a codebase or designing a new one by integrating high-value external components.
+Key Principles:
+- Decompose the project into independent, modular components that communicate via FastAPI endpoints.
+- Identify state-of-the-art Hugging Face Models/Spaces or GitHub projects that can serve as functional building blocks.
+- **Strict Critical Judgment**: Only suggest an external project if it is exceptionally useful and provides significant advantages over a custom implementation.
+- Focus on reducing custom code and maintenance by leveraging established open-source ecosystems."""
+        user_prompt = f"Given these weaknesses or project requirements:\n{weaknesses}\n\nPropose a strategic improvement roadmap focusing on modularity and external integrations. Respond in JSON with format:\n{{\n  'improvements': [\n    {{\n      'component_or_weakness': 'the target component or identified weakness',\n      'proposal': 'detailed plan for integration or improvement',\n      'justification': 'critical reasoning for why this external project or approach is high-value',\n      'replacement_search_query': 'specific query for Hugging Face or GitHub discovery',\n      'utility_score': 1-10,\n      'feasibility': 1-10\n    }}\n  ]\n}}"
         return self._get_response(system_prompt, user_prompt, response_format={"type": "json_object"})
 
     def _mock_response(self, system_prompt: str) -> Any:
         return {
             "improvements": [
                 {
-                    "weakness": "Manual memory management",
-                    "proposal": "Use a managed library",
-                    "replacement_search_query": "memory management library"
+                    "component_or_weakness": "Memory Management",
+                    "proposal": "Integrate a specialized Rust-based memory optimizer via a Python wrapper.",
+                    "justification": "Significant reduction in overhead for high-throughput data processing.",
+                    "replacement_search_query": "python rust memory management",
+                    "utility_score": 8,
+                    "feasibility": 7
                 },
                 {
-                    "weakness": "Lack of sentiment analysis accuracy",
-                    "proposal": "Use a pre-trained transformer model",
-                    "replacement_search_query": "sentiment analysis"
+                    "component_or_weakness": "Sentiment Analysis",
+                    "proposal": "Replace custom rule-based system with a hosted Hugging Face Space API.",
+                    "justification": "LLM-based models provide far superior accuracy for nuanced text.",
+                    "replacement_search_query": "sentiment analysis space",
+                    "utility_score": 9,
+                    "feasibility": 10
                 }
             ]
         }