Docs (internal): Add package comments

Author: lvan100

gs/gstest/gstest.go

@@ -14,11 +14,36 @@
  * limitations under the License.
  */
 
-// Package gstest is a unit testing framework designed for dependency injection in go-spring.
-// Unlike standard dependency injection, in unit testing mode, the framework gracefully ignores
-// non-critical dependency injection failures by logging warnings instead of halting execution.
-// This ensures seamless testing workflows when dealing with extensive dependencies,
-// as only the specific dependencies under test need to be validated, while others remain non-blocking.
+/*
+Package gstest provides unit testing utilities for dependency injection in Go-Spring framework.
+
+Key Features:
+  - Non-critical Dependency Tolerance - Gracefully ignores non-test-target injection failures
+    via warning logs (enabled by gs.ForceAutowireIsNullable)
+  - Type-Safe Mocking - Offers MockFor/With methods for compile-time verified mock registration
+  - Context Lifecycle Management - TestMain automates application context bootstrap/teardown
+  - Smart Injection Helpers - Provides Get/Wire utilities to simplify test case composition
+
+Usage Pattern:
+
+	// Register mocks in init function (executes before TestMain)
+	func init() {
+	    gstest.MockFor[*Dao]().With(&MockDao{})
+	}
+
+	func TestMain(m *testing.M) {
+		gstest.TestMain(m)
+	}
+
+	func TestService(t *testing.T) {
+	    // Retrieve autowired test target
+	    service := gstest.Get[*Service](t)
+
+	    // Verify business logic
+	    result := service.Process()
+	    assert.Equal(t, expect, result)
+	}
+*/
 package gstest
 
 import (

gs/internal/gs_arg/arg.go

@@ -14,6 +14,16 @@
  * limitations under the License.
  */
 
+/*
+Package gs_arg provides implementation for function argument resolution and binding
+
+Key Features:
+  - Configuration property binding and dependency injection via struct tags
+  - Precise positional binding through index-based arguments
+  - Direct injection of fixed value arguments
+  - Full support for variadic function parameters
+  - Conditional execution with runtime evaluation
+*/
 package gs_arg
 
 import (

gs/internal/gs_bean/bean.go

@@ -14,6 +14,15 @@
  * limitations under the License.
  */
 
+/*
+Package gs_bean provides core bean management for Go-Spring framework, featuring:
+
+  - Full lifecycle management (instantiation, DI, destruction)
+  - Method-as-factory mechanism (generate child beans via configured rules)
+  - Conditional registration (profile-based activation)
+  - Type-safe interface export validation
+  - Mock replacement mechanism
+*/
 package gs_bean
 
 import (

gs/internal/gs_cond/cond.go

@@ -14,6 +14,59 @@
  * limitations under the License.
  */
 
+/*
+Package gs_cond provides conditional component registration for Go-Spring framework,
+offering runtime decision-making through various condition types.
+
+1. Property Conditions
+
+  - Existence check:
+    cond := OnProperty("db.host")
+
+  - Value matching:
+    cond := OnProperty("env").HavingValue("prod")
+
+  - Expression evaluation:
+    cond := OnProperty("port").HavingValue("expr:int($) > 1024")
+
+  - Missing handling:
+    cond := OnProperty("debug").MatchIfMissing()
+
+2. Bean Conditions
+
+  - Existence verification:
+    cond := OnBean[Database]()
+
+  - Absence check:
+    cond := OnMissingBean[Logger]()
+
+  - Singleton validation:
+    cond := OnSingleBean[Config]()
+
+3. Logical Combinators
+
+  - Conjunction:
+    cond := And(condition1, condition2)
+
+  - Disjunction:
+    cond := Or(condition1, condition2)
+
+  - Negation:
+    cond := Not(condition)
+
+  - Universal negation:
+    cond := None(condition1, condition2)
+
+4. Custom Conditions
+
+  - Functional condition:
+    cond := OnFunc(func(ctx gs.CondContext) (bool, error) {
+    return time.Now().Hour() > 9, nil
+    })
+
+  - Expression condition (Pending implementation):
+    cond := OnExpression("beans('redis').size() > 0")
+*/
 package gs_cond
 
 import (

gs/internal/gs_conf/conf.go

@@ -14,6 +14,33 @@
  * limitations under the License.
  */
 
+/*
+Package gs_conf provides hierarchical configuration management
+with multi-source support for Go-Spring framework.
+
+Key Features:
+
+1. Command-line argument parsing
+  - Supports `-D key[=value]` format arguments
+  - Customizable prefix via `GS_ARGS_PREFIX` environment variable
+  - Example: `./app -D server.port=8080 -D debug`
+
+2. Environment variable handling
+  - Automatic loading of `GS_` prefixed variables
+  - Conversion rules: `GS_DB_HOST=127.0.0.1` → `db.host=127.0.0.1`
+  - Direct mapping of non-prefixed environment variables
+
+3. Configuration file management
+  - Supports properties/yaml/toml/json formats
+  - Local configurations: ./conf/app.{properties|yaml|toml|json}
+  - Remote configurations: ./conf/remote/app.{properties|yaml|toml|json}
+  - Profile-based configurations (e.g., app-dev.properties)
+
+4. Layered configuration hierarchy
+  - Priority order: System config → File config → Env variables → CLI arguments
+  - Provides AppConfig (application context) and BootConfig (boot context)
+  - High-priority configurations override lower ones
+*/
 package gs_conf
 
 import (

gs/internal/gs_dync/dync.go

@@ -14,6 +14,50 @@
  * limitations under the License.
  */
 
+/*
+Package gs_dync provides dynamic configuration binding and
+refresh capabilities for Go applications.
+
+Features:
+  - Thread-safe atomic.Value based storage with automatic type conversion
+  - Property change listeners with channel-based notifications
+  - Hierarchical configuration key resolution (supports nested structs and map keys)
+  - Live configuration updates with granular change detection
+  - JSON serialization support for configuration values
+
+Examples:
+
+Basic value binding:
+
+	var v Value[int]
+	_ = v.onRefresh(conf.Map(map[string]any{"key": 42}), conf.BindParam{Key: "key"})
+	fmt.Print(v.Value()) // Output: 42
+
+Struct binding with nested configuration:
+
+	type Config struct {
+		Server struct {
+			Port Value[int] `value:"${port}"`
+		} `value:"${server}"`
+	}
+
+	var cfg Config
+	_ = p.RefreshField(reflect.ValueOf(&cfg), conf.BindParam{Key: "config"})
+
+JSON serialization:
+
+	b, _ := json.Marshal(map[string]any{"key": &v})
+	fmt.Print(string(b)) // Output: {"key":42}
+
+Change notification:
+
+	listener := v.NewListener()
+	go func() {
+		<-listener.C
+		fmt.Print("value changed!")
+	}()
+	_ = v.onRefresh(conf.Map(map[string]any{"key": 100}), conf.BindParam{Key: "key"})
+*/
 package gs_dync
 
 import (