knowledge-governance/cmd/pp-ledger-import/main.go

package main

import (
	"context"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"strings"

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

	ppconnector "knowledge-governance/internal/connectors/pp"
	postgresstore "knowledge-governance/internal/platform/postgres"
)

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 {
	flags := flag.NewFlagSet("pp-ledger-import", flag.ContinueOnError)
	flags.SetOutput(io.Discard)
	ledgerPath := flags.String("ledger", "", "path to the legacy PP state JSONL")
	manifestPath := flags.String("manifest", "", "path to the validated download manifest JSON")
	dryRun := flags.Bool("dry-run", false, "validate and print aggregate counts without database access")
	if err := flags.Parse(args); err != nil {
		return fmt.Errorf("parse arguments: %w", err)
	}
	if *ledgerPath == "" || *manifestPath == "" {
		return fmt.Errorf("-ledger and -manifest are required")
	}

	ledger, err := os.Open(*ledgerPath)
	if err != nil {
		return fmt.Errorf("open PP ledger: %w", err)
	}
	snapshot, foldErr := ppconnector.FoldLedger(ledger)
	closeErr := ledger.Close()
	if foldErr != nil {
		return foldErr
	}
	if closeErr != nil {
		return fmt.Errorf("close PP ledger: %w", closeErr)
	}

	manifest, err := os.Open(*manifestPath)
	if err != nil {
		return fmt.Errorf("open PP download manifest: %w", err)
	}
	recovered, recovery, recoveryErr := ppconnector.RecoverMissingSHA256(snapshot, manifest)
	closeErr = manifest.Close()
	if recoveryErr != nil {
		return recoveryErr
	}
	if closeErr != nil {
		return fmt.Errorf("close PP download manifest: %w", closeErr)
	}
	overLimitManifest, err := os.Open(*manifestPath)
	if err != nil {
		return fmt.Errorf("reopen PP download manifest: %w", err)
	}
	complete, overLimit, overLimitErr := ppconnector.MergeOverLimitManifest(recovered, overLimitManifest)
	closeErr = overLimitManifest.Close()
	if overLimitErr != nil {
		return overLimitErr
	}
	if closeErr != nil {
		return fmt.Errorf("close PP download manifest: %w", closeErr)
	}
	if err := ppconnector.ValidateSnapshot(complete); err != nil {
		return fmt.Errorf("validate PP snapshot: %w", err)
	}
	plan, err := ppconnector.BuildImportPlan(complete)
	if err != nil {
		return fmt.Errorf("build PP import plan: %w", err)
	}

	completed := 0
	aliases := 0
	for _, item := range complete.Items {
		switch item.Status {
		case ppconnector.StatusCompleted:
			completed++
		case ppconnector.StatusContentAlias:
			aliases++
		}
	}
	_, _ = fmt.Fprintf(stdout,
		"events=%d\nsource_items=%d\ncompleted=%d\ncontent_aliases=%d\nover_limit=%d\nrecovered_sha256=%d\nverified_bytes=%d\ncontent_objects=%d\nversions=%d\npublications=%d\n",
		complete.EventCount,
		len(plan.SourceItems),
		completed,
		aliases,
		overLimit.Added,
		recovery.Recovered,
		recovery.VerifiedBytes,
		len(plan.ContentObjects),
		len(plan.Versions),
		len(plan.Publications),
	)
	if *dryRun {
		_, _ = fmt.Fprintln(stdout, "dry_run=true")
		return nil
	}

	databaseURL := strings.TrimSpace(getenv("DATABASE_URL"))
	if databaseURL == "" {
		return fmt.Errorf("DATABASE_URL is required unless -dry-run is used")
	}
	pool, err := pgxpool.New(ctx, databaseURL)
	if err != nil {
		return fmt.Errorf("open governance database: %w", err)
	}
	defer pool.Close()
	if err := pool.Ping(ctx); err != nil {
		return fmt.Errorf("ping governance database: %w", err)
	}
	if err := postgresstore.ApplyMigrations(ctx, pool); err != nil {
		return err
	}
	report, err := postgresstore.ImportPPLegacy(ctx, pool, plan)
	if err != nil {
		return err
	}
	_, _ = fmt.Fprintf(stdout,
		"inserted_connections=%d\ninserted_source_items=%d\ninserted_content_objects=%d\ninserted_versions=%d\ninserted_publications=%d\n",
		report.Connections,
		report.SourceItems,
		report.ContentObjects,
		report.Versions,
		report.Publications,
	)
	current, err := postgresstore.LoadPPCurrentItems(ctx, pool, plan.Connection.ID)
	if err != nil {
		return err
	}
	reconciliation, err := ppconnector.PlanReconciliation(complete, current)
	if err != nil {
		return err
	}
	_, _ = fmt.Fprintf(stdout,
		"reconcile_unchanged=%d\nreconcile_adopted=%d\nreconcile_over_limit=%d\nplanned_uploads=%d\n",
		reconciliation.Unchanged,
		reconciliation.Adopted,
		reconciliation.OverLimit,
		reconciliation.UploadRequired,
	)
	return nil
}