vibe-aigc 0.1.1__tar.gz → 0.2.0__tar.gz

{vibe_aigc-0.1.1/vibe_aigc.egg-info → vibe_aigc-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vibe-aigc
-Version: 0.1.1
+Version: 0.2.0
 Summary: A New Paradigm for Content Generation via Agentic Orchestration
 Author: Vibe AIGC Contributors
 License-Expression: MIT
@@ -69,9 +69,35 @@ planner = MetaPlanner()
 result = await planner.execute(vibe)
 ```
 
+## Architecture (Paper Section 5)
+
+The implementation follows the paper's three-part architecture:
+
+| Component | Purpose | Module |
+|-----------|---------|--------|
+| **MetaPlanner** | Decomposes Vibes into workflows | `vibe_aigc.planner` |
+| **KnowledgeBase** | Domain expertise for intent understanding | `vibe_aigc.knowledge` |
+| **ToolRegistry** | Atomic tools for content generation | `vibe_aigc.tools` |
+
+```python
+from vibe_aigc import MetaPlanner, Vibe, create_knowledge_base, create_default_registry
+
+# The full architecture
+kb = create_knowledge_base()  # Film, writing, design, music knowledge
+tools = create_default_registry()  # LLM, templates, combine tools
+
+planner = MetaPlanner(knowledge_base=kb, tool_registry=tools)
+
+# Query knowledge for "Hitchcockian suspense" → technical specs
+result = kb.query("Hitchcockian suspense")
+# Returns: camera techniques, lighting specs, editing patterns
+```
+
 ## Features
 
 - 🎯 **Vibe-based Planning** — High-level intent → executable workflows
+- 🧠 **Domain Knowledge** — Built-in expertise for film, writing, design, music
+- 🔧 **Tool Library** — Pluggable tools for actual content generation
 - ⚡ **Parallel Execution** — Independent nodes run concurrently
 - 🔄 **Adaptive Replanning** — Automatic recovery from failures
 - 💾 **Checkpoint/Resume** — Save and restore workflow state

{vibe_aigc-0.1.1 → vibe_aigc-0.2.0}/README.md

@@ -34,9 +34,35 @@ planner = MetaPlanner()
 result = await planner.execute(vibe)
 ```
 
+## Architecture (Paper Section 5)
+
+The implementation follows the paper's three-part architecture:
+
+| Component | Purpose | Module |
+|-----------|---------|--------|
+| **MetaPlanner** | Decomposes Vibes into workflows | `vibe_aigc.planner` |
+| **KnowledgeBase** | Domain expertise for intent understanding | `vibe_aigc.knowledge` |
+| **ToolRegistry** | Atomic tools for content generation | `vibe_aigc.tools` |
+
+```python
+from vibe_aigc import MetaPlanner, Vibe, create_knowledge_base, create_default_registry
+
+# The full architecture
+kb = create_knowledge_base()  # Film, writing, design, music knowledge
+tools = create_default_registry()  # LLM, templates, combine tools
+
+planner = MetaPlanner(knowledge_base=kb, tool_registry=tools)
+
+# Query knowledge for "Hitchcockian suspense" → technical specs
+result = kb.query("Hitchcockian suspense")
+# Returns: camera techniques, lighting specs, editing patterns
+```
+
 ## Features
 
 - 🎯 **Vibe-based Planning** — High-level intent → executable workflows
+- 🧠 **Domain Knowledge** — Built-in expertise for film, writing, design, music
+- 🔧 **Tool Library** — Pluggable tools for actual content generation
 - ⚡ **Parallel Execution** — Independent nodes run concurrently
 - 🔄 **Adaptive Replanning** — Automatic recovery from failures
 - 💾 **Checkpoint/Resume** — Save and restore workflow state

{vibe_aigc-0.1.1 → vibe_aigc-0.2.0}/pyproject.toml

@@ -8,7 +8,7 @@ exclude = ["tests*", "docs*", "examples*", "landing*"]
 
 [project]
 name = "vibe-aigc"
-version = "0.1.1"
+version = "0.2.0"
 description = "A New Paradigm for Content Generation via Agentic Orchestration"
 authors = [{name = "Vibe AIGC Contributors"}]
 license = "MIT"

{vibe_aigc-0.1.1 → vibe_aigc-0.2.0}/tests/test_adaptive_replanning.py

@@ -282,7 +282,7 @@ class TestAdaptiveReplanning:
         ]
 
         plan_call_count = 0
-        async def plan_side_effect(vibe):
+        async def plan_side_effect(vibe, knowledge_context=None, tools_context=None):
             nonlocal plan_call_count
             result = plans[min(plan_call_count, len(plans) - 1)]
             plan_call_count += 1

vibe_aigc-0.2.0/tests/test_agents.py

@@ -0,0 +1,231 @@
+"""Tests for Specialized Agent Framework."""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+
+from vibe_aigc.agents import (
+    BaseAgent,
+    AgentRole,
+    AgentContext,
+    AgentResult,
+    AgentRegistry,
+    WriterAgent,
+    ResearcherAgent,
+    EditorAgent,
+    DirectorAgent,
+    DesignerAgent,
+    ScreenwriterAgent,
+    ComposerAgent,
+    create_default_agents
+)
+from vibe_aigc.tools import ToolRegistry, ToolResult
+
+
+class TestAgentContext:
+    """Test AgentContext class."""
+    
+    def test_create_context(self):
+        ctx = AgentContext(
+            task="Write a blog post",
+            vibe_description="Technical but accessible",
+            style="informative",
+            constraints=["under 1000 words"]
+        )
+        
+        assert ctx.task == "Write a blog post"
+        assert ctx.style == "informative"
+        assert len(ctx.constraints) == 1
+
+
+class TestAgentResult:
+    """Test AgentResult class."""
+    
+    def test_success_result(self):
+        result = AgentResult(
+            success=True,
+            output="Generated content",
+            artifacts={"image": "url"},
+            messages=["Completed"]
+        )
+        
+        assert result.success
+        assert result.output == "Generated content"
+        assert "image" in result.artifacts
+    
+    def test_to_dict(self):
+        result = AgentResult(success=True, output="test")
+        d = result.to_dict()
+        
+        assert d["success"] is True
+        assert d["output"] == "test"
+
+
+class TestWriterAgent:
+    """Test WriterAgent."""
+    
+    def test_creation(self):
+        agent = WriterAgent()
+        
+        assert agent.name == "Writer"
+        assert agent.role == AgentRole.WRITER
+        assert "llm_generate" in agent._capabilities
+    
+    @pytest.mark.asyncio
+    async def test_execute_without_registry(self):
+        agent = WriterAgent()
+        ctx = AgentContext(task="Write something", vibe_description="Test")
+        
+        result = await agent.execute(ctx)
+        
+        assert not result.success
+        assert "No tool registry" in result.messages[0]
+    
+    @pytest.mark.asyncio
+    async def test_execute_with_mock_registry(self):
+        # Create mock registry
+        mock_registry = MagicMock(spec=ToolRegistry)
+        mock_tool = AsyncMock()
+        mock_tool.execute.return_value = ToolResult(
+            success=True,
+            output={"text": "Generated text", "tokens_used": 100}
+        )
+        mock_registry.get.return_value = mock_tool
+        
+        agent = WriterAgent(tool_registry=mock_registry)
+        ctx = AgentContext(task="Write a haiku", vibe_description="Peaceful")
+        
+        result = await agent.execute(ctx)
+        
+        assert result.success
+        assert "Generated text" in result.output
+
+
+class TestResearcherAgent:
+    """Test ResearcherAgent."""
+    
+    def test_creation(self):
+        agent = ResearcherAgent()
+        
+        assert agent.role == AgentRole.RESEARCHER
+        assert "search" in agent._capabilities
+
+
+class TestEditorAgent:
+    """Test EditorAgent."""
+    
+    def test_creation(self):
+        agent = EditorAgent()
+        
+        assert agent.role == AgentRole.EDITOR
+    
+    @pytest.mark.asyncio
+    async def test_execute_without_content(self):
+        mock_registry = MagicMock(spec=ToolRegistry)
+        mock_registry.get.return_value = None
+        
+        agent = EditorAgent(tool_registry=mock_registry)
+        ctx = AgentContext(task="Edit", vibe_description="Test")
+        
+        result = await agent.execute(ctx)
+        
+        assert not result.success
+        assert "No content" in result.messages[0]
+
+
+class TestDirectorAgent:
+    """Test DirectorAgent."""
+    
+    def test_add_managed_agent(self):
+        director = DirectorAgent()
+        writer = WriterAgent()
+        
+        director.add_agent(writer)
+        
+        assert "Writer" in director._managed_agents
+
+
+class TestDesignerAgent:
+    """Test DesignerAgent."""
+    
+    def test_creation(self):
+        agent = DesignerAgent()
+        
+        assert agent.role == AgentRole.DESIGNER
+        assert "image_generate" in agent._capabilities
+
+
+class TestScreenwriterAgent:
+    """Test ScreenwriterAgent."""
+    
+    def test_creation(self):
+        agent = ScreenwriterAgent()
+        
+        assert agent.role == AgentRole.SCREENWRITER
+
+
+class TestComposerAgent:
+    """Test ComposerAgent."""
+    
+    def test_creation(self):
+        agent = ComposerAgent()
+        
+        assert agent.role == AgentRole.COMPOSER
+        assert "audio_generate" in agent._capabilities
+
+
+class TestAgentRegistry:
+    """Test AgentRegistry."""
+    
+    def test_register_and_get(self):
+        registry = AgentRegistry()
+        agent = WriterAgent()
+        
+        registry.register(agent)
+        
+        assert registry.get("Writer") == agent
+    
+    def test_find_by_role(self):
+        registry = AgentRegistry()
+        registry.register(WriterAgent())
+        registry.register(EditorAgent())
+        
+        writers = registry.find_by_role(AgentRole.WRITER)
+        
+        assert len(writers) == 1
+        assert writers[0].role == AgentRole.WRITER
+    
+    def test_list_agents(self):
+        registry = AgentRegistry()
+        registry.register(WriterAgent())
+        registry.register(EditorAgent())
+        
+        names = registry.list_agents()
+        
+        assert "Writer" in names
+        assert "Editor" in names
+    
+    def test_create_team(self):
+        registry = AgentRegistry()
+        registry.register(WriterAgent())
+        registry.register(EditorAgent())
+        registry.register(DirectorAgent())
+        
+        team = registry.create_team([AgentRole.WRITER, AgentRole.EDITOR])
+        
+        assert AgentRole.WRITER in team
+        assert AgentRole.EDITOR in team
+
+
+class TestCreateDefaultAgents:
+    """Test create_default_agents factory."""
+    
+    def test_creates_all_agents(self):
+        registry = create_default_agents()
+        
+        assert registry.get("Writer") is not None
+        assert registry.get("Researcher") is not None
+        assert registry.get("Editor") is not None
+        assert registry.get("Director") is not None
+        assert registry.get("Designer") is not None
+        assert registry.get("Screenwriter") is not None
+        assert registry.get("Composer") is not None

vibe_aigc-0.2.0/tests/test_assets.py

@@ -0,0 +1,291 @@
+"""Tests for Asset Bank."""
+
+import pytest
+import tempfile
+import shutil
+from pathlib import Path
+
+from vibe_aigc.assets import (
+    AssetBank,
+    Character,
+    StyleGuide,
+    Artifact,
+    create_asset_bank
+)
+
+
+class TestCharacter:
+    """Test Character class."""
+    
+    def test_create_character(self):
+        char = Character(
+            id="char-001",
+            name="Alice",
+            description="A curious adventurer",
+            visual_description="Young woman, brown hair, blue eyes",
+            personality="Curious, brave, kind"
+        )
+        
+        assert char.name == "Alice"
+        assert char.id == "char-001"
+    
+    def test_to_prompt_context(self):
+        char = Character(
+            id="char-001",
+            name="Bob",
+            description="A wise mentor",
+            visual_description="Elderly man with white beard",
+            color_palette=["#333", "#gold"]
+        )
+        
+        context = char.to_prompt_context()
+        
+        assert "Bob" in context
+        assert "wise mentor" in context
+        assert "white beard" in context
+        assert "#333" in context
+
+
+class TestStyleGuide:
+    """Test StyleGuide class."""
+    
+    def test_create_style_guide(self):
+        style = StyleGuide(
+            id="style-001",
+            name="Cyberpunk",
+            description="Neon-lit dystopian future",
+            mood="dark, gritty",
+            aesthetic="high-tech low-life",
+            color_palette=["#ff00ff", "#00ffff", "#000"]
+        )
+        
+        assert style.name == "Cyberpunk"
+        assert style.mood == "dark, gritty"
+    
+    def test_to_prompt_context(self):
+        style = StyleGuide(
+            id="style-001",
+            name="Minimalist",
+            description="Clean and simple",
+            mood="calm",
+            aesthetic="modern",
+            aspect_ratio="16:9"
+        )
+        
+        context = style.to_prompt_context()
+        
+        assert "Minimalist" in context
+        assert "calm" in context
+        assert "16:9" in context
+
+
+class TestArtifact:
+    """Test Artifact class."""
+    
+    def test_create_artifact(self):
+        artifact = Artifact(
+            id="art-001",
+            type="image",
+            name="Hero Shot",
+            description="Main character portrait",
+            url="https://example.com/image.png"
+        )
+        
+        assert artifact.type == "image"
+        assert artifact.url is not None
+
+
+class TestAssetBank:
+    """Test AssetBank class."""
+    
+    @pytest.fixture
+    def temp_dir(self):
+        """Create temporary directory for tests."""
+        dir_path = tempfile.mkdtemp()
+        yield dir_path
+        shutil.rmtree(dir_path)
+    
+    def test_create_asset_bank(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        assert bank.storage_dir.exists()
+    
+    def test_add_and_get_character(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        char = Character(
+            id="char-001",
+            name="Test Character",
+            description="A test"
+        )
+        bank.add_character(char)
+        
+        retrieved = bank.get_character("char-001")
+        
+        assert retrieved is not None
+        assert retrieved.name == "Test Character"
+    
+    def test_find_character_by_name(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        char = Character(id="c1", name="Alice", description="Test")
+        bank.add_character(char)
+        
+        found = bank.find_character("alice")  # Case insensitive
+        
+        assert found is not None
+        assert found.id == "c1"
+    
+    def test_list_characters(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        bank.add_character(Character(id="c1", name="A", description=""))
+        bank.add_character(Character(id="c2", name="B", description=""))
+        
+        chars = bank.list_characters()
+        
+        assert len(chars) == 2
+    
+    def test_update_character(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        char = Character(id="c1", name="Old Name", description="")
+        bank.add_character(char)
+        
+        bank.update_character("c1", {"name": "New Name"})
+        
+        updated = bank.get_character("c1")
+        assert updated.name == "New Name"
+    
+    def test_add_character_reference(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        char = Character(id="c1", name="Test", description="")
+        bank.add_character(char)
+        
+        bank.add_character_reference("c1", "https://example.com/ref.png")
+        
+        updated = bank.get_character("c1")
+        assert len(updated.reference_images) == 1
+    
+    def test_add_and_get_style_guide(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        style = StyleGuide(id="s1", name="Test Style", description="")
+        bank.add_style_guide(style)
+        
+        retrieved = bank.get_style_guide("s1")
+        
+        assert retrieved is not None
+        assert retrieved.name == "Test Style"
+    
+    def test_store_and_get_artifact(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        artifact = Artifact(
+            id="a1",
+            type="image",
+            name="Test Image",
+            description="",
+            url="https://example.com/img.png"
+        )
+        bank.store_artifact(artifact)
+        
+        retrieved = bank.get_artifact("a1")
+        
+        assert retrieved is not None
+        assert retrieved.type == "image"
+    
+    def test_find_artifacts(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        bank.store_artifact(Artifact(id="a1", type="image", name="Img1", description="", related_character_id="c1"))
+        bank.store_artifact(Artifact(id="a2", type="image", name="Img2", description="", related_character_id="c1"))
+        bank.store_artifact(Artifact(id="a3", type="audio", name="Audio1", description=""))
+        
+        images = bank.find_artifacts(type="image")
+        char_images = bank.find_artifacts(character_id="c1")
+        
+        assert len(images) == 2
+        assert len(char_images) == 2
+    
+    def test_get_project_context(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        bank.add_character(Character(id="c1", name="Hero", description="Main character"))
+        bank.add_style_guide(StyleGuide(id="s1", name="Dark", description="Dark aesthetic"))
+        
+        context = bank.get_project_context()
+        
+        assert "Hero" in context
+        assert "Dark" in context
+    
+    def test_persistence(self, temp_dir):
+        # Create and populate bank
+        bank1 = AssetBank(storage_dir=temp_dir)
+        bank1.add_character(Character(id="c1", name="Persistent", description=""))
+        
+        # Create new bank from same directory
+        bank2 = AssetBank(storage_dir=temp_dir)
+        
+        # Should have loaded the character
+        assert bank2.get_character("c1") is not None
+        assert bank2.get_character("c1").name == "Persistent"
+    
+    def test_clear(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        bank.add_character(Character(id="c1", name="Test", description=""))
+        bank.clear()
+        
+        assert len(bank.list_characters()) == 0
+    
+    def test_create_character_convenience(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        char = bank.create_character(
+            name="Quick Character",
+            description="Created quickly",
+            visual_description="Generic look"
+        )
+        
+        assert char.id is not None
+        assert char.name == "Quick Character"
+        assert bank.get_character(char.id) is not None
+    
+    def test_create_style_guide_convenience(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        style = bank.create_style_guide(
+            name="Quick Style",
+            description="Created quickly",
+            mood="happy",
+            color_palette=["#fff", "#000"]
+        )
+        
+        assert style.id is not None
+        assert style.mood == "happy"
+    
+    def test_create_artifact_convenience(self, temp_dir):
+        bank = AssetBank(storage_dir=temp_dir)
+        
+        artifact = bank.create_artifact(
+            type="image",
+            name="Generated Image",
+            description="AI generated",
+            url="https://example.com/gen.png",
+            prompt_used="A beautiful sunset"
+        )
+        
+        assert artifact.id is not None
+        assert artifact.prompt_used == "A beautiful sunset"
+
+
+class TestCreateAssetBank:
+    """Test create_asset_bank factory."""
+    
+    def test_creates_bank(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            bank = create_asset_bank(storage_dir=temp_dir)
+            
+            assert isinstance(bank, AssetBank)