
Personal Assistant
- 2.6k installs
- 432 repo stars
- Updated November 11, 2025
- ailabs-393/ai-labs-claude-skills
A personal assistant skill with persistent profile, tasks, schedule, and context databases for personalized schedule and productivity help.
About
Personal Assistant transforms Claude into a context-aware helper with persistent memory of user preferences, schedules, tasks, and goals. On first use it collects name, timezone, work hours, goals, routines, communication preferences, and recurring commitments, then saves via assistant_db.py to ~/.claude/personal_assistant/. Subsequent sessions load profile, tasks, schedule, and context before answering. Task management supports add, update, complete, and list operations through assistant_db.py and task_helper.py CLI with priority, due dates, and categories. Schedule management handles one-time and recurring events with conflict detection against existing commitments. Context tracking stores interactions, important notes, and temporary context with low, normal, and high importance levels controlling retention. Automatic cleanup removes completed tasks and old interactions after 30 days while preserving profiles, pending tasks, and high-importance notes. The skill applies user preferences for communication style, task organization, working hours, and goals when suggesting priorities, flagging conflicts, and proposing schedule optimizations. Example flows cover overwhelmed task list.
- First-run profile setup then persistent storage in ~/.claude/personal_assistant/
- Task, schedule, and context management via assistant_db.py and task_helper.py
- Conflict detection against recurring commitments and work hours
- Context importance levels control retention from 7 to indefinite days
- Automatic cleanup of completed tasks and old interactions after 30 days
Personal Assistant by the numbers
- 2,571 all-time installs (skills.sh)
- +12 installs in the week ending Aug 2, 2026 (Skillselion tracking)
- Ranked #203 of 3,280 Productivity & Planning skills by installs in the Skillselion catalog
- Security screen: MEDIUM risk (skills.sh audit)
- Data as of Aug 3, 2026 (Skillselion catalog sync)
personal-assistant capabilities & compatibility
- Capabilities
- collect and save user profile with timezone, wor · add, update, complete, and list tasks with prior · manage one time and recurring calendar events wi · track context with importance levels and automat · suggest goal aligned scheduling based on working
- Runs
- Runs locally
- Pricing
- Free
npx skills add https://github.com/ailabs-393/ai-labs-claude-skills --skill personal-assistantAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 2.6k |
|---|---|
| repo stars | ★ 432 |
| Security audit | 3 / 3 scanners passed |
| Last updated | November 11, 2025 |
| Repository | ailabs-393/ai-labs-claude-skills ↗ |
How do agents provide personalized schedule and task help without re-asking preferences every session?
Provide personalized schedule, task, reminder, and habit assistance with persistent profile, tasks, and context stored in local JSON databases.
Who is it for?
Users requesting schedule management, task tracking, reminders, habit monitoring, or productivity advice with continuity across sessions.
Skip if: Skip when the user needs enterprise team project management or calendar integrations beyond local JSON storage.
When should I use this skill?
Use for personal assistance tasks including schedule management, task tracking, reminders, habit monitoring, and time management queries.
What you get
Context-aware assistance using stored profile, tasks, events, and notes with conflict checks and goal-aligned suggestions.
- persistent user context database
- prioritized task and schedule summaries
Files
Personal Assistant
Overview
This skill transforms Claude into a comprehensive personal assistant with persistent memory of user preferences, schedules, tasks, and context. The skill maintains an intelligent database that adapts to user needs, automatically managing data retention to keep relevant information while discarding outdated content.
When to Use This Skill
Invoke this skill for personal assistance queries, including:
- Task management and to-do lists
- Schedule and calendar management
- Reminder setting and tracking
- Habit monitoring and productivity tips
- Time management and planning
- Personal goal tracking
- Routine optimization
- Preference-based recommendations
- Context-aware assistance
Workflow
Step 1: Check for Existing Profile
Before providing any personalized assistance, always check if a user profile exists:
python3 scripts/assistant_db.py has_profileIf the output is "false", proceed to Step 2 (Initial Setup). If "true", proceed to Step 3 (Load Profile and Context).
Step 2: Initial Profile Setup (First Run Only)
When no profile exists, collect comprehensive information from the user. Use a conversational, friendly approach to gather this data.
Essential Information to Collect:
1. Personal Details
- Name and preferred form of address
- Timezone
- Location (city/country)
2. Schedule & Working Habits
- Typical work hours
- Work schedule type (9-5, flexible, shift work, etc.)
- Preferred working times (morning person vs night owl)
- Break preferences
- Meeting preferences
3. Goals & Priorities
- Short-term goals (next 1-3 months)
- Long-term goals (6+ months)
- Priority areas (career, health, relationships, learning, etc.)
- Success metrics
4. Habits & Routines
- Morning routine
- Evening routine
- Exercise habits
- Sleep schedule
- Meal times
5. Preferences & Communication Style
- Communication preference (detailed vs concise)
- Reminder style (gentle vs firm)
- Notification preferences
- Task organization style (by priority, category, time, etc.)
6. Current Commitments
- Recurring commitments (weekly meetings, classes, etc.)
- Regular activities (gym, hobbies, etc.)
- Family or social obligations
7. Tools & Integration
- Calendar system used (Google, Outlook, Apple, etc.)
- Task management preferences
- Note-taking system
Example Setup Flow:
Hi! I'm your personal assistant. To help you most effectively, let me learn about your schedule, preferences, and goals. This will take just a few minutes.
Let's start with the basics:
1. What's your name, and how would you like me to address you?
2. What timezone are you in?
3. What's your typical work schedule like?
[Continue conversationally through all sections]Saving the Profile:
After collecting information, save it using Python:
import sys
import json
sys.path.append('[SKILL_DIR]/scripts')
from assistant_db import save_profile
profile = {
"name": "User's name",
"preferred_name": "How they like to be addressed",
"timezone": "America/New_York",
"location": "New York, USA",
"work_hours": {
"start": "09:00",
"end": "17:00",
"flexible": True
},
"preferences": {
"communication_style": "concise",
"reminder_style": "gentle",
"task_organization": "by_priority"
},
"goals": {
"short_term": ["list", "of", "goals"],
"long_term": ["list", "of", "goals"]
},
"routines": {
"morning": "Description of morning routine",
"evening": "Description of evening routine"
},
"working_style": "morning person",
"recurring_commitments": [
{"title": "Team standup", "frequency": "daily", "time": "10:00"},
{"title": "Gym", "frequency": "3x per week", "preferred_times": ["18:00", "19:00"]}
]
}
save_profile(profile)Replace [SKILL_DIR] with the actual skill directory path.
Confirmation:
Perfect! I've saved your profile. From now on, I'll provide personalized assistance based on your schedule, preferences, and goals. I'll help you stay organized, track your tasks, and optimize your time.
You can update your profile anytime by asking me to modify your preferences or schedule.Step 3: Load Profile and Context
For all personal assistance queries, load the user's data:
# Check profile status
python3 scripts/assistant_db.py has_profile
# Get full profile
python3 scripts/assistant_db.py get_profile
# Get current tasks
python3 scripts/assistant_db.py get_tasks
# Get schedule
python3 scripts/assistant_db.py get_schedule
# Get context and notes
python3 scripts/assistant_db.py get_context
# Get quick summary
python3 scripts/assistant_db.py summaryOr use Python imports for more control:
import sys
sys.path.append('[SKILL_DIR]/scripts')
from assistant_db import get_profile, get_tasks, get_schedule, get_context
profile = get_profile()
tasks = get_tasks()
schedule = get_schedule()
context = get_context()Step 4: Provide Personalized Assistance
Apply the loaded profile and context to provide tailored assistance:
Key Principles:
1. Respect User Preferences
- Use their preferred communication style
- Follow their task organization preferences
- Honor their working hours and routines
2. Leverage Context
- Reference their goals when suggesting tasks
- Consider their schedule when proposing activities
- Adapt to their working style (morning person, etc.)
3. Be Proactive
- Suggest task prioritization based on goals
- Remind about recurring commitments
- Flag scheduling conflicts
- Propose routine optimizations
4. Maintain Context
- Track important interactions
- Remember ongoing projects
- Note temporary context for continuity
Example Applications:
Scenario 1: Task Management
User: "I need to finish the quarterly report"
Claude: [Loads profile - finds: works 9-5, morning person, prefers focused blocks]
I'll add that to your tasks. Based on your preference for morning work, I recommend
scheduling this during your 9-11am block tomorrow when you're most productive.
The report is due when? I'll set an appropriate priority and reminder.
[Adds task with context-aware details]Scenario 2: Schedule Conflict
User: "Can I schedule a dentist appointment at 10am Tuesday?"
Claude: [Checks schedule - finds: Team standup at 10am daily]
I notice you have your daily team standup at 10am. Would you like to:
1. Schedule the dentist for 11am instead
2. Move your standup for that day
3. Choose a different day entirely
What works best for you?Scenario 3: Goal-Aligned Suggestion
User: "What should I focus on this week?"
Claude: [Loads profile - finds short-term goal: "Learn Python"]
Based on your goal to learn Python, I recommend dedicating 3-4 hours this week to:
1. Tuesday 7-8pm: Python tutorial (after gym, before evening routine)
2. Thursday 7-8pm: Practice exercises
3. Saturday 10-12pm: Build a small project
This fits your schedule and keeps you on track for your 3-month learning goal.
Shall I add these to your calendar?Step 5: Task Management Operations
Use the task management system for organizing user tasks:
Adding Tasks:
import sys
sys.path.append('[SKILL_DIR]/scripts')
from assistant_db import add_task, add_context
task = {
"title": "Complete quarterly report",
"description": "Q4 financial analysis",
"priority": "high", # high, medium, low
"category": "work",
"due_date": "2025-11-15",
"estimated_time": "3 hours"
}
add_task(task)
add_context("interaction", "Added Q4 report task", "normal")Quick Task Operations via CLI:
# List all tasks in formatted view
python3 scripts/task_helper.py list
# Add a quick task
python3 scripts/task_helper.py add "Buy groceries" medium "2025-11-08" personal
# Complete a task
python3 scripts/task_helper.py complete <task_id>
# View overdue tasks
python3 scripts/task_helper.py overdue
# View today's tasks
python3 scripts/task_helper.py today
# View this week's tasks
python3 scripts/task_helper.py week
# View tasks by category
python3 scripts/task_helper.py category workCompleting Tasks:
from assistant_db import complete_task
complete_task(task_id)Updating Tasks:
from assistant_db import update_task
update_task(task_id, {
"priority": "urgent",
"due_date": "2025-11-10"
})Step 6: Schedule and Event Management
Manage calendar events and recurring commitments:
Adding Events:
from assistant_db import add_event
# One-time event
event = {
"title": "Dentist appointment",
"date": "2025-11-12",
"time": "14:00",
"duration": "1 hour",
"location": "Downtown Dental",
"notes": "Bring insurance card"
}
add_event(event, recurring=False)
# Recurring event
recurring_event = {
"title": "Team standup",
"frequency": "daily",
"time": "10:00",
"duration": "15 minutes",
"days": ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday"]
}
add_event(recurring_event, recurring=True)Getting Upcoming Events:
from assistant_db import get_events
# Get events for next 7 days
upcoming = get_events(days_ahead=7)
# Get events for next 30 days
monthly = get_events(days_ahead=30)Step 7: Context Management and Memory
Maintain context for continuity and personalized assistance:
Adding Context:
from assistant_db import add_context
# Track an interaction
add_context("interaction", "User mentioned struggling with morning productivity", "normal")
# Add an important note (kept indefinitely)
add_context("note", "User prefers written communication over calls for work matters", "high")
# Add temporary context (auto-cleaned after 7 days)
add_context("temporary", "Currently working on project X deadline next week", "normal")Context Importance Levels:
"low"- Automatically cleaned up quickly"normal"- Standard retention (30 days for interactions, 7 days for temporary)"high"- Kept indefinitely (for important notes) or extended retention
Retrieving Context:
from assistant_db import get_context
# Get all context
all_context = get_context()
# Get specific type
interactions = get_context("recent_interactions")
notes = get_context("important_notes")
temp = get_context("temporary_context")Step 8: Intelligent Data Cleanup
The system automatically manages data retention, but you can trigger manual cleanup:
# Clean up data older than 30 days (default)
python3 scripts/assistant_db.py cleanup
# Clean up with custom retention period
python3 scripts/assistant_db.py cleanup 60What Gets Cleaned:
- ✓ Completed tasks older than retention period
- ✓ Past one-time events
- ✓ Old interactions (unless marked high importance)
- ✓ Temporary context older than 7 days
- ✗ User profile (never cleaned)
- ✗ Pending tasks (never cleaned)
- ✗ Important notes (never cleaned)
- ✗ Recurring events (never cleaned)
Step 9: Updating User Profile
When users want to update their profile or preferences:
from assistant_db import get_profile, save_profile
# Load current profile
profile = get_profile()
# Update specific fields
profile["work_hours"]["start"] = "08:00"
profile["preferences"]["reminder_style"] = "firm"
# Save updated profile
save_profile(profile)Or update schedule information:
from assistant_db import get_schedule, save_schedule
schedule = get_schedule()
schedule["working_hours"]["Friday"] = {"start": "09:00", "end": "15:00"}
save_schedule(schedule)Best Practices
1. Always Load Context First
- Check profile status before any personalized assistance
- Load relevant data (profile, tasks, schedule) at the start
2. Be Proactive
- Suggest task prioritization
- Flag scheduling conflicts
- Remind about goals
- Propose optimizations
3. Respect Preferences
- Honor communication style preferences
- Follow task organization preferences
- Respect working hours and boundaries
4. Maintain Continuity
- Track important interactions in context
- Reference previous conversations
- Remember ongoing projects
5. Keep Data Fresh
- Periodically run cleanup (suggest monthly)
- Mark important information appropriately
- Use temporary context for short-term tracking
6. Provide Value
- Make connections between tasks and goals
- Optimize schedules based on working style
- Offer personalized productivity insights
7. Update Incrementally
- If user mentions new preferences in conversation, offer to update profile
- Add new commitments to schedule as they arise
- Track context changes naturally
Example Interactions
Example 1: First-Time User
User: "Help me organize my week"
Claude: [Checks profile - finds none]
I'd love to help you organize your week! To provide the most personalized assistance,
let me first learn about your schedule and preferences. This will only take a few minutes.
What's your typical work schedule like? For example, do you work 9-5, have flexible
hours, or something else?
[Proceeds through profile setup]
Great! Now let me look at your week and help you organize it effectively...Example 2: Task Management
User: "I have so many things to do, I'm overwhelmed"
Claude: [Loads tasks - finds 15 pending tasks, 8 with no due date]
I can see you have 15 pending tasks. Let me help you prioritize based on your goals
and schedule.
High Priority (Due Soon):
1. Quarterly report - Due Tuesday (aligns with your career goals)
2. Client presentation - Due Thursday
Medium Priority (This Week):
3. Code review - No deadline but good for Friday afternoon
4. Team feedback - Due next Monday
Let's start with the top 2. Your morning blocks (9-11am) work best for focused work
like the quarterly report. Shall I schedule it for tomorrow morning?
[Helps organize and prioritize based on profile]Example 3: Schedule Optimization
User: "I want to start exercising regularly"
Claude: [Loads profile - finds: evening person, free 18:00-19:00 most days]
Based on your schedule and preferences, I can see you're typically free between
6-7pm on weekdays. This aligns well with your peak energy time in the evenings.
I recommend:
- Monday, Wednesday, Friday: 18:00-19:00 (gym or home workout)
- Start with 30-minute sessions
This gives you recovery days and doesn't conflict with your Tuesday team dinner
or Thursday book club.
Shall I add these as recurring events to your calendar?Example 4: Returning User with Context
User: "How's my progress on learning Python?"
Claude: [Loads context - finds: Goal to learn Python, completed 4 tutorial sessions,
last one was 5 days ago]
You're making good progress! You've completed 4 Python tutorial sessions over the
past 3 weeks. However, I notice it's been 5 days since your last session.
To maintain momentum toward your 3-month goal, let's schedule your next session.
Your usual Thursday 7pm slot is open tomorrow. Does that work?
Also, you're at the point where building a small project would be valuable. What
interests you - a web scraper, a to-do app, or something else?Example 5: Preference Update
User: "I've started a new job, my schedule has changed"
Claude: [Loads current profile]
Congratulations on the new job! Let me update your profile with your new schedule.
What are your new working hours? And have any of your recurring commitments changed?
[Collects updated information and saves]
Perfect! I've updated your profile with your new 8-4 schedule and remote work setup.
I'll adjust all my suggestions accordingly. Your morning productivity block is now
8-10am instead of 9-11am.Technical Notes
Data Storage Location: All data is stored in ~/.claude/personal_assistant/:
profile.json- User profile and preferencestasks.json- Task list and completed tasksschedule.json- Calendar events and recurring commitmentscontext.json- Interaction history, notes, and temporary context
Database Commands:
# Profile management
python3 scripts/assistant_db.py has_profile
python3 scripts/assistant_db.py get_profile
# Task management
python3 scripts/assistant_db.py get_tasks
# Schedule management
python3 scripts/assistant_db.py get_schedule
# Context management
python3 scripts/assistant_db.py get_context
# Utilities
python3 scripts/assistant_db.py summary # Quick overview
python3 scripts/assistant_db.py cleanup [days] # Clean old data
python3 scripts/assistant_db.py export # Export all data
python3 scripts/assistant_db.py reset # Reset everythingTask Helper Commands:
python3 scripts/task_helper.py list
python3 scripts/task_helper.py add <title> [priority] [due_date] [category]
python3 scripts/task_helper.py complete <task_id>
python3 scripts/task_helper.py overdue
python3 scripts/task_helper.py today
python3 scripts/task_helper.py week
python3 scripts/task_helper.py category <name>Data Retention Policy:
- User profile: Never auto-deleted
- Pending tasks: Never auto-deleted
- Completed tasks: Deleted after 30 days (configurable)
- One-time past events: Deleted after 30 days (configurable)
- Recurring events: Never auto-deleted
- Recent interactions: Deleted after 30 days unless marked "high" importance
- Important notes: Never auto-deleted
- Temporary context: Deleted after 7 days
Profile Data Structure:
{
"initialized": true,
"name": "John Doe",
"preferred_name": "John",
"timezone": "America/New_York",
"location": "New York, USA",
"work_hours": {
"start": "09:00",
"end": "17:00",
"flexible": true
},
"preferences": {
"communication_style": "concise",
"reminder_style": "gentle",
"task_organization": "by_priority"
},
"goals": {
"short_term": ["Learn Python", "Run 5K"],
"long_term": ["Career advancement", "Financial independence"]
},
"working_style": "morning person"
}Resources
scripts/assistant_db.py
Main database management module providing:
- Profile management (get, save, check initialization)
- Task CRUD operations (add, update, complete, delete)
- Schedule and event management
- Context tracking with importance levels
- Intelligent data cleanup
- Data export and summary functions
scripts/task_helper.py
Convenience script for quick task operations:
- Formatted task listings
- Quick task addition
- Task filtering (overdue, today, this week, by category)
- Task completion by ID or title match
export default async function personal_assistant(input) {
console.log("🧠 Running skill: personal-assistant");
// TODO: implement actual logic for this skill
return {
message: "Skill 'personal-assistant' executed successfully!",
input
};
}
{
"name": "@ai-labs-claude-skills/personal-assistant",
"version": "1.0.0",
"description": "Claude AI skill: personal-assistant",
"main": "index.js",
"files": [
"."
],
"license": "MIT",
"author": "AI Labs"
}Personal Assistant Capabilities Reference
Core Capabilities
This document provides detailed information about the personal assistant's capabilities and how to leverage them effectively.
1. Profile Management
Profile Components
Personal Information:
- Name and preferred form of address
- Timezone and location
- Contact preferences
Work & Schedule:
- Working hours (start, end, flexibility)
- Work environment (office, remote, hybrid)
- Break preferences
- Meeting preferences
- Preferred working times
Goals & Priorities:
- Short-term goals (1-3 months)
- Long-term goals (6+ months)
- Priority areas
- Success metrics and KPIs
Habits & Routines:
- Morning routine
- Evening routine
- Exercise habits
- Sleep schedule
- Meal patterns
- Self-care practices
Communication Preferences:
- Communication style (concise, detailed, balanced)
- Reminder style (gentle, firm, assertive)
- Notification preferences
- Preferred communication channels
Tools & Systems:
- Calendar system
- Task management tools
- Note-taking apps
- Email client
- Other productivity tools
2. Task Management
Task Properties
Every task can include:
- Title (required): Brief description
- Description (optional): Detailed information
- Priority: high, medium, low
- Category: work, personal, health, learning, etc.
- Due Date: ISO format (YYYY-MM-DD)
- Estimated Time: Duration to complete
- Status: pending, in_progress, completed
- Dependencies: Related tasks or prerequisites
- Tags: Custom labels for organization
Task Organization Strategies
By Priority:
- High priority tasks first
- Consider urgency vs importance
- Eisenhower Matrix approach
By Category:
- Group similar tasks together
- Context-switching optimization
- Focus on one area at a time
By Time:
- Chronological ordering
- Deadline-driven
- Time-blocking compatible
By Energy:
- High-energy tasks during peak hours
- Low-energy tasks during slow periods
- Match task difficulty to energy levels
Task Lifecycle
1. Creation: Task is added with initial details 2. Planning: Due date, priority, and category assigned 3. Scheduling: Task placed in calendar/schedule 4. Execution: Task marked in progress 5. Completion: Task marked complete and archived 6. Review: Periodic review of completed tasks
3. Schedule Management
Event Types
One-Time Events:
- Appointments
- Deadlines
- Special occasions
- Travel
- Social events
Recurring Events:
- Daily standups
- Weekly meetings
- Regular exercise
- Classes or courses
- Maintenance tasks
Schedule Optimization
Time Blocking:
- Dedicated blocks for focused work
- Buffer time between meetings
- Break blocks for rest
- Flexible blocks for unexpected tasks
Energy Management:
- Schedule important tasks during peak energy times
- Lighter tasks during low-energy periods
- Regular breaks to maintain energy
- Align task type with energy level
Conflict Resolution:
- Identify scheduling conflicts proactively
- Suggest alternative times
- Consider priority when resolving
- Maintain work-life balance
4. Context and Memory Management
Context Types
Recent Interactions:
- Recent conversations
- Decisions made
- Information shared
- Standard retention: 30 days
- High importance: Kept longer
Important Notes:
- Key preferences
- Critical information
- Long-term references
- Never auto-deleted
- Always available
Temporary Context:
- Short-term projects
- Current focus areas
- Transient information
- Auto-cleaned after 7 days
- For immediate continuity
Context Importance Levels
Low Importance:
- Routine interactions
- Minor details
- Quick cleanup (7-14 days)
Normal Importance:
- Standard interactions
- Regular updates
- Medium retention (30 days)
High Importance:
- Critical information
- Key preferences
- Long-term or indefinite retention
Intelligent Data Retention
The system automatically:
- Removes outdated completed tasks
- Cleans up old temporary context
- Archives past events
- Retains important notes indefinitely
- Keeps high-importance items longer
Manual cleanup can be triggered:
- Monthly recommended
- Custom retention periods
- Selective cleanup options
5. Personalization Strategies
Communication Adaptation
Concise Style:
- Brief, to-the-point responses
- Bullet points and lists
- Action-oriented
- Minimal elaboration
Detailed Style:
- Comprehensive explanations
- Context and reasoning
- Multiple options explained
- Thorough background
Balanced Style:
- Mix of brief and detailed
- Context when needed
- Summary + details available
- Flexible approach
Recommendation Personalization
Based on Goals:
- Connect tasks to objectives
- Prioritize goal-aligned activities
- Track progress toward goals
- Celebrate milestones
Based on Schedule:
- Respect working hours
- Consider availability
- Account for energy patterns
- Avoid conflicts
Based on Preferences:
- Honor communication style
- Follow organization preferences
- Respect boundaries
- Adapt to feedback
Proactive Assistance
Anticipate Needs:
- Remind about upcoming deadlines
- Suggest task prioritization
- Flag potential conflicts
- Propose optimizations
Provide Context:
- Reference previous interactions
- Connect to goals
- Explain reasoning
- Offer alternatives
Learn and Adapt:
- Track what works
- Adjust recommendations
- Refine approach
- Improve over time
6. Productivity Insights
Time Management
Focus Time:
- Identify peak productivity hours
- Schedule important work accordingly
- Minimize interruptions during focus time
- Protect deep work blocks
Meeting Management:
- Batch meetings when possible
- Maintain meeting-free days
- Limit meeting duration
- Ensure meeting necessity
Break Optimization:
- Regular breaks prevent burnout
- Pomodoro technique support
- Active vs passive breaks
- Movement and rest balance
Goal Tracking
Progress Monitoring:
- Regular check-ins on goals
- Milestone celebrations
- Adjustment when needed
- Obstacle identification
Habit Formation:
- Consistency over intensity
- Small wins compound
- Track streaks
- Build on success
Accountability:
- Regular progress reports
- Gentle reminders
- Success reinforcement
- Course correction support
7. Best Use Cases
Daily Planning
"What should I focus on today?"
- Reviews pending tasks
- Checks schedule
- Considers goals
- Suggests priorities
Weekly Review
"Help me plan my week"
- Overview of commitments
- Task distribution
- Goal alignment
- Balance check
Task Overwhelm
"I have too much to do"
- Prioritization assistance
- Breaking down large tasks
- Delegation suggestions
- Realistic scheduling
Goal Setting
"Help me achieve X"
- Break down goal
- Create action plan
- Schedule activities
- Track progress
Schedule Conflicts
"I need to reschedule X"
- Find alternatives
- Consider priorities
- Minimize disruption
- Propose solutions
Productivity Coaching
"I'm not being productive"
- Analyze patterns
- Identify blockers
- Suggest strategies
- Provide support
8. Integration Tips
Calendar Sync
While the assistant maintains its own schedule, it works best when:
- You mention calendar updates
- You reference external calendars
- You sync important events manually
- You keep the assistant informed
Task System Sync
For best results:
- Add tasks as they arise
- Update status regularly
- Review completed tasks
- Archive when appropriate
Note-Taking Integration
Complement existing systems:
- Important notes → assistant context
- Project notes → task descriptions
- Meeting notes → event details
- Reference notes → profile updates
9. Privacy and Data Management
Data Location
All data stored locally:
~/.claude/personal_assistant/- User-owned and controlled
- No external syncing
- Easily exportable
Data Export
Export all data anytime:
python3 scripts/assistant_db.py export > backup.jsonData Reset
Complete reset if needed:
python3 scripts/assistant_db.py resetSelective Cleanup
Remove old data while keeping important items:
python3 scripts/assistant_db.py cleanup 3010. Advanced Features
Batch Operations
Perform multiple actions:
- Add multiple tasks at once
- Schedule multiple events
- Update multiple preferences
- Bulk task completion
Smart Reminders
Context-aware reminders:
- Consider location
- Check schedule
- Account for dependencies
- Respect preferences
Habit Tracking
Build and maintain habits:
- Daily habit check-ins
- Streak tracking
- Completion patterns
- Obstacle identification
Energy Mapping
Optimize based on energy:
- Track energy patterns
- Schedule accordingly
- Identify energy drains
- Maximize peak times
Goal Cascading
Break down large goals:
- Major goal → sub-goals
- Sub-goals → action items
- Action items → scheduled tasks
- Scheduled tasks → completed actions
#!/usr/bin/env python3
"""
Personal Assistant Database Manager
Manages user profile, schedule, preferences, tasks, and context information
with intelligent data retention and cleanup.
"""
import json
import os
from pathlib import Path
from datetime import datetime, timedelta
from typing import Dict, Any, List, Optional
DB_DIR = Path.home() / ".claude" / "personal_assistant"
PROFILE_FILE = DB_DIR / "profile.json"
TASKS_FILE = DB_DIR / "tasks.json"
SCHEDULE_FILE = DB_DIR / "schedule.json"
CONTEXT_FILE = DB_DIR / "context.json"
def ensure_db_files() -> None:
"""Ensure all database files exist."""
DB_DIR.mkdir(parents=True, exist_ok=True)
default_files = {
PROFILE_FILE: {
"initialized": False,
"created_at": datetime.now().isoformat()
},
TASKS_FILE: {
"tasks": [],
"completed_tasks": []
},
SCHEDULE_FILE: {
"working_hours": {},
"recurring_events": [],
"one_time_events": []
},
CONTEXT_FILE: {
"recent_interactions": [],
"important_notes": [],
"temporary_context": []
}
}
for file_path, default_data in default_files.items():
if not file_path.exists():
file_path.write_text(json.dumps(default_data, indent=2))
def load_json(file_path: Path) -> Dict[str, Any]:
"""Load JSON from file."""
ensure_db_files()
try:
with open(file_path, 'r') as f:
return json.load(f)
except (json.JSONDecodeError, FileNotFoundError):
return {}
def save_json(file_path: Path, data: Dict[str, Any]) -> None:
"""Save JSON to file."""
ensure_db_files()
with open(file_path, 'w') as f:
json.dump(data, f, indent=2)
# ============================================================================
# PROFILE MANAGEMENT
# ============================================================================
def get_profile() -> Dict[str, Any]:
"""Get user profile."""
return load_json(PROFILE_FILE)
def save_profile(profile_data: Dict[str, Any]) -> None:
"""Save user profile."""
profile = load_json(PROFILE_FILE)
profile.update(profile_data)
profile["initialized"] = True
profile["last_updated"] = datetime.now().isoformat()
save_json(PROFILE_FILE, profile)
def has_profile() -> bool:
"""Check if profile is initialized."""
profile = load_json(PROFILE_FILE)
return profile.get("initialized", False)
# ============================================================================
# TASK MANAGEMENT
# ============================================================================
def get_tasks(include_completed: bool = False) -> Dict[str, List[Dict]]:
"""Get all tasks."""
tasks_data = load_json(TASKS_FILE)
if include_completed:
return tasks_data
return {"tasks": tasks_data.get("tasks", [])}
def add_task(task: Dict[str, Any]) -> None:
"""Add a new task."""
tasks_data = load_json(TASKS_FILE)
task["id"] = datetime.now().timestamp()
task["created_at"] = datetime.now().isoformat()
task["status"] = task.get("status", "pending")
tasks_data["tasks"].append(task)
save_json(TASKS_FILE, tasks_data)
def update_task(task_id: float, updates: Dict[str, Any]) -> bool:
"""Update an existing task."""
tasks_data = load_json(TASKS_FILE)
for task in tasks_data["tasks"]:
if task["id"] == task_id:
task.update(updates)
task["updated_at"] = datetime.now().isoformat()
save_json(TASKS_FILE, tasks_data)
return True
return False
def complete_task(task_id: float) -> bool:
"""Mark a task as completed and move it to completed tasks."""
tasks_data = load_json(TASKS_FILE)
for i, task in enumerate(tasks_data["tasks"]):
if task["id"] == task_id:
task["status"] = "completed"
task["completed_at"] = datetime.now().isoformat()
tasks_data["tasks"].pop(i)
tasks_data["completed_tasks"].append(task)
save_json(TASKS_FILE, tasks_data)
return True
return False
def delete_task(task_id: float) -> bool:
"""Delete a task."""
tasks_data = load_json(TASKS_FILE)
for i, task in enumerate(tasks_data["tasks"]):
if task["id"] == task_id:
tasks_data["tasks"].pop(i)
save_json(TASKS_FILE, tasks_data)
return True
return False
# ============================================================================
# SCHEDULE MANAGEMENT
# ============================================================================
def get_schedule() -> Dict[str, Any]:
"""Get user schedule."""
return load_json(SCHEDULE_FILE)
def save_schedule(schedule_data: Dict[str, Any]) -> None:
"""Save schedule information."""
schedule = load_json(SCHEDULE_FILE)
schedule.update(schedule_data)
save_json(SCHEDULE_FILE, schedule)
def add_event(event: Dict[str, Any], recurring: bool = False) -> None:
"""Add a calendar event."""
schedule = load_json(SCHEDULE_FILE)
event["id"] = datetime.now().timestamp()
event["created_at"] = datetime.now().isoformat()
if recurring:
schedule["recurring_events"].append(event)
else:
schedule["one_time_events"].append(event)
save_json(SCHEDULE_FILE, schedule)
def get_events(days_ahead: int = 7) -> List[Dict[str, Any]]:
"""Get upcoming events for the next N days."""
schedule = load_json(SCHEDULE_FILE)
cutoff_date = datetime.now() + timedelta(days=days_ahead)
upcoming = []
for event in schedule.get("one_time_events", []):
if "date" in event:
event_date = datetime.fromisoformat(event["date"])
if event_date <= cutoff_date:
upcoming.append(event)
# Include all recurring events
upcoming.extend(schedule.get("recurring_events", []))
return upcoming
# ============================================================================
# CONTEXT MANAGEMENT (Intelligent Data Retention)
# ============================================================================
def add_context(context_type: str, content: str, importance: str = "normal") -> None:
"""
Add context information.
Args:
context_type: "interaction", "note", or "temporary"
content: The context content
importance: "low", "normal", or "high"
"""
context_data = load_json(CONTEXT_FILE)
context_item = {
"id": datetime.now().timestamp(),
"content": content,
"importance": importance,
"timestamp": datetime.now().isoformat()
}
if context_type == "interaction":
context_data["recent_interactions"].append(context_item)
elif context_type == "note":
context_data["important_notes"].append(context_item)
elif context_type == "temporary":
context_data["temporary_context"].append(context_item)
save_json(CONTEXT_FILE, context_data)
def get_context(context_type: Optional[str] = None) -> Dict[str, Any]:
"""Get context information."""
context_data = load_json(CONTEXT_FILE)
if context_type:
return {context_type: context_data.get(context_type, [])}
return context_data
def cleanup_old_data(days_to_keep: int = 30) -> Dict[str, int]:
"""
Intelligently clean up old data.
- Remove completed tasks older than days_to_keep
- Remove old temporary context
- Keep important notes regardless of age
- Remove old one-time events
Returns count of items removed.
"""
cutoff_date = datetime.now() - timedelta(days=days_to_keep)
removed_counts = {
"tasks": 0,
"events": 0,
"interactions": 0,
"temporary": 0
}
# Clean up old completed tasks
tasks_data = load_json(TASKS_FILE)
original_count = len(tasks_data.get("completed_tasks", []))
tasks_data["completed_tasks"] = [
task for task in tasks_data.get("completed_tasks", [])
if datetime.fromisoformat(task.get("completed_at", datetime.now().isoformat())) > cutoff_date
]
removed_counts["tasks"] = original_count - len(tasks_data["completed_tasks"])
save_json(TASKS_FILE, tasks_data)
# Clean up old one-time events
schedule = load_json(SCHEDULE_FILE)
original_count = len(schedule.get("one_time_events", []))
schedule["one_time_events"] = [
event for event in schedule.get("one_time_events", [])
if "date" not in event or datetime.fromisoformat(event["date"]) > cutoff_date
]
removed_counts["events"] = original_count - len(schedule["one_time_events"])
save_json(SCHEDULE_FILE, schedule)
# Clean up old context (keep important notes)
context_data = load_json(CONTEXT_FILE)
# Keep only recent interactions
original_count = len(context_data.get("recent_interactions", []))
context_data["recent_interactions"] = [
item for item in context_data.get("recent_interactions", [])
if datetime.fromisoformat(item.get("timestamp", datetime.now().isoformat())) > cutoff_date
or item.get("importance") == "high"
]
removed_counts["interactions"] = original_count - len(context_data["recent_interactions"])
# Remove all temporary context older than 7 days
temp_cutoff = datetime.now() - timedelta(days=7)
original_count = len(context_data.get("temporary_context", []))
context_data["temporary_context"] = [
item for item in context_data.get("temporary_context", [])
if datetime.fromisoformat(item.get("timestamp", datetime.now().isoformat())) > temp_cutoff
]
removed_counts["temporary"] = original_count - len(context_data["temporary_context"])
save_json(CONTEXT_FILE, context_data)
return removed_counts
# ============================================================================
# UTILITY FUNCTIONS
# ============================================================================
def reset_all() -> None:
"""Reset all data (use with caution)."""
for file_path in [PROFILE_FILE, TASKS_FILE, SCHEDULE_FILE, CONTEXT_FILE]:
if file_path.exists():
file_path.unlink()
ensure_db_files()
def export_all() -> Dict[str, Any]:
"""Export all data as a single JSON object."""
return {
"profile": get_profile(),
"tasks": get_tasks(include_completed=True),
"schedule": get_schedule(),
"context": get_context(),
"exported_at": datetime.now().isoformat()
}
def get_summary() -> Dict[str, Any]:
"""Get a summary of all stored data."""
tasks_data = get_tasks(include_completed=True)
schedule = get_schedule()
context_data = get_context()
return {
"profile_initialized": has_profile(),
"pending_tasks": len(tasks_data.get("tasks", [])),
"completed_tasks": len(tasks_data.get("completed_tasks", [])),
"recurring_events": len(schedule.get("recurring_events", [])),
"upcoming_events": len(schedule.get("one_time_events", [])),
"recent_interactions": len(context_data.get("recent_interactions", [])),
"important_notes": len(context_data.get("important_notes", [])),
"temporary_context": len(context_data.get("temporary_context", []))
}
# ============================================================================
# CLI INTERFACE
# ============================================================================
if __name__ == "__main__":
import sys
if len(sys.argv) < 2:
print("Personal Assistant Database Manager")
print("\nUsage:")
print(" python3 assistant_db.py has_profile")
print(" python3 assistant_db.py get_profile")
print(" python3 assistant_db.py get_tasks")
print(" python3 assistant_db.py get_schedule")
print(" python3 assistant_db.py get_context")
print(" python3 assistant_db.py summary")
print(" python3 assistant_db.py cleanup [days]")
print(" python3 assistant_db.py export")
print(" python3 assistant_db.py reset")
sys.exit(1)
command = sys.argv[1]
if command == "has_profile":
print("true" if has_profile() else "false")
elif command == "get_profile":
print(json.dumps(get_profile(), indent=2))
elif command == "get_tasks":
print(json.dumps(get_tasks(include_completed=True), indent=2))
elif command == "get_schedule":
print(json.dumps(get_schedule(), indent=2))
elif command == "get_context":
print(json.dumps(get_context(), indent=2))
elif command == "summary":
print(json.dumps(get_summary(), indent=2))
elif command == "cleanup":
days = int(sys.argv[2]) if len(sys.argv) > 2 else 30
removed = cleanup_old_data(days)
print(f"Cleaned up old data (kept last {days} days):")
print(json.dumps(removed, indent=2))
elif command == "export":
print(json.dumps(export_all(), indent=2))
elif command == "reset":
confirm = input("Are you sure you want to reset all data? (yes/no): ")
if confirm.lower() == "yes":
reset_all()
print("All data has been reset.")
else:
print("Reset cancelled.")
else:
print(f"Unknown command: {command}")
sys.exit(1)
#!/usr/bin/env python3
"""
Quick Task Management Helper
Provides convenient functions for common task operations.
"""
import sys
from pathlib import Path
# Add the scripts directory to the path
sys.path.insert(0, str(Path(__file__).parent))
from assistant_db import (
add_task, get_tasks, update_task, complete_task,
delete_task, add_context
)
import json
from datetime import datetime, timedelta
def list_tasks_formatted() -> str:
"""Return formatted list of pending tasks."""
tasks_data = get_tasks()
tasks = tasks_data.get("tasks", [])
if not tasks:
return "No pending tasks."
output = ["=== Pending Tasks ===\n"]
# Sort by priority and due date
priority_order = {"high": 0, "medium": 1, "low": 2, "": 3}
sorted_tasks = sorted(
tasks,
key=lambda t: (
priority_order.get(t.get("priority", ""), 3),
t.get("due_date", "9999-12-31")
)
)
for i, task in enumerate(sorted_tasks, 1):
priority = task.get("priority", "")
priority_str = f"[{priority.upper()}] " if priority else ""
due_date = task.get("due_date", "")
due_str = f" (Due: {due_date})" if due_date else ""
category = task.get("category", "")
cat_str = f" [{category}]" if category else ""
output.append(f"{i}. {priority_str}{task.get('title', 'Untitled')}{due_str}{cat_str}")
if task.get("description"):
output.append(f" {task['description']}")
output.append(f" ID: {task['id']}\n")
return "\n".join(output)
def add_quick_task(title: str, priority: str = "", due_date: str = "",
category: str = "", description: str = "") -> str:
"""Add a task with convenient parameters."""
task = {
"title": title,
"description": description,
"priority": priority,
"category": category,
"status": "pending"
}
if due_date:
task["due_date"] = due_date
add_task(task)
add_context("interaction", f"Added task: {title}", "normal")
return f"✓ Task added: {title}"
def get_overdue_tasks() -> List[Dict]:
"""Get tasks that are overdue."""
tasks_data = get_tasks()
tasks = tasks_data.get("tasks", [])
today = datetime.now().date()
overdue = []
for task in tasks:
if "due_date" in task:
due = datetime.fromisoformat(task["due_date"]).date()
if due < today:
overdue.append(task)
return overdue
def get_tasks_by_category(category: str) -> List[Dict]:
"""Get tasks filtered by category."""
tasks_data = get_tasks()
tasks = tasks_data.get("tasks", [])
return [t for t in tasks if t.get("category", "").lower() == category.lower()]
def get_today_tasks() -> List[Dict]:
"""Get tasks due today."""
tasks_data = get_tasks()
tasks = tasks_data.get("tasks", [])
today = datetime.now().date().isoformat()
return [t for t in tasks if t.get("due_date", "") == today]
def get_this_week_tasks() -> List[Dict]:
"""Get tasks due this week."""
tasks_data = get_tasks()
tasks = tasks_data.get("tasks", [])
today = datetime.now().date()
week_end = today + timedelta(days=7)
week_tasks = []
for task in tasks:
if "due_date" in task:
due = datetime.fromisoformat(task["due_date"]).date()
if today <= due <= week_end:
week_tasks.append(task)
return week_tasks
def mark_complete_by_title(title: str) -> str:
"""Complete a task by its title (fuzzy match)."""
tasks_data = get_tasks()
tasks = tasks_data.get("tasks", [])
title_lower = title.lower()
for task in tasks:
if title_lower in task.get("title", "").lower():
complete_task(task["id"])
add_context("interaction", f"Completed task: {task['title']}", "normal")
return f"✓ Completed: {task['title']}"
return f"✗ Task not found: {title}"
if __name__ == "__main__":
import sys
from typing import List
if len(sys.argv) < 2:
print("Task Helper")
print("\nUsage:")
print(" python3 task_helper.py list")
print(" python3 task_helper.py add <title> [priority] [due_date] [category]")
print(" python3 task_helper.py complete <task_id>")
print(" python3 task_helper.py overdue")
print(" python3 task_helper.py today")
print(" python3 task_helper.py week")
print(" python3 task_helper.py category <category_name>")
sys.exit(1)
command = sys.argv[1]
if command == "list":
print(list_tasks_formatted())
elif command == "add":
if len(sys.argv) < 3:
print("Error: Title required")
sys.exit(1)
title = sys.argv[2]
priority = sys.argv[3] if len(sys.argv) > 3 else ""
due_date = sys.argv[4] if len(sys.argv) > 4 else ""
category = sys.argv[5] if len(sys.argv) > 5 else ""
print(add_quick_task(title, priority, due_date, category))
elif command == "complete":
if len(sys.argv) < 3:
print("Error: Task ID required")
sys.exit(1)
task_id = float(sys.argv[2])
if complete_task(task_id):
print(f"✓ Task {task_id} completed")
else:
print(f"✗ Task {task_id} not found")
elif command == "overdue":
tasks = get_overdue_tasks()
print(json.dumps(tasks, indent=2))
elif command == "today":
tasks = get_today_tasks()
print(json.dumps(tasks, indent=2))
elif command == "week":
tasks = get_this_week_tasks()
print(json.dumps(tasks, indent=2))
elif command == "category":
if len(sys.argv) < 3:
print("Error: Category name required")
sys.exit(1)
category = sys.argv[2]
tasks = get_tasks_by_category(category)
print(json.dumps(tasks, indent=2))
else:
print(f"Unknown command: {command}")
sys.exit(1)
Related skills
How it compares
Pick personal-assistant over generic chat memory when you need structured schedule, habit, and task tracking with explicit priority organization across projects.
FAQ
Where is user data stored?
In ~/.claude/personal_assistant/ as profile.json, tasks.json, schedule.json, and context.json managed by assistant_db.py.
What happens on first use?
The skill runs has_profile check, collects schedule, goals, routines, and preferences conversationally, then saves via save_profile.
How does data cleanup work?
Completed tasks and old interactions clean after 30 days by default. Profiles, pending tasks, and high-importance notes are never auto-deleted.
Is Personal Assistant safe to install?
skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.