namnam-skills 1.0.0

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

@@ -0,0 +1,177 @@
+# Cursor Agent Patterns
+
+> Best practices extracted from Cursor AI IDE's Agent Prompt 2.0
+
+## Core Philosophy
+
+Cursor operates on a **maximize context understanding** philosophy:
+- Be THOROUGH when gathering information
+- TRACE every symbol back to definitions and usages
+- EXPLORE alternative implementations
+- Keep searching until CONFIDENT nothing important remains
+
+---
+
+## Key Patterns
+
+### 1. Semantic Search Strategy
+
+```markdown
+# Codebase Search Best Practices
+
+## When to Use Semantic Search
+- Exploring unfamiliar codebases
+- Asking "how / where / what" questions
+- Finding code by meaning, not exact text
+
+## When NOT to Use
+- Exact text matches (use grep)
+- Reading known files (use read_file)
+- Simple symbol lookups (use grep)
+- Finding files by name (use file_search)
+
+## Query Formulation
+Good: "Where is interface MyInterface implemented in the frontend?"
+Bad: "MyInterface frontend" (too vague)
+
+Good: "Where do we encrypt user passwords before saving?"
+Bad: "AuthService" (single word - use grep)
+```
+
+### 2. Code Reference Format
+
+```markdown
+# Citing Existing Code
+
+## Format: startLine:endLine:filepath
+\`\`\`12:14:app/components/Todo.tsx
+export const Todo = () => {
+  return <div>Todo</div>;
+};
+\`\`\`
+
+## Rules
+- NEVER add language tags to code references
+- Include at least 1 line of actual code
+- Use `// ... existing code ...` for truncation
+```
+
+### 3. Edit Patterns
+
+```markdown
+# Making Code Changes
+
+## Approach
+- Never output code to user unless requested
+- Use code edit tools instead
+- Ensure code is immediately runnable
+
+## Edit File Tool
+- Specify edits in sequence
+- Use `// ... existing code ...` for unchanged sections
+- Include sufficient context to resolve ambiguity
+- Never omit code without the comment marker
+```
+
+### 4. Tool Calling Rules
+
+```markdown
+# Tool Usage
+
+1. Follow schema exactly - provide ALL parameters
+2. Never call unavailable tools
+3. Never refer to tool names to user
+4. Prefer tool calls over asking user
+5. Make a plan, then execute immediately
+6. Read files when unsure - don't guess
+7. Can read multiple files to clarify questions
+```
+
+### 5. Todo System
+
+```markdown
+# Task Management
+
+## When to Use
+- Complex multi-step tasks (3+ steps)
+- Non-trivial planning required
+- User provides multiple tasks
+- Tracking progress visibility
+
+## When NOT to Use
+- Single straightforward tasks
+- Trivial tasks
+- Conversational requests
+
+## Never Include in Todos
+- Linting
+- Testing
+- Searching/examining codebase
+```
+
+---
+
+## Implementation Example
+
+```javascript
+// Example: Implementing Cursor-style semantic search handling
+
+const searchStrategy = {
+  // Start broad, then narrow
+  phase1: {
+    query: "How does user authentication work?",
+    target: [],  // Search everywhere
+    explanation: "Find auth flow"
+  },
+
+  // Based on phase1 results, narrow down
+  phase2: {
+    query: "Where are user roles checked?",
+    target: ["backend/auth/"],
+    explanation: "Find role logic in identified area"
+  }
+};
+
+// For large files, use semantic search within file
+const largeFileStrategy = {
+  query: "How are websocket connections handled?",
+  target: ["backend/services/realtime.ts"],
+  explanation: "File too large to read entirely"
+};
+```
+
+---
+
+## Best Practices Summary
+
+| Area | Practice |
+|------|----------|
+| Search | Start broad, narrow based on results |
+| Edit | Use `// ... existing code ...` marker |
+| Cite | Use `startLine:endLine:filepath` format |
+| Tools | Call parallel when independent |
+| Todos | Track complex multi-step work |
+| Code | Ensure immediately runnable |
+
+---
+
+## Applying to Your Projects
+
+1. **Add to .cursorrules**:
+```
+# Agent Behavior
+- Use semantic search for "how/where/what" questions
+- Read files before modifying
+- Track progress with todo system
+- Ensure code is immediately runnable
+```
+
+2. **In AGENTS.md**:
+```markdown
+## Search Strategy
+- Start with exploratory queries
+- Narrow down based on results
+- Use grep for exact matches
+```
+
+**Source**: Cursor Agent Prompt 2.0

package/src/templates/system-prompts/google-antigravity-patterns.md

@@ -0,0 +1,274 @@
+# Google Antigravity Patterns
+
+> Best practices extracted from Google DeepMind's Antigravity AI Coding Assistant
+
+## Identity
+
+Antigravity is created by the **Google DeepMind team** working on Advanced Agentic Coding.
+
+---
+
+## Key Innovations
+
+### 1. Workflow System
+
+```markdown
+# Custom Workflows
+
+## Location
+.agent/workflows/*.md
+
+## Format
+---
+description: [short title]
+---
+[specific steps]
+
+## Turbo Annotations
+- `// turbo` above a step: Auto-run that step
+- `// turbo-all` anywhere: Auto-run ALL steps
+
+## Example
+\`\`\`
+1. Install dependencies
+// turbo
+2. Run build
+// turbo
+3. Start dev server
+\`\`\`
+Steps 2 and 3 auto-run (SafeToAutoRun: true)
+```
+
+### 2. Knowledge Item (KI) System
+
+```markdown
+# Knowledge Discovery
+
+## MANDATORY First Step
+Check KI summaries before ANY research
+
+## Process
+1. Review KI summaries provided at conversation start
+2. Identify relevant KIs by title/summary
+3. Read relevant KI artifacts BEFORE independent research
+4. Build upon KI information
+
+## KI Structure
+C:\Users\...\.gemini\<project>\knowledge\
+├── metadata.json (summary, timestamps, references)
+└── artifacts/ (documentation, implementation details)
+```
+
+### 3. Persistent Context
+
+```markdown
+# Cross-Conversation Memory
+
+## Two Mechanisms
+1. Conversation Logs and Artifacts
+   - Raw conversation history
+   - ASSISTANT-generated artifacts
+
+2. Knowledge Items (KIs)
+   - Distilled knowledge
+   - Updated by KNOWLEDGE SUBAGENT
+
+## When to Use Conversation Logs
+- Small number of relevant conversations
+- Need conversation details
+- @mention with Conversation ID
+- User references specific conversation
+
+## When to Use KIs
+- Starting any kind of research
+- Topic appears relevant
+- Referenced by conversation or another KI
+```
+
+### 4. Web Application Development
+
+```markdown
+# Technology Stack
+
+## Core Rules
+- HTML for structure, JavaScript for logic
+- Vanilla CSS preferred (not Tailwind unless requested)
+- Next.js or Vite for complex web apps
+
+## New Project Creation
+- Use `npx -y` for automatic install
+- Run `--help` first to see options
+- Initialize in current directory: `./`
+- Non-interactive mode always
+
+## Design Aesthetics (CRITICAL)
+- USER MUST BE WOWED
+- Vibrant colors, dark modes, glassmorphism
+- Dynamic animations
+- Modern typography (Google Fonts)
+- Smooth gradients
+- Micro-animations
+
+FAILURE TO IMPRESS = FAILURE!
+```
+
+### 5. Tool Execution Model
+
+```markdown
+# Parallel Tool Execution
+
+## waitForPreviousTools Parameter
+- false (default): Execute immediately (parallel)
+- true: Wait for previous tools to complete (sequential)
+
+## Example
+{
+  "tool": "codebase_search",
+  "Query": "auth flow",
+  "waitForPreviousTools": false  // Run in parallel
+}
+
+{
+  "tool": "view_file",
+  "AbsolutePath": "/path/to/auth.ts",
+  "waitForPreviousTools": true  // Wait for search first
+}
+```
+
+---
+
+## Implementation Examples
+
+### Workflow File
+
+```markdown
+---
+description: How to deploy the application
+---
+
+1. Run tests to ensure everything passes
+   \`npm test\`
+
+2. Build the production bundle
+// turbo
+   \`npm run build\`
+
+3. Deploy to production
+// turbo
+   \`npm run deploy\`
+```
+
+### KI Usage Pattern
+
+```javascript
+// Before ANY research, check KIs first
+
+async function handleUserRequest(request) {
+  // Step 1: Check KI summaries (MANDATORY)
+  const relevantKIs = await findRelevantKIs(request);
+
+  if (relevantKIs.length > 0) {
+    // Step 2: Read relevant KI artifacts
+    const kiContent = await Promise.all(
+      relevantKIs.map(ki => readKIArtifacts(ki.path))
+    );
+
+    // Step 3: Build upon existing knowledge
+    return buildOnExistingKnowledge(kiContent, request);
+  }
+
+  // Only do fresh research if no relevant KIs
+  return performFreshResearch(request);
+}
+```
+
+### Browser Subagent
+
+```javascript
+// Launch browser subagent for web interactions
+
+const browserTask = {
+  RecordingName: "login_flow_demo",
+  TaskName: "Navigating to Login Page",
+  Task: `
+    1. Navigate to http://localhost:3000/login
+    2. Fill in email field with "test@example.com"
+    3. Fill in password field with "password123"
+    4. Click the Login button
+    5. Wait for redirect to dashboard
+    6. Take screenshot to verify
+  `
+};
+```
+
+---
+
+## Best Practices Summary
+
+| Area | Antigravity Approach |
+|------|---------------------|
+| Workflows | Custom .md files with turbo annotations |
+| Knowledge | KI system with artifacts |
+| Context | Persistent across conversations |
+| Web Dev | Premium aesthetics required |
+| Tools | Parallel by default, sequential when needed |
+| Paths | Absolute paths only |
+
+---
+
+## Unique Features
+
+### 1. Image Generation
+```markdown
+- Built-in generate_image tool
+- Create UI mockups
+- Generate assets for apps
+- Iterate on designs with user
+- No placeholders - real images
+```
+
+### 2. Browser Recording
+```markdown
+- Automatic WebP video recording
+- All browser interactions recorded
+- Save as artifacts
+- Review flows visually
+```
+
+### 3. Token Budget
+```markdown
+- Explicit token budget management
+- Budget tag in system prompt
+- Optimize context usage
+```
+
+---
+
+## Applying to Your Projects
+
+1. **Create Workflows**:
+```markdown
+# .agent/workflows/deploy.md
+---
+description: Deploy to production
+---
+// turbo-all
+1. Run tests
+2. Build bundle
+3. Deploy
+```
+
+2. **In AGENTS.md**:
+```markdown
+## Knowledge Discovery
+- Check existing documentation first
+- Build on prior analysis
+- Store important context
+
+## Web Development
+- Premium aesthetics required
+- Modern design patterns
+- Micro-animations essential
+```
+
+**Source**: Google Antigravity Fast Prompt & Planning Mode