update

internal/api/handlers.go

···
 	})
 }
 
+func (s *Server) handleGetPLCHistory(w http.ResponseWriter, r *http.Request) {
+	resp := newResponse(w)
+
+	limit := getQueryInt(r, "limit", 0)
+	fromBundle := getQueryInt(r, "from", 1)
+
+	history, err := s.db.GetPLCHistory(r.Context(), limit, fromBundle)
+	if err != nil {
+		resp.error(err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	var totalOps int64
+	var totalUncompressed int64
+	var totalCompressed int64
+
+	for _, point := range history {
+		totalOps += int64(point.OperationCount)
+		totalUncompressed += point.UncompressedSize
+		totalCompressed += point.CompressedSize
+	}
+
+	result := map[string]interface{}{
+		"data": history,
+		"summary": map[string]interface{}{
+			"days":               len(history),
+			"total_operations":   totalOps,
+			"total_uncompressed": totalUncompressed,
+			"total_compressed":   totalCompressed,
+			"compression_ratio":  0.0,
+		},
+	}
+
+	if len(history) > 0 {
+		result["summary"].(map[string]interface{})["first_date"] = history[0].Date
+		result["summary"].(map[string]interface{})["last_date"] = history[len(history)-1].Date
+		result["summary"].(map[string]interface{})["time_span_days"] = len(history)
+
+		if totalCompressed > 0 {
+			result["summary"].(map[string]interface{})["compression_ratio"] = float64(totalUncompressed) / float64(totalCompressed)
+		}
+
+		result["summary"].(map[string]interface{})["avg_operations_per_day"] = totalOps / int64(len(history))
+		result["summary"].(map[string]interface{})["avg_size_per_day"] = totalUncompressed / int64(len(history))
+	}
+
+	resp.json(result)
+}
+
 // ===== UTILITY FUNCTIONS =====
 
 func computeOperationsHash(ops []plc.PLCOperation) string {

internal/api/server.go

···
 	api.HandleFunc("/plc/bundles/{number}/download", s.handleDownloadPLCBundle).Methods("GET")
 	api.HandleFunc("/plc/bundles/{bundleNumber}/verify", s.handleVerifyPLCBundle).Methods("POST")
 
+	// PLC history/metrics
+	api.HandleFunc("/plc/history", s.handleGetPLCHistory).Methods("GET")
+
 	// PLC Export endpoint (simulates PLC directory)
 	api.HandleFunc("/plc/export", s.handlePLCExport).Methods("GET")
 

internal/storage/db.go

···
 	GetBundleStats(ctx context.Context) (count, compressedSize, uncompressedSize, lastBundle int64, err error)
 	GetLastBundleNumber(ctx context.Context) (int, error)
 	GetBundleForTimestamp(ctx context.Context, afterTime time.Time) (int, error)
+	GetPLCHistory(ctx context.Context, limit int, fromBundle int) ([]*PLCHistoryPoint, error)
 
 	// Mempool operations
 	AddToMempool(ctx context.Context, ops []MempoolOperation) error

internal/storage/postgres.go

···
 	return bundleNum, nil
 }
 
+func (p *PostgresDB) GetPLCHistory(ctx context.Context, limit int, fromBundle int) ([]*PLCHistoryPoint, error) {
+	query := `
+		WITH daily_stats AS (
+			SELECT 
+				DATE(start_time) as date,
+				MAX(bundle_number) as last_bundle,
+				COUNT(*) as bundle_count,
+				SUM(uncompressed_size) as total_uncompressed,
+				SUM(compressed_size) as total_compressed,
+				MAX(cumulative_uncompressed_size) as cumulative_uncompressed,
+				MAX(cumulative_compressed_size) as cumulative_compressed
+			FROM plc_bundles
+			WHERE bundle_number >= $1
+			GROUP BY DATE(start_time)
+		)
+		SELECT 
+			date::text,
+			last_bundle,
+			SUM(bundle_count * 10000) OVER (ORDER BY date) as cumulative_operations,
+			total_uncompressed,
+			total_compressed,
+			cumulative_uncompressed,
+			cumulative_compressed
+		FROM daily_stats
+		ORDER BY date ASC
+	`
+
+	if limit > 0 {
+		query += fmt.Sprintf(" LIMIT %d", limit)
+	}
+
+	rows, err := p.db.QueryContext(ctx, query, fromBundle)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var history []*PLCHistoryPoint
+	for rows.Next() {
+		var point PLCHistoryPoint
+		var cumulativeOps int64
+
+		err := rows.Scan(
+			&point.Date,
+			&point.BundleNumber,
+			&cumulativeOps,
+			&point.UncompressedSize,
+			&point.CompressedSize,
+			&point.CumulativeUncompressed,
+			&point.CumulativeCompressed,
+		)
+		if err != nil {
+			return nil, err
+		}
+
+		point.OperationCount = int(cumulativeOps)
+
+		history = append(history, &point)
+	}
+
+	return history, rows.Err()
+}
+
 // ===== MEMPOOL OPERATIONS =====
 
 func (p *PostgresDB) AddToMempool(ctx context.Context, ops []MempoolOperation) error {

internal/storage/types.go

···
 	return 10000
 }
 
+type PLCHistoryPoint struct {
+	Date                   string `json:"date"`
+	BundleNumber           int    `json:"last_bundle_number"`
+	OperationCount         int    `json:"operations"`
+	UncompressedSize       int64  `json:"size_uncompressed"`
+	CompressedSize         int64  `json:"size_compressed"`
+	CumulativeUncompressed int64  `json:"cumulative_uncompressed"`
+	CumulativeCompressed   int64  `json:"cumulative_compressed"`
+}
+
 // MempoolOperation represents an operation waiting to be bundled
 type MempoolOperation struct {
 	ID        int64