prime8dev

content.go (12676B)

---

 package tui
 
 import (
 	"fmt"
 	"strconv"
 	"strings"
 
 	appconfig "git.prime8.dev/moncheeta/prime8dev/internal/config"
 	appcontent "git.prime8.dev/moncheeta/prime8dev/internal/content"
 	"github.com/charmbracelet/lipgloss"
 )
 
 func (m portfolioModel) aboutDetail() string {
 	job := "building and learning"
 	if m.currentJob != nil {
 		job = fmt.Sprintf("%s @ %s", m.currentJob.Role, m.currentJob.Company)
 	}
 
 	parts := []string{
 		renderPrompt(m.about.Handle, "whoami"),
 		m.aboutNameASCII,
 		m.about.Bio,
 		"",
 		renderPrompt(m.about.Handle, "cat info"),
 		m.infoNowTable(job),
 		"",
 		renderPrompt(m.about.Handle, "ls interests/"),
 		renderTagList(m.about.Interests),
 		"",
 		renderPrompt(m.about.Handle, "ls tools/"),
 		renderTagList(m.about.Tools),
 		"",
 		renderPrompt(m.about.Handle, "ls languages/"),
 		renderTagList(m.about.Languages),
 		"",
 		renderPrompt(m.about.Handle, "wakatime --week"),
 		m.aboutWeeklyStats(),
 	}
 
 	return strings.Join(parts, "\n")
 }
 
 func (m portfolioModel) aboutWeeklyStats() string {
 	if m.wakaWeekly == nil || len(m.wakaWeekly.Days) == 0 {
 		if m.wakaLoading || !m.wakaLoaded {
 			return dimStyle.Render("loading stats...")
 		}
 		return dimStyle.Render("stats unavailable")
 	}
 
 	barWidth := 24
 	lines := make([]string, 0, len(m.wakaWeekly.Days)+2)
 	lines = append(lines, rowStyle.Render("total: ")+infoStyle.Render(m.wakaWeekly.TotalText), "")
 
 	for _, day := range m.wakaWeekly.Days {
 		label := strings.ToLower(fitRunes(day.DayText, 3))
 		label = padRunesRight(label, 3)
 		percent := clampBarPercent(day.BarWidthPercent)
 		bar := renderASCIIBar(percent, barWidth)
 		line := dimStyle.Render(label+" ") + rowStyle.Render("|"+bar+"|") + dimStyle.Render(" "+day.TimeText)
 		lines = append(lines, line)
 	}
 
 	return strings.Join(lines, "\n")
 }
 
 func clampBarPercent(percent string) int {
 	v := strings.TrimSpace(strings.TrimSuffix(percent, "%"))
 	n, err := strconv.Atoi(v)
 	if err != nil {
 		return 0
 	}
 	if n < 0 {
 		return 0
 	}
 	if n > 100 {
 		return 100
 	}
 	return n
 }
 
 func renderASCIIBar(percent int, width int) string {
 	filled := (percent * width) / 100
 	if filled < 0 {
 		filled = 0
 	}
 	if filled > width {
 		filled = width
 	}
 	return strings.Repeat("#", filled) + strings.Repeat("-", width-filled)
 }
 
 func (m portfolioModel) infoNowTable(job string) string {
 	left := [][2]string{
 		{"location", m.about.Location},
 	}
 
 	right := [][2]string{}
 	if m.currentJob != nil {
 		right = append(right,
 			[2]string{"company", m.currentJob.Company},
 			[2]string{"position", m.currentJob.Role},
 		)
 	} else {
 		right = append(right, [2]string{"current", job})
 	}
 
 	labelLW := 10
 	labelRW := 8
 	gap := 3
 	viewW, _ := m.detailSize()
 	available := max(viewW-2, 44)
 	valueBudget := available - (labelLW + 3) - gap - (labelRW + 3)
 	if valueBudget < 20 {
 		valueBudget = 20
 	}
 	valueLW := valueBudget / 2
 	valueRW := valueBudget - valueLW
 
 	rows := max(len(left), len(right))
 	lines := make([]string, 0, rows)
 	for i := 0; i < rows; i++ {
 		lk, lv := "", ""
 		if i < len(left) {
 			lk = left[i][0]
 			lv = fitRunes(left[i][1], valueLW)
 		}
 
 		rk, rv := "", ""
 		if i < len(right) {
 			rk = right[i][0]
 			rv = fitRunes(right[i][1], valueRW)
 		}
 
 		line := renderInfoCell(lk, lv, labelLW, valueLW)
 		if rk != "" || rv != "" {
 			line += strings.Repeat(" ", gap) + renderInfoCell(rk, rv, labelRW, valueRW)
 		}
 		lines = append(lines, strings.TrimRight(line, " "))
 	}
 
 	return strings.Join(lines, "\n")
 }
 
 func renderInfoCell(key string, value string, keyWidth int, valueWidth int) string {
 	key = fitRunes(key, keyWidth)
 	value = fitRunes(value, valueWidth)
 	keyPadding := max(keyWidth-len([]rune(key)), 0)
 	keyText := key + ":" + strings.Repeat(" ", keyPadding+1)
 	valueText := fmt.Sprintf("%-*s", valueWidth, value)
 	return dimStyle.Render(keyText) + valueText
 }
 
 func (m portfolioModel) projectDetail() string {
 	if len(m.projects) == 0 {
 		return "No projects available."
 	}
 	p := m.projects[m.projectIndex]
 
 	if readme, ok := m.projectReadmes[p.ID]; ok && strings.TrimSpace(readme) != "" {
 		width := m.markdownWidth()
 		if rendered, ok := m.cachedProjectMarkdown(p.ID, width); ok && strings.TrimSpace(rendered) != "" {
 			return rendered
 		}
 
 		patched := replaceFirstH1WithSourceLink(readme, p.Name, p.URL)
 		fallback := patched
 		if tech := renderTagList(p.Tech); tech != "" {
 			fallback = insertTechRowBelowMarkdownH1(fallback, tech)
 		}
 
 		return fallback + "\n\n" + dimStyle.Render("formatting markdown...")
 	}
 
 	if m.projectReadmeLoads[p.ID] {
 		return m.projectReadmeFallback(p, infoStyle.Render("loading README..."))
 	}
 
 	if msg, ok := m.projectReadmeErrors[p.ID]; ok && msg != "" {
 		return m.projectReadmeFallback(p, dimStyle.Render("README unavailable: "+msg))
 	}
 
 	return m.projectReadmeFallback(p, infoStyle.Render("README not loaded yet."))
 }
 
 func (m portfolioModel) projectReadmeFallback(project appconfig.Project, status string) string {
 	headerMarkdown := replaceFirstH1WithSourceLink("", project.Name, project.URL)
 	header := strings.TrimSpace(renderMarkdown(headerMarkdown, m.projectMarkdownWidth()))
 	if header == "" {
 		header = titleStyle.Render(defaultProjectHeader(project.Name))
 	}
 
 	parts := []string{header}
 
 	if tech := renderTagList(project.Tech); tech != "" {
 		parts = append(parts, tech)
 	}
 
 	if strings.TrimSpace(status) != "" {
 		parts = append(parts, status)
 	}
 
 	return strings.Join(parts, "\n\n")
 }
 
 func defaultProjectHeader(name string) string {
 	name = strings.TrimSpace(name)
 	if name == "" {
 		return "Project Source"
 	}
 	return name
 }
 
 func insertTechRowBelowMarkdownH1(markdown string, techRow string) string {
 	if strings.TrimSpace(techRow) == "" {
 		return markdown
 	}
 
 	lines := strings.Split(markdown, "\n")
 	headIdx := -1
 	for i, line := range lines {
 		if strings.TrimSpace(line) != "" {
 			headIdx = i
 			break
 		}
 	}
 	if headIdx == -1 {
 		return techRow
 	}
 
 	if !strings.HasPrefix(strings.TrimSpace(lines[headIdx]), "# ") {
 		return techRow + "\n\n" + markdown
 	}
 
 	bodyStart := headIdx + 1
 	for bodyStart < len(lines) && strings.TrimSpace(lines[bodyStart]) == "" {
 		bodyStart++
 	}
 
 	header := strings.Join(lines[:headIdx+1], "\n")
 	if bodyStart >= len(lines) {
 		return header + "\n\n" + techRow
 	}
 
 	body := strings.Join(lines[bodyStart:], "\n")
 	return header + "\n\n" + techRow + "\n\n" + body
 }
 
 func replaceFirstH1WithSourceLink(markdown string, projectName string, projectURL string) string {
 	if projectName == "" {
 		projectName = "Project Source"
 	}
 
 	body := removeFirstMarkdownH1(markdown)
 
 	header := "# " + projectName
 	if strings.TrimSpace(projectURL) != "" {
 		header = "# [" + projectName + "](" + projectURL + ")"
 	}
 
 	if strings.TrimSpace(body) == "" {
 		return header
 	}
 
 	return header + "\n\n" + body
 }
 
 func removeFirstMarkdownH1(markdown string) string {
 	lines := strings.Split(markdown, "\n")
 	removed := false
 	out := make([]string, 0, len(lines))
 
 	for _, line := range lines {
 		if !removed && strings.HasPrefix(strings.TrimSpace(line), "# ") {
 			removed = true
 			continue
 		}
 		out = append(out, line)
 	}
 
 	return strings.TrimSpace(strings.Join(out, "\n"))
 }
 
 func (m portfolioModel) projectMarkdownWidth() int {
 	return m.markdownWidth()
 }
 
 func (m portfolioModel) markdownWidth() int {
 	w, _ := m.detailSize()
 	return max(w, 20)
 }
 
 func (m portfolioModel) experiencePage() string {
 	if len(m.experience) == 0 {
 		return "No experience available."
 	}
 
 	rows := []string{renderPrompt(m.about.Handle, "git log --oneline --graph --decorate")}
 	for i, e := range m.experience {
 		decorator := ""
 		if e.Current {
 			decorator = " (HEAD -> now)"
 		}
 		label := fmt.Sprintf("* %s %-20s %s%s", utilsYearLabel(e), fitRunes(e.Company, 20), fitRunes(e.Role, 22), decorator)
 		rangeLine := "    " + dateRangeLabel(e)
 		if i == m.experienceIndex {
 			rows = append(rows, selectedRowStyle.Render("> "+label))
 			rows = append(rows, selectedRowStyle.Render(rangeLine))
 			for _, d := range e.Description {
 				rows = append(rows, rowStyle.Render("    | "+d))
 			}
 			if len(e.Tech) > 0 {
 				rows = append(rows, rowStyle.Render("    | ")+dimStyle.Render("tech: ")+renderTagList(e.Tech))
 			}
 			if e.URL != "" {
 				rows = append(rows, rowStyle.Render("    | ")+dimStyle.Render("url: ")+linkStyle.Render(e.URL))
 			}
 		} else {
 			rows = append(rows, rowStyle.Render("  "+label))
 			rows = append(rows, dimStyle.Render(rangeLine))
 		}
 	}
 	return strings.Join(rows, "\n")
 }
 
 func (m portfolioModel) blogDetail() string {
 	if len(m.blogs) == 0 {
 		return "~/blog is empty"
 	}
 	b := m.blogs[m.blogIndex]
 	parts := []string{renderPrompt(m.about.Handle, "cat ~/blog/"+b.ID+".md")}
 	parts = append(parts, renderBlogFrontmatter(b)...)
 	if m.blogOpen {
 		width := m.markdownWidth()
 		if rendered, ok := m.cachedBlogMarkdown(b.ID, width); ok && rendered != "" {
 			parts = append(parts, "", rendered)
 		} else {
 			fallback := normalizeBlogMarkdown(b.Markdown, b.Description)
 			if strings.TrimSpace(fallback) != "" {
 				parts = append(parts, "", fallback, "", dimStyle.Render("formatting markdown..."))
 			} else {
 				parts = append(parts, "", infoStyle.Render("rendering markdown..."))
 			}
 		}
 	}
 	return strings.Join(parts, "\n")
 }
 
 func renderBlogFrontmatter(b appcontent.Blog) []string {
 	lines := []string{
 		renderBlogMetaLine("title", b.Title, titleStyle),
 		renderBlogMetaLine("description", b.Description, rowStyle),
 		renderBlogMetaLine("date", b.Date.Format("2006-01-02"), infoStyle),
 	}
 
 	tags := strings.TrimSpace(renderTagList(b.Tags))
 	if tags != "" {
 		lines = append(lines, dimStyle.Render(padRunesRight("tags:", 12)+" ")+tags)
 	}
 
 	return lines
 }
 
 func renderBlogMetaLine(label string, value string, valueStyle lipgloss.Style) string {
 	key := dimStyle.Render(padRunesRight(label+":", 12) + " ")
 	return key + valueStyle.Render(value)
 }
 
 func normalizeBlogMarkdown(markdown string, description string) string {
 	lines := strings.Split(markdown, "\n")
 	for i := range lines {
 		trimmed := strings.TrimSpace(lines[i])
 		if trimmed == "" {
 			continue
 		}
 
 		if strings.EqualFold(trimmed, strings.TrimSpace(description)) {
 			lines[i] = "# " + trimmed
 		}
 		break
 	}
 
 	return strings.Join(lines, "\n")
 }
 
 func (m portfolioModel) blogMarkdownWidth() int {
 	return m.markdownWidth()
 }
 
 func (m portfolioModel) blogPage() string {
 	if len(m.blogs) == 0 {
 		return "~/blog is empty"
 	}
 
 	if m.blogOpen {
 		return m.blogDetail()
 	}
 
 	modeW, dateW, nameW, descW := m.blogTableWidths()
 	markerW := 2
 	header := blogHeaderLine(markerW, modeW, dateW, nameW, descW)
 
 	rows := []string{
 		renderPrompt(m.about.Handle, "ls -l ~/blog"),
 		header,
 	}
 	for i, b := range m.blogs {
 		rows = append(rows, blogDataLine(i == m.blogIndex, b, markerW, modeW, dateW, nameW, descW))
 	}
 
 	return strings.Join(rows, "\n")
 }
 
 func (m portfolioModel) blogTableWidths() (int, int, int, int) {
 	viewW, _ := m.detailSize()
 	available := max(viewW-5, 24)
 
 	modeW := 10
 	dateW := 10
 	remaining := available - modeW - dateW - 3
 	if remaining < 14 {
 		nameW := max(4, remaining/2)
 		descW := max(4, remaining-nameW)
 		return modeW, dateW, nameW, descW
 	}
 
 	nameW := min(40, max(12, remaining/2))
 	descW := max(8, remaining-nameW)
 
 	maxName := 0
 	maxDesc := 0
 	for _, b := range m.blogs {
 		nameLen := len([]rune(b.ID + ".md"))
 		descLen := len([]rune(b.Description))
 		if nameLen > maxName {
 			maxName = nameLen
 		}
 		if descLen > maxDesc {
 			maxDesc = descLen
 		}
 	}
 
 	if maxName > 0 && maxName < nameW {
 		spare := nameW - maxName
 		nameW = maxName
 		descW += spare
 	}
 	if maxDesc > 0 && maxDesc < descW {
 		descW = maxDesc
 	}
 
 	return modeW, dateW, max(nameW, 8), max(descW, 8)
 }
 
 func blogHeaderLine(markerW int, modeW int, dateW int, nameW int, descW int) string {
 	marker := lipgloss.NewStyle().Width(markerW).Render("")
 	mode := dimStyle.Width(modeW).Render("mode")
 	date := dimStyle.Width(dateW).Render("date")
 	name := dimStyle.Width(nameW).Render("name")
 	desc := dimStyle.Width(descW).Render("desc")
 	return lipgloss.JoinHorizontal(lipgloss.Top, marker, mode, " ", date, " ", name, " ", desc)
 }
 
 func blogDataLine(selected bool, b appcontent.Blog, markerW int, modeW int, dateW int, nameW int, descW int) string {
 	marker := ""
 	if selected {
 		marker = ">"
 	}
 
 	markerCol := rowStyle.Width(markerW).Render(marker)
 	if selected {
 		markerCol = selectedRowStyle.Width(markerW).Render(marker)
 	}
 	modeCol := blogModeStyle.Width(modeW).Render("-rw-r--r--")
 	dateCol := dimStyle.Width(dateW).Render(b.Date.Format("2006-01-02"))
 	nameCol := blogNameStyle.Width(nameW).Render(fitRunes(b.ID+".md", nameW))
 	descCol := dimStyle.Width(descW).Render(fitRunes(b.Description, max(descW, 4)))
 
 	return lipgloss.JoinHorizontal(lipgloss.Top, markerCol, modeCol, " ", dateCol, " ", nameCol, " ", descCol)
 }