create-arete-workspace 0.2.0

package/packages/gatsaeng-os/python/proactive.py

@@ -0,0 +1,158 @@
+"""Proactive Engine — 패턴 감지 + 사전 알림 시스템."""
+
+from datetime import date, timedelta, datetime
+from typing import Optional
+
+import vault_io
+import timing_engine
+
+
+def check_all() -> list[dict]:
+    """모든 proactive 체크를 실행하고 알림 목록 반환."""
+    alerts = []
+    alerts.extend(check_skipped_routines())
+    alerts.extend(check_dday_warnings())
+    alerts.extend(check_streak_danger())
+    alerts.extend(check_reanalysis_due())
+    alerts.extend(check_energy_pattern())
+    return alerts
+
+
+def check_skipped_routines() -> list[dict]:
+    """2일 이상 연속 스킵된 루틴 감지."""
+    alerts = []
+    skips = vault_io.get_consecutive_skips()
+
+    for rid, count in skips.items():
+        if count >= 2:
+            routine = vault_io.get_entity('routines', rid)
+            if not routine:
+                continue
+            title = routine['data'].get('title', rid)
+
+            if count >= 4:
+                severity = 'critical'
+                msg = f'"{title}" {count}일 연속 스킵. 습관 체인 끊길 위험. 루틴 재설계 검토 필요.'
+            elif count >= 2:
+                severity = 'warning'
+                msg = f'"{title}" {count}일 연속 스킵. 오늘 반드시 실행하라.'
+
+            alerts.append({
+                'type': 'skipped_routine',
+                'severity': severity,
+                'title': f'{title} — {count}일 연속 미실행',
+                'message': msg,
+                'routine_id': rid,
+            })
+
+    return alerts
+
+
+def check_dday_warnings() -> list[dict]:
+    """마일스톤 D-day 경고."""
+    alerts = []
+    milestones = vault_io.get_active_milestones()
+
+    for m in milestones:
+        d = m.get('d_day', 999)
+        title = m.get('title', '?')
+        progress = 0
+        target = m.get('target_value', 0)
+        if target > 0:
+            progress = round(m.get('current_value', 0) / target * 100)
+
+        if d <= 0:
+            alerts.append({
+                'type': 'deadline',
+                'severity': 'critical',
+                'title': f'{title} — D-Day 초과!',
+                'message': f'마감 {abs(d)}일 초과. 진행률 {progress}%. 즉시 완료하거나 마감 재조정.',
+                'milestone_id': m.get('id'),
+            })
+        elif d <= 3:
+            alerts.append({
+                'type': 'milestone_dday',
+                'severity': 'critical',
+                'title': f'{title} — D-{d}',
+                'message': f'진행률 {progress}%. 남은 {m.get("target_value", 0) - m.get("current_value", 0)} {m.get("unit", "")} 집중.',
+                'milestone_id': m.get('id'),
+            })
+        elif d <= 7:
+            alerts.append({
+                'type': 'milestone_dday',
+                'severity': 'warning',
+                'title': f'{title} — D-{d}',
+                'message': f'진행률 {progress}%. 마감 {d}일 전.',
+                'milestone_id': m.get('id'),
+            })
+
+    return alerts
+
+
+def check_streak_danger() -> list[dict]:
+    """스트릭 위험 감지 — 오후 9시 이후 미완료 루틴 존재 시."""
+    now = datetime.now()
+    if now.hour < 21:
+        return []
+
+    unchecked = vault_io.get_unchecked_today()
+    if not unchecked:
+        return []
+
+    streaks = vault_io.get_active_streaks()
+    current = streaks.get('current', 0)
+
+    if current >= 3:
+        return [{
+            'type': 'streak_danger',
+            'severity': 'warning',
+            'title': f'{current}일 스트릭 끊길 위험!',
+            'message': f'{len(unchecked)}개 루틴 미완료. 자기 전에 처리하라.',
+        }]
+
+    return []
+
+
+def check_reanalysis_due() -> list[dict]:
+    """재분석 필요한 목표 감지."""
+    alerts = []
+    due = timing_engine.get_all_due_reanalyses()
+
+    for gid in due:
+        goal = vault_io.read_goal(gid)
+        if not goal:
+            continue
+        alerts.append({
+            'type': 'reanalysis_due',
+            'severity': 'info',
+            'title': f'"{goal["data"].get("title", "?")}" 재분석 필요',
+            'message': '2주 경과. Goal Context Agent 재실행 추천.',
+            'goal_id': gid,
+        })
+
+    return alerts
+
+
+def check_energy_pattern() -> list[dict]:
+    """에너지 패턴 감지 — 최근 3일 연속 low energy."""
+    alerts = []
+    today = date.today()
+
+    low_days = 0
+    for i in range(3):
+        d = (today - timedelta(days=i)).isoformat()
+        log = vault_io.get_entity_by_date('energy_logs', d)
+        if log and 'entries' in log['data']:
+            avg = sum(e.get('level', 3) for e in log['data']['entries']) / max(len(log['data']['entries']), 1)
+            if avg <= 2:
+                low_days += 1
+
+    if low_days >= 3:
+        alerts.append({
+            'type': 'energy_warning',
+            'severity': 'warning',
+            'title': '3일 연속 저에너지 감지',
+            'message': '회복 우선. 루틴을 절반으로 줄이고 수면/운동부터.',
+        })
+
+    return alerts

package/packages/gatsaeng-os/python/requirements.txt

@@ -0,0 +1,11 @@
+fastapi==0.115.0
+uvicorn==0.30.0
+python-frontmatter==1.1.0
+pyyaml==6.0.2
+anthropic==0.49.0
+python-telegram-bot==21.5
+apscheduler==3.10.4
+python-dotenv==1.0.1
+python-multipart==0.0.9
+aiofiles==24.1.0
+pytz==2024.2

package/packages/gatsaeng-os/python/run.py

@@ -0,0 +1,28 @@
+"""Entry point for the gatsaeng-os Python backend (API server only).
+
+Telegram은 OpenClaw gateway가 처리 — 이 서버는 FastAPI만 실행.
+"""
+
+import logging
+import sys
+
+import uvicorn
+from config import DASHBOARD_PORT
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s [%(name)s] %(levelname)s: %(message)s',
+)
+logger = logging.getLogger('gatsaeng')
+
+
+if __name__ == '__main__':
+    host = sys.argv[1] if len(sys.argv) > 1 else '127.0.0.1'
+    logger.info(f'Starting Gatsaeng API server on {host}:{DASHBOARD_PORT}')
+    uvicorn.run(
+        'api_server:app',
+        host=host,
+        port=DASHBOARD_PORT,
+        reload='--reload' in sys.argv,
+        log_level='info',
+    )

package/packages/gatsaeng-os/python/scoring.py

@@ -0,0 +1,44 @@
+"""Gatsaeng scoring system with variable rewards (Skinner)."""
+
+import random
+
+BASE_SCORES = {
+    'routine_complete': 10,
+    'task_done': 5,
+    'task_done_urgent': 15,
+    'milestone_complete': 100,
+    'review_written': 20,
+    'data_uploaded': 10,
+    'goal_25pct': 30,
+    'goal_50pct': 60,
+    'goal_100pct': 200,
+}
+
+
+def calculate(event: str, streak: int = 0) -> dict:
+    """Calculate score with streak multiplier and variable bonus."""
+    base = BASE_SCORES.get(event, 0)
+
+    # streak multiplier — 동일 로직을 streak.get_streak_multiplier()와 공유
+    if streak >= 30:
+        multiplier = 5.0
+    elif streak >= 21:
+        multiplier = 4.0
+    elif streak >= 14:
+        multiplier = 3.0
+    elif streak >= 7:
+        multiplier = 2.0
+    elif streak >= 3:
+        multiplier = 1.5
+    else:
+        multiplier = 1.0
+    points = round(base * multiplier)
+
+    # 15% variable bonus (Skinner)
+    bonus_message = None
+    if random.random() < 0.15:
+        bonus = random.choice([5, 10, 15, 25])
+        points += bonus
+        bonus_message = f'🎉 보너스 +{bonus}점!'
+
+    return {'points': points, 'bonus_message': bonus_message}

package/packages/gatsaeng-os/python/streak.py

@@ -0,0 +1,70 @@
+"""Streak Engine — 연속 실행일 계산 + 보정."""
+
+from datetime import date, timedelta
+
+import vault_io
+
+
+def calculate_streak() -> dict:
+    """현재 스트릭을 재계산하고 프로필에 반영."""
+    today = date.today()
+    streak = 0
+
+    all_routines = vault_io.list_entities('routines')
+    active = [r for r in all_routines if r['data'].get('is_active')]
+
+    for days_ago in range(1, 365):
+        check_date = today - timedelta(days=days_ago)
+        d_str = check_date.isoformat()
+
+        log = vault_io.get_entity_by_date('routine_logs', d_str)
+        if not log or not log['data'].get('completions'):
+            break
+        day_of_week = check_date.isoweekday()
+        scheduled = [
+            r for r in active
+            if day_of_week in r['data'].get('scheduled_days', [1,2,3,4,5,6,7])
+        ]
+
+        if not scheduled:
+            continue  # 스케줄 없는 날은 건너뜀
+
+        completed_ids = {c.get('routine_id', '') for c in log['data'].get('completions', [])}
+        scheduled_ids = {r['data'].get('id', '') for r in scheduled}
+
+        # 50% 이상 완료 시 스트릭 유지
+        if len(completed_ids & scheduled_ids) >= len(scheduled_ids) * 0.5:
+            streak += 1
+        else:
+            break
+
+    # Update profile
+    profile = vault_io.read_profile()
+    old_longest = profile.get('longest_streak', 0)
+    new_longest = max(old_longest, streak)
+
+    vault_io.update_profile({
+        'current_streak': streak,
+        'longest_streak': new_longest,
+    })
+
+    return {
+        'current': streak,
+        'longest': new_longest,
+        'changed': streak != profile.get('current_streak', 0),
+    }
+
+
+def get_streak_multiplier(streak: int) -> float:
+    """스트릭에 따른 점수 배율 (최대 5x)."""
+    if streak >= 30:
+        return 5.0
+    elif streak >= 21:
+        return 4.0
+    elif streak >= 14:
+        return 3.0
+    elif streak >= 7:
+        return 2.0
+    elif streak >= 3:
+        return 1.5
+    return 1.0

package/packages/gatsaeng-os/python/telegram_bot.py

@@ -0,0 +1,331 @@
+"""Telegram Bot — Coach_Eve_bot 통합 갓생 코치."""
+
+import logging
+from datetime import datetime
+from telegram import Update
+from telegram.ext import (
+    Application,
+    CommandHandler,
+    MessageHandler,
+    filters,
+    ContextTypes,
+)
+
+import vault_io
+import briefing
+import proactive
+import gyeokguk
+import timing_engine
+import goal_context_agent
+import streak
+from config import TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID
+
+logger = logging.getLogger(__name__)
+
+
+def is_authorized(update: Update) -> bool:
+    """Only allow Drake (chat_id from config)."""
+    if not TELEGRAM_CHAT_ID:
+        return True
+    return str(update.effective_chat.id) == TELEGRAM_CHAT_ID.replace('tg:', '')
+
+
+# ─── Command Handlers ───
+
+async def cmd_start(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    await update.message.reply_text(
+        "🧭 갓생 코치 활성화.\n"
+        "/morning — 모닝 브리핑\n"
+        "/check — 루틴 체크인\n"
+        "/score — 오늘 스코어\n"
+        "/dday — D-day 현황\n"
+        "/timing — 이달 운기\n"
+        "/gyeokguk — 격국 판정\n"
+        "/scorecard — 성장 스코어카드\n"
+        "/analyze — 목표 AI 분석"
+    )
+
+
+async def cmd_morning(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    text = briefing.generate_morning_briefing()
+    await update.message.reply_text(text, parse_mode=None)
+
+
+async def cmd_evening(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    text = briefing.generate_evening_checkin()
+    await update.message.reply_text(text, parse_mode=None)
+
+
+async def cmd_check(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """현재 루틴 상태 표시."""
+    if not is_authorized(update):
+        return
+    routines = vault_io.get_routines_with_status()
+    if not routines:
+        await update.message.reply_text("활성 루틴 없음.")
+        return
+
+    lines = ["오늘 루틴 현황:"]
+    done = 0
+    for r in routines:
+        status = '✅' if r.get('completed_today') else '⬜'
+        lines.append(f"{status} {r.get('title', '?')} (🔥{r.get('streak', 0)}일)")
+        if r.get('completed_today'):
+            done += 1
+
+    lines.append(f"\n{done}/{len(routines)} 완료")
+    await update.message.reply_text('\n'.join(lines))
+
+
+async def cmd_score(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    today_score = vault_io.get_today_score()
+    streaks = vault_io.get_active_streaks()
+    profile = vault_io.read_profile()
+
+    text = (
+        f"오늘 스코어: {today_score}점\n"
+        f"누적: {profile.get('total_score', 0)}점 (Lv.{profile.get('level', 1)})\n"
+        f"연속: {streaks['current']}일 (최장: {streaks['longest']}일)"
+    )
+    await update.message.reply_text(text)
+
+
+async def cmd_dday(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    milestones = vault_io.get_active_milestones()
+    if not milestones:
+        await update.message.reply_text("활성 마일스톤 없음.")
+        return
+
+    lines = ["D-day 현황:"]
+    for m in milestones[:8]:
+        d = m.get('d_day', 0)
+        label = f"D-{d}" if d > 0 else "D-Day" if d == 0 else f"D+{abs(d)}"
+        progress = 0
+        target = m.get('target_value', 0)
+        if target > 0:
+            progress = round(m.get('current_value', 0) / target * 100)
+        lines.append(f"  {label}: {m.get('title', '?')} ({progress}%)")
+
+    await update.message.reply_text('\n'.join(lines))
+
+
+async def cmd_timing(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    text = timing_engine.get_monthly_briefing()
+    if not text:
+        await update.message.reply_text("타이밍 데이터 없음.")
+        return
+    await update.message.reply_text(f"이달 운기:\n{text}")
+
+
+async def cmd_gyeokguk(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    result = gyeokguk.judge_daily_actions()
+
+    lines = [f"격국 판정 ({result.get('date', '?')}):", ""]
+    for d in result.get('details', []):
+        arrow = '↗' if d['score'] > 0 else '↙' if d['score'] < 0 else '→'
+        lines.append(f"  {arrow} {d.get('action', '?')}: {d.get('reason', '')}")
+
+    lines.append("")
+    lines.append(f"전진 {result.get('forward', 0)} / 후퇴 {result.get('backward', 0)} / 중립 {result.get('neutral', 0)}")
+    lines.append(f"판정: {result.get('verdict', '')}")
+
+    await update.message.reply_text('\n'.join(lines))
+
+
+async def cmd_scorecard(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    sc = gyeokguk.get_growth_scorecard()
+
+    lines = [f"성장 스코어카드 ({sc.get('period', '')}):", ""]
+    for d in sc.get('daily', []):
+        bar = '█' * max(d.get('net_score', 0), 0) + '░' * max(-d.get('net_score', 0), 0)
+        lines.append(f"  {d['date'][-5:]}: {bar or '·'} ({d.get('net_score', 0):+d})")
+
+    lines.append("")
+    lines.append(f"주간 순전진: {sc.get('weekly_net', 0):+d}")
+    lines.append(f"판정: {sc.get('verdict', '')}")
+
+    await update.message.reply_text('\n'.join(lines))
+
+
+async def cmd_analyze(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    goals = vault_io.get_active_goals()
+    if not goals:
+        await update.message.reply_text("활성 목표 없음.")
+        return
+
+    # If goal_id specified
+    args = ctx.args
+    if args:
+        goal_id = args[0]
+    else:
+        # Show list and analyze first one
+        lines = ["분석할 목표:"]
+        for g in goals:
+            lines.append(f"  {g.get('id', '?')}: {g.get('title', '?')}")
+        lines.append(f"\n첫 번째 목표 분석 중...")
+        await update.message.reply_text('\n'.join(lines))
+        goal_id = goals[0].get('id', '')
+
+    await update.message.reply_text(f"🔍 '{goal_id}' 분석 중...")
+    result = goal_context_agent.run(goal_id)
+
+    if result.get('error'):
+        await update.message.reply_text(f"분석 실패: {result['error']}")
+        return
+
+    lines = [
+        f"AI 진단: {result.get('diagnosis', '?')}",
+        f"방향: {result.get('direction', '?')}",
+        f"다음 리뷰: {result.get('next_review', '?')}",
+    ]
+    if result.get('milestones_created', 0) > 0:
+        lines.append(f"새 마일스톤 {result['milestones_created']}개 생성됨.")
+
+    await update.message.reply_text('\n'.join(lines))
+
+
+async def cmd_alerts(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    if not is_authorized(update):
+        return
+    alerts = proactive.check_all()
+    if not alerts:
+        await update.message.reply_text("현재 알림 없음. 잘 하고 있다.")
+        return
+
+    lines = ["🚨 알림:"]
+    for a in alerts:
+        severity = {'critical': '🔴', 'warning': '🟡', 'info': '🔵'}.get(a.get('severity', 'info'), '⚪')
+        lines.append(f"  {severity} [{a.get('type', '?')}] {a.get('title', '')}: {a.get('message', '')}")
+
+    await update.message.reply_text('\n'.join(lines))
+
+
+# ─── Message Handler (Intent Classification) ───
+
+INTENT_KEYWORDS = {
+    'check': ['체크', '루틴', '완료', '했어', '끝'],
+    'score': ['점수', '스코어', '몇점'],
+    'timing': ['운기', '운세', '타이밍', '이달'],
+    'dday': ['디데이', 'd-day', '마감', '마일스톤'],
+    'gyeokguk': ['격국', '판정', '전진', '후퇴'],
+    'morning': ['아침', '모닝', '브리핑', '오늘'],
+    'evening': ['저녁', '체크인', '하루', '마무리'],
+    'analyze': ['분석', '진단', 'ai'],
+    'alerts': ['알림', '경고', '주의'],
+}
+
+async def handle_message(update: Update, ctx: ContextTypes.DEFAULT_TYPE):
+    """Free-text message intent classification."""
+    if not is_authorized(update):
+        return
+
+    text = update.message.text.lower()
+
+    # Match intent by keywords
+    for intent, keywords in INTENT_KEYWORDS.items():
+        if any(kw in text for kw in keywords):
+            handler_map = {
+                'check': cmd_check,
+                'score': cmd_score,
+                'timing': cmd_timing,
+                'dday': cmd_dday,
+                'gyeokguk': cmd_gyeokguk,
+                'morning': cmd_morning,
+                'evening': cmd_evening,
+                'analyze': cmd_analyze,
+                'alerts': cmd_alerts,
+            }
+            handler = handler_map.get(intent)
+            if handler:
+                await handler(update, ctx)
+                return
+
+    # Default: show status summary
+    today_score = vault_io.get_today_score()
+    routines = vault_io.get_routines_with_status()
+    done = sum(1 for r in routines if r.get('completed_today'))
+    streaks = vault_io.get_active_streaks()
+
+    await update.message.reply_text(
+        f"스코어: {today_score}점 | 루틴: {done}/{len(routines)} | 연속: {streaks['current']}일\n\n"
+        "명령어: /morning /check /score /dday /timing /gyeokguk /scorecard /analyze /alerts"
+    )
+
+
+# ─── Scheduled Jobs ───
+
+async def scheduled_morning_briefing(ctx: ContextTypes.DEFAULT_TYPE):
+    """매일 아침 자동 브리핑."""
+    chat_id = TELEGRAM_CHAT_ID.replace('tg:', '')
+    text = briefing.generate_morning_briefing()
+    await ctx.bot.send_message(chat_id=chat_id, text=text)
+
+
+async def scheduled_evening_checkin(ctx: ContextTypes.DEFAULT_TYPE):
+    """매일 저녁 자동 체크인."""
+    chat_id = TELEGRAM_CHAT_ID.replace('tg:', '')
+
+    # Recalculate streak before evening check-in
+    streak.calculate_streak()
+
+    text = briefing.generate_evening_checkin()
+    await ctx.bot.send_message(chat_id=chat_id, text=text)
+
+
+async def scheduled_proactive_check(ctx: ContextTypes.DEFAULT_TYPE):
+    """주기적 proactive 알림."""
+    chat_id = TELEGRAM_CHAT_ID.replace('tg:', '')
+    alerts = proactive.check_all()
+    critical = [a for a in alerts if a.get('severity') == 'critical']
+
+    if critical:
+        lines = ["🚨 긴급 알림:"]
+        for a in critical:
+            lines.append(f"  {a.get('title', '')}: {a.get('message', '')}")
+        await ctx.bot.send_message(chat_id=chat_id, text='\n'.join(lines))
+
+
+# ─── Bot Setup ───
+
+def create_bot() -> Application:
+    """Create and configure the Telegram bot."""
+    if not TELEGRAM_BOT_TOKEN:
+        raise ValueError("TELEGRAM_BOT_TOKEN not set")
+
+    app = Application.builder().token(TELEGRAM_BOT_TOKEN).build()
+
+    # Commands
+    app.add_handler(CommandHandler('start', cmd_start))
+    app.add_handler(CommandHandler('morning', cmd_morning))
+    app.add_handler(CommandHandler('evening', cmd_evening))
+    app.add_handler(CommandHandler('check', cmd_check))
+    app.add_handler(CommandHandler('score', cmd_score))
+    app.add_handler(CommandHandler('dday', cmd_dday))
+    app.add_handler(CommandHandler('timing', cmd_timing))
+    app.add_handler(CommandHandler('gyeokguk', cmd_gyeokguk))
+    app.add_handler(CommandHandler('scorecard', cmd_scorecard))
+    app.add_handler(CommandHandler('analyze', cmd_analyze))
+    app.add_handler(CommandHandler('alerts', cmd_alerts))
+
+    # Free text
+    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
+
+    return app