for Digital Nomads Harvest vs Writer: What You Need to Know

import os
import requests
import time
from datetime import datetime, timedelta
from typing import List, Dict, Optional

# Configuration: set via environment variables for security
HARVEST_ACCOUNT_ID = os.getenv("HARVEST_ACCOUNT_ID")
HARVEST_API_KEY = os.getenv("HARVEST_API_KEY")
GITHUB_TOKEN = os.getenv("GITHUB_TOKEN")
GITHUB_REPO_OWNER = "your-org"
GITHUB_REPO_NAME = "nomad-time-logs"
SYNC_WINDOW_HOURS = 24  # Sync time entries from last 24 hours

# Validate required environment variables
if not all([HARVEST_ACCOUNT_ID, HARVEST_API_KEY, GITHUB_TOKEN]):
    raise ValueError("Missing required environment variables: HARVEST_ACCOUNT_ID, HARVEST_API_KEY, GITHUB_TOKEN")

# Harvest API client with rate limit handling
class HarvestClient:
    BASE_URL = "https://api.harvestapp.com/v2"

    def __init__(self, account_id: str, api_key: str):
        self.account_id = account_id
        self.api_key = api_key
        self.session = requests.Session()
        self.session.headers.update({
            "Harvest-Account-ID": self.account_id,
            "Authorization": f"Bearer {self.api_key}",
            "User-Agent": "Nomad-Sync/1.0"
        })

    def get_time_entries(self, start_date: str, end_date: str) -> List[Dict]:
        """Fetch time entries within a date range, handling pagination"""
        entries = []
        page = 1
        while True:
            try:
                response = self.session.get(
                    f"{self.BASE_URL}/time_entries",
                    params={"start_date": start_date, "end_date": end_date, "page": page},
                    timeout=10
                )
                response.raise_for_status()
                data = response.json()
                entries.extend(data.get("time_entries", []))
                if page >= data.get("total_pages", 1):
                    break
                page += 1
                time.sleep(0.5)  # Respect Harvest rate limit: 100 req/min
            except requests.exceptions.RequestException as e:
                print(f"Harvest API error on page {page}: {str(e)}")
                time.sleep(5)
                continue
        return entries

# GitHub API client for issue creation
class GitHubClient:
    BASE_URL = "https://api.github.com"

    def __init__(self, token: str, owner: str, repo: str):
        self.token = token
        self.owner = owner
        self.repo = repo
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"token {self.token}",
            "Accept": "application/vnd.github.v3+json",
            "User-Agent": "Nomad-Sync/1.0"
        })

    def create_issue(self, title: str, body: str, labels: List[str] = None) -> Optional[Dict]:
        """Create a GitHub issue with time entry details"""
        try:
            response = self.session.post(
                f"{self.BASE_URL}/repos/{self.owner}/{self.repo}/issues",
                json={
                    "title": title,
                    "body": body,
                    "labels": labels or ["time-tracking"]
                },
                timeout=10
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"GitHub API error creating issue: {str(e)}")
            return None

def main():
    # Calculate sync window
    end_date = datetime.utcnow().strftime("%Y-%m-%d")
    start_date = (datetime.utcnow() - timedelta(hours=SYNC_WINDOW_HOURS)).strftime("%Y-%m-%d")

    # Initialize clients
    harvest = HarvestClient(HARVEST_ACCOUNT_ID, HARVEST_API_KEY)
    github = GitHubClient(GITHUB_TOKEN, GITHUB_REPO_OWNER, GITHUB_REPO_NAME)

    # Fetch time entries
    print(f"Fetching Harvest time entries from {start_date} to {end_date}")
    entries = harvest.get_time_entries(start_date, end_date)
    print(f"Found {len(entries)} time entries to sync")

    # Sync each entry to GitHub
    synced = 0
    for entry in entries:
        entry_date = entry.get("spent_date")
        project = entry.get("project", {}).get("name", "Unknown Project")
        task = entry.get("task", {}).get("name", "Unknown Task")
        hours = entry.get("hours", 0)
        notes = entry.get("notes", "No notes")

        title = f"[Time Entry] {project} - {task} ({entry_date})"
        body = f"""## Harvest Time Entry
- **Project**: {project}
- **Task**: {task}
- **Hours**: {hours}
- **Date**: {entry_date}
- **Notes**: {notes}
- **Harvest ID**: {entry.get("id")}
"""
        result = github.create_issue(title, body)
        if result:
            synced += 1
            print(f"Synced entry {entry.get('id')} to GitHub issue #{result.get('number')}")
        time.sleep(1)  # Respect GitHub rate limit: 5000 req/hour

    print(f"Sync complete: {synced}/{len(entries)} entries synced successfully")

if __name__ == "__main__":
    main()

const fetch = require('node-fetch');
const { Client } = require('@elastic/elasticsearch'); // For logging benchmarks
require('dotenv').config();

// Configuration
const HARVEST_API_KEY = process.env.HARVEST_API_KEY;
const HARVEST_ACCOUNT_ID = process.env.HARVEST_ACCOUNT_ID;
const WRITER_API_KEY = process.env.WRITER_API_KEY;
const WRITER_BRAND_VOICE_ID = process.env.WRITER_BRAND_VOICE_ID;
const ELASTICSEARCH_URL = process.env.ELASTICSEARCH_URL || 'http://localhost:9200';

// Initialize Elasticsearch client for benchmark logging
const esClient = new Client({ node: ELASTICSEARCH_URL });

// Harvest API client
class HarvestClient {
  constructor(apiKey, accountId) {
    this.apiKey = apiKey;
    this.accountId = accountId;
    this.baseUrl = 'https://api.harvestapp.com/v2';
  }

  async getProjectTimeSummary(projectId) {
    try {
      const response = await fetch(`${this.baseUrl}/projects/${projectId}/time_entries`, {
        method: 'GET',
        headers: {
          'Harvest-Account-ID': this.accountId,
          'Authorization': `Bearer ${this.apiKey}`,
          'User-Agent': 'Nomad-Writer-Sync/1.0'
        },
        timeout: 10000
      });

      if (!response.ok) {
        throw new Error(`Harvest API error: ${response.status} ${response.statusText}`);
      }

      const data = await response.json();
      const totalHours = data.time_entries.reduce((sum, entry) => sum + entry.hours, 0);
      const projectName = data.time_entries[0]?.project?.name || 'Unknown Project';

      return {
        projectId,
        projectName,
        totalHours,
        entryCount: data.time_entries.length,
        tasks: [...new Set(data.time_entries.map(e => e.task.name))]
      };
    } catch (error) {
      console.error(`Failed to fetch Harvest project ${projectId}:`, error.message);
      return null;
    }
  }
}

// Writer API client
class WriterClient {
  constructor(apiKey, brandVoiceId) {
    this.apiKey = apiKey;
    this.brandVoiceId = brandVoiceId;
    this.baseUrl = 'https://api.writer.com/v1';
  }

  async generateBlogPost(projectSummary) {
    const prompt = `Write a 1500-word technical blog post for digital nomads about completing the project "${projectSummary.projectName}". 
    Include:
    - Total hours worked: ${projectSummary.totalHours}
    - Key tasks: ${projectSummary.tasks.join(', ')}
    - Lessons learned for remote teams
    - Tools used (mention Harvest for time tracking)
    Use an authoritative, technical tone consistent with our brand voice.`;

    try {
      const startTime = Date.now();
      const response = await fetch(`${this.baseUrl}/content/generate`, {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json',
          'X-Brand-Voice-ID': this.brandVoiceId
        },
        body: JSON.stringify({
          prompt,
          max_tokens: 2048,
          temperature: 0.3,
          format: 'markdown'
        }),
        timeout: 30000
      });

      if (!response.ok) {
        throw new Error(`Writer API error: ${response.status} ${response.statusText}`);
      }

      const data = await response.json();
      const latency = Date.now() - startTime;

      // Log benchmark to Elasticsearch
      await esClient.index({
        index: 'writer-benchmarks',
        body: {
          timestamp: new Date(),
          latency_ms: latency,
          prompt_tokens: data.usage.prompt_tokens,
          completion_tokens: data.usage.completion_tokens,
          project_id: projectSummary.projectId
        }
      });

      return {
        content: data.content,
        latency,
        usage: data.usage
      };
    } catch (error) {
      console.error('Failed to generate Writer content:', error.message);
      return null;
    }
  }
}

async function main() {
  if (!HARVEST_API_KEY || !HARVEST_ACCOUNT_ID || !WRITER_API_KEY) {
    throw new Error('Missing required environment variables');
  }

  const harvest = new HarvestClient(HARVEST_API_KEY, HARVEST_ACCOUNT_ID);
  const writer = new WriterClient(WRITER_API_KEY, WRITER_BRAND_VOICE_ID);

  // Get top 3 projects by time spent in last 30 days
  const thirtyDaysAgo = new Date();
  thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
  const startDate = thirtyDaysAgo.toISOString().split('T')[0];

  try {
    const projectsResponse = await fetch(`${harvest.baseUrl}/projects?active=true`, {
      headers: {
        'Harvest-Account-ID': HARVEST_ACCOUNT_ID,
        'Authorization': `Bearer ${HARVEST_API_KEY}`
      }
    });
    const { projects } = await projectsResponse.json();

    for (const project of projects.slice(0, 3)) {
      console.log(`Processing project: ${project.name}`);
      const summary = await harvest.getProjectTimeSummary(project.id);
      if (!summary) continue;

      const blogPost = await writer.generateBlogPost(summary);
      if (blogPost) {
        console.log(`Generated blog post for ${project.name} in ${blogPost.latency}ms`);
        // Save to file
        const fs = require('fs');
        fs.writeFileSync(
          `./blog-posts/${project.name.replace(/\s+/g, '-')}.md`,
          blogPost.content
        );
      }
    }
  } catch (error) {
    console.error('Main process error:', error.message);
  }
}

main();

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "io"
    "log"
    "net/http"
    "os"
    "sort"
    "strconv"
    "time"
)

// Config holds API credentials and benchmark parameters
type Config struct {
    HarvestAPIKey    string
    HarvestAccountID string
    WriterAPIKey     string
    WriterBrandVoice string
    RequestCount     int
}

// BenchmarkResult stores latency metrics for an API
type BenchmarkResult struct {
    API         string
    MinLatency  time.Duration
    MaxLatency  time.Duration
    AvgLatency  time.Duration
    P99Latency  time.Duration
    ErrorCount  int
    TotalRequests int
}

// LoadConfig reads configuration from environment variables
func LoadConfig() (*Config, error) {
    reqCount, err := strconv.Atoi(os.Getenv("BENCHMARK_REQUEST_COUNT"))
    if err != nil {
        reqCount = 100 // Default to 100 requests per API
    }

    config := &Config{
        HarvestAPIKey:    os.Getenv("HARVEST_API_KEY"),
        HarvestAccountID: os.Getenv("HARVEST_ACCOUNT_ID"),
        WriterAPIKey:     os.Getenv("WRITER_API_KEY"),
        WriterBrandVoice: os.Getenv("WRITER_BRAND_VOICE_ID"),
        RequestCount:     reqCount,
    }

    if config.HarvestAPIKey == "" || config.HarvestAccountID == "" {
        return nil, fmt.Errorf("missing Harvest credentials")
    }
    if config.WriterAPIKey == "" {
        return nil, fmt.Errorf("missing Writer API key")
    }

    return config, nil
}

// BenchmarkHarvestAPI measures Harvest API v2 latency
func BenchmarkHarvestAPI(ctx context.Context, config *Config) *BenchmarkResult {
    url := "https://api.harvestapp.com/v2/time_entries?per_page=1"
    latencies := make([]time.Duration, 0, config.RequestCount)
    errCount := 0

    for i := 0; i < config.RequestCount; i++ {
        start := time.Now()
        req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
        if err != nil {
            errCount++
            continue
        }
        req.Header.Set("Harvest-Account-ID", config.HarvestAccountID)
        req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", config.HarvestAPIKey))
        req.Header.Set("User-Agent", "Harvest-Benchmark/1.0")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            errCount++
            continue
        }
        io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
        latency := time.Since(start)
        latencies = append(latencies, latency)

        time.Sleep(500 * time.Millisecond) // Respect rate limit
    }

    return calculateMetrics("Harvest API v2", latencies, errCount, config.RequestCount)
}

// BenchmarkWriterAPI measures Writer API v1 latency
func BenchmarkWriterAPI(ctx context.Context, config *Config) *BenchmarkResult {
    url := "https://api.writer.com/v1/brand-voices"
    latencies := make([]time.Duration, 0, config.RequestCount)
    errCount := 0

    for i := 0; i < config.RequestCount; i++ {
        start := time.Now()
        req, err := http.NewRequestWithContext(ctx, "GET", url, nil)
        if err != nil {
            errCount++
            continue
        }
        req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", config.WriterAPIKey))
        req.Header.Set("User-Agent", "Writer-Benchmark/1.0")

        resp, err := http.DefaultClient.Do(req)
        if err != nil {
            errCount++
            continue
        }
        io.Copy(io.Discard, resp.Body)
        resp.Body.Close()
        latency := time.Since(start)
        latencies = append(latencies, latency)

        time.Sleep(200 * time.Millisecond) // Respect rate limit
    }

    return calculateMetrics("Writer API v1", latencies, errCount, config.RequestCount)
}

// calculateMetrics computes latency statistics
func calculateMetrics(api string, latencies []time.Duration, errCount, total int) *BenchmarkResult {
    if len(latencies) == 0 {
        return &BenchmarkResult{API: api, ErrorCount: errCount, TotalRequests: total}
    }

    // Sort latencies for percentile calculation
    sort.Slice(latencies, func(i, j int) bool { return latencies[i] < latencies[j] })

    min := latencies[0]
    max := latencies[len(latencies)-1]
    sum := time.Duration(0)
    for _, l := range latencies {
        sum += l
    }
    avg := sum / time.Duration(len(latencies))

    // Calculate p99
    p99Index := int(float64(len(latencies)) * 0.99)
    if p99Index >= len(latencies) {
        p99Index = len(latencies) - 1
    }
    p99 := latencies[p99Index]

    return &BenchmarkResult{
        API:         api,
        MinLatency:  min,
        MaxLatency:  max,
        AvgLatency:  avg,
        P99Latency:  p99,
        ErrorCount:  errCount,
        TotalRequests: total,
    }
}

func main() {
    config, err := LoadConfig()
    if err != nil {
        log.Fatalf("Failed to load config: %v", err)
    }

    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
    defer cancel()

    fmt.Println("Starting API benchmarks...")
    harvestResult := BenchmarkHarvestAPI(ctx, config)
    writerResult := BenchmarkWriterAPI(ctx, config)

    // Print results as JSON
    results := []*BenchmarkResult{harvestResult, writerResult}
    jsonData, err := json.MarshalIndent(results, "", "  ")
    if err != nil {
        log.Fatalf("Failed to marshal results: %v", err)
    }

    fmt.Println(string(jsonData))
}

# Apply client-specific rounding to time entries
def apply_client_rounding(time_entries, client_rounding_rules):
    for entry in time_entries:
        client_id = entry.get("client", {}).get("id")
        rule = client_rounding_rules.get(client_id, 15)  # Default 15 min
        entry["hours"] = round(entry["hours"] * (60 / rule)) * (rule / 60)
    return time_entries

// Check content against Writer brand voice
async function validateBrandVoice(content, brandVoiceId) {
  const response = await fetch('https://api.writer.com/v1/content/score', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${process.env.WRITER_API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      content,
      brand_voice_id: brandVoiceId
    })
  });
  const { score, feedback } = await response.json();
  return { score, feedback };
}

// Convert Writer token usage to Harvest time entry
func tokensToTimeEntry(tokenCount int, projectID string) map[string]interface{} {
  billableHours := float64(tokenCount) / 2000.0 // 2000 tokens = 1 billable hour
  return map[string]interface{}{
    "project_id": projectID,
    "task_id": "ai-editing-task-id", // Pre-created Harvest task
    "hours": billableHours,
    "notes": fmt.Sprintf("AI content generation: %d tokens", tokenCount),
    "spent_date": time.Now().Format("2006-01-02"),
  }
}