namnam-skills 1.0.0

package/src/templates/platforms/AGENTS.md

@@ -0,0 +1,326 @@
+# AGENTS.md - Universal AI Agent Configuration
+
+> **Industry-Grade Configuration** compatible with all AI coding assistants
+> Powered by insights from Claude Code, Cursor, Windsurf, Cline, VSCode Agent, and 25+ AI platforms
+
+This file is automatically read by:
+- **Claude Code** (Anthropic) - Primary support
+- **Cursor** (reads AGENTS.md as fallback)
+- **Windsurf** (reads AGENTS.md as fallback)
+- **Cline** (reads AGENTS.md)
+- **OpenAI Codex** (reads project context)
+- **Aider** (reads project context)
+- **Google Gemini** (reads GEMINI.md)
+
+---
+
+## Project Overview
+
+| Property | Value |
+|----------|-------|
+| **Name** | [Your Project Name] |
+| **Type** | [Web App / API / Library / CLI] |
+| **Stack** | TypeScript, React/Next.js, Node.js |
+| **Test Framework** | Vitest / Jest / Playwright |
+| **Package Manager** | npm / pnpm / yarn |
+
+---
+
+## Universal Agent Behavior
+
+### Core Philosophy
+```
+1. Research before modifying - NEVER guess
+2. Read files before editing
+3. Verify success before proceeding
+4. Handle errors gracefully
+5. Complete tasks autonomously
+6. Ask only when genuinely blocked
+```
+
+### Communication Style
+- **Concise**: Keep responses short and direct
+- **Technical**: Focus on facts, not validation
+- **No filler**: Never start with "Great", "Certainly", "Sure"
+- **Markdown**: Use proper formatting, backticks for code
+- **Direct**: Answer questions, don't explain obvious things
+
+### Task Execution Model
+```
+1. Analyze the request fully
+2. Extract ALL requirements to checklist
+3. Research and gather context
+4. Plan minimal, focused changes
+5. Execute with proper error handling
+6. Verify changes work
+7. Update progress tracking
+```
+
+---
+
+## Code Style
+
+### Always Do
+| Rule | Reason |
+|------|--------|
+| Use TypeScript strict mode | Type safety |
+| Prefer async/await | Readability |
+| Handle errors with try-catch | Robustness |
+| Add all necessary imports | Immediate runnable |
+| Follow existing conventions | Consistency |
+| Use functional patterns | Predictability |
+
+### Never Do
+| Rule | Reason |
+|------|--------|
+| Use `any` types | Type safety |
+| Leave console.log | Production cleanliness |
+| Use inline styles | Maintainability |
+| Use magic numbers | Readability |
+| Mutate state directly | Predictability |
+| Skip error handling | Reliability |
+
+---
+
+## Naming Conventions
+
+| Type | Convention | Example |
+|------|------------|---------|
+| Components | PascalCase | `UserProfile` |
+| Functions | camelCase | `getUserData` |
+| Constants | UPPER_SNAKE | `API_BASE_URL` |
+| Files | kebab-case | `user-profile.tsx` |
+| Types | PascalCase | `UserData` |
+| Hooks | camelCase with use | `useUserAuth` |
+| Test files | *.test.ts / *.spec.ts | `auth.test.ts` |
+
+---
+
+## Project Structure
+
+```
+src/
+├── app/              # Next.js app router / Entry points
+├── components/       # React components
+│   ├── ui/           # Base UI components (Button, Input, etc.)
+│   └── features/     # Feature-specific components
+├── hooks/            # Custom React hooks
+├── lib/              # Utility functions and helpers
+├── types/            # TypeScript type definitions
+├── server/           # Server-side code / API routes
+├── services/         # External service integrations
+├── stores/           # State management (Zustand, etc.)
+└── tests/            # Test files (if not co-located)
+```
+
+---
+
+## Tool Usage Patterns
+
+### Research First (CRITICAL)
+```
+Before ANY modification:
+1. Read the target file
+2. Understand existing patterns
+3. Check related files
+4. Identify dependencies
+5. Plan minimal changes
+```
+
+### Parallel Execution
+```
+When operations are independent:
+- Run file reads in parallel
+- Batch similar operations
+- Don't wait unnecessarily
+
+When operations depend on each other:
+- Wait for results
+- Validate outputs
+- Use results as inputs
+```
+
+### Task Tracking
+```
+For complex tasks (3+ steps):
+1. Create todo list immediately
+2. Mark items in_progress when starting
+3. Mark complete when finished
+4. Update progress regularly
+5. Don't batch completions
+```
+
+---
+
+## Security Requirements
+
+### Absolute Rules
+- **NEVER** expose API keys in code
+- **NEVER** commit secrets to repository
+- **NEVER** log sensitive information
+- **NEVER** skip input validation
+- **NEVER** use eval() or similar
+
+### Always Do
+- Validate all user input
+- Use parameterized database queries
+- Sanitize HTML output
+- Implement proper authentication
+- Use HTTPS for external requests
+- Follow OWASP guidelines
+
+---
+
+## Preferred Libraries
+
+| Purpose | Library | Alternative |
+|---------|---------|-------------|
+| State Management | Zustand | React Query / Jotai |
+| Forms | React Hook Form | Formik |
+| Validation | Zod | Yup |
+| Styling | Tailwind CSS | CSS Modules |
+| Testing (Unit) | Vitest | Jest |
+| Testing (E2E) | Playwright | Cypress |
+| HTTP Client | Axios | fetch API |
+| Dates | date-fns | dayjs |
+
+---
+
+## AI Agent Behavior
+
+### When Generating Code
+1. Follow existing patterns in the codebase
+2. Use TypeScript types from `src/types`
+3. Match the existing code style exactly
+4. Add appropriate error handling
+5. Include all necessary imports
+6. Ensure code runs immediately
+
+### When Modifying Code
+1. Read the file first (ALWAYS)
+2. Preserve existing functionality
+3. Keep changes minimal and focused
+4. Update related tests if needed
+5. Don't refactor unrelated code
+6. Verify changes work
+
+### When Asked to Review
+1. Check for security issues first
+2. Verify type safety
+3. Look for performance problems
+4. Identify missing error handling
+5. Suggest improvements constructively
+
+### When Debugging
+1. Understand the error fully
+2. Read relevant context
+3. Identify root cause (not symptoms)
+4. Plan a fix
+5. Implement and verify
+6. Don't guess at solutions
+
+---
+
+## Custom Commands (Claude Code)
+
+### Available Skills
+| Command | Description |
+|---------|-------------|
+| `/namnam <task>` | Orchestrate multiple agents |
+| `/namnam --full <task>` | Maximum power mode |
+| `/code-review` | Multi-aspect code review |
+| `/validate-and-fix` | Run checks and auto-fix |
+| `/git:commit` | Smart commit with message |
+| `/git:push` | Smart push with checks |
+| `/research <topic>` | Deep research with citations |
+
+### For Other Platforms
+When using Cursor, Windsurf, Cline, or other agents:
+- Reference this file for project conventions
+- Follow the structure and naming rules
+- Use the preferred libraries
+- Avoid forbidden patterns
+- Maintain code style consistency
+
+---
+
+## Web Development Standards
+
+### Design Philosophy
+- **Visual Excellence**: Users should be impressed at first glance
+- **Modern Aesthetics**: Use contemporary design patterns
+- **Premium Feel**: No basic/simple designs
+- **Dynamic**: Micro-animations, hover effects
+- **Responsive**: Works on all devices
+
+### Implementation
+1. Build design system first (tokens, utilities)
+2. Create reusable components
+3. Assemble pages with proper routing
+4. Polish with transitions and animations
+5. Optimize for performance
+
+### Accessibility
+- Semantic HTML
+- ARIA labels where needed
+- Keyboard navigation
+- Color contrast compliance
+- Screen reader support
+
+---
+
+## Memory & Context
+
+### What to Remember
+- Important architectural decisions
+- User preferences and patterns
+- Project-specific conventions
+- Previous solutions to similar problems
+- Known issues and workarounds
+
+### Knowledge Discovery
+- Check existing documentation first
+- Build on prior analysis
+- Avoid redundant research
+- Reference previous work
+- Store important context
+
+---
+
+## Error Handling
+
+### Strategy
+```
+1. Understand the error message
+2. Read relevant context
+3. Identify the root cause
+4. Plan a fix
+5. Implement solution
+6. Verify fix works
+7. Don't give up immediately
+8. Try alternative approaches
+```
+
+### Don't
+- Guess at solutions without research
+- Ignore error messages
+- Skip verification
+- Give up without trying alternatives
+- Assume success without checking
+
+---
+
+## Quality Checklist
+
+Before considering any task complete:
+- [ ] Code follows existing patterns
+- [ ] TypeScript types are correct
+- [ ] Error handling is in place
+- [ ] No security vulnerabilities
+- [ ] Changes are minimal and focused
+- [ ] Code runs without errors
+- [ ] Related tests pass (if applicable)
+
+---
+
+**Generated by namnam-skills** | **Source**: [system-prompts-and-models-of-ai-tools](https://github.com/x1xhlol/system-prompts-and-models-of-ai-tools)

package/src/templates/platforms/aider/aider-template.md

@@ -0,0 +1,75 @@
+# Aider Configuration
+
+> Configuration for Aider AI pair programming assistant
+
+## File: .aider.conf.yml
+
+Place this file in your project root to configure Aider behavior.
+
+```yaml
+# Aider Configuration
+
+# Model settings
+model: gpt-4-turbo
+edit-format: diff
+
+# File handling
+auto-commits: true
+dirty-commits: false
+attribute-author: true
+attribute-committer: true
+
+# Code style
+lint-cmd: npm run lint
+test-cmd: npm test
+
+# Context
+read:
+  - README.md
+  - package.json
+  - tsconfig.json
+
+# Ignore patterns (also respects .gitignore)
+ignore:
+  - node_modules/
+  - dist/
+  - .next/
+  - coverage/
+
+# Git settings
+git-depth: 10
+show-diffs: true
+```
+
+## File: .aider.input.md
+
+Optional file for persistent instructions:
+
+```markdown
+# Aider Instructions
+
+## Project Context
+This is a Next.js 14 application using:
+- TypeScript with strict mode
+- Tailwind CSS for styling
+- Prisma for database
+- NextAuth for authentication
+
+## Code Style
+- Use functional components
+- Prefer server components where possible
+- Use Zod for validation
+- Handle errors with try-catch
+
+## When Making Changes
+1. Follow existing code patterns
+2. Add TypeScript types
+3. Update tests if needed
+4. Keep commits atomic
+```
+
+## Usage
+
+1. Copy `.aider.conf.yml` to project root
+2. Optionally add `.aider.input.md` for persistent context
+3. Run `aider` in your project directory

package/src/templates/platforms/cline/clinerules-template.md

@@ -0,0 +1,205 @@
+# Cline Rules - Industry-Grade Configuration
+
+> Powered by insights from Cline (formerly Claude Dev) and 25+ AI coding assistants
+
+## File: .clinerules
+
+Place this content in your project root to configure Cline behavior.
+
+```yaml
+# Industry-Grade Cline Configuration
+# Source: system-prompts-and-models-of-ai-tools
+
+identity:
+  role: "Expert software engineer with extensive knowledge in many languages and frameworks"
+  behavior: "Agentic - complete tasks autonomously before yielding to user"
+
+core_philosophy:
+  - "Research before modifying - NEVER guess"
+  - "Read files before editing"
+  - "Verify success before proceeding"
+  - "Handle errors gracefully"
+  - "Complete tasks autonomously"
+  - "Ask only when genuinely blocked"
+
+tool_usage:
+  strategy: "one_at_a_time"
+  wait_for_confirmation: true
+  verify_success: true
+
+  guidelines:
+    - "Use one tool per message"
+    - "Wait for user response with results"
+    - "Analyze results before next action"
+    - "Each step informed by previous results"
+    - "Never assume tool success"
+
+file_editing:
+  default_tool: "replace_in_file"
+
+  write_to_file:
+    use_when:
+      - "Creating new files"
+      - "Overwriting large boilerplate"
+      - "Extensive changes make replace unwieldy"
+      - "Complete restructuring needed"
+
+  replace_in_file:
+    use_when:
+      - "Small, localized changes (DEFAULT)"
+      - "Updating specific portions"
+      - "Long files with minimal changes"
+    format: "SEARCH/REPLACE blocks"
+    rules:
+      - "Match content EXACTLY including whitespace"
+      - "Include enough context for uniqueness"
+      - "List blocks in file order"
+      - "Keep blocks concise"
+      - "Complete lines only, no partial"
+
+modes:
+  plan_mode:
+    purpose: "Gather information, clarify requirements, create detailed plans"
+    tools: ["plan_mode_respond", "read_file", "search_files"]
+    actions:
+      - "Ask clarifying questions"
+      - "Create mermaid diagrams"
+      - "Brainstorm approaches"
+      - "Get user approval"
+
+  act_mode:
+    purpose: "Execute tasks, use all tools, complete user requests"
+    tools: "all except plan_mode_respond"
+    actions:
+      - "Make changes"
+      - "Run commands"
+      - "Complete tasks"
+      - "Present results"
+
+code_style:
+  language: "TypeScript"
+  mode: "strict"
+
+  always:
+    - "Use async/await over Promise chains"
+    - "Handle errors with try-catch"
+    - "Add all necessary imports"
+    - "Follow existing conventions"
+    - "Functional components for React"
+
+  never:
+    - "Use any types"
+    - "Leave console.log in production"
+    - "Use inline styles"
+    - "Use magic numbers"
+    - "Direct state mutation"
+    - "var declarations"
+
+naming_conventions:
+  components: "PascalCase"
+  functions: "camelCase"
+  constants: "SCREAMING_SNAKE_CASE"
+  files: "kebab-case"
+  types: "PascalCase"
+  hooks: "camelCase with use prefix"
+
+communication:
+  style: "Direct and technical"
+  format: "Markdown with proper code blocks"
+
+  forbidden_phrases:
+    - "Great"
+    - "Certainly"
+    - "Okay"
+    - "Sure"
+    - "Sounds good"
+
+  correct_examples:
+    bad: "Great, I've updated the CSS"
+    good: "Updated the CSS with dark mode styles"
+
+mcp_integration:
+  enabled: true
+  operations: "sequential"
+  wait_for_confirmation: true
+
+  usage:
+    - "One MCP operation at a time"
+    - "Wait for confirmation before proceeding"
+    - "Use server_name and tool_name correctly"
+
+task_handoff:
+  when:
+    - "Current task complete"
+    - "Context switch needed"
+    - "User may want fresh start"
+
+  content:
+    - "What was accomplished"
+    - "Specific file names"
+    - "Next steps and focus"
+    - "Critical information"
+    - "Relation to overall workflow"
+
+security:
+  never:
+    - "Expose API keys in code"
+    - "Commit secrets to repository"
+    - "Log sensitive information"
+    - "Skip input validation"
+    - "Use eval() or similar"
+
+  always:
+    - "Validate user input"
+    - "Use parameterized queries"
+    - "Sanitize HTML output"
+    - "Implement proper authentication"
+
+preferred_libraries:
+  state_management: ["Zustand", "React Query"]
+  forms: ["React Hook Form", "Zod"]
+  styling: "Tailwind CSS"
+  testing: ["Vitest", "Playwright", "Testing Library"]
+  http: ["Axios", "fetch"]
+
+debugging:
+  strategy:
+    - "Understand the error fully"
+    - "Read relevant context"
+    - "Identify root cause (not symptoms)"
+    - "Plan a fix"
+    - "Implement and verify"
+    - "Don't guess at solutions"
+```
+
+## Usage
+
+Copy the content between the triple backticks to `.clinerules` in your project root.
+Cline will follow these rules when generating and modifying code.
+
+## Key Cline Features
+
+### SEARCH/REPLACE Format
+```
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+```
+
+### Plan Mode vs Act Mode
+- **Plan Mode**: Design and discuss before implementing
+- **Act Mode**: Execute with full tool access
+
+### MCP Server Integration
+- Use `use_mcp_tool` for external tools
+- Use `access_mcp_resource` for data sources
+- One operation at a time, wait for confirmation
+
+### Task Handoff
+Create comprehensive context for new tasks:
+- Like a handoff file for a new developer
+- Include all necessary context to continue
+
+**Source**: Cline System Prompt + Industry Best Practices

package/src/templates/platforms/codex/codex-template.md

@@ -0,0 +1,74 @@
+# OpenAI Codex Configuration
+
+> Configuration for OpenAI Codex CLI agent
+
+## File: codex.md or CODEX.md
+
+Place this file in your project root to configure Codex behavior.
+
+```markdown
+# Codex Project Instructions
+
+## Project Overview
+- **Name**: [Your Project Name]
+- **Type**: [Web App / API / Library]
+- **Stack**: TypeScript, React, Node.js
+
+## Code Generation Rules
+
+### Style Guidelines
+1. Use TypeScript with strict mode
+2. Prefer functional programming patterns
+3. Use async/await for asynchronous code
+4. Handle all errors explicitly
+
+### Project Structure
+\`\`\`
+src/
+├── components/    # React components
+├── hooks/         # Custom hooks
+├── lib/           # Utilities and helpers
+├── types/         # TypeScript types
+├── api/           # API routes
+└── tests/         # Test files
+\`\`\`
+
+### Naming Conventions
+- **Components**: PascalCase (UserProfile.tsx)
+- **Functions**: camelCase (getUserData)
+- **Constants**: SCREAMING_SNAKE_CASE (API_BASE_URL)
+- **Files**: kebab-case (user-profile.tsx)
+
+### Best Practices
+- No `any` types - use proper typing
+- Extract reusable logic into custom hooks
+- Keep functions under 50 lines
+- Write unit tests for business logic
+
+### Forbidden Patterns
+- console.log in production code
+- Inline styles
+- Magic numbers
+- Deeply nested callbacks
+- Mutation of state directly
+
+### Preferred Libraries
+| Purpose | Library |
+|---------|---------|
+| State | Zustand, React Query |
+| Forms | React Hook Form + Zod |
+| Styling | Tailwind CSS |
+| Testing | Jest, Vitest |
+| HTTP | Axios, fetch |
+
+## Safety Rules
+- Never expose API keys in code
+- Validate all user input
+- Use parameterized queries for DB
+- Sanitize output to prevent XSS
+```
+
+## Usage
+
+Place this file as `codex.md` or `CODEX.md` in your project root.
+Codex will read and follow these instructions.