Deep Productivity

interface:
  display_name: "Deep Productivity"
  short_description: "Build sustainable deep work with 1 hour daily"
  default_prompt: "Design a deep productivity system for me using Building, Maintenance, and Recovery, with a practical weekly plan and lever tasks."

#!/usr/bin/env python3
"""
Focus State Assessment Tool

Diagnose current focus state based on the Challenge ≈ Skill framework.
Helps identify whether user is in Anxiety, Boredom, Flow, or Relaxed state.
"""

import sys


def get_challenge_rating():
    """Get challenge level rating from user (1-10)"""
    while True:
        try:
            print("\nOn a scale of 1-10, how challenging is your current main task?")
            print("(1 = trivial, 10 = completely overwhelming)")
            rating = int(input("> "))
            if 1 <= rating <= 10:
                return rating
            print("Please enter a number between 1 and 10.")
        except ValueError:
            print("Please enter a valid number.")


def get_skill_rating():
    """Get skill level rating from user (1-10)"""
    while True:
        try:
            print("\nOn a scale of 1-10, how would you rate your current skill level for this task?")
            print("(1 = complete beginner, 10 = world-class expert)")
            rating = int(input("> "))
            if 1 <= rating <= 10:
                return rating
            print("Please enter a number between 1 and 10.")
        except ValueError:
            print("Please enter a valid number.")


def get_symptoms():
    """Gather symptoms to confirm assessment"""
    print("\nWhich symptoms are you experiencing? (select all that apply)")
    symptoms = {
        "overwhelmed": False,
        "negative_self_talk": False,
        "paralysis": False,
        "restlessness": False,
        "wandering_mind": False,
        "time_flies": False,
        "complete_absorption": False,
        "effortless_performance": False,
        "boredom": False,
        "frustration": False,
    }

    symptom_list = list(symptoms.keys())

    for i, symptom in enumerate(symptom_list, 1):
        print(f"{i}. {symptom.replace('_', ' ').title()}")

    print("\nEnter numbers separated by commas (e.g., 1,3,5), or press Enter for none:")

    try:
        response = input("> ").strip()
        if response:
            indices = [int(x.strip()) for x in response.split(",")]
            for idx in indices:
                if 1 <= idx <= len(symptom_list):
                    symptom = symptom_list[idx - 1]
                    symptoms[symptom] = True
    except ValueError:
        pass

    return symptoms


def analyze_state(challenge, skill, symptoms):
    """Analyze the focus state based on inputs"""

    gap = challenge - skill

    states = {
        "anxiety": {
            "name": "ANXIETY",
            "condition": challenge > skill + 1,
            "indicators": ["overwhelmed", "negative_self_talk", "paralysis", "frustration"],
            "message": "Your challenge level exceeds your skill level. You're attempting a level-100 boss as a level-1 character.",
        },
        "boredom": {
            "name": "BOREDOM",
            "condition": skill > challenge + 1,
            "indicators": ["restlessness", "wandering_mind", "boredom"],
            "message": "Your skill level exceeds the challenge. The task is too easy and isn't stretching you.",
        },
        "flow": {
            "name": "FLOW",
            "condition": abs(gap) <= 1,
            "indicators": ["time_flies", "complete_absorption", "effortless_performance"],
            "message": "Challenge and skill are well-matched. You're in the optimal zone for performance and growth.",
        },
        "relaxed": {
            "name": "RELAXED",
            "condition": False,  # This is a catch-all, handled separately
            "indicators": [],
            "message": "You've mastered this level. It's comfortable but not challenging.",
        },
    }

    # Determine primary state
    if states["anxiety"]["condition"]:
        state = "anxiety"
    elif states["boredom"]["condition"]:
        state = "boredom"
    elif states["flow"]["condition"]:
        state = "flow"
    else:
        state = "relaxed"

    return state, states[state]


def get_recommendations(state, challenge, skill):
    """Get recommendations for the identified state"""
    recommendations = {
        "anxiety": [
            f"Break your task into smaller sub-goals (current challenge: {challenge}, skill: {skill})",
            "Focus only on the very next micro-step, not the entire project",
            "Set a timer for 15 minutes and commit to just 15 minutes of work",
            "Study foundational skills before continuing",
            "Accept that feeling overwhelmed means you're growing—lean into it",
        ],
        "boredom": [
            f"Increase the challenge (current skill: {skill} is too high for challenge: {challenge})",
            "Add a deadline or time constraint",
            "Raise your standards—aim higher than you initially planned",
            "Take on a stretch project that scares you slightly",
            "Compete with yourself or others",
        ],
        "flow": [
            "Protect this state—document what conditions created it",
            "Extend your session if energy allows (max 4 hours)",
            "Take a short break every 60-90 minutes to maintain quality",
            "Capture any insights that emerge—they're valuable",
            "You're in the zone—keep building",
        ],
        "relaxed": [
            "You've mastered this level—time to move up",
            "Find a stretch goal that genuinely challenges you",
            "Review your 10-year vision and raise your targets",
            "Consider taking on a mentorship or teaching role",
        ],
    }

    return recommendations[state]


def main():
    print("=" * 60)
    print("FOCUS STATE ASSESSMENT TOOL")
    print("Based on the Challenge ≈ Skill Framework")
    print("=" * 60)

    challenge = get_challenge_rating()
    skill = get_skill_rating()
    symptoms = get_symptoms()

    state, state_info = analyze_state(challenge, skill, symptoms)

    print("\n" + "=" * 60)
    print(f"ASSESSMENT: {state_info['name']}")
    print("=" * 60)
    print(f"\n{state_info['message']}")
    print(f"\nChallenge Level: {challenge}/10")
    print(f"Skill Level: {skill}/10")
    print(f"Gap: {abs(challenge - skill)}")

    print("\n" + "-" * 60)
    print("RECOMMENDATIONS:")
    print("-" * 60)

    recommendations = get_recommendations(state, challenge, skill)
    for i, rec in enumerate(recommendations, 1):
        print(f"{i}. {rec}")

    print("\n" + "-" * 60)
    print("DEEP WORK CHECKLIST:")
    print("-" * 60)
    checklist = [
        "I know exactly what one task I'm working on",
        "The challenge is just above my current skill level",
        "I understand WHY this matters to my future",
        "Distractions are removed (phone, tabs, notifications)",
        "I have a hard stop time (60 or 90 minutes max)",
    ]
    for item in checklist:
        print(f"[ ] {item}")

    print("\n" + "=" * 60)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Goal Hierarchy Generator

Creates a 10-year → 1-year → 1-month → 1-week → daily goal hierarchy
from user's vision statement and anti-vision.
"""

import sys


def get_anti_vision():
    """Gather anti-vision (what user doesn't want)"""
    print("\n" + "=" * 60)
    print("ANTI-VISION EXERCISE")
    print("=" * 60)
    print("\nWrite out what you DON'T want in your life.")
    print("Be specific. Feel the discomfort. Don't stop until you feel it.\n")

    print("Consider these areas:")
    print("- Career/Work: What job or work situation would be terrible?")
    print("- Relationships: What kind of connections drain you?")
    print("- Health: What would your body look like if you neglected it?")
    print("- finances: What would financial stress look like for you?")
    print("- Daily life: What would a typical day look like that you hate?")

    print("\nType your anti-vision (press Enter twice when done, or 'skip' to move on):")

    lines = []
    while True:
        try:
            line = input()
            if line.lower() == 'skip':
                break
            if line == '' and lines:
                break
            lines.append(line)
        except EOFError:
            break

    return '\n'.join(lines)


def get_vision():
    """Gather vision (what user wants)"""
    print("\n" + "=" * 60)
    print("VISION EXERCISE")
    print("=" * 60)
    print("\nWrite out your ideal future. Be petty. Think big.")
    print("Ignore what's 'rational.' If friends/family think you can't do it, even better.\n")

    print("Consider these areas:")
    print("- Career: What work would you do for free?")
    print("- Impact: What problem would you solve for millions of people?")
    print("- Lifestyle: Where do you live? How do you spend your days?")
    print("- Relationships: Who surrounds you? What connections do you have?")
    print("- Health: How does your body feel? What can you do?")
    print("- finances: What does abundance look like for you?")
    print("- Legacy: What would you be remembered for?")

    print("\nType your vision (press Enter twice when done, or 'skip' to move on):")

    lines = []
    while True:
        try:
            line = input()
            if line.lower() == 'skip':
                break
            if line == '' and lines:
                break
            lines.append(line)
        except EOFError:
            break

    return '\n'.join(lines)


def get_distractions():
    """Gather distractions standing between user and their vision"""
    print("\n" + "=" * 60)
    print("DISTRACTIONS AUDIT")
    print("=" * 60)
    print("\nWhat stands between you and your vision?\n")

    print("People: Who drains your energy or holds you back?")
    print("Activities: What do you do that doesn't serve your vision?")
    print("Apps/Consumption: What content do you consume that doesn't help?")
    print("Habits: What patterns repeat that you want to change?")
    print("Commitments: What are you saying yes to that you should no?")

    print("\nType your distractions (press Enter twice when done, or 'skip' to move on):")

    lines = []
    while True:
        try:
            line = input()
            if line.lower() == 'skip':
                break
            if line == '' and lines:
                break
            lines.append(line)
        except EOFError:
            break

    return '\n'.join(lines)


def generate_10_year():
    """Generate 10-year goal from vision"""
    print("\n" + "=" * 60)
    print("10-YEAR GOAL")
    print("=" * 60)
    print("\nBased on your vision, what is your 10-year destination?")
    print("Think big. This is your north star.\n")

    print("Example: 'I will be the founder of a global education company")
    print("         impacting 10 million students annually.'")

    goal = input("Your 10-year goal: ")
    return goal


def generate_1_year(ten_year):
    """Generate 1-year goal from 10-year goal"""
    print("\n" + "=" * 60)
    print("1-YEAR GOAL")
    print("=" * 60)
    print(f"\nYour 10-year goal: {ten_year}")
    print("\nWhat milestone must you achieve in 1 year to stay on track?")
    print("Be specific and measurable.\n")

    print("Example: 'I will launch my MVP and acquire 1,000 paid subscribers'")

    goal = input("Your 1-year goal: ")
    return goal


def generate_1_month(one_year):
    """Generate 1-month goal from 1-year goal"""
    print("\n" + "=" * 60)
    print("1-MONTH GOAL")
    print("=" * 60)
    print(f"\nYour 1-year goal: {one_year}")
    print("\nWhat must you accomplish this month to stay on track?")
    print("This should be a concrete deliverable.\n")

    print("Example: 'I will create the minimum viable course product with 5 lessons'")

    goal = input("Your 1-month goal: ")
    return goal


def generate_1_week(one_month):
    """Generate 1-week goal from 1-month goal"""
    print("\n" + "=" * 60)
    print("1-WEEK GOAL")
    print("=" * 60)
    print(f"\nYour 1-month goal: {one_month}")
    print("\nWhat specific actions will you take this week?")
    print("Break it down into tangible tasks.\n")

    print("Example: 'Record 3 video lessons and set up the payment system'")

    goal = input("Your 1-week goal: ")
    return goal


def generate_daily(week):
    """Generate daily lever-moving tasks from 1-week goal"""
    print("\n" + "=" * 60)
    print("DAILY LEVER-MOVING TASKS")
    print("=" * 60)
    print(f"\nYour 1-week goal: {week}")
    print("\nWhat is ONE task you can do today that moves the needle?")
    print("If you could only do ONE thing today, what would it be?\n")

    print("Format: [Task] ([time duration])")

    task = input("Today's lever-moving task: ")
    return task


def generate_hierarchy():
    """Generate complete goal hierarchy"""
    print("=" * 60)
    print("GOAL HIERARCHY GENERATOR")
    print("=" * 60)
    print("\nThis tool helps you build a clear mental frame for your goals.")
    print("It creates a hierarchy: 10-year → 1-year → 1-month → 1-week → daily")

    # Get foundations
    anti_vision = get_anti_vision()
    vision = get_vision()
    distractions = get_distractions()

    # Generate hierarchy
    ten_year = generate_10_year()
    one_year = generate_1_year(ten_year)
    one_month = generate_1_month(one_year)
    one_week = generate_1_week(one_month)
    daily = generate_daily(one_week)

    # Output hierarchy
    print("\n" + "=" * 60)
    print("YOUR GOAL HIERARCHY")
    print("=" * 60)

    hierarchy = {
        "10-Year Goal": ten_year,
        "1-Year Goal": one_year,
        "1-Month Goal": one_month,
        "1-Week Goal": one_week,
        "Today's Lever-Moving Task": daily,
    }

    for level, goal in hierarchy.items():
        print(f"\n{level}:")
        print(f"  {goal}")

    print("\n" + "-" * 60)
    print("THE HIERARCHY:")
    print("-" * 60)
    print("""
    10-Year Goal → Where you want to be
        ↓
    1-Year Goal → Milestone to reach this year
        ↓
    1-Month Goal → What you must achieve this month
        ↓
    1-Week Goal → Actionable tasks this week
        ↓
    Lever-Moving Tasks → Daily 1-3 priorities that move the needle
    """)

    print("-" * 60)
    print("USAGE:")
    print("-" * 60)
    print("""
    DAILY PROTOCOL:
    1. Each morning, review your hierarchy
    2. Identify ONE lever-moving task for today
    3. Work on that for 60 minutes (no multitasking)
    4. At day's end, identify tomorrow's task
    5. Weekly, assess progress against 1-week goal
    6. Monthly, assess progress against 1-month goal
    7. Annually, reassess and adjust all goals
    """)

    # Store for potential export
    return hierarchy


def export_to_file(hierarchy):
    """Export hierarchy to a file"""
    filename = "goal_hierarchy.md"

    with open(filename, 'w') as f:
        f.write("# My Goal Hierarchy\n\n")
        f.write("## Anti-Vision\n")
        f.write(hierarchy.get('anti_vision', 'Not defined') + "\n\n")
        f.write("## Vision\n")
        f.write(hierarchy.get('vision', 'Not defined') + "\n\n")
        f.write("## Distractions to Remove\n")
        f.write(hierarchy.get('distractions', 'Not defined') + "\n\n")
        f.write("---\n\n")
        f.write("## Goals\n\n")
        for level, goal in hierarchy.items():
            if level not in ['anti_vision', 'vision', 'distractions']:
                f.write(f"### {level}\n{goal}\n\n")

    print(f"\nHierarchy exported to {filename}")


def main():
    hierarchy = generate_hierarchy()

    # Ask about export
    print("\n" + "=" * 60)
    export = input("Export to goal_hierarchy.md? (y/n): ")
    if export.lower() == 'y':
        # Add foundations to hierarchy for export
        anti_vision = get_anti_vision()
        vision = get_vision()
        distractions = get_distractions()
        hierarchy['anti_vision'] = anti_vision
        hierarchy['vision'] = vision
        hierarchy['distractions'] = distractions
        export_to_file(hierarchy)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Lever-Moving Task Tracker

Track daily progress on lever-moving tasks and assess whether
you're actually moving toward your goals.
"""

import json
import os
from datetime import datetime, timedelta


class LeverTracker:
    def __init__(self, data_file="lever_tracking.json"):
        self.data_file = data_file
        self.data = self.load_data()

    def load_data(self):
        """Load tracking data from file"""
        if os.path.exists(self.data_file):
            try:
                with open(self.data_file, 'r') as f:
                    return json.load(f)
            except (json.JSONDecodeError, FileNotFoundError):
                return {"tasks": [], "projects": [], "logs": []}
        return {"tasks": [], "projects": [], "logs": []}

    def save_data(self):
        """Save tracking data to file"""
        with open(self.data_file, 'w') as f:
            json.dump(self.data, f, indent=2, default=str)

    def add_project(self, name, ten_year_goal):
        """Add a project with its alignment to 10-year goal"""
        project = {
            "id": len(self.data["projects"]) + 1,
            "name": name,
            "ten_year_goal": ten_year_goal,
            "created": datetime.now().isoformat(),
            "status": "active",
            "milestones": []
        }
        self.data["projects"].append(project)
        self.save_data()
        return project

    def add_milestone(self, project_id, one_year, one_month, one_week):
        """Add milestones to a project"""
        for project in self.data["projects"]:
            if project["id"] == project_id:
                project["milestones"] = {
                    "one_year": one_year,
                    "one_month": one_month,
                    "one_week": one_week
                }
                self.save_data()
                return True
        return False

    def log_daily_task(self, project_id, task, duration_minutes, completed=True, notes=""):
        """Log a daily lever-moving task"""
        log_entry = {
            "id": len(self.data["logs"]) + 1,
            "project_id": project_id,
            "date": datetime.now().isoformat(),
            "task": task,
            "duration_minutes": duration_minutes,
            "completed": completed,
            "notes": notes
        }
        self.data["logs"].append(log_entry)
        self.save_data()
        return log_entry

    def get_project_progress(self, project_id):
        """Calculate progress on a project"""
        project_logs = [l for l in self.data["logs"] if l["project_id"] == project_id]
        completed_tasks = [l for l in project_logs if l["completed"]]
        total_minutes = sum(l["duration_minutes"] for l in project_logs)
        completed_minutes = sum(l["duration_minutes"] for l in completed_tasks)

        return {
            "total_tasks": len(project_logs),
            "completed_tasks": len(completed_tasks),
            "total_minutes": total_minutes,
            "completed_minutes": completed_minutes,
            "completion_rate": len(completed_tasks) / len(project_logs) * 100 if project_logs else 0
        }

    def check_lever_moving(self, project_id, weeks=2):
        """Check if lever-moving tasks are actually moving the needle"""
        cutoff = datetime.now() - timedelta(weeks=weeks)
        recent_logs = [l for l in self.data["logs"]
                      if l["project_id"] == project_id
                      and datetime.fromisoformat(l["date"]) > cutoff]

        if not recent_logs:
            return {
                "status": "no_activity",
                "message": "No activity in the past 2 weeks",
                "recommendation": "Start your daily 1-hour protocol immediately"
            }

        progress = self.get_project_progress(project_id)

        if progress["completion_rate"] < 50:
            return {
                "status": "low_engagement",
                "message": f"Only {progress['completion_rate']:.0f}% completion rate",
                "recommendation": "Review your goal hierarchy—are you working on the right levers?"
            }

        if progress["total_minutes"] < 60 * 14:  # 1 hour/day for 2 weeks
            return {
                "status": "insufficient_time",
                "message": f"Only {progress['total_minutes']/60:.1f} hours logged",
                "recommendation": "You need 1 hour/day minimum. Protect your time."
            }

        return {
            "status": "on_track",
            "message": f"Good progress: {progress['completed_tasks']} tasks completed",
            "recommendation": "Keep going—you're moving the right levers"
        }

    def weekly_review(self, project_id):
        """Generate weekly review summary"""
        progress = self.get_project_progress(project_id)
        lever_status = self.check_lever_moving(project_id)

        review = {
            "date": datetime.now().isoformat(),
            "tasks_completed": progress["completed_tasks"],
            "total_hours": progress["completed_minutes"] / 60,
            "completion_rate": progress["completion_rate"],
            "lever_status": lever_status["status"]
        }

        return review


def main():
    tracker = LeverTracker()

    print("=" * 60)
    print("LEVER-MOVING TASK TRACKER")
    print("=" * 60)
    print("\nOptions:")
    print("1. Log daily task")
    print("2. View project progress")
    print("3. Check if you're moving the right levers")
    print("4. Weekly review")
    print("5. Add new project")
    print("q. Quit")

    choice = input("\n> ")

    if choice == "1":
        print("\nLogging a daily task...")
        project_id = int(input("Project ID: "))
        task = input("Task description: ")
        duration = int(input("Duration (minutes): "))
        completed_input = input("Completed? (y/n): ")
        completed = completed_input.lower() == 'y'
        notes = input("Notes (optional): ")

        log = tracker.log_daily_task(project_id, task, duration, completed, notes)
        print(f"\nLogged: {task} ({duration} min) - {'Done' if completed else 'Not done'}")

    elif choice == "2":
        print("\nProject Progress:")
        for p in tracker.data["projects"]:
            if p["status"] == "active":
                prog = tracker.get_project_progress(p["id"])
                print(f"\n{p['name']} (ID: {p['id']})")
                print(f"  Tasks: {prog['completed_tasks']}/{prog['total_tasks']} completed")
                print(f"  Hours: {prog['completed_minutes']/60:.1f}")
                print(f"  Rate: {prog['completion_rate']:.0f}%")

    elif choice == "3":
        project_id = int(input("Project ID to check: "))
        status = tracker.check_lever_moving(project_id)
        print(f"\nStatus: {status['status'].upper()}")
        print(f"Message: {status['message']}")
        print(f"Recommendation: {status['recommendation']}")

    elif choice == "4":
        project_id = int(input("Project ID for weekly review: "))
        review = tracker.weekly_review(project_id)
        print(f"\nWeekly Review for Project {project_id}:")
        print(f"  Tasks Completed: {review['tasks_completed']}")
        print(f"  Total Hours: {review['total_hours']:.1f}")
        print(f"  Completion Rate: {review['completion_rate']:.0f}%")
        print(f"  Lever Status: {review['lever_status']}")

    elif choice == "5":
        print("\nAdding new project...")
        name = input("Project name: ")
        ten_year = input("10-year goal alignment: ")
        project = tracker.add_project(name, ten_year)
        print(f"\nCreated project: {name} (ID: {project['id']})")

    elif choice.lower() == "q":
        return

    else:
        print("Invalid choice")

    tracker.save_data()


if __name__ == "__main__":
    main()