knowledge-governance/cmd/test-weknora-probe/main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"log"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"

	postgresstore "knowledge-governance/internal/platform/postgres"
	"knowledge-governance/internal/platform/weknora"
	"knowledge-governance/internal/workflows/testweknora"
)

type probeConfig struct {
	DatabaseURL      string
	Concurrency      int
	Online           bool
	BaseURL          string
	APIKeyFile       string
	ChunkSampleEvery int
}

func main() {
	if err := run(context.Background(), os.Args[1:], os.Getenv, os.Stdout); err != nil {
		log.Fatal(err)
	}
}

func run(ctx context.Context, args []string, getenv func(string) string, stdout io.Writer) error {
	config, err := parseProbeConfig(args, getenv)
	if err != nil {
		return err
	}

	pool, err := pgxpool.New(ctx, config.DatabaseURL)
	if err != nil {
		return fmt.Errorf("open database: %w", err)
	}
	defer pool.Close()
	if err := pool.Ping(ctx); err != nil {
		return fmt.Errorf("ping database: %w", err)
	}
	store := postgresstore.NewStore(pool)
	legacy, err := store.ListLegacyVerificationCandidates(ctx)
	if err != nil {
		return err
	}
	candidates := make([]testweknora.LegacyCandidate, 0, len(legacy))
	for _, candidate := range legacy {
		candidates = append(candidates, testweknora.LegacyCandidate{
			ID: candidate.ID, TestKBID: candidate.TestKBID, KnowledgeID: candidate.KnowledgeID,
		})
	}
	if !config.Online {
		_, _ = io.WriteString(stdout, testweknora.FormatDryRunReport(candidates, config.Concurrency))
		return nil
	}
	apiKey, err := weknora.ReadAPIKeyFile(config.APIKeyFile)
	if err != nil {
		return fmt.Errorf("read test WeKnora API key: %w", err)
	}
	client, err := weknora.NewClient(weknora.ClientConfig{
		BaseURL: config.BaseURL,
		APIKey:  apiKey,
		Timeout: 30 * time.Second,
	})
	if err != nil {
		return fmt.Errorf("create test WeKnora client: %w", err)
	}
	report, err := testweknora.VerifyLegacyConcurrent(ctx, client, candidates, config.ChunkSampleEvery, config.Concurrency)
	if err != nil {
		return fmt.Errorf("verify historical test publications: %w", err)
	}
	_, _ = io.WriteString(stdout, testweknora.FormatLegacyVerificationReport(report))
	return nil
}

func parseProbeConfig(args []string, getenv func(string) string) (probeConfig, error) {
	flags := flag.NewFlagSet("test-weknora-probe", flag.ContinueOnError)
	flags.SetOutput(io.Discard)
	databaseURL := flags.String("database-url", "", "PostgreSQL connection URL (or DATABASE_URL)")
	concurrency := flags.Int("concurrency", 4, "planned read-only verify concurrency for the online phase")
	online := flags.Bool("online", false, "run authenticated read-only verification")
	baseURL := flags.String("base-url", "", "HTTPS WeKnora base URL")
	apiKeyFile := flags.String("api-key-file", "", "mode-0600 WeKnora API key file")
	chunkSampleEvery := flags.Int("chunk-sample-every", 25, "check one completed Knowledge chunk count every N items; 0 disables")
	if err := flags.Parse(args); err != nil {
		return probeConfig{}, fmt.Errorf("parse arguments: %w", err)
	}
	if *databaseURL == "" {
		*databaseURL = getenv("DATABASE_URL")
	}
	if *databaseURL == "" {
		return probeConfig{}, fmt.Errorf("-database-url or DATABASE_URL is required")
	}
	if *concurrency < 1 || *concurrency > 16 || *chunkSampleEvery < 0 {
		return probeConfig{}, fmt.Errorf("concurrency must be 1..16 and chunk-sample-every must be non-negative")
	}
	if *baseURL == "" {
		*baseURL = getenv("TEST_WEKNORA_BASE_URL")
	}
	if *apiKeyFile == "" {
		*apiKeyFile = getenv("TEST_WEKNORA_API_KEY_FILE")
	}
	if *online {
		parsed, err := url.Parse(strings.TrimSpace(*baseURL))
		if err != nil || parsed.Scheme != "https" || parsed.Host == "" || parsed.User != nil {
			return probeConfig{}, fmt.Errorf("online verification requires an HTTPS base-url")
		}
		if !filepath.IsAbs(*apiKeyFile) {
			return probeConfig{}, fmt.Errorf("online verification requires an absolute api-key-file")
		}
	}
	return probeConfig{
		DatabaseURL:      *databaseURL,
		Concurrency:      *concurrency,
		Online:           *online,
		BaseURL:          strings.TrimRight(strings.TrimSpace(*baseURL), "/"),
		APIKeyFile:       *apiKeyFile,
		ChunkSampleEvery: *chunkSampleEvery,
	}, nil
}