Move comprehensive documentation from extension files to Swift source

- Move overview, examples, and usage patterns from DocC extension files to Swift source files
- Keep only Topics sections in extension files for API organization
- Updated source files with comprehensive documentation:
  * Attribute.swift - Full property wrapper documentation with examples
  * Rule.swift - Complete protocol documentation with usage patterns
  * StatefulRule.swift - Detailed stateful rule documentation
  * WeakAttribute.swift - Comprehensive weak reference documentation
  * Focus.swift - Complete KeyPath-based focusing documentation

- Simplified extension files to contain only Topics sections:
  * Attribute.md - Topics organization only
  * Rule.md - Topics organization only
  * StatefulRule.md - Topics organization only
  * WeakAttribute.md - Topics organization only
  * Focus.md - Topics organization only

This provides comprehensive in-source documentation while maintaining
clean Topics-based API organization in extension files.

Author: Kyle-Ye

Sources/OpenAttributeGraph/Attribute/Attribute/Attribute.swift

@@ -1,6 +1,58 @@
 public import OpenAttributeGraphCxx
 
 /// A reactive property wrapper that automatically tracks dependencies and manages value updates.
+///
+/// `Attribute` is the core building block of the OpenAttributeGraph reactive system. When you wrap a property with `@Attribute`, it becomes reactive and can automatically track dependencies and propagate changes.
+///
+///     @Attribute var count: Int = 0
+///     @Attribute var doubledCount: Int = count * 2
+///     
+///     count = 5 // doubledCount automatically becomes 10
+///
+/// ## Key Features
+///
+/// - Automatic dependency tracking: Attributes automatically discover their dependencies
+/// - Efficient updates: Only affected attributes are recomputed when changes occur
+/// - Type safety: Full Swift type safety with compile-time checking
+/// - Dynamic member lookup: Access nested properties as reactive attributes
+/// - Property wrapper syntax: Clean, declarative syntax using `@Attribute`
+///
+/// ## Property Wrapper Usage
+///
+/// Use `@Attribute` to make any Swift value reactive:
+///
+///     struct CounterView {
+///         @Attribute var count: Int = 0
+///         
+///         var body: some View {
+///             Button("Count: \(count)") {
+///                 count += 1
+///             }
+///         }
+///     }
+///
+/// ## Dynamic Member Lookup
+///
+/// Access nested properties as separate attributes:
+///
+///     @Attribute var person: Person = Person(name: "Alice", age: 30)
+///     let nameAttribute: Attribute<String> = person.name
+///     let ageAttribute: Attribute<Int> = person.age
+///
+/// ## Integration with Rules
+///
+/// Create computed attributes using ``Rule`` or ``StatefulRule``:
+///
+///     struct DoubledRule: Rule {
+///         typealias Value = Int
+///         let source: Attribute<Int>
+///         
+///         func value() -> Int {
+///             source.wrappedValue * 2
+///         }
+///     }
+///
+///     let doubled = Attribute(DoubledRule(source: count))
 @frozen
 @propertyWrapper
 @dynamicMemberLookup

Sources/OpenAttributeGraph/Attribute/Rule/Focus.swift

@@ -6,6 +6,34 @@
 //  Status: Complete
 
 /// A rule that focuses on a specific property of another attribute using KeyPath.
+///
+/// `Focus` provides a way to create attributes that automatically track a specific property of another attribute. It uses Swift's KeyPath system to create a focused view of part of a larger data structure.
+///
+///     struct Person {
+///         let name: String
+///         let age: Int
+///     }
+///
+///     @Attribute var person = Person(name: "Alice", age: 30)
+///     let nameAttribute = Attribute(Focus(root: $person, keyPath: \.name))
+///     // nameAttribute automatically updates when person.name changes
+///
+/// Focus is commonly used internally by OpenAttributeGraph's dynamic member lookup system to create property-specific attributes.
+///
+/// ## Key Features
+///
+/// - KeyPath-based focusing: Use any Swift KeyPath to focus on specific properties
+/// - Automatic updates: Changes to the focused property automatically propagate
+/// - Type safety: Full compile-time type checking for focused properties
+/// - Efficient tracking: Only tracks changes to the specific focused property
+///
+/// ## Usage Pattern
+///
+/// Focus is ideal for:
+/// - Creating focused views of complex data structures
+/// - Implementing dynamic member lookup for attributes
+/// - Breaking down large objects into smaller, more manageable attribute pieces
+/// - Selective observation of specific properties
 @frozen
 public struct Focus<Root, Value>: Rule, CustomStringConvertible {
     public var root: Attribute<Root>

Sources/OpenAttributeGraph/Attribute/Rule/Rule.swift

@@ -8,6 +8,44 @@
 public import OpenAttributeGraphCxx
 
 /// A protocol for defining computed attributes that automatically update when dependencies change.
+///
+/// Rules provide a way to create derived attributes that compute their values based on other attributes.
+/// When any dependency changes, the rule will automatically recompute its value.
+///
+///     struct DoubledRule: Rule {
+///         typealias Value = Int
+///         let source: Attribute<Int>
+///         
+///         var value: Int {
+///             source.wrappedValue * 2
+///         }
+///     }
+///
+///     @Attribute var count: Int = 5
+///     let doubled = Attribute(DoubledRule(source: $count))
+///     // doubled.wrappedValue == 10
+///
+///     count = 10
+///     // doubled.wrappedValue automatically becomes 20
+///
+/// ## Key Features
+///
+/// - Automatic dependency tracking: Dependencies are discovered automatically when accessed
+/// - Lazy evaluation: Values are only computed when needed
+/// - Caching: Results are cached until dependencies change
+/// - Efficient updates: Only recomputes when dependencies actually change
+///
+/// ## Implementation Requirements
+///
+/// Types conforming to `Rule` must provide:
+/// - `Value`: The type of value produced by the rule
+/// - `value`: A computed property that returns the current value
+/// - `initialValue`: An optional initial value (defaults to `nil`)
+///
+/// ## Advanced Usage
+///
+/// For rules that need to maintain state between evaluations, see ``StatefulRule``.
+/// For rules that can be cached based on their content, make your rule type conform to `Hashable`.
 public protocol Rule: _AttributeBody {
     /// The type of value produced by this rule.
     associatedtype Value

Sources/OpenAttributeGraph/Attribute/Rule/StatefulRule.swift

@@ -8,6 +8,35 @@
 public import OpenAttributeGraphCxx
 
 /// A protocol for defining computed attributes that maintain state between evaluations.
+///
+/// `StatefulRule` extends the basic `Rule` concept by allowing rules to maintain mutable state between updates. This is useful for rules that need to track changes over time or maintain internal state.
+///
+///     struct CounterRule: StatefulRule {
+///         typealias Value = Int
+///         private var counter = 0
+///         
+///         mutating func updateValue() {
+///             counter += 1
+///             value = counter
+///         }
+///     }
+///
+/// Unlike ``Rule``, `StatefulRule` allows mutation through the `updateValue()` method and provides direct access to the current value through the `value` property.
+///
+/// ## Key Features
+///
+/// - Mutable state: Rules can maintain and modify internal state
+/// - Direct value access: Read and write the current value directly
+/// - Context access: Access to rule evaluation context and attribute
+/// - Lifecycle control: Manual control over when and how values update
+///
+/// ## Usage Pattern
+///
+/// StatefulRule is ideal for scenarios where you need to:
+/// - Accumulate values over time
+/// - Maintain counters or timers
+/// - Implement complex state machines
+/// - Cache expensive computations with custom invalidation
 public protocol StatefulRule: _AttributeBody {
     associatedtype Value
     static var initialValue: Value? { get }

Sources/OpenAttributeGraph/Attribute/Weak/WeakAttribute.swift

@@ -8,6 +8,32 @@
 public import OpenAttributeGraphCxx
 
 /// A weak reference property wrapper for attributes that prevents retain cycles.
+///
+/// `WeakAttribute` provides a way to hold weak references to attributes, preventing strong reference cycles in the attribute graph while still allowing access to reactive values.
+///
+///     @WeakAttribute var parentAttribute: SomeType?
+///     
+///     // Safe access to potentially deallocated attribute
+///     if let value = parentAttribute {
+///         print("Parent value: \(value)")
+///     }
+///
+/// The weak attribute automatically becomes `nil` when the referenced attribute is deallocated, providing memory-safe access to optional attribute references.
+///
+/// ## Key Features
+///
+/// - Weak references: Prevents retain cycles in attribute relationships
+/// - Automatic nil assignment: Referenced attributes become nil when deallocated  
+/// - Dynamic member lookup: Access nested properties through weak references
+/// - Optional semantics: All values are optional since references may be deallocated
+///
+/// ## Usage Pattern
+///
+/// WeakAttribute is essential for:
+/// - Parent-child attribute relationships
+/// - Observer patterns that don't own the observed attribute
+/// - Breaking potential retain cycles in complex attribute graphs
+/// - Optional attribute references in data structures
 @frozen
 @propertyWrapper
 @dynamicMemberLookup

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Attribute/Attribute/Attribute.md

@@ -1,61 +1,5 @@
 # ``Attribute``
 
-A reactive property wrapper that automatically tracks dependencies and manages value updates.
-
-## Overview
-
-`Attribute` is the core building block of the OpenAttributeGraph reactive system. When you wrap a property with `@Attribute`, it becomes reactive and can automatically track dependencies and propagate changes.
-
-    @Attribute var count: Int = 0
-    @Attribute var doubledCount: Int = count * 2
-    
-    count = 5 // doubledCount automatically becomes 10
-
-## Key Features
-
-- Automatic dependency tracking: Attributes automatically discover their dependencies
-- Efficient updates: Only affected attributes are recomputed when changes occur
-- Type safety: Full Swift type safety with compile-time checking
-- Dynamic member lookup: Access nested properties as reactive attributes
-- Property wrapper syntax: Clean, declarative syntax using `@Attribute`
-
-## Property Wrapper Usage
-
-Use `@Attribute` to make any Swift value reactive:
-
-    struct CounterView {
-        @Attribute var count: Int = 0
-        
-        var body: some View {
-            Button("Count: \(count)") {
-                count += 1
-            }
-        }
-    }
-
-## Dynamic Member Lookup
-
-Access nested properties as separate attributes:
-
-    @Attribute var person: Person = Person(name: "Alice", age: 30)
-    let nameAttribute: Attribute<String> = person.name
-    let ageAttribute: Attribute<Int> = person.age
-
-## Integration with Rules
-
-Create computed attributes using ``Rule`` or ``StatefulRule``:
-
-    struct DoubledRule: Rule {
-        typealias Value = Int
-        let source: Attribute<Int>
-        
-        func value() -> Int {
-            source.wrappedValue * 2
-        }
-    }
-
-    let doubled = Attribute(DoubledRule(source: count))
-
 ## Topics
 
 ### Creating Attributes

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Attribute/Rule/Focus.md

@@ -1,35 +1,5 @@
 # ``Focus``
 
-## Overview
-
-`Focus` provides a way to create attributes that automatically track a specific property of another attribute. It uses Swift's KeyPath system to create a focused view of part of a larger data structure.
-
-    struct Person {
-        let name: String
-        let age: Int
-    }
-
-    @Attribute var person = Person(name: "Alice", age: 30)
-    let nameAttribute = Attribute(Focus(root: $person, keyPath: \.name))
-    // nameAttribute automatically updates when person.name changes
-
-Focus is commonly used internally by OpenAttributeGraph's dynamic member lookup system to create property-specific attributes.
-
-## Key Features
-
-- KeyPath-based focusing: Use any Swift KeyPath to focus on specific properties
-- Automatic updates: Changes to the focused property automatically propagate
-- Type safety: Full compile-time type checking for focused properties
-- Efficient tracking: Only tracks changes to the specific focused property
-
-## Usage Pattern
-
-Focus is ideal for:
-- Creating focused views of complex data structures
-- Implementing dynamic member lookup for attributes
-- Breaking down large objects into smaller, more manageable attribute pieces
-- Selective observation of specific properties
-
 ## Topics
 
 ### Creating Focus Rules

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Attribute/Rule/Rule.md

@@ -1,46 +1,5 @@
 # ``Rule``
 
-A protocol for defining computed attributes that automatically update when dependencies change.
-
-## Overview
-
-Rules provide a way to create derived attributes that compute their values based on other attributes. When any dependency changes, the rule will automatically recompute its value.
-
-    struct DoubledRule: Rule {
-        typealias Value = Int
-        let source: Attribute<Int>
-        
-        var value: Int {
-            source.wrappedValue * 2
-        }
-    }
-
-    @Attribute var count: Int = 5
-    let doubled = Attribute(DoubledRule(source: $count))
-    // doubled.wrappedValue == 10
-
-    count = 10
-    // doubled.wrappedValue automatically becomes 20
-
-## Key Features
-
-- Automatic dependency tracking: Dependencies are discovered automatically when accessed
-- Lazy evaluation: Values are only computed when needed
-- Caching: Results are cached until dependencies change
-- Efficient updates: Only recomputes when dependencies actually change
-
-## Implementation Requirements
-
-Types conforming to `Rule` must provide:
-- `Value`: The type of value produced by the rule
-- `value`: A computed property that returns the current value
-- `initialValue`: An optional initial value (defaults to `nil`)
-
-## Advanced Usage
-
-For rules that need to maintain state between evaluations, see ``StatefulRule``.
-For rules that can be cached based on their content, make your rule type conform to `Hashable`.
-
 ## Topics
 
 ### Protocol Requirements

Sources/OpenAttributeGraph/OpenAttributeGraph.docc/Attribute/Rule/StatefulRule.md

@@ -1,38 +1,5 @@
 # ``StatefulRule``
 
-A protocol for defining computed attributes that maintain state between evaluations.
-
-## Overview
-
-`StatefulRule` extends the basic `Rule` concept by allowing rules to maintain mutable state between updates. This is useful for rules that need to track changes over time or maintain internal state.
-
-    struct CounterRule: StatefulRule {
-        typealias Value = Int
-        private var counter = 0
-        
-        mutating func updateValue() {
-            counter += 1
-            value = counter
-        }
-    }
-
-Unlike ``Rule``, `StatefulRule` allows mutation through the `updateValue()` method and provides direct access to the current value through the `value` property.
-
-## Key Features
-
-- Mutable state: Rules can maintain and modify internal state
-- Direct value access: Read and write the current value directly
-- Context access: Access to rule evaluation context and attribute
-- Lifecycle control: Manual control over when and how values update
-
-## Usage Pattern
-
-StatefulRule is ideal for scenarios where you need to:
-- Accumulate values over time
-- Maintain counters or timers
-- Implement complex state machines
-- Cache expensive computations with custom invalidation
-
 ## Topics
 
 ### Protocol Requirements