206 lines
7.0 KiB
Go
206 lines
7.0 KiB
Go
package diagnostics
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.maximumdirect.net/eric/audita/v3/internal/core/chunking"
|
|
"gitea.maximumdirect.net/eric/audita/v3/internal/core/normalization"
|
|
"gitea.maximumdirect.net/eric/audita/v3/internal/core/redaction"
|
|
"gitea.maximumdirect.net/eric/audita/v3/internal/core/schema"
|
|
)
|
|
|
|
// RunDirectory represents a per-run diagnostics directory
|
|
type RunDirectory struct {
|
|
redactor redaction.Redactor
|
|
path string
|
|
createdAt time.Time
|
|
}
|
|
|
|
// InvocationMetadata captures non-secret invocation details for diagnostics.
|
|
type InvocationMetadata struct {
|
|
Operation string `json:"operation"`
|
|
TranscriptPath string `json:"transcript_path"`
|
|
GlossaryPath string `json:"glossary_path"`
|
|
OutputPath string `json:"output_path,omitempty"`
|
|
ConfigPath string `json:"config_path,omitempty"`
|
|
ConfigSource string `json:"config_source,omitempty"`
|
|
Overlay string `json:"overlay,omitempty"`
|
|
ConfigVersion *int `json:"config_version,omitempty"`
|
|
TranscriptDescription string `json:"transcript_description,omitempty"`
|
|
Modules []string `json:"modules"`
|
|
RunID string `json:"run_id"`
|
|
StartedAt time.Time `json:"started_at"`
|
|
}
|
|
|
|
// NewRunDirectory creates a new run directory under the configured work dir
|
|
func NewRunDirectory(workDir, runID string, secrets ...string) (*RunDirectory, error) {
|
|
if strings.TrimSpace(workDir) == "" {
|
|
return nil, fmt.Errorf("debug work directory is required")
|
|
}
|
|
if strings.TrimSpace(runID) == "" || filepath.Base(runID) != runID || runID == "." || runID == ".." {
|
|
return nil, fmt.Errorf("valid run ID is required")
|
|
}
|
|
|
|
// 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)
|
|
}
|
|
|
|
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,
|
|
redactor: redaction.New(secrets),
|
|
createdAt: time.Now().UTC(),
|
|
}, nil
|
|
}
|
|
|
|
// Path returns the run directory path
|
|
func (r *RunDirectory) Path() string {
|
|
return r.path
|
|
}
|
|
|
|
func (r *RunDirectory) runID() string {
|
|
return filepath.Base(r.path)
|
|
}
|
|
|
|
// WriteInvocationMetadata writes invocation metadata for this run.
|
|
func (r *RunDirectory) WriteInvocationMetadata(metadata InvocationMetadata) error {
|
|
if metadata.RunID == "" {
|
|
metadata.RunID = r.runID()
|
|
}
|
|
if metadata.StartedAt.IsZero() {
|
|
metadata.StartedAt = r.createdAt
|
|
}
|
|
|
|
path := filepath.Join(r.path, ArtifactInvocationMetadata)
|
|
bytes, err := r.redactor.JSON(metadata)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to marshal invocation metadata: %w", err)
|
|
}
|
|
bytes = append(bytes, '\n')
|
|
if err := os.WriteFile(path, bytes, 0o644); err != nil {
|
|
return fmt.Errorf("failed to write invocation metadata: %w", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// WriteEffectiveConfig writes redacted effective config metadata for this run.
|
|
func (r *RunDirectory) WriteEffectiveConfig(effectiveYAML []byte) error {
|
|
return r.WriteYAMLArtifact(ArtifactEffectiveConfig, effectiveYAML)
|
|
}
|
|
|
|
// WriteSourceTranscript writes the source transcript artifact
|
|
func (r *RunDirectory) WriteSourceTranscript(transcript *schema.SourceTranscript, raw []byte) error {
|
|
// Preserve the source snapshot without copying unredacted input bytes.
|
|
var source any
|
|
decoder := json.NewDecoder(strings.NewReader(string(raw)))
|
|
decoder.UseNumber()
|
|
if err := decoder.Decode(&source); err != nil {
|
|
return fmt.Errorf("decode source snapshot: %w", err)
|
|
}
|
|
sourceBytes, err := r.redactor.JSON(source)
|
|
if err != nil {
|
|
return fmt.Errorf("redact source snapshot: %w", err)
|
|
}
|
|
sourcePath := filepath.Join(r.path, ArtifactSourceTranscript)
|
|
if err := os.WriteFile(sourcePath, append(sourceBytes, '\n'), 0o644); err != nil {
|
|
return fmt.Errorf("failed to write source transcript: %w", err)
|
|
}
|
|
|
|
// Write parsed source for debugging
|
|
parsedPath := filepath.Join(r.path, ArtifactParsedSourceTranscript)
|
|
parsedBytes, err := r.redactor.JSON(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, ArtifactNormalizedTranscript)
|
|
bytes, err := r.redactor.JSON(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, ArtifactNormalizationSummary)
|
|
bytes, err := r.redactor.JSON(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
|
|
}
|
|
|
|
// WriteErrorLog writes an error log on failure
|
|
func (r *RunDirectory) WriteErrorLog(errorMessage string) error {
|
|
errorPath := filepath.Join(r.path, ArtifactErrorLog)
|
|
return os.WriteFile(errorPath, []byte(r.redactor.String(errorMessage)+"\n"), 0o644)
|
|
}
|
|
|
|
// WriteChunkingSummary writes the chunking summary artifact
|
|
func (r *RunDirectory) WriteChunkingSummary(summary *chunking.DetailedSummary) error {
|
|
summaryPath := filepath.Join(r.path, ArtifactChunkingSummary)
|
|
bytes, err := r.redactor.JSON(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
|
|
}
|
|
|
|
func (r *RunDirectory) WriteJSONArtifact(name string, payload any) error {
|
|
artifactPath := filepath.Join(r.path, name)
|
|
bytes, err := r.redactor.JSON(payload)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to marshal %s: %w", name, err)
|
|
}
|
|
bytes = append(bytes, '\n')
|
|
if err := os.WriteFile(artifactPath, bytes, 0o644); err != nil {
|
|
return fmt.Errorf("failed to write %s: %w", name, err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// WriteYAMLArtifact writes a sanitized YAML diagnostic artifact.
|
|
func (r *RunDirectory) WriteYAMLArtifact(name string, payload []byte) error {
|
|
var err error
|
|
payload, err = r.redactor.YAML(payload)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := os.WriteFile(filepath.Join(r.path, name), payload, 0o644); err != nil {
|
|
return fmt.Errorf("failed to write %s: %w", name, err)
|
|
}
|
|
return nil
|
|
}
|