foundation/serialization impl

[gbrennon]

foundation/serialization implemented.

in the future maybe it will include impl of default serialization for other presentation layer protocols

[Copilot]

Pull request overview

Introduces a new foundation/serialization capability by defining a Serializable interface and adding a JSON-based implementation, along with basic tests and repo-level developer tooling/docs (Makefile, .gitignore, README updates).

Changes:

• Added Serializable interface and JSONSerializable implementation for JSON marshaling/unmarshaling.
• Added a unit test covering JSON round-trip behavior.
• Added README guidance plus Makefile targets for testing/coverage/release and a .gitignore for Go artifacts.

Reviewed changes

Copilot reviewed 5 out of 6 changed files in this pull request and generated 9 comments.

Show a summary per file

File	Description
pkg/forging/foundation/serialization/serializable.go	Introduces core Serializable interface.
pkg/forging/foundation/serialization/json_serializable.go	Adds JSON-backed implementation of Serializable.
pkg/forging/foundation/serialization/json_serializable_test.go	Adds JSON round-trip unit test.
README.md	Documents the new serialization package and contributor workflow.
Makefile	Adds test/coverage/check-coverage/release targets.
.gitignore	Ignores Go build/test artifacts and editor files.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The check-coverage target depends on bc being installed (echo ... | bc). That tool isn’t available by default in some environments/CI images, which can make coverage checks fail unexpectedly. Consider doing the comparison in awk (or Go) to avoid external dependencies, or document bc as a prerequisite.

[Copilot]

FromData unmarshals into &j.Value (a *interface{}), which causes encoding/json to replace Value with generic map[string]any/[]any instead of populating the concrete destination. This breaks the intended round-trip and will make the test’s *testStruct type assertion fail. Unmarshal into the concrete destination stored in j.Value (and require it to be a non-nil pointer), or change the type to a generic JSONSerializable[T any] that holds *T so the destination type is explicit.

Suggested change

	)
	type JSONSerializable struct {
	Value interface{}
	}
	func (j *JSONSerializable) ToData() ([]byte, error) {
	return json.Marshal(j.Value)
	}
	func (j *JSONSerializable) FromData(data []byte) error {
	return json.Unmarshal(data, &j.Value)
	"fmt"
	"reflect"
	)
	type JSONSerializable struct {
	Value interface{}
	}
	func (j *JSONSerializable) ToData() ([]byte, error) {
	return json.Marshal(j.Value)
	}
	func (j *JSONSerializable) FromData(data []byte) error {
	if j == nil {
	return fmt.Errorf("JSONSerializable receiver is nil")
	}
	if j.Value == nil {
	return fmt.Errorf("JSONSerializable.Value must be a non-nil pointer; got <nil>")
	}
	v := reflect.ValueOf(j.Value)
	if v.Kind() != reflect.Ptr || v.IsNil() {
	return fmt.Errorf("JSONSerializable.Value must be a non-nil pointer; got %T", j.Value)
	}
	return json.Unmarshal(data, j.Value)

[Copilot]

Package name is foundation even though the folder path is foundation/serialization. This makes the public API awkward to consume (import path ends in serialization but code is referenced as foundation.JSONSerializable). Align package name with the directory (e.g., package serialization) or move the code under a foundation directory that matches the package name.

Suggested change

	package foundation
	package serialization

[Copilot]

This file isn’t gofmt-formatted (spaces instead of tabs/standard formatting). Running gofmt (or ensuring the formatter runs in CI) will normalize indentation/import formatting and avoid noisy diffs later.

Suggested change

	"testing"
	)
	type testStruct struct {
	Name string
	Age int
	}
	func TestJSONSerializable_ToDataAndFromData(t *testing.T) {
	original := &JSONSerializable{Value: testStruct{Name: "Alice", Age: 30}}
	data, err := original.ToData()
	if err != nil {
	t.Fatalf("ToData failed: %v", err)
	}
	copy := &JSONSerializable{Value: &testStruct{}}
	err = copy.FromData(data)
	if err != nil {
	t.Fatalf("FromData failed: %v", err)
	}
	result, ok := copy.Value.(*testStruct)
	if !ok {
	t.Fatalf("Type assertion failed")
	}
	if result.Name != "Alice" || result.Age != 30 {
	t.Errorf("Expected Alice, 30; got %s, %d", result.Name, result.Age)
	}
	"testing"
	)
	type testStruct struct {
	Name string
	Age int
	}
	func TestJSONSerializable_ToDataAndFromData(t *testing.T) {
	original := &JSONSerializable{Value: testStruct{Name: "Alice", Age: 30}}
	data, err := original.ToData()
	if err != nil {
	t.Fatalf("ToData failed: %v", err)
	}
	copy := &JSONSerializable{Value: &testStruct{}}
	err = copy.FromData(data)
	if err != nil {
	t.Fatalf("FromData failed: %v", err)
	}
	result, ok := copy.Value.(*testStruct)
	if !ok {
	t.Fatalf("Type assertion failed")
	}
	if result.Name != "Alice" || result.Age != 30 {
	t.Errorf("Expected Alice, 30; got %s, %d", result.Name, result.Age)
	}

[Copilot]

In check-coverage, cov=$(shell ...) is evaluated by make during recipe expansion, before the preceding go test -coverprofile=... line generates coverage.out. This can result in go tool cover running against a missing/stale file and makes the target unreliable. Compute cov using shell command substitution ($$(...)) inside the recipe after generating the coverage file.

[Copilot]

make release will happily run with an empty VERSION, creating/pushing a v tag, and it always pushes directly to origin. Add guards to require VERSION to be set/valid (and ideally ensure a clean working tree), and consider using an annotated tag (git tag -a) to reduce accidental releases.

[Copilot]

@gbrennon I've opened a new pull request, #2, to work on those changes. Once the pull request is ready, I'll request review from you.