# Fork the repository on GitHub first, then clone your fork
git clone https://github.com/YOUR_USERNAME/daily-vibe.git
cd daily-vibe

# Add upstream remote
git remote add upstream https://github.com/AoWangg/daily-vibe.git

# Verify remotes
git remote -v

# Install dependencies (pnpm recommended)
pnpm install

# Or with npm
npm install

# Verify installation
pnpm list

# Build the project
pnpm run build

# Run tests
pnpm test

# Run linting
pnpm run lint

# Link for local development
pnpm link --global

# Test the CLI
daily-vibe --version

// Use strict typing
interface AnalysisResult {
  summary: {
    overview: string;
    keyOutputs: string[];
  };
  statistics: {
    totalSessions: number;
    totalHours: number;
    avgSessionLength: number;
  };
}

// Prefer type guards
function isValidAnalysisResult(data: unknown): data is AnalysisResult {
  return typeof data === 'object' && 
         data !== null && 
         'summary' in data && 
         'statistics' in data;
}

// Use generic constraints
interface DataCollector<T extends SessionData> {
  collect(dateRange: DateRange): Promise<T[]>;
}

// Use async/await over Promises
async function analyzeSession(session: SessionData): Promise<AnalysisResult> {
  try {
    const analysis = await llmProvider.analyze(session.content);
    return processAnalysis(analysis);
  } catch (error) {
    logger.error('Analysis failed:', error);
    throw new AnalysisError('Failed to analyze session', { cause: error });
  }
}

// Prefer functional programming
const validSessions = sessions
  .filter(session => session.duration > minDuration)
  .map(session => normalizeSession(session))
  .filter(session => session.content.length > 0);

// Use descriptive names
const extractProblemSolutionPairs = (content: string): ProblemSolution[] => {
  // Implementation
};

// Create custom error classes
export class ConfigurationError extends Error {
  constructor(message: string, public readonly field?: string) {
    super(message);
    this.name = 'ConfigurationError';
  }
}

// Handle errors gracefully
async function loadConfiguration(): Promise<Configuration> {
  try {
    const config = await cosmiconfig.search();
    if (!config) {
      throw new ConfigurationError('No configuration file found');
    }
    
    return validateConfiguration(config.config);
  } catch (error) {
    if (error instanceof ConfigurationError) {
      throw error;
    }
    
    throw new ConfigurationError('Failed to load configuration', { cause: error });
  }
}

// tests/unit/analyzers/knowledge-extractor.test.ts
import { describe, it, expect } from 'vitest';
import { KnowledgeExtractor } from '../../../src/lib/analyzers/knowledge-extractor';

describe('KnowledgeExtractor', () => {
  const extractor = new KnowledgeExtractor();
  
  it('should extract problem-solution pairs', () => {
    const content = `
      I encountered a TypeScript error: Property 'foo' does not exist on type 'Bar'.
      I solved it by adding a type assertion: (obj as any).foo
    `;
    
    const result = extractor.extractProblemSolution(content);
    
    expect(result).toHaveLength(1);
    expect(result[0].problem).toContain('TypeScript error');
    expect(result[0].solution).toContain('type assertion');
  });
  
  it('should categorize knowledge by tags', () => {
    const problemSolution = {
      problem: 'React component not re-rendering',
      solution: 'Use useCallback hook',
      context: 'React functional component'
    };
    
    const tags = extractor.generateTags(problemSolution);
    
    expect(tags).toContain('react');
    expect(tags).toContain('hooks');
  });
});

// tests/integration/commands/analyze.test.ts
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { mkdtemp, rm } from 'fs/promises';
import { join } from 'path';
import { tmpdir } from 'os';
import { AnalyzeCommand } from '../../../src/commands/analyze';

describe('Analyze Command Integration', () => {
  let tempDir: string;
  
  beforeEach(async () => {
    tempDir = await mkdtemp(join(tmpdir(), 'daily-vibe-test-'));
  });
  
  afterEach(async () => {
    await rm(tempDir, { recursive: true });
  });
  
  it('should generate reports for valid session data', async () => {
    // Setup test data
    const mockSessions = [
      { timestamp: new Date(), content: 'Test session', duration: 3600 }
    ];
    
    // Run analysis
    const command = new AnalyzeCommand();
    await command.run(['today', '--out', tempDir]);
    
    // Verify outputs
    const dailyReport = await readFile(join(tempDir, 'daily.md'), 'utf8');
    expect(dailyReport).toContain('Daily Development Report');
  });
});

// tests/unit/lib/llm/openai-provider.test.ts
import { describe, it, expect, vi } from 'vitest';
import { OpenAIProvider } from '../../../src/lib/llm/openai-provider';

// Mock the OpenAI client
vi.mock('openai', () => ({
  default: vi.fn().mockImplementation(() => ({
    chat: {
      completions: {
        create: vi.fn().mockResolvedValue({
          choices: [{ message: { content: 'Mock response' } }]
        })
      }
    }
  }))
}));

describe('OpenAIProvider', () => {
  it('should make API calls with correct parameters', async () => {
    const provider = new OpenAIProvider({ apiKey: 'test-key', model: 'gpt-4' });
    
    const result = await provider.analyze('Test content');
    
    expect(result).toBe('Mock response');
  });
});

# Run all tests
pnpm test

# Run tests in watch mode during development
pnpm test:watch

# Run tests with verbose output
pnpm test --reporter=verbose

# Run specific test file
pnpm test tests/unit/analyzers/knowledge-extractor.test.ts

# Run tests matching pattern
pnpm test --grep "KnowledgeExtractor"

# Run integration tests only
pnpm test tests/integration/

# Generate coverage report
pnpm test:coverage

# View coverage in browser
open coverage/index.html