@usejarvis/brain 0.1.0

package/src/goals/integration.test.ts

@@ -0,0 +1,329 @@
+/**
+ * Tests for M16 Phase 7 — Goal System Integrations
+ *
+ * Tests awareness-bridge (fuzzy matching), workflow-bridge (rhythm workflows),
+ * and goal context injection.
+ */
+
+import { test, expect, beforeEach } from 'bun:test';
+import { initDatabase } from '../vault/schema.ts';
+import { createGoal, updateGoalStatus } from '../vault/goals.ts';
+import { matchAwarenessToGoals, logAutoDetectedProgress } from './awareness-bridge.ts';
+import { generateRhythmWorkflows, registerGoalWorkflows } from './workflow-bridge.ts';
+import { extractGoalCompletion } from '../vault/extractor.ts';
+import { getActiveGoalsSummary } from '../vault/retrieval.ts';
+import { findEntities } from '../vault/entities.ts';
+import { findFacts } from '../vault/facts.ts';
+import type { GoalConfig } from '../config/types.ts';
+
+beforeEach(() => {
+  initDatabase(':memory:');
+});
+
+// ── Awareness Bridge Tests ──────────────────────────────────────────
+
+test('matchAwarenessToGoals returns empty when no active goals', () => {
+  const matches = matchAwarenessToGoals({
+    app_name: 'VS Code',
+    window_title: 'index.ts - project',
+  });
+  expect(matches).toEqual([]);
+});
+
+test('matchAwarenessToGoals finds matches for active goals', () => {
+  createGoal('Learn TypeScript fundamentals', 'task', {
+    description: 'Complete TypeScript tutorial covering generics, interfaces, and type guards',
+    status: 'active',
+  });
+  createGoal('Exercise daily', 'daily_action', {
+    description: 'Run or gym workout every day',
+    status: 'active',
+  });
+
+  // Event related to TypeScript
+  const matches = matchAwarenessToGoals({
+    app_name: 'VS Code',
+    window_title: 'TypeScript Tutorial - generics.ts',
+    ocr_text: 'interface UserProfile extends BaseInterface',
+  });
+
+  expect(matches.length).toBeGreaterThanOrEqual(1);
+  expect(matches[0]!.goalTitle).toBe('Learn TypeScript fundamentals');
+  expect(matches[0]!.matchedTerms.length).toBeGreaterThanOrEqual(2);
+});
+
+test('matchAwarenessToGoals does not match unrelated events', () => {
+  createGoal('Learn Python machine learning', 'task', {
+    description: 'Complete scikit-learn and tensorflow courses',
+    status: 'active',
+  });
+
+  // Unrelated event
+  const matches = matchAwarenessToGoals({
+    app_name: 'Spotify',
+    window_title: 'Playing: Jazz Classics',
+  });
+
+  expect(matches).toEqual([]);
+});
+
+test('matchAwarenessToGoals ignores non-active goals', () => {
+  createGoal('Learn TypeScript fundamentals', 'task', {
+    description: 'Complete TypeScript tutorial covering generics and interfaces',
+    status: 'completed', // not active
+  });
+
+  const matches = matchAwarenessToGoals({
+    app_name: 'VS Code',
+    window_title: 'TypeScript generics tutorial',
+  });
+
+  expect(matches).toEqual([]);
+});
+
+test('matchAwarenessToGoals handles session_ended data', () => {
+  createGoal('Build web application with React', 'milestone', {
+    description: 'Develop a React web application with components and hooks',
+    status: 'active',
+  });
+
+  const matches = matchAwarenessToGoals({
+    dominant_app: 'VS Code',
+    summary: 'Worked on React application components and hooks',
+    activities: ['Edited React component files', 'Debugged hooks issue'],
+  });
+
+  expect(matches.length).toBeGreaterThanOrEqual(1);
+  expect(matches[0]!.matchedTerms.length).toBeGreaterThanOrEqual(2);
+});
+
+test('logAutoDetectedProgress creates progress entries', () => {
+  const goal = createGoal('Learn TypeScript', 'task', {
+    description: 'Complete TypeScript tutorial',
+    status: 'active',
+  });
+
+  const matches = [{
+    goalId: goal.id,
+    goalTitle: goal.title,
+    matchScore: 0.5,
+    matchedTerms: ['typescript', 'tutorial'],
+    source: 'VS Code',
+  }];
+
+  logAutoDetectedProgress(matches, 'context_changed');
+
+  // Check progress was logged
+  const { getProgressHistory } = require('../vault/goals.ts');
+  const progress = getProgressHistory(goal.id, 10);
+  expect(progress.length).toBe(1);
+  expect(progress[0].type).toBe('auto_detected');
+  expect(progress[0].source).toBe('awareness');
+  expect(progress[0].note).toContain('typescript');
+});
+
+test('logAutoDetectedProgress deduplicates within 30 minutes', () => {
+  const goal = createGoal('Learn TypeScript', 'task', {
+    description: 'Complete TypeScript tutorial',
+    status: 'active',
+  });
+
+  const matches = [{
+    goalId: goal.id,
+    goalTitle: goal.title,
+    matchScore: 0.5,
+    matchedTerms: ['typescript', 'tutorial'],
+    source: 'VS Code',
+  }];
+
+  // First call logs progress
+  logAutoDetectedProgress(matches, 'context_changed');
+
+  // Second call within 30min should not log again
+  logAutoDetectedProgress(matches, 'context_changed');
+
+  const { getProgressHistory } = require('../vault/goals.ts');
+  const progress = getProgressHistory(goal.id, 10);
+  expect(progress.length).toBe(1); // still just 1
+});
+
+// ── Workflow Bridge Tests ───────────────────────────────────────────
+
+test('generateRhythmWorkflows creates morning and evening workflows', () => {
+  const config: 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,
+  };
+
+  const workflows = generateRhythmWorkflows(config);
+  expect(workflows.length).toBe(2);
+
+  const morning = workflows.find(w => w.action === 'morning_plan');
+  expect(morning).toBeDefined();
+  expect(morning!.cronExpression).toBe('0 7 * * *');
+  expect(morning!.triggerType).toBe('cron');
+
+  const evening = workflows.find(w => w.action === 'evening_review');
+  expect(evening).toBeDefined();
+  expect(evening!.cronExpression).toBe('0 20 * * *');
+});
+
+test('generateRhythmWorkflows returns empty when disabled', () => {
+  const config: GoalConfig = {
+    enabled: false,
+    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,
+  };
+
+  const workflows = generateRhythmWorkflows(config);
+  expect(workflows.length).toBe(0);
+});
+
+test('generateRhythmWorkflows uses custom window times', () => {
+  const config: GoalConfig = {
+    enabled: true,
+    morning_window: { start: 6, end: 8 },
+    evening_window: { start: 21, end: 23 },
+    accountability_style: 'supportive',
+    escalation_weeks: { pressure: 2, root_cause: 4, suggest_kill: 6 },
+    auto_decompose: true,
+    calendar_ownership: true,
+  };
+
+  const workflows = generateRhythmWorkflows(config);
+  const morning = workflows.find(w => w.action === 'morning_plan')!;
+  const evening = workflows.find(w => w.action === 'evening_review')!;
+
+  expect(morning.cronExpression).toBe('0 6 * * *');
+  expect(evening.cronExpression).toBe('0 21 * * *');
+});
+
+test('registerGoalWorkflows logs workflows without error', () => {
+  const workflows = generateRhythmWorkflows({
+    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,
+  });
+
+  const mockTriggerManager = {
+    fireTrigger: () => {},
+  };
+
+  // Should not throw
+  expect(() => registerGoalWorkflows(workflows, mockTriggerManager)).not.toThrow();
+});
+
+// ── Phase 8: Goal Memory + Knowledge ───────────────────────────────
+
+test('extractGoalCompletion creates entity with facts', () => {
+  const goal = createGoal('Build REST API', 'milestone', {
+    description: 'Create a full REST API with CRUD endpoints',
+    status: 'active',
+  });
+
+  // Simulate completion
+  const completedGoal = {
+    ...goal,
+    status: 'completed',
+    score: 0.85,
+    estimated_hours: 20,
+    actual_hours: 25.5,
+    completed_at: Date.now(),
+    tags: ['backend', 'api'],
+  };
+
+  extractGoalCompletion(completedGoal);
+
+  // Verify entity was created
+  const entities = findEntities({ name: 'Build REST API', type: 'concept' });
+  expect(entities.length).toBe(1);
+  expect(entities[0]!.source).toBe('goal_completion');
+
+  // Verify facts were stored
+  const facts = findFacts({ subject_id: entities[0]!.id });
+  const factMap = new Map(facts.map(f => [f.predicate, f.object]));
+
+  expect(factMap.get('goal_final_score')).toBe('0.85');
+  expect(factMap.get('goal_outcome')).toBe('completed');
+  expect(factMap.get('goal_level')).toBe('milestone');
+  expect(factMap.get('estimated_hours')).toBe('20');
+  expect(factMap.get('actual_hours')).toBe('25.5');
+  expect(factMap.get('goal_tags')).toBe('backend, api');
+  expect(factMap.has('days_to_complete')).toBe(true);
+  expect(factMap.has('estimation_accuracy')).toBe(true);
+});
+
+test('extractGoalCompletion handles failed goals', () => {
+  extractGoalCompletion({
+    id: 'test-failed',
+    title: 'Learn Rust',
+    level: 'objective',
+    score: 0.2,
+    status: 'failed',
+    estimated_hours: null,
+    actual_hours: 0,
+    created_at: Date.now() - 86400000 * 30,
+    completed_at: null,
+    tags: [],
+  });
+
+  const entities = findEntities({ name: 'Learn Rust', type: 'concept' });
+  expect(entities.length).toBe(1);
+
+  const facts = findFacts({ subject_id: entities[0]!.id });
+  const factMap = new Map(facts.map(f => [f.predicate, f.object]));
+  expect(factMap.get('goal_outcome')).toBe('failed');
+  expect(factMap.get('goal_final_score')).toBe('0.20');
+  // No estimated_hours or actual_hours since they're null/0
+  expect(factMap.has('estimated_hours')).toBe(false);
+  expect(factMap.has('actual_hours')).toBe(false);
+});
+
+test('getActiveGoalsSummary returns formatted goal list', () => {
+  createGoal('Get fit', 'objective', { status: 'active' });
+  createGoal('Run daily', 'key_result', { status: 'active' });
+  createGoal('Complete project', 'milestone', { status: 'active' });
+
+  const summary = getActiveGoalsSummary();
+  expect(summary).toContain('Get fit');
+  expect(summary).toContain('Run daily');
+  expect(summary).toContain('Complete project');
+  expect(summary).toContain('/1.0');
+});
+
+test('getActiveGoalsSummary returns empty when no active goals', () => {
+  createGoal('Done goal', 'task', { status: 'completed' });
+
+  const summary = getActiveGoalsSummary();
+  expect(summary).toBe('');
+});
+
+test('getActiveGoalsSummary sorts by level hierarchy', () => {
+  createGoal('Daily run', 'daily_action', { status: 'active' });
+  createGoal('Get fit', 'objective', { status: 'active' });
+  createGoal('Lose 10 lbs', 'key_result', { status: 'active' });
+
+  const summary = getActiveGoalsSummary();
+  const lines = summary.split('\n');
+
+  // Objective should come before key_result, which should come before daily_action
+  const fitIndex = lines.findIndex(l => l.includes('Get fit'));
+  const loseIndex = lines.findIndex(l => l.includes('Lose 10 lbs'));
+  const runIndex = lines.findIndex(l => l.includes('Daily run'));
+
+  expect(fitIndex).toBeLessThan(loseIndex);
+  expect(loseIndex).toBeLessThan(runIndex);
+});

package/src/goals/nl-builder.test.ts

@@ -0,0 +1,220 @@
+import { test, expect, describe, beforeEach } from 'bun:test';
+import { initDatabase } from '../vault/schema.ts';
+import { NLGoalBuilder, type GoalProposal } from './nl-builder.ts';
+import { GoalEstimator } from './estimator.ts';
+import * as vault from '../vault/goals.ts';
+
+// Mock LLM manager — returns canned responses
+const mockLLM = {
+  chat: async (messages: any[], _opts?: any) => {
+    const lastMsg = messages[messages.length - 1];
+    const content = typeof lastMsg.content === 'string' ? lastMsg.content : '';
+
+    // Default proposal response
+    if (content.includes('Convert this into an OKR') || content.includes('Decompose this')) {
+      return {
+        content: JSON.stringify({
+          objective: {
+            title: 'Ship MVP',
+            description: 'Launch the minimum viable product',
+            success_criteria: '100 active users within 30 days of launch',
+            time_horizon: 'quarterly',
+            deadline_days: 90,
+            tags: ['product', 'launch'],
+          },
+          key_results: [
+            {
+              title: 'Complete core features',
+              description: 'Build all must-have features',
+              success_criteria: '5 core features deployed and tested',
+              deadline_days: 60,
+            },
+            {
+              title: 'Launch marketing site',
+              description: 'Build and deploy landing page',
+              success_criteria: 'Site live with signup form',
+              deadline_days: 45,
+            },
+          ],
+          milestones: [
+            {
+              key_result_index: 0,
+              title: 'Auth system complete',
+              description: 'User registration and login working',
+              deadline_days: 30,
+            },
+          ],
+        }),
+      };
+    }
+
+    // Estimation response
+    if (content.includes('Estimate hours')) {
+      return {
+        content: JSON.stringify({
+          hours: 40,
+          confidence: 0.6,
+          reasoning: 'Medium complexity project with standard web stack',
+        }),
+      };
+    }
+
+    // Chat response
+    return { content: 'Here are some suggestions for improving your goal.' };
+  },
+};
+
+describe('NLGoalBuilder', () => {
+  let builder: NLGoalBuilder;
+
+  beforeEach(() => {
+    initDatabase(':memory:');
+    builder = new NLGoalBuilder(mockLLM);
+  });
+
+  test('parseGoal returns structured proposal', async () => {
+    const proposal = await builder.parseGoal('I want to ship my MVP this quarter');
+
+    expect(proposal.objective.title).toBe('Ship MVP');
+    expect(proposal.key_results.length).toBe(2);
+    expect(proposal.milestones?.length).toBe(1);
+    expect(proposal.objective.tags).toEqual(['product', 'launch']);
+  });
+
+  test('createFromProposal creates goal hierarchy', async () => {
+    const proposal = await builder.parseGoal('Ship MVP');
+    const goals = builder.createFromProposal(proposal);
+
+    expect(goals.length).toBe(4); // 1 objective + 2 key results + 1 milestone
+
+    // Goals created in order: objective, KR1, milestone (under KR1), KR2
+    expect(goals[0]!.level).toBe('objective');
+    expect(goals[0]!.title).toBe('Ship MVP');
+    expect(goals[1]!.level).toBe('key_result');
+    expect(goals[1]!.parent_id).toBe(goals[0]!.id);
+    expect(goals[2]!.level).toBe('milestone');
+    expect(goals[2]!.parent_id).toBe(goals[1]!.id); // Under first KR
+    expect(goals[3]!.level).toBe('key_result');
+    expect(goals[3]!.parent_id).toBe(goals[0]!.id);
+  });
+
+  test('createFromProposal with parent_id', async () => {
+    const parent = vault.createGoal('Parent Objective', 'objective');
+    const proposal = await builder.parseGoal('Sub-objective');
+    const goals = builder.createFromProposal(proposal, parent.id);
+
+    expect(goals[0]!.parent_id).toBe(parent.id);
+  });
+
+  test('decompose returns proposal for children', async () => {
+    const goal = vault.createGoal('Root Objective', 'objective', {
+      description: 'A big goal',
+      success_criteria: 'It works',
+    });
+
+    const proposal = await builder.decompose(goal.id);
+    expect(proposal).not.toBeNull();
+    expect(proposal!.objective.title).toBe('Ship MVP');
+  });
+
+  test('decompose returns null for non-existent goal', async () => {
+    const proposal = await builder.decompose('nonexistent');
+    expect(proposal).toBeNull();
+  });
+
+  test('decompose returns null for daily_action (no next level)', async () => {
+    const goal = vault.createGoal('Daily task', 'daily_action');
+    const proposal = await builder.decompose(goal.id);
+    expect(proposal).toBeNull();
+  });
+
+  test('chat returns text reply', async () => {
+    const goal = vault.createGoal('Chat goal', 'objective');
+    const result = await builder.chat(goal.id, 'How can I improve this?', []);
+
+    expect(result.reply).toBeTruthy();
+    expect(result.proposal).toBeUndefined();
+  });
+});
+
+describe('GoalEstimator', () => {
+  let estimator: GoalEstimator;
+
+  beforeEach(() => {
+    initDatabase(':memory:');
+    estimator = new GoalEstimator(mockLLM);
+  });
+
+  test('quickEstimate returns heuristic for no history', () => {
+    const est = estimator.quickEstimate('Build auth', 'task');
+    expect(est.hours).toBe(4);
+    expect(est.confidence).toBe(0.2);
+  });
+
+  test('quickEstimate uses history when available', () => {
+    // Create some completed goals with actual hours
+    const g1 = vault.createGoal('Build login', 'task', { status: 'active' });
+    vault.updateGoalActualHours(g1.id, 6);
+    vault.updateGoalStatus(g1.id, 'completed');
+
+    const g2 = vault.createGoal('Build signup', 'task', { status: 'active' });
+    vault.updateGoalActualHours(g2.id, 8);
+    vault.updateGoalStatus(g2.id, 'completed');
+
+    const est = estimator.quickEstimate('Build auth flow', 'task');
+    // Should find similar goals and use their average
+    expect(est.hours).toBe(7); // avg of 6 and 8
+    expect(est.confidence).toBe(0.6);
+  });
+
+  test('estimate returns null for non-existent goal', async () => {
+    const est = await estimator.estimate('nonexistent');
+    expect(est).toBeNull();
+  });
+
+  test('estimate returns LLM-based estimate when no history', async () => {
+    const goal = vault.createGoal('New feature', 'key_result', {
+      description: 'Build something new',
+      success_criteria: 'It works well',
+    });
+
+    const est = await estimator.estimate(goal.id);
+    expect(est).not.toBeNull();
+    expect(est!.llm_estimate_hours).toBe(40);
+    expect(est!.historical_estimate_hours).toBeNull();
+    expect(est!.final_estimate_hours).toBe(40);
+    expect(est!.reasoning).toContain('No historical data');
+  });
+
+  test('estimate blends history and LLM', async () => {
+    // Create completed goals with matching words
+    const g1 = vault.createGoal('Build feature alpha', 'key_result', {
+      status: 'active',
+      description: 'Build something',
+    });
+    vault.updateGoalActualHours(g1.id, 30);
+    vault.updateGoalStatus(g1.id, 'completed');
+
+    const g2 = vault.createGoal('Build feature beta', 'key_result', {
+      status: 'active',
+      description: 'Build another thing',
+    });
+    vault.updateGoalActualHours(g2.id, 50);
+    vault.updateGoalStatus(g2.id, 'completed');
+
+    // Create goal to estimate
+    const goal = vault.createGoal('Build feature gamma', 'key_result', {
+      description: 'Build yet another thing',
+      success_criteria: 'Feature complete',
+    });
+
+    const est = await estimator.estimate(goal.id);
+    expect(est).not.toBeNull();
+    expect(est!.historical_estimate_hours).toBe(40); // avg of 30 and 50
+    expect(est!.llm_estimate_hours).toBe(40);
+    // 60% history (40) + 40% LLM (40) = 40
+    expect(est!.final_estimate_hours).toBe(40);
+    expect(est!.confidence).toBeGreaterThan(0.5);
+    expect(est!.similar_past_goals.length).toBe(2);
+  });
+});