@jwdobeutechsolutions/dobeutech-claude-code-custom 1.0.0 → 1.0.2

package/commands/docs-arch.md

@@ -0,0 +1,55 @@
+---
+description: Generate architecture documentation and diagrams
+---
+
+# Architecture Documentation Command
+
+Generate comprehensive architecture documentation including diagrams, component descriptions, and system design.
+
+## Process
+
+1. **Analyze System Architecture**
+   - Identify components
+   - Map dependencies
+   - Document data flows
+   - Identify integration points
+
+2. **Create Architecture Diagrams**
+   - System overview diagram
+   - Component diagrams
+   - Sequence diagrams
+   - Deployment diagrams
+
+3. **Document Components**
+   - Component descriptions
+   - API contracts
+   - Data models
+   - Technology stack
+
+4. **Document Patterns and Decisions**
+   - Architectural patterns used
+   - Design decisions
+   - Trade-offs considered
+   - Future improvements
+
+5. **Generate Documentation**
+   - Architecture overview document
+   - Component documentation
+   - Diagram files (Mermaid, PlantUML, etc.)
+   - README updates
+
+## Output
+
+- Architecture documentation
+- System diagrams
+- Component documentation
+- Design decision records
+
+## Related Agents
+
+- `fullstack-architect` - Architecture specialist
+
+## Related Skills
+
+- `architecture-diagrams` - Architecture visualization patterns
+- `technical-writing` - Technical documentation patterns

package/commands/login.md

@@ -0,0 +1,82 @@
+---
+description: Authenticate with services (GitHub, MCP servers, APIs)
+---
+
+# Login & Authentication Helper
+
+This command helps you authenticate with various services used in Claude Code workflows.
+
+## Available Authentication Options
+
+Please specify what you'd like to authenticate with:
+
+1. **GitHub CLI (gh)**
+   - Repository access
+   - PR creation and management
+   - Issues and actions
+
+2. **MCP Servers**
+   - Context7 (code documentation)
+   - Tavily (web search)
+   - GitHub MCP
+   - Linear, Notion, etc.
+
+3. **Cloud Providers**
+   - AWS credentials
+   - Azure authentication
+   - GCP authentication
+
+4. **API Keys**
+   - OpenAI API
+   - Anthropic API
+   - Other service APIs
+
+## GitHub Authentication
+
+To authenticate with GitHub:
+
+```bash
+# Check if already logged in
+gh auth status
+
+# Login with browser
+gh auth login
+
+# Or use token
+gh auth login --with-token < token.txt
+```
+
+## MCP Server Configuration
+
+MCP servers are configured in `~/.claude.json`. To set up:
+
+1. Check current MCP status:
+```bash
+claude-mcp status
+```
+
+2. Add API keys to environment variables in `~/.env-mcp`:
+```bash
+export CONTEXT7_API_KEY="your_key_here"
+export TAVILY_API_KEY="your_key_here"
+export GITHUB_TOKEN="your_token_here"
+```
+
+3. Restart MCP servers:
+```bash
+claude-mcp restart
+```
+
+## Verification Steps
+
+After authentication, verify:
+
+- **GitHub**: `gh auth status`
+- **MCP**: `claude-mcp status`
+- **AWS**: `aws sts get-caller-identity`
+- **Azure**: `az account show`
+- **GCP**: `gcloud auth list`
+
+## What would you like to authenticate?
+
+Please respond with the service name (e.g., "GitHub", "MCP servers", "AWS") or ask for help with a specific authentication scenario.

package/commands/migrate-db.md

@@ -0,0 +1,53 @@
+---
+description: Plan and execute database migrations safely
+---
+
+# Database Migration Command
+
+Plan and execute safe database migrations with rollback support.
+
+## Process
+
+1. **Analyze Current Schema**
+   - Review existing database structure
+   - Identify tables, indexes, constraints
+   - Document current state
+
+2. **Design Migration**
+   - Create migration script
+   - Ensure backward compatibility
+   - Plan rollback strategy
+   - Consider data migration needs
+
+3. **Test Migration**
+   - Run on development database
+   - Verify data integrity
+   - Test rollback procedure
+   - Check performance impact
+
+4. **Execute Migration**
+   - Backup database
+   - Run migration script
+   - Verify schema changes
+   - Update application code if needed
+
+5. **Post-Migration**
+   - Verify data integrity
+   - Update documentation
+   - Monitor for issues
+   - Clean up old migrations if safe
+
+## Output
+
+- Migration script (SQL or ORM migration)
+- Rollback script
+- Data migration scripts if needed
+- Documentation of changes
+
+## Related Agents
+
+- `database-migrator` - Database migration specialist
+
+## Related Skills
+
+- `database-patterns` - Database patterns and best practices

package/commands/test-integration.md

@@ -0,0 +1,54 @@
+---
+description: Generate and run integration tests for API endpoints and services
+---
+
+# Integration Test Command
+
+Generate comprehensive integration tests for APIs, services, and database interactions.
+
+## Process
+
+1. **Identify Integration Points**
+   - API endpoints
+   - Service interactions
+   - Database operations
+   - External service calls
+
+2. **Design Test Scenarios**
+   - Happy path tests
+   - Error handling tests
+   - Edge cases
+   - Performance tests
+
+3. **Set Up Test Environment**
+   - Test database setup
+   - Mock external services
+   - Configure test fixtures
+   - Set up test data
+
+4. **Write Integration Tests**
+   - API endpoint tests
+   - Service integration tests
+   - Database integration tests
+   - End-to-end workflow tests
+
+5. **Run and Verify**
+   - Execute test suite
+   - Verify all tests pass
+   - Check coverage
+   - Document results
+
+## Output
+
+- Integration test files
+- Test fixtures and setup
+- Mock configurations
+- Test documentation
+
+## Related Agents
+
+- `integration-tester` - Integration testing specialist
+
+## Related Skills
+
+- `frontend-backend-integration` - Integration patterns

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jwdobeutechsolutions/dobeutech-claude-code-custom",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Comprehensive centralized repository of Claude Code configurations including agents, skills, commands, hooks, and MCP servers optimized for full-stack development",
   "author": "jwdobeutechsolutions",
   "license": "MIT",
@@ -41,7 +41,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/dobeutech/dobeutech-claude-code-custom.git"
+    "url": "git+https://github.com/dobeutech/dobeutech-claude-code-custom.git"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",

package/scripts/install.js

@@ -63,6 +63,17 @@ function getTargetDir() {
 
 // Get source directory (where package files are)
 function getSourceDir() {
+  // Try to resolve the package location first (most reliable for npm installs)
+  try {
+    const packageJsonPath = require.resolve('@jwdobeutechsolutions/dobeutech-claude-code-custom/package.json');
+    const packageDir = path.dirname(packageJsonPath);
+    if (fs.existsSync(path.join(packageDir, 'agents'))) {
+      return packageDir;
+    }
+  } catch (err) {
+    // Package not found via require.resolve, try other methods
+  }
+  
   // When installed via npm, files are in node_modules/@jwdobeutechsolutions/dobeutech-claude-code-custom
   // When running from source, files are in the repo root
   const possiblePaths = [
@@ -71,6 +82,15 @@ function getSourceDir() {
     path.join(process.cwd(), 'node_modules', 'dobeutech-claude-code-custom'),
   ];
   
+  // Also check global npm locations
+  const npmPrefix = process.env.npm_config_prefix || (process.platform === 'win32' 
+    ? path.join(os.homedir(), 'AppData', 'Roaming', 'npm')
+    : '/usr/local');
+  possiblePaths.push(
+    path.join(npmPrefix, 'lib', 'node_modules', '@jwdobeutechsolutions', 'dobeutech-claude-code-custom'),
+    path.join(npmPrefix, 'node_modules', '@jwdobeutechsolutions', 'dobeutech-claude-code-custom')
+  );
+  
   for (const possiblePath of possiblePaths) {
     if (fs.existsSync(path.join(possiblePath, 'agents'))) {
       return possiblePath;

package/skills/api-design-patterns.md

@@ -0,0 +1,145 @@
+---
+name: api-design-patterns
+description: API design patterns for RESTful, GraphQL, and gRPC APIs including versioning, authentication, error handling, and documentation
+---
+
+# API Design Patterns
+
+Comprehensive patterns for designing robust, scalable APIs across different protocols.
+
+## RESTful API Patterns
+
+### Resource-Based Design
+
+```typescript
+// ✅ Resource-based URLs
+GET    /api/users                 # List users
+GET    /api/users/:id             # Get user
+POST   /api/users                 # Create user
+PUT    /api/users/:id             # Replace user
+PATCH  /api/users/:id             # Update user
+DELETE /api/users/:id             # Delete user
+
+// ✅ Nested resources
+GET    /api/users/:id/posts       # User's posts
+POST   /api/users/:id/posts       # Create post for user
+```
+
+### Query Parameters
+
+```typescript
+// ✅ Filtering, sorting, pagination
+GET /api/users?status=active&sort=created_at&limit=20&offset=0
+GET /api/users?fields=id,name,email  # Field selection
+```
+
+## GraphQL Patterns
+
+### Schema Design
+
+```graphql
+type User {
+  id: ID!
+  name: String!
+  email: String!
+  posts: [Post!]!
+}
+
+type Query {
+  user(id: ID!): User
+  users(filter: UserFilter): [User!]!
+}
+
+type Mutation {
+  createUser(input: CreateUserInput!): User!
+  updateUser(id: ID!, input: UpdateUserInput!): User!
+}
+```
+
+### Resolver Patterns
+
+```typescript
+// ✅ DataLoader for N+1 query prevention
+const userLoader = new DataLoader(async (ids) => {
+  const users = await db.users.findByIds(ids);
+  return ids.map(id => users.find(u => u.id === id));
+});
+```
+
+## gRPC Patterns
+
+### Service Definition
+
+```protobuf
+service UserService {
+  rpc GetUser(GetUserRequest) returns (User);
+  rpc ListUsers(ListUsersRequest) returns (stream User);
+  rpc CreateUser(CreateUserRequest) returns (User);
+}
+```
+
+## API Versioning
+
+### URL Versioning
+
+```typescript
+// ✅ Version in URL path
+/api/v1/users
+/api/v2/users
+```
+
+### Header Versioning
+
+```typescript
+// ✅ Version in Accept header
+Accept: application/vnd.api+json;version=2
+```
+
+## Authentication Patterns
+
+### JWT Tokens
+
+```typescript
+// ✅ Stateless authentication
+Authorization: Bearer <token>
+```
+
+### API Keys
+
+```typescript
+// ✅ Key-based authentication
+X-API-Key: <api-key>
+```
+
+## Error Handling
+
+### Standardized Error Responses
+
+```typescript
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Invalid input",
+    "details": [
+      { "field": "email", "message": "Invalid email format" }
+    ]
+  }
+}
+```
+
+## Rate Limiting
+
+```typescript
+// ✅ Rate limit headers
+X-RateLimit-Limit: 1000
+X-RateLimit-Remaining: 999
+X-RateLimit-Reset: 1640995200
+```
+
+## Related Commands
+
+- `/api-design` - Generate API specifications
+
+## Related Agents
+
+- `api-designer` - API design specialist

package/skills/database-patterns.md

@@ -0,0 +1,140 @@
+---
+name: database-patterns
+description: Database design patterns, ORM usage, query optimization, migration strategies, and data modeling best practices
+---
+
+# Database Patterns
+
+Comprehensive patterns for database design, optimization, and management.
+
+## ORM Patterns
+
+### Active Record Pattern
+
+```typescript
+// ✅ Model-based operations
+const user = await User.findById(id);
+user.name = 'New Name';
+await user.save();
+```
+
+### Repository Pattern
+
+```typescript
+// ✅ Abstract data access
+class UserRepository {
+  async findById(id: string): Promise<User | null> {
+    return db.users.findOne({ where: { id } });
+  }
+  
+  async create(data: CreateUserData): Promise<User> {
+    return db.users.create(data);
+  }
+}
+```
+
+## Query Optimization
+
+### Indexing Strategy
+
+```sql
+-- ✅ Index frequently queried columns
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_posts_user_id ON posts(user_id);
+
+-- ✅ Composite indexes for multi-column queries
+CREATE INDEX idx_posts_user_status ON posts(user_id, status);
+```
+
+### Query Patterns
+
+```typescript
+// ✅ Use select to limit fields
+await db.users.findAll({
+  attributes: ['id', 'name', 'email'],
+  where: { status: 'active' }
+});
+
+// ✅ Eager loading to prevent N+1
+await db.users.findAll({
+  include: [{ model: Post, as: 'posts' }]
+});
+```
+
+## Migration Patterns
+
+### Safe Migrations
+
+```typescript
+// ✅ Additive changes first
+export async function up(queryInterface) {
+  await queryInterface.addColumn('users', 'phone', {
+    type: DataTypes.STRING,
+    allowNull: true  // Allow null initially
+  });
+}
+
+// ✅ Populate data
+export async function up(queryInterface) {
+  await queryInterface.addColumn('users', 'phone', {
+    type: DataTypes.STRING,
+    allowNull: true
+  });
+  
+  // Populate existing records
+  await queryInterface.sequelize.query(
+    `UPDATE users SET phone = '' WHERE phone IS NULL`
+  );
+  
+  // Make required
+  await queryInterface.changeColumn('users', 'phone', {
+    type: DataTypes.STRING,
+    allowNull: false
+  });
+}
+```
+
+### Rollback Strategy
+
+```typescript
+// ✅ Always provide rollback
+export async function down(queryInterface) {
+  await queryInterface.removeColumn('users', 'phone');
+}
+```
+
+## Data Modeling
+
+### Normalization
+
+```sql
+-- ✅ Normalized design
+users (id, name, email)
+posts (id, user_id, title, content)
+comments (id, post_id, user_id, content)
+```
+
+### Denormalization for Performance
+
+```sql
+-- ✅ Denormalize for read performance
+posts (id, user_id, user_name, title, content, comment_count)
+```
+
+## Transaction Patterns
+
+```typescript
+// ✅ Use transactions for atomic operations
+await db.transaction(async (t) => {
+  const user = await User.create(data, { transaction: t });
+  await Profile.create({ userId: user.id }, { transaction: t });
+});
+```
+
+## Related Commands
+
+- `/migrate-db` - Plan and execute migrations
+
+## Related Agents
+
+- `database-migrator` - Database migration specialist

package/skills/memory-management.md

@@ -0,0 +1,102 @@
+---
+name: memory-management
+description: Patterns for managing persistent memory in Claude Code using mem0 and other memory systems for context retention across sessions
+---
+
+# Memory Management Patterns
+
+Patterns for managing persistent memory and context retention in Claude Code.
+
+## mem0 Integration
+
+### Memory Storage
+
+```typescript
+// ✅ Store important context
+await mem0.store({
+  key: 'user_preferences',
+  value: {
+    language: 'TypeScript',
+    framework: 'React',
+    style: 'functional'
+  }
+});
+```
+
+### Memory Retrieval
+
+```typescript
+// ✅ Retrieve context
+const preferences = await mem0.get('user_preferences');
+```
+
+## Context Patterns
+
+### Session Context
+
+```typescript
+// ✅ Maintain session context
+const sessionContext = {
+  project: 'my-app',
+  currentFeature: 'authentication',
+  lastAction: 'created login component'
+};
+```
+
+### Project Context
+
+```typescript
+// ✅ Store project-wide context
+const projectContext = {
+  techStack: ['React', 'TypeScript', 'Node.js'],
+  patterns: ['component-based', 'functional'],
+  conventions: ['PascalCase for components']
+};
+```
+
+## Memory Strategies
+
+### Important Information
+
+Store:
+- User preferences
+- Project conventions
+- API patterns
+- Architecture decisions
+- ID mappings
+
+Don't Store:
+- Temporary status
+- Ephemeral data
+- One-time actions
+- Log entries
+
+### Memory Format
+
+```typescript
+// ✅ Descriptive memory entries
+{
+  "slack": [
+    "The main team channel has ID C1234567 and is called #general"
+  ],
+  "github": [
+    "The main repository is owned by 'teamlead' with ID 98765"
+  ]
+}
+```
+
+## Related MCP Servers
+
+- `mem0` - Memory management server
+
+## Related Agents
+
+- Any agent that needs context retention
+
+## Best Practices
+
+1. Store stable, reusable information
+2. Use descriptive memory entries
+3. Update memory when context changes
+4. Clean up outdated memories
+5. Use memory for cross-session continuity