golangLAKEHOUSE/cmd/audit_full/main.go

// audit_full — Go-side audit-full runner. Calls into
// internal/distillation.RunAuditFull, dumps the Markdown report to
// stdout (or a file), and optionally appends an AuditBaseline entry
// to data/_kb/audit_baselines.jsonl for the longitudinal log.
//
// Usage:
//   audit_full                                      # report only
//   audit_full -root /home/profit/lakehouse         # custom root
//   audit_full -append-baseline                     # also append to audit_baselines.jsonl
//   audit_full -out reports/distillation/run.md     # write report file
//
// Designed to live alongside the Rust scripts/distillation/audit_full.ts
// — operators can run either runtime against the same root and the
// audit_baselines.jsonl entries are interchangeable.
package main

import (
	"encoding/json"
	"flag"
	"fmt"
	"log"
	"os"
	"os/exec"
	"strings"
	"time"

	"git.agentview.dev/profit/golangLAKEHOUSE/internal/distillation"
)

func main() {
	root := flag.String("root", "", "lakehouse data root (defaults to $LH_DISTILL_ROOT or /home/profit/lakehouse)")
	out := flag.String("out", "", "write Markdown report to this path (default: stdout)")
	appendBaseline := flag.Bool("append-baseline", false, "append an AuditBaseline entry to data/_kb/audit_baselines.jsonl after the run")
	jsonOut := flag.Bool("json", false, "emit the full PhaseCheckReport as JSON instead of Markdown")
	flag.Parse()

	gitHEAD := resolveGitHEAD()
	report := distillation.RunAuditFull(distillation.AuditFullOptions{
		Root:    *root,
		GitHEAD: gitHEAD,
	})

	var body []byte
	if *jsonOut {
		body = mustJSON(report)
	} else {
		body = []byte(distillation.FormatAuditFullReport(report))
	}

	if *out == "" {
		_, _ = os.Stdout.Write(body)
	} else {
		if err := os.WriteFile(*out, body, 0o644); err != nil {
			log.Fatalf("write %s: %v", *out, err)
		}
		fmt.Fprintf(os.Stderr, "wrote %s (%d bytes)\n", *out, len(body))
	}

	if *appendBaseline {
		// Resolve the same path the Rust pipeline uses so both
		// runtimes share the audit_baselines.jsonl log.
		resolvedRoot := *root
		if resolvedRoot == "" {
			if env := os.Getenv("LH_DISTILL_ROOT"); env != "" {
				resolvedRoot = env
			} else {
				resolvedRoot = "/home/profit/lakehouse"
			}
		}
		bp := distillation.DefaultBaselinePath(resolvedRoot)
		err := distillation.AppendBaseline(bp, distillation.AuditBaseline{
			RecordedAt: time.Now().UTC().Format(time.RFC3339),
			GitCommit:  gitHEAD,
			Metrics:    report.Metrics,
		})
		if err != nil {
			log.Fatalf("append baseline: %v", err)
		}
		fmt.Fprintf(os.Stderr, "appended baseline to %s\n", bp)
	}

	if report.Failed > 0 {
		os.Exit(1)
	}
}

// resolveGitHEAD returns the current commit SHA if the Go repo is a
// git checkout. Falls back to "" rather than failing — the audit
// runs even on a fresh clone without git.
func resolveGitHEAD() string {
	cmd := exec.Command("git", "rev-parse", "HEAD")
	bs, err := cmd.Output()
	if err != nil {
		return ""
	}
	return strings.TrimSpace(string(bs))
}

func mustJSON(v any) []byte {
	bs, err := json.MarshalIndent(v, "", "  ")
	if err != nil {
		log.Fatalf("json marshal: %v", err)
	}
	return append(bs, '\n')
}