codingbuddy-rules 0.0.0-canary.20251222065027.7844cd5

package/.ai-rules/rules/project.md

@@ -0,0 +1,200 @@
+# Project Setup
+
+## Project Overview
+
+Define per project. This file is a universal AI rules template.
+
+## Tech Stack
+
+Refer to the project's `package.json`. AI rules do not pin specific package versions.
+
+## Project Structure
+
+Define per project. Below is a layered architecture example:
+
+```
+src/
+├── app/                    # Entry point / Router
+│   ├── api/               # API Routes
+│   ├── (pages)/           # Page routing
+│   ├── layout.tsx         # Root layout
+│   └── globals.css        # Global styles
+│
+├── entities/              # Domain entities (business logic)
+│   └── {domain}/
+│       ├── apis/          # API call functions (*.ts)
+│       ├── models/        # Data models / hooks (*.ts, *.tsx)
+│       ├── types.ts       # Type definitions
+│       └── index.ts       # Public API
+│
+├── features/              # Feature-specific UI components
+│   └── {Feature}/
+│       ├── {Feature}.tsx          # Main component
+│       ├── {Feature}.parts.tsx    # Sub-components
+│       ├── {Feature}.types.ts     # Type definitions
+│       ├── {Feature}.constants.ts # Constants
+│       ├── {Feature}.unit.spec.tsx # Unit tests
+│       └── index.ts               # Export
+│
+├── widgets/               # Composite widgets (multiple features combined)
+│   └── {Widget}/
+│       ├── {Widget}.tsx           # Main widget
+│       ├── {Widget}.parts.tsx     # Sub-components
+│       └── index.ts
+│
+└── shared/                # Common modules (used across the project)
+    ├── components/        # Reusable UI components
+    ├── hooks/            # Custom hooks
+    ├── providers/        # Context providers / State management
+    ├── utils/            # Utility functions
+    ├── types/            # Common type definitions
+    ├── constants/        # Common constants
+    ├── api/              # API client, error handlers
+    ├── auth/             # Authentication logic
+    └── services/         # Business services
+```
+
+## Development Rules
+
+### 1. Code Writing Rules
+
+#### Core Principles
+- **Never use mocking**: Write only real, working code
+- **Type Safety**: Follow strict type checking mode
+- **Latest Framework Features**: Utilize latest framework capabilities
+- **Component Naming**: PascalCase, use clear names that indicate functionality
+- **Type imports**: Use named imports for types (e.g., `import { type SomeType } from 'module';`)
+
+#### File Naming Convention
+- **Component**: `{Feature}.tsx`
+- **Sub-components**: `{Feature}.parts.tsx`
+- **Types**: `{Feature}.types.ts` or `types.ts`
+- **Constants**: `{Feature}.constants.ts` or `constants.ts`
+- **Utils**: `{Feature}.utils.ts`
+- **Unit Tests**: `{Feature}.unit.spec.tsx` or `{Feature}.test.ts`
+- **E2E Tests**: `{Feature}.e2e.ts` or `{Feature}.cy.ts`
+- **Module Export**: `index.ts`
+
+#### Import/Export Rules
+- Each module exports only public API through `index.ts`
+- Use absolute paths configured in the project (e.g., `@/`, `~/`)
+- Layer dependency direction: `app → widgets → features → entities → shared`
+
+### 2. Pure vs Impure Function Separation
+
+- **Always separate pure and impure functions into different files**
+- **Pure functions**: `*.utils.ts`, `*.helpers.ts`
+- **Impure functions**: `*.api.ts`, `*.service.ts`, `*.models.ts`
+
+Example:
+```typescript
+// ✅ Good: Separated
+// validation.utils.ts - Pure function
+export const validateEmail = (email: string) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+
+// user.api.ts - Impure function
+export const createUser = async (data: UserData) => { /* API call */ };
+
+// ❌ Bad: Mixed
+// user.ts - Mixed together
+export const validateEmail = (email: string) => { /* ... */ };
+export const createUser = async (data: UserData) => { /* ... */ };
+```
+
+### 3. Script Commands
+
+Refer to the project's `package.json` scripts section. Common commands:
+
+```bash
+# Development
+yarn dev          # Start dev server
+yarn build        # Production build
+yarn start        # Start production server
+
+# Code Quality
+yarn lint         # Linting check
+yarn format       # Code formatting
+
+# Testing
+yarn test         # Run tests
+yarn test:coverage # Run tests with coverage
+```
+
+Actual commands may vary per project. Check the project's package.json.
+
+## Development Workflow
+
+For detailed TDD workflows, testing strategies, and code quality practices, refer to **`augmented-coding.md`**.
+
+### Quick Reference
+
+**Development approach:**
+- Core logic (entities, shared/utils, hooks): TDD (test-first)
+- UI components (features, widgets): Test-after
+- Coverage goal: 90%+
+
+### Code Review Checklist
+
+#### Required Checks
+- [ ] **TypeScript Type Safety**: No `any` usage, all types explicitly defined
+- [ ] **Test Coverage**: Maintain 90%+ coverage
+- [ ] **Linting Rules**: Resolve all linting errors
+- [ ] **Pure/Impure Separation**: Separate files for pure and impure functions
+
+#### Architecture & Design
+- [ ] **Layer Architecture**: Respect layer boundaries and separation of concerns
+- [ ] **Dependency Direction**: app → widgets → features → entities → shared
+- [ ] **Component Reusability**: DRY principle, utilize shared components
+- [ ] **Code quality**: See `augmented-coding.md` for SOLID, TDD, and refactoring standards
+
+#### Performance & Optimization
+- [ ] **Framework Optimization**: Proper use of framework-specific optimization techniques
+- [ ] **Image Optimization**: Use framework's Image component
+- [ ] **Bundle Size**: Code splitting with dynamic imports
+- [ ] **Rendering Optimization**: Prevent unnecessary re-renders
+
+#### UX & Accessibility
+- [ ] **Responsive Design**: Support mobile/tablet/desktop
+- [ ] **Accessibility (a11y)**: ARIA attributes, keyboard navigation
+- [ ] **Loading States**: Provide loading UI (Skeleton, Spinner, etc.)
+- [ ] **Error Handling**: Utilize error boundaries
+
+## Important Guidelines
+
+### 1. Never Do ❌
+
+- **Mock data or fake implementations**: Only real API integration allowed
+- **Type `any` usage**: Explicitly define all types
+- **Direct DOM manipulation**: Use framework patterns
+- **Leave console.log in production code**: Development only
+- **Mix pure/impure functions**: Must separate into different files
+- **Reverse layer dependencies**: Lower layers cannot import upper layers
+
+### 2. Must Do ✅
+
+- **Write code with real API calls** (no mocking)
+- **Design reusable components**
+- **Consider accessibility (a11y)**
+- **Apply performance optimizations**
+- **Utilize error boundaries**
+- **Follow augmented coding practices** (see `augmented-coding.md`)
+
+### 3. Problem-Solving Priority
+
+1. **Find real working solutions** (no mocking)
+2. **Maintain consistency after analyzing existing code patterns**
+3. **Ensure type safety**
+4. **Consider performance impact**
+
+### 4. Design System Usage
+
+Refer to the project's design system documentation. General guidelines:
+- Prioritize project design system components
+- Use className composition utilities as defined in project
+- Maintain design token consistency
+- Follow typography patterns
+- Respect responsive breakpoints
+
+---
+
+This guide helps AI assistants understand the project and generate consistent code.

package/.ai-rules/schemas/README.md

@@ -0,0 +1,66 @@
+# Codingbuddy Schemas
+
+This directory contains JSON schemas for validating AI rule files.
+
+## Available Schemas
+
+### agent.schema.json
+
+Validates agent definition files in `.ai-rules/agents/`.
+
+**Required Fields:**
+- `name` - Agent display name
+- `description` - Brief description of expertise
+- `role` - Role definition with title and expertise
+- `context_files` - List of context files to load
+
+**Agent Types:**
+
+| Type | Key Field | Examples |
+|------|-----------|----------|
+| Developer | `activation` | frontend-developer, backend-developer |
+| Reviewer | `activation` | code-reviewer |
+| Specialist | `modes` | security-specialist, performance-specialist |
+| Other | Neither | devops-engineer |
+
+## Usage
+
+### VS Code Integration
+
+Schemas are automatically applied in VS Code via `.vscode/settings.json`:
+
+```json
+{
+  "json.schemas": [
+    {
+      "fileMatch": [".ai-rules/agents/*.json"],
+      "url": "./.ai-rules/schemas/agent.schema.json"
+    }
+  ]
+}
+```
+
+### CLI Validation
+
+```bash
+# Validate all agent files
+yarn validate:rules
+
+# Validate schema only
+yarn validate:rules:schema
+```
+
+### Manual Validation with ajv
+
+```bash
+npx ajv validate -s .ai-rules/schemas/agent.schema.json -d ".ai-rules/agents/*.json"
+```
+
+## Schema Development
+
+When modifying the schema:
+
+1. Update `agent.schema.json`
+2. Run validation against all existing files
+3. Fix any breaking changes or adjust schema
+4. Update this README if needed

package/.ai-rules/schemas/agent.schema.json

@@ -0,0 +1,258 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://codingbuddy.dev/schemas/agent.schema.json",
+  "title": "Codingbuddy Agent Definition",
+  "description": "Schema for AI agent definition files in .ai-rules/agents/",
+  "type": "object",
+  "required": ["name", "description", "role", "context_files"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Display name of the agent",
+      "minLength": 1,
+      "examples": ["Frontend Developer", "Code Reviewer", "Security Specialist"]
+    },
+    "description": {
+      "type": "string",
+      "description": "Brief description of the agent's purpose and expertise",
+      "minLength": 10
+    },
+    "role": {
+      "type": "object",
+      "description": "Agent's role definition including title, expertise, and responsibilities",
+      "required": ["title"],
+      "properties": {
+        "title": {
+          "type": "string",
+          "description": "Official role title",
+          "minLength": 1
+        },
+        "expertise": {
+          "type": "array",
+          "description": "List of expertise areas",
+          "items": { "type": "string" },
+          "minItems": 1
+        },
+        "responsibilities": {
+          "type": "array",
+          "description": "List of responsibilities",
+          "items": { "type": "string" }
+        },
+        "tech_stack_reference": {
+          "type": "string",
+          "description": "Reference to tech stack documentation"
+        }
+      },
+      "additionalProperties": true
+    },
+    "context_files": {
+      "type": "array",
+      "description": "List of context files to load for this agent",
+      "items": {
+        "type": "string",
+        "pattern": "^\\.ai-rules/.*"
+      },
+      "minItems": 1,
+      "examples": [[".ai-rules/rules/core.md", ".ai-rules/rules/project.md"]]
+    },
+    "activation": {
+      "type": "object",
+      "description": "Activation configuration for developer/reviewer agents",
+      "properties": {
+        "trigger": {
+          "type": "string",
+          "description": "Condition that triggers this agent"
+        },
+        "rule": {
+          "type": "string",
+          "description": "Strict rule for activation"
+        },
+        "mandatory_checklist": {
+          "type": "object",
+          "description": "Checklist items that must be followed",
+          "additionalProperties": true
+        },
+        "verification_guide": {
+          "type": "object",
+          "description": "Guide for verifying checklist items",
+          "additionalProperties": { "type": "string" }
+        },
+        "execution_order": {
+          "type": "object",
+          "description": "Order of execution for different modes",
+          "additionalProperties": {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        },
+        "workflow_integration": {
+          "type": "object",
+          "description": "How this agent integrates with workflow"
+        },
+        "planning_framework": {
+          "type": "object",
+          "description": "Framework for planning mode"
+        },
+        "implementation_framework": {
+          "type": "object",
+          "description": "Framework for implementation mode"
+        }
+      },
+      "additionalProperties": true
+    },
+    "modes": {
+      "type": "object",
+      "description": "Mode-specific configuration for specialist agents",
+      "properties": {
+        "planning": {
+          "type": "object",
+          "description": "Planning mode configuration"
+        },
+        "implementation": {
+          "type": "object",
+          "description": "Implementation mode configuration"
+        },
+        "evaluation": {
+          "type": "object",
+          "description": "Evaluation mode configuration"
+        }
+      },
+      "additionalProperties": true
+    },
+    "workflow": {
+      "type": "object",
+      "description": "Workflow configuration",
+      "additionalProperties": true
+    },
+    "development_philosophy": {
+      "type": "object",
+      "description": "Development philosophy and approach",
+      "additionalProperties": true
+    },
+    "code_quality_checklist": {
+      "type": "array",
+      "description": "Code quality checklist items",
+      "items": { "type": "string" }
+    },
+    "tdd_cycle": {
+      "type": "object",
+      "description": "TDD cycle configuration",
+      "additionalProperties": true
+    },
+    "ai_monitoring": {
+      "type": "object",
+      "description": "AI behavior monitoring configuration",
+      "additionalProperties": true
+    },
+    "commit_rules": {
+      "type": "object",
+      "description": "Commit rules and discipline",
+      "additionalProperties": true
+    },
+    "design_system": {
+      "type": "object",
+      "description": "Design system configuration",
+      "additionalProperties": true
+    },
+    "communication": {
+      "type": "object",
+      "description": "Communication preferences",
+      "properties": {
+        "language": {
+          "type": "string",
+          "description": "Response language preference"
+        },
+        "approach": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "reference_style": {
+          "type": "string"
+        },
+        "emphasis": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": true
+    },
+    "file_naming": {
+      "type": "object",
+      "description": "File naming conventions",
+      "additionalProperties": true
+    },
+    "reference": {
+      "type": "object",
+      "description": "Reference links and documentation",
+      "additionalProperties": true
+    },
+    "shared_framework": {
+      "type": "object",
+      "description": "Shared framework configuration for specialist agents",
+      "additionalProperties": true
+    },
+    "persona": {
+      "type": "object",
+      "description": "Agent persona configuration",
+      "additionalProperties": true
+    },
+    "evaluation_framework": {
+      "type": "object",
+      "description": "Evaluation framework for reviewer agents",
+      "additionalProperties": true
+    },
+    "evaluation_output_format": {
+      "type": "object",
+      "description": "Output format for evaluations",
+      "additionalProperties": true
+    },
+    "evaluation_checklist": {
+      "type": "object",
+      "description": "Evaluation checklist",
+      "additionalProperties": true
+    },
+    "improvement_prioritization": {
+      "type": "object",
+      "description": "Improvement prioritization rules",
+      "additionalProperties": true
+    },
+    "workflow_integration": {
+      "type": "object",
+      "description": "Workflow integration configuration",
+      "additionalProperties": true
+    },
+    "research_requirements": {
+      "type": "object",
+      "description": "Research requirements for evidence-based recommendations",
+      "additionalProperties": true
+    },
+    "quality_gates": {
+      "type": "object",
+      "description": "Quality gate definitions",
+      "additionalProperties": true
+    },
+    "infrastructure": {
+      "type": "object",
+      "description": "Infrastructure configuration (DevOps)",
+      "additionalProperties": true
+    },
+    "best_practices": {
+      "type": "object",
+      "description": "Best practices guidelines",
+      "additionalProperties": true
+    },
+    "checklist": {
+      "oneOf": [
+        {
+          "type": "object",
+          "additionalProperties": true
+        },
+        {
+          "type": "array",
+          "items": { "type": "string" }
+        }
+      ],
+      "description": "General checklist (can be object or array)"
+    }
+  },
+  "additionalProperties": true
+}

package/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Path to the .ai-rules directory
+ */
+export const rulesPath: string;

package/index.js

@@ -0,0 +1,8 @@
+const path = require('path');
+
+/**
+ * Path to the .ai-rules directory
+ */
+const rulesPath = path.resolve(__dirname, '.ai-rules');
+
+module.exports = { rulesPath };

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "codingbuddy-rules",
+  "version": "0.0.0-canary.20251222065027.7844cd5",
+  "description": "AI coding rules for consistent practices across AI assistants",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    ".ai-rules"
+  ],
+  "keywords": [
+    "ai",
+    "coding",
+    "rules",
+    "claude",
+    "cursor",
+    "codex",
+    "mcp"
+  ],
+  "author": "JeremyDev87",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JeremyDev87/codingbuddy",
+    "directory": "packages/rules"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "packageManager": "yarn@4.11.0"
+}