compression

type ABTestManager struct {
	// contains filtered or unexported fields
}

type AbstractiveCompressor struct {
	// contains filtered or unexported fields
}

type Algorithm string

type Capabilities struct {
	// Supported algorithms
	SupportedAlgorithms []Algorithm

	// Maximum content length supported
	MaxContentLength int

	// Whether it supports target compression ratios
	SupportsTargetRatio bool

	// Quality score range
	QualityScoreRange struct {
		Min float64
		Max float64
	}
}

type ClaudeClient interface {
	// Summarize generates an abstractive summary using Claude API
	Summarize(ctx context.Context, content string, targetRatio float64) (string, error)
}

type ClaudeError struct {
	Type  string `json:"type"`
	Error struct {
		Type    string `json:"type"`
		Message string `json:"message"`
	} `json:"error"`
}

type ClaudeMessage struct {
	Role    string `json:"role"`
	Content string `json:"content"`
}

type ClaudeRequest struct {
	Model       string          `json:"model"`
	MaxTokens   int             `json:"max_tokens"`
	Messages    []ClaudeMessage `json:"messages"`
	System      string          `json:"system,omitempty"`
	Temperature float64         `json:"temperature"`
}

type ClaudeResponse struct {
	ID      string `json:"id"`
	Type    string `json:"type"`
	Role    string `json:"role"`
	Content []struct {
		Type string `json:"type"`
		Text string `json:"text"`
	} `json:"content"`
	Model      string `json:"model"`
	StopReason string `json:"stop_reason"`
	Usage      struct {
		InputTokens  int `json:"input_tokens"`
		OutputTokens int `json:"output_tokens"`
	} `json:"usage"`
}

type ComparisonReport struct {
	ExperimentID   string                       // Experiment identifier
	GeneratedAt    time.Time                    // When report was generated
	TotalSessions  int                          // Total unique sessions
	VariantMetrics map[Algorithm]VariantMetrics // Metrics per variant
	Winner         *Algorithm                   // Best performing algorithm (if conclusive)
	WinnerReason   string                       // Why this variant won
	Recommendation string                       // Recommendation for production use
}

type CompressionOutcome struct {
	SessionID        string    // Unique session identifier
	Algorithm        Algorithm // Algorithm used
	CompressionRatio float64   // Actual compression ratio achieved
	QualityScore     float64   // Quality score (0.0 to 1.0)
	ProcessingTimeMs float64   // Processing time in milliseconds
	Success          bool      // Whether compression succeeded
	UserAccepted     bool      // Whether user accepted the compressed result
	ErrorMessage     string    // Error message if failed
	Timestamp        time.Time // When the compression occurred
}

type Compressor interface {
	// Compress compresses the given content using the specified algorithm
	Compress(ctx context.Context, content string, algorithm Algorithm, targetRatio float64) (*Result, error)

	// GetCapabilities returns the capabilities of this compressor
	GetCapabilities(ctx context.Context) Capabilities
}

type Config struct {
	// Default algorithm to use
	DefaultAlgorithm Algorithm

	// Target compression ratio (original/compressed)
	TargetRatio float64

	// Quality threshold (minimum acceptable quality score)
	QualityThreshold float64

	// Maximum processing time per compression
	MaxProcessingTime time.Duration

	// Anthropic API key for abstractive compression
	AnthropicAPIKey string
}

type ContentSection struct {
	Content string
	IsCode  bool
}

type ContentType string

type Experiment struct {
	ID        string              // Unique experiment identifier
	Variants  []ExperimentVariant // Algorithm variants to test
	StartTime time.Time           // When experiment started
	EndTime   *time.Time          // When experiment ended (nil if ongoing)
	// contains filtered or unexported fields
}

type ExperimentVariant struct {
	Algorithm Algorithm // Compression algorithm
	Weight    float64   // Assignment weight (for weighted distribution)
}

type ExtractiveCompressor struct {
	// contains filtered or unexported fields
}

type HTTPClaudeClient struct {
	// contains filtered or unexported fields
}

type HybridCompressor struct {
	// contains filtered or unexported fields
}

type MockAbstractiveCompressor struct {
	// contains filtered or unexported fields
}

type PreviewOptions struct {
	// Width of the output (terminal columns)
	Width int

	// ShowMetrics displays compression metrics at the top
	ShowMetrics bool

	// ColorOutput enables ANSI color codes for diff highlighting
	ColorOutput bool
}

type QualityGate struct {
	Thresholds QualityThresholds
}

type QualityGateResult struct {
	Pass                      bool
	FailureReason             string
	CompressionRatioScore     float64
	InformationRetentionScore float64
	SemanticSimilarityScore   float64
	ReadabilityScore          float64
	CompositeScore            float64
}

type QualityMetrics struct {
	OriginalSize   int
	CompressedSize int
	TargetRatio    float64
}

type QualityThresholds struct {
	MinCompressionRatio     float64
	MinInformationRetention float64
	MinSemanticSimilarity   float64
	MinReadability          float64
	MinCompositeScore       float64
}

type Result struct {
	// Compressed content
	Content string

	// Compression metadata
	Metadata vectorstore.CompressionMetadata

	// Processing time
	ProcessingTime time.Duration

	// Quality score (0.0 to 1.0, higher is better)
	QualityScore float64
}

type RoutingStrategy string

type Service struct {
	// contains filtered or unexported fields
}

type Stats struct {
	LastRatio       float64
	LastQuality     float64
	OperationsTotal int64
}

type VariantMetrics struct {
	Algorithm           Algorithm // Algorithm variant
	TotalAttempts       int       // Total compression attempts
	SuccessCount        int       // Successful compressions
	SuccessRate         float64   // Success rate (0.0 to 1.0)
	AvgCompressionRatio float64   // Average compression ratio
	AvgQualityScore     float64   // Average quality score
	AvgProcessingTimeMs float64   // Average processing time
	UserAcceptanceRate  float64   // Rate of user acceptance (0.0 to 1.0)
	UserAcceptanceCount int       // Number of times user accepted
	UserRejectionCount  int       // Number of times user rejected
	P50CompressionRatio float64   // Median compression ratio
	P95ProcessingTimeMs float64   // 95th percentile processing time
}