@caddis/cli 0.0.0 → 0.2.0

package/bundles/antigravity-plugin-extras/skills/job-application/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: job-application
+description: Write tailored cover letters and job applications using a structured methodology. Analyzes job descriptions, maps experience, and generates personalized applications.
+---
+
+# Job Application Assistant
+
+Generate cover letters and job applications that sound like you, not a template.
+
+## When to Use
+
+- Writing a cover letter for a specific job posting
+- Tailoring a resume/CV for a role
+- Preparing application materials
+- Analyzing job descriptions for keyword alignment
+
+---
+
+## Steps
+
+### Step 1: Gather Your Materials
+
+Before generating any application, ensure you have:
+
+#### Your CV/Resume
+
+```
+[Your name]
+[Your title/headline]
+
+EXPERIENCE
+- [Job 1: Company, Title, Dates, Key achievements]
+- [Job 2: Company, Title, Dates, Key achievements]
+
+SKILLS
+- [Technical: languages, frameworks, tools]
+- [Soft: leadership, communication, problem-solving]
+
+EDUCATION
+- [Degree, School, Year]
+
+CERTIFICATIONS (if any)
+- [Cert name, Issuer, Year]
+```
+
+#### Cover Letter Examples You Like
+
+Paste 1-2 cover letters you've written that worked well. These define your voice.
+
+#### Your Voice & Preferences
+
+- **Tone**: Professional but not stiff, confident without bragging
+- **Emphasize**: What makes you unique, key achievements, leading skills
+- **Avoid**: Generic phrases ("I'm a hard worker"), repeating the job description
+
+### Step 2: Analyze the Job Description
+
+For each application, systematically extract:
+
+```markdown
+## Job Analysis
+
+**Company**: [Name]
+**Role**: [Title]
+**Level**: [Junior/Mid/Senior/Lead]
+
+### Key Requirements
+1. [Must-have skill 1] -> Your match: [specific experience]
+2. [Must-have skill 2] -> Your match: [specific experience]
+3. [Nice-to-have 1] -> Your match: [if any]
+
+### Keywords to Include
+- [Technical terms from the posting]
+- [Soft skills mentioned]
+- [Industry-specific language]
+
+### Company Research
+- Mission/values: [from their website]
+- Recent news: [if relevant]
+- Culture signals: [startup/enterprise, remote/hybrid]
+```
+
+### Step 3: Generate the Cover Letter
+
+**Structure (under 400 words):**
+
+1. **Opening (2-3 sentences)**: Why you're interested in THIS role at THIS company. Mention something specific about the company.
+
+2. **Experience Match (2-3 paragraphs)**: Connect your experience to their requirements. Use specific metrics:
+   - "Reduced API latency by 40% serving 2M daily requests"
+   - "Led a team of 5 engineers shipping features for 500K users"
+
+3. **Closing (2-3 sentences)**: Clear call to action. Express enthusiasm.
+
+**Adapt tone to company:**
+- Startup: casual, enthusiastic, show builder mentality
+- Enterprise: formal, structured, show process expertise
+- Agency: creative, adaptable, show breadth
+
+### Step 4: Tailor the Resume
+
+For each application, consider:
+
+```markdown
+## Resume Adjustments
+
+1. **Headline**: Align with the role title
+2. **Summary**: Customize 2-3 sentences to match the role
+3. **Experience bullets**: Reorder to lead with most relevant
+4. **Skills section**: Move matching skills to the top
+5. **Keywords**: Ensure ATS-friendly keywords from the posting appear
+```
+
+### Step 5: Review and Refine
+
+**Quality checks:**
+- [ ] Is it under 400 words (cover letter)?
+- [ ] Does it mention the company name and something specific about them?
+- [ ] Are achievements quantified where possible?
+- [ ] Does it match the posting's tone?
+- [ ] No spelling or grammar errors?
+- [ ] Does it avoid generic phrases?
+
+---
+
+## Patterns and Examples
+
+### Strong Opening
+
+```
+I noticed [Company] is expanding its data platform to support real-time analytics
+for [specific product]. Having built similar systems at [Previous Company] that
+process 50M events daily, I'm excited about the opportunity to bring that
+experience to your team as a Senior Data Engineer.
+```
+
+### Weak Opening (Avoid)
+
+```
+I am writing to apply for the Senior Data Engineer position at [Company].
+I believe I am a good fit for this role because of my experience.
+```
+
+### Achievement Bullets (STAR Format)
+
+```
+- Architected event-driven pipeline (Kafka + Flink) reducing data latency
+  from 4 hours to 30 seconds, enabling real-time dashboards for 200 analysts
+- Led migration from monolith to microservices, cutting deployment time from
+  2 weeks to 45 minutes and reducing incidents by 60%
+```
+
+---
+
+## Output Format
+
+When generating application materials:
+
+```markdown
+## Cover Letter: [Role] at [Company]
+
+[Full cover letter text]
+
+---
+
+## Resume Adjustments
+- Headline: [suggested change]
+- Key bullets to highlight: [list]
+- Keywords to add: [list]
+
+## Application Notes
+- [Any additional insights or warnings]
+```
+
+---
+
+## Checklist
+
+- [ ] CV/resume is provided and up to date
+- [ ] Job description thoroughly analyzed
+- [ ] Requirements mapped to specific experience
+- [ ] Cover letter under 400 words
+- [ ] Company-specific opening (not generic)
+- [ ] Achievements quantified with metrics
+- [ ] Tone matches company culture
+- [ ] Resume bullets reordered for relevance
+- [ ] ATS keywords included
+- [ ] Proofread for errors

package/bundles/antigravity-plugin-extras/skills/lead-research-assistant/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: lead-research-assistant
+context: fork
+description: Identifies high-quality leads for your product or service by analyzing your business, searching for target companies, and providing actionable contact strategies. Perfect for sales, business development, and marketing professionals.
+---
+
+# Lead Research Assistant
+
+This skill helps you identify and qualify potential leads for your business by analyzing your product/service, understanding your ideal customer profile, and providing actionable outreach strategies.
+
+## When to Use This Skill
+
+- Finding potential customers or clients for your product/service
+- Building a list of companies to reach out to for partnerships
+- Identifying target accounts for sales outreach
+- Researching companies that match your ideal customer profile
+- Preparing for business development activities
+
+## What This Skill Does
+
+1. **Understands Your Business**: Analyzes your product/service, value proposition, and target market
+2. **Identifies Target Companies**: Finds companies that match your ideal customer profile based on:
+   - Industry and sector
+   - Company size and location
+   - Technology stack and tools they use
+   - Growth stage and funding
+   - Pain points your product solves
+3. **Prioritizes Leads**: Ranks companies based on fit score and relevance
+4. **Provides Contact Strategies**: Suggests how to approach each lead with personalized messaging
+5. **Enriches Data**: Gathers relevant information about decision-makers and company context
+
+## How to Use
+
+### Basic Usage
+
+Simply describe your product/service and what you're looking for:
+
+```
+I'm building [product description]. Find me 10 companies in [location/industry] 
+that would be good leads for this.
+```
+
+### With Your Codebase
+
+For even better results, run this from your product's source code directory:
+
+```
+Look at what I'm building in this repository and identify the top 10 companies 
+in [location/industry] that would benefit from this product.
+```
+
+### Advanced Usage
+
+For more targeted research:
+
+```
+My product: [description]
+Ideal customer profile:
+- Industry: [industry]
+- Company size: [size range]
+- Location: [location]
+- Current pain points: [pain points]
+- Technologies they use: [tech stack]
+
+Find me 20 qualified leads with contact strategies for each.
+```
+
+## Instructions
+
+When a user requests lead research:
+
+1. **Understand the Product/Service**
+   - If in a code directory, analyze the codebase to understand the product
+   - Ask clarifying questions about the value proposition
+   - Identify key features and benefits
+   - Understand what problems it solves
+
+2. **Define Ideal Customer Profile**
+   - Determine target industries and sectors
+   - Identify company size ranges
+   - Consider geographic preferences
+   - Understand relevant pain points
+   - Note any technology requirements
+
+3. **Research and Identify Leads**
+   - Search for companies matching the criteria
+   - Look for signals of need (job postings, tech stack, recent news)
+   - Consider growth indicators (funding, expansion, hiring)
+   - Identify companies with complementary products/services
+   - Check for budget indicators
+
+4. **Prioritize and Score**
+   - Create a fit score (1-10) for each lead
+   - Consider factors like:
+     - Alignment with ICP
+     - Signals of immediate need
+     - Budget availability
+     - Competitive landscape
+     - Timing indicators
+
+5. **Provide Actionable Output**
+   
+   For each lead, provide:
+   - **Company Name** and website
+   - **Why They're a Good Fit**: Specific reasons based on their business
+   - **Priority Score**: 1-10 with explanation
+   - **Decision Maker**: Role/title to target (e.g., "VP of Engineering")
+   - **Contact Strategy**: Personalized approach suggestions
+   - **Value Proposition**: How your product solves their specific problem
+   - **Conversation Starters**: Specific points to mention in outreach
+   - **LinkedIn URL**: If available, for easy connection
+
+6. **Format the Output**
+
+   Present results in a clear, scannable format:
+
+   ```markdown
+   # Lead Research Results
+   
+   ## Summary
+   - Total leads found: [X]
+   - High priority (8-10): [X]
+   - Medium priority (5-7): [X]
+   - Average fit score: [X]
+   
+   ---
+   
+   ## Lead 1: [Company Name]
+   
+   **Website**: [URL]
+   **Priority Score**: [X/10]
+   **Industry**: [Industry]
+   **Size**: [Employee count/revenue range]
+   
+   **Why They're a Good Fit**:
+   [2-3 specific reasons based on their business]
+   
+   **Target Decision Maker**: [Role/Title]
+   **LinkedIn**: [URL if available]
+   
+   **Value Proposition for Them**:
+   [Specific benefit for this company]
+   
+   **Outreach Strategy**:
+   [Personalized approach - mention specific pain points, recent company news, or relevant context]
+   
+   **Conversation Starters**:
+   - [Specific point 1]
+   - [Specific point 2]
+   
+   ---
+   
+   [Repeat for each lead]
+   ```
+
+7. **Offer Next Steps**
+   - Suggest saving results to a CSV for CRM import
+   - Offer to draft personalized outreach messages
+   - Recommend prioritization based on timing
+   - Suggest follow-up research for top leads
+
+## Examples
+
+### Example 1: From Lenny's Newsletter
+
+**User**: "I'm building a tool that masks sensitive data in AI coding assistant queries. Find potential leads."
+
+**Output**: Creates a prioritized list of companies that:
+- Use AI coding assistants (Copilot, Cursor, etc.)
+- Handle sensitive data (fintech, healthcare, legal)
+- Have evidence in their GitHub repos of using coding agents
+- May have accidentally exposed sensitive data in code
+- Includes LinkedIn URLs of relevant decision-makers
+
+### Example 2: Local Business
+
+**User**: "I run a consulting practice for remote team productivity. Find me 10 companies in the Bay Area that recently went remote."
+
+**Output**: Identifies companies that:
+- Recently posted remote job listings
+- Announced remote-first policies
+- Are hiring distributed teams
+- Show signs of remote work challenges
+- Provides personalized outreach strategies for each
+
+## Tips for Best Results
+
+- **Be specific** about your product and its unique value
+- **Run from your codebase** if applicable for automatic context
+- **Provide context** about your ideal customer profile
+- **Specify constraints** like industry, location, or company size
+- **Request follow-up** research on promising leads for deeper insights
+
+## Related Use Cases
+
+- Drafting personalized outreach emails after identifying leads
+- Building a CRM-ready CSV of qualified prospects
+- Researching specific companies in detail
+- Analyzing competitor customer bases
+- Identifying partnership opportunities

package/bundles/antigravity-plugin-extras/skills/llm-application-dev/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: llm-application-dev
+context: fork
+description: Building applications with Large Language Models - prompt engineering, RAG patterns, and LLM integration. Use for AI-powered features, chatbots, or LLM-based automation.
+source: wshobson/agents
+license: MIT
+---
+
+# LLM Application Development
+
+## Prompt Engineering
+
+### Structured Prompts
+```typescript
+const systemPrompt = `You are a helpful assistant that answers questions about our product.
+
+RULES:
+- Only answer questions about our product
+- If you don't know, say "I don't know"
+- Keep responses concise (under 100 words)
+- Never make up information
+
+CONTEXT:
+{context}`;
+
+const userPrompt = `Question: {question}`;
+```
+
+### Few-Shot Examples
+```typescript
+const prompt = `Classify the sentiment of customer feedback.
+
+Examples:
+Input: "Love this product!"
+Output: positive
+
+Input: "Worst purchase ever"
+Output: negative
+
+Input: "It works fine"
+Output: neutral
+
+Input: "${customerFeedback}"
+Output:`;
+```
+
+### Chain of Thought
+```typescript
+const prompt = `Solve this step by step:
+
+Question: ${question}
+
+Let's think through this:
+1. First, identify the key information
+2. Then, determine the approach
+3. Finally, calculate the answer
+
+Step-by-step solution:`;
+```
+
+## API Integration
+
+### OpenAI Pattern
+```typescript
+import OpenAI from 'openai';
+
+const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+
+async function chat(messages: Message[]): Promise<string> {
+  const response = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages,
+    temperature: 0.7,
+    max_tokens: 500,
+  });
+
+  return response.choices[0].message.content ?? '';
+}
+```
+
+### Anthropic Pattern
+```typescript
+import Anthropic from '@anthropic-ai/sdk';
+
+const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+async function chat(prompt: string): Promise<string> {
+  const response = await anthropic.messages.create({
+    model: 'claude-3-opus-20240229',
+    max_tokens: 1024,
+    messages: [{ role: 'user', content: prompt }],
+  });
+
+  return response.content[0].type === 'text'
+    ? response.content[0].text
+    : '';
+}
+```
+
+### Streaming Responses
+```typescript
+async function* streamChat(prompt: string) {
+  const stream = await openai.chat.completions.create({
+    model: 'gpt-4',
+    messages: [{ role: 'user', content: prompt }],
+    stream: true,
+  });
+
+  for await (const chunk of stream) {
+    const content = chunk.choices[0]?.delta?.content;
+    if (content) yield content;
+  }
+}
+```
+
+## RAG (Retrieval-Augmented Generation)
+
+### Basic RAG Pipeline
+```typescript
+async function ragQuery(question: string): Promise<string> {
+  // 1. Embed the question
+  const questionEmbedding = await embedText(question);
+
+  // 2. Search vector database
+  const relevantDocs = await vectorDb.search(questionEmbedding, { limit: 5 });
+
+  // 3. Build context
+  const context = relevantDocs.map(d => d.content).join('\n\n');
+
+  // 4. Generate answer
+  const prompt = `Answer based on this context:\n${context}\n\nQuestion: ${question}`;
+  return await chat(prompt);
+}
+```
+
+### Document Chunking
+```typescript
+function chunkDocument(text: string, options: ChunkOptions): string[] {
+  const { chunkSize = 1000, overlap = 200 } = options;
+  const chunks: string[] = [];
+
+  let start = 0;
+  while (start < text.length) {
+    const end = Math.min(start + chunkSize, text.length);
+    chunks.push(text.slice(start, end));
+    start += chunkSize - overlap;
+  }
+
+  return chunks;
+}
+```
+
+### Embedding Storage
+```typescript
+// Using Supabase with pgvector
+async function storeEmbeddings(docs: Document[]) {
+  for (const doc of docs) {
+    const embedding = await embedText(doc.content);
+
+    await supabase.from('documents').insert({
+      content: doc.content,
+      metadata: doc.metadata,
+      embedding: embedding,  // vector column
+    });
+  }
+}
+
+async function searchSimilar(query: string, limit = 5) {
+  const embedding = await embedText(query);
+
+  const { data } = await supabase.rpc('match_documents', {
+    query_embedding: embedding,
+    match_count: limit,
+  });
+
+  return data;
+}
+```
+
+## Error Handling
+
+```typescript
+async function safeLLMCall<T>(
+  fn: () => Promise<T>,
+  options: { retries?: number; fallback?: T }
+): Promise<T> {
+  const { retries = 3, fallback } = options;
+
+  for (let i = 0; i < retries; i++) {
+    try {
+      return await fn();
+    } catch (error) {
+      if (error.status === 429) {
+        // Rate limit - exponential backoff
+        await sleep(Math.pow(2, i) * 1000);
+        continue;
+      }
+      if (i === retries - 1) {
+        if (fallback !== undefined) return fallback;
+        throw error;
+      }
+    }
+  }
+  throw new Error('Max retries exceeded');
+}
+```
+
+## Best Practices
+
+- **Token Management**: Track usage and set limits
+- **Caching**: Cache embeddings and common queries
+- **Evaluation**: Test prompts with diverse inputs
+- **Guardrails**: Validate outputs before using
+- **Logging**: Log prompts and responses for debugging
+- **Cost Control**: Use cheaper models for simple tasks
+- **Latency**: Stream responses for better UX
+- **Privacy**: Don't send PII to external APIs