Improve COCOMO floor

Author: tstromberg

Makefile

@@ -67,3 +67,7 @@ fix:
 	exit $$exit_code
 
 # END: lint-install .
+
+.PHONY: deploy
+deploy:
+	./hacks/deploy.sh cmd/server/

README.md

@@ -8,7 +8,7 @@ Calculate the real-world cost of GitHub pull requests with detailed breakdowns o
 $ prcost https://github.com/chainguard-dev/apko/pull/1860
 
   https://github.com/chainguard-dev/apko/pull/1860
-  Rate: $156.25/hr  •  Salary: $250,000.00  •  Benefits: 1.3x
+  Rate: $155.71/hr  •  Salary: $249,000.00  •  Benefits: 1.3x
 
   Author
   ──────
@@ -31,8 +31,8 @@ $ prcost https://github.com/chainguard-dev/apko/pull/1860
 
   Merge Delay
   ───────────
-    Cost of Delay              $9,481.36    2.5 days (capped)
-    Cognitive Load             $3,160.45    20.2 hrs (capped)
+    Delivery                  $9,481.36    2.5 days (capped)
+    Coordination              $3,160.45    20.2 hrs (capped)
                               ────────────
     Subtotal                  $12,641.81    3.4 days
 
@@ -170,6 +170,8 @@ func main() {
 
 This model synthesizes empirical research from software engineering economics, cognitive psychology, and organizational behavior to estimate the comprehensive cost of pull request workflows. Individual PR estimates exhibit variance due to developer heterogeneity and project characteristics; statistical validity improves with aggregate analysis across larger samples (n ≥ 25).
 
+**Default Salary**: The model uses $249,000 as the default annual salary, based on the 2025 average for Staff Software Engineers per [Glassdoor](https://www.glassdoor.com/Salaries/staff-software-engineer-salary-SRCH_KO0,23.htm). This can be customized via the `--salary` flag or API configuration.
+
 ### 1. Development Effort
 
 **Method**: COCOMO II (COnstructive COst MOdel) effort estimation [1]
@@ -273,15 +275,11 @@ Where:
 
 **Scientific Justification**:
 
-**Cognitive Load**: Each unmerged PR consumes working memory capacity. Cognitive Load Theory shows that human working memory is limited to 7±2 items [7]. Developers must mentally track:
-1. The PR's current state and review status
-2. Potential merge conflicts with ongoing work
-3. Dependencies on or from the unmerged code
-4. Communication overhead coordinating with reviewers
+**Working Memory Burden**: Each unmerged PR consumes limited working memory capacity. Developers must mentally track the PR's current state, potential merge conflicts, dependencies, and communication with reviewers. Cognitive Load Theory shows human working memory is limited to 7±2 items [7], making this tracking overhead measurable.
 
 **Context Retention Costs**: Weinberg's research on programmer productivity shows 20-25% productivity loss from maintaining multiple mental contexts [8]. The 5% coordination factor captures the cost of "keeping tabs" on pending work rather than the cost of full context switches (which are accounted separately).
 
-**Team Communication Overhead**: Brooks' Law demonstrates that communication overhead grows with project complexity [9]. Unmerged PRs increase coordination burden as team members must track dependencies and potential conflicts.
+**Team Communication Overhead**: Brooks' Law demonstrates that communication overhead grows with project complexity [9]. Unmerged PRs increase coordination burden as team members must track dependencies and potential conflicts across the team.
 
 **References**:
 [7] Sweller, J., van Merriënboer, J. J., & Paas, F. (1998). Cognitive Architecture and Instructional Design. *Educational Psychology Review*, 10(3), 251-296. DOI: 10.1023/A:1022193728205

cmd/prcost/main.go

@@ -20,16 +20,16 @@ import (
 
 func main() {
 	// Define command-line flags
-	salary := flag.Float64("salary", 250000, "Annual salary for cost calculation")
+	salary := flag.Float64("salary", 249000, "Annual salary for cost calculation")
 	benefits := flag.Float64("benefits", 1.3, "Benefits multiplier (1.3 = 30% benefits)")
-	eventMinutes := flag.Float64("event-minutes", 20, "Minutes per review event")
+	eventMinutes := flag.Float64("event-minutes", 10, "Minutes per GitHub event (commits, comments, etc.)")
 	format := flag.String("format", "human", "Output format: human or json")
 	verbose := flag.Bool("verbose", false, "Show verbose logging output")
 
 	// Org/Repo sampling flags
 	org := flag.String("org", "", "GitHub organization to analyze (optionally with --repo for single repo)")
 	repo := flag.String("repo", "", "GitHub repository to analyze (requires --org)")
-	samples := flag.Int("samples", 25, "Number of PRs to sample for extrapolation")
+	samples := flag.Int("samples", 20, "Number of PRs to sample for extrapolation")
 	days := flag.Int("days", 90, "Number of days to look back for PR modifications")
 
 	flag.Usage = func() {
@@ -43,13 +43,13 @@ func main() {
 		fmt.Fprint(os.Stderr, "Options:\n")
 		flag.PrintDefaults()
 		fmt.Fprint(os.Stderr, "\nExamples:\n")
-		fmt.Fprintf(os.Stderr, "  Single PR:\n")
+		fmt.Fprint(os.Stderr, "  Single PR:\n")
 		fmt.Fprintf(os.Stderr, "    %s https://github.com/owner/repo/pull/123\n", os.Args[0])
 		fmt.Fprintf(os.Stderr, "    %s --salary 300000 https://github.com/owner/repo/pull/123\n\n", os.Args[0])
-		fmt.Fprintf(os.Stderr, "  Repository analysis:\n")
+		fmt.Fprint(os.Stderr, "  Repository analysis:\n")
 		fmt.Fprintf(os.Stderr, "    %s --org kubernetes --repo kubernetes\n", os.Args[0])
 		fmt.Fprintf(os.Stderr, "    %s --org myorg --repo myrepo --samples 50 --days 30\n\n", os.Args[0])
-		fmt.Fprintf(os.Stderr, "  Organization-wide analysis:\n")
+		fmt.Fprint(os.Stderr, "  Organization-wide analysis:\n")
 		fmt.Fprintf(os.Stderr, "    %s --org chainguard-dev\n", os.Args[0])
 		fmt.Fprintf(os.Stderr, "    %s --org myorg --samples 100 --days 60\n", os.Args[0])
 	}
@@ -74,13 +74,13 @@ func main() {
 	// Validate mode selection
 	// First check if --repo is specified without --org
 	if *repo != "" && *org == "" {
-		fmt.Fprintf(os.Stderr, "Error: --repo requires --org to be specified\n\n")
+		fmt.Fprint(os.Stderr, "Error: --repo requires --org to be specified\n\n")
 		flag.Usage()
 		os.Exit(1)
 	}
 
 	if orgMode && singlePRMode {
-		fmt.Fprintf(os.Stderr, "Error: Cannot use both --org and PR URL. Choose one mode.\n\n")
+		fmt.Fprint(os.Stderr, "Error: Cannot use both --org and PR URL. Choose one mode.\n\n")
 		flag.Usage()
 		os.Exit(1)
 	}
@@ -210,25 +210,45 @@ func printHumanReadable(breakdown *cost.Breakdown, prURL string) {
 	// Header with PR info
 	fmt.Println()
 	fmt.Printf("  %s\n", prURL)
+
+	// Show author and duration
+	authorLabel := breakdown.PRAuthor
+	if breakdown.AuthorBot {
+		authorLabel += " (bot)"
+	}
+	fmt.Printf("  Author: %s  •  Open: %s\n", authorLabel, formatTimeUnit(breakdown.PRDuration))
 	fmt.Printf("  Rate: %s/hr  •  Salary: %s  •  Benefits: %.1fx\n",
 		formatCurrency(breakdown.HourlyRate),
 		formatCurrency(breakdown.AnnualSalary),
 		breakdown.BenefitsMultiplier)
 	fmt.Println()
 
-	// Author Costs
-	fmt.Println("  Author")
-	fmt.Println("  ──────")
-	fmt.Printf("    Development Effort        %12s    %d LOC • %s\n",
-		formatCurrency(breakdown.Author.CodeCost), breakdown.Author.LinesAdded, formatTimeUnit(breakdown.Author.CodeHours))
-	fmt.Printf("    GitHub Activity           %12s    %d sessions • %s\n",
-		formatCurrency(breakdown.Author.GitHubCost), breakdown.Author.Sessions, formatTimeUnit(breakdown.Author.GitHubHours))
-	fmt.Printf("    GitHub Context Switching  %12s    %s\n",
-		formatCurrency(breakdown.Author.GitHubContextCost), formatTimeUnit(breakdown.Author.GitHubContextHours))
-	fmt.Println("                              ────────────")
-	fmt.Printf("    Subtotal                  %12s    %s\n",
-		formatCurrency(breakdown.Author.TotalCost), formatTimeUnit(breakdown.Author.TotalHours))
-	fmt.Println()
+	// Author Costs (skip entire section if no costs)
+	if breakdown.Author.TotalCost > 0 {
+		fmt.Println("  Development Cost")
+		fmt.Println("  ────────────────")
+		// Show development and adaptation separately (only if there are actual lines of code)
+		if breakdown.Author.NewLines > 0 {
+			fmt.Printf("    New Development           %12s    %d LOC • %s\n",
+				formatCurrency(breakdown.Author.NewCodeCost), breakdown.Author.NewLines, formatTimeUnit(breakdown.Author.NewCodeHours))
+		}
+		if breakdown.Author.ModifiedLines > 0 {
+			fmt.Printf("    Adaptation                %12s    %d LOC • %s\n",
+				formatCurrency(breakdown.Author.AdaptationCost), breakdown.Author.ModifiedLines, formatTimeUnit(breakdown.Author.AdaptationHours))
+		}
+		if breakdown.Author.GitHubHours > 0 {
+			fmt.Printf("    GitHub Activity           %12s    %d sessions • %s\n",
+				formatCurrency(breakdown.Author.GitHubCost), breakdown.Author.Sessions, formatTimeUnit(breakdown.Author.GitHubHours))
+		}
+		if breakdown.Author.GitHubContextHours > 0 {
+			fmt.Printf("    GitHub Context Switching  %12s    %s\n",
+				formatCurrency(breakdown.Author.GitHubContextCost), formatTimeUnit(breakdown.Author.GitHubContextHours))
+		}
+		fmt.Println("                              ────────────")
+		fmt.Printf("    Subtotal                  %12s    %s\n",
+			formatCurrency(breakdown.Author.TotalCost), formatTimeUnit(breakdown.Author.TotalHours))
+		fmt.Println()
+	}
 
 	// Participant Costs
 	if len(breakdown.Participants) > 0 {
@@ -240,14 +260,25 @@ func printHumanReadable(breakdown *cost.Breakdown, prURL string) {
 			totalParticipantHours += p.TotalHours
 		}
 
-		fmt.Println("  Participants")
-		fmt.Println("  ────────────")
+		fmt.Println("  Participant Cost")
+		fmt.Println("  ────────────────")
 		for _, p := range breakdown.Participants {
 			fmt.Printf("    %s\n", p.Actor)
-			fmt.Printf("      Review Activity         %12s    %d sessions • %s\n",
-				formatCurrency(p.GitHubCost), p.Sessions, formatTimeUnit(p.GitHubHours))
-			fmt.Printf("      Context Switching       %12s    %s\n",
-				formatCurrency(p.GitHubContextCost), formatTimeUnit(p.GitHubContextHours))
+			// Only show review activity if they reviewed (LOC-based)
+			if p.ReviewHours > 0 {
+				fmt.Printf("      Review Activity         %12s    %s\n",
+					formatCurrency(p.ReviewCost), formatTimeUnit(p.ReviewHours))
+			}
+			// Only show other events if they had non-review events
+			if p.GitHubHours > 0 {
+				fmt.Printf("      GitHub Events           %12s    %d sessions • %s\n",
+					formatCurrency(p.GitHubCost), p.Sessions, formatTimeUnit(p.GitHubHours))
+			}
+			// Always show context switching if there were sessions
+			if p.Sessions > 0 {
+				fmt.Printf("      Context Switching       %12s    %s\n",
+					formatCurrency(p.GitHubContextCost), formatTimeUnit(p.GitHubContextHours))
+			}
 		}
 		fmt.Println("                              ────────────")
 		fmt.Printf("    Subtotal                  %12s    %s\n",
@@ -256,28 +287,32 @@ func printHumanReadable(breakdown *cost.Breakdown, prURL string) {
 	}
 
 	// Merge Delay Costs
-	fmt.Println("  Merge Delay")
+	fmt.Println("  Delay Costs")
 	fmt.Println("  ───────────")
-	if breakdown.DelayCapped {
-		fmt.Printf("    Cost of Delay           %12s    %s (capped)\n",
-			formatCurrency(breakdown.DelayCostDetail.DeliveryDelayCost), formatTimeUnit(breakdown.DelayCostDetail.DeliveryDelayHours))
-	} else {
-		fmt.Printf("    Cost of Delay           %12s    %s\n",
-			formatCurrency(breakdown.DelayCostDetail.DeliveryDelayCost), formatTimeUnit(breakdown.DelayCostDetail.DeliveryDelayHours))
+	if breakdown.DelayCostDetail.DeliveryDelayHours > 0 {
+		if breakdown.DelayCapped {
+			fmt.Printf("    Delivery                  %12s    %s (capped)\n",
+				formatCurrency(breakdown.DelayCostDetail.DeliveryDelayCost), formatTimeUnit(breakdown.DelayCostDetail.DeliveryDelayHours))
+		} else {
+			fmt.Printf("    Delivery                  %12s    %s\n",
+				formatCurrency(breakdown.DelayCostDetail.DeliveryDelayCost), formatTimeUnit(breakdown.DelayCostDetail.DeliveryDelayHours))
+		}
 	}
 
-	if breakdown.DelayCapped {
-		fmt.Printf("    Cognitive Load          %12s    %s (capped)\n",
-			formatCurrency(breakdown.DelayCostDetail.CoordinationCost), formatTimeUnit(breakdown.DelayCostDetail.CoordinationHours))
-	} else {
-		fmt.Printf("    Cognitive Load          %12s    %s\n",
-			formatCurrency(breakdown.DelayCostDetail.CoordinationCost), formatTimeUnit(breakdown.DelayCostDetail.CoordinationHours))
+	if breakdown.DelayCostDetail.CoordinationHours > 0 {
+		if breakdown.DelayCapped {
+			fmt.Printf("    Coordination              %12s    %s (capped)\n",
+				formatCurrency(breakdown.DelayCostDetail.CoordinationCost), formatTimeUnit(breakdown.DelayCostDetail.CoordinationHours))
+		} else {
+			fmt.Printf("    Coordination              %12s    %s\n",
+				formatCurrency(breakdown.DelayCostDetail.CoordinationCost), formatTimeUnit(breakdown.DelayCostDetail.CoordinationHours))
+		}
 	}
 
 	mergeDelayCost := breakdown.DelayCostDetail.DeliveryDelayCost + breakdown.DelayCostDetail.CoordinationCost
 	mergeDelayHours := breakdown.DelayCostDetail.DeliveryDelayHours + breakdown.DelayCostDetail.CoordinationHours
 	fmt.Println("                              ────────────")
-	fmt.Printf("    Subtotal                %12s    %s\n",
+	fmt.Printf("    Subtotal                  %12s    %s\n",
 		formatCurrency(mergeDelayCost), formatTimeUnit(mergeDelayHours))
 	fmt.Println()
 
@@ -292,24 +327,28 @@ func printHumanReadable(breakdown *cost.Breakdown, prURL string) {
 		fmt.Println("  ────────────")
 
 		if breakdown.DelayCostDetail.ReworkPercentage > 0 {
-			fmt.Printf("    Code Churn (%.0f%% drift) %12s    %s\n",
-				breakdown.DelayCostDetail.ReworkPercentage,
+			label := fmt.Sprintf("Code Churn (%.0f%% drift)", breakdown.DelayCostDetail.ReworkPercentage)
+			fmt.Printf("    %-24s%12s    %s\n",
+				label,
 				formatCurrency(breakdown.DelayCostDetail.CodeChurnCost),
 				formatTimeUnit(breakdown.DelayCostDetail.CodeChurnHours))
 		}
 
 		if breakdown.DelayCostDetail.FutureReviewCost > 0 {
-			fmt.Printf("    Review                  %12s    %s\n",
+			fmt.Printf("    %-24s%12s    %s\n",
+				"Review",
 				formatCurrency(breakdown.DelayCostDetail.FutureReviewCost), formatTimeUnit(breakdown.DelayCostDetail.FutureReviewHours))
 		}
 
 		if breakdown.DelayCostDetail.FutureMergeCost > 0 {
-			fmt.Printf("    Merge                   %12s    %s\n",
+			fmt.Printf("    %-24s%12s    %s\n",
+				"Merge",
 				formatCurrency(breakdown.DelayCostDetail.FutureMergeCost), formatTimeUnit(breakdown.DelayCostDetail.FutureMergeHours))
 		}
 
 		if breakdown.DelayCostDetail.FutureContextCost > 0 {
-			fmt.Printf("    Context Switching       %12s    %s\n",
+			fmt.Printf("    %-24s%12s    %s\n",
+				"Context Switching",
 				formatCurrency(breakdown.DelayCostDetail.FutureContextCost), formatTimeUnit(breakdown.DelayCostDetail.FutureContextHours))
 		}
 
@@ -322,7 +361,7 @@ func printHumanReadable(breakdown *cost.Breakdown, prURL string) {
 			breakdown.DelayCostDetail.FutureMergeHours +
 			breakdown.DelayCostDetail.FutureContextHours
 		fmt.Println("                              ────────────")
-		fmt.Printf("    Subtotal                %12s    %s\n",
+		fmt.Printf("    Subtotal                  %12s    %s\n",
 			formatCurrency(futureCost), formatTimeUnit(futureHours))
 		fmt.Println()
 	}