audita/internal/core/diagnostics/run_dir.go

package diagnostics

import (
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"time"

	"gitea.maximumdirect.net/eric/audita/internal/core/chunking"
	"gitea.maximumdirect.net/eric/audita/internal/core/normalization"
	"gitea.maximumdirect.net/eric/audita/internal/core/reporting"
	"gitea.maximumdirect.net/eric/audita/internal/core/schema"
)

// RunDirectory represents a per-run diagnostics directory
type RunDirectory struct {
	path      string
	retention string
	createdAt time.Time
}

// NewRunDirectory creates a new run directory under the configured work dir
func NewRunDirectory(workDir, retention string) (*RunDirectory, error) {
	if workDir == "" {
		workDir = ".audita-runs"
	}

	// Create work directory if it doesn't exist
	if err := os.MkdirAll(workDir, 0o755); err != nil {
		return nil, fmt.Errorf("failed to create work directory %q: %w", workDir, err)
	}

	// Create a unique run directory identifier.
	runID := fmt.Sprintf("run-%d", time.Now().UTC().UnixNano())
	runPath := filepath.Join(workDir, runID)

	if err := os.Mkdir(runPath, 0o755); err != nil {
		return nil, fmt.Errorf("failed to create run directory %q: %w", runPath, err)
	}

	return &RunDirectory{
		path:      runPath,
		retention: retention,
		createdAt: time.Now().UTC(),
	}, nil
}

// Path returns the run directory path
func (r *RunDirectory) Path() string {
	return r.path
}

// WriteSourceTranscript writes the source transcript artifact
func (r *RunDirectory) WriteSourceTranscript(transcript *schema.SourceTranscript, raw []byte) error {
	// Write raw source for reference
	sourcePath := filepath.Join(r.path, "source-transcript.json")
	if err := os.WriteFile(sourcePath, raw, 0o644); err != nil {
		return fmt.Errorf("failed to write source transcript: %w", err)
	}

	// Write parsed source for debugging
	parsedPath := filepath.Join(r.path, "source-transcript-parsed.json")
	parsedBytes, err := json.MarshalIndent(transcript, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal parsed source transcript: %w", err)
	}
	parsedBytes = append(parsedBytes, '\n')
	if err := os.WriteFile(parsedPath, parsedBytes, 0o644); err != nil {
		return fmt.Errorf("failed to write parsed source transcript: %w", err)
	}

	return nil
}

// WriteNormalizedTranscript writes the normalized transcript artifact
func (r *RunDirectory) WriteNormalizedTranscript(transcript *schema.Transcript) error {
	normalizedPath := filepath.Join(r.path, "normalized-transcript.json")
	bytes, err := schema.TranscriptToJSON(transcript)
	if err != nil {
		return fmt.Errorf("failed to serialize normalized transcript: %w", err)
	}
	if err := os.WriteFile(normalizedPath, bytes, 0o644); err != nil {
		return fmt.Errorf("failed to write normalized transcript: %w", err)
	}
	return nil
}

// WriteNormalizationSummary writes the normalization summary artifact
func (r *RunDirectory) WriteNormalizationSummary(summary *normalization.NormalizationSummary) error {
	summaryPath := filepath.Join(r.path, "normalization-summary.json")
	bytes, err := json.MarshalIndent(summary, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal normalization summary: %w", err)
	}
	bytes = append(bytes, '\n')
	if err := os.WriteFile(summaryPath, bytes, 0o644); err != nil {
		return fmt.Errorf("failed to write normalization summary: %w", err)
	}
	return nil
}

// WriteReport writes the authoritative report artifact
func (r *RunDirectory) WriteReport(report reporting.ProcessReport) error {
	reportPath := filepath.Join(r.path, "report.json")
	bytes, err := json.MarshalIndent(report, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal report: %w", err)
	}
	bytes = append(bytes, '\n')
	if err := os.WriteFile(reportPath, bytes, 0o644); err != nil {
		return fmt.Errorf("failed to write report: %w", err)
	}
	return nil
}

// WriteErrorLog writes an error log on failure
func (r *RunDirectory) WriteErrorLog(errorMessage string) error {
	errorPath := filepath.Join(r.path, "error.log")
	return os.WriteFile(errorPath, []byte(errorMessage+"\n"), 0o644)
}

// WriteChunkingSummary writes the chunking summary artifact
func (r *RunDirectory) WriteChunkingSummary(summary *chunking.DetailedSummary) error {
	summaryPath := filepath.Join(r.path, "chunking-summary.json")
	bytes, err := json.MarshalIndent(summary, "", "  ")
	if err != nil {
		return fmt.Errorf("failed to marshal chunking summary: %w", err)
	}
	bytes = append(bytes, '\n')
	if err := os.WriteFile(summaryPath, bytes, 0o644); err != nil {
		return fmt.Errorf("failed to write chunking summary: %w", err)
	}
	return nil
}

// TODO: In later phases, implement full "auto" semantics based on skip/report outcomes.
func (r *RunDirectory) ApplyRetention(runSucceeded bool) error {
	if !runSucceeded {
		// Failed runs are always retained.
		return nil
	}

	switch r.retention {
	case "always":
		return nil
	case "never", "auto":
		return os.RemoveAll(r.path)
	default:
		// Retain by default for unknown modes; config validation should prevent this.
		return nil
	}
}