540 lines
15 KiB
Go
540 lines
15 KiB
Go
package clusterlog
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
const siteStateVersion = 2
|
|
|
|
func loadReviewLog(root string) (ReviewLog, error) {
|
|
log := ReviewLog{Version: 1, Events: []ReviewEvent{}}
|
|
files, err := reviewEventFiles(root)
|
|
if err != nil {
|
|
return log, err
|
|
}
|
|
for _, path := range files {
|
|
var event ReviewEvent
|
|
if err := loadJSON(path, &event); err != nil {
|
|
return log, err
|
|
}
|
|
log.Events = append(log.Events, event)
|
|
}
|
|
sortReviewEvents(log.Events)
|
|
return log, nil
|
|
}
|
|
|
|
func loadTaskLog(root string) (TaskLog, error) {
|
|
log := TaskLog{Version: 1, Events: []TaskEvent{}}
|
|
files, err := taskEventFiles(root)
|
|
if err != nil {
|
|
return log, err
|
|
}
|
|
for _, path := range files {
|
|
var event TaskEvent
|
|
if err := loadJSON(path, &event); err != nil {
|
|
return log, err
|
|
}
|
|
log.Events = append(log.Events, event)
|
|
}
|
|
sortTaskEvents(log.Events)
|
|
return log, nil
|
|
}
|
|
|
|
func requiredReviewers(registry AdminRegistry, policy, authorID string) []string {
|
|
policy = firstNonEmpty(policy, registry.ReviewPolicy.Default)
|
|
required := activeAdminIDs(registry)
|
|
excludeAuthor := policy == "all-active-except-author" ||
|
|
(policy == "all-active" && !registry.ReviewPolicy.IncludeAuthor)
|
|
if !excludeAuthor || authorID == "" {
|
|
return required
|
|
}
|
|
filtered := make([]string, 0, len(required))
|
|
for _, id := range required {
|
|
if id != authorID {
|
|
filtered = append(filtered, id)
|
|
}
|
|
}
|
|
return filtered
|
|
}
|
|
|
|
func (a *App) BuildState(root string) (SiteState, error) {
|
|
registry, err := loadAdmins(root)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
reviews, err := loadReviewLog(root)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
tasksLog, err := loadTaskLog(root)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
|
|
memoryFiles, err := listMarkdownFiles(root, "memorias")
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
taskFiles, err := listMarkdownFiles(root, "tareas")
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
projectFiles, err := listMarkdownFiles(root, "proyectos")
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
|
|
reviewFiles, err := reviewEventFiles(root)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
taskEventPaths, err := taskEventFiles(root)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
sourcePaths := []string{filepath.Join(root, "data", "admins.json")}
|
|
sourcePaths = append(sourcePaths, reviewFiles...)
|
|
sourcePaths = append(sourcePaths, taskEventPaths...)
|
|
sourcePaths = append(sourcePaths, memoryFiles...)
|
|
sourcePaths = append(sourcePaths, taskFiles...)
|
|
sourcePaths = append(sourcePaths, projectFiles...)
|
|
digest, err := sourceDigest(sourcePaths)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
|
|
memories := make([]MemoryRecord, 0, len(memoryFiles))
|
|
for _, path := range memoryFiles {
|
|
meta, err := parseMarkdown(path)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
id := normalizeID(meta.ExtraString("id"))
|
|
if id == "" {
|
|
continue
|
|
}
|
|
rel, _ := filepath.Rel(root, path)
|
|
record := MemoryRecord{
|
|
EntryID: id,
|
|
Title: meta.String("title"),
|
|
Description: meta.String("description"),
|
|
Date: meta.String("date"),
|
|
AuthorID: meta.ExtraString("author_id"),
|
|
AuthorFingerprint: meta.ExtraString("author_fingerprint"),
|
|
Risk: firstNonEmpty(meta.ExtraString("risk"), "low"),
|
|
Ticket: meta.ExtraString("ticket"),
|
|
ReviewRequired: meta.ExtraBool("review_required"),
|
|
ReviewPolicy: meta.ExtraString("review_policy"),
|
|
ReviewerSnapshot: meta.ExtraBool("reviewer_snapshot"),
|
|
Reviewers: uniqueSorted(meta.ExtraStrings("reviewers")),
|
|
Tags: uniqueSorted(meta.Taxonomies["tags"]),
|
|
Systems: uniqueSorted(meta.Taxonomies["systems"]),
|
|
Slug: pageSlug(meta),
|
|
SourcePath: filepath.ToSlash(rel),
|
|
ContentSHA256: meta.ContentHash,
|
|
}
|
|
record.Permalink = "/memorias/" + record.Slug + "/"
|
|
if record.ReviewPolicy == "" {
|
|
record.ReviewPolicy = registry.ReviewPolicy.Default
|
|
}
|
|
memories = append(memories, record)
|
|
}
|
|
sort.Slice(memories, func(i, j int) bool {
|
|
if memories[i].Date == memories[j].Date {
|
|
return memories[i].EntryID > memories[j].EntryID
|
|
}
|
|
return memories[i].Date > memories[j].Date
|
|
})
|
|
|
|
activeIDs := activeAdminIDs(registry)
|
|
queue := []ReviewQueueItem{}
|
|
for _, memory := range memories {
|
|
if !memory.ReviewRequired {
|
|
continue
|
|
}
|
|
var required []string
|
|
if memory.ReviewerSnapshot {
|
|
required = append([]string(nil), memory.Reviewers...)
|
|
} else {
|
|
required = requiredReviewers(registry, memory.ReviewPolicy, memory.AuthorID)
|
|
}
|
|
|
|
reviewedSet := map[string]bool{}
|
|
for _, event := range reviews.Events {
|
|
if normalizeID(event.EntryID) != memory.EntryID || event.ContentSHA256 != memory.ContentSHA256 {
|
|
continue
|
|
}
|
|
if contains(required, event.AdminID) {
|
|
reviewedSet[event.AdminID] = true
|
|
}
|
|
}
|
|
reviewed := []string{}
|
|
missing := []string{}
|
|
for _, id := range required {
|
|
if reviewedSet[id] {
|
|
reviewed = append(reviewed, id)
|
|
} else {
|
|
missing = append(missing, id)
|
|
}
|
|
}
|
|
item := ReviewQueueItem{
|
|
EntryID: memory.EntryID, Title: memory.Title, Description: memory.Description,
|
|
Date: memory.Date, AuthorID: memory.AuthorID, Risk: memory.Risk,
|
|
Tags: memory.Tags, Systems: memory.Systems, Permalink: memory.Permalink,
|
|
ContentSHA256: memory.ContentSHA256, ReviewedBy: reviewed,
|
|
MissingReviewers: missing, RequiredCount: len(required), ReviewedCount: len(reviewed),
|
|
}
|
|
if !memory.ReviewerSnapshot && len(activeIDs) == 0 {
|
|
item.ConfigurationError = "No hay administradores activos; registre al menos uno antes de cerrar revisiones."
|
|
}
|
|
if item.ConfigurationError != "" || len(missing) > 0 {
|
|
queue = append(queue, item)
|
|
}
|
|
}
|
|
|
|
taskStates := make([]TaskState, 0, len(taskFiles))
|
|
taskIndex := map[string]int{}
|
|
for _, path := range taskFiles {
|
|
meta, err := parseMarkdown(path)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
id := normalizeID(meta.ExtraString("id"))
|
|
if id == "" {
|
|
continue
|
|
}
|
|
rel, _ := filepath.Rel(root, path)
|
|
state := TaskState{
|
|
TaskID: id,
|
|
RunningBy: []string{},
|
|
Title: meta.String("title"),
|
|
Description: meta.String("description"),
|
|
Status: firstNonEmpty(meta.ExtraString("status"), "todo"),
|
|
Priority: firstNonEmpty(meta.ExtraString("priority"), "medium"),
|
|
ProjectID: normalizeID(meta.ExtraString("project_id")),
|
|
Assignees: uniqueSorted(meta.ExtraStrings("assignees")),
|
|
EstimateMinutes: meta.ExtraInt("estimate_minutes"),
|
|
Due: meta.ExtraString("due"),
|
|
Slug: pageSlug(meta),
|
|
SourcePath: filepath.ToSlash(rel),
|
|
}
|
|
state.Permalink = "/tareas/" + state.Slug + "/"
|
|
taskIndex[id] = len(taskStates)
|
|
taskStates = append(taskStates, state)
|
|
}
|
|
running := map[string]map[string]bool{}
|
|
for _, event := range tasksLog.Events {
|
|
id := normalizeID(event.TaskID)
|
|
idx, ok := taskIndex[id]
|
|
if !ok {
|
|
continue
|
|
}
|
|
state := &taskStates[idx]
|
|
actor := event.AdminID
|
|
switch event.Type {
|
|
case "start":
|
|
if running[id] == nil {
|
|
running[id] = map[string]bool{}
|
|
}
|
|
running[id][actor] = true
|
|
if state.Status == "todo" || state.Status == "backlog" {
|
|
state.Status = "in_progress"
|
|
}
|
|
case "stop":
|
|
state.ActualMinutes += event.Minutes
|
|
if running[id] != nil {
|
|
delete(running[id], actor)
|
|
}
|
|
case "adjust":
|
|
state.ActualMinutes += event.Minutes
|
|
case "status":
|
|
if event.Status != "" {
|
|
state.Status = event.Status
|
|
}
|
|
}
|
|
}
|
|
for id, actors := range running {
|
|
idx, ok := taskIndex[id]
|
|
if !ok {
|
|
continue
|
|
}
|
|
for actor, isRunning := range actors {
|
|
if isRunning {
|
|
taskStates[idx].RunningBy = append(taskStates[idx].RunningBy, actor)
|
|
}
|
|
}
|
|
sort.Strings(taskStates[idx].RunningBy)
|
|
}
|
|
sort.Slice(taskStates, func(i, j int) bool {
|
|
order := map[string]int{"in_progress": 0, "blocked": 1, "todo": 2, "backlog": 3, "done": 4, "cancelled": 5}
|
|
oi, ok := order[taskStates[i].Status]
|
|
if !ok {
|
|
oi = 9
|
|
}
|
|
oj, ok := order[taskStates[j].Status]
|
|
if !ok {
|
|
oj = 9
|
|
}
|
|
if oi == oj {
|
|
if taskStates[i].Due == taskStates[j].Due {
|
|
return taskStates[i].TaskID < taskStates[j].TaskID
|
|
}
|
|
if taskStates[i].Due == "" {
|
|
return false
|
|
}
|
|
if taskStates[j].Due == "" {
|
|
return true
|
|
}
|
|
return taskStates[i].Due < taskStates[j].Due
|
|
}
|
|
return oi < oj
|
|
})
|
|
|
|
projects := make([]ProjectState, 0, len(projectFiles))
|
|
for _, path := range projectFiles {
|
|
meta, err := parseMarkdown(path)
|
|
if err != nil {
|
|
return SiteState{}, err
|
|
}
|
|
id := normalizeID(meta.ExtraString("id"))
|
|
if id == "" {
|
|
continue
|
|
}
|
|
rel, _ := filepath.Rel(root, path)
|
|
project := ProjectState{
|
|
ProjectID: id,
|
|
Title: meta.String("title"),
|
|
Description: meta.String("description"),
|
|
Status: firstNonEmpty(meta.ExtraString("status"), "planned"),
|
|
Owners: uniqueSorted(meta.ExtraStrings("owners")),
|
|
TargetDate: meta.ExtraString("target_date"),
|
|
Slug: pageSlug(meta),
|
|
SourcePath: filepath.ToSlash(rel),
|
|
}
|
|
project.Permalink = "/proyectos/" + project.Slug + "/"
|
|
projects = append(projects, project)
|
|
}
|
|
sort.Slice(projects, func(i, j int) bool {
|
|
return projects[i].ProjectID < projects[j].ProjectID
|
|
})
|
|
|
|
openTasks := 0
|
|
for _, task := range taskStates {
|
|
if task.Status != "done" && task.Status != "cancelled" {
|
|
openTasks++
|
|
}
|
|
}
|
|
activeProjects := 0
|
|
for _, project := range projects {
|
|
switch project.Status {
|
|
case "done", "completed", "cancelled", "archived":
|
|
default:
|
|
activeProjects++
|
|
}
|
|
}
|
|
recent := memories
|
|
if len(recent) > 30 {
|
|
recent = recent[:30]
|
|
}
|
|
return SiteState{
|
|
Version: siteStateVersion,
|
|
SourceSHA256: digest,
|
|
Stats: SiteStats{
|
|
ActiveAdmins: len(activeIDs), PendingReviews: len(queue),
|
|
OpenTasks: openTasks, ActiveProjects: activeProjects,
|
|
},
|
|
ReviewQueue: queue,
|
|
RecentMemories: recent,
|
|
Tasks: taskStates,
|
|
Projects: projects,
|
|
}, nil
|
|
}
|
|
|
|
func (a *App) Sync(root string, check bool) (SiteState, bool, string, error) {
|
|
state, err := a.BuildState(root)
|
|
if err != nil {
|
|
return SiteState{}, false, "", err
|
|
}
|
|
path := filepath.Join(root, "data", "generated", "site_state.json")
|
|
var old SiteState
|
|
oldErr := loadJSON(path, &old)
|
|
upToDate := oldErr == nil && old.Version == state.Version && old.SourceSHA256 == state.SourceSHA256
|
|
if check {
|
|
if !upToDate {
|
|
return state, false, path, NewError(ExitValidation, "generated_state_stale",
|
|
"data/generated/site_state.json no corresponde a las fuentes actuales", map[string]any{
|
|
"expected_source_sha256": state.SourceSHA256,
|
|
"actual_source_sha256": old.SourceSHA256,
|
|
"hint": "ejecute clusterlog sync",
|
|
})
|
|
}
|
|
return old, false, path, nil
|
|
}
|
|
if upToDate {
|
|
return old, false, path, nil
|
|
}
|
|
state.GeneratedAt = a.Options.Now().UTC().Format("2006-01-02T15:04:05Z")
|
|
if a.Options.DryRun {
|
|
return state, true, path, nil
|
|
}
|
|
if err := writeJSONAtomic(path, state); err != nil {
|
|
return SiteState{}, false, path, err
|
|
}
|
|
return state, true, path, nil
|
|
}
|
|
|
|
func findMemory(root, id string) (MemoryRecord, PageMeta, error) {
|
|
id = normalizeID(id)
|
|
files, err := listMarkdownFiles(root, "memorias")
|
|
if err != nil {
|
|
return MemoryRecord{}, PageMeta{}, err
|
|
}
|
|
for _, path := range files {
|
|
meta, err := parseMarkdown(path)
|
|
if err != nil {
|
|
return MemoryRecord{}, PageMeta{}, err
|
|
}
|
|
if normalizeID(meta.ExtraString("id")) == id {
|
|
rel, _ := filepath.Rel(root, path)
|
|
record := MemoryRecord{
|
|
EntryID: id,
|
|
Title: meta.String("title"), Description: meta.String("description"),
|
|
Date: meta.String("date"), AuthorID: meta.ExtraString("author_id"),
|
|
AuthorFingerprint: meta.ExtraString("author_fingerprint"), Risk: meta.ExtraString("risk"),
|
|
ReviewRequired: meta.ExtraBool("review_required"), ReviewPolicy: meta.ExtraString("review_policy"),
|
|
ReviewerSnapshot: meta.ExtraBool("reviewer_snapshot"), Reviewers: uniqueSorted(meta.ExtraStrings("reviewers")),
|
|
Tags: meta.Taxonomies["tags"], Systems: meta.Taxonomies["systems"],
|
|
Slug: pageSlug(meta), SourcePath: filepath.ToSlash(rel), ContentSHA256: meta.ContentHash,
|
|
}
|
|
record.Permalink = "/memorias/" + record.Slug + "/"
|
|
return record, meta, nil
|
|
}
|
|
}
|
|
return MemoryRecord{}, PageMeta{}, NewError(ExitUsage, "memory_not_found", "no existe la memoria indicada", id)
|
|
}
|
|
|
|
func findTask(root, id string) (TaskState, PageMeta, error) {
|
|
id = normalizeID(id)
|
|
files, err := listMarkdownFiles(root, "tareas")
|
|
if err != nil {
|
|
return TaskState{}, PageMeta{}, err
|
|
}
|
|
for _, path := range files {
|
|
meta, err := parseMarkdown(path)
|
|
if err != nil {
|
|
return TaskState{}, PageMeta{}, err
|
|
}
|
|
if normalizeID(meta.ExtraString("id")) == id {
|
|
rel, _ := filepath.Rel(root, path)
|
|
state := TaskState{
|
|
TaskID: id, Title: meta.String("title"), Description: meta.String("description"),
|
|
Status: firstNonEmpty(meta.ExtraString("status"), "todo"), Priority: meta.ExtraString("priority"),
|
|
ProjectID: normalizeID(meta.ExtraString("project_id")), Assignees: meta.ExtraStrings("assignees"),
|
|
EstimateMinutes: meta.ExtraInt("estimate_minutes"), Due: meta.ExtraString("due"),
|
|
Slug: pageSlug(meta), SourcePath: filepath.ToSlash(rel),
|
|
}
|
|
state.Permalink = "/tareas/" + state.Slug + "/"
|
|
return state, meta, nil
|
|
}
|
|
}
|
|
return TaskState{}, PageMeta{}, NewError(ExitUsage, "task_not_found", "no existe la tarea indicada", id)
|
|
}
|
|
|
|
func taskActiveStart(log TaskLog, adminID string) (TaskEvent, bool) {
|
|
active := map[string]TaskEvent{}
|
|
for _, event := range log.Events {
|
|
if event.AdminID != adminID {
|
|
continue
|
|
}
|
|
id := normalizeID(event.TaskID)
|
|
switch event.Type {
|
|
case "start":
|
|
active[id] = event
|
|
case "stop":
|
|
delete(active, id)
|
|
}
|
|
}
|
|
if len(active) == 0 {
|
|
return TaskEvent{}, false
|
|
}
|
|
keys := make([]string, 0, len(active))
|
|
for id := range active {
|
|
keys = append(keys, id)
|
|
}
|
|
sort.Strings(keys)
|
|
return active[keys[0]], true
|
|
}
|
|
|
|
func taskIsRunning(log TaskLog, taskID, adminID string) (TaskEvent, bool) {
|
|
taskID = normalizeID(taskID)
|
|
var current TaskEvent
|
|
running := false
|
|
for _, event := range log.Events {
|
|
if normalizeID(event.TaskID) != taskID || event.AdminID != adminID {
|
|
continue
|
|
}
|
|
switch event.Type {
|
|
case "start":
|
|
current = event
|
|
running = true
|
|
case "stop":
|
|
running = false
|
|
}
|
|
}
|
|
return current, running
|
|
}
|
|
|
|
func ensureProjectExists(root, id string) error {
|
|
if strings.TrimSpace(id) == "" {
|
|
return nil
|
|
}
|
|
id = normalizeID(id)
|
|
files, err := listMarkdownFiles(root, "proyectos")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, path := range files {
|
|
meta, err := parseMarkdown(path)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if normalizeID(meta.ExtraString("id")) == id {
|
|
return nil
|
|
}
|
|
}
|
|
return NewError(ExitValidation, "project_not_found", "la tarea referencia un proyecto inexistente", id)
|
|
}
|
|
|
|
func generatedStateExists(root string) bool {
|
|
_, err := os.Stat(filepath.Join(root, "data", "generated", "site_state.json"))
|
|
return err == nil
|
|
}
|
|
|
|
func statusIsClosed(status string) bool {
|
|
switch strings.ToLower(status) {
|
|
case "done", "completed", "cancelled", "archived":
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func pageIDDuplicates(records []string) []string {
|
|
counts := map[string]int{}
|
|
for _, id := range records {
|
|
counts[id]++
|
|
}
|
|
out := []string{}
|
|
for id, count := range counts {
|
|
if id != "" && count > 1 {
|
|
out = append(out, fmt.Sprintf("%s (%d)", id, count))
|
|
}
|
|
}
|
|
sort.Strings(out)
|
|
return out
|
|
}
|