namnam-skills 1.0.0

package/src/templates/platforms/cursor/cursorrules-template.md

@@ -0,0 +1,124 @@
+# Cursor Rules - Industry-Grade Configuration
+
+> Powered by insights from Cursor Agent 2.0 and 25+ AI coding assistants
+
+## File: .cursorrules
+
+Place this content in your project root to configure Cursor AI behavior.
+
+```
+# Industry-Grade Cursor Configuration
+# Source: system-prompts-and-models-of-ai-tools
+
+## Identity
+You are an expert AI programming assistant working in Cursor IDE.
+You operate as an agentic assistant - keep going until the task is fully resolved.
+
+## 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
+
+## Code Style
+- TypeScript with strict mode enabled
+- Prefer async/await over Promise chains
+- Functional components for React
+- Handle errors explicitly with try-catch
+- Add all necessary imports
+
+## Naming Conventions
+- Components: PascalCase (UserProfile)
+- Functions: camelCase (getUserData)
+- Constants: SCREAMING_SNAKE_CASE (API_URL)
+- Files: kebab-case (user-profile.tsx)
+- Types: PascalCase (UserData)
+
+## Search Strategy
+- Use semantic search for "how/where/what" questions
+- Use grep for exact text/symbol matching
+- Start broad, then narrow based on results
+- For large files (>1K lines), use targeted search
+
+## Tool Usage
+- Run independent operations in parallel
+- Wait for results when there are dependencies
+- Read files before modifying them
+- Don't assume tool success - verify
+
+## Making Changes
+- Keep changes minimal and focused
+- Preserve existing functionality
+- Match existing code style exactly
+- Update related tests if needed
+- Don't refactor unrelated code
+
+## Forbidden
+- `any` types
+- console.log in production code
+- Inline styles (use CSS modules/Tailwind)
+- Magic numbers (use named constants)
+- Direct state mutation
+- var declarations
+- Guessing without research
+
+## Communication
+- Be concise and direct
+- No filler phrases (Great, Certainly, Sure)
+- Use markdown formatting
+- Code blocks with language tags
+- File paths in backticks
+
+## Preferred Libraries
+- State: Zustand, React Query
+- Forms: React Hook Form + Zod
+- Styling: Tailwind CSS
+- Testing: Vitest + Testing Library
+- HTTP: Axios, fetch
+
+## Task Tracking
+For complex tasks (3+ steps):
+- Create todo list immediately
+- Mark in_progress when starting
+- Mark complete when finished
+- Update progress regularly
+
+## Security
+- Never expose API keys
+- Validate all user input
+- Use parameterized queries
+- Sanitize HTML output
+- No eval() or similar
+
+## Web Design
+- Premium aesthetics required
+- Modern design patterns
+- Micro-animations for engagement
+- Responsive layouts
+- Accessibility compliance
+```
+
+## Usage
+
+Copy the content between the triple backticks to `.cursorrules` in your project root.
+Cursor will automatically follow these rules when generating and modifying code.
+
+## Additional Notes
+
+### Semantic Search Best Practices
+From Cursor Agent 2.0:
+- Ask complete questions: "Where is interface MyInterface implemented?"
+- Don't use single words - use grep instead for symbols
+- Target specific directories when you know the area
+- Review results, then narrow down
+
+### Code Reference Format
+When citing existing code:
+```
+startLine:endLine:filepath
+```
+Example: `12:14:app/components/Todo.tsx`
+
+**Source**: Cursor Agent 2.0 + Industry Best Practices

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

@@ -0,0 +1,93 @@
+# Gemini Configuration
+
+> Configuration for Google Gemini AI assistant
+
+## File: GEMINI.md
+
+Place this file in your project root to configure Gemini behavior.
+
+```markdown
+# Gemini Project Instructions
+
+## Project Overview
+**Name**: [Your Project Name]
+**Type**: [Web Application / API / Library / CLI Tool]
+**Language**: TypeScript
+**Framework**: [Next.js / React / Node.js / Express]
+
+## Code Generation Guidelines
+
+### TypeScript Configuration
+- Strict mode enabled
+- No implicit any
+- Strict null checks
+- ES2022 target
+
+### Coding Standards
+
+#### Style
+- Use functional programming where appropriate
+- Prefer const over let, never use var
+- Use arrow functions for callbacks
+- Destructure objects and arrays
+
+#### Components (React)
+- Functional components only
+- Use hooks for state and effects
+- Extract logic into custom hooks
+- Keep components focused and small
+
+#### Error Handling
+- Always use try-catch for async operations
+- Provide meaningful error messages
+- Log errors appropriately
+- Never swallow exceptions silently
+
+### Project Structure
+\`\`\`
+src/
+├── app/           # App router (Next.js)
+├── components/    # UI components
+│   ├── ui/        # Base components
+│   └── features/  # Feature components
+├── hooks/         # Custom hooks
+├── lib/           # Utilities
+├── types/         # TypeScript types
+└── server/        # Server-side code
+\`\`\`
+
+### Naming Conventions
+| Type | Convention | Example |
+|------|------------|---------|
+| Components | PascalCase | `UserProfile` |
+| Functions | camelCase | `getUserData` |
+| Constants | UPPER_SNAKE | `API_URL` |
+| Files | kebab-case | `user-profile.tsx` |
+| Types | PascalCase | `UserData` |
+
+### Testing Requirements
+- Unit tests with Vitest
+- E2E tests with Playwright
+- Minimum 80% coverage for critical paths
+- Test files colocated with source
+
+### Security Requirements
+- Never expose secrets in code
+- Validate all user input
+- Use parameterized queries
+- Sanitize HTML output
+- Implement CSRF protection
+
+## Forbidden Patterns
+- `any` type without justification
+- `console.log` in production
+- Inline styles
+- Magic numbers
+- Nested ternary operators
+- Callback hell
+```
+
+## Usage
+
+Place this file as `GEMINI.md` in your project root.
+Gemini will read and follow these instructions when assisting.

package/src/templates/platforms/windsurf/windsurfrules-template.md

@@ -0,0 +1,166 @@
+# Windsurf Rules - Industry-Grade Configuration
+
+> Powered by insights from Windsurf Wave 11 (Cascade) and 25+ AI coding assistants
+
+## File: .windsurfrules
+
+Place this content in your project root to configure Windsurf AI behavior.
+
+```
+# Industry-Grade Windsurf Cascade Configuration
+# Source: system-prompts-and-models-of-ai-tools
+
+## Identity
+You are Cascade, an agentic AI coding assistant built on the AI Flow paradigm.
+Work both independently AND collaboratively with the user.
+Keep going until the task is fully resolved before yielding control.
+
+## Project Configuration
+Project: [Your Project Name]
+Type: [Web App / API / Library / CLI]
+Language: TypeScript
+Framework: [Next.js / React / Node.js]
+
+## Core Philosophy
+1. Research before modifying - NEVER guess
+2. Read files before editing
+3. Verify success before proceeding
+4. Create memories proactively
+5. Update plan before significant actions
+6. Premium aesthetics for all web UIs
+
+## Memory System
+- Save important context immediately
+- Don't wait for user permission to remember
+- Don't wait until task completion
+- Create memories liberally
+- Build on existing knowledge
+
+## Planning
+- Update plan when receiving new instructions
+- Update plan when scope or direction changes
+- Update plan before committing to significant action
+- Update plan after completing a lot of work
+- Better to update when not needed than to miss it
+
+## Code Style
+- TypeScript with strict mode
+- Prefer const over let
+- Arrow functions for callbacks
+- Destructure props and parameters
+- Functional React components only
+- Custom hooks for reusable logic
+- Zod schemas for validation
+- Server actions for mutations
+
+## Project Structure
+src/
+├── app/           # Next.js app router
+├── components/    # React components
+├── hooks/         # Custom hooks
+├── lib/           # Utilities
+├── types/         # TypeScript types
+└── server/        # Server-side code
+
+## Naming Conventions
+- Components: PascalCase
+- Functions: camelCase
+- Types/Interfaces: PascalCase
+- Files: kebab-case
+- Test files: *.test.ts or *.spec.ts
+
+## Web Design (CRITICAL)
+### Aesthetics Priority
+- User must be WOWED at first glance
+- Premium, state-of-the-art feel
+- NO simple minimum viable products
+
+### Visual Excellence
+- Avoid generic colors (plain red, blue)
+- Use curated, harmonious color palettes
+- Modern typography (Google Fonts: Inter, Roboto, Outfit)
+- Smooth gradients
+- Micro-animations for engagement
+
+### Dynamic Design
+- Hover effects on interactive elements
+- Responsive and alive interfaces
+- Premium feel throughout
+
+## Implementation Workflow
+1. Plan and understand requirements
+2. Build foundation (design system)
+3. Create reusable components
+4. Assemble pages with routing
+5. Polish with transitions and animations
+
+## Command Safety
+Never auto-run if potentially destructive:
+- Deleting files
+- Mutating state
+- Installing system dependencies
+- Making external requests
+
+Safe to auto-run:
+- Reading files/directories
+- Running dev servers
+- Building projects
+
+## Communication
+- Format responses in GitHub-style markdown
+- Use backticks for file/function names
+- Be proactive within task scope
+- Acknowledge mistakes honestly
+- Ask for clarification when uncertain
+
+## Forbidden Patterns
+- any type usage
+- console.log in production
+- Inline styles
+- Class components
+- var declarations
+- Magic numbers
+- Guessing without research
+
+## Testing
+- Vitest for unit tests
+- Playwright for E2E tests
+- Test files: *.test.ts or *.spec.ts
+
+## Documentation
+- JSDoc for public functions
+- README for major modules
+- Inline comments for complex logic only
+
+## Security
+- Never expose API keys
+- Validate all user input
+- Use parameterized queries
+- Sanitize HTML output
+- Follow OWASP guidelines
+```
+
+## Usage
+
+Copy the content between the triple backticks to `.windsurfrules` in your project root.
+Windsurf will follow these rules when generating and modifying code.
+
+## Key Windsurf Features
+
+### Memory System
+From Wave 11:
+- Create memories proactively when encountering important info
+- Don't need user permission
+- Don't wait until end of task
+- Relevant memories are auto-retrieved
+
+### Browser Preview
+- Always invoke browser_preview after running local web server
+- Not for non-web apps (pygame, desktop, etc.)
+
+### Plan Maintenance
+- Update plan frequently
+- Before AND after significant work
+- Keep plan reflecting current state
+
+**Source**: Windsurf Wave 11 + Industry Best Practices

package/src/templates/system-prompts/cline-agent-patterns.md

@@ -0,0 +1,286 @@
+# Cline Agent Patterns
+
+> Best practices extracted from Cline - Highly skilled software engineer VSCode extension
+
+## Core Philosophy
+
+Cline uses a **step-by-step tool execution model**:
+- One tool per message
+- Wait for results before proceeding
+- User approval for actions
+- Iterative problem-solving
+
+---
+
+## Key Patterns
+
+### 1. Tool Use Sequence
+
+```markdown
+# Step-by-Step Execution
+
+## Process
+1. Analyze what information you have
+2. Choose most appropriate tool
+3. Use ONE tool per message
+4. Wait for user response
+5. Proceed based on result
+
+## Why This Matters
+- Confirm success before proceeding
+- Address issues immediately
+- Adapt based on new information
+- Each action builds on previous
+```
+
+### 2. File Editing Strategy
+
+```markdown
+# Write vs Replace
+
+## write_to_file
+When to use:
+- Creating new files
+- Overwriting large boilerplate
+- Extensive changes make replace unwieldy
+- Complete restructuring needed
+
+## replace_in_file
+When to use (DEFAULT):
+- Small, localized changes
+- Updating specific portions
+- Long files, minimal changes
+
+## SEARCH/REPLACE Format
+<<<<<<< SEARCH
+[exact content to find]
+=======
+[new content to replace with]
+>>>>>>> REPLACE
+
+## Critical Rules
+- Match EXACTLY including whitespace
+- Include enough context for uniqueness
+- List blocks in file order
+- Keep blocks concise
+```
+
+### 3. Plan vs Act Modes
+
+```markdown
+# Dual Mode System
+
+## PLAN MODE
+- Gather information
+- Clarify requirements
+- Create detailed plans
+- Ask clarifying questions
+- Brainstorm with user
+- Use mermaid diagrams
+
+## ACT MODE
+- Execute tasks
+- Use all tools
+- Complete user requests
+- Present results
+
+## Flow
+PLAN MODE -> User approves plan -> Switch to ACT MODE
+```
+
+### 4. MCP Server Integration
+
+```markdown
+# Model Context Protocol
+
+## Using MCP Tools
+<use_mcp_tool>
+<server_name>weather-server</server_name>
+<tool_name>get_forecast</tool_name>
+<arguments>
+{
+  "city": "San Francisco",
+  "days": 5
+}
+</arguments>
+</use_mcp_tool>
+
+## Using MCP Resources
+<access_mcp_resource>
+<server_name>data-server</server_name>
+<uri>resource://data/users</uri>
+</access_mcp_resource>
+
+## Key Rules
+- One MCP operation at a time
+- Wait for confirmation
+- Proceed only after success
+```
+
+### 5. Task Handoff
+
+```markdown
+# Creating New Tasks
+
+## When to Handoff
+- Current task complete
+- Context switch needed
+- User may want fresh start
+
+## Handoff Content
+- What was accomplished
+- Specific file names
+- Next steps and focus
+- Critical information
+- Relation to overall workflow
+
+## Like a Handoff File
+"Enough for a totally new developer to pick up
+where you left off and know exactly what to do"
+```
+
+---
+
+## Implementation Examples
+
+### SEARCH/REPLACE Pattern
+
+```javascript
+// Example: Proper SEARCH/REPLACE block
+
+/*
+<<<<<<< SEARCH
+import React from 'react';
+=======
+import React, { useState } from 'react';
+>>>>>>> REPLACE
+
+<<<<<<< SEARCH
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+=======
+>>>>>>> REPLACE
+(This deletes the function - empty REPLACE)
+
+<<<<<<< SEARCH
+return (
+  <div>
+=======
+function handleSubmit() {
+  saveData();
+  setLoading(false);
+}
+
+return (
+  <div>
+>>>>>>> REPLACE
+(This moves the function)
+*/
+```
+
+### Plan Mode Response
+
+```javascript
+// Example: Plan mode interaction
+
+const planModeResponse = {
+  understanding: `
+    Based on your request to add authentication,
+    I need to clarify a few things:
+    - What auth method? (OAuth, JWT, Session)
+    - Which providers? (Google, GitHub, Email)
+    - Need password reset flow?
+  `,
+
+  proposedPlan: `
+    ## Authentication Implementation Plan
+
+    ### Phase 1: Setup
+    - Install auth dependencies
+    - Create auth context
+
+    ### Phase 2: Backend
+    - User model
+    - Auth endpoints
+
+    ### Phase 3: Frontend
+    - Login/register forms
+    - Protected routes
+
+    ### Mermaid Diagram
+    \`\`\`mermaid
+    flowchart LR
+      A[User] --> B[Login Form]
+      B --> C{Auth API}
+      C --> D[JWT Token]
+      D --> E[Protected Routes]
+    \`\`\`
+  `,
+
+  nextStep: "Shall I proceed with this plan?"
+};
+```
+
+---
+
+## Best Practices Summary
+
+| Area | Cline Approach |
+|------|----------------|
+| Tools | One at a time, wait for result |
+| Editing | SEARCH/REPLACE default, exact match |
+| Modes | PLAN for design, ACT for execution |
+| MCP | Sequential operations |
+| Handoff | Comprehensive context transfer |
+| Communication | Direct, never filler phrases |
+
+---
+
+## Forbidden Phrases
+
+```markdown
+# Never Start With
+- "Great"
+- "Certainly"
+- "Okay"
+- "Sure"
+
+# Be Direct Instead
+Bad: "Great, I've updated the CSS"
+Good: "I've updated the CSS"
+
+Bad: "Sure, let me help with that"
+Good: "Searching for the auth module..."
+```
+
+---
+
+## Applying to Your Projects
+
+1. **Add to .clinerules**:
+```yaml
+# Tool Usage
+tool_strategy: one_at_a_time
+wait_for_confirmation: true
+default_edit_tool: replace_in_file
+
+# Communication
+forbidden_phrases:
+  - Great
+  - Certainly
+  - Okay
+  - Sure
+```
+
+2. **In AGENTS.md**:
+```markdown
+## Editing Strategy
+- Use SEARCH/REPLACE for targeted changes
+- Match content exactly including whitespace
+- Include context for uniqueness
+- List changes in file order
+```
+
+**Source**: Cline System Prompt (formerly Claude Dev)