DEV-000068 add learning write diagnostics

Merge DEV-000068 strong Postgres credential support

adapters/postgres/authority_repository.go

@@ -11,7 +11,7 @@ import (
 type AuthorityRepository struct{ pool *pgxpool.Pool }
 
 func OpenAuthority(ctx context.Context, c ContinuityConfig) (*AuthorityRepository, error) {
-	p, e := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", c.Host, c.Port, c.Database, c.User, c.Password))
+	p, e := openPool(ctx, c)
 	if e != nil {
 		return nil, e
 	}

adapters/postgres/capability_repository.go

@@ -19,8 +19,7 @@ var ErrCapabilityImplementationNotFound = errors.New("capability implementation
 type CapabilityRepository struct{ pool *pgxpool.Pool }
 
 func OpenCapability(ctx context.Context, config ContinuityConfig) (*CapabilityRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
+	pool, err := openPool(ctx, config)
-	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/commit_repository.go

@@ -23,7 +23,7 @@ var (
 type CommitRepository struct{ pool *pgxpool.Pool }
 
 func OpenCommit(ctx context.Context, c ContinuityConfig) (*CommitRepository, error) {
-	p, e := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", c.Host, c.Port, c.Database, c.User, c.Password))
+	p, e := openPool(ctx, c)
 	if e != nil {
 		return nil, e
 	}

adapters/postgres/continuity_repository.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 
 	"git.cin.su/m/Assistant/contracts/authority"
 	"git.cin.su/m/Assistant/contracts/continuity"
@@ -29,9 +30,25 @@ var (
 type ContinuityConfig struct{ Host, Port, Database, User, Password string }
 type ContinuityRepository struct{ pool *pgxpool.Pool }
 
+func openPool(ctx context.Context, config ContinuityConfig) (*pgxpool.Pool, error) {
+	poolConfig, err := pgxpool.ParseConfig("")
+	if err != nil {
+		return nil, err
+	}
+	port, err := strconv.ParseUint(config.Port, 10, 16)
+	if err != nil {
+		return nil, fmt.Errorf("invalid postgres port: %w", err)
+	}
+	poolConfig.ConnConfig.Host = config.Host
+	poolConfig.ConnConfig.Port = uint16(port)
+	poolConfig.ConnConfig.Database = config.Database
+	poolConfig.ConnConfig.User = config.User
+	poolConfig.ConnConfig.Password = config.Password
+	return pgxpool.NewWithConfig(ctx, poolConfig)
+}
+
 func OpenContinuity(ctx context.Context, config ContinuityConfig) (*ContinuityRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
+	pool, err := openPool(ctx, config)
-	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/epistemics_repository.go

@@ -11,8 +11,7 @@ import (
 type EpistemicsRepository struct{ pool *pgxpool.Pool }
 
 func OpenEpistemics(ctx context.Context, config ContinuityConfig) (*EpistemicsRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
+	pool, err := openPool(ctx, config)
-	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/identity_repository.go

@@ -11,7 +11,7 @@ import (
 type IdentityRepository struct{ pool *pgxpool.Pool }
 
 func OpenIdentity(ctx context.Context, config ContinuityConfig) (*IdentityRepository, error) {
-	pool, err := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password))
+	pool, err := openPool(ctx, config)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/interaction_repository.go

@@ -2,7 +2,6 @@ package postgres
 
 import (
 	"context"
-	"fmt"
 
 	"git.cin.su/m/Assistant/contracts/interaction"
 	"github.com/jackc/pgx/v5/pgxpool"
@@ -11,7 +10,7 @@ import (
 type InteractionRepository struct{ pool *pgxpool.Pool }
 
 func OpenInteraction(ctx context.Context, c ContinuityConfig) (*InteractionRepository, error) {
-	p, e := pgxpool.New(ctx, fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", c.Host, c.Port, c.Database, c.User, c.Password))
+	p, e := openPool(ctx, c)
 	return &InteractionRepository{p}, e
 }
 func (r *InteractionRepository) Close() { r.pool.Close() }

adapters/postgres/situation_repository.go

@@ -2,7 +2,6 @@ package postgres
 
 import (
 	"context"
-	"fmt"
 	"strings"
 
 	"git.cin.su/m/Assistant/contracts/identity"
@@ -13,8 +12,7 @@ import (
 type SituationRepository struct{ pool *pgxpool.Pool }
 
 func OpenSituation(ctx context.Context, config ContinuityConfig) (*SituationRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
+	pool, err := openPool(ctx, config)
-	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		return nil, err
 	}

adapters/postgres/work_repository.go

@@ -11,8 +11,7 @@ import (
 type WorkRepository struct{ pool *pgxpool.Pool }
 
 func OpenWork(ctx context.Context, config ContinuityConfig) (*WorkRepository, error) {
-	dsn := fmt.Sprintf("host=%s port=%s dbname=%s user=%s password=%s", config.Host, config.Port, config.Database, config.User, config.Password)
+	pool, err := openPool(ctx, config)
-	pool, err := pgxpool.New(ctx, dsn)
 	if err != nil {
 		return nil, err
 	}

cmd/core-runtime/learning.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"context"
+	"log"
 	"strings"
 	"time"
 
@@ -85,7 +86,12 @@ func (r learningRecorder) recordReminderResponse(ctx context.Context, input remi
 		RecordedAtUnixMillis: input.At.UnixMilli(),
 	}
 	expectation, err := epistemicsdomain.NewSystemExpectation(expectation)
-	if err != nil || r.epistemics.SaveSystemExpectation(ctx, expectation) != nil {
+	if err != nil {
+		log.Printf("learning reminder expectation invalid: %v", err)
+		return
+	}
+	if err := r.epistemics.SaveSystemExpectation(ctx, expectation); err != nil {
+		log.Printf("learning reminder expectation unavailable: %v", err)
 		return
 	}
 	actual, confidence := outcomeForHumanResponse(input.Result.Response)
@@ -197,13 +203,19 @@ func (r learningRecorder) recordCapabilityUse(ctx context.Context, input capabil
 func (r learningRecorder) saveExperienceAndReflection(ctx context.Context, value epistemics.ExperienceRecord) (epistemics.ExperienceRecord, bool) {
 	value, err := epistemicsdomain.NewExperienceRecord(value)
 	if err != nil {
+		log.Printf("learning experience invalid: %v", err)
 		return epistemics.ExperienceRecord{}, false
 	}
 	if err := r.epistemics.SaveExperienceRecord(ctx, value); err != nil {
+		log.Printf("learning experience unavailable: %v", err)
 		return epistemics.ExperienceRecord{}, false
 	}
 	if candidate, ok, err := epistemicsdomain.ReflectionForExperience(value); err == nil && ok {
-		_ = r.epistemics.SaveReflectionCandidate(ctx, candidate)
+		if err := r.epistemics.SaveReflectionCandidate(ctx, candidate); err != nil {
+			log.Printf("learning reflection unavailable: %v", err)
+		}
+	} else if err != nil {
+		log.Printf("learning reflection invalid: %v", err)
 	}
 	return value, true
 }
@@ -214,6 +226,7 @@ func (r learningRecorder) updateReminderSkill(ctx context.Context, experience ep
 	}
 	profile, err := r.capability.LoadSkillProfile(ctx, reminderResponseSkillID)
 	if err != nil {
+		log.Printf("learning skill profile unavailable: %v", err)
 		return
 	}
 	next, err := capabilitydomain.ObserveSkillOutcome(profile, capability.SkillOutcomeObservation{
@@ -223,9 +236,11 @@ func (r learningRecorder) updateReminderSkill(ctx context.Context, experience ep
 		ObservedAtUnixMillis: experience.RecordedAtUnixMillis,
 	})
 	if err != nil {
+		log.Printf("learning skill observation invalid: %v", err)
 		return
 	}
 	if err := r.capability.SaveSkillProfile(ctx, next); err != nil {
+		log.Printf("learning skill profile save unavailable: %v", err)
 		return
 	}
 }