Add application file

.gitignore

@@ -0,0 +1,199 @@
+.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+test/
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+/threads
+state.json
+/workspace/
+/workspace/*
+/workspace/**
+
+*.venvy/*
+*.venvy*
+
+# SQLite
+*.db
+
+# .DS_Store files
+.DS_Store
+**/.DS_Store
+.aider*
+supabase/.temp/cli-latest
+supabase/.temp/gotrue-version
+supabase/.temp/pooler-url
+supabase/.temp/postgres-version
+supabase/.temp/project-ref
+supabase/.temp/rest-version
+supabase/.temp/storage-version
+
+**/.prompts/
+**/__pycache__/
+
+
+.env.scripts
+server/.git
+trash
+templates
+output
+
+rand.edu.backend/.git

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.9
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

agents/analysis/__init__.py

@@ -0,0 +1,15 @@
+from .entities_analysis import EntitiesAnalysis
+from .actors_analysis import ActorsAnalysis
+from .sequence_analysis import SequenceAnalysis
+from .state_analysis import StateAnalysis
+from .architecture_analysis import ArchitectureAnalysis
+from .deployment_analysis import DeploymentAnalysis
+
+__all__ = [
+    'EntitiesAnalysis',
+    'ActorsAnalysis',
+    'SequenceAnalysis',
+    'StateAnalysis',
+    'ArchitectureAnalysis',
+    'DeploymentAnalysis'
+] 

agents/analysis/actors_analysis.py

@@ -0,0 +1,90 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class ActorsAnalysis(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Conduct a thorough actor and use case analysis for the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+
+        Analysis Requirements:
+        1. Identify all actor types:
+           - Primary actors (initiate interactions)
+           - Secondary actors (support the system)
+           - External systems (integrated services)
+           - Offstage actors (affected but don't interact)
+        2. For each actor, specify:
+           - Role/purpose
+           - Interaction frequency
+           - Special characteristics
+        3. Identify core use cases with:
+           - Clear actor-action-benefit format
+           - Preconditions and postconditions
+           - Main success scenarios
+           - Key variations/alternate flows
+        4. Highlight relationships between actors
+        5. Identify system boundaries
+
+        Format your response as follows:
+
+        ### Actor Analysis
+        #### Primary Actors
+        - [Actor Name] 
+          * Role: [description]
+          * Frequency: [constant/occasional/rare]
+          * Characteristics: [key attributes]
+
+        #### Supporting Actors
+        - [System/Service Name]
+          * Role: [description]
+          * Integration Type: [API/database/event]
+
+        ### Use Case Analysis
+        #### Core Use Cases
+        1. "[Actor] performs [action] to [benefit]"
+           - Preconditions: [required state]
+           - Main Flow: [step-by-step]
+           - Postconditions: [system state after]
+           - Variations: [alternate paths]
+
+        #### Supporting Use Cases
+        1. "[System] provides [functionality] for [purpose]"
+
+        ### System Boundaries
+        - Included: [what's in scope]
+        - Excluded: [out-of-scope items]
+
+        Example:
+        ### Actor Analysis
+        #### Primary Actors
+        - Online Customer
+          * Role: Initiates purchases and manages account
+          * Frequency: Constant
+          * Characteristics: Authenticated, varying technical skill
+
+        ### Use Case Analysis
+        #### Core Use Cases
+        1. "Customer places order for products"
+           - Preconditions: Customer is logged in, cart not empty
+           - Main Flow: 
+             1. Customer selects checkout
+             2. System validates inventory
+             3. Customer enters payment
+             4. System confirms order
+           - Postconditions: Order is persisted, inventory updated
+           - Variations: Payment fails, inventory unavailable
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="actors_use_cases",
+            step_name="extract_actors",
+            project_name=state["project_name"],
+            project_description=state["project_description"]
+        ):
+            yield chunk

agents/analysis/architecture_analysis.py

@@ -0,0 +1,33 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class ArchitectureAnalysis(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Analyze the following project and identify system components:
+
+        Project: {project_name}
+        Description: {project_description}
+        Entities: {entities_classes}
+        Use Cases: {actors_use_cases}
+
+        Instructions:
+        1. Identify major system components/modules
+        2. List their responsibilities
+        3. Describe how they interact
+        4. Format as a structured component hierarchy
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="architecture_components",
+            step_name="extract_architecture",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            entities_classes=state["entities_classes"],
+            actors_use_cases=state["actors_use_cases"]
+        ):
+            yield chunk

agents/analysis/deployment_analysis.py

@@ -0,0 +1,31 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class DeploymentAnalysis(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Analyze the following project and identify deployment context:
+
+        Project: {project_name}
+        Description: {project_description}
+        Architecture Components: {architecture_components}
+
+        Instructions:
+        1. Identify the deployment nodes (servers, clients, etc.)
+        2. List the artifacts to be deployed
+        3. Show the relationships between nodes
+        4. Format as a structured list of deployment elements
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="deployment_context",
+            step_name="extract_deployment",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            architecture_components=state.get("architecture_components", "")
+        ):
+            yield chunk

agents/analysis/entities_analysis.py

@@ -0,0 +1,60 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class EntitiesAnalysis(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Conduct a comprehensive domain analysis for the following project to identify:
+        - Core entities
+        - Their attributes (with data types)
+        - Key relationships
+        - Important methods/operations
+        - Business rules/constraints
+
+        Project: {project_name}
+        Description: {project_description}
+
+        Format your response using the following structure for each entity:
+
+        ### [EntityName]
+        **Description**: [Brief purpose description]
+        **Attributes**:
+          - name: type (constraints/notes)
+        **Relationships**:
+          - [Cardinality] to [RelatedEntity] (description)
+        **Methods**:
+          - methodName(params): returnType (description)
+        **Business Rules**:
+          - [Rule description]
+
+        Example:
+        ### User
+        **Description**: Represents system users with authentication
+        **Attributes**:
+          - id: UUID (primary key)
+          - username: string (unique, 3-20 chars)
+          - email: string (valid email format)
+          - passwordHash: string (encrypted)
+        **Relationships**:
+          - One-to-Many to Order (user places orders)
+        **Methods**:
+          - authenticate(password: string): boolean
+          - placeOrder(items: List[CartItem]): Order
+        **Business Rules**:
+          - Password must be at least 8 characters
+          - Email must be verified before ordering
+
+        Provide this analysis for all major domain entities.
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="entities_classes",
+            step_name="extract_entities",
+            project_name=state["project_name"],
+            project_description=state["project_description"]
+        ):
+            yield chunk

agents/analysis/sequence_analysis.py

@@ -0,0 +1,77 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class SequenceAnalysis(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Conduct a comprehensive sequence analysis for the key workflow in:
+
+        Project: {project_name}
+        Description: {project_description}
+        Use Cases: {actors_use_cases}
+
+        Analysis Requirements:
+        1. Identify all participating components:
+           - Primary actors (initiators)
+           - Secondary systems/services
+           - Internal components
+        2. For each interaction step specify:
+           - Sender and receiver
+           - Message content/type
+           - Synchronization points
+           - Alternative/error flows
+        3. Include timing considerations where relevant
+        4. Note any parallel/concurrent activities
+        5. Highlight critical system boundaries
+
+        Format your response as:
+
+        ### Workflow: [Workflow Name]
+        #### Components:
+        - [Component1] (type/role)
+        - [Component2] (type/role)
+
+        #### Main Flow:
+        1. [ComponentA] -> [ComponentB]: [Message/Purpose]
+           - Preconditions: [required state]
+           - Postconditions: [resulting state]
+           - Variations: [alternate paths]
+
+        2. [ComponentB] --> [ComponentA]: [Response]
+           ...
+
+        #### Parallel Flows:
+        - Concurrent with step 2: [Description]
+
+        #### Error Handling:
+        - At step 3: [Error Condition] → [Recovery Path]
+
+        Example:
+        ### Workflow: Order Processing
+        #### Components:
+        - Customer (primary actor)
+        - OrderService (core system)
+        - PaymentGateway (external service)
+
+        #### Main Flow:
+        1. Customer -> OrderService: SubmitOrder(cart)
+           - Preconditions: Cart not empty, user authenticated
+           - Postconditions: Order pending payment
+           - Variations: Invalid items → Rejection notice
+
+        2. OrderService -> PaymentGateway: ProcessPayment(details)
+           ...
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="sequence_interactions",
+            step_name="extract_sequence",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            actors_use_cases=state["actors_use_cases"]
+        ):
+            yield chunk

agents/analysis/state_analysis.py

@@ -0,0 +1,32 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class StateAnalysis(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Analyze the following project and identify state transitions for key entities:
+
+        Project: {project_name}
+        Description: {project_description}
+        Entities: {entities_classes}
+        Sequence: {sequence_interactions}
+
+        Instructions:
+        1. For each key entity, identify its possible states
+        2. List the events that trigger state transitions
+        3. Format as a structured list of states and transitions
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="state_transitions",
+            step_name="extract_state_transitions",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            entities_classes=state["entities_classes"],
+            sequence_interactions=state["sequence_interactions"]
+        ):
+            yield chunk

agents/code/__init__.py

@@ -0,0 +1,21 @@
+from .class_diagram_generator import ClassDiagramGenerator
+from .use_case_diagram_generator import UseCaseDiagramGenerator
+from .sequence_diagram_generator import SequenceDiagramGenerator
+from .activity_diagram_generator import ActivityDiagramGenerator
+from .component_diagram_generator import ComponentDiagramGenerator
+from .deployment_diagram_generator import DeploymentDiagramGenerator
+from .state_diagram_generator import StateDiagramGenerator
+from .timing_diagram_generator import TimingDiagramGenerator
+from .object_diagram_generator import ObjectDiagramGenerator
+
+__all__ = [
+    'ClassDiagramGenerator',
+    'UseCaseDiagramGenerator',
+    'SequenceDiagramGenerator',
+    'ActivityDiagramGenerator',
+    'ComponentDiagramGenerator',
+    'DeploymentDiagramGenerator',
+    'StateDiagramGenerator',
+    'TimingDiagramGenerator',
+    'ObjectDiagramGenerator'
+] 

agents/code/activity_diagram_generator.py

@@ -0,0 +1,45 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class ActivityDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate PlantUML code for an activity diagram based on the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+        Use Cases: {actors_use_cases}
+
+        Instructions:
+        1. Show the main workflows as activities
+        2. Include decision points and parallel activities where appropriate
+        3. Use standard PlantUML activity diagram syntax
+        4. Don't include any explanation, just the PlantUML code
+
+        Example format (DO NOT TREAT THIS AS VARIABLES):
+        '''plantuml
+        @startuml
+        start
+        :Main Activity;
+        if (Decision?) then (yes)
+          :Activity 1;
+        else (no)
+          :Activity 2;
+        endif
+        stop
+        @enduml
+        '''
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="activity_diagram",
+            step_name="generate_activity_diagram",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            actors_use_cases=state["actors_use_cases"]
+        ):
+            yield chunk

agents/code/class_diagram_generator.py

@@ -0,0 +1,83 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class ClassDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate comprehensive PlantUML code for a class diagram based on the following domain analysis:
+
+        {entities_classes}
+
+        Instructions:
+        1. Include all classes with their complete attributes (visibility, type, constraints)
+        2. Use proper UML relationships with correct cardinality and labels:
+           - Inheritance: <|--
+           - Implementation: <|..
+           - Composition: *--
+           - Aggregation: o--
+           - Dependency: -->
+        3. For complex relationships, use association classes when needed
+        4. Include proper visibility markers:
+           - Public: +
+           - Private: -
+           - Protected: #
+           - Package: ~
+        5. Use advanced PlantUML features where appropriate:
+           - Abstract classes/interfaces
+           - Enumerations
+           - Stereotypes
+           - Notes and constraints
+           - Method signatures
+        6. Organize classes into packages if the domain suggests logical groupings
+        7. Use proper formatting with alignment and spacing
+        8. Include only the raw PlantUML code without explanations
+
+        Example Structure (DO NOT TREAT AS VARIABLES):
+        @startuml
+        package "Domain Model" {{
+          abstract class AbstractEntity {{
+            + id: UUID {{readonly}}
+            # createdAt: DateTime
+            + equals(other: Object): boolean {{abstract}}
+          }}
+
+          class User {{
+            + username: String {{unique}}
+            + email: String
+            - passwordHash: String
+            + authenticate(password: String): boolean
+          }}
+
+          enum UserRole {{
+            ADMIN
+            MEMBER
+            GUEST
+          }}
+
+          User "1" *-- "0..*" Order : places >
+          User o-- UserRole : has >
+
+          (User, Order) .. OrderAssociation
+          class OrderAssociation {{
+            + orderDate: DateTime
+            + status: OrderStatus
+          }}
+        }}
+
+        note top of User
+          User represents all system users
+          with authentication capabilities
+        end note
+        @enduml
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="class_diagram",
+            step_name="generate_class_diagram",
+            entities_classes=state["entities_classes"]
+        ):
+            yield chunk

agents/code/component_diagram_generator.py

@@ -0,0 +1,40 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class ComponentDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate PlantUML code for a component diagram based on the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+        Entities: {entities_classes}
+
+        Instructions:
+        1. Show the main system components and their interfaces
+        2. Include relationships between components
+        3. Use standard PlantUML component diagram syntax
+        4. Don't include any explanation, just the PlantUML code
+
+        Example format (DO NOT TREAT THIS AS VARIABLES):
+        '''plantuml
+        @startuml
+        component [Component1] as C1
+        component [Component2] as C2
+        C1 --> C2 : uses
+        @enduml
+        '''
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="component_diagram",
+            step_name="generate_component_diagram",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            entities_classes=state["entities_classes"]
+        ):
+            yield chunk

agents/code/deployment_diagram_generator.py

@@ -0,0 +1,40 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class DeploymentDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate PlantUML code for a deployment diagram based on the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+
+        Instructions:
+        1. Show the physical deployment architecture
+        2. Include nodes, artifacts, and their relationships
+        3. Use standard PlantUML deployment diagram syntax
+        4. Don't include any explanation, just the PlantUML code
+
+        Example format (DO NOT TREAT THIS AS VARIABLES):
+        '''plantuml
+        @startuml
+        node "Server" as server {{
+          artifact "WebApp"
+        }}
+        node "Client" as client
+        client --> server : HTTP
+        @enduml
+        '''
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="deployment_diagram",
+            step_name="generate_deployment_diagram",
+            project_name=state["project_name"],
+            project_description=state["project_description"]
+        ):
+            yield chunk

agents/code/object_diagram_generator.py

@@ -0,0 +1,45 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class ObjectDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate PlantUML code for an object diagram based on the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+        Entities: {entities_classes}
+
+        Instructions:
+        1. Show object instances and their relationships
+        2. Include attribute values for a specific scenario
+        3. Use standard PlantUML object diagram syntax
+        4. Don't include any explanation, just the PlantUML code
+
+        Example format (DO NOT TREAT THIS AS VARIABLES):
+        '''plantuml
+        @startuml
+        object "Object1" as o1 {{
+          attribute1 = value1
+          attribute2 = value2
+        }}
+        object "Object2" as o2 {{
+          attribute3 = value3
+        }}
+        o1 --> o2 : relationship
+        @enduml
+        '''
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="object_diagram",
+            step_name="generate_object_diagram",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            entities_classes=state["entities_classes"]
+        ):
+            yield chunk

agents/code/sequence_diagram_generator.py

@@ -0,0 +1,86 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class SequenceDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate comprehensive PlantUML code for a sequence diagram based on:
+
+        Workflow Analysis: {sequence_interactions}
+
+        Instructions:
+        1. Use proper participant types:
+           - actor for human users
+           - boundary for UI elements  
+           - control for controllers
+           - entity for domain objects
+           - database for storage
+        2. Include all message types:
+           - Synchronous: ->
+           - Asynchronous: ->>
+           - Return: -->
+           - Self: -> self
+        3. Add activation bars with:
+           - activate/deactivate
+           - Nested activations where needed
+        4. Use advanced features:
+           - Groups (alt/opt/loop/par)
+           - Notes
+           - Dividers (== Sections ==)
+           - Stereotypes <<component>>
+           - Arrows with:
+             * Lost messages (->x)
+             * Found messages (x->)
+             * Parallel (->||)
+        5. Format for readability:
+           - Proper indentation
+           - Section comments
+           - Color coding where helpful
+
+        Example Structure (DO NOT TREAT AS VARIABLES):
+        @startuml
+        skinparam style strictuml
+        skinparam lifelineStrategy solid
+        
+        actor Customer <<Human>>
+        boundary "Web UI" as UI
+        control OrderController
+        entity Order
+        database OrderDB
+        
+        == Order Submission ==
+        Customer -> UI: Submit Order
+        activate UI
+        UI -> OrderController: processOrder()
+        activate OrderController
+        
+        group Payment Processing
+            OrderController -> PaymentService <<External>>: authorizePayment()
+            activate PaymentService
+            PaymentService --> OrderController: status
+            deactivate PaymentService
+        end
+        
+        alt payment approved
+            OrderController -> OrderDB: persistOrder()
+            OrderController --> UI: confirmation
+        else payment declined
+            OrderController --> UI: error
+        end
+        
+        deactivate OrderController
+        UI --> Customer: Order Status
+        deactivate UI
+        @enduml
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="sequence_diagram",
+            step_name="generate_sequence_diagram",
+            sequence_interactions=state["sequence_interactions"]
+        ):
+            yield chunk

agents/code/state_diagram_generator.py

@@ -0,0 +1,40 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class StateDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate PlantUML code for a state diagram based on the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+        Entities: {entities_classes}
+
+        Instructions:
+        1. Show the state transitions for one key entity
+        2. Include states, transitions, and events
+        3. Use standard PlantUML state diagram syntax
+        4. Don't include any explanation, just the PlantUML code
+
+        Example format (DO NOT TREAT THIS AS VARIABLES):
+        '''plantuml
+        @startuml
+        [*] --> State1
+        State1 --> State2 : Event1
+        State2 --> [*]
+        @enduml
+        '''
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="state_diagram",
+            step_name="generate_state_diagram",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            entities_classes=state["entities_classes"]
+        ):
+            yield chunk

agents/code/timing_diagram_generator.py

@@ -0,0 +1,45 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class TimingDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate PlantUML code for a timing diagram based on the following project:
+
+        Project: {project_name}
+        Description: {project_description}
+        Sequence: {sequence_interactions}
+
+        Instructions:
+        1. Show the timing constraints between components
+        2. Include lifelines and state changes over time
+        3. Use standard PlantUML timing diagram syntax
+        4. Don't include any explanation, just the PlantUML code
+
+        Example format (DO NOT TREAT THIS AS VARIABLES):
+        '''plantuml
+        @startuml
+        clock "Clock" as C with period 1
+        binary "Signal" as S
+        @0
+        S is low
+        @5
+        S is high
+        @10
+        S is low
+        @enduml
+        '''
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="timing_diagram",
+            step_name="generate_timing_diagram",
+            project_name=state["project_name"],
+            project_description=state["project_description"],
+            sequence_interactions=state["sequence_interactions"]
+        ):
+            yield chunk

agents/code/use_case_diagram_generator.py

@@ -0,0 +1,69 @@
+from base_agent import BaseAgent
+from models import AgentState
+from typing import AsyncGenerator
+import json
+
+class UseCaseDiagramGenerator(BaseAgent):
+    async def __call__(self, state: AgentState) -> AsyncGenerator[str, None]:
+        prompt_template = """
+        Generate comprehensive PlantUML code for a use case diagram based on:
+        
+        Project: {project_name}
+        Actors and Use Cases: {actors_use_cases}
+
+        Instructions:
+        1. Include all actors with proper typing:
+           - Primary actors on left
+           - Supporting actors on right
+           - System actors if applicable
+        2. Organize use cases into logical packages/subsystems when appropriate
+        3. Use proper relationship types:
+           - Association: --> (actor to use case)
+           - Include: .> (base use case includes another)
+           - Extend: .> (use case extends another with conditions)
+        4. Apply stereotypes where helpful (<<system>>, <<external>>, etc.)
+        5. Include notes for complex relationships when needed
+        6. Use left-to-right direction for better readability
+        7. Format with clear alignment and spacing
+        8. Include only raw PlantUML code without explanations
+
+        Example Structure (DO NOT TREAT AS VARIABLES):
+        @startuml
+        left to right direction
+        skinparam packageStyle rectangle
+        
+        actor "Primary Actor" <<Human>> as user
+        actor "Supporting System" <<System>> as legacy
+        
+        rectangle "Order Processing" {{
+          usecase "Place Order" as UC1
+          usecase "Process Payment" as UC2
+          usecase "Validate Order" as UC3
+          
+          UC1 .> UC2 : include
+          UC1 .> UC3 : include
+        }}
+        
+        rectangle "Inventory" {{
+          usecase "Check Stock" as UC4
+        }}
+        
+        user --> UC1
+        legacy --> UC3
+        
+        note right of UC1 
+          This use case initiates the 
+          order fulfillment workflow
+        end note
+        @enduml
+        """
+
+        async for chunk in self._stream_process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="use_case_diagram",
+            step_name="generate_use_case_diagram",
+            actors_use_cases=state["actors_use_cases"],
+            project_name=state["project_name"]
+        ):
+            yield chunk

app.py

@@ -0,0 +1,68 @@
+from flask import Flask, jsonify, render_template, request, Response, stream_with_context
+from research_generator import ResearchGenerator
+import asyncio
+import json
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+
+app = Flask(__name__)
+generator = ResearchGenerator()
+
+@app.route('/')
+def index():
+    return render_template('index.html')
+
+async def process_state(state):
+    if "index" in state and state["index"]:
+        # If we have an index, process it with the LLM
+        prompt = ChatPromptTemplate.from_template("""
+        Process the following research state:
+        {state}
+        """)
+        chain = prompt | generator.llm | StrOutputParser()
+        
+        async for chunk in chain.astream({"state": json.dumps(state)}):
+            yield f"data: {json.dumps({'chunk': chunk, 'state': state})}\n\n"
+    else:
+        # If we're generating the index, stream it directly
+        yield f"data: {json.dumps({'state': state})}\n\n"
+
+@app.route('/generate', methods=['POST'])
+def generate_research():
+    data = request.get_json()
+    subject = data.get('subject')
+    if not subject:
+        return jsonify({'error': 'Subject is required'}), 400
+
+    async def generate():
+        generator = ResearchGenerator()
+        async for state in generator.astream({
+            "subject": subject,
+            "index": [],
+            "content": {},
+            "current_step": 0
+        }):
+            async for chunk in process_state(state):
+                yield chunk
+
+    def sync_generate():
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            async_gen = generate()
+            while True:
+                try:
+                    chunk = loop.run_until_complete(async_gen.__anext__())
+                    yield chunk
+                except StopAsyncIteration:
+                    break
+        finally:
+            loop.close()
+
+    return Response(
+        stream_with_context(sync_generate()),
+        mimetype='text/event-stream'
+    )
+
+if __name__ == '__main__':
+    app.run(debug=True) 

base_agent.py

@@ -0,0 +1,46 @@
+import json
+from typing import Dict, Generator, AsyncGenerator
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.callbacks import StreamingStdOutCallbackHandler
+from config import Config
+from logger import Logger
+from file_manager import FileManager
+from models import AgentState
+from langchain_ollama import OllamaLLM
+from langchain_core.runnables import RunnableConfig
+from langchain_core.output_parsers import StrOutputParser
+
+class BaseAgent:
+    def __init__(self):
+        self.config = Config()
+        self.logger = Logger()
+        self.file_manager = FileManager()
+        
+        # Set up callbacks based on streaming config
+        callbacks = [StreamingStdOutCallbackHandler()] if self.config.streaming else None
+        
+        self.llm = OllamaLLM(
+            model=self.config.ollama_model,
+            base_url=self.config.ollama_base_url,
+            temperature=self.config.temperature,
+            top_p=self.config.top_p,
+            callbacks=callbacks,
+        
+        )
+        
+    async def _stream_process(self, state: AgentState, prompt_template: str, output_key: str, step_name: str, **kwargs) -> AsyncGenerator[str, None]:
+        prompt = ChatPromptTemplate.from_template(prompt_template)
+        chain = prompt | self.llm | StrOutputParser()
+
+        # Use stream method to get partial chunks
+        async for chunk in chain.astream(kwargs):
+            yield json.dumps({output_key: chunk})
+    
+    async def _process(self, state: AgentState, prompt_template: str, 
+                output_key: str, step_name: str, **kwargs) -> Dict:
+        prompt = ChatPromptTemplate.from_template(prompt_template)
+        chain = prompt | self.llm
+        
+        result = await chain.ainvoke(kwargs)
+     
+        return {output_key: result} 

config.py

@@ -0,0 +1,25 @@
+from dotenv import load_dotenv
+import os
+from enum import Enum
+
+load_dotenv()
+
+class DiagramType(Enum):
+    CLASS = 1
+    USE_CASE = 2
+    SEQUENCE = 3
+    OBJECT = 4
+    ACTIVITY = 5
+    COMPONENT = 6
+    DEPLOYMENT = 7
+    STATE = 8
+    TIMING = 9
+
+class Config:
+    def __init__(self):
+        self.ollama_model = os.getenv("OLLAMA_MODEL", "llama3.3:70b")
+        self.ollama_base_url = os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
+        self.temperature = float(os.getenv("TEMPERATURE", "0.7"))
+        self.top_p = float(os.getenv("TOP_P", "0.9"))
+        self.streaming = True#os.getenv("STREAMING", "false").lower() == "true"
+        self.callbacks = None

d.sh

@@ -0,0 +1,3 @@
+git add .
+git commit -m "Add application file"
+git push

file_manager.py

@@ -0,0 +1,106 @@
+import os
+from datetime import datetime
+from typing import Dict
+import subprocess
+
+class FileManager:
+    def __init__(self):
+        self.output_base = "output"
+        
+    def create_output_dir(self, project_name: str, timestamp: str) -> str:
+        """Create output directory structure for this run."""
+        dir_name = f"{project_name}_{timestamp}"
+        output_dir = os.path.join(self.output_base, dir_name)
+        
+        # Create main directories
+        os.makedirs(output_dir, exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "code"), exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "analysis"), exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "images"), exist_ok=True)
+        
+        return output_dir
+    
+    def save_step_result(self, output_dir: str, step_name: str, content: str):
+        """Save intermediate step result with clean PlantUML code."""
+        ext = ".pu" if "diagram" in step_name else ".md"
+        
+        # Determine target directory based on file type
+        if ext == ".pu":
+            target_dir = os.path.join(output_dir, "code")
+            # Render PlantUML diagram
+            self._render_plantuml(content, output_dir, step_name)
+        else:
+            target_dir = os.path.join(output_dir, "analysis")
+            
+        filename = f"{step_name}{ext}"
+        filepath = os.path.join(target_dir, filename)
+        
+        print(f"Saving {filename} to {target_dir}")  # Add this line for debugging
+        
+        # Clean PlantUML code by removing markdown code block markers
+        if ext == ".pu":
+            content = self._clean_plantuml_content(content)
+        
+        with open(filepath, "w") as f:
+            f.write(content)
+
+    def _render_plantuml(self, content: str, output_dir: str, step_name: str):
+        """Render PlantUML diagram to PNG."""
+        # Clean the content first
+        content = self._clean_plantuml_content(content)
+        
+        # Create temporary .pu file
+        temp_pu = os.path.join(output_dir, "code", f"{step_name}.pu")
+        with open(temp_pu, "w") as f:
+            f.write(content)
+        
+        # Render to PNG
+        output_png = os.path.join(output_dir, "images", f"{step_name}.png")
+        try:
+            subprocess.run([
+                "plantuml", 
+                "-tpng",
+                temp_pu,
+                "-o",  "images"
+            ], check=True)
+        except subprocess.CalledProcessError as e:
+            print(f"Error rendering PlantUML diagram: {e}")
+        except FileNotFoundError:
+            print("PlantUML not found. Please install PlantUML to generate images.")
+
+    def _clean_plantuml_content(self, content: str) -> str:
+        """Remove triple quotes and plantuml markers from the content."""
+        # Remove '''plantuml and ''' markers
+        content = content.replace("'''plantuml", "").replace("'''", "")
+        content = content.replace("```plantuml", "").replace("```", "")
+        
+        
+        # Remove any remaining leading/trailing whitespace
+        content = content.strip()
+        
+        return content
+    
+    def save_final_results(self, state: Dict):
+        """Save all final results."""
+        output_dir = state["output_dir"]
+        
+        # Save all analysis results and diagram codes
+        for key, value in state.items():
+            # Skip metadata fields
+            if key in ["project_name", "project_description", "output_dir", "selected_diagrams"]:
+                continue
+            
+            if value:  # Only save if there's content
+                self.save_step_result(output_dir, key, value)
+        
+        # Save metadata
+        metadata = {
+            "project_name": state["project_name"],
+            "project_description": state["project_description"],
+            "generated_diagrams": state["selected_diagrams"],
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        import json
+        with open(os.path.join(output_dir, "metadata.json"), "w") as f:
+            json.dump(metadata, f, indent=2)

logger.py

@@ -0,0 +1,26 @@
+class Logger:
+    def __init__(self):
+        self.verbose = True
+    
+    def log(self, message: str):
+        if self.verbose:
+            print(message)
+    
+    def log_title(self, title: str):
+        if self.verbose:
+            print(f"\n{'='*40}")
+            print(f"{title.center(40)}")
+            print(f"{'='*40}")
+    
+    def log_step(self, step_name: str):
+        if self.verbose:
+            print(f"\n{'='*40}")
+            print(f"STEP: {step_name.upper().replace('_', ' ')}")
+            print(f"{'='*40}")
+    
+    def log_success(self, message: str):
+        if self.verbose:
+            print(f"\n✅ {message}")
+    
+    def log_error(self, message: str):
+        print(f"\n❌ ERROR: {message}")

main.py

@@ -0,0 +1,153 @@
+from logging import Logger
+import os
+from datetime import datetime
+from typing import Dict, List, Optional
+from dotenv import load_dotenv
+from langchain_ollama import OllamaLLM
+from langgraph.graph import END, StateGraph
+from models import AgentState, DiagramType
+from config import Config
+from langchain_core.prompts import ChatPromptTemplate
+from file_manager import FileManager
+from agents.analysis import (
+    EntitiesAnalysis,
+    ActorsAnalysis,
+    SequenceAnalysis,
+    StateAnalysis,
+    ArchitectureAnalysis,
+    DeploymentAnalysis
+)
+from agents.code import (
+    ClassDiagramGenerator,
+    UseCaseDiagramGenerator,
+    SequenceDiagramGenerator,
+    ActivityDiagramGenerator,
+    ComponentDiagramGenerator,
+    DeploymentDiagramGenerator,
+    StateDiagramGenerator,
+    TimingDiagramGenerator,
+    ObjectDiagramGenerator
+)
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import StreamingResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import asyncio
+from langchain_core.callbacks import StreamingStdOutCallbackHandler
+import json
+
+# Load environment variables
+load_dotenv()
+
+# Initialize FastAPI app
+app = FastAPI()
+
+# Add CORS middleware configuration
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# Request model
+class DiagramRequest(BaseModel):
+    project_name: str
+    project_description: str
+    selected_diagrams: List[int]
+    output_dir: Optional[str] = "output"
+
+
+
+
+@app.post("/generate-diagrams")
+async def generate_diagrams(request: DiagramRequest):
+    try:
+        initial_state = AgentState(
+            project_name=request.project_name,
+            project_description=request.project_description,
+            output_dir=request.output_dir,
+            selected_diagrams=request.selected_diagrams,
+            entities_classes="",
+            actors_use_cases="",
+            sequence_interactions="",
+            class_diagram="",
+            use_case_diagram="",
+            sequence_diagram="",
+            activity_diagram="",
+            component_diagram="",
+            deployment_diagram="",
+            state_diagram="",
+            timing_diagram="",
+            object_diagram=""
+        )
+
+    
+        diagram_requirements = {
+            DiagramType.CLASS: ["extract_entities"],
+            DiagramType.USE_CASE: ["extract_actors"],
+            DiagramType.SEQUENCE: ["extract_actors", "extract_sequence"],
+            DiagramType.OBJECT: ["extract_entities"],
+            DiagramType.ACTIVITY: ["extract_actors"],
+            DiagramType.COMPONENT: ["extract_entities", "extract_architecture"],
+            DiagramType.DEPLOYMENT: ["extract_architecture", "extract_deployment"],
+            DiagramType.STATE: ["extract_entities", "extract_sequence", "extract_states"],
+            DiagramType.TIMING: ["extract_sequence"]
+        }
+
+       
+        analysis_functions = {
+            "extract_entities": EntitiesAnalysis(),
+            "extract_actors": ActorsAnalysis(),
+            "extract_sequence": SequenceAnalysis(),
+            "extract_states": StateAnalysis(),
+            "extract_architecture": ArchitectureAnalysis(),
+            "extract_deployment": DeploymentAnalysis()
+        }
+
+        generation_functions = {
+            DiagramType.CLASS: ("generate_class", ClassDiagramGenerator()),
+            DiagramType.USE_CASE: ("generate_use_case", UseCaseDiagramGenerator()),
+            DiagramType.SEQUENCE: ("generate_sequence", SequenceDiagramGenerator()),
+            DiagramType.ACTIVITY: ("generate_activity", ActivityDiagramGenerator()),
+            DiagramType.COMPONENT: ("generate_component", ComponentDiagramGenerator()),
+            DiagramType.DEPLOYMENT: ("generate_deployment", DeploymentDiagramGenerator()),
+            DiagramType.STATE: ("generate_state", StateDiagramGenerator()),
+            DiagramType.TIMING: ("generate_timing", TimingDiagramGenerator()),
+            DiagramType.OBJECT: ("generate_object", ObjectDiagramGenerator())
+        }
+
+      
+        selected_types = [DiagramType(d) for d in request.selected_diagrams]
+        added_analysis_steps = set()
+        steps = []
+
+        for diagram_type in selected_types:
+            required_analysis = diagram_requirements.get(diagram_type, [])
+            for step in required_analysis:
+                if step not in added_analysis_steps:
+                    steps.append((step, analysis_functions[step]))
+                    added_analysis_steps.add(step)
+
+            if diagram_type in generation_functions:
+                steps.append(generation_functions[diagram_type])
+
+       
+        async def event_stream():
+            for step_name, step_func in steps:
+                # Determine if it's an analysis step or generation step
+                step_type = "analysis" if step_name in analysis_functions else "generation"
+                # Determine file extension based on step type
+                file_ext = "pu" if step_type == "generation" else "md"
+                yield f'data: {{"type": "step", "step_type": "{step_type}", "file_name": "{step_name}.{file_ext}"}}\n\n'
+                async for chunk in step_func(initial_state):
+                    yield f"data: {chunk}\n\n"
+
+        return StreamingResponse(event_stream(), media_type="text/event-stream")
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+

models.py

@@ -0,0 +1,31 @@
+from typing import TypedDict, List
+from enum import Enum
+
+class DiagramType(Enum):
+    CLASS = 1
+    USE_CASE = 2
+    SEQUENCE = 3
+    OBJECT = 4
+    ACTIVITY = 5
+    COMPONENT = 6
+    DEPLOYMENT = 7
+    STATE = 8
+    TIMING = 9
+
+class AgentState(TypedDict):
+    project_name: str
+    project_description: str
+    output_dir: str
+    selected_diagrams: List[int]
+    entities_classes: str
+    actors_use_cases: str
+    sequence_interactions: str
+    class_diagram: str
+    use_case_diagram: str
+    sequence_diagram: str
+    activity_diagram: str
+    component_diagram: str
+    deployment_diagram: str
+    state_diagram: str
+    timing_diagram: str
+    object_diagram: str

requirements.txt

@@ -0,0 +1,8 @@
+langgraph
+langchain-community
+langchain-core
+pydantic
+python-dotenv
+langchain-ollama
+fastapi
+uvicorn

research_generator.py

@@ -0,0 +1,202 @@
+from typing import Dict, List, TypedDict
+from langgraph.graph import StateGraph, END
+from base_agent import BaseAgent
+from models import AgentState
+import os
+from datetime import datetime
+import json
+
+class ResearchState(TypedDict):
+    subject: str
+    index: List[str]
+    content: Dict[str, str]
+    current_step: int
+
+class ResearchGenerator(BaseAgent):
+    def __init__(self):
+        super().__init__()
+        self.workflow = self._create_workflow()
+        self.output_dir = "research_output"
+        os.makedirs(self.output_dir, exist_ok=True)
+        self.timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        self.research_dir = f"{self.output_dir}/research_{self.timestamp}"
+        os.makedirs(self.research_dir, exist_ok=True)
+
+    def _create_workflow(self):
+        # Create the graph
+        workflow = StateGraph(ResearchState)
+
+        # Add nodes
+        workflow.add_node("generate_index", self._generate_index)
+        workflow.add_node("generate_content", self._generate_content)
+        workflow.add_node("check_completion", self._check_completion)
+
+        # Add edges
+        workflow.add_edge("generate_index", "generate_content")
+        workflow.add_edge("generate_content", "check_completion")
+        workflow.add_conditional_edges(
+            "check_completion",
+            self._should_continue,
+            {
+                True: "generate_content",
+                False: END
+            }
+        )
+
+        # Set entry point
+        workflow.set_entry_point("generate_index")
+
+        return workflow.compile()
+
+    def _save_step(self, state: ResearchState, step_name: str, content: str):
+        """Save individual step content to a file"""
+        filename = f"{self.research_dir}/{step_name}.md"
+        with open(filename, 'w', encoding='utf-8') as f:
+            f.write(content)
+        print(f"Saved {step_name} to: {filename}")
+
+    def _save_final_markdown(self, state: ResearchState):
+        """Save the complete research in a single markdown file"""
+        filename = f"{self.research_dir}/complete_research.md"
+        
+        with open(filename, 'w', encoding='utf-8') as f:
+            # Write title
+            f.write(f"# {state['subject']}\n\n")
+            
+            # Write index
+            f.write("## الفهرس\n\n")
+            for item in state['index']:
+                f.write(f"{item}\n")
+            f.write("\n")
+            
+            # Write content
+            f.write("## المحتوى\n\n")
+            for topic, content in state['content'].items():
+                f.write(f"### {topic}\n\n")
+                f.write(f"{content}\n\n")
+                f.write("---\n\n")
+        
+        return filename
+
+    async def _generate_index(self, state: ResearchState) -> Dict:
+        prompt_template = """
+        Create a detailed research index for the following subject:
+
+        Subject: {subject}
+
+        Instructions:
+        1. Create a comprehensive list of topics and subtopics
+        2. Organize them in a logical order
+        3. Include main sections and subsections
+        4. Format as a numbered list
+
+        Example format:
+        1. Main Topic 1
+           1.1 Subtopic 1.1
+           1.2 Subtopic 1.2
+        2. Main Topic 2
+           2.1 Subtopic 2.1
+           2.2 Subtopic 2.2
+        """
+
+        result = await self._process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="index",
+            step_name="research index",
+            subject=state["subject"]
+        )
+
+        # Save index immediately
+        index_content = f"# {state['subject']}\n\n## الفهرس\n\n{result['index']}"
+        self._save_step(state, "index", index_content)
+
+        return {"index": result["index"].split("\n"), "current_step": 0}
+
+    async def _generate_content(self, state: ResearchState) -> Dict:
+        current_topic = state["index"][state["current_step"]]
+        
+        prompt_template = """
+        Generate detailed content for the following research topic:
+
+        Subject: {subject}
+        Topic: {current_topic}
+
+        Instructions:
+        1. Provide comprehensive information about the topic
+        2. Include relevant examples and explanations
+        3. Use clear and academic language
+        4. Structure the content with proper paragraphs
+        5. Include key points and supporting details
+        """
+
+        result = await self._process(
+            state=state,
+            prompt_template=prompt_template,
+            output_key="content",
+            step_name=f"content for {current_topic}",
+            subject=state["subject"],
+            current_topic=current_topic
+        )
+
+        # Update content dictionary
+        content = state.get("content", {})
+        content[current_topic] = result["content"]
+
+        # Save this topic's content immediately
+        topic_content = f"### {current_topic}\n\n{result['content']}"
+        self._save_step(state, f"topic_{state['current_step']}", topic_content)
+
+        return {
+            "content": content,
+            "current_step": state["current_step"] + 1
+        }
+
+    def _check_completion(self, state: ResearchState) -> Dict:
+        return state
+
+    def _should_continue(self, state: ResearchState) -> bool:
+        return state["current_step"] < len(state["index"])
+
+    async def generate_research(self, subject: str) -> Dict:
+        initial_state = {
+            "subject": subject,
+            "index": [],
+            "content": {},
+            "current_step": 0
+        }
+        
+        result = await self.workflow.ainvoke(initial_state)
+        
+        # Save final complete research
+        filename = self._save_final_markdown(result)
+        print(f"\nComplete research saved to: {filename}")
+        
+        return result
+
+    async def astream(self, initial_state: ResearchState):
+        """Stream the workflow execution state."""
+        async for state in self.workflow.astream(initial_state):
+            yield state
+
+# Example usage
+if __name__ == "__main__":
+    import asyncio
+    
+    async def main():
+        generator = ResearchGenerator()
+        research = await generator.generate_research("الذكاء الاصطناعي والاستثمار")
+        
+        # Print summary
+        print("\n=== البحث المولد ===\n")
+        print("\n=== الفهرس ===")
+        for item in research["index"]:
+            print(item.strip())
+        
+        print("\n=== المحتوى ===")
+        for topic, content in research["content"].items():
+            print(f"\n{topic.strip()}:")
+            print(content.strip())
+            print("-" * 50)
+
+    asyncio.run(main())