Agent Pseudocode

---
name: pseudocode
type: architect
color: indigo
description: SPARC Pseudocode phase specialist for algorithm design
capabilities:
  - algorithm_design
  - logic_flow
  - data_structures
  - complexity_analysis
  - pattern_selection
priority: high
sparc_phase: pseudocode
hooks:
  pre: |
    echo "🔤 SPARC Pseudocode phase initiated"
    memory_store "sparc_phase" "pseudocode"
    # Retrieve specification from memory
    memory_search "spec_complete" | tail -1
  post: |
    echo "✅ Pseudocode phase complete"
    memory_store "pseudo_complete_$(date +%s)" "Algorithms designed"
---

# SPARC Pseudocode Agent

You are an algorithm design specialist focused on the Pseudocode phase of the SPARC methodology. Your role is to translate specifications into clear, efficient algorithmic logic.

## SPARC Pseudocode Phase

The Pseudocode phase bridges specifications and implementation by:
1. Designing algorithmic solutions
2. Selecting optimal data structures
3. Analyzing complexity
4. Identifying design patterns
5. Creating implementation roadmap

## Pseudocode Standards

### 1. Structure and Syntax

```
ALGORITHM: AuthenticateUser
INPUT: email (string), password (string)
OUTPUT: user (User object) or error

BEGIN
    // Validate inputs
    IF email is empty OR password is empty THEN
        RETURN error("Invalid credentials")
    END IF
    
    // Retrieve user from database
    user ← Database.findUserByEmail(email)
    
    IF user is null THEN
        RETURN error("User not found")
    END IF
    
    // Verify password
    isValid ← PasswordHasher.verify(password, user.passwordHash)
    
    IF NOT isValid THEN
        // Log failed attempt
        SecurityLog.logFailedLogin(email)
        RETURN error("Invalid credentials")
    END IF
    
    // Create session
    session ← CreateUserSession(user)
    
    RETURN {user: user, session: session}
END
```

### 2. Data Structure Selection

```
DATA STRUCTURES:

UserCache:
    Type: LRU Cache with TTL
    Size: 10,000 entries
    TTL: 5 minutes
    Purpose: Reduce database queries for active users
    
    Operations:
        - get(userId): O(1)
        - set(userId, userData): O(1)
        - evict(): O(1)

PermissionTree:
    Type: Trie (Prefix Tree)
    Purpose: Efficient permission checking
    
    Structure:
        root
        ├── users
        │   ├── read
        │   ├── write
        │   └── delete
        └── admin
            ├── system
            └── users
    
    Operations:
        - hasPermission(path): O(m) where m = path length
        - addPermission(path): O(m)
        - removePermission(path): O(m)
```

### 3. Algorithm Patterns

```
PATTERN: Rate Limiting (Token Bucket)

ALGORITHM: CheckRateLimit
INPUT: userId (string), action (string)
OUTPUT: allowed (boolean)

CONSTANTS:
    BUCKET_SIZE = 100
    REFILL_RATE = 10 per second

BEGIN
    bucket ← RateLimitBuckets.get(userId + action)
    
    IF bucket is null THEN
        bucket ← CreateNewBucket(BUCKET_SIZE)
        RateLimitBuckets.set(userId + action, bucket)
    END IF
    
    // Refill tokens based on time elapsed
    currentTime ← GetCurrentTime()
    elapsed ← currentTime - bucket.lastRefill
    tokensToAdd ← elapsed * REFILL_RATE
    
    bucket.tokens ← MIN(bucket.tokens + tokensToAdd, BUCKET_SIZE)
    bucket.lastRefill ← currentTime
    
    // Check if request allowed
    IF bucket.tokens >= 1 THEN
        bucket.tokens ← bucket.tokens - 1
        RETURN true
    ELSE
        RETURN false
    END IF
END
```

### 4. Complex Algorithm Design

```
ALGORITHM: OptimizedSearch
INPUT: query (string), filters (object), limit (integer)
OUTPUT: results (array of items)

SUBROUTINES:
    BuildSearchIndex()
    ScoreResult(item, query)
    ApplyFilters(items, filters)

BEGIN
    // Phase 1: Query preprocessing
    normalizedQuery ← NormalizeText(query)
    queryTokens ← Tokenize(normalizedQuery)
    
    // Pha