feat: implement Foundation V1 walking skeleton
CI / test (push) Successful in 7m31s

This commit is contained in:
m
2026-08-16 15:22:49 +03:00
commit 9b136621ef
205 changed files with 6345 additions and 0 deletions
+29
View File
@@ -0,0 +1,29 @@
package postgres
import (
"context"
"fmt"
"git.cin.su/m/Assistant/contracts/authority"
"github.com/jackc/pgx/v5/pgxpool"
)
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))
if e != nil {
return nil, e
}
return &AuthorityRepository{p}, nil
}
func (r *AuthorityRepository) Close() { r.pool.Close() }
func (r *AuthorityRepository) LoadGrant(ctx context.Context, id authority.GrantID) (authority.AuthorityGrant, authority.Scope, error) {
var grant authority.AuthorityGrant
var scope authority.Scope
err := r.pool.QueryRow(ctx, `SELECT g.grant_id, g.actor_id, g.principal_id, g.scope_id, g.grant_class, g.revision, g.active, s.scope_id, s.global_scope, s.label FROM authority.authority_grants g JOIN authority.scopes s ON s.scope_id=g.scope_id WHERE g.grant_id=$1`, id).Scan(&grant.ID, &grant.ActorID, &grant.PrincipalID, &grant.ScopeID, &grant.Class, &grant.Revision, &grant.Active, &scope.ID, &scope.Global, &scope.Label)
if err != nil {
return authority.AuthorityGrant{}, authority.Scope{}, fmt.Errorf("load authority grant: %w", err)
}
return grant, scope, nil
}
@@ -0,0 +1,58 @@
package postgres
import (
"context"
"errors"
"fmt"
"git.cin.su/m/Assistant/contracts/capability"
"github.com/jackc/pgx/v5/pgxpool"
)
var ErrCapabilityHealthNotFound = errors.New("capability health not found")
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 := pgxpool.New(ctx, dsn)
if err != nil {
return nil, err
}
return &CapabilityRepository{pool: pool}, nil
}
func (r *CapabilityRepository) Close() { r.pool.Close() }
func (r *CapabilityRepository) SaveHealth(ctx context.Context, health capability.Health) error {
_, err := r.pool.Exec(ctx, `INSERT INTO capability.health (capability_id, state, reason, revision, semantic_version, observed_at_unix_millis) VALUES ($1,$2,$3,$4,$5,$6) ON CONFLICT (capability_id) DO UPDATE SET state=EXCLUDED.state, reason=EXCLUDED.reason, revision=EXCLUDED.revision, semantic_version=EXCLUDED.semantic_version, observed_at_unix_millis=EXCLUDED.observed_at_unix_millis WHERE capability.health.revision < EXCLUDED.revision`, health.CapabilityID, health.State, health.Reason, health.Revision, health.SemanticVersion, health.ObservedAtUnixMillis)
return err
}
func (r *CapabilityRepository) LoadHealth(ctx context.Context, id capability.CapabilityID) (capability.Health, error) {
var health capability.Health
err := r.pool.QueryRow(ctx, `SELECT capability_id, state, reason, revision, semantic_version, observed_at_unix_millis FROM capability.health WHERE capability_id=$1`, id).Scan(&health.CapabilityID, &health.State, &health.Reason, &health.Revision, &health.SemanticVersion, &health.ObservedAtUnixMillis)
if err != nil {
return capability.Health{}, fmt.Errorf("load capability health: %w", err)
}
return health, nil
}
func (r *CapabilityRepository) RebuildHealthProjection(ctx context.Context) (int64, error) {
tx, err := r.pool.Begin(ctx)
if err != nil {
return 0, err
}
defer tx.Rollback(ctx)
if _, err = tx.Exec(ctx, `DELETE FROM capability.health_projection`); err != nil {
return 0, err
}
result, err := tx.Exec(ctx, `INSERT INTO capability.health_projection (capability_id, state, reason, revision, semantic_version, observed_at_unix_millis) SELECT capability_id, state, reason, revision, semantic_version, observed_at_unix_millis FROM capability.health`)
if err != nil {
return 0, err
}
if err = tx.Commit(ctx); err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
+27
View File
@@ -0,0 +1,27 @@
package postgres
import (
"context"
"fmt"
commitcontract "git.cin.su/m/Assistant/contracts/commit"
"github.com/jackc/pgx/v5/pgxpool"
)
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))
if e != nil {
return nil, e
}
return &CommitRepository{p}, nil
}
func (r *CommitRepository) Close() { r.pool.Close() }
func (r *CommitRepository) SaveAuthorized(ctx context.Context, a commitcontract.AuthorizedAction) error {
_, e := r.pool.Exec(ctx, `INSERT INTO commit.authorized_actions (authorized_action_id,action_intent_id,state,revision) VALUES ($1,$2,$3,1) ON CONFLICT (authorized_action_id) DO NOTHING`, a.ID, a.Proposal.IntentID, a.State)
return e
}
func (r *CommitRepository) SaveAttempt(ctx context.Context, a commitcontract.ActionAttempt) error {
_, e := r.pool.Exec(ctx, `INSERT INTO commit.action_attempts (action_attempt_id,authorized_action_id,action_intent_id,state) VALUES ($1,$2,$3,$4) ON CONFLICT (action_attempt_id) DO NOTHING`, a.ID, a.AuthorizedID, a.IntentID, a.State)
return e
}
@@ -0,0 +1,37 @@
package postgres
import (
"context"
"errors"
"fmt"
"git.cin.su/m/Assistant/contracts/continuity"
"github.com/jackc/pgx/v5/pgxpool"
)
var ErrProspectiveNotFound = errors.New("prospective item not found")
type ContinuityConfig struct{ Host, Port, Database, User, Password string }
type ContinuityRepository struct{ pool *pgxpool.Pool }
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 := pgxpool.New(ctx, dsn)
if err != nil {
return nil, err
}
return &ContinuityRepository{pool: pool}, nil
}
func (r *ContinuityRepository) Close() { r.pool.Close() }
func (r *ContinuityRepository) Save(ctx context.Context, item continuity.ProspectiveItem) error {
_, err := r.pool.Exec(ctx, `INSERT INTO continuity.prospective_items (prospective_item_id, commitment_id, owner_principal_id, scope_id, goal_id, trigger_at_unix_millis, state, revision) VALUES ($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT (prospective_item_id) DO UPDATE SET state=EXCLUDED.state, revision=EXCLUDED.revision`, item.ID, item.CommitmentID, item.OwnerPrincipalID, item.ScopeID, item.GoalID, item.TriggerAtUnixMillis, item.State, item.Revision)
return err
}
func (r *ContinuityRepository) Load(ctx context.Context, id continuity.ProspectiveItemID) (continuity.ProspectiveItem, error) {
var item continuity.ProspectiveItem
err := r.pool.QueryRow(ctx, `SELECT prospective_item_id, commitment_id, owner_principal_id, scope_id, goal_id, trigger_at_unix_millis, state, revision FROM continuity.prospective_items WHERE prospective_item_id=$1`, id).Scan(&item.ID, &item.CommitmentID, &item.OwnerPrincipalID, &item.ScopeID, &item.GoalID, &item.TriggerAtUnixMillis, &item.State, &item.Revision)
if err != nil {
return continuity.ProspectiveItem{}, fmt.Errorf("load prospective item: %w", err)
}
return item, nil
}
+3
View File
@@ -0,0 +1,3 @@
package postgres
// Package postgres: PostgreSQL implementations of owner persistence ports. No domain meaning belongs here.
+28
View File
@@ -0,0 +1,28 @@
package postgres
import (
"context"
"fmt"
"git.cin.su/m/Assistant/contracts/identity"
"github.com/jackc/pgx/v5/pgxpool"
)
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))
if err != nil {
return nil, err
}
return &IdentityRepository{pool: pool}, nil
}
func (r *IdentityRepository) Close() { r.pool.Close() }
func (r *IdentityRepository) LoadBinding(ctx context.Context, actor identity.ActorID, principal identity.PrincipalID) (identity.PrincipalBinding, error) {
var binding identity.PrincipalBinding
err := r.pool.QueryRow(ctx, `SELECT actor_id, principal_id, active FROM identity.principal_bindings WHERE actor_id=$1 AND principal_id=$2`, actor, principal).Scan(&binding.ActorID, &binding.PrincipalID, &binding.Active)
if err != nil {
return identity.PrincipalBinding{}, fmt.Errorf("load identity binding: %w", err)
}
return binding, nil
}
+41
View File
@@ -0,0 +1,41 @@
package postgres
import (
"context"
"fmt"
"git.cin.su/m/Assistant/contracts/situation"
"github.com/jackc/pgx/v5/pgxpool"
)
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 := pgxpool.New(ctx, dsn)
if err != nil {
return nil, err
}
return &SituationRepository{pool: pool}, nil
}
func (r *SituationRepository) Close() { r.pool.Close() }
func (r *SituationRepository) Save(ctx context.Context, binding situation.FocusBinding) error {
_, err := r.pool.Exec(ctx, `INSERT INTO situation.focus_bindings (focus_binding_id, actor_id, session_id, workspace_id, project_id, goal_id, scope_id, active) VALUES ($1,$2,$3,$4,$5,$6,$7,$8) ON CONFLICT (focus_binding_id) DO UPDATE SET active=EXCLUDED.active`, binding.ID, binding.ActorID, binding.SessionID, binding.Workspace, binding.ProjectID, binding.GoalID, binding.ScopeID, binding.Active)
return err
}
func (r *SituationRepository) ByRuntime(ctx context.Context, runtime situation.RuntimeBinding) ([]situation.FocusBinding, error) {
rows, err := r.pool.Query(ctx, `SELECT focus_binding_id, actor_id, session_id, workspace_id, project_id, goal_id, scope_id, active FROM situation.focus_bindings WHERE session_id=$1 AND workspace_id=$2`, runtime.SessionID, runtime.Workspace)
if err != nil {
return nil, err
}
defer rows.Close()
var bindings []situation.FocusBinding
for rows.Next() {
var binding situation.FocusBinding
if err := rows.Scan(&binding.ID, &binding.ActorID, &binding.SessionID, &binding.Workspace, &binding.ProjectID, &binding.GoalID, &binding.ScopeID, &binding.Active); err != nil {
return nil, err
}
bindings = append(bindings, binding)
}
return bindings, rows.Err()
}
+41
View File
@@ -0,0 +1,41 @@
package postgres
import (
"context"
"fmt"
"git.cin.su/m/Assistant/contracts/work"
"github.com/jackc/pgx/v5/pgxpool"
)
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 := pgxpool.New(ctx, dsn)
if err != nil {
return nil, err
}
return &WorkRepository{pool}, nil
}
func (r *WorkRepository) Close() { r.pool.Close() }
func (r *WorkRepository) Create(ctx context.Context, target work.TaskTarget) error {
_, err := r.pool.Exec(ctx, `INSERT INTO work.tasks (task_id,goal_id,scope_id,revision) VALUES ($1,$2,$3,$4) ON CONFLICT (task_id) DO NOTHING`, target.TaskID, target.GoalID, target.ScopeID, target.Revision)
return err
}
func (r *WorkRepository) Commit(ctx context.Context, target work.TaskTarget) (work.TaskRevision, error) {
var revision work.TaskRevision
err := r.pool.QueryRow(ctx, `UPDATE work.tasks SET revision=revision+1 WHERE task_id=$1 AND goal_id=$2 AND scope_id=$3 AND revision=$4 RETURNING revision`, target.TaskID, target.GoalID, target.ScopeID, target.Revision).Scan(&revision)
if err != nil {
return 0, fmt.Errorf("commit task: %w", err)
}
return revision, nil
}
func (r *WorkRepository) Load(ctx context.Context, id work.TaskID) (work.TaskTarget, error) {
var target work.TaskTarget
err := r.pool.QueryRow(ctx, `SELECT task_id, goal_id, scope_id, revision FROM work.tasks WHERE task_id=$1`, id).Scan(&target.TaskID, &target.GoalID, &target.ScopeID, &target.Revision)
if err != nil {
return work.TaskTarget{}, fmt.Errorf("load task: %w", err)
}
return target, nil
}