bizy-ai 1.0.0__py3-none-any.whl

agent/__init__.py

@@ -0,0 +1,5 @@
+"""
+Business Agent - AI-Powered Business Execution Assistant
+"""
+
+__version__ = "1.0.0"

agent/cli.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python3
+"""Business Agent CLI Tool"""
+
+import click
+from agent.tasks import TaskManager
+from agent.planner import BusinessPlanner
+from agent.research import ResearchAgent
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.markdown import Markdown
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+
+load_dotenv()
+console = Console()
+
+@click.group()
+def cli():
+    """Business Agent CLI - Manage your business from the command line"""
+    pass
+
+# TASK COMMANDS
+@cli.group()
+def task():
+    """Manage tasks"""
+    pass
+
+@task.command()
+@click.argument('title')
+@click.option('--description', '-d', help='Task description')
+@click.option('--priority', '-p', type=int, default=3)
+@click.option('--category', '-c', help='Task category')
+@click.option('--hours', '-h', type=float, help='Estimated hours')
+def add(title, description, priority, category, hours):
+    """Add a new task"""
+    task_mgr = TaskManager()
+    task = task_mgr.create_task(
+        title=title,
+        description=description,
+        priority=priority,
+        category=category,
+        estimated_hours=hours
+    )
+    console.print(f"[green]✓[/green] Task created: {task.title} (ID: {task.id})")
+    task_mgr.close()
+
+@task.command()
+def list():
+    """List all pending tasks"""
+    task_mgr = TaskManager()
+    tasks = task_mgr.get_tasks_for_today()
+
+    if not tasks:
+        console.print("[yellow]No pending tasks[/yellow]")
+        return
+
+    table = Table(title="📋 Your Tasks", show_header=True, header_style="bold cyan")
+    table.add_column("ID", style="dim")
+    table.add_column("Priority", justify="center")
+    table.add_column("Title")
+    table.add_column("Category", style="cyan")
+
+    for task in tasks:
+        priority_str = "🔴" if task.priority == 1 else "🟡" if task.priority == 3 else "🟢"
+        table.add_row(
+            str(task.id),
+            priority_str,
+            task.title[:50],
+            task.category or "-"
+        )
+
+    console.print(table)
+    task_mgr.close()
+
+@task.command()
+@click.argument('task_id', type=int)
+def complete(task_id):
+    """Mark a task as complete"""
+    task_mgr = TaskManager()
+    task = task_mgr.complete_task(task_id)
+    if task:
+        console.print(f"[green]✓[/green] Completed: {task.title}")
+    else:
+        console.print(f"[red]✗[/red] Task {task_id} not found")
+    task_mgr.close()
+
+# GOAL COMMANDS
+@cli.group()
+def goal():
+    """Manage goals"""
+    pass
+
+@goal.command()
+@click.argument('title')
+@click.option('--description', '-d', help='Goal description')
+@click.option('--horizon', '-h', type=click.Choice(['weekly', 'monthly', 'quarterly', 'yearly']), default='monthly')
+@click.option('--target', '-t', help='Target date (YYYY-MM-DD)')
+def add(title, description, horizon, target):
+    """Add a new goal"""
+    planner = BusinessPlanner()
+    target_date = None
+    if target:
+        target_date = datetime.strptime(target, '%Y-%m-%d')
+
+    goal = planner.create_goal(
+        title=title,
+        description=description,
+        horizon=horizon,
+        target_date=target_date
+    )
+    console.print(f"[green]✓[/green] Goal created: {goal.title} (ID: {goal.id})")
+    planner.close()
+
+@goal.command()
+def list():
+    """List all active goals"""
+    planner = BusinessPlanner()
+    goals = planner.get_active_goals()
+
+    if not goals:
+        console.print("[yellow]No active goals[/yellow]")
+        return
+
+    table = Table(title="🎯 Your Goals", show_header=True, header_style="bold cyan")
+    table.add_column("ID", style="dim")
+    table.add_column("Title")
+    table.add_column("Horizon", style="cyan")
+    table.add_column("Progress", justify="right")
+
+    for goal in goals:
+        progress_bar = "█" * int(goal.progress_percentage / 10) + "░" * (10 - int(goal.progress_percentage / 10))
+        table.add_row(
+            str(goal.id),
+            goal.title[:40],
+            goal.horizon,
+            f"{progress_bar} {goal.progress_percentage:.0f}%"
+        )
+
+    console.print(table)
+    planner.close()
+
+@goal.command()
+@click.argument('goal_id', type=int)
+def breakdown(goal_id):
+    """Break down a goal into tasks using AI"""
+    planner = BusinessPlanner()
+    console.print(f"[cyan]Breaking down goal {goal_id}...[/cyan]")
+    tasks = planner.break_down_goal(goal_id)
+
+    if tasks:
+        console.print(f"[green]✓[/green] Created {len(tasks)} tasks")
+        for task in tasks:
+            console.print(f"  • {task.title}")
+    else:
+        console.print("[red]✗[/red] Failed to break down goal")
+    planner.close()
+
+# RESEARCH COMMANDS
+@cli.group()
+def research():
+    """Conduct research"""
+    pass
+
+@research.command()
+@click.argument('topic')
+@click.option('--goal', '-g', help='Business goal')
+def topic(topic, goal):
+    """Research a topic"""
+    researcher = ResearchAgent()
+    console.print(f"[cyan]Researching: {topic}...[/cyan]\n")
+
+    result = researcher.research_topic(
+        topic=topic,
+        business_goal=goal or "General research",
+        depth="standard"
+    )
+
+    if 'error' in result:
+        console.print(f"[red]✗ Error:[/red] {result['error']}")
+    else:
+        console.print(Panel(
+            Markdown(result['findings']),
+            title=f"🔍 Research: {topic}",
+            border_style="blue"
+        ))
+        console.print(f"\n[dim]Saved as research ID: {result['research_id']}[/dim]")
+    researcher.close()
+
+@research.command()
+@click.argument('domain')
+@click.argument('offering')
+def competitors(domain, offering):
+    """Research competitors"""
+    researcher = ResearchAgent()
+    console.print(f"[cyan]Analyzing competitive landscape...[/cyan]\n")
+
+    result = researcher.research_competitors(domain, offering)
+
+    if 'error' in result:
+        console.print(f"[red]✗ Error:[/red] {result['error']}")
+    else:
+        console.print(Panel(
+            Markdown(result['findings']),
+            title="🏆 Competitive Analysis",
+            border_style="blue"
+        ))
+    researcher.close()
+
+# STATS COMMAND
+@cli.command()
+def stats():
+    """Show statistics"""
+    task_mgr = TaskManager()
+    weekly_stats = task_mgr.get_weekly_stats()
+    velocity = task_mgr.get_task_velocity()
+    today_tasks = task_mgr.get_tasks_for_today()
+
+    console.print("\n[bold cyan]📊 Your Statistics[/bold cyan]\n")
+    console.print("[bold]This Week:[/bold]")
+    console.print(f"  • Tasks Completed: {weekly_stats['total_tasks_completed']}")
+    console.print(f"  • Completion Rate: {weekly_stats['average_completion_rate']:.0%}")
+    console.print(f"\n[bold]Velocity:[/bold] {velocity:.1f} tasks/day")
+    console.print(f"\n[bold]Today:[/bold] {len(today_tasks)} tasks scheduled\n")
+    task_mgr.close()
+
+if __name__ == "__main__":
+    cli()

agent/core.py

@@ -0,0 +1,205 @@
+import anthropic
+import os
+from datetime import datetime, timedelta
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+import json
+
+console = Console()
+
+class BusinessAgent:
+    def __init__(self):
+        api_key = os.getenv('ANTHROPIC_API_KEY')
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+        
+        self.client = anthropic.Anthropic(api_key=api_key)
+        self.model = "claude-sonnet-4-20250514"
+    
+    def morning_briefing(self, tasks_today, yesterday_summary, business_context, goals=None):
+        """Generate morning briefing with AI"""
+        
+        tasks_str = self._format_tasks_for_prompt(tasks_today)
+        goals_str = self._format_goals_for_prompt(goals) if goals else "No active goals set"
+        
+        prompt = f"""You are my business execution assistant. Generate an energizing and focused morning briefing for today.
+
+TODAY'S DATE: {datetime.now().strftime('%A, %B %d, %Y')}
+
+YESTERDAY'S SUMMARY:
+Tasks Completed: {yesterday_summary.get('tasks_completed', 0)} of {yesterday_summary.get('tasks_due', 0)}
+Completion Rate: {yesterday_summary.get('completion_rate', 0):.0%}
+
+ACTIVE GOALS:
+{goals_str}
+
+TODAY'S SCHEDULED TASKS:
+{tasks_str}
+
+Create a morning briefing with these sections:
+
+## 🌅 Good Morning!
+Brief motivational opener (1-2 sentences)
+
+## 📊 Yesterday's Recap
+Quick summary of what was accomplished and what it means
+
+## 🎯 Today's Mission
+Top 3 priorities for today with estimated time for each
+Explain why each matters for the bigger picture
+
+## ⚠️ Watch Out For
+Any potential blockers, risks, or important deadlines
+
+## 💡 Pro Tip
+One specific, actionable suggestion to move the business forward today
+
+Keep it concise, energizing, and actionable. Use markdown formatting."""
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=2000,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return message.content[0].text
+        except Exception as e:
+            return f"Error generating briefing: {e}"
+    
+    def evening_review_analysis(self, completed_tasks, planned_tasks, wins, blockers, learnings, energy_level):
+        """Analyze the day's work and provide insights"""
+        
+        completed_str = "\n".join([f"- {t.title} ({t.category or 'uncategorized'})" for t in completed_tasks])
+        planned_str = "\n".join([f"- {t.title} ({t.status})" for t in planned_tasks])
+        
+        completion_rate = len(completed_tasks) / len(planned_tasks) if planned_tasks else 0
+        
+        prompt = f"""Analyze today's business execution and provide insights:
+
+DATE: {datetime.now().strftime('%A, %B %d, %Y')}
+
+COMPLETION RATE: {completion_rate:.0%} ({len(completed_tasks)}/{len(planned_tasks)} tasks)
+
+COMPLETED TASKS:
+{completed_str or 'None'}
+
+PLANNED BUT NOT COMPLETED:
+{planned_str or 'All completed!'}
+
+USER'S REFLECTION:
+- Wins: {wins or 'Not specified'}
+- Blockers: {blockers or 'None mentioned'}
+- Learnings: {learnings or 'Not specified'}
+- Energy Level: {energy_level or 'Not specified'}
+
+Provide:
+
+## 📈 Day Analysis
+Honest assessment of today's productivity (2-3 sentences)
+
+## 🎯 What Worked
+Highlight positive patterns or wins
+
+## 🔄 What to Adjust
+Constructive suggestions for improvement
+
+## 🌟 Momentum Builder
+One specific thing to carry into tomorrow
+
+Be supportive but honest. Keep it concise."""
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=1500,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return message.content[0].text
+        except Exception as e:
+            return f"Error generating analysis: {e}"
+    
+    def weekly_review(self, weekly_stats, goals_progress, key_events):
+        """Generate comprehensive weekly review"""
+        
+        prompt = f"""Generate a comprehensive weekly review for my business:
+
+WEEK ENDING: {datetime.now().strftime('%B %d, %Y')}
+
+STATS:
+- Total Tasks Completed: {weekly_stats.get('total_tasks_completed', 0)}
+- Total Tasks Planned: {weekly_stats.get('total_tasks_planned', 0)}
+- Average Completion Rate: {weekly_stats.get('average_completion_rate', 0):.0%}
+- Days Logged: {weekly_stats.get('days_logged', 0)}
+
+GOAL PROGRESS:
+{goals_progress}
+
+KEY EVENTS/NOTES:
+{key_events or 'None logged'}
+
+Create a weekly review with:
+
+## 📊 Week in Review
+High-level summary of the week's productivity
+
+## 🎯 Goal Progress
+Assessment of progress toward key goals
+
+## 📈 Trends & Patterns
+What patterns do you notice? (velocity, energy, blockers)
+
+## 🏆 Wins & Achievements
+Celebrate what went well
+
+## 🔧 Areas for Improvement
+What could be better next week?
+
+## 📋 Next Week's Focus
+Top 3 priorities for the coming week
+
+## 💡 Strategic Insight
+One key insight or recommendation for the business
+
+Be thorough but scannable. Use bullet points where appropriate."""
+
+        try:
+            message = self.client.messages.create(
+                model=self.model,
+                max_tokens=3000,
+                messages=[{"role": "user", "content": prompt}]
+            )
+            return message.content[0].text
+        except Exception as e:
+            return f"Error generating weekly review: {e}"
+    
+    # Helper methods
+    
+    def _format_tasks_for_prompt(self, tasks):
+        """Format tasks for inclusion in prompts"""
+        if not tasks:
+            return "No tasks scheduled"
+        
+        formatted = []
+        for task in tasks[:10]:  # Limit to top 10
+            due_str = task.due_date.strftime('%m/%d') if task.due_date else 'No due date'
+            est_str = f"{task.estimated_hours}h" if task.estimated_hours else "?"
+            formatted.append(
+                f"- [{task.priority}] {task.title} (Est: {est_str}, Due: {due_str})"
+            )
+        
+        return "\n".join(formatted)
+    
+    def _format_goals_for_prompt(self, goals):
+        """Format goals for inclusion in prompts"""
+        if not goals:
+            return "No active goals"
+        
+        formatted = []
+        for goal in goals[:5]:  # Top 5 goals
+            target_str = goal.target_date.strftime('%m/%d/%Y') if goal.target_date else 'No target'
+            formatted.append(
+                f"- [{goal.horizon.upper()}] {goal.title} - {goal.progress_percentage:.0f}% (Target: {target_str})"
+            )
+        
+        return "\n".join(formatted)

agent/models.py

@@ -0,0 +1,216 @@
+from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean, Text, Float, JSON
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+import os
+
+Base = declarative_base()
+
+class Task(Base):
+    __tablename__ = 'tasks'
+    
+    id = Column(Integer, primary_key=True)
+    title = Column(String(500), nullable=False)
+    description = Column(Text)
+    priority = Column(Integer, default=3)  # 1=highest, 5=lowest
+    status = Column(String(50), default='pending')  # pending, in_progress, completed, blocked
+    category = Column(String(100))  # development, marketing, operations, finance, etc.
+    estimated_hours = Column(Float)
+    actual_hours = Column(Float)
+    due_date = Column(DateTime)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    completed_at = Column(DateTime)
+    parent_goal_id = Column(Integer)  # Links to goals
+    dependencies = Column(JSON)  # List of task IDs this depends on
+    notes = Column(Text)
+    tags = Column(JSON)  # List of tags for filtering
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'title': self.title,
+            'description': self.description,
+            'priority': self.priority,
+            'status': self.status,
+            'category': self.category,
+            'estimated_hours': self.estimated_hours,
+            'actual_hours': self.actual_hours,
+            'due_date': self.due_date.isoformat() if self.due_date else None,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'completed_at': self.completed_at.isoformat() if self.completed_at else None,
+            'parent_goal_id': self.parent_goal_id,
+            'dependencies': self.dependencies or [],
+            'notes': self.notes,
+            'tags': self.tags or []
+        }
+
+class Goal(Base):
+    __tablename__ = 'goals'
+    
+    id = Column(Integer, primary_key=True)
+    title = Column(String(500), nullable=False)
+    description = Column(Text)
+    horizon = Column(String(50))  # yearly, quarterly, monthly, weekly
+    target_date = Column(DateTime)
+    status = Column(String(50), default='active')  # active, completed, on_hold, cancelled
+    progress_percentage = Column(Float, default=0.0)
+    success_criteria = Column(Text)
+    parent_goal_id = Column(Integer)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    metrics = Column(JSON)  # Key metrics to track
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'title': self.title,
+            'description': self.description,
+            'horizon': self.horizon,
+            'target_date': self.target_date.isoformat() if self.target_date else None,
+            'status': self.status,
+            'progress_percentage': self.progress_percentage,
+            'success_criteria': self.success_criteria,
+            'parent_goal_id': self.parent_goal_id,
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'metrics': self.metrics or {}
+        }
+
+class DailyLog(Base):
+    __tablename__ = 'daily_logs'
+    
+    id = Column(Integer, primary_key=True)
+    date = Column(DateTime, nullable=False, unique=True)
+    tasks_completed = Column(Integer, default=0)
+    tasks_planned = Column(Integer, default=0)
+    completion_rate = Column(Float)
+    energy_level = Column(String(20))  # high, medium, low
+    blockers = Column(Text)
+    wins = Column(Text)
+    learnings = Column(Text)
+    tomorrow_focus = Column(Text)
+    mood = Column(String(50))
+    notes = Column(Text)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'date': self.date.isoformat() if self.date else None,
+            'tasks_completed': self.tasks_completed,
+            'tasks_planned': self.tasks_planned,
+            'completion_rate': self.completion_rate,
+            'energy_level': self.energy_level,
+            'blockers': self.blockers,
+            'wins': self.wins,
+            'learnings': self.learnings,
+            'tomorrow_focus': self.tomorrow_focus,
+            'mood': self.mood,
+            'notes': self.notes
+        }
+
+class ResearchItem(Base):
+    __tablename__ = 'research'
+    
+    id = Column(Integer, primary_key=True)
+    title = Column(String(500))
+    summary = Column(Text)
+    source_url = Column(String(1000))
+    category = Column(String(100))  # competitor, trend, opportunity, threat, technology
+    relevance_score = Column(Float)
+    date_found = Column(DateTime, default=datetime.utcnow)
+    action_items = Column(Text)
+    tags = Column(JSON)
+    raw_data = Column(JSON)  # Store full research data
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'title': self.title,
+            'summary': self.summary,
+            'source_url': self.source_url,
+            'category': self.category,
+            'relevance_score': self.relevance_score,
+            'date_found': self.date_found.isoformat() if self.date_found else None,
+            'action_items': self.action_items,
+            'tags': self.tags or []
+        }
+
+class BusinessMetric(Base):
+    __tablename__ = 'metrics'
+    
+    id = Column(Integer, primary_key=True)
+    metric_name = Column(String(200))
+    value = Column(Float)
+    date = Column(DateTime, default=datetime.utcnow)
+    notes = Column(Text)
+    target_value = Column(Float)
+    category = Column(String(100))  # revenue, growth, customer, product, etc.
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'metric_name': self.metric_name,
+            'value': self.value,
+            'date': self.date.isoformat() if self.date else None,
+            'notes': self.notes,
+            'target_value': self.target_value,
+            'category': self.category
+        }
+
+class BusinessPlan(Base):
+    __tablename__ = 'business_plans'
+    
+    id = Column(Integer, primary_key=True)
+    version = Column(String(50))
+    vision = Column(Text)
+    mission = Column(Text)
+    value_proposition = Column(Text)
+    target_market = Column(Text)
+    revenue_model = Column(Text)
+    key_resources = Column(JSON)
+    key_activities = Column(JSON)
+    key_partnerships = Column(JSON)
+    cost_structure = Column(JSON)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    is_active = Column(Boolean, default=True)
+    
+    def to_dict(self):
+        return {
+            'id': self.id,
+            'version': self.version,
+            'vision': self.vision,
+            'mission': self.mission,
+            'value_proposition': self.value_proposition,
+            'target_market': self.target_market,
+            'revenue_model': self.revenue_model,
+            'key_resources': self.key_resources or {},
+            'key_activities': self.key_activities or [],
+            'key_partnerships': self.key_partnerships or [],
+            'cost_structure': self.cost_structure or {},
+            'created_at': self.created_at.isoformat() if self.created_at else None,
+            'is_active': self.is_active
+        }
+
+# Database setup
+def get_engine(db_path=None):
+    if db_path is None:
+        # Use environment variable or default to home directory
+        db_path = os.getenv('BUSINESS_AGENT_DB', os.path.expanduser('~/.business-agent/tasks.db'))
+
+    # Create directory if it doesn't exist
+    db_dir = os.path.dirname(db_path)
+    if db_dir:
+        os.makedirs(db_dir, exist_ok=True)
+
+    return create_engine(f'sqlite:///{db_path}', echo=False)
+
+def get_session(engine=None):
+    if engine is None:
+        engine = get_engine()
+    Session = sessionmaker(bind=engine)
+    return Session()
+
+def init_database(db_path=None):
+    """Initialize the database with all tables"""
+    engine = get_engine(db_path)
+    Base.metadata.create_all(engine)
+    return engine