autocrossbow/cmd/acb/main.go

package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"os"
	"time"

	"o5r.ca/autocrossbow/contributions"
	"o5r.ca/autocrossbow/issues"
	"o5r.ca/autocrossbow/issues/vikunja"
)

func main() {
	// Define flags
	var jiraUser = flag.String("jira-user", "", "Jira user to query")
	var proj = flag.String("proj", "", "Project name")
	var ghusername = flag.String("ghusername", "", "GitHub username")
	var start = flag.String("start", "", "Start date")
	var end = flag.String("end", "", "End date")
	var employeename = flag.String("employeename", "", "Employee name")
	var prompt = flag.String("prompt", defaultPrompt, "Custom prompt to use for summarization")

	flag.Parse()

	// Check required flags
	if *start == "" || *end == "" {
		fmt.Println("Error: start and end dates are required")
		flag.Usage()
		os.Exit(1)
	}

	// Check that at least one of employee name, jira user, project, or ghusername is provided
	if *employeename == "" && *jiraUser == "" && *proj == "" && *ghusername == "" {
		fmt.Println("Error: at least one of employee name, jira user, project, or ghusername must be provided")
		flag.Usage()
		os.Exit(1)
	}

	// Check if the prompt is a file path and read it if it exists
	finalPrompt := *prompt
	if _, err := os.Stat(*prompt); err == nil {
		// File exists, read it
		content, err := os.ReadFile(*prompt)
		if err != nil {
			fmt.Printf("Error reading prompt file: %v\n", err)
			os.Exit(1)
		}
		finalPrompt = string(content)
	}

	var prs map[string][]contributions.PullRequest
	var issues []issues.Issue
	var vikunjaTasks []vikunja.Task

	// Only call tools if relevant flags are set
	if *proj != "" || *ghusername != "" {
		prs = DoPrs(*proj, *ghusername, *start, *end)
	}

	if *jiraUser != "" {
		issues = DoJira(*start, *end, *jiraUser)
	}

	//	if *employeename != "" {
	//		vikunjaTasks = DoVikunja(*start, *end)
	//	}

	// Get environment variables
	openaiEndpoint := os.Getenv("OPENAI_ENDPOINT")
	openaiToken := os.Getenv("OPENAI_TOKEN")
	openaiModel := os.Getenv("OPENAI_MODEL")
	anthropicModel := os.Getenv("ANTHROPIC_MODEL")

	// Create appropriate summarizer based on available environment variables
	var summarizer Summarizer
	if openaiEndpoint != "" && openaiToken != "" {
		// Use OpenAI summarizer
		summarizer = NewOpenAISummarizer(openaiEndpoint, openaiToken, openaiModel)
	} else if anthropicModel != "" {
		// Use Anthropic summarizer
		summarizer = NewAnthropicSummarizer(anthropicModel)
	} else {
		// Use Ollama summarizer as fallback
		summarizer = NewOllamaSummarizer("", "", openaiModel)
	}

	// Always call SummarizeData to ensure prompt file is created for debugging
	summ, err := SummarizeData(*employeename, prs, issues, vikunjaTasks, finalPrompt, summarizer)
	if err != nil {
		fmt.Println(fmt.Errorf("error getting PRs: %w", err))
		os.Exit(1)
	}

	// Only call summarization endpoint if we have a valid summarizer
	if summarizer != nil {
		fmt.Println(summ)
	} else {
		fmt.Println("No summarization endpoint configured, but prompt file was created for debugging")
	}
}

func DoPrs(proj, ghusername, start, end string) map[string][]contributions.PullRequest {
	prs, err := contributions.GetPRs(proj, ghusername, start, end)
	if err != nil {
		fmt.Println(fmt.Errorf("error getting PRs: %w", err))
		os.Exit(1)
	}

	ghf, err := os.Create(fmt.Sprintf("gh-%s-%s-%s-%s-%d.json", proj, ghusername, start, end, time.Now().Unix()))
	if err != nil {
		fmt.Println(fmt.Errorf("error creating PR file: %w", err))
		os.Exit(1)
	}
	enc := json.NewEncoder(ghf)
	err = enc.Encode(prs)
	if err != nil {
		fmt.Println(fmt.Errorf("error writing out PRs: %w", err))
		os.Exit(1)
	}
	return prs
}

func DoJira(start, end string, user string) []issues.Issue {
	host := os.Getenv("JIRA_HOST")
	tasks, err := issues.GetIssues(host, user, start, end)
	if err != nil {
		fmt.Println(fmt.Errorf("error getting Vikunja tasks: %w", err))
		os.Exit(1)
	}

	vf, err := os.Create(fmt.Sprintf("jira-%s-%s-%s-%s-%d.json", host, user, start, end, time.Now().Unix()))
	if err != nil {
		fmt.Println(fmt.Errorf("error creating Jira file: %w", err))
		os.Exit(1)
	}
	defer vf.Close()

	enc := json.NewEncoder(vf)
	err = enc.Encode(tasks)
	if err != nil {
		fmt.Println(fmt.Errorf("error writing out Jira tasks: %w", err))
		os.Exit(1)
	}
	return tasks
}

func DoVikunja(start, end string) []vikunja.Task {
	host := os.Getenv("VIKUNJA_HOST")
	user := os.Getenv("VIKUNJA_USER")
	tasks, err := vikunja.GetTasks(host, user, start, end)
	if err != nil {
		fmt.Println(fmt.Errorf("error getting Vikunja tasks: %w", err))
		os.Exit(1)
	}

	vf, err := os.Create(fmt.Sprintf("vikunja-%s-%s-%s-%s-%d.json", host, user, start, end, time.Now().Unix()))
	if err != nil {
		fmt.Println(fmt.Errorf("error creating Vikunja file: %w", err))
		os.Exit(1)
	}
	defer vf.Close()

	enc := json.NewEncoder(vf)
	err = enc.Encode(tasks)
	if err != nil {
		fmt.Println(fmt.Errorf("error writing out Vikunja tasks: %w", err))
		os.Exit(1)
	}
	return tasks
}