Upload 18 files

README.md

@@ -1,8 +1,8 @@
 ---
 title: Paper2Agent
-emoji: 🌍
-colorFrom: indigo
-colorTo: indigo
+emoji: 📈
+colorFrom: yellow
+colorTo: pink
 sdk: gradio
 sdk_version: 6.0.2
 app_file: app.py

requirements.txt

@@ -0,0 +1,12 @@
+# Web UI
+gradio
+
+# Async runtime
+anyio
+
+# Claude Agent SDK
+claude-agent-sdk
+
+uv
+
+fastmcp

test.py

@@ -0,0 +1,143 @@
+import anyio
+import argparse
+import shutil
+import subprocess
+from claude_agent_sdk import (
+    ClaudeSDKClient,
+    ClaudeAgentOptions,
+    AgentDefinition,
+    AssistantMessage,
+    TextBlock,
+    ToolUseBlock,
+    ToolResultBlock
+)
+
+import os
+import sys
+from pathlib import Path
+from utils import copy_project_resources, clone_github_repo, prepare_folder_structure
+from prompts.tasks import step1_environment_setup_and_tutorial_discovery, step2_tutorial_execution, step3_tool_extraction_and_testing, step4_mcp_integration
+
+# ANTHROPIC_API_KEY should be set via environment variable by the caller (app.py)
+
+async def fully_automatic(tasks: list, task_descriptions: list = None, log_file_path: str = None):
+    options = ClaudeAgentOptions(
+        allowed_tools=["Bash", "Edit", "Glob", "Grep", "NotebookEdit", "NotebookRead", "Read", "SlashCommand", "Task", "TodoWrite", "WebFetch", "WebSearch", "Write"],
+        permission_mode='acceptEdits',
+        cwd=str(Path.cwd()),
+        setting_sources=["project"],
+    )
+
+    async with ClaudeSDKClient(options=options) as client:
+        for i, task in enumerate(tasks, 1):
+            # Simple print for UI
+            print(f"\n{'='*70}")
+            if task_descriptions and i <= len(task_descriptions):
+                print(f"🚀 Starting {task_descriptions[i-1]}")
+            else:
+                print(f"🚀 Starting Task {i}")
+            print('='*70 + "\n")
+
+            try:
+                await client.query(task)
+                async for message in client.receive_response():
+                    # Write detailed logs to file
+                    if log_file_path:
+                        with open(f"Task_{i}_{log_file_path}", 'a', encoding='utf-8') as log_file:
+                            if isinstance(message, AssistantMessage):
+                                for block in message.content:
+                                    if isinstance(block, TextBlock):
+                                        log_file.write(f"💭 Claude: {block.text}\n")
+                                    elif isinstance(block, ToolUseBlock):
+                                        if hasattr(block, 'input') and block.input:
+                                            if isinstance(block.input, dict):
+                                                for key, value in block.input.items():
+                                                    val_str = str(value)
+                                                    log_file.write(f"[ToolUseBlock] {key}: {val_str}\n")
+                            elif isinstance(message, ToolResultBlock):
+                                if hasattr(message, 'content'):
+                                    result = str(message.content)
+                                    log_file.write(f"  ✅ Result: {result}\n")
+
+                    # Only print brief progress to stdout for UI
+                    if isinstance(message, AssistantMessage):
+                        for block in message.content:
+                            if isinstance(block, TextBlock):
+                                # Only print short text blocks
+                                text = block.text.strip()
+                                if len(text) < 150:
+                                    print(f"💭 {text}")
+
+                print(f"\n✅ Task {i} Completed\n")
+
+            except Exception as e:
+                print(f"❌ Task {i} Failed: {e}\n")
+                if log_file_path:
+                    with open(log_file_path, 'a', encoding='utf-8') as log_file:
+                        log_file.write(f"❌ Task {i} Failed: {e}\n")
+
+
+def main():
+
+    parser = argparse.ArgumentParser(description="Script for running tasks with configurable options.")
+    parser.add_argument('--github_url', dest='github_repo_url', default="", help='GitHub repository URL')
+    parser.add_argument('--tutorials', dest='tutorial_filter', default="", help='Tutorial filter')
+    parser.add_argument('--api', dest='api_key', default="", help='API key')
+    args = parser.parse_args()
+
+    GITHUB_REPO_URL = args.github_repo_url
+    FOLDER_NAME = "Results"
+    TUTORIAL_FILTER = args.tutorial_filter
+    API_KEY = args.api_key
+
+    # Extract repo_name from the GITHUB_REPO_URL (strip .git suffix if present)
+    if GITHUB_REPO_URL:
+        repo_name = os.path.basename(GITHUB_REPO_URL)
+        if repo_name.endswith(".git"):
+            repo_name = repo_name[:-4]
+    else:
+        repo_name = ""
+
+    
+    os.makedirs(FOLDER_NAME, exist_ok=True)
+
+    # step 1: copy .claude, templates, tools to the project directory
+    copy_project_resources(FOLDER_NAME)
+    
+    # step 2: prepare the folder structure
+    prepare_folder_structure(FOLDER_NAME)
+
+    os.chdir(FOLDER_NAME)
+    
+    # step 3: clone the github repository
+    clone_github_repo(GITHUB_REPO_URL, repo_name)
+
+    task_descriptions = [
+        "Task 1: Environment Setup and Tutorial Discovery",
+        "Task 2: Tutorial Execution",
+        "Task 3: Tool Extraction and Testing",
+        "Task 4: MCP Integration"
+    ]
+
+    tasks = [
+        step1_environment_setup_and_tutorial_discovery(repo_name,TUTORIAL_FILTER),
+        step2_tutorial_execution(repo_name,API_KEY),
+        step3_tool_extraction_and_testing(repo_name,API_KEY),
+        step4_mcp_integration(repo_name),
+    ]
+
+    print("\n" + "="*70)
+    print("📋 Pipeline Tasks:")
+    for i, desc in enumerate(task_descriptions, 1):
+        print(f"   {i}. {desc}")
+    print("="*70 + "\n")
+
+    # Define log file path
+    log_file_path = "log.log"
+
+    #print(tasks[0])
+    anyio.run(fully_automatic, tasks, task_descriptions, log_file_path)
+
+
+if __name__ == "__main__":
+    main()

utils.py

@@ -0,0 +1,91 @@
+import anyio
+import argparse
+import shutil
+import subprocess
+import os
+import sys
+from pathlib import Path
+def copy_project_resources(FOLDER_NAME):
+    """
+    Step 1: Copy .claude, templates, tools to the project directory.
+    """
+    MAIN_DIR = FOLDER_NAME or "."
+    SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+    copy_targets = [
+        (".claude", "01: .claude already exists or source missing"),
+        ("templates", "01: templates already exists or source missing"),
+        ("tools", "01: tools already exists or source missing"),
+    ]
+
+    for subdir, error_msg in copy_targets:
+        src = os.path.join(SCRIPT_DIR, subdir)
+        dst = os.path.join(MAIN_DIR, subdir)
+        if not os.path.isdir(dst) and os.path.isdir(src):
+            try:
+                shutil.copytree(src, dst)
+            except Exception as copy_exc:
+                print(f"01: failed to copy {subdir}: {copy_exc}", file=sys.stderr)
+        else:
+            print(error_msg, file=sys.stderr)
+
+def clone_github_repo(GITHUB_REPO_URL, repo_name):
+    """
+    Step 3: Clone the GitHub repository into the repo directory.
+    """
+    REPO_PARENT = os.path.join(os.getcwd(), "repo")
+    REPO_DIR = os.path.join(REPO_PARENT, repo_name) if repo_name else ""
+    GIT_URL = GITHUB_REPO_URL
+
+    print(f"03: clone target={GIT_URL} into {REPO_DIR}", file=sys.stderr)
+
+    os.makedirs(REPO_PARENT, exist_ok=True)
+
+    if repo_name and os.path.isdir(REPO_DIR):
+        print("03: repo dir already exists: {}".format(REPO_DIR), file=sys.stderr)
+    elif repo_name and GIT_URL:
+        clone_attempts = [
+            (["git", "clone", "--recurse-submodules", GIT_URL, REPO_DIR], "02: cloned with submodules"),
+            (["git", "clone", "--depth=1", GIT_URL, REPO_DIR], "02: shallow clone ok"),
+            (["git", "clone", GIT_URL, REPO_DIR], None),
+        ]
+        for i, (cmd, success_msg) in enumerate(clone_attempts):
+            if i == 0:
+                print("03: starting git clone with submodules...", file=sys.stderr)
+            elif i == 1:
+                print("03: main clone failed, trying --depth=1", file=sys.stderr)
+            elif i == 2:
+                print("03: shallow clone failed, trying plain clone", file=sys.stderr)
+            try:
+                rc = subprocess.call(cmd)
+            except Exception as e:
+                print(f"03: clone exception: {e}", file=sys.stderr)
+                rc = 1
+            if rc == 0:
+                if success_msg:
+                    print(success_msg, file=sys.stderr)
+                break
+        else:
+            print("03: failed: all clone attempts failed", file=sys.stderr)
+            
+def prepare_folder_structure(main_dir):
+    """
+    Prepare the required folder structure for the pipeline under main_dir.
+
+    Args:
+        main_dir (str): The main project directory where folders will be created.
+    """
+    print(f"02: preparing folder structure under {main_dir}", file=sys.stderr)
+    dirs_to_make = [
+        os.path.join(main_dir, "reports"),
+        os.path.join(main_dir, "src", "tools"),
+        os.path.join(main_dir, "tests", "code"),
+        os.path.join(main_dir, "tests", "data"),
+        os.path.join(main_dir, "notebooks"),
+        os.path.join(main_dir, "tests", "results"),
+        os.path.join(main_dir, "tests", "logs"),
+        os.path.join(main_dir, "tests", "summary"),
+        os.path.join(main_dir, "tmp", "inputs"),
+        os.path.join(main_dir, "tmp", "outputs"),
+    ]
+    for d in dirs_to_make:
+        os.makedirs(d, exist_ok=True)