repos / pgit

 1@@ -10,7 +10,7 @@ clean:
 2 .PHONY: clean
 3 
 4 build:
 5-	go build -o pgit ./main.go
 6+	go build -o pgit .
 7 .PHONY: build
 8 
 9 img:
10@@ -31,15 +31,17 @@ test:
11 
12 test-site:
13 	mkdir -p testdata.site
14-	go run main.go \
15+	rm -rf testdata.site/*
16+	go run . \
17 		--repo ./testdata \
18 		--out testdata.site \
19 		--clone-url "https://test.com/test/test2" \
20 		--home-url "https://test.com/test" \
21 		--label testdata \
22-		--desc "pgit testing site" \
23-		--theme "dracula" \
24-		--revs "main,branch-c"
25+		--desc "pgit testing site - [link](https://yourmom.com)" \
26+		--theme "kanagawa-dragon" \
27+		--revs "main,branch-c" \
28+		--issues
29 .PHONY: test-site
30 
31 static: build clean

 1@@ -8,7 +8,8 @@
 2     "ripgrep@latest",
 3     "nodejs@latest",
 4     "yarn@latest",
 5-    "git@latest"
 6+    "git@latest",
 7+    "git-bug@latest"
 8   ],
 9   "shell": {
10     "init_hook": [

 1@@ -197,6 +197,54 @@
 2         }
 3       }
 4     },
 5+    "git-bug@latest": {
 6+      "last_modified": "2026-03-21T07:29:51Z",
 7+      "resolved": "github:NixOS/nixpkgs/09061f748ee21f68a089cd5d91ec1859cd93d0be#git-bug",
 8+      "source": "devbox-search",
 9+      "version": "0.10.1",
10+      "systems": {
11+        "aarch64-darwin": {
12+          "outputs": [
13+            {
14+              "name": "out",
15+              "path": "/nix/store/cs52jih5d6zjp73z5aw73jmrgz8kk8nh-git-bug-0.10.1",
16+              "default": true
17+            }
18+          ],
19+          "store_path": "/nix/store/cs52jih5d6zjp73z5aw73jmrgz8kk8nh-git-bug-0.10.1"
20+        },
21+        "aarch64-linux": {
22+          "outputs": [
23+            {
24+              "name": "out",
25+              "path": "/nix/store/h06gd6mgm5jhb2ny43ql7xbxrrd76cxw-git-bug-0.10.1",
26+              "default": true
27+            }
28+          ],
29+          "store_path": "/nix/store/h06gd6mgm5jhb2ny43ql7xbxrrd76cxw-git-bug-0.10.1"
30+        },
31+        "x86_64-darwin": {
32+          "outputs": [
33+            {
34+              "name": "out",
35+              "path": "/nix/store/7kr8ypm571jkqacl9bk5cvfasj031h1l-git-bug-0.10.1",
36+              "default": true
37+            }
38+          ],
39+          "store_path": "/nix/store/7kr8ypm571jkqacl9bk5cvfasj031h1l-git-bug-0.10.1"
40+        },
41+        "x86_64-linux": {
42+          "outputs": [
43+            {
44+              "name": "out",
45+              "path": "/nix/store/gqs0rch1z1gpl2qr52rjgfaxjzqrxr7n-git-bug-0.10.1",
46+              "default": true
47+            }
48+          ],
49+          "store_path": "/nix/store/gqs0rch1z1gpl2qr52rjgfaxjzqrxr7n-git-bug-0.10.1"
50+        }
51+      }
52+    },
53     "git@latest": {
54       "last_modified": "2026-03-21T07:29:51Z",
55       "resolved": "github:NixOS/nixpkgs/09061f748ee21f68a089cd5d91ec1859cd93d0be#git",

  1@@ -0,0 +1,939 @@
  2+# git-bug Integration Implementation Plan
  3+
  4+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
  5+
  6+**Goal:** Integrate git-bug issue tracking into pgit static site generator, creating issue list pages and individual issue detail pages.
  7+
  8+**Architecture:** Use git-bug's Go library (cache and entities/bug packages) to read issues from the repository at build time, filter and categorize them, then generate static HTML pages using Go templates.
  9+
 10+**Tech Stack:** Go, git-bug library, Go templates (existing pgit template system)
 11+
 12+---
 13+
 14+## Task 1: Add git-bug Dependency
 15+
 16+**Files:**
 17+- Modify: `go.mod`
 18+- Run: `go mod tidy`
 19+
 20+**Step 1: Add git-bug dependency**
 21+
 22+Run: `go get github.com/git-bug/[email protected]`
 23+
 24+**Step 2: Verify go.mod updated**
 25+
 26+Check that `github.com/git-bug/git-bug v0.10.1` appears in go.mod
 27+
 28+**Step 3: Commit**
 29+
 30+```bash
 31+jj commit -m "deps: add git-bug library for issue tracking"
 32+```
 33+
 34+---
 35+
 36+## Task 2: Create Issue Data Structures
 37+
 38+**Files:**
 39+- Create: `issues.go` (new file)
 40+
 41+**Step 1: Create issue data types**
 42+
 43+```go
 44+package main
 45+
 46+import (
 47+	"html/template"
 48+	"time"
 49+)
 50+
 51+// IssueData represents a git-bug issue for templates
 52+type IssueData struct {
 53+	ID           string
 54+	FullID       string
 55+	Title        string
 56+	Status       string // "open" or "closed"
 57+	Author       string
 58+	CreatedAt    time.Time
 59+	HumanDate    string
 60+	Labels       []string
 61+	CommentCount int // excludes original description
 62+	Description  template.HTML
 63+	Comments     []CommentData
 64+	URL          template.URL
 65+}
 66+
 67+// CommentData represents a comment on an issue
 68+type CommentData struct {
 69+	Author    string
 70+	CreatedAt time.Time
 71+	HumanDate string
 72+	Body      template.HTML
 73+}
 74+
 75+// IssuesListPageData for list pages (open, closed, by label)
 76+type IssuesListPageData struct {
 77+	*PageData
 78+	Filter      string // "open", "closed", or "label"
 79+	OpenCount   int
 80+	ClosedCount int
 81+	Issues      []*IssueData
 82+	Label       string   // set when Filter == "label"
 83+	AllLabels   []string // all unique labels from open issues
 84+}
 85+
 86+// IssueDetailPageData for individual issue pages
 87+type IssueDetailPageData struct {
 88+	*PageData
 89+	Issue *IssueData
 90+}
 91+
 92+// Active returns the active navigation item
 93+func (i *IssuesListPageData) Active() string { return "issues" }
 94+func (i *IssueDetailPageData) Active() string { return "issues" }
 95+```
 96+
 97+**Step 2: Commit**
 98+
 99+```bash
100+jj commit -m "feat: add issue data structures"
101+```
102+
103+---
104+
105+## Task 3: Create Issue Loading Function
106+
107+**Files:**
108+- Modify: `issues.go` (add import and functions)
109+
110+**Step 1: Add imports and loading function**
111+
112+```go
113+import (
114+	"fmt"
115+	"net/url"
116+	"path/filepath"
117+	"strings"
118+
119+	"github.com/git-bug/git-bug/cache"
120+	"github.com/git-bug/git-bug/entities/bug"
121+	"github.com/git-bug/git-bug/repository"
122+)
123+
124+// loadIssues reads all issues from git-bug in the repository
125+func (c *Config) loadIssues() ([]*IssueData, error) {
126+	// Open the repository with git-bug's repo opener
127+	repo, err := repository.OpenGoGitRepo(c.RepoPath, nil, nil)
128+	if err != nil {
129+		return nil, fmt.Errorf("failed to open repository: %w", err)
130+	}
131+	
132+	// Create cache for efficient querying
133+	repoCache, err := cache.NewRepoCacheNoEvents(repo)
134+	if err != nil {
135+		return nil, fmt.Errorf("failed to create repo cache: %w", err)
136+	}
137+	defer repoCache.Close()
138+	
139+	// Read all bugs
140+	var issues []*IssueData
141+	bugCache := repoCache.Bugs()
142+	
143+	for streamedBug := range bugCache.ReadAll() {
144+		if streamedBug.Err != nil {
145+			c.Logger.Warn("failed to read bug", "error", streamedBug.Err)
146+			continue
147+		}
148+		
149+		b := streamedBug.Entity
150+		snap := b.Compile()
151+		
152+		// Count comments (excluding the original description)
153+		commentCount := 0
154+		for _, op := range snap.Operations {
155+			if _, ok := op.(*bug.AddCommentOp); ok {
156+				commentCount++
157+			}
158+		}
159+		
160+		// Build labels slice
161+		labels := make([]string, len(snap.Labels))
162+		copy(labels, snap.Labels)
163+		
164+		// Build comments
165+		var comments []CommentData
166+		for _, op := range snap.Operations {
167+			if addCommentOp, ok := op.(*bug.AddCommentOp); ok {
168+				comments = append(comments, CommentData{
169+					Author:    addCommentOp.Author.Name,
170+					CreatedAt: addCommentOp.Timestamp,
171+					HumanDate: humanizeTime(addCommentOp.Timestamp),
172+					Body:      renderMarkdown(addCommentOp.Message),
173+				})
174+			}
175+		}
176+		
177+		fullID := b.Id().String()
178+		issue := &IssueData{
179+			ID:           getShortID(fullID),
180+			FullID:       fullID,
181+			Title:        snap.Title,
182+			Status:       string(snap.Status),
183+			Author:       snap.Author.Name,
184+			CreatedAt:    snap.CreateTime,
185+			HumanDate:    humanizeTime(snap.CreateTime),
186+			Labels:       labels,
187+			CommentCount: commentCount,
188+			Description:  renderMarkdown(snap.Description),
189+			Comments:     comments,
190+			URL:          c.getIssueURL(fullID),
191+		}
192+		issues = append(issues, issue)
193+	}
194+	
195+	return issues, nil
196+}
197+
198+// getIssueURL generates the URL for an issue detail page
199+func (c *Config) getIssueURL(issueID string) template.URL {
200+	url := fmt.Sprintf("%sissues/%s.html", c.RootRelative, issueID)
201+	return template.URL(url)
202+}
203+
204+// getIssuesListURL generates URL for issues list pages
205+func (c *Config) getIssuesListURL(filter string, label string) template.URL {
206+	var path string
207+	switch filter {
208+	case "open", "closed":
209+		path = filepath.Join("issues", filter, "index.html")
210+	case "label":
211+		// URL-encode the label
212+		encodedLabel := url.PathEscape(label)
213+		path = filepath.Join("issues", "label", encodedLabel, "index.html")
214+	default:
215+		path = filepath.Join("issues", "open", "index.html")
216+	}
217+	return c.compileURL("/", path)
218+}
219+```
220+
221+**Step 2: Commit**
222+
223+```bash
224+jj commit -m "feat: add issue loading from git-bug"
225+```
226+
227+---
228+
229+## Task 4: Create Issue List Template
230+
231+**Files:**
232+- Create: `html/issues_list.page.tmpl`
233+
234+**Step 1: Create the list template**
235+
236+```html
237+{{template "base" .}}
238+
239+{{define "title"}}{{if eq .Filter "label"}}Issues labeled "{{.Label}}"{{else if eq .Filter "closed"}}Closed Issues{{else}}Open Issues{{end}} - {{.Repo.RepoName}}{{end}}
240+
241+{{define "content"}}
242+<div class="issues-page">
243+  <div class="issues-header">
244+    <h1>
245+      {{if eq .Filter "label"}}
246+        Issues labeled "{{.Label}}"
247+      {{else if eq .Filter "closed"}}
248+        Closed Issues
249+      {{else}}
250+        Open Issues
251+      {{end}}
252+    </h1>
253+    
254+    <div class="issues-stats">
255+      {{if eq .Filter "open"}}
256+        <span class="stat active">{{.OpenCount}} Open</span>
257+        <a href="{{getIssuesListURL "closed" ""}}" class="stat">{{.ClosedCount}} Closed</a>
258+      {{else if eq .Filter "closed"}}
259+        <a href="{{getIssuesListURL "open" ""}}" class="stat">{{.OpenCount}} Open</a>
260+        <span class="stat active">{{.ClosedCount}} Closed</span>
261+      {{else}}
262+        <a href="{{getIssuesListURL "open" ""}}" class="stat">{{.OpenCount}} Open</a>
263+        <a href="{{getIssuesListURL "closed" ""}}" class="stat">{{.ClosedCount}} Closed</a>
264+        <span class="label-indicator">Label: {{.Label}}</span>
265+      {{end}}
266+    </div>
267+  </div>
268+
269+  {{if eq .Filter "open"}}
270+  <div class="issues-labels">
271+    <span>Filter by label:</span>
272+    {{range .AllLabels}}
273+      <a href="{{$.Repo.getIssuesListURL "label" .}}" class="label-link">{{.}}</a>
274+    {{end}}
275+  </div>
276+  {{end}}
277+
278+  <div class="issues-list">
279+    {{range .Issues}}
280+    <div class="issue-item">
281+      <div class="issue-item__main">
282+        <a href="{{.URL}}" class="issue-item__title">{{.Title}}</a>
283+        <div class="issue-item__meta">
284+          <span class="issue-id">#{{.ID}}</span>
285+          <span class="issue-status issue-status--{{.Status}}">{{.Status}}</span>
286+          {{if .Labels}}
287+          <span class="issue-labels">
288+            {{range .Labels}}<span class="issue-label">{{.}}</span>{{end}}
289+          </span>
290+          {{end}}
291+        </div>
292+      </div>
293+      <div class="issue-item__stats">
294+        <span class="issue-date" title="{{.CreatedAt}}">{{.HumanDate}}</span>
295+        {{if gt .CommentCount 0}}
296+        <span class="issue-comments">{{.CommentCount}} comment{{if ne .CommentCount 1}}s{{end}}</span>
297+        {{end}}
298+      </div>
299+    </div>
300+    {{else}}
301+    <p class="no-issues">No issues found.</p>
302+    {{end}}
303+  </div>
304+</div>
305+{{end}}
306+```
307+
308+**Step 2: Commit**
309+
310+```bash
311+jj commit -m "feat: add issues list template"
312+```
313+
314+---
315+
316+## Task 5: Create Issue Detail Template
317+
318+**Files:**
319+- Create: `html/issue_detail.page.tmpl`
320+
321+**Step 1: Create the detail template**
322+
323+```html
324+{{template "base" .}}
325+
326+{{define "title"}}{{.Issue.Title}} - Issue #{{.Issue.ID}} - {{.Repo.RepoName}}{{end}}
327+
328+{{define "content"}}
329+<div class="issue-detail">
330+  <div class="issue-detail__header">
331+    <h1>
332+      <span class="issue-status issue-status--{{.Issue.Status}}">{{.Issue.Status}}</span>
333+      {{.Issue.Title}}
334+    </h1>
335+    <div class="issue-detail__meta">
336+      <span class="issue-id">#{{.Issue.ID}}</span>
337+      <span class="issue-author">opened by {{.Issue.Author}}</span>
338+      <span class="issue-date" title="{{.Issue.CreatedAt}}">{{.Issue.HumanDate}}</span>
339+    </div>
340+    {{if .Issue.Labels}}
341+    <div class="issue-detail__labels">
342+      <span>Labels:</span>
343+      {{range .Issue.Labels}}<span class="issue-label">{{.}}</span>{{end}}
344+    </div>
345+    {{end}}
346+  </div>
347+
348+  <div class="issue-description">
349+    <div class="issue-comment">
350+      <div class="issue-comment__header">
351+        <span class="issue-comment__author">{{.Issue.Author}}</span>
352+        <span class="issue-comment__date" title="{{.Issue.CreatedAt}}">{{.Issue.HumanDate}}</span>
353+      </div>
354+      <div class="issue-comment__body">{{.Issue.Description}}</div>
355+    </div>
356+  </div>
357+
358+  {{if .Issue.Comments}}
359+  <div class="issue-comments">
360+    <h3>{{len .Issue.Comments}} Comment{{if ne (len .Issue.Comments) 1}}s{{end}}</h3>
361+    {{range .Issue.Comments}}
362+    <div class="issue-comment">
363+      <div class="issue-comment__header">
364+        <span class="issue-comment__author">{{.Author}}</span>
365+        <span class="issue-comment__date" title="{{.CreatedAt}}">{{.HumanDate}}</span>
366+      </div>
367+      <div class="issue-comment__body">{{.Body}}</div>
368+    </div>
369+    {{end}}
370+  </div>
371+  {{end}}
372+</div>
373+{{end}}
374+```
375+
376+**Step 2: Commit**
377+
378+```bash
379+jj commit -m "feat: add issue detail template"
380+```
381+
382+---
383+
384+## Task 6: Create Issue Page Generation Functions
385+
386+**Files:**
387+- Modify: `issues.go` (add generation functions)
388+
389+**Step 1: Add generation functions**
390+
391+```go
392+// writeIssueListPage generates an issues list page
393+func (c *Config) writeIssueListPage(data *PageData, filter string, label string, issues []*IssueData, openCount, closedCount int, allLabels []string) {
394+	c.Logger.Info("writing issues list", "filter", filter, "label", label, "count", len(issues))
395+	
396+	pageData := &IssuesListPageData{
397+		PageData:    data,
398+		Filter:      filter,
399+		OpenCount:   openCount,
400+		ClosedCount: closedCount,
401+		Issues:      issues,
402+		Label:       label,
403+		AllLabels:   allLabels,
404+	}
405+	
406+	var subdir string
407+	switch filter {
408+	case "open":
409+		subdir = "issues/open"
410+	case "closed":
411+		subdir = "issues/closed"
412+	case "label":
413+		encodedLabel := url.PathEscape(label)
414+		subdir = filepath.Join("issues/label", encodedLabel)
415+	}
416+	
417+	c.writeHtml(&WriteData{
418+		Filename: "index.html",
419+		Subdir:   subdir,
420+		Template: "html/issues_list.page.tmpl",
421+		Data:     pageData,
422+	})
423+}
424+
425+// writeIssueDetailPage generates an individual issue page
426+func (c *Config) writeIssueDetailPage(data *PageData, issue *IssueData) {
427+	c.Logger.Info("writing issue detail", "id", issue.ID, "title", issue.Title)
428+	
429+	pageData := &IssueDetailPageData{
430+		PageData: data,
431+		Issue:    issue,
432+	}
433+	
434+	c.writeHtml(&WriteData{
435+		Filename: fmt.Sprintf("%s.html", issue.FullID),
436+		Subdir:   "issues",
437+		Template: "html/issue_detail.page.tmpl",
438+		Data:     pageData,
439+	})
440+}
441+
442+// writeIssues generates all issue-related pages
443+func (c *Config) writeIssues(pageData *PageData) error {
444+	// Load all issues from git-bug
445+	issues, err := c.loadIssues()
446+	if err != nil {
447+		return fmt.Errorf("failed to load issues: %w", err)
448+	}
449+	
450+	// If no issues, skip generation
451+	if len(issues) == 0 {
452+		c.Logger.Info("no git-bug issues found, skipping issue generation")
453+		return nil
454+	}
455+	
456+	c.Logger.Info("loaded issues", "count", len(issues))
457+	
458+	// Categorize issues
459+	var openIssues, closedIssues []*IssueData
460+	labelIssues := make(map[string][]*IssueData)
461+	allLabels := make(map[string]bool)
462+	
463+	for _, issue := range issues {
464+		if issue.Status == "open" {
465+			openIssues = append(openIssues, issue)
466+			// Collect labels from open issues
467+			for _, label := range issue.Labels {
468+				allLabels[label] = true
469+				labelIssues[label] = append(labelIssues[label], issue)
470+			}
471+		} else {
472+			closedIssues = append(closedIssues, issue)
473+		}
474+	}
475+	
476+	openCount := len(openIssues)
477+	closedCount := len(closedIssues)
478+	
479+	// Build sorted label list
480+	var sortedLabels []string
481+	for label := range allLabels {
482+		sortedLabels = append(sortedLabels, label)
483+	}
484+	sort.Strings(sortedLabels)
485+	
486+	// Generate individual issue pages for all issues
487+	for _, issue := range issues {
488+		c.writeIssueDetailPage(pageData, issue)
489+	}
490+	
491+	// Generate list pages
492+	c.writeIssueListPage(pageData, "open", "", openIssues, openCount, closedCount, sortedLabels)
493+	c.writeIssueListPage(pageData, "closed", "", closedIssues, openCount, closedCount, sortedLabels)
494+	
495+	// Generate label filter pages (only for open issues)
496+	for label, issues := range labelIssues {
497+		c.writeIssueListPage(pageData, "label", label, issues, openCount, closedCount, sortedLabels)
498+	}
499+	
500+	return nil
501+}
502+```
503+
504+**Step 2: Add import for sort**
505+
506+Add `sort` to imports in `issues.go`
507+
508+**Step 3: Commit**
509+
510+```bash
511+jj commit -m "feat: add issue page generation functions"
512+```
513+
514+---
515+
516+## Task 7: Update Header Template for Issues Navigation
517+
518+**Files:**
519+- Modify: `html/header.partial.tmpl`
520+
521+**Step 1: Add Issues link to navigation**
522+
523+Add after the commits link (around line 16):
524+
525+```html
526+{{if .SiteURLs.IssuesURL}}{{if eq .Active "issues"}}<span class="active">issues</span>{{else}}<a href="{{.SiteURLs.IssuesURL}}">issues</a>{{end}}{{end}}
527+```
528+
529+**Step 2: Commit**
530+
531+```bash
532+jj commit -m "feat: add issues navigation link to header"
533+```
534+
535+---
536+
537+## Task 8: Add IssuesURL to SiteURLs
538+
539+**Files:**
540+- Modify: `main.go` (SiteURLs struct and getURLs method)
541+
542+**Step 1: Add IssuesURL to SiteURLs struct**
543+
544+Around line 167, add:
545+
546+```go
547+type SiteURLs struct {
548+	HomeURL    template.URL
549+	CloneURL   template.URL
550+	SummaryURL template.URL
551+	RefsURL    template.URL
552+	IssuesURL  template.URL // new
553+}
554+```
555+
556+**Step 2: Add IssuesURL generation to getURLs method**
557+
558+Around line 609, add:
559+
560+```go
561+func (c *Config) getURLs() *SiteURLs {
562+	return &SiteURLs{
563+		HomeURL:    c.HomeURL,
564+		CloneURL:   c.CloneURL,
565+		RefsURL:    c.getRefsURL(),
566+		SummaryURL: c.getSummaryURL(),
567+		IssuesURL:  c.getIssuesURL(),
568+	}
569+}
570+
571+// getIssuesURL returns the URL for the issues page
572+func (c *Config) getIssuesURL() template.URL {
573+	url := c.RootRelative + "issues/open/index.html"
574+	return template.URL(url)
575+}
576+```
577+
578+**Step 3: Commit**
579+
580+```bash
581+jj commit -m "feat: add IssuesURL to site URLs"
582+```
583+
584+---
585+
586+## Task 9: Add --issues CLI Flag and Integration
587+
588+**Files:**
589+- Modify: `main.go` (Config struct, flags, and writeRepo)
590+
591+**Step 1: Add Issues field to Config struct**
592+
593+Around line 34, add:
594+
595+```go
596+type Config struct {
597+	// ... existing fields ...
598+	Issues bool // enable git-bug issue generation
599+	// ... rest of fields ...
600+}
601+```
602+
603+**Step 2: Add --issues flag**
604+
605+Around line 1117, add:
606+
607+```go
608+var issuesFlag = flag.Bool("issues", false, "enable git-bug issue generation")
609+```
610+
611+**Step 3: Add Issues to config initialization**
612+
613+Around line 1146, add:
614+
615+```go
616+config := &Config{
617+	// ... existing fields ...
618+	Issues: *issuesFlag,
619+	// ... rest ...
620+}
621+```
622+
623+**Step 4: Integrate issue generation into writeRepo**
624+
625+Around line 740 (before `c.writeRefs`), add:
626+
627+```go
628+// Generate issue pages if enabled
629+if c.Issues {
630+	err := c.writeIssues(data)
631+	if err != nil {
632+		c.Logger.Warn("failed to write issues", "error", err)
633+	}
634+}
635+```
636+
637+**Step 5: Commit**
638+
639+```bash
640+jj commit -m "feat: add --issues flag and integrate issue generation"
641+```
642+
643+---
644+
645+## Task 10: Add CSS Styling for Issues
646+
647+**Files:**
648+- Modify: `html/header.partial.tmpl` (add style block) or create separate CSS
649+
650+**Step 1: Add styles to header template**
651+
652+Add inside the `<style>` block or in a style tag in header.partial.tmpl:
653+
654+```html
655+<style>
656+/* Issues styles */
657+.issues-page {
658+  max-width: 1200px;
659+  margin: 0 auto;
660+  padding: 20px;
661+}
662+
663+.issues-header {
664+  margin-bottom: 20px;
665+  border-bottom: 1px solid var(--border);
666+  padding-bottom: 15px;
667+}
668+
669+.issues-header h1 {
670+  margin-bottom: 10px;
671+}
672+
673+.issues-stats {
674+  display: flex;
675+  gap: 15px;
676+  align-items: center;
677+}
678+
679+.issues-stats .stat {
680+  padding: 5px 10px;
681+  border-radius: 4px;
682+  text-decoration: none;
683+}
684+
685+.issues-stats .stat.active {
686+  background: var(--link-color);
687+  color: var(--bg-color);
688+}
689+
690+.issues-labels {
691+  margin: 15px 0;
692+  padding: 10px;
693+  background: rgba(255,255,255,0.05);
694+  border-radius: 4px;
695+}
696+
697+.issues-labels .label-link {
698+  margin-left: 10px;
699+  padding: 2px 8px;
700+  background: var(--border);
701+  border-radius: 3px;
702+  font-size: 0.9em;
703+}
704+
705+.issue-item {
706+  display: flex;
707+  justify-content: space-between;
708+  align-items: flex-start;
709+  padding: 15px;
710+  border-bottom: 1px solid var(--border);
711+}
712+
713+.issue-item:hover {
714+  background: rgba(255,255,255,0.02);
715+}
716+
717+.issue-item__title {
718+  font-size: 1.1em;
719+  font-weight: bold;
720+  margin-bottom: 5px;
721+  display: block;
722+}
723+
724+.issue-item__meta {
725+  display: flex;
726+  gap: 10px;
727+  align-items: center;
728+  font-size: 0.85em;
729+  color: var(--text-color);
730+  opacity: 0.7;
731+}
732+
733+.issue-status {
734+  padding: 2px 8px;
735+  border-radius: 3px;
736+  font-size: 0.85em;
737+  font-weight: bold;
738+}
739+
740+.issue-status--open {
741+  background: #28a745;
742+  color: white;
743+}
744+
745+.issue-status--closed {
746+  background: #6c757d;
747+  color: white;
748+}
749+
750+.issue-labels {
751+  display: flex;
752+  gap: 5px;
753+}
754+
755+.issue-label {
756+  padding: 2px 6px;
757+  background: var(--border);
758+  border-radius: 3px;
759+  font-size: 0.8em;
760+}
761+
762+.issue-item__stats {
763+  text-align: right;
764+  font-size: 0.85em;
765+  opacity: 0.7;
766+}
767+
768+.issue-comments {
769+  margin-left: 10px;
770+}
771+
772+/* Issue detail */
773+.issue-detail {
774+  max-width: 1000px;
775+  margin: 0 auto;
776+  padding: 20px;
777+}
778+
779+.issue-detail__header {
780+  margin-bottom: 20px;
781+  padding-bottom: 15px;
782+  border-bottom: 1px solid var(--border);
783+}
784+
785+.issue-detail__header h1 {
786+  margin-bottom: 10px;
787+}
788+
789+.issue-detail__meta {
790+  display: flex;
791+  gap: 10px;
792+  align-items: center;
793+  margin-bottom: 10px;
794+}
795+
796+.issue-detail__labels {
797+  margin-top: 10px;
798+}
799+
800+.issue-description {
801+  margin-bottom: 30px;
802+}
803+
804+.issue-comment {
805+  padding: 15px;
806+  border: 1px solid var(--border);
807+  border-radius: 6px;
808+  margin-bottom: 15px;
809+}
810+
811+.issue-comment__header {
812+  display: flex;
813+  justify-content: space-between;
814+  margin-bottom: 10px;
815+  padding-bottom: 10px;
816+  border-bottom: 1px solid var(--border);
817+}
818+
819+.issue-comment__author {
820+  font-weight: bold;
821+}
822+
823+.issue-comment__date {
824+  opacity: 0.7;
825+  font-size: 0.9em;
826+}
827+
828+.issue-comment__body {
829+  line-height: 1.6;
830+}
831+
832+.issue-comments h3 {
833+  margin-bottom: 15px;
834+}
835+</style>
836+```
837+
838+**Step 2: Commit**
839+
840+```bash
841+jj commit -m "feat: add CSS styling for issues"
842+```
843+
844+---
845+
846+## Task 11: Build and Test
847+
848+**Files:**
849+- Run: Build and test commands
850+
851+**Step 1: Build the project**
852+
853+```bash
854+go build -o pgit
855+```
856+
857+**Step 2: Test without --issues (should work as before)**
858+
859+```bash
860+./pgit --revs HEAD --out ./test-output
861+```
862+
863+**Step 3: Test with --issues on repo without git-bug (should skip gracefully)**
864+
865+```bash
866+./pgit --revs HEAD --out ./test-output --issues
867+```
868+
869+Expected: Should see "no git-bug issues found, skipping issue generation" in logs
870+
871+**Step 4: Test with --issues on repo with git-bug (if available)**
872+
873+If you have a repo with git-bug:
874+```bash
875+./pgit --repo /path/to/repo-with-issues --revs HEAD --out ./test-output --issues
876+```
877+
878+Expected: Should see issues pages generated
879+
880+**Step 5: Commit**
881+
882+```bash
883+jj commit -m "build: verify issues feature compiles and runs"
884+```
885+
886+---
887+
888+## Task 12: Add Template Function for IssuesListURL
889+
890+**Files:**
891+- Modify: `main.go` (writeHtml method to add template functions)
892+
893+**Step 1: Add template function**
894+
895+In `writeHtml` method, modify the template parsing to include a function map:
896+
897+```go
898+func (c *Config) writeHtml(writeData *WriteData) {
899+	// Create function map
900+	funcMap := template.FuncMap{
901+		"getIssuesListURL": func(filter string, label string) template.URL {
902+			return c.getIssuesListURL(filter, label)
903+		},
904+	}
905+	
906+	ts, err := template.New("").Funcs(funcMap).ParseFS(
907+		embedFS,
908+		writeData.Template,
909+		"html/header.partial.tmpl",
910+		"html/footer.partial.tmpl",
911+		"html/base.layout.tmpl",
912+	)
913+	bail(err)
914+	
915+	// ... rest of method ...
916+}
917+```
918+
919+**Step 2: Commit**
920+
921+```bash
922+jj commit -m "feat: add getIssuesListURL template function"
923+```
924+
925+---
926+
927+## Summary
928+
929+After completing all tasks, the pgit static site generator will:
930+
931+1. Support `--issues` flag to enable git-bug integration
932+2. Generate `/issues/open/index.html` with all open issues
933+3. Generate `/issues/closed/index.html` with all closed issues
934+4. Generate `/issues/label/{label}/index.html` for each label (URL-encoded)
935+5. Generate `/issues/{short-hash}.html` for each issue
936+6. Show issue counts and navigation links on list pages
937+7. Display individual issues with title, status, labels, description, and comments
938+8. Add "Issues" link to site navigation
939+
940+All pages will match the existing pgit styling and use the same template system.

  1@@ -0,0 +1,129 @@
  2+# CSS Build Pipeline Improvement - Design Document
  3+
  4+**Date:** 2026-04-08
  5+
  6+## Goal
  7+
  8+Improve the CSS build pipeline by concatenating all CSS files in the proper precedence order, minimizing the result, appending a content-based hash to the filename, and inserting the correct link in the header.
  9+
 10+## Architecture
 11+
 12+Build-time CSS processing integrated into the existing Go build flow. CSS files are concatenated in precedence order, minified using a Go library, hashed for cache-busting, and the resulting filename is passed to templates.
 13+
 14+**Tech Stack:**
 15+- Go 1.21+
 16+- `github.com/tdewolff/minify/v2` - CSS minification library
 17+- SHA256 for content hashing
 18+
 19+---
 20+
 21+## Current State
 22+
 23+**Current CSS Setup:**
 24+- `static/pgit.css` - Main stylesheet (1380 lines, ~23KB)
 25+- `vars.css` - Dynamically generated from Chroma theme colors
 26+- `syntax.css` - Dynamically generated for syntax highlighting
 27+- CSS links are hardcoded in `html/base.layout.tmpl`
 28+
 29+**Current Build Flow:**
 30+1. `copyStatic()` copies static files as-is
 31+2. `vars.css` and `syntax.css` are generated in main.go
 32+3. No minification or concatenation happens
 33+
 34+---
 35+
 36+## Design Decisions
 37+
 38+### CSS Precedence Order
 39+
 40+1. **`pgit.css`** - Base styles (default variables, layout, components)
 41+2. **`vars.css`** - Theme overrides (CSS variables from Chroma theme)  
 42+3. **`syntax.css`** - Syntax highlighting (`.chroma*` selectors)
 43+
 44+This order ensures base styles load first, theme variables override defaults, and syntax highlighting has its specific selectors applied last.
 45+
 46+### CSS Minification Library
 47+
 48+**Selected:** `github.com/tdewolff/minify/v2`
 49+
 50+**Rationale:**
 51+- Pure Go implementation (no external dependencies)
 52+- Very fast (~50-70MB/s for CSS processing)
 53+- Safe minifications (removes comments/whitespace, optimizes colors/numbers, but won't restructure rules)
 54+- Well maintained (4.1k stars, active development)
 55+- Simple API for integration
 56+- Can also handle HTML minification if needed in future
 57+
 58+**Typical compression:** 10-15% reduction for CSS files.
 59+
 60+### Build Flow
 61+
 62+**New steps in `main()`:**
 63+
 64+1. **Collect CSS content in order:**
 65+   - Read `static/pgit.css` from embedded FS
 66+   - Generate `vars.css` content (from existing `style()` function)
 67+   - Generate `syntax.css` content (from existing `formatter.WriteCSS()`)
 68+
 69+2. **Concatenate:** `pgit.css` + `vars.css` + `syntax.css`
 70+
 71+3. **Minify** using `tdewolff/minify/v2/css`
 72+
 73+4. **Generate hash** (SHA256, first 8 chars of hex encoding)
 74+
 75+5. **Write file:** `styles.{hash}.css`
 76+
 77+6. **Update Config** with the CSS filename for templates
 78+
 79+7. **Update template** `html/base.layout.tmpl` to use single CSS link
 80+
 81+### Output Structure
 82+
 83+```
 84+public/
 85+  styles.a3f7b2c1.css   # Minified, hashed bundle (replaces pgit.css, vars.css, syntax.css)
 86+  index.html            # References styles.a3f7b2c1.css
 87+  ...
 88+```
 89+
 90+---
 91+
 92+## Files to Modify
 93+
 94+1. **`main.go`** - Add CSS bundling logic
 95+   - Add `CSSFile` field to `Config` struct
 96+   - Create `bundleCSS()` function
 97+   - Call it in `main()` after theme setup, before `writeRepo()`
 98+
 99+2. **`html/base.layout.tmpl`** - Update CSS link
100+   - Replace two `<link>` tags with single `{{.Repo.CSSFile}}` reference
101+
102+3. **`go.mod`** - Add tdewolff/minify dependency
103+
104+---
105+
106+## Out of Scope
107+
108+- HTML minification (pages are already lightweight)
109+- Source maps for CSS (not needed)
110+- External CSS processing tools (keeping it pure Go)
111+- Additional CSS files (none planned)
112+
113+---
114+
115+## Success Criteria
116+
117+- [ ] All three CSS files concatenated in correct order
118+- [ ] Result is minified (smaller than sum of individual files)
119+- [ ] Filename includes content-based hash (e.g., `styles.a3f7b2c1.css`)
120+- [ ] HTML templates reference the hashed CSS file correctly
121+- [ ] Site renders identically to before (visual parity)
122+- [ ] Build completes without errors
123+
124+## Benefits
125+
126+- ✅ **Single HTTP request** for all CSS (vs. 3 separate files)
127+- ✅ **Cache-busting** via content hash in filename
128+- ✅ **Smaller file size** (~10-15% reduction from minification)
129+- ✅ **No external tools** - pure Go implementation
130+- ✅ **Deterministic** - same content = same hash

  1@@ -0,0 +1,402 @@
  2+# CSS Build Pipeline Implementation Plan
  3+
  4+> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.
  5+
  6+**Goal:** Concatenate all CSS files in proper precedence order, minimize, add content hash to filename, and update templates to reference the bundled CSS.
  7+
  8+**Architecture:** Build-time CSS processing integrated into existing Go build flow using tdewolff/minify library.
  9+
 10+**Tech Stack:** Go 1.21+, github.com/tdewolff/minify/v2, SHA256 hashing
 11+
 12+---
 13+
 14+## Task 1: Add CSS minification dependency
 15+
 16+**Files:**
 17+- Modify: `go.mod`
 18+
 19+**Step 1: Add tdewolff/minify dependency**
 20+
 21+Run: `go get github.com/tdewolff/minify/v2/css`
 22+
 23+Expected: Module added to go.mod and go.sum updated
 24+
 25+**Step 2: Commit**
 26+
 27+```bash
 28+jj commit -m "deps: add tdewolff/minify for CSS processing"
 29+```
 30+
 31+---
 32+
 33+## Task 2: Add CSSFile field to Config struct
 34+
 35+**Files:**
 36+- Modify: `main.go:39-81` (Config struct)
 37+
 38+**Step 1: Add CSSFile field**
 39+
 40+Add to Config struct after line 80:
 41+
 42+```go
 43+	// CSS bundle filename (with content hash)
 44+	CSSFile string
 45+```
 46+
 47+**Step 2: Verify struct compiles**
 48+
 49+Run: `go build -o /dev/null .`
 50+
 51+Expected: Build succeeds
 52+
 53+**Step 3: Commit**
 54+
 55+```bash
 56+jj commit -m "feat: add CSSFile field to Config struct"
 57+```
 58+
 59+---
 60+
 61+## Task 3: Create CSS bundling function
 62+
 63+**Files:**
 64+- Modify: `main.go` (add new function before main())
 65+
 66+**Step 1: Add imports for minification and hashing**
 67+
 68+Add to imports section:
 69+
 70+```go
 71+	"crypto/sha256"
 72+	"encoding/hex"
 73+
 74+	"github.com/tdewolff/minify/v2"
 75+	"github.com/tdewolff/minify/v2/css"
 76+```
 77+
 78+**Step 2: Create bundleCSS function**
 79+
 80+Add before `main()` function:
 81+
 82+```go
 83+// bundleCSS concatenates, minifies, and hashes all CSS files
 84+// Returns the filename of the bundled CSS (e.g., "styles.a3f7b2c1.css")
 85+func (c *Config) bundleCSS() (string, error) {
 86+	c.Logger.Info("bundling CSS files")
 87+
 88+	// Initialize minifier
 89+	m := minify.New()
 90+	m.AddFunc("text/css", css.Minify)
 91+
 92+	var buf bytes.Buffer
 93+
 94+	// 1. Read pgit.css from embedded static FS
 95+	pgitCSS, err := staticFS.ReadFile("static/pgit.css")
 96+	if err != nil {
 97+		return "", fmt.Errorf("failed to read pgit.css: %w", err)
 98+	}
 99+	buf.Write(pgitCSS)
100+	buf.WriteString("\n")
101+
102+	// 2. Generate vars.css content
103+	varsCSS := style(*c.Theme)
104+	buf.WriteString(varsCSS)
105+	buf.WriteString("\n")
106+
107+	// 3. Generate syntax.css content
108+	var syntaxBuf bytes.Buffer
109+	err = c.Formatter.WriteCSS(&syntaxBuf, c.Theme)
110+	if err != nil {
111+		return "", fmt.Errorf("failed to generate syntax.css: %w", err)
112+	}
113+	buf.Write(syntaxBuf.Bytes())
114+
115+	// 4. Minify the concatenated CSS
116+	minified, err := m.Bytes("text/css", buf.Bytes())
117+	if err != nil {
118+		return "", fmt.Errorf("failed to minify CSS: %w", err)
119+	}
120+
121+	// 5. Generate content hash (first 8 chars of SHA256)
122+	hash := sha256.Sum256(minified)
123+	hashStr := hex.EncodeToString(hash[:8])
124+
125+	// 6. Create filename with hash
126+	filename := fmt.Sprintf("styles.%s.css", hashStr)
127+
128+	// 7. Write to output directory
129+	outPath := filepath.Join(c.Outdir, filename)
130+	err = os.WriteFile(outPath, minified, 0644)
131+	if err != nil {
132+		return "", fmt.Errorf("failed to write CSS bundle: %w", err)
133+	}
134+
135+	c.Logger.Info("CSS bundle created", "filename", filename, "size", len(minified))
136+
137+	return filename, nil
138+}
139+```
140+
141+**Step 3: Verify function compiles**
142+
143+Run: `go build -o /dev/null .`
144+
145+Expected: Build succeeds
146+
147+**Step 4: Commit**
148+
149+```bash
150+jj commit -m "feat: add CSS bundling function"
151+```
152+
153+---
154+
155+## Task 4: Integrate CSS bundling into main build flow
156+
157+**Files:**
158+- Modify: `main.go:1349-1367` (main function end)
159+
160+**Step 1: Call bundleCSS before writeRepo**
161+
162+Locate this section in main():
163+```go
164+	config.writeRepo()
165+	err = config.copyStatic("static")
166+	bail(err)
167+```
168+
169+Replace with:
170+```go
171+	// Bundle CSS files before generating site
172+	cssFile, err := config.bundleCSS()
173+	bail(err)
174+	config.CSSFile = cssFile
175+
176+	config.writeRepo()
177+	
178+	// Note: copyStatic is no longer needed for CSS files since they're bundled
179+	// but we keep it for any other static assets
180+	err = config.copyStatic("static")
181+	bail(err)
182+```
183+
184+**Step 2: Remove old CSS generation code**
185+
186+Remove this section at the end of main():
187+```go
188+	styles := style(*theme)
189+	err = os.WriteFile(filepath.Join(out, "vars.css"), []byte(styles), 0644)
190+	if err != nil {
191+		panic(err)
192+	}
193+
194+	fp := filepath.Join(out, "syntax.css")
195+	w, err := os.OpenFile(fp, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
196+	if err != nil {
197+		bail(err)
198+	}
199+	err = formatter.WriteCSS(w, theme)
200+	if err != nil {
201+		bail(err)
202+	}
203+```
204+
205+**Step 3: Verify build succeeds**
206+
207+Run: `go build -o pgit .`
208+
209+Expected: Build succeeds
210+
211+**Step 4: Commit**
212+
213+```bash
214+jj commit -m "feat: integrate CSS bundling into build flow"
215+```
216+
217+---
218+
219+## Task 5: Update base layout template
220+
221+**Files:**
222+- Modify: `html/base.layout.tmpl:13-15`
223+
224+**Step 1: Replace CSS link tags**
225+
226+Current:
227+```html
228+    <link rel="stylesheet" href="{{.Repo.RootRelative}}pgit.css" />
229+    <link rel="stylesheet" href="{{.Repo.RootRelative}}vars.css" />
230+```
231+
232+Replace with:
233+```html
234+    <link rel="stylesheet" href="{{.Repo.RootRelative}}{{.Repo.CSSFile}}" />
235+```
236+
237+**Step 2: Verify template syntax**
238+
239+No build step for templates - will be validated at runtime
240+
241+**Step 3: Commit**
242+
243+```bash
244+jj commit -m "feat: update template to use bundled CSS"
245+```
246+
247+---
248+
249+## Task 6: Test the implementation
250+
251+**Files:**
252+- Test: Run build and verify output
253+
254+**Step 1: Build the binary**
255+
256+Run: `go build -o pgit .`
257+
258+Expected: Clean build
259+
260+**Step 2: Run test-site target**
261+
262+Run: `make test-site`
263+
264+Expected: Build completes successfully
265+
266+**Step 3: Verify CSS bundle was created**
267+
268+Run: `ls -la testdata.site/*.css`
269+
270+Expected: Single file `styles.{hash}.css` exists (no pgit.css, vars.css, syntax.css)
271+
272+**Step 4: Verify file content**
273+
274+Run: `head -5 testdata.site/styles.*.css`
275+
276+Expected: Minified CSS (no whitespace, all on few lines)
277+
278+**Step 5: Verify HTML references correct file**
279+
280+Run: `grep -o 'styles\.[a-f0-9]*\.css' testdata.site/index.html`
281+
282+Expected: Matches the filename from step 3
283+
284+**Step 6: Check file size reduction**
285+
286+Run: `wc -c static/pgit.css` and compare with bundled file
287+
288+Expected: Bundled file should be smaller than original pgit.css alone (due to minification)
289+
290+**Step 7: Commit**
291+
292+```bash
293+jj commit -m "test: verify CSS bundling works correctly"
294+```
295+
296+---
297+
298+## Task 7: Verify visual parity
299+
300+**Files:**
301+- Test: Compare rendered output
302+
303+**Step 1: Start a local server**
304+
305+Run: `cd testdata.site && python3 -m http.server 8080 &`
306+
307+**Step 2: Check a page renders correctly**
308+
309+Open browser or use curl: `curl -s http://localhost:8080/index.html | head -20`
310+
311+Expected: HTML loads, CSS is referenced correctly
312+
313+**Step 3: Verify CSS loads**
314+
315+Run: `curl -s http://localhost:8080/styles.*.css | head -5`
316+
317+Expected: Returns minified CSS content
318+
319+**Step 4: Stop test server**
320+
321+Run: `pkill -f "http.server 8080"`
322+
323+**Step 5: Commit**
324+
325+```bash
326+jj commit -m "test: verify visual parity and CSS loading"
327+```
328+
329+---
330+
331+## Task 8: Clean up (optional)
332+
333+**Files:**
334+- Modify: `main.go` (remove unused code if desired)
335+
336+**Step 1: Review if copyStatic is still needed**
337+
338+If `static/` only contained CSS files, we can remove the `copyStatic` call entirely.
339+
340+Check: `ls static/`
341+
342+If only CSS files, remove:
343+```go
344+	err = config.copyStatic("static")
345+	bail(err)
346+```
347+
348+**Step 2: Commit if changes made**
349+
350+```bash
351+jj commit -m "cleanup: remove unused copyStatic call"
352+```
353+
354+---
355+
356+## Task 9: Final verification
357+
358+**Files:**
359+- Test: Full build pipeline
360+
361+**Step 1: Clean and rebuild**
362+
363+Run:
364+```bash
365+make clean
366+make build
367+make test-site
368+```
369+
370+Expected: All steps succeed
371+
372+**Step 2: Verify final output**
373+
374+Run: `ls -la testdata.site/ | grep -E '\.(css|html)$'`
375+
376+Expected:
377+- One CSS file: `styles.{hash}.css`
378+- Multiple HTML files
379+- No `pgit.css`, `vars.css`, or `syntax.css`
380+
381+**Step 3: Final commit**
382+
383+```bash
384+jj commit -m "feat: complete CSS build pipeline improvement"
385+```
386+
387+---
388+
389+## Summary
390+
391+After completing all tasks:
392+
393+1. ✅ All three CSS files concatenated in correct order (pgit.css → vars.css → syntax.css)
394+2. ✅ Result is minified using tdewolff/minify
395+3. ✅ Filename includes 8-char content hash (e.g., `styles.a3f7b2c1.css`)
396+4. ✅ HTML templates reference the hashed CSS file via `{{.Repo.CSSFile}}`
397+5. ✅ Site renders identically to before
398+6. ✅ Build completes without errors
399+
400+**Files changed:**
401+- `go.mod` - Added tdewolff/minify dependency
402+- `main.go` - Added bundleCSS function and integrated into build flow
403+- `html/base.layout.tmpl` - Updated to use bundled CSS