@usejarvis/brain 0.1.0

package/src/goals/rhythm.ts

@@ -0,0 +1,275 @@
+/**
+ * Daily Rhythm — Morning Plan + Evening Review
+ *
+ * Morning: queries active goals + calendar → LLM generates focus areas,
+ * daily actions, warnings (drill sergeant tone) → creates check-in.
+ * Evening: gets morning plan + day's progress → LLM scores day,
+ * generates accountability assessment → updates scores.
+ */
+
+import type { Goal, GoalCheckIn } from './types.ts';
+import type { GoalEvent } from './events.ts';
+import * as vault from '../vault/goals.ts';
+
+export type MorningPlanResult = {
+  checkIn: GoalCheckIn;
+  focusAreas: string[];
+  dailyActions: string[];
+  warnings: string[];
+  message: string; // Drill sergeant message to the user
+};
+
+export type EveningReviewResult = {
+  checkIn: GoalCheckIn;
+  scoreUpdates: { goalId: string; newScore: number; reason: string }[];
+  assessment: string; // Day summary
+  message: string; // Drill sergeant verdict
+};
+
+export class DailyRhythm {
+  private llmManager: any; // LLMManager
+  private eventCallback: ((event: GoalEvent) => void) | null = null;
+  private accountabilityStyle: 'drill_sergeant' | 'supportive' | 'balanced';
+
+  constructor(llmManager: unknown, style: 'drill_sergeant' | 'supportive' | 'balanced' = 'drill_sergeant') {
+    this.llmManager = llmManager;
+    this.accountabilityStyle = style;
+  }
+
+  setEventCallback(cb: (event: GoalEvent) => void): void {
+    this.eventCallback = cb;
+  }
+
+  private emit(event: GoalEvent): void {
+    if (this.eventCallback) this.eventCallback(event);
+  }
+
+  /**
+   * Run morning planning session.
+   */
+  async runMorningPlan(): Promise<MorningPlanResult> {
+    const activeGoals = vault.findGoals({ status: 'active', limit: 20 });
+    const overdueGoals = vault.getOverdueGoals();
+    const yesterdayEvening = vault.getRecentCheckIns('evening_review', 1);
+
+    const goalSummary = activeGoals.map(g =>
+      `- ${g.title} (${g.level}, score: ${g.score}, health: ${g.health}, deadline: ${g.deadline ? new Date(g.deadline).toLocaleDateString() : 'none'})`
+    ).join('\n');
+
+    const overdueSummary = overdueGoals.length > 0
+      ? `\n\nOVERDUE GOALS:\n${overdueGoals.map(g => `- ${g.title} (due ${new Date(g.deadline!).toLocaleDateString()})`).join('\n')}`
+      : '';
+
+    const yesterdaySummary = yesterdayEvening.length > 0
+      ? `\n\nYesterday's review:\n${yesterdayEvening[0]!.summary}`
+      : '';
+
+    const prompt = [
+      { role: 'system' as const, content: this.buildMorningPrompt() },
+      {
+        role: 'user' as const,
+        content: `Active goals:\n${goalSummary}${overdueSummary}${yesterdaySummary}\n\nGenerate today's morning plan. Respond with ONLY valid JSON.`,
+      },
+    ];
+
+    try {
+      const response = await this.llmManager.chat(prompt, {
+        temperature: 0.4,
+        max_tokens: 2000,
+      });
+
+      const text = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+      const json = text.match(/\{[\s\S]*\}/)?.[0];
+      const plan = json ? JSON.parse(json) : this.fallbackMorningPlan(activeGoals);
+
+      const focusAreas: string[] = plan.focus_areas ?? [];
+      const dailyActions: string[] = plan.daily_actions ?? [];
+      const warnings: string[] = plan.warnings ?? [];
+      const message: string = plan.message ?? 'Time to work.';
+
+      const goalsReviewed = activeGoals.map(g => g.id);
+
+      const checkIn = vault.createCheckIn(
+        'morning_plan',
+        `Focus: ${focusAreas.join(', ')}`,
+        goalsReviewed,
+        dailyActions,
+      );
+
+      this.emit({
+        type: 'check_in_morning',
+        data: { checkInId: checkIn.id, focusAreas, dailyActions, warnings },
+        timestamp: Date.now(),
+      });
+
+      return { checkIn, focusAreas, dailyActions, warnings, message };
+    } catch (err) {
+      console.error('[DailyRhythm] Morning plan LLM error:', err);
+      const fallback = this.fallbackMorningPlan(activeGoals);
+      const checkIn = vault.createCheckIn(
+        'morning_plan',
+        'Morning plan (fallback)',
+        activeGoals.map(g => g.id),
+        fallback.daily_actions,
+      );
+      return {
+        checkIn,
+        focusAreas: fallback.focus_areas,
+        dailyActions: fallback.daily_actions,
+        warnings: fallback.warnings,
+        message: fallback.message,
+      };
+    }
+  }
+
+  /**
+   * Run evening review session.
+   */
+  async runEveningReview(): Promise<EveningReviewResult> {
+    const activeGoals = vault.findGoals({ status: 'active', limit: 20 });
+    const morningCheckIn = vault.getTodayCheckIn('morning_plan');
+
+    const goalSummary = activeGoals.map(g =>
+      `- ${g.title} (${g.level}, score: ${g.score}, health: ${g.health})`
+    ).join('\n');
+
+    const plannedActions = morningCheckIn?.actions_planned ?? [];
+    const morningContext = morningCheckIn
+      ? `\nMorning plan:\n- Focus: ${morningCheckIn.summary}\n- Planned actions:\n${plannedActions.map(a => `  * ${a}`).join('\n')}`
+      : '\nNo morning plan was created today.';
+
+    const prompt = [
+      { role: 'system' as const, content: this.buildEveningPrompt() },
+      {
+        role: 'user' as const,
+        content: `Active goals:\n${goalSummary}${morningContext}\n\nReview the day and score progress. Respond with ONLY valid JSON.`,
+      },
+    ];
+
+    try {
+      const response = await this.llmManager.chat(prompt, {
+        temperature: 0.4,
+        max_tokens: 2000,
+      });
+
+      const text = typeof response.content === 'string' ? response.content : JSON.stringify(response.content);
+      const json = text.match(/\{[\s\S]*\}/)?.[0];
+      const review = json ? JSON.parse(json) : this.fallbackEveningReview();
+
+      const scoreUpdates: { goalId: string; newScore: number; reason: string }[] = review.score_updates ?? [];
+      const assessment: string = review.assessment ?? 'Day complete.';
+      const message: string = review.message ?? 'Another day done.';
+      const actionsCompleted: string[] = review.actions_completed ?? [];
+
+      // Apply score updates
+      for (const update of scoreUpdates) {
+        vault.updateGoalScore(update.goalId, update.newScore, update.reason, 'daily_review');
+      }
+
+      const goalsReviewed = activeGoals.map(g => g.id);
+      const checkIn = vault.createCheckIn(
+        'evening_review',
+        assessment,
+        goalsReviewed,
+        [],
+        actionsCompleted,
+      );
+
+      this.emit({
+        type: 'check_in_evening',
+        data: { checkInId: checkIn.id, scoreUpdates, assessment },
+        timestamp: Date.now(),
+      });
+
+      return { checkIn, scoreUpdates, assessment, message };
+    } catch (err) {
+      console.error('[DailyRhythm] Evening review LLM error:', err);
+      const checkIn = vault.createCheckIn(
+        'evening_review',
+        'Evening review (fallback)',
+        activeGoals.map(g => g.id),
+        [],
+        [],
+      );
+      return {
+        checkIn,
+        scoreUpdates: [],
+        assessment: 'Review completed without LLM.',
+        message: 'Day over. Check your goals manually.',
+      };
+    }
+  }
+
+  // ── Prompts ──────────────────────────────────────────────────────
+
+  private buildMorningPrompt(): string {
+    const tone = this.getToneInstructions();
+    return `You are JARVIS, an AI assistant running a morning planning session.${tone}
+
+Analyze the user's active goals and generate today's plan.
+
+Respond with ONLY valid JSON:
+{
+  "focus_areas": ["top 1-3 priorities for today"],
+  "daily_actions": ["specific actionable tasks for today"],
+  "warnings": ["any urgent warnings about deadlines, health, or missed targets"],
+  "message": "motivational/accountability message to the user"
+}`;
+  }
+
+  private buildEveningPrompt(): string {
+    const tone = this.getToneInstructions();
+    return `You are JARVIS, an AI assistant running an evening review session.${tone}
+
+Compare the morning plan against the day's reality. Score progress honestly.
+
+Respond with ONLY valid JSON:
+{
+  "score_updates": [{ "goalId": "id", "newScore": 0.0-1.0, "reason": "why" }],
+  "actions_completed": ["what got done today"],
+  "assessment": "honest day summary",
+  "message": "accountability verdict for the user"
+}
+
+Only include score_updates for goals where you have evidence of progress or regression.`;
+  }
+
+  private getToneInstructions(): string {
+    switch (this.accountabilityStyle) {
+      case 'drill_sergeant':
+        return `\n\nYour tone is DRILL SERGEANT: direct, blunt, no sugarcoating. Call out laziness. Praise only exceptional effort. Use short, punchy sentences. No pleasantries.`;
+      case 'supportive':
+        return `\n\nYour tone is SUPPORTIVE: encouraging, empathetic, focus on progress over perfection. Celebrate small wins. Gently point out areas for improvement.`;
+      case 'balanced':
+        return `\n\nYour tone is BALANCED: honest but fair. Acknowledge good work, directly address problems. Mix encouragement with accountability.`;
+    }
+  }
+
+  // ── Fallbacks ────────────────────────────────────────────────────
+
+  private fallbackMorningPlan(goals: Goal[]) {
+    const overdueGoals = goals.filter(g => g.deadline && g.deadline < Date.now());
+    const behindGoals = goals.filter(g => g.health === 'behind' || g.health === 'critical');
+
+    return {
+      focus_areas: goals.slice(0, 3).map(g => g.title),
+      daily_actions: goals.slice(0, 5).map(g => `Work on: ${g.title}`),
+      warnings: [
+        ...overdueGoals.map(g => `OVERDUE: ${g.title}`),
+        ...behindGoals.map(g => `BEHIND: ${g.title}`),
+      ],
+      message: overdueGoals.length > 0
+        ? 'You have overdue goals. Fix that today.'
+        : 'Get to work.',
+    };
+  }
+
+  private fallbackEveningReview() {
+    return {
+      score_updates: [],
+      actions_completed: [],
+      assessment: 'Review completed without LLM analysis.',
+      message: 'Check your goals manually.',
+    };
+  }
+}

package/src/goals/service.test.ts

@@ -0,0 +1,135 @@
+import { test, expect, describe, beforeEach } from 'bun:test';
+import { initDatabase } from '../vault/schema.ts';
+import { GoalService } from './service.ts';
+import type { GoalEvent } from './events.ts';
+import type { GoalConfig } from '../config/types.ts';
+
+const defaultConfig: GoalConfig = {
+  enabled: true,
+  morning_window: { start: 7, end: 9 },
+  evening_window: { start: 20, end: 22 },
+  accountability_style: 'drill_sergeant',
+  escalation_weeks: { pressure: 1, root_cause: 3, suggest_kill: 4 },
+  auto_decompose: true,
+  calendar_ownership: false,
+};
+
+describe('GoalService', () => {
+  let service: GoalService;
+  let events: GoalEvent[];
+
+  beforeEach(async () => {
+    initDatabase(':memory:');
+    service = new GoalService(defaultConfig);
+    events = [];
+    service.setEventCallback((e) => events.push(e));
+  });
+
+  test('start and stop lifecycle', async () => {
+    expect(service.status()).toBe('stopped');
+    await service.start();
+    expect(service.status()).toBe('running');
+    await service.stop();
+    expect(service.status()).toBe('stopped');
+  });
+
+  test('disabled config skips start', async () => {
+    const disabled = new GoalService({ ...defaultConfig, enabled: false });
+    await disabled.start();
+    expect(disabled.status()).toBe('stopped');
+  });
+
+  test('createGoal emits goal_created event', () => {
+    const goal = service.createGoal('Test Goal', 'objective');
+    expect(goal.title).toBe('Test Goal');
+    expect(events.length).toBe(1);
+    expect(events[0]!.type).toBe('goal_created');
+    expect(events[0]!.goalId).toBe(goal.id);
+  });
+
+  test('updateGoal emits goal_updated event', () => {
+    const goal = service.createGoal('Original', 'task');
+    events = [];
+
+    const updated = service.updateGoal(goal.id, { title: 'Changed' });
+    expect(updated!.title).toBe('Changed');
+    expect(events.length).toBe(1);
+    expect(events[0]!.type).toBe('goal_updated');
+  });
+
+  test('scoreGoal emits goal_scored event', () => {
+    const goal = service.createGoal('Scored', 'key_result');
+    events = [];
+
+    service.scoreGoal(goal.id, 0.5, 'halfway');
+    expect(events.length).toBe(1);
+    expect(events[0]!.type).toBe('goal_scored');
+    expect(events[0]!.data.score).toBe(0.5);
+  });
+
+  test('updateStatus emits correct event type', () => {
+    const goal = service.createGoal('Status test', 'task', { status: 'active' });
+    events = [];
+
+    service.updateStatus(goal.id, 'completed');
+    expect(events.length).toBe(1);
+    expect(events[0]!.type).toBe('goal_completed');
+
+    const g2 = service.createGoal('Fail test', 'task', { status: 'active' });
+    events = [];
+    service.updateStatus(g2.id, 'failed');
+    expect(events[0]!.type).toBe('goal_failed');
+
+    const g3 = service.createGoal('Kill test', 'task', { status: 'active' });
+    events = [];
+    service.updateStatus(g3.id, 'killed');
+    expect(events[0]!.type).toBe('goal_killed');
+
+    const g4 = service.createGoal('Pause test', 'task', { status: 'active' });
+    events = [];
+    service.updateStatus(g4.id, 'paused');
+    expect(events[0]!.type).toBe('goal_status_changed');
+  });
+
+  test('updateHealth emits goal_health_changed event', () => {
+    const goal = service.createGoal('Health test', 'objective');
+    events = [];
+
+    service.updateHealth(goal.id, 'at_risk');
+    expect(events.length).toBe(1);
+    expect(events[0]!.type).toBe('goal_health_changed');
+    expect(events[0]!.data.health).toBe('at_risk');
+  });
+
+  test('deleteGoal emits goal_deleted event', () => {
+    const goal = service.createGoal('Delete me', 'task');
+    events = [];
+
+    service.deleteGoal(goal.id);
+    expect(events.length).toBe(1);
+    expect(events[0]!.type).toBe('goal_deleted');
+    expect(events[0]!.goalId).toBe(goal.id);
+  });
+
+  test('getGoal returns null for non-existent', () => {
+    expect(service.getGoal('nope')).toBeNull();
+  });
+
+  test('getMetrics returns aggregated data', () => {
+    service.createGoal('Active', 'task', { status: 'active' });
+    service.createGoal('Draft', 'task');
+
+    const metrics = service.getMetrics();
+    expect(metrics.total).toBe(2);
+    expect(metrics.active).toBe(1);
+  });
+
+  test('no events when update returns null', () => {
+    events = [];
+    service.updateGoal('nonexistent', { title: 'X' });
+    service.scoreGoal('nonexistent', 0.5, 'nope');
+    service.updateHealth('nonexistent', 'behind');
+    service.deleteGoal('nonexistent');
+    expect(events.length).toBe(0);
+  });
+});