plcode-linux-x64-musl 2.1.0

package/.plcode/context/core/navigation.md

@@ -0,0 +1,69 @@
+# Core Context Navigation
+
+**Purpose**: Universal standards and workflows for all development
+
+---
+
+## Structure
+
+```
+core/
+├── navigation.md
+├── context-system.md
+├── essential-patterns.md
+│
+├── standards/
+│   ├── navigation.md
+│   ├── code-quality.md
+│   ├── test-coverage.md
+│   ├── documentation.md
+│   ├── security-patterns.md
+│   └── code-analysis.md
+│
+├── workflows/
+│   ├── navigation.md
+│   ├── code-review.md
+│   ├── task-delegation.md
+│   ├── feature-breakdown.md
+│   ├── session-management.md
+│   └── design-iteration.md
+│
+├── system/
+│   └── context-guide.md
+│
+└── context-system/
+    ├── guides/
+    ├── examples/
+    ├── standards/
+    └── operations/
+```
+
+---
+
+## Quick Routes
+
+| Task                   | Path                             |
+| ---------------------- | -------------------------------- |
+| **Write code**         | `standards/code-quality.md`      |
+| **Write tests**        | `standards/test-coverage.md`     |
+| **Write docs**         | `standards/documentation.md`     |
+| **Security patterns**  | `standards/security-patterns.md` |
+| **Review code**        | `workflows/code-review.md`       |
+| **Delegate task**      | `workflows/task-delegation.md`   |
+| **Break down feature** | `workflows/feature-breakdown.md` |
+| **Context system**     | `context-system.md`              |
+
+---
+
+## By Type
+
+**Standards** → Code quality, testing, docs, security (critical priority)
+**Workflows** → Review, delegation, task breakdown (high priority)
+**System** → Context management and guides (medium priority)
+
+---
+
+## Related Context
+
+- **Development** → `../development/navigation.md`
+- **OpenAgents Repo** → `../openagents-repo/navigation.md`

package/.plcode/context/core/standards/code-analysis.md

@@ -0,0 +1,172 @@
+<!-- Context: standards/analysis | Priority: high | Version: 2.0 | Updated: 2025-01-21 -->
+
+# Analysis Guidelines
+
+## Quick Reference
+
+**Process**: Context → Gather → Patterns → Impact → Recommendations
+
+**Report Format**: Context, Findings, Patterns, Issues (🔴🟡🔵), Recommendations, Trade-offs, Next Steps
+
+**Be**: Thorough, Objective, Specific, Actionable
+
+**Checklist**: Context stated, Evidence gathered, Patterns identified, Issues prioritized, Recommendations specific, Trade-offs considered
+
+---
+
+## Purpose
+
+Framework for analyzing code, patterns, and technical issues systematically.
+
+## When to Use
+
+Reference this when:
+
+- Analyzing codebase patterns
+- Investigating bugs or issues
+- Evaluating architectural decisions
+- Assessing code quality
+- Researching solutions
+
+## Analysis Process
+
+### 1. Understand Context
+
+- What are we analyzing and why?
+- What's the goal or question?
+- What's the scope?
+- What constraints exist?
+
+### 2. Gather Information
+
+- Read relevant code / data points
+- Check documentation
+- Search for patterns
+- Review related issues
+- Examine dependencies
+
+### 3. Identify Patterns
+
+- What's consistent across the codebase?
+- What conventions are followed?
+- What patterns are repeated?
+- What's inconsistent or unusual?
+
+### 4. Assess Impact
+
+- What are the implications?
+- What are the trade-offs?
+- What could break?
+- What are the risks?
+
+### 5. Provide Recommendations
+
+- What should be done?
+- Why this approach?
+- What are alternatives?
+- What's the priority?
+
+## Analysis Report Format
+
+```markdown
+## Analysis: {Topic}
+
+**Context:** {What we're analyzing and why}
+
+**Findings:**
+
+- {Key finding 1}
+- {Key finding 2}
+- {Key finding 3}
+
+**Patterns Observed:**
+
+- {Pattern 1}: {Description}
+- {Pattern 2}: {Description}
+
+**Issues Identified:**
+
+- 🔴 Critical: {Issue requiring immediate attention}
+- 🟡 Warning: {Issue to address soon}
+- 🔵 Suggestion: {Nice-to-have improvement}
+
+**Recommendations:**
+
+1. {Recommendation 1} - {Why}
+2. {Recommendation 2} - {Why}
+
+**Trade-offs:**
+
+- {Approach A}: {Pros/Cons}
+- {Approach B}: {Pros/Cons}
+
+**Next Steps:**
+
+- {Action 1}
+- {Action 2}
+```
+
+## Common Analysis Types
+
+### Code Quality Analysis
+
+- Complexity (cyclomatic, cognitive)
+- Duplication
+- Test coverage
+- Documentation completeness
+- Naming consistency
+- Error handling patterns
+
+### Architecture Analysis
+
+- Module dependencies
+- Coupling and cohesion
+- Separation of concerns
+- Scalability considerations
+- Performance bottlenecks
+
+### Bug Investigation
+
+- Reproduce the issue
+- Identify root cause
+- Assess impact and severity
+- Propose fix with rationale
+- Consider edge cases
+
+### Pattern Discovery
+
+- Search for similar implementations
+- Identify common approaches
+- Document conventions
+- Note inconsistencies
+- Recommend standardization
+
+## Best Practices
+
+### Be Thorough
+
+- Check multiple examples
+- Consider edge cases
+- Look for exceptions
+- Verify assumptions
+
+### Be Objective
+
+- Base conclusions on evidence
+- Avoid assumptions
+- Consider multiple perspectives
+- Acknowledge limitations
+
+### Be Specific
+
+- Provide concrete examples
+- Include file names and line numbers
+- Show code snippets
+- Quantify when possible
+
+### Be Actionable
+
+- Clear recommendations
+- Prioritize findings
+- Explain rationale
+- Suggest next steps

package/.plcode/context/core/standards/code-quality.md

@@ -0,0 +1,182 @@
+<!-- Context: standards/code | Priority: critical | Version: 2.0 | Updated: 2025-01-21 -->
+
+# Code Standards
+
+## Quick Reference
+
+**Core Philosophy**: Modular, Functional, Maintainable
+**Golden Rule**: If you can't easily test it, refactor it
+
+**Critical Patterns** (use these):
+
+- ✅ Pure functions (same input = same output, no side effects)
+- ✅ Immutability (create new data, don't modify)
+- ✅ Composition (build complex from simple)
+- ✅ Small functions (< 50 lines)
+- ✅ Explicit dependencies (dependency injection)
+
+**Anti-Patterns** (avoid these):
+
+- ❌ Mutation, side effects, deep nesting
+- ❌ God modules, global state, large functions
+
+---
+
+## Core Philosophy
+
+**Modular**: Everything is a component - small, focused, reusable
+**Functional**: Pure functions, immutability, composition over inheritance
+**Maintainable**: Self-documenting, testable, predictable
+
+## Principles
+
+### Modular Design
+
+- Single responsibility per module
+- Clear interfaces (explicit inputs/outputs)
+- Independent and composable
+- < 100 lines per component (ideally < 50)
+
+### Functional Approach
+
+- **Pure functions**: Same input = same output, no side effects
+- **Immutability**: Create new data, don't modify existing
+- **Composition**: Build complex from simple functions
+- **Declarative**: Describe what, not how
+
+### Component Structure
+
+```
+component/
+├── index.js      # Public interface
+├── core.js       # Core logic (pure functions)
+├── utils.js      # Helpers
+└── tests/        # Tests
+```
+
+## Patterns
+
+### Pure Functions
+
+```javascript
+// ✅ Pure
+const add = (a, b) => a + b
+const formatUser = (user) => ({ ...user, fullName: `${user.firstName} ${user.lastName}` })
+
+// ❌ Impure (side effects)
+let total = 0
+const addToTotal = (value) => {
+  total += value
+  return total
+}
+```
+
+### Immutability
+
+```javascript
+// ✅ Immutable
+const addItem = (items, item) => [...items, item]
+const updateUser = (user, changes) => ({ ...user, ...changes })
+
+// ❌ Mutable
+const addItem = (items, item) => {
+  items.push(item)
+  return items
+}
+```
+
+### Composition
+
+```javascript
+// ✅ Compose small functions
+const processUser = pipe(validateUser, enrichUserData, saveUser)
+const isValidEmail = (email) => validateEmail(normalizeEmail(email))
+
+// ❌ Deep inheritance
+class ExtendedUserManagerWithValidation extends UserManager {}
+```
+
+### Declarative
+
+```javascript
+// ✅ Declarative
+const activeUsers = users.filter((u) => u.isActive).map((u) => u.name)
+
+// ❌ Imperative
+const names = []
+for (let i = 0; i < users.length; i++) {
+  if (users[i].isActive) names.push(users[i].name)
+}
+```
+
+## Naming
+
+- **Files**: lowercase-with-dashes.js
+- **Functions**: verbPhrases (getUser, validateEmail)
+- **Predicates**: isValid, hasPermission, canAccess
+- **Variables**: descriptive (userCount not uc), const by default
+- **Constants**: UPPER_SNAKE_CASE
+
+## Error Handling
+
+```javascript
+// ✅ Explicit error handling
+function parseJSON(text) {
+  try {
+    return { success: true, data: JSON.parse(text) }
+  } catch (error) {
+    return { success: false, error: error.message }
+  }
+}
+
+// ✅ Validate at boundaries
+function createUser(userData) {
+  const validation = validateUserData(userData)
+  if (!validation.isValid) {
+    return { success: false, errors: validation.errors }
+  }
+  return { success: true, user: saveUser(userData) }
+}
+```
+
+## Dependency Injection
+
+```javascript
+// ✅ Dependencies explicit
+function createUserService(database, logger) {
+  return {
+    createUser: (userData) => {
+      logger.info("Creating user")
+      return database.insert("users", userData)
+    },
+  }
+}
+
+// ❌ Hidden dependencies
+import db from "./database.js"
+function createUser(userData) {
+  return db.insert("users", userData)
+}
+```
+
+## Anti-Patterns
+
+❌ **Mutation**: Modifying data in place
+❌ **Side effects**: console.log, API calls in pure functions
+❌ **Deep nesting**: Use early returns instead
+❌ **God modules**: Split into focused modules
+❌ **Global state**: Pass dependencies explicitly
+❌ **Large functions**: Keep < 50 lines
+
+## Best Practices
+
+✅ Pure functions whenever possible
+✅ Immutable data structures
+✅ Small, focused functions (< 50 lines)
+✅ Compose small functions into larger ones
+✅ Explicit dependencies (dependency injection)
+✅ Validate at boundaries
+✅ Self-documenting code
+✅ Test in isolation
+
+**Golden Rule**: If you can't easily test it, refactor it.

package/.plcode/context/core/standards/code.md

@@ -0,0 +1 @@
+code-quality.md

package/.plcode/context/core/standards/docs.md

@@ -0,0 +1 @@
+documentation.md

package/.plcode/context/core/standards/documentation.md

@@ -0,0 +1,173 @@
+<!-- Context: standards/docs | Priority: critical | Version: 2.0 | Updated: 2025-01-21 -->
+
+# Documentation Standards
+
+## Quick Reference
+
+**Golden Rule**: If users ask the same question twice, document it
+
+**Document** (✅ DO):
+
+- WHY decisions were made
+- Complex algorithms/logic
+- Public APIs, setup, common use cases
+
+**Don't Document** (❌ DON'T):
+
+- Obvious code (i++ doesn't need comment)
+- What code does (should be self-explanatory)
+
+**Principles**: Audience-focused, Show don't tell, Keep current
+
+---
+
+## Principles
+
+**Audience-focused**: Write for users (what/how), developers (why/when), contributors (setup/conventions)
+**Show, don't tell**: Code examples, real use cases, expected output
+**Keep current**: Update with code changes, remove outdated info, mark deprecations
+
+## README Structure
+
+````markdown
+# Project Name
+
+Brief description (1-2 sentences)
+
+## Features
+
+- Key feature 1
+- Key feature 2
+
+## Installation
+
+```bash
+npm install package-name
+```
+````
+
+## Quick Start
+
+```javascript
+const result = doSomething()
+```
+
+## Usage
+
+[Detailed examples]
+
+## API Reference
+
+[If applicable]
+
+## Contributing
+
+[Link to CONTRIBUTING.md]
+
+## License
+
+[License type]
+
+````
+
+## Function Documentation
+
+```javascript
+/**
+ * Calculate total price including tax
+ *
+ * @param {number} price - Base price
+ * @param {number} taxRate - Tax rate (0-1)
+ * @returns {number} Total with tax
+ *
+ * @example
+ * calculateTotal(100, 0.1) // 110
+ */
+function calculateTotal(price, taxRate) {
+  return price * (1 + taxRate);
+}
+````
+
+## What to Document
+
+### ✅ DO
+
+- **WHY** decisions were made
+- Complex algorithms/logic
+- Non-obvious behavior
+- Public APIs
+- Setup/installation
+- Common use cases
+- Known limitations
+- Workarounds (with explanation)
+
+### ❌ DON'T
+
+- Obvious code (i++ doesn't need comment)
+- What code does (should be self-explanatory)
+- Redundant information
+- Outdated/incorrect info
+
+## Comments
+
+### Good
+
+```javascript
+// Calculate discount by tier (Bronze: 5%, Silver: 10%, Gold: 15%)
+const discount = getDiscountByTier(customer.tier)
+
+// HACK: API returns null instead of [], normalize it
+const items = response.items || []
+
+// TODO: Use async/await when Node 18+ is minimum
+```
+
+### Bad
+
+```javascript
+// Increment i
+i++
+
+// Get user
+const user = getUser()
+```
+
+## API Documentation
+
+````markdown
+### POST /api/users
+
+Create a new user
+
+**Request:**
+
+```json
+{ "name": "John", "email": "john@example.com" }
+```
+````
+
+**Response:**
+
+```json
+{ "id": "123", "name": "John", "email": "john@example.com" }
+```
+
+**Errors:**
+
+- 400 - Invalid input
+- 409 - Email exists
+
+```
+
+## Best Practices
+
+✅ Explain WHY, not just WHAT
+✅ Include working examples
+✅ Show expected output
+✅ Cover error handling
+✅ Use consistent terminology
+✅ Keep structure predictable
+✅ Update when code changes
+
+**Golden Rule**: If users ask the same question twice, document it.
+```

package/.plcode/context/core/standards/navigation.md

@@ -0,0 +1,46 @@
+# Core Standards Navigation
+
+**Purpose**: Universal standards for all development work
+
+---
+
+## Files
+
+| File                   | Topic                   | Priority   | Load When                 |
+| ---------------------- | ----------------------- | ---------- | ------------------------- |
+| `code-quality.md`      | Code quality rules      | ⭐⭐⭐⭐⭐ | Writing/reviewing code    |
+| `test-coverage.md`     | Testing standards       | ⭐⭐⭐⭐⭐ | Writing tests             |
+| `documentation.md`     | Documentation rules     | ⭐⭐⭐⭐   | Writing docs              |
+| `security-patterns.md` | Security best practices | ⭐⭐⭐⭐   | Security review, patterns |
+| `code-analysis.md`     | Analysis approaches     | ⭐⭐⭐     | Analyzing code, debugging |
+
+---
+
+## Loading Strategy
+
+**For code implementation**:
+
+1. Load `code-quality.md` (critical)
+2. Load `security-patterns.md` (high)
+
+**For testing**:
+
+1. Load `test-coverage.md` (critical)
+2. Depends on: `code-quality.md`
+
+**For documentation**:
+
+1. Load `documentation.md` (critical)
+
+**For code review**:
+
+1. Load `code-quality.md` (critical)
+2. Load `security-patterns.md` (high)
+3. Load `test-coverage.md` (high)
+
+---
+
+## Related
+
+- **Workflows** → `../workflows/navigation.md`
+- **Development Principles** → `../../development/principles/`