Upload 9 files

Dockerfile

@@ -0,0 +1,31 @@
+# Use a base image with Python 3.10 and CUDA for GPU support
+FROM python:3.10-slim
+
+# Install system dependencies for Docker and Git
+RUN apt-get update && apt-get install -y \
+    curl \
+    git \
+    build-essential \
+    libffi-dev \
+    libssl-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Docker inside the container
+RUN curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh
+RUN usermod -aG docker www-data
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the application files
+COPY . /app
+
+# Install Python dependencies
+# We use --no-cache-dir to save space
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Expose the port for the Flask application
+EXPOSE 7860
+
+# Command to run the application
+CMD ["bash", "run.sh"]

agents.py

@@ -0,0 +1,80 @@
+# FallnAI Autonomous Software Developer
+# agent.py
+
+from crewai import Agent
+from crewai_tools import SerperDevTool
+
+# Define search tool
+search_tool = SerperDevTool()
+
+# Define the Planner Agent
+planner_agent = Agent(
+    role="Software Architect",
+    goal="""Create a detailed, step-by-step plan to develop a new software application 
+            based on the user's request. Break down the project into manageable tasks 
+            for other agents.""",
+    backstory="""You are a seasoned software architect with a passion for designing elegant 
+                 and efficient systems. You excel at translating vague ideas into clear, 
+                 actionable project plans.""",
+    verbose=True,
+    allow_delegation=False
+)
+
+# Define the Coder Agent
+coder_agent = Agent(
+    role="Senior Python Developer",
+    goal="""Write high-quality, bug-free, and well-commented Python code according to the 
+            project plan. Ensure the code is clean and adheres to best practices.""",
+    backstory="""You are a highly skilled Python developer with a knack for solving complex 
+                 problems. You write robust code that is easy to read and maintain.""",
+    verbose=True,
+    allow_delegation=False
+)
+
+# Define the Tester Agent
+tester_agent = Agent(
+    role="Quality Assurance Engineer",
+    goal="""Test the developed code for bugs, errors, and edge cases. Provide detailed 
+            feedback to the Coder Agent to ensure the final product is flawless.""",
+    backstory="""You are a meticulous and thorough QA engineer. You find pleasure in breaking 
+                 code and providing constructive criticism to improve its quality.""",
+    verbose=True,
+    allow_delegation=False
+)
+
+# Define the UI Designer Agent
+ui_designer_agent = Agent(
+    role="Frontend Developer",
+    goal="""Create a simple but functional user interface for the software. Use HTML and 
+            CSS to design a clean and intuitive layout.""",
+    backstory="""You are a creative frontend developer who can turn any concept into a 
+                 visually appealing and easy-to-use interface. You specialize in rapid 
+                 prototyping with basic web technologies.""",
+    verbose=True,
+    allow_delegation=False
+)
+
+# Define the Documentation Agent
+docs_agent = Agent(
+    role="Technical Writer",
+    goal="""Write high-quality documentation, including a README.md file, for the software. 
+            The documentation should explain the project's purpose, how to use it, and how to install dependencies.""",
+    backstory="""You are a skilled technical writer who specializes in making complex topics easy to understand. 
+                 You create excellent READMEs and other project documentation.""",
+    verbose=True,
+    allow_delegation=False
+)
+
+# Define the DevOps Agent
+devops_agent = Agent(
+    role="DevOps Engineer",
+    goal="""Manage repository creation and push the final, working code to GitHub. 
+            Automate the deployment process.""",
+    backstory="""You are an expert in continuous integration and deployment. 
+                 You handle all aspects of getting the software from development 
+                 to a live, accessible repository.""",
+    verbose=True,
+    allow_delegation=False
+)
+
+

app.py

@@ -0,0 +1,105 @@
+#FallnAI Autonomous Software Developer
+#app.py
+
+import os
+import json
+import subprocess
+import tempfile
+import time
+import re
+from flask import Flask, request, jsonify
+from crewai import Crew, Process
+from crewai.agent import Agent
+from crewai.task import Task
+from crewai.tools import Tool
+from textwrap import dedent
+from crewai_tools import SerperDevTool
+
+# Import agent and task classes
+from agents import planner_agent, coder_agent, tester_agent, ui_designer_agent, docs_agent, devops_agent
+from tasks import SoftwareDevelopmentTasks
+
+# Import the GitHub Manager
+from github_manager import GitHubManager
+
+app = Flask(__name__)
+
+# --- Configuration ---
+# GitHub Token from environment variable
+# IMPORTANT: Never hardcode this token.
+GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN")
+if not GITHUB_TOKEN:
+    print("Warning: GITHUB_TOKEN environment variable not set. GitHub push will fail.")
+
+# Initialize the GitHub tool
+github_tool = Tool(
+    name="GitHub_Manager",
+    func=GitHubManager(GITHUB_TOKEN).create_and_push_repo,
+    description="A tool to create and push files to a new GitHub repository."
+)
+
+@app.route('/develop', methods=['POST'])
+def develop_software():
+    data = request.json
+    user_prompt = data.get('prompt')
+
+    if not user_prompt:
+        return jsonify({"error": "No prompt provided"}), 400
+
+    # Sanitize and create a unique repository name
+    sanitized_prompt = re.sub(r'[^a-zA-Z0-9-]', '', user_prompt[:30]).lower()
+    timestamp = int(time.time())
+    repo_name = f"auto-dev-{sanitized_prompt}-{timestamp}"
+
+    try:
+        # Create a new crew for this request
+        tasks = SoftwareDevelopmentTasks(user_prompt)
+        
+        # Add the GitHub tool to the DevOps agent
+        devops_agent.tools.append(github_tool)
+
+        crew = Crew(
+            agents=[planner_agent, coder_agent, tester_agent, ui_designer_agent, docs_agent, devops_agent],
+            tasks=[
+                tasks.plan_software(planner_agent),
+                tasks.write_code(coder_agent),
+                tasks.write_ui(ui_designer_agent),
+                tasks.review_and_test(tester_agent),
+                tasks.write_documentation(docs_agent), # New documentation task
+                tasks.push_to_github(devops_agent, repo_name=repo_name) # Pass repo_name
+            ],
+            process=Process.sequential,
+            verbose=2
+        )
+        
+        # Kick off the development process
+        result = crew.kickoff()
+
+        # Extract the final outputs to be pushed
+        final_code = ""
+        final_ui = ""
+        final_docs = ""
+        for task_result in crew.tasks_outputs:
+            if "code" in task_result.description.lower():
+                final_code = task_result.output
+            if "ui" in task_result.description.lower():
+                final_ui = task_result.output
+            if "documentation" in task_result.description.lower():
+                final_docs = task_result.output
+
+        # Final step is to get the push result and include it in the response
+        final_result = crew.kickoff()
+
+        return jsonify({
+            "status": "success",
+            "log": final_result,
+            "final_code": final_code,
+            "final_ui": final_ui,
+            "final_docs": final_docs
+        })
+
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0', port=5000)

github_manager.py

@@ -0,0 +1,50 @@
+# FallnAI Autonomous Software Developer
+# github_manager.py 
+
+import os
+from github import Github, InputGitTreeElement
+
+class GitHubManager:
+    """A tool to manage GitHub repositories and push code."""
+
+    def __init__(self, token):
+        self.github = Github(token)
+
+    def create_and_push_repo(self, repo_name, commit_message, files):
+        """
+        Creates a new public repository and pushes a set of files to it.
+
+        :param repo_name: The name for the new repository.
+        :param commit_message: The message for the initial commit.
+        :param files: A dictionary of {file_path: file_content}.
+        :return: The URL of the new repository on success, or an error message.
+        """
+        try:
+            user = self.github.get_user()
+            
+            # Check if repo already exists
+            try:
+                user.get_repo(repo_name)
+                return f"Error: Repository '{repo_name}' already exists."
+            except Exception:
+                pass # Repo doesn't exist, which is what we want
+
+            # Create the repository
+            repo = user.create_repo(repo_name, private=False)
+            main_branch = repo.get_branch("main")
+            
+            # Prepare files for the commit
+            elements = []
+            for file_path, content in files.items():
+                elements.append(InputGitTreeElement(file_path, '100644', 'blob', content))
+
+            # Create the initial commit
+            base_tree = repo.get_git_tree(main_branch.commit.sha)
+            new_tree = repo.create_git_tree(elements, base_tree)
+            new_commit = repo.create_git_commit(commit_message, new_tree, [main_branch.commit])
+            main_branch.set_reference(f"refs/heads/main", new_commit.sha)
+            
+            return f"Success: Repository created and code pushed. URL: {repo.html_url}"
+
+        except Exception as e:
+            return f"Error pushing to GitHub: {e}"

index.html

@@ -0,0 +1,102 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FallnAI Autonomous Software Developer</title>
+    <style>
+        body { font-family: sans-serif; margin: 20px; background-color: #f0f4f8; }
+        .container { max-width: 900px; margin: auto; padding: 20px; background: white; border-radius: 8px; box-shadow: 0 2px 10px rgba(0,0,0,0.1); }
+        h1 { text-align: center; color: #333; }
+        .input-group { margin-bottom: 20px; }
+        textarea { width: 100%; height: 100px; padding: 10px; border: 1px solid #ccc; border-radius: 4px; }
+        button { padding: 10px 20px; background-color: #007bff; color: white; border: none; border-radius: 4px; cursor: pointer; }
+        button:disabled { background-color: #aaa; cursor: not-allowed; }
+        .log-section, .code-section, .docs-section { margin-top: 20px; }
+        pre { background: #eee; padding: 15px; border-radius: 4px; overflow-x: auto; white-space: pre-wrap; word-wrap: break-word; }
+        #progressLog, #finalCode, #finalUI, #finalDocs { border: 1px solid #ddd; min-height: 150px; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🤖 FallnAI Autonomous Software Developer v.01</h1>
+        <p>Enter your software specifications below. The agents will plan, code, and test the solution automatically using open-source models.</p>
+        
+        <div class="input-group">
+            <textarea id="prompt" placeholder="e.g., A simple Python script that takes a list of numbers and returns the sum."></textarea>
+            <button id="devButton" onclick="startDevelopment()">Start Development</button>
+        </div>
+
+        <div class="log-section">
+            <h2>Development Log</h2>
+            <pre id="progressLog">Waiting for input...</pre>
+        </div>
+
+        <div class="code-section">
+            <h2>Final Code (`app.py`)</h2>
+            <pre id="finalCode">The final code will appear here.</pre>
+        </div>
+        
+        <div class="code-section">
+            <h2>User Interface (`index.html`)</h2>
+            <pre id="finalUI">The user interface code will appear here.</pre>
+        </div>
+        
+        <div class="docs-section">
+            <h2>Documentation (`README.md`)</h2>
+            <pre id="finalDocs">The README file will be generated here.</pre>
+        </div>
+    </div>
+
+    <script>
+        async function startDevelopment() {
+            const prompt = document.getElementById('prompt').value;
+            const progressLog = document.getElementById('progressLog');
+            const finalCode = document.getElementById('finalCode');
+            const finalUI = document.getElementById('finalUI');
+            const finalDocs = document.getElementById('finalDocs');
+            const devButton = document.getElementById('devButton');
+
+            if (!prompt) {
+                alert('Please enter a prompt.');
+                return;
+            }
+
+            devButton.disabled = true;
+            progressLog.textContent = 'Development started... This may take a few minutes as the model is generating and the sandbox is building.';
+            finalCode.textContent = 'Awaiting result...';
+            finalUI.textContent = 'Awaiting result...';
+            finalDocs.textContent = 'Awaiting result...';
+
+            try {
+                const response = await fetch('http://localhost:5000/develop', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ prompt: prompt })
+                });
+                
+                const data = await response.json();
+
+                if (response.ok) {
+                    progressLog.textContent = data.log;
+                    if (data.status === "success") {
+                        finalCode.textContent = data.final_code;
+                        finalUI.textContent = data.final_ui;
+                        finalDocs.textContent = data.final_docs;
+                    } else {
+                        finalCode.textContent = "Could not generate working code. See log for details.";
+                        finalUI.textContent = "";
+                        finalDocs.textContent = "";
+                    }
+                } else {
+                    progressLog.textContent = `Error from server: ${data.error}`;
+                }
+            } catch (error) {
+                progressLog.textContent = `Failed to connect to the backend: ${error.message}`;
+            } finally {
+                devButton.disabled = false;
+            }
+        }
+    </script>
+</body>
+</html>

readme.md

@@ -0,0 +1,24 @@
+---
+title: FallnAI Autonomous Software Developer
+emoji: 🚀
+colorFrom: pink
+colorTo: purple
+sdk: docker
+app_port: 7860
+---
+
+# FallnAI Autonomous Software Development Platform
+
+This is a proof-of-concept autonomous software development platform. It leverages a crew of AI agents using open-source Large Language Models (LLMs) from Hugging Face to write, test, and correct its own code within a secure Docker sandbox. It automatically pushes the final, working code and documentation to a new GitHub repository.
+
+## How it works
+
+1.  **Frontend**: A simple web UI in `index.html` allows users to submit a software request.
+2.  **Backend**: The Flask application in `app.py` receives the request.
+3.  **Agent Crew**: The backend uses the CrewAI framework to orchestrate a team of specialized agents (e.g., Planner, Coder, Tester) to execute a sequential development process: plan, code, test, and document.
+4.  **LLMs & Transformers**: Each agent uses an LLM (accessed via the `transformers` library) as its core reasoning engine to perform its task.
+5.  **Sandboxing**: The generated code is executed inside a temporary, isolated Docker container to prevent any malicious code from affecting the host system.
+6.  **Correction Loop**: The LLM analyzes the output and errors from the sandbox and corrects the code until it passes.
+7.  **Documentation & Deployment**: A dedicated agent writes a `README.md` file, and a DevOps agent pushes all final files to a new, unique GitHub repository.
+
+Give it a try! You can describe any simple Python script, such as "a program that calculates the factorial of a number."

requirements.txt

@@ -0,0 +1,9 @@
+flask
+transformers
+torch
+docker
+crewai
+crewai[mistral]
+openai
+PyGithub
+crewai-tools

run.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# Start the Docker daemon in the background
+dockerd-entrypoint.sh &
+
+# Wait for the Docker daemon to be ready
+until docker info >/dev/null 2>&1; do
+    echo "Waiting for Docker daemon to start..."
+    sleep 1
+done
+
+echo "Docker daemon is running."
+
+# Run the Flask application
+# Hugging Face Spaces uses port 7860 by default
+python app.py --port 7860 --host 0.0.0.0

task.py

@@ -0,0 +1,77 @@
+# FallnAI Autonomous Software Developer
+# tasks.py
+
+from crewai import Task
+from textwrap import dedent
+
+class SoftwareDevelopmentTasks:
+    def __init__(self, user_prompt):
+        self.user_prompt = user_prompt
+
+    def plan_software(self, agent):
+        return Task(
+            description=dedent(f"""
+                Plan the development of a software application based on the following request:
+                "{self.user_prompt}"
+                Break down the project into clear, executable steps for the other agents.
+                The final output should be a detailed development plan.
+            """),
+            agent=agent
+        )
+
+    def write_code(self, agent):
+        return Task(
+            description=dedent("""
+                Write the core Python code for the application based on the provided plan. 
+                Ensure the code is functional, well-commented, and includes necessary imports.
+                The final output must be a single, complete Python script.
+            """),
+            agent=agent
+        )
+
+    def write_ui(self, agent):
+        return Task(
+            description=dedent("""
+                Create a simple but functional HTML/CSS user interface to interact with the Python script.
+                The UI should be a single HTML file with embedded CSS.
+                The final output must be the complete HTML file content.
+            """),
+            agent=agent
+        )
+
+    def review_and_test(self, agent, code_content, ui_content):
+        return Task(
+            description=dedent(f"""
+                Review and test the generated Python code and UI.
+                Identify any bugs, errors, or security vulnerabilities.
+                If any issues are found, provide specific feedback for the Coder and UI agents to fix.
+                The final output should be a confirmation that the code is working or a list of required fixes.
+                Code to test: {code_content}
+                UI to test: {ui_content}
+            """),
+            agent=agent
+        )
+
+    def write_documentation(self, agent):
+        return Task(
+            description=dedent("""
+                Analyze the provided software code and the original user request.
+                Write a detailed README.md file that includes:
+                - A project title and a brief description.
+                - A "How to Use" section with clear instructions.
+                - An "Installation" section listing any required dependencies.
+
+                The final output should be the complete documentation content for a single file named README.md.
+            """),
+            agent=agent
+        )
+
+    def push_to_github(self, agent, repo_name):
+        return Task(
+            description=dedent(f"""
+                Take the final, verified code and documentation and push it to a new GitHub repository.
+                The repository name should be '{repo_name}'.
+                The final output must be the URL of the repository.
+            """),
+            agent=agent
+        )