deepagents-printshop 0.1.0__py3-none-any.whl

agents/content_editor/__init__.py

@@ -0,0 +1 @@
+"""Content Editor Agent for DeepAgents PrintShop."""

agents/content_editor/agent.py

@@ -0,0 +1,279 @@
+"""
+Content Editor Agent - Milestone 1
+
+A specialized agent for improving grammar, readability, and overall content quality.
+Part of the DeepAgents PrintShop quality assurance system.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Tuple
+import json
+from datetime import datetime
+
+# Add project root to path
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+from agents.content_editor.content_reviewer import ContentReviewer
+
+
+class ContentEditorAgent:
+    """
+    Content Editor Agent with memory for improving research content quality.
+
+    This agent focuses on:
+    1. Grammar and spelling corrections
+    2. Readability improvements
+    3. Sentence structure optimization
+    4. Content flow and coherence
+    """
+
+    def __init__(self, memory_dir: str = ".deepagents/content_editor/memories", document_type: str = "research_report"):
+        """
+        Initialize the content editor agent.
+
+        Args:
+            memory_dir: Directory for storing agent memories
+            document_type: Type of document for pattern learning
+        """
+        self.memory_dir = Path(memory_dir)
+        self.memory_dir.mkdir(parents=True, exist_ok=True)
+        self.document_type = document_type
+        self.content_reviewer = ContentReviewer(document_type=document_type)
+
+        # Paths
+        self.input_dir = Path("artifacts/sample_content")
+        self.output_dir = Path("artifacts/reviewed_content/v1_content_edited")
+        self.reports_dir = Path("artifacts/agent_reports/quality")
+
+        # Ensure directories exist
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+        self.reports_dir.mkdir(parents=True, exist_ok=True)
+
+        # Initialize memory
+        self.init_memory()
+
+    def init_memory(self):
+        """Initialize agent memory files."""
+        memory_files = {
+            "grammar_rules.md": """# Grammar and Style Rules
+
+## Common Grammar Issues to Fix
+- Subject-verb agreement errors
+- Comma splices and run-on sentences
+- Misplaced modifiers
+- Inconsistent tense usage
+- Passive voice overuse
+
+## Style Guidelines
+- Use active voice when possible
+- Vary sentence length for readability
+- Avoid redundant phrases
+- Use precise, technical vocabulary
+- Maintain consistent terminology throughout
+
+## Academic Writing Standards
+- Third person perspective for research
+- Present tense for established facts
+- Past tense for specific studies conducted
+- Clear, concise sentences (15-20 words average)
+- Logical paragraph structure with topic sentences
+""",
+            "readability_patterns.md": """# Readability Improvement Patterns
+
+## Sentence Structure
+- Break long sentences (>25 words) into shorter ones
+- Use transitional phrases between ideas
+- Vary sentence beginnings to avoid monotony
+- Replace complex constructions with simpler alternatives
+
+## Word Choice
+- Replace vague terms with specific ones
+- Eliminate unnecessary jargon
+- Use strong verbs instead of weak verb + adverb combinations
+- Choose concrete nouns over abstract ones when possible
+
+## Flow and Coherence
+- Ensure each paragraph has a clear main idea
+- Use connecting words and phrases
+- Maintain logical progression of ideas
+- Eliminate redundant information
+""",
+            "quality_metrics.md": """# Content Quality Metrics
+
+## Grammar Score (0-100)
+- 0-20 errors: 90-100 points
+- 21-40 errors: 70-89 points
+- 41-60 errors: 50-69 points
+- 60+ errors: 0-49 points
+
+## Readability Score (0-100)
+- Based on Flesch Reading Ease
+- 90-100: Very Easy (Graduate level appropriate: 30-50)
+- 60-70: Standard (Target for academic writing)
+- 30-50: Difficult (Acceptable for technical content)
+- 0-30: Very Difficult (May need simplification)
+
+## Content Quality Indicators
+- Average sentence length: 15-20 words
+- Passive voice usage: <20%
+- Paragraph length: 3-5 sentences
+- Transition word usage: Present in 60%+ of sentences
+"""
+        }
+
+        for filename, content in memory_files.items():
+            file_path = self.memory_dir / filename
+            if not file_path.exists():
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(content)
+
+    def load_content(self, filename: str) -> str:
+        """Load content from the sample_content directory."""
+        file_path = self.input_dir / filename
+        if file_path.exists():
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        return ""
+
+    def save_content(self, filename: str, content: str):
+        """Save reviewed content to the output directory."""
+        file_path = self.output_dir / filename
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+
+    def review_content(self, content: str) -> Dict:
+        """
+        Review and improve content quality.
+
+        Args:
+            content: Original content text
+
+        Returns:
+            Dict with improved content and quality metrics
+        """
+        return self.content_reviewer.review_text(content)
+
+    def process_all_content(self) -> Dict:
+        """
+        Process all content files in the sample_content directory.
+
+        Returns:
+            Dict with processing results and overall quality improvements
+        """
+        print(f"📄 Document Type: {self.document_type}")
+        print(f"🧠 Pattern Learning: {'Enabled' if self.content_reviewer.pattern_injector else 'Disabled'}")
+        print()
+
+        results = {
+            "files_processed": [],
+            "overall_quality_improvement": 0,
+            "total_issues_fixed": 0,
+            "timestamp": datetime.now().isoformat()
+        }
+
+        # Process each markdown file
+        for file_path in self.input_dir.glob("*.md"):
+            print(f"Processing {file_path.name}...")
+
+            # Load original content
+            original_content = self.load_content(file_path.name)
+
+            # Review and improve content
+            review_result = self.review_content(original_content)
+
+            # Save improved content
+            self.save_content(file_path.name, review_result["improved_content"])
+
+            # Track results
+            file_result = {
+                "filename": file_path.name,
+                "original_quality_score": review_result["original_quality_score"],
+                "improved_quality_score": review_result["improved_quality_score"],
+                "quality_improvement": review_result["quality_improvement"],
+                "issues_fixed": len(review_result["changes_made"]),
+                "changes_summary": review_result["changes_summary"]
+            }
+
+            results["files_processed"].append(file_result)
+            results["total_issues_fixed"] += file_result["issues_fixed"]
+
+        # Calculate overall improvement
+        if results["files_processed"]:
+            avg_improvement = sum(f["quality_improvement"] for f in results["files_processed"]) / len(results["files_processed"])
+            results["overall_quality_improvement"] = round(avg_improvement, 2)
+
+        # Save processing report
+        self.save_report(results)
+
+        return results
+
+    def save_report(self, results: Dict):
+        """Save the content review report."""
+        report_path = self.reports_dir / "content_review_report.json"
+
+        with open(report_path, 'w', encoding='utf-8') as f:
+            json.dump(results, f, indent=2)
+
+        # Also create a human-readable markdown report
+        md_report_path = self.reports_dir / "content_review_report.md"
+        self.create_markdown_report(results, md_report_path)
+
+    def create_markdown_report(self, results: Dict, output_path: Path):
+        """Create a human-readable markdown report."""
+        report_content = f"""# Content Review Report
+
+**Generated:** {results['timestamp']}
+
+## Summary
+- **Files Processed:** {len(results['files_processed'])}
+- **Overall Quality Improvement:** +{results['overall_quality_improvement']} points
+- **Total Issues Fixed:** {results['total_issues_fixed']}
+
+## File-by-File Results
+
+"""
+
+        for file_result in results["files_processed"]:
+            report_content += f"""### {file_result['filename']}
+- **Original Quality Score:** {file_result['original_quality_score']}/100
+- **Improved Quality Score:** {file_result['improved_quality_score']}/100
+- **Quality Improvement:** +{file_result['quality_improvement']} points
+- **Issues Fixed:** {file_result['issues_fixed']}
+
+**Changes Summary:** {file_result['changes_summary']}
+
+---
+
+"""
+
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(report_content)
+
+
+def main():
+    """Run the content editor agent."""
+    print("Starting Content Editor Agent - Milestone 1")
+    print("=" * 50)
+
+    # Initialize agent
+    agent = ContentEditorAgent()
+
+    # Process all content
+    results = agent.process_all_content()
+
+    # Display summary
+    print("\n" + "=" * 50)
+    print("CONTENT REVIEW COMPLETE")
+    print("=" * 50)
+    print(f"Files processed: {len(results['files_processed'])}")
+    print(f"Overall quality improvement: +{results['overall_quality_improvement']} points")
+    print(f"Total issues fixed: {results['total_issues_fixed']}")
+    print("\nReviewed content saved to: artifacts/reviewed_content/v1_content_edited/")
+    print("Quality report saved to: artifacts/agent_reports/quality/")
+
+
+if __name__ == "__main__":
+    main()

agents/content_editor/content_reviewer.py

@@ -0,0 +1,327 @@
+"""
+Content Reviewer Tool
+
+Provides content analysis and improvement capabilities using LLM-based review.
+"""
+
+import re
+import os
+import sys
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+from anthropic import Anthropic
+
+# Add project root to path for pattern injector
+project_root = Path(__file__).parent.parent.parent
+sys.path.insert(0, str(project_root))
+
+try:
+    from tools.pattern_injector import PatternInjector
+except ImportError:
+    PatternInjector = None
+
+
+class ContentReviewer:
+    """Content review and improvement tool using Anthropic Claude with pattern learning."""
+
+    def __init__(self, document_type: str = "research_report"):
+        """
+        Initialize the content reviewer with API client and pattern learning.
+
+        Args:
+            document_type: Type of document for loading type-specific patterns
+        """
+        self.client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
+        self.document_type = document_type
+
+        # Initialize pattern injector if available
+        if PatternInjector:
+            try:
+                self.pattern_injector = PatternInjector(document_type=document_type)
+            except Exception as e:
+                print(f"⚠️  Could not load pattern injector: {e}")
+                self.pattern_injector = None
+        else:
+            self.pattern_injector = None
+
+    def analyze_readability(self, text: str) -> Dict:
+        """
+        Analyze text readability metrics.
+
+        Args:
+            text: Input text to analyze
+
+        Returns:
+            Dict with readability metrics
+        """
+        # Basic readability analysis
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+
+        words = text.split()
+        total_words = len(words)
+        total_sentences = len(sentences)
+
+        # Calculate average sentence length
+        avg_sentence_length = total_words / total_sentences if total_sentences > 0 else 0
+
+        # Count syllables (rough approximation)
+        syllable_count = sum(self._count_syllables(word) for word in words)
+
+        # Flesch Reading Ease (simplified)
+        if total_sentences > 0 and total_words > 0:
+            flesch_score = 206.835 - (1.015 * avg_sentence_length) - (84.6 * (syllable_count / total_words))
+            flesch_score = max(0, min(100, flesch_score))
+        else:
+            flesch_score = 0
+
+        # Passive voice detection (simplified)
+        passive_indicators = ['was', 'were', 'been', 'being', 'is', 'are', 'am']
+        passive_count = sum(1 for word in words if word.lower() in passive_indicators)
+        passive_percentage = (passive_count / total_words * 100) if total_words > 0 else 0
+
+        return {
+            "total_words": total_words,
+            "total_sentences": total_sentences,
+            "avg_sentence_length": round(avg_sentence_length, 1),
+            "flesch_reading_ease": round(flesch_score, 1),
+            "passive_voice_percentage": round(passive_percentage, 1),
+            "syllable_count": syllable_count
+        }
+
+    def _count_syllables(self, word: str) -> int:
+        """Rough syllable counting approximation."""
+        word = word.lower()
+        vowels = "aeiouy"
+        syllables = 0
+        prev_was_vowel = False
+
+        for char in word:
+            if char in vowels:
+                if not prev_was_vowel:
+                    syllables += 1
+                prev_was_vowel = True
+            else:
+                prev_was_vowel = False
+
+        # Handle silent e
+        if word.endswith('e') and syllables > 1:
+            syllables -= 1
+
+        return max(1, syllables)
+
+    def calculate_quality_score(self, metrics: Dict, issues: List[str]) -> int:
+        """
+        Calculate overall content quality score (0-100).
+
+        Args:
+            metrics: Readability metrics
+            issues: List of identified issues
+
+        Returns:
+            Quality score from 0-100
+        """
+        score = 100
+
+        # Penalize for grammar/style issues
+        score -= min(len(issues) * 2, 40)  # Up to 40 points for issues
+
+        # Readability factors
+        flesch = metrics.get("flesch_reading_ease", 0)
+        if flesch < 30:  # Too difficult
+            score -= 15
+        elif flesch > 70:  # Too easy for academic content
+            score -= 10
+
+        # Sentence length factors
+        avg_length = metrics.get("avg_sentence_length", 0)
+        if avg_length > 25:  # Too long
+            score -= 10
+        elif avg_length < 10:  # Too short
+            score -= 5
+
+        # Passive voice penalty
+        passive_pct = metrics.get("passive_voice_percentage", 0)
+        if passive_pct > 30:
+            score -= 10
+
+        return max(0, min(100, score))
+
+    def review_text(self, text: str) -> Dict:
+        """
+        Review and improve text content with pattern learning.
+
+        Args:
+            text: Original text content
+
+        Returns:
+            Dict with improved content and analysis
+        """
+        # Analyze original content
+        original_metrics = self.analyze_readability(text)
+
+        # Get pattern context if available
+        pattern_context = ""
+        if self.pattern_injector:
+            pattern_context = self.pattern_injector.get_context_for_content_editor()
+            if pattern_context:
+                print(f"✅ Applying learned patterns for '{self.document_type}' documents")
+
+        # Build prompt with pattern learning context
+        prompt = f"""You are a professional editor specializing in academic and technical writing.
+
+Please review and improve the following text for:
+1. Grammar and spelling errors
+2. Sentence structure and clarity
+3. Word choice and precision
+4. Flow and readability
+5. Academic writing style"""
+
+        # Add pattern learning context if available
+        if pattern_context:
+            prompt += f"""
+
+{pattern_context}
+
+IMPORTANT: Apply the historical patterns above to improve this document. Look specifically for the common issues identified in previous documents of this type."""
+
+        prompt += f"""
+
+Original text:
+{text}
+
+Please provide:
+1. The improved version of the text
+2. A list of specific changes you made
+3. A brief summary of the improvements
+
+Format your response as:
+
+IMPROVED TEXT:
+[improved version here]
+
+CHANGES MADE:
+- [change 1]
+- [change 2]
+- [etc.]
+
+SUMMARY:
+[brief summary of improvements]
+"""
+
+        try:
+            response = self.client.messages.create(
+                model="claude-sonnet-4-20250514",  # Latest Sonnet 4.5 model
+                max_tokens=2000,
+                messages=[{"role": "user", "content": prompt}]
+            )
+
+            response_text = response.content[0].text
+
+            # Parse the response
+            improved_text, changes_made, summary = self._parse_review_response(response_text)
+
+            # Analyze improved content
+            improved_metrics = self.analyze_readability(improved_text)
+
+            # Calculate quality scores
+            original_issues = self._identify_issues(text, original_metrics)
+            improved_issues = self._identify_issues(improved_text, improved_metrics)
+
+            original_score = self.calculate_quality_score(original_metrics, original_issues)
+            improved_score = self.calculate_quality_score(improved_metrics, improved_issues)
+
+            return {
+                "original_content": text,
+                "improved_content": improved_text,
+                "original_metrics": original_metrics,
+                "improved_metrics": improved_metrics,
+                "original_quality_score": original_score,
+                "improved_quality_score": improved_score,
+                "quality_improvement": improved_score - original_score,
+                "changes_made": changes_made,
+                "changes_summary": summary,
+                "issues_fixed": len(original_issues) - len(improved_issues)
+            }
+
+        except Exception as e:
+            print(f"Error during content review: {e}")
+            return {
+                "original_content": text,
+                "improved_content": text,  # Fallback to original
+                "original_metrics": original_metrics,
+                "improved_metrics": original_metrics,
+                "original_quality_score": self.calculate_quality_score(original_metrics, []),
+                "improved_quality_score": self.calculate_quality_score(original_metrics, []),
+                "quality_improvement": 0,
+                "changes_made": [],
+                "changes_summary": f"Review failed: {str(e)}",
+                "issues_fixed": 0
+            }
+
+    def _parse_review_response(self, response: str) -> Tuple[str, List[str], str]:
+        """Parse Claude's review response into components."""
+        improved_text = ""
+        changes_made = []
+        summary = ""
+
+        # Split response into sections
+        sections = response.split('\n\n')
+        current_section = ""
+
+        for section in sections:
+            if section.startswith("IMPROVED TEXT:"):
+                current_section = "improved"
+                improved_text = section.replace("IMPROVED TEXT:", "").strip()
+            elif section.startswith("CHANGES MADE:"):
+                current_section = "changes"
+                changes_text = section.replace("CHANGES MADE:", "").strip()
+                changes_made = [line.strip().lstrip("- ") for line in changes_text.split('\n') if line.strip()]
+            elif section.startswith("SUMMARY:"):
+                current_section = "summary"
+                summary = section.replace("SUMMARY:", "").strip()
+            elif current_section == "improved":
+                improved_text += "\n\n" + section
+            elif current_section == "changes":
+                changes_made.extend([line.strip().lstrip("- ") for line in section.split('\n') if line.strip()])
+            elif current_section == "summary":
+                summary += "\n\n" + section
+
+        return improved_text.strip(), changes_made, summary.strip()
+
+    def _identify_issues(self, text: str, metrics: Dict) -> List[str]:
+        """Identify potential issues in the text."""
+        issues = []
+
+        # Check sentence length
+        if metrics.get("avg_sentence_length", 0) > 25:
+            issues.append("Long sentences detected")
+
+        # Check passive voice
+        if metrics.get("passive_voice_percentage", 0) > 30:
+            issues.append("High passive voice usage")
+
+        # Check readability
+        flesch = metrics.get("flesch_reading_ease", 0)
+        if flesch < 30:
+            issues.append("Text may be too complex")
+
+        # Simple grammar checks
+        if "....." in text:
+            issues.append("Multiple consecutive periods")
+
+        if "  " in text:
+            issues.append("Multiple consecutive spaces")
+
+        # Check for common issues
+        common_errors = [
+            (r'\bit\'s\b', "Possible incorrect apostrophe usage"),
+            (r'\byour\b.*\byour\b', "Repeated 'your'"),
+            (r'\bthe the\b', "Repeated 'the'"),
+        ]
+
+        for pattern, description in common_errors:
+            if re.search(pattern, text, re.IGNORECASE):
+                issues.append(description)
+
+        return issues