@namch/agent-assistant 1.0.0

package/skills/fullstack-guardian/references/security-checklist.md

@@ -0,0 +1,109 @@
+# Security Checklist
+
+> Reference for: Fullstack Guardian
+> Load when: Implementing any feature
+
+## Per-Feature Security Checklist
+
+| Category | Check | Action |
+|----------|-------|--------|
+| **Auth** | Endpoint requires authentication? | Add auth middleware/guard |
+| **Authz** | User authorized for this action? | Check ownership/role |
+| **Input** | All input validated and sanitized? | Use schemas, sanitize |
+| **Output** | Sensitive data excluded from response? | Filter response fields |
+| **Rate Limit** | Endpoint rate limited? | Add rate limiter |
+| **Logging** | Security events logged? | Log auth failures, changes |
+
+## Authentication Patterns
+
+```typescript
+// NestJS Guard
+@UseGuards(JwtAuthGuard)
+@Get('profile')
+async getProfile(@CurrentUser() user: User) {
+  return this.userService.findById(user.id);
+}
+
+// Express Middleware
+app.get('/profile', authenticate, (req, res) => {
+  res.json(req.user);
+});
+```
+
+```python
+# FastAPI Dependency
+@router.get("/profile")
+async def get_profile(current_user: User = Depends(get_current_user)):
+    return current_user
+```
+
+## Authorization Patterns
+
+```typescript
+// Resource ownership check
+async updatePost(postId: string, userId: string, data: UpdatePostDto) {
+  const post = await this.postRepo.findById(postId);
+
+  if (post.authorId !== userId) {
+    throw new ForbiddenException('Not authorized to edit this post');
+  }
+
+  return this.postRepo.update(postId, data);
+}
+
+// Role-based check
+@Roles('admin')
+@UseGuards(RolesGuard)
+@Delete(':id')
+async deleteUser(@Param('id') id: string) {
+  return this.userService.delete(id);
+}
+```
+
+## Input Validation
+
+```typescript
+// Zod schema
+const CreateUserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1).max(100),
+  password: z.string().min(12),
+});
+
+// Use in endpoint
+const validated = CreateUserSchema.parse(req.body);
+```
+
+```python
+# Pydantic model
+class CreateUser(BaseModel):
+    email: EmailStr
+    name: str = Field(min_length=1, max_length=100)
+    password: str = Field(min_length=12)
+```
+
+## Rate Limiting
+
+```typescript
+// Express rate-limit
+import rateLimit from 'express-rate-limit';
+
+const authLimiter = rateLimit({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  max: 5, // 5 attempts
+  message: 'Too many login attempts',
+});
+
+app.post('/login', authLimiter, loginHandler);
+```
+
+## Quick Reference
+
+| Risk | Mitigation |
+|------|------------|
+| SQL Injection | Parameterized queries |
+| XSS | Output encoding, CSP |
+| CSRF | CSRF tokens, SameSite cookies |
+| IDOR | Authorization checks |
+| Brute Force | Rate limiting |
+| Data Exposure | Response filtering |

package/skills/game-developer/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: game-developer
+description: Use when building game systems, implementing Unity/Unreal features, or optimizing game performance. Invoke for Unity, Unreal, game patterns, ECS, physics, networking, performance optimization.
+triggers:
+  - Unity
+  - Unreal Engine
+  - game development
+  - ECS architecture
+  - game physics
+  - multiplayer networking
+  - game optimization
+  - shader programming
+  - game AI
+role: specialist
+scope: implementation
+output-format: code
+---
+
+# Game Developer
+
+Senior game developer with expertise in creating high-performance gaming experiences across Unity, Unreal, and custom engines.
+
+## Role Definition
+
+You are a senior game developer with 10+ years of experience in game engine programming, graphics optimization, and multiplayer systems. You specialize in Unity C#, Unreal C++, ECS architecture, and cross-platform optimization. You build engaging, performant games that run smoothly across all target platforms.
+
+## When to Use This Skill
+
+- Building game systems (ECS, physics, AI, networking)
+- Implementing Unity or Unreal Engine features
+- Optimizing game performance (60+ FPS targets)
+- Creating multiplayer/networking architecture
+- Developing shaders and graphics pipelines
+- Implementing game design patterns (object pooling, state machines)
+
+## Core Workflow
+
+1. **Analyze requirements** - Identify genre, platforms, performance targets, multiplayer needs
+2. **Design architecture** - Plan ECS/component systems, optimize for target platforms
+3. **Implement** - Build core mechanics, graphics, physics, AI, networking
+4. **Optimize** - Profile and optimize for 60+ FPS, minimize memory/battery usage
+5. **Test** - Cross-platform testing, performance validation, multiplayer stress tests
+
+## Reference Guide
+
+Load detailed guidance based on context:
+
+| Topic | Reference | Load When |
+|-------|-----------|-----------|
+| Unity Development | `references/unity-patterns.md` | Unity C#, MonoBehaviour, Scriptable Objects |
+| Unreal Development | `references/unreal-cpp.md` | Unreal C++, Blueprints, Actor components |
+| ECS & Patterns | `references/ecs-patterns.md` | Entity Component System, game patterns |
+| Performance | `references/performance-optimization.md` | FPS optimization, profiling, memory |
+| Networking | `references/multiplayer-networking.md` | Multiplayer, client-server, lag compensation |
+
+## Constraints
+
+### MUST DO
+- Target 60+ FPS on all platforms
+- Use object pooling for frequent instantiation
+- Implement LOD systems for optimization
+- Profile performance regularly (CPU, GPU, memory)
+- Use async loading for resources
+- Implement proper state machines for game logic
+- Cache component references (avoid GetComponent in Update)
+- Use delta time for frame-independent movement
+
+### MUST NOT DO
+- Instantiate/Destroy in tight loops or Update()
+- Skip profiling and performance testing
+- Use string comparisons for tags (use CompareTag)
+- Allocate memory in Update/FixedUpdate loops
+- Ignore platform-specific constraints (mobile, console)
+- Use Find methods in Update loops
+- Hardcode game values (use ScriptableObjects/data files)
+
+## Output Templates
+
+When implementing game features, provide:
+1. Core system implementation (ECS component, MonoBehaviour, or Actor)
+2. Associated data structures (ScriptableObjects, structs, configs)
+3. Performance considerations and optimizations
+4. Brief explanation of architecture decisions
+
+## Knowledge Reference
+
+Unity C#, Unreal C++, Entity Component System (ECS), object pooling, state machines, command pattern, observer pattern, physics optimization, shader programming (HLSL/GLSL), multiplayer networking, client-server architecture, lag compensation, client prediction, performance profiling, LOD systems, occlusion culling, draw call batching
+
+## Related Skills
+
+- **Performance Engineer** - Deep performance optimization
+- **Backend Developer** - Game server implementation
+- **Frontend Developer** - Game UI/UX implementation
+- **Mobile Developer** - Mobile game optimization

package/skills/game-developer/references/ecs-patterns.md

@@ -0,0 +1,504 @@
+# ECS Architecture and Game Patterns
+
+> Reference for: Game Developer
+> Load when: Entity Component System, game design patterns, architecture
+
+## Entity Component System (ECS)
+
+```csharp
+// Component = pure data (no logic)
+public struct PositionComponent
+{
+    public float X;
+    public float Y;
+    public float Z;
+}
+
+public struct VelocityComponent
+{
+    public float X;
+    public float Y;
+    public float Z;
+}
+
+public struct HealthComponent
+{
+    public int Current;
+    public int Max;
+}
+
+public struct PlayerTag { } // Marker component
+
+// Entity = just an ID
+public struct Entity
+{
+    public int Id;
+}
+
+// System = logic operating on components
+public class MovementSystem
+{
+    public void Update(float deltaTime,
+        Span<PositionComponent> positions,
+        Span<VelocityComponent> velocities)
+    {
+        for (int i = 0; i < positions.Length; i++)
+        {
+            positions[i].X += velocities[i].X * deltaTime;
+            positions[i].Y += velocities[i].Y * deltaTime;
+            positions[i].Z += velocities[i].Z * deltaTime;
+        }
+    }
+}
+
+// Simple ECS World
+public class World
+{
+    private int nextEntityId = 0;
+    private Dictionary<int, PositionComponent> positions = new();
+    private Dictionary<int, VelocityComponent> velocities = new();
+    private Dictionary<int, HealthComponent> healths = new();
+
+    public Entity CreateEntity()
+    {
+        return new Entity { Id = nextEntityId++ };
+    }
+
+    public void AddComponent<T>(Entity entity, T component)
+    {
+        // Store component by entity ID
+    }
+
+    public T GetComponent<T>(Entity entity)
+    {
+        // Retrieve component for entity
+        return default;
+    }
+}
+```
+
+## Object Pool Pattern
+
+```csharp
+public class ObjectPool<T> where T : class, new()
+{
+    private readonly Stack<T> pool = new();
+    private readonly Func<T> createFunc;
+    private readonly Action<T> resetAction;
+    private readonly int maxSize;
+
+    public ObjectPool(Func<T> createFunc, Action<T> resetAction, int initialSize = 10, int maxSize = 100)
+    {
+        this.createFunc = createFunc;
+        this.resetAction = resetAction;
+        this.maxSize = maxSize;
+
+        // Pre-populate pool
+        for (int i = 0; i < initialSize; i++)
+        {
+            pool.Push(createFunc());
+        }
+    }
+
+    public T Get()
+    {
+        if (pool.Count > 0)
+            return pool.Pop();
+
+        return createFunc();
+    }
+
+    public void Return(T obj)
+    {
+        if (pool.Count < maxSize)
+        {
+            resetAction?.Invoke(obj);
+            pool.Push(obj);
+        }
+    }
+}
+
+// Usage example
+public class BulletManager
+{
+    private ObjectPool<Bullet> bulletPool;
+
+    public void Initialize()
+    {
+        bulletPool = new ObjectPool<Bullet>(
+            createFunc: () => new Bullet(),
+            resetAction: (bullet) => bullet.Reset(),
+            initialSize: 50,
+            maxSize: 200
+        );
+    }
+
+    public Bullet SpawnBullet()
+    {
+        Bullet bullet = bulletPool.Get();
+        bullet.Activate();
+        return bullet;
+    }
+
+    public void ReturnBullet(Bullet bullet)
+    {
+        bullet.Deactivate();
+        bulletPool.Return(bullet);
+    }
+}
+```
+
+## State Machine Pattern
+
+```csharp
+public interface IState
+{
+    void Enter();
+    void Update(float deltaTime);
+    void Exit();
+}
+
+public class StateMachine
+{
+    private IState currentState;
+
+    public void ChangeState(IState newState)
+    {
+        currentState?.Exit();
+        currentState = newState;
+        currentState?.Enter();
+    }
+
+    public void Update(float deltaTime)
+    {
+        currentState?.Update(deltaTime);
+    }
+}
+
+// Example: Enemy AI States
+public class IdleState : IState
+{
+    private readonly EnemyController enemy;
+
+    public IdleState(EnemyController enemy) => this.enemy = enemy;
+
+    public void Enter()
+    {
+        enemy.PlayAnimation("Idle");
+    }
+
+    public void Update(float deltaTime)
+    {
+        if (enemy.PlayerInRange())
+            enemy.StateMachine.ChangeState(new ChaseState(enemy));
+    }
+
+    public void Exit() { }
+}
+
+public class ChaseState : IState
+{
+    private readonly EnemyController enemy;
+
+    public ChaseState(EnemyController enemy) => this.enemy = enemy;
+
+    public void Enter()
+    {
+        enemy.PlayAnimation("Run");
+    }
+
+    public void Update(float deltaTime)
+    {
+        if (!enemy.PlayerInRange())
+            enemy.StateMachine.ChangeState(new IdleState(enemy));
+        else if (enemy.InAttackRange())
+            enemy.StateMachine.ChangeState(new AttackState(enemy));
+        else
+            enemy.MoveTowardsPlayer(deltaTime);
+    }
+
+    public void Exit() { }
+}
+```
+
+## Command Pattern (Input Handling)
+
+```csharp
+public interface ICommand
+{
+    void Execute();
+    void Undo();
+}
+
+public class MoveCommand : ICommand
+{
+    private readonly Transform transform;
+    private readonly Vector3 movement;
+    private Vector3 previousPosition;
+
+    public MoveCommand(Transform transform, Vector3 movement)
+    {
+        this.transform = transform;
+        this.movement = movement;
+    }
+
+    public void Execute()
+    {
+        previousPosition = transform.position;
+        transform.position += movement;
+    }
+
+    public void Undo()
+    {
+        transform.position = previousPosition;
+    }
+}
+
+public class InputHandler
+{
+    private Stack<ICommand> commandHistory = new();
+
+    public void ExecuteCommand(ICommand command)
+    {
+        command.Execute();
+        commandHistory.Push(command);
+    }
+
+    public void UndoLastCommand()
+    {
+        if (commandHistory.Count > 0)
+        {
+            ICommand command = commandHistory.Pop();
+            command.Undo();
+        }
+    }
+}
+```
+
+## Observer Pattern (Event System)
+
+```csharp
+public class GameEvent<T>
+{
+    private event Action<T> listeners;
+
+    public void Subscribe(Action<T> listener)
+    {
+        listeners += listener;
+    }
+
+    public void Unsubscribe(Action<T> listener)
+    {
+        listeners -= listener;
+    }
+
+    public void Trigger(T data)
+    {
+        listeners?.Invoke(data);
+    }
+}
+
+// Event hub
+public static class GameEvents
+{
+    public static readonly GameEvent<int> OnScoreChanged = new();
+    public static readonly GameEvent<float> OnHealthChanged = new();
+    public static readonly GameEvent<string> OnGameOver = new();
+}
+
+// Subscriber
+public class UIController
+{
+    private void OnEnable()
+    {
+        GameEvents.OnScoreChanged.Subscribe(UpdateScoreDisplay);
+        GameEvents.OnHealthChanged.Subscribe(UpdateHealthBar);
+    }
+
+    private void OnDisable()
+    {
+        GameEvents.OnScoreChanged.Unsubscribe(UpdateScoreDisplay);
+        GameEvents.OnHealthChanged.Unsubscribe(UpdateHealthBar);
+    }
+
+    private void UpdateScoreDisplay(int score)
+    {
+        // Update UI
+    }
+
+    private void UpdateHealthBar(float health)
+    {
+        // Update UI
+    }
+}
+
+// Publisher
+public class Player
+{
+    public void TakeDamage(float damage)
+    {
+        health -= damage;
+        GameEvents.OnHealthChanged.Trigger(health);
+    }
+}
+```
+
+## Service Locator Pattern
+
+```csharp
+public static class ServiceLocator
+{
+    private static Dictionary<Type, object> services = new();
+
+    public static void Register<T>(T service)
+    {
+        services[typeof(T)] = service;
+    }
+
+    public static T Get<T>()
+    {
+        if (services.TryGetValue(typeof(T), out object service))
+            return (T)service;
+
+        throw new Exception($"Service {typeof(T)} not found");
+    }
+
+    public static bool TryGet<T>(out T service)
+    {
+        if (services.TryGetValue(typeof(T), out object obj))
+        {
+            service = (T)obj;
+            return true;
+        }
+
+        service = default;
+        return false;
+    }
+
+    public static void Clear()
+    {
+        services.Clear();
+    }
+}
+
+// Usage
+public class GameInitializer
+{
+    public void Initialize()
+    {
+        ServiceLocator.Register<IAudioManager>(new AudioManager());
+        ServiceLocator.Register<ISaveSystem>(new SaveSystem());
+        ServiceLocator.Register<IInputManager>(new InputManager());
+    }
+}
+
+public class Player
+{
+    private IAudioManager audioManager;
+
+    public void Start()
+    {
+        audioManager = ServiceLocator.Get<IAudioManager>();
+    }
+
+    public void PlaySound(string soundName)
+    {
+        audioManager.PlaySound(soundName);
+    }
+}
+```
+
+## Spatial Partitioning (Grid)
+
+```csharp
+public class SpatialGrid<T>
+{
+    private readonly Dictionary<(int, int), List<T>> grid = new();
+    private readonly float cellSize;
+
+    public SpatialGrid(float cellSize)
+    {
+        this.cellSize = cellSize;
+    }
+
+    private (int, int) GetCell(Vector2 position)
+    {
+        int x = Mathf.FloorToInt(position.x / cellSize);
+        int y = Mathf.FloorToInt(position.y / cellSize);
+        return (x, y);
+    }
+
+    public void Insert(Vector2 position, T item)
+    {
+        var cell = GetCell(position);
+        if (!grid.ContainsKey(cell))
+            grid[cell] = new List<T>();
+
+        grid[cell].Add(item);
+    }
+
+    public List<T> Query(Vector2 position, float radius)
+    {
+        List<T> results = new();
+        int cellRadius = Mathf.CeilToInt(radius / cellSize);
+
+        var centerCell = GetCell(position);
+
+        for (int x = -cellRadius; x <= cellRadius; x++)
+        {
+            for (int y = -cellRadius; y <= cellRadius; y++)
+            {
+                var cell = (centerCell.Item1 + x, centerCell.Item2 + y);
+                if (grid.TryGetValue(cell, out List<T> items))
+                    results.AddRange(items);
+            }
+        }
+
+        return results;
+    }
+
+    public void Clear()
+    {
+        grid.Clear();
+    }
+}
+```
+
+## Double Buffer Pattern (for Rendering/Physics)
+
+```csharp
+public class DoubleBuffer<T>
+{
+    private T[] buffers = new T[2];
+    private int currentIndex = 0;
+
+    public DoubleBuffer(T buffer1, T buffer2)
+    {
+        buffers[0] = buffer1;
+        buffers[1] = buffer2;
+    }
+
+    public T Current => buffers[currentIndex];
+    public T Next => buffers[1 - currentIndex];
+
+    public void Swap()
+    {
+        currentIndex = 1 - currentIndex;
+    }
+}
+
+// Usage for physics
+public class PhysicsSimulation
+{
+    private DoubleBuffer<PhysicsState> stateBuffer;
+
+    public void Update(float deltaTime)
+    {
+        // Read from current, write to next
+        ComputeNextState(stateBuffer.Current, stateBuffer.Next, deltaTime);
+
+        // Swap buffers
+        stateBuffer.Swap();
+    }
+}
+```