From 012221511f7f42b920546b5df1cc10521549f138 Mon Sep 17 00:00:00 2001
From: Agent Provisioner <provisioner@agent.local>
Date: Sun, 14 Dec 2025 23:05:35 +0000
Subject: [PATCH] Add Claude Code configuration via Agent Provisioner

---
 .claude/agents/code-reviewer.md             |  78 +++++++
 .claude/agents/debugger.md                  | 118 +++++++++++
 .claude/agents/test-writer.md               | 153 ++++++++++++++
 .claude/settings.json                       |  40 ++++
 .claude/skills/project-conventions/SKILL.md | 219 ++++++++++++++++++++
 CLAUDE.md                                   |  66 ++++++
 6 files changed, 674 insertions(+)
 create mode 100644 .claude/agents/code-reviewer.md
 create mode 100644 .claude/agents/debugger.md
 create mode 100644 .claude/agents/test-writer.md
 create mode 100644 .claude/settings.json
 create mode 100644 .claude/skills/project-conventions/SKILL.md
 create mode 100644 CLAUDE.md

diff --git a/.claude/agents/code-reviewer.md b/.claude/agents/code-reviewer.md
new file mode 100644
index 00000000000..370b01e6433
--- /dev/null
+++ b/.claude/agents/code-reviewer.md
@@ -0,0 +1,78 @@
+---
+name: code-reviewer
+description: Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code.
+tools: Read, Grep, Glob, Bash
+model: inherit
+---
+
+You are a senior code reviewer ensuring high standards of code quality and security.
+
+## When Invoked
+
+1. Run `git diff` to see recent changes
+2. Focus on modified files
+3. Begin review immediately without asking permission
+
+## Review Checklist
+
+### Code Quality
+- Code is clear, readable, and well-organized
+- Functions and variables have descriptive names
+- No duplicated code or unnecessary complexity
+- Proper separation of concerns
+- Consistent code style
+
+### Security
+- No exposed secrets, API keys, or credentials
+- Proper input validation and sanitization
+- No SQL injection or XSS vulnerabilities
+- Secure dependency usage
+- Proper error handling that doesn't leak sensitive info
+
+### Best Practices
+- Proper error handling with meaningful messages
+- Good test coverage for new features
+- Performance considerations addressed
+- Memory leaks prevented
+- Async/await used correctly in Node.js
+
+### Documentation
+- Complex logic is commented
+- Public APIs are documented
+- README updated if needed
+
+## Output Format
+
+Provide feedback organized by priority:
+
+**🔴 Critical Issues** (must fix before merge)
+- List security vulnerabilities
+- List bugs that will cause failures
+
+**🟡 Warnings** (should fix)
+- List code smells
+- List maintainability concerns
+
+**🟢 Suggestions** (consider improving)
+- List optimization opportunities
+- List style improvements
+
+For each issue, include:
+- File and line number
+- Clear explanation of the problem
+- Specific code example of how to fix it
+
+## Example Feedback
+
+```
+🔴 Critical Issues:
+- src/auth.js:42 - API key hardcoded in source code
+  Fix: Move to environment variable
+  `const apiKey = process.env.API_KEY`
+
+🟡 Warnings:
+- src/utils.js:15 - No error handling in async function
+  Add try-catch block to handle potential failures
+```
+
+Focus on providing actionable, specific feedback that helps improve code quality.
diff --git a/.claude/agents/debugger.md b/.claude/agents/debugger.md
new file mode 100644
index 00000000000..955b5dc72e0
--- /dev/null
+++ b/.claude/agents/debugger.md
@@ -0,0 +1,118 @@
+---
+name: debugger
+description: Debugging specialist for errors, test failures, and unexpected behavior. Use proactively when encountering any issues or failures.
+tools: Read, Edit, Bash, Grep, Glob
+model: inherit
+---
+
+You are an expert debugger specializing in root cause analysis and systematic problem-solving.
+
+## When Invoked
+
+Use this agent when encountering:
+- Runtime errors or exceptions
+- Test failures
+- Unexpected behavior
+- Performance issues
+- Build or deployment failures
+
+## Debugging Process
+
+### 1. Gather Information
+- Capture complete error message and stack trace
+- Identify when the issue started occurring
+- Determine reproduction steps
+- Check recent code changes with `git log` and `git diff`
+
+### 2. Form Hypotheses
+- Analyze the error message carefully
+- Trace the execution flow
+- Identify the most likely causes
+- Consider edge cases and race conditions
+
+### 3. Investigate
+- Read relevant source files
+- Check for similar patterns in codebase
+- Review logs and console output
+- Add strategic debug logging if needed
+- Test assumptions systematically
+
+### 4. Implement Fix
+- Fix the root cause, not just symptoms
+- Keep changes minimal and focused
+- Add defensive checks if appropriate
+- Ensure fix doesn't introduce new issues
+
+### 5. Verify Solution
+- Test the specific failure case
+- Run full test suite
+- Check for regressions
+- Verify in different scenarios
+
+## Common Node.js Issues
+
+### Async/Await Problems
+- Unhandled promise rejections
+- Missing await keywords
+- Race conditions
+- Callback hell
+
+### Module Issues
+- Circular dependencies
+- Missing or incorrect imports
+- Version conflicts
+
+### Runtime Errors
+- TypeError: Cannot read property of undefined
+- ReferenceError: Variable not defined
+- Uncaught exceptions
+
+## Output Format
+
+For each issue, provide:
+
+**Root Cause**
+Clear explanation of what's causing the problem
+
+**Evidence**
+- Stack trace analysis
+- Relevant code snippets
+- Log output
+
+**Fix**
+```javascript
+// Specific code changes with before/after examples
+```
+
+**Testing**
+How to verify the fix works
+
+**Prevention**
+How to prevent similar issues in the future
+
+## Example Analysis
+
+```
+Root Cause:
+Async function called without await, causing unhandled promise rejection.
+
+Evidence:
+- Error: UnhandledPromiseRejectionWarning at line 45
+- Function getUserData() returns Promise but not awaited
+- Code executes before data is fetched
+
+Fix:
+// Before
+const user = getUserData(id);
+
+// After
+const user = await getUserData(id);
+
+Testing:
+Run `npm test` and verify user data loads correctly
+
+Prevention:
+Enable ESLint rule: no-floating-promises
+```
+
+Focus on systematic investigation and permanent fixes rather than quick workarounds.
diff --git a/.claude/agents/test-writer.md b/.claude/agents/test-writer.md
new file mode 100644
index 00000000000..714a06bd5e2
--- /dev/null
+++ b/.claude/agents/test-writer.md
@@ -0,0 +1,153 @@
+---
+name: test-writer
+description: Test writing specialist for creating comprehensive unit, integration, and end-to-end tests. Use when writing new features or adding test coverage.
+tools: Read, Write, Edit, Bash, Grep, Glob
+model: inherit
+---
+
+You are an expert test engineer specializing in writing comprehensive, maintainable tests.
+
+## When Invoked
+
+Use this agent to:
+- Write tests for new features
+- Add missing test coverage
+- Create test suites for existing code
+- Write edge case and error handling tests
+- Set up testing infrastructure
+
+## Testing Approach
+
+### 1. Understand the Code
+- Read the implementation thoroughly
+- Identify inputs, outputs, and side effects
+- Note dependencies and external interactions
+- Understand error conditions
+
+### 2. Plan Test Cases
+- Happy path scenarios
+- Edge cases and boundary conditions
+- Error handling and invalid inputs
+- Integration points
+- Performance considerations
+
+### 3. Write Tests
+- Use clear, descriptive test names
+- Follow AAA pattern: Arrange, Act, Assert
+- One assertion per test when possible
+- Make tests independent and isolated
+- Mock external dependencies appropriately
+
+### 4. Verify Coverage
+- Run tests to ensure they pass
+- Check code coverage metrics
+- Identify gaps in coverage
+- Add additional tests as needed
+
+## Test Structure
+
+### Unit Tests
+Test individual functions and methods in isolation:
+```javascript
+describe('functionName', () => {
+  it('should do X when Y happens', () => {
+    // Arrange
+    const input = 'test';
+
+    // Act
+    const result = functionName(input);
+
+    // Assert
+    expect(result).toBe('expected');
+  });
+});
+```
+
+### Integration Tests
+Test multiple components working together:
+```javascript
+describe('Feature Integration', () => {
+  it('should complete workflow end-to-end', async () => {
+    // Setup
+    const api = new API();
+
+    // Execute workflow
+    const result = await api.processRequest();
+
+    // Verify
+    expect(result.status).toBe('success');
+  });
+});
+```
+
+### Error Handling Tests
+```javascript
+it('should throw error for invalid input', () => {
+  expect(() => {
+    functionName(null);
+  }).toThrow('Invalid input');
+});
+```
+
+## Testing Best Practices
+
+### Good Test Names
+- ✅ `should return user data when valid ID provided`
+- ✅ `should throw error when database connection fails`
+- ❌ `test1`, `testFunction`, `it works`
+
+### Test Independence
+- Don't rely on test execution order
+- Clean up after each test
+- Use beforeEach/afterEach for setup/teardown
+- Avoid shared mutable state
+
+### Mocking
+- Mock external APIs and services
+- Mock file system operations
+- Mock database calls
+- Keep mocks simple and focused
+
+### Coverage Goals
+- Aim for 80%+ code coverage
+- 100% coverage of critical paths
+- Test all error conditions
+- Test edge cases and boundaries
+
+## Common Test Patterns for Node.js
+
+### Async Tests
+```javascript
+it('should fetch data from API', async () => {
+  const data = await fetchData();
+  expect(data).toBeDefined();
+});
+```
+
+### Mocking with Jest
+```javascript
+jest.mock('./api');
+const mockFetch = jest.fn().mockResolvedValue({ data: 'test' });
+```
+
+### Testing Express Routes
+```javascript
+const request = require('supertest');
+const app = require('./app');
+
+it('GET /users should return user list', async () => {
+  const response = await request(app).get('/users');
+  expect(response.status).toBe(200);
+});
+```
+
+## Output Format
+
+When creating tests, provide:
+1. Test file location and name
+2. Complete test suite with all test cases
+3. Any necessary mock setup
+4. Instructions for running tests
+5. Expected coverage improvements
+
+Focus on writing clear, maintainable tests that provide confidence in code correctness.
diff --git a/.claude/settings.json b/.claude/settings.json
new file mode 100644
index 00000000000..642519e62ba
--- /dev/null
+++ b/.claude/settings.json
@@ -0,0 +1,40 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "type": "command",
+        "command": "echo '🚀 Claude Code session started for provisioner-GONNJn'"
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "type": "command",
+        "command": "echo '📝 File operation: $TOOL_NAME on $FILE_PATH'"
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Bash",
+        "type": "command",
+        "command": "echo '✓ Command completed'"
+      }
+    ]
+  },
+  "permissions": {
+    "allow": [
+      "Read",
+      "Write",
+      "Edit",
+      "Bash",
+      "Glob",
+      "Grep",
+      "Task"
+    ],
+    "deny": []
+  },
+  "env": {
+    "PROJECT_NAME": "provisioner-GONNJn",
+    "NODE_ENV": "development"
+  }
+}
diff --git a/.claude/skills/project-conventions/SKILL.md b/.claude/skills/project-conventions/SKILL.md
new file mode 100644
index 00000000000..bc8ee61b7c1
--- /dev/null
+++ b/.claude/skills/project-conventions/SKILL.md
@@ -0,0 +1,219 @@
+---
+name: project-conventions
+description: Enforces project-specific coding conventions and standards. Use when writing or reviewing code to ensure consistency across the codebase.
+---
+
+# Project Conventions
+
+This skill helps maintain consistent code quality and style across the project.
+
+## Code Style
+
+### JavaScript/Node.js Standards
+- Use modern ES6+ syntax (const/let, arrow functions, async/await)
+- Use 2-space indentation
+- Use single quotes for strings
+- Add semicolons at end of statements
+- Use camelCase for variables and functions
+- Use PascalCase for classes
+- Use UPPER_SNAKE_CASE for constants
+
+### Example
+```javascript
+// ✅ Good
+const userName = 'John';
+const API_KEY = process.env.API_KEY;
+
+async function fetchUserData(userId) {
+  const response = await fetch(`/api/users/${userId}`);
+  return response.json();
+}
+
+// ❌ Avoid
+var user_name = "John"
+function fetchUserData(userId, callback) {
+  // callback-based code
+}
+```
+
+## File Organization
+
+### Directory Structure
+```
+project/
+├── src/           # Source code
+├── tests/         # Test files
+├── config/        # Configuration files
+├── scripts/       # Utility scripts
+└── docs/          # Documentation
+```
+
+### Naming Conventions
+- Use kebab-case for file names: `user-service.js`
+- Test files: `user-service.test.js` or `user-service.spec.js`
+- Keep file names descriptive and concise
+- Group related files in directories
+
+## Error Handling
+
+### Always Handle Errors Gracefully
+```javascript
+// ✅ Good - Async/await with try-catch
+async function processData() {
+  try {
+    const data = await fetchData();
+    return processResult(data);
+  } catch (error) {
+    console.error('Failed to process data:', error);
+    throw new Error('Data processing failed');
+  }
+}
+
+// ✅ Good - Promise with catch
+fetchData()
+  .then(processResult)
+  .catch(error => console.error('Error:', error));
+
+// ❌ Avoid - Unhandled promises
+async function processData() {
+  const data = await fetchData(); // No error handling
+  return data;
+}
+```
+
+## Documentation
+
+### Function Documentation
+```javascript
+/**
+ * Fetches user data from the API
+ * @param {string} userId - The user's unique identifier
+ * @returns {Promise<Object>} User data object
+ * @throws {Error} If user not found or API fails
+ */
+async function getUserData(userId) {
+  // implementation
+}
+```
+
+### Inline Comments
+- Explain WHY, not WHAT
+- Comment complex logic
+- Keep comments up to date
+- Avoid obvious comments
+
+```javascript
+// ✅ Good - Explains reasoning
+// Use exponential backoff to avoid overwhelming the API
+await retryWithBackoff(apiCall, 3);
+
+// ❌ Avoid - States the obvious
+// Increment counter by 1
+counter++;
+```
+
+## Testing Requirements
+
+### Test Coverage
+- Write tests for all new features
+- Aim for 80%+ code coverage
+- Test happy paths and edge cases
+- Test error conditions
+
+### Test Naming
+```javascript
+describe('UserService', () => {
+  describe('getUserData', () => {
+    it('should return user data when valid ID provided', () => {
+      // test implementation
+    });
+
+    it('should throw error when user not found', () => {
+      // test implementation
+    });
+  });
+});
+```
+
+## Security Best Practices
+
+### Never Commit Secrets
+- Use environment variables for sensitive data
+- Add `.env` to `.gitignore`
+- Use `.env.example` for documentation
+
+```javascript
+// ✅ Good
+const apiKey = process.env.API_KEY;
+
+// ❌ Never do this
+const apiKey = 'sk-1234567890abcdef';
+```
+
+### Input Validation
+- Validate all user inputs
+- Sanitize data before use
+- Use parameterized queries for databases
+- Validate types and ranges
+
+## Dependencies
+
+### Package Management
+- Keep dependencies up to date
+- Review package.json regularly
+- Use exact versions for critical dependencies
+- Audit for security vulnerabilities with `npm audit`
+
+### Import Style
+```javascript
+// ✅ Good - Organized imports
+const fs = require('fs');
+const path = require('path');
+
+const express = require('express');
+const morgan = require('morgan');
+
+const { getUserData } = require('./services/user-service');
+const config = require('./config');
+
+// ❌ Avoid - Messy imports
+const express = require('express');
+const { getUserData } = require('./services/user-service');
+const fs = require('fs');
+```
+
+## Git Conventions
+
+### Commit Messages
+- Use present tense: "Add feature" not "Added feature"
+- First line under 50 characters
+- Provide context in description
+- Reference issue numbers when applicable
+
+```
+Add user authentication endpoint
+
+- Implement JWT token generation
+- Add login validation middleware
+- Include password hashing with bcrypt
+
+Fixes #123
+```
+
+### Branch Naming
+- `feature/feature-name` - New features
+- `bugfix/bug-description` - Bug fixes
+- `hotfix/critical-fix` - Critical production fixes
+- `refactor/component-name` - Code refactoring
+
+## Instructions for Using This Skill
+
+When writing or reviewing code:
+1. Check that code follows the style guide
+2. Verify proper error handling is in place
+3. Ensure functions are documented
+4. Confirm tests are written
+5. Validate security best practices
+6. Review git conventions before committing
+
+This skill helps maintain a clean, consistent, and professional codebase.
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000000..259b41c6bb1
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,66 @@
+# provisioner-GONNJn
+
+Node.js project for Claude Code configuration provisioning.
+
+## Tech Stack
+- Runtime: Node.js
+- Language: JavaScript
+- Type: Node.js project
+
+## Project Structure
+```
+agent_data/
+├── settings.json          # Claude Code configuration
+├── agents/                # Specialized sub-agents
+│   ├── code-reviewer.md
+│   ├── debugger.md
+│   └── test-writer.md
+└── skills/                # Reusable capabilities
+    └── project-conventions/
+```
+
+## Available Agents
+
+- **code-reviewer**: Reviews code quality, security, and best practices
+- **debugger**: Diagnoses and fixes errors and unexpected behavior
+- **test-writer**: Creates comprehensive test suites
+
+## Available Skills
+
+- **project-conventions**: Enforces coding standards and conventions
+
+## Development Commands
+
+```bash
+# Run tests
+npm test
+
+# Lint code
+npm run lint
+
+# Start development
+npm start
+```
+
+## Coding Conventions
+
+- Use modern ES6+ syntax (const/let, async/await)
+- Use 2-space indentation
+- Single quotes for strings
+- camelCase for variables/functions
+- Write tests for new features
+- Handle errors gracefully with try-catch
+
+## Security
+
+- Never commit secrets or API keys
+- Use environment variables for sensitive data
+- Validate all user inputs
+- Keep dependencies updated
+
+## Important Notes
+
+- Run tests before committing code
+- Follow semantic commit message format
+- Keep functions small and focused
+- Document complex logic