@opendirectory.dev/skills 0.1.0

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/src/debug.ts

@@ -0,0 +1,23 @@
+// Write a quick script to debug the exact apify item output
+import { ApifyClient } from 'apify-client';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const client = new ApifyClient({
+    token: process.env.APIFY_API_TOKEN,
+});
+
+async function debug() {
+    const input = {
+        "query": '("DevRel hiring" OR "GTM hiring" OR "hiring DevRel" OR "hiring GTM" OR "founding GTM" OR "developer advocate hiring") since:2026-03-10 -is:retweet',
+        "search_type": "Latest",
+        "max_posts": 3
+    };
+
+    console.log('Running debug query...');
+    const run = await client.actor("ghSpYIW3L1RvT57NT").call(input);
+    const { items } = await client.dataset(run.defaultDatasetId).listItems();
+    console.log(JSON.stringify(items[0], null, 2));
+}
+
+debug().catch(console.error);

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/src/extractor.ts

@@ -0,0 +1,79 @@
+import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const apiKey = process.env.GEMINI_API_KEY || '';
+const genAI = new GoogleGenerativeAI(apiKey);
+
+export interface JobExtract {
+    isJobPost: boolean;
+    role: string | null;
+    company: string | null;
+    tweetUrl: string | null;
+    authorProfileUrl: string | null;
+}
+
+export async function extractJobDetails(tweetText: string, authorName: string, authorBio: string, tweetUrl: string, authorProfileUrl: string): Promise<JobExtract> {
+    if (!apiKey) {
+        return {
+            isJobPost: tweetText.toLowerCase().includes('hiring') || tweetText.toLowerCase().includes('role'),
+            role: "Mocked GTM Role",
+            company: "Mocked Company Inc.",
+            tweetUrl,
+            authorProfileUrl
+        };
+    }
+
+    const prompt = `
+You are an AI assistant designed to extract ONLY TECH AND STARTUP job postings from Twitter data.
+
+Your goal is to parse the tweet and the author's profile bio to identify:
+1. Is this a genuine job posting looking to hire someone?
+2. What is the specific role being hired for?
+3. What is the name or domain of the company hiring?
+
+STRICT FILTERING RULES:
+- ONLY mark "isJobPost" as TRUE if the company is a software startup, tech company, developer-first tool, SaaS, or similar.
+- REJECT and mark "isJobPost" as FALSE if the role is for traditional industries (e.g. Automotive, Real Estate, Clinics, generic Recruitment Agencies, HR Trainees, Payroll clerks, etc.).
+- REJECT if the author is just praising someone who used to be a "Founding GTM" or similar. It MUST be an active request to hire someone.
+- Ignore people looking for jobs themselves (e.g., "I am looking for a DevRel role").
+
+If they don't explicitly name the company in the tweet, infer it from their bio (e.g., "Founder @ CompanyX").
+
+Data:
+Tweet Text: "${tweetText}"
+Author Name: "${authorName}"
+Author Bio: "${authorBio}"
+`;
+
+    try {
+        const model = genAI.getGenerativeModel({ 
+            model: "gemini-flash-latest",
+            generationConfig: {
+                responseMimeType: "application/json",
+                responseSchema: {
+                    type: SchemaType.OBJECT,
+                    properties: {
+                        isJobPost: { type: SchemaType.BOOLEAN },
+                        role: { type: SchemaType.STRING, nullable: true },
+                        company: { type: SchemaType.STRING, nullable: true }
+                    },
+                    required: ["isJobPost"]
+                }
+            }
+        });
+
+        const result = await model.generateContent(prompt);
+        const content = result.response.text();
+
+        if (!content) throw new Error("No response from LLM");
+
+        const parsed: JobExtract = JSON.parse(content);
+        parsed.tweetUrl = tweetUrl;
+        parsed.authorProfileUrl = authorProfileUrl;
+        return parsed;
+    } catch (error) {
+        console.error("Error extracting job details:", error);
+        return { isJobPost: false, role: null, company: null, tweetUrl, authorProfileUrl };
+    }
+}

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/src/icp-filter.ts

@@ -0,0 +1,87 @@
+import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
+import { JobExtract } from './extractor';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const apiKey = process.env.GEMINI_API_KEY || '';
+const genAI = new GoogleGenerativeAI(apiKey);
+
+export interface IcpResult extends JobExtract {
+    isICP: boolean;
+    icpReasoning: string;
+    companyUrl: string | null;
+    estimatedFunding: string | null;
+}
+
+export async function evaluateICP(job: JobExtract): Promise<IcpResult> {
+    if (!apiKey) {
+        return { ...job, isICP: false, icpReasoning: "No API Key", companyUrl: null, estimatedFunding: null };
+    }
+
+    const model = genAI.getGenerativeModel({
+        model: "gemini-flash-latest",
+        tools: [
+            { googleSearch: {} } as any
+        ],
+        generationConfig: {
+            responseMimeType: "application/json",
+            responseSchema: {
+                type: SchemaType.OBJECT,
+                properties: {
+                    isICP: { type: SchemaType.BOOLEAN },
+                    icpReasoning: { type: SchemaType.STRING },
+                    companyUrl: { type: SchemaType.STRING, nullable: true },
+                    estimatedFunding: { type: SchemaType.STRING, nullable: true }
+                },
+                required: ["isICP", "icpReasoning"]
+            }
+        }
+    });
+
+    const prompt = `
+You are an M&A/Sales researcher validating a company against a strict ICP (Ideal Customer Profile) checklist.
+Your goal is to use Google Search to research the company and determine if they are an exact match for our ICP.
+
+COMPANY TO RESEARCH: "${job.company}"
+(Role hiring for: "${job.role}")
+
+### ICP CHECKLIST:
+1. Developer-First Product
+- WHAT QUALIFIES: API platforms, infrastructure tools, SDKs, dev utilities, AI agents/automation for technical workflows, DevOps, CI/CD, monitoring, analytics, Code editors, Data infrastructure, LLM deployment platforms.
+- AUTO-SKIP (NOT ICP): Consumer apps, B2C SaaS, HR tools, pure Fintech/healthcare, traditional physical industries, recruiting agencies.
+
+2. Funding Evidence
+- MINIMUM REQUIREMENT: $100K+ raised (verifiable via Crunchbase, YC, press, founder posts).
+- PREFERRED: $500K-$5M seed/Series A in last 18 months. YC, a16z, Sequoia backed.
+- SKIP IF (NOT ICP): Pure bootstrap, absolutely no funding evidence found.
+
+### INSTRUCTIONS:
+1. Use Google Search to find the official website for "${job.company}".
+2. Use Google Search to find funding data (search "${job.company} funding Crunchbase Y Combinator").
+3. Evaluate them strictly against the 2 checklist items above.
+4. If they are a dev-first/infrastructure/AI tool AND have funding, "isICP" must be TRUE.
+5. If they fail EITHER criteria (e.g. consumer app, OR zero funding found), "isICP" must be FALSE.
+6. Provide a concise 1-2 sentence "icpReasoning" explaining exactly what the company does and how much funding you found.
+
+Output valid JSON exactly matching the schema.
+`;
+
+    try {
+        const result = await model.generateContent(prompt);
+        const content = result.response.text();
+        
+        if (!content) throw new Error("No response from LLM");
+        
+        const parsed = JSON.parse(content);
+        return {
+            ...job,
+            isICP: parsed.isICP,
+            icpReasoning: parsed.icpReasoning,
+            companyUrl: parsed.companyUrl || null,
+            estimatedFunding: parsed.estimatedFunding || null
+        };
+    } catch (error) {
+        console.error(`Error evaluating ICP for ${job.company}:`, error);
+        return { ...job, isICP: false, icpReasoning: "Error during evaluation", companyUrl: null, estimatedFunding: null };
+    }
+}

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/src/index.ts

@@ -0,0 +1,94 @@
+import { scrapeTwitterJobs } from './scraper';
+import { extractJobDetails, JobExtract } from './extractor';
+import { evaluateICP, IcpResult } from './icp-filter';
+import fs from 'fs';
+
+async function main() {
+    const maxPosts = parseInt(process.env.MAX_POSTS || '20', 10);
+    
+    const rawTweets = await scrapeTwitterJobs(maxPosts);
+    const radarData: JobExtract[] = [];
+
+    console.log(`\nProcessing ${rawTweets.length} tweets to extract job details...`);
+    const seenJobs = new Set<string>();
+    const seenTweetIds = new Set<string>();
+
+    const extractedResults = await Promise.all(rawTweets.map(async (item: any) => {
+        const itemAny = item;
+        const tweetId = itemAny.tweet_id || itemAny.id_str || itemAny.id || "";
+        
+        const tweetText = itemAny.full_text || itemAny.text || String(itemAny);
+        let authorName = "Unknown";
+        let authorBio = "Unknown";
+        
+        if (itemAny.user_info) {
+            authorName = itemAny.user_info.name || itemAny.user_info.screen_name || "Unknown";
+            authorBio = itemAny.user_info.description || "Unknown";
+        } else if (itemAny.author) {
+            authorName = itemAny.author.name || itemAny.author.userName || "Unknown";
+            authorBio = itemAny.author.description || "Unknown";
+        } else if (itemAny.user) {
+            authorName = itemAny.user.name || itemAny.user.screen_name || "Unknown";
+            authorBio = itemAny.user.description || "Unknown";
+        }
+
+        const authorHandle = itemAny.screen_name || itemAny.user_info?.screen_name || itemAny.author?.userName || itemAny.user?.screen_name || "";
+        const tweetUrl = tweetId && authorHandle ? `https://twitter.com/${authorHandle}/status/${tweetId}` : itemAny.url || "";
+        const authorProfileUrl = authorHandle ? `https://twitter.com/${authorHandle}` : "";
+
+        return {
+            tweetId,
+            extracted: await extractJobDetails(tweetText, authorName, String(authorBio), tweetUrl, authorProfileUrl)
+        };
+    }));
+
+    for (const result of extractedResults) {
+        if (result.tweetId && seenTweetIds.has(result.tweetId)) continue;
+        if (result.tweetId) seenTweetIds.add(result.tweetId);
+
+        const { extracted } = result;
+        if (extracted.isJobPost && extracted.company && extracted.role) {
+            const dedupKey = extracted.company.toLowerCase().replace(/[^a-z0-9]/g, '');
+            if (seenJobs.has(dedupKey)) {
+                console.log(`⚠️ Skipped Duplicate Company: [Role]: ${extracted.role} | [Company]: ${extracted.company}`);
+                continue;
+            }
+            seenJobs.add(dedupKey);
+
+            radarData.push(extracted);
+            console.log(`✅ Added to Radar: [Role]: ${extracted.role} | [Company]: ${extracted.company}`);
+        } else {
+            console.log(`❌ Skipped: Not a valid job post or missing info.`);
+        }
+    }
+
+    fs.writeFileSync('radar-jobs.json', JSON.stringify(radarData, null, 2));
+    console.log(`\n🎉 Step 1 Complete: Found ${radarData.length} valid jobs.`);
+    
+    console.log(`\n🔍 Step 2: Evaluating ${radarData.length} companies against OpenClaw ICP...`);
+    
+    const icpData: IcpResult[] = [];
+    
+    const BATCH_SIZE = 5;
+    for (let i = 0; i < radarData.length; i += BATCH_SIZE) {
+        const batch = radarData.slice(i, i + BATCH_SIZE);
+        console.log(`Researching batch ${i/BATCH_SIZE + 1} (${batch.length} companies)...`);
+        
+        const evaluations = await Promise.all(batch.map(job => evaluateICP(job)));
+        
+        for (const evaluation of evaluations) {
+            if (evaluation.isICP) {
+                console.log(`   🟢 PASSED ICP: ${evaluation.company} - ${evaluation.icpReasoning}`);
+                icpData.push(evaluation);
+            } else {
+                console.log(`   🔴 FAILED ICP: ${evaluation.company} - ${evaluation.icpReasoning}`);
+            }
+        }
+        
+        fs.writeFileSync('openclaw-icp-jobs.json', JSON.stringify(icpData, null, 2));
+    }
+
+    console.log(`\n🎉 Pipeline Complete! Exported ${icpData.length} highly-targeted ICP companies to openclaw-icp-jobs.json.`);
+}
+
+main().catch(console.error);

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/src/scraper.ts

@@ -0,0 +1,41 @@
+import { ApifyClient } from 'apify-client';
+import dotenv from 'dotenv';
+dotenv.config();
+
+const client = new ApifyClient({
+    token: process.env.APIFY_API_TOKEN,
+});
+
+export async function scrapeTwitterJobs(maxPostsPerQuery: number = 20) {
+    console.log('Starting Twitter Job Scraper (Multi-Query Mode)...');
+
+    const lastWeek = new Date();
+    lastWeek.setDate(lastWeek.getDate() - 7);
+    const sinceDate = lastWeek.toISOString().split('T')[0];
+
+    const queries = [
+        `("hiring" OR "looking for" OR "open role") ("DevRel" OR "Developer Advocate" OR "DevRel Intern") since:${sinceDate} -is:retweet`,
+        `("hiring" OR "looking for" OR "open role") ("GTM" OR "go to market" OR "Founding GTM" OR "GTM Lead") since:${sinceDate} -is:retweet`,
+        `("hiring" OR "looking for" OR "open role") ("Growth Lead" OR "Growth Hacker" OR "Head of Growth") since:${sinceDate} -is:retweet`,
+        `("hiring" OR "looking for" OR "open role") ("Developer Marketing" OR "Developer Relations" OR "Community Lead") since:${sinceDate} -is:retweet`,
+        `("hiring DevRel" OR "GTM Engineer" OR "hiring GTM" OR "hiring founding GTM" OR "developer advocate hiring") since:${sinceDate} -is:retweet`
+    ];
+
+    let allItems: any[] = [];
+
+    for (const [index, query] of queries.entries()) {
+        console.log(`\n--- Running Query ${index + 1}/5 ---`);
+        console.log(`Executing query: ${query}`);
+        const input = {
+            "query": query,
+            "search_type": "Latest",
+            "max_posts": maxPostsPerQuery
+        };
+        const run = await client.actor("ghSpYIW3L1RvT57NT").call(input);
+        const { items } = await client.dataset(run.defaultDatasetId).listItems();
+        console.log(`Found ${items.length} tweets for this query.`);
+        allItems = allItems.concat(items);
+    }
+
+    return allItems;
+}

package/skills/twitter-GTM-find-skill/twitter-GTM-find/scripts/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*"]
+}

package/skills/yc-intent-radar-skill/README.md

@@ -0,0 +1,39 @@
+# YC Intent Radar
+
+<img width="1280" height="640" alt="yc-intent-radar-cover" src="https://github.com/user-attachments/assets/2328ae2b-1b5d-45ad-8604-b90721b8d398" />
+
+An automated scraper that pulls job listings and company data from YCombinator's Workatastartup platform. It bypasses login bottlenecks by utilizing authenticated sessions and ensures no duplicates are recorded by saving everything directly to a local SQLite database (`jobs.db`).
+
+## Features
+- **Deduplication:** Utilizes `better-sqlite3` to store state, ensuring you never scrape the same job twice.
+- **Robust Extraction:** Identifies hidden JSON payloads on YC pages to grab accurate backend `job_id` values.
+- **Filtered Exports:** Includes an export script (`export_radar_candidates.js`) that queries the SQLite database for intent-based hiring (e.g., GTM, DevRel, Growth, Content) and outputs it as a JSON payload for secondary research tools.
+
+## Setup
+1. Clone the repository.
+2. Navigate to the `scripts/` directory:
+   ```bash
+   cd scripts
+   npm install
+   npx playwright install
+   ```
+
+3. **Authenticate (First Time Only):**
+   Run the following script and log in to YC via the browser that opens. This creates a `state.json` file.
+   ```bash
+   node auth.js
+   ```
+
+4. **Run the Scraper:**
+   ```bash
+   node scraper.js
+   ```
+
+5. **Export Targeted Jobs:**
+   ```bash
+   node export_radar_candidates.js
+   ```
+   This will query the DB and produce `radar_candidates.json` containing the targeted companies and matching roles.
+
+## Note on Sensitive Files
+The `.gitignore` strictly protects your `state.json` (authentication cookies) and `jobs.db` (local history). Do not commit these files to a public repository.

package/skills/yc-intent-radar-skill/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: yc-intent-radar-skill
+description: A skill for yc-intent-radar-skill
+author: OpenDirectory
+version: 1.0.0
+---
+

package/skills/yc-intent-radar-skill/yc-jobs-scraper/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: yc-jobs-scraper
+description: Scrape daily job listings from YCombinator's Workatastartup platform without duplicates. Use this skill when asked to scrape YC jobs, update the YC companies list, or retrieve the latest startup jobs. It handles authentication, extracts company slugs via Inertia.js JSON payloads, falls back to public YC job pages when necessary, and maintains a local SQLite database to track historical jobs and prevent duplicates.
+---
+
+# YC Jobs Scraper
+
+This skill provides a robust architecture for scraping jobs from YCombinator and `workatastartup.com`. It is designed to run automatically, bypass login bottlenecks, and maintain state to never scrape duplicate jobs.
+
+## Architecture
+
+The scraper uses a hybrid approach to maximize reliability and minimize bot detection:
+
+1. **Authentication:** `scripts/auth.js` uses Playwright to let a human log in once and saves the session to `scripts/state.json`.
+2. **Database:** `scripts/db.js` uses `better-sqlite3` to manage `scripts/jobs.db`. It tracks every `company_slug` and `job_id` ever seen.
+3. **Primary Extraction:** `scripts/scraper.js` loads `state.json`, visits YC query URLs, and extracts company slugs from the hidden Inertia.js `data-page` JSON payload.
+4. **Job Extraction (JSON):** It then visits the authenticated company pages (`/companies/[slug]`) to extract jobs from the backend JSON payload to ensure we get the real `job_id` for accurate deduplication.
+5. **Job Extraction (Fallback):** If the JSON extraction fails, it falls back to parsing public HTML job cards from `ycombinator.com/companies/[slug]/jobs`.
+
+## Workflows
+
+### 1. First-Time Setup
+If this is the first time running the scraper in an environment, or if `node_modules` is missing:
+```bash
+cd @path/scripts
+npm install
+npx playwright install
+```
+
+### 2. Authentication (Manual Step)
+If `scripts/state.json` is missing or expired, the scraper will fail. You must instruct the human user to run the authentication script manually:
+```bash
+cd @path/scripts
+node auth.js
+```
+Tell the user a browser will open, and they must log in. Playwright will automatically save the cookies/tokens to `state.json`.
+
+### 3. Running the Daily Scraper
+To scrape for new companies and jobs:
+```bash
+cd @path/scripts
+node scraper.js
+```
+This script will output exactly how many new companies and new jobs were found. Because of `jobs.db`, running it multiple times consecutively will result in `0 new jobs found`.
+
+### 4. Querying the Database
+If you need to analyze the scraped data or view the companies/jobs, you can query `scripts/jobs.db` directly using `better-sqlite3`.
+
+**Example: Count Companies**
+```bash
+cd @path/scripts
+node -e "const db = require('better-sqlite3')('jobs.db'); console.log('Companies:', db.prepare('SELECT COUNT(*) as count FROM companies').get().count);"
+```
+
+**Example: View Recent Jobs**
+```bash
+cd @path/scripts
+node -e "const db = require('better-sqlite3')('jobs.db'); const jobs = db.prepare('SELECT title, company_slug, location FROM jobs ORDER BY created_at DESC LIMIT 5').all(); console.table(jobs);"
+```

package/skills/yc-intent-radar-skill/yc-jobs-scraper/scripts/auth.js

@@ -0,0 +1,29 @@
+const { chromium } = require('playwright');
+const fs = require('fs');
+
+async function loginAndSaveSession() {
+    console.log('Opening browser for login...');
+    console.log('Please log in manually if you are not prompted.');
+    
+const browser = await chromium.launch({ headless: false });
+    const context = await browser.newContext();
+    const page = await context.newPage();
+
+    console.log('Navigating to YC login page...');
+    await page.goto('https://account.ycombinator.com/?continue=https://www.workatastartup.com/');
+
+    console.log('\n--- ACTION REQUIRED ---');
+    console.log('Please log in using your YC credentials in the browser window.');
+    console.log('Waiting until you are redirected to the workatastartup.com dashboard...\n');
+
+    await page.waitForURL('https://www.workatastartup.com/**', { timeout: 0 });
+
+    console.log('Login successful! Saving session state...');
+    
+    await context.storageState({ path: 'state.json' });
+
+    console.log('Session saved to state.json. You can now run the scraper!');
+    await browser.close();
+}
+
+loginAndSaveSession().catch(console.error);

package/skills/yc-intent-radar-skill/yc-jobs-scraper/scripts/db.js

@@ -0,0 +1,62 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+
+const dbPath = path.join(__dirname, 'jobs.db');
+const db = new Database(dbPath);
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS companies (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    slug TEXT UNIQUE NOT NULL,
+    name TEXT NOT NULL,
+    scraped_at DATETIME DEFAULT CURRENT_TIMESTAMP
+  );
+
+  CREATE TABLE IF NOT EXISTS jobs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    job_id TEXT UNIQUE NOT NULL,
+    company_slug TEXT NOT NULL,
+    title TEXT NOT NULL,
+    location TEXT,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    FOREIGN KEY (company_slug) REFERENCES companies(slug)
+  );
+`);
+
+function insertCompany(slug, name) {
+  try {
+    const stmt = db.prepare('INSERT OR IGNORE INTO companies (slug, name) VALUES (?, ?)');
+    const info = stmt.run(slug, name);
+    return info.changes > 0;
+  } catch (err) {
+    console.error(`Error inserting company ${slug}:`, err);
+    return false;
+  }
+}
+
+function insertJob(jobId, companySlug, title, location) {
+  try {
+    const stmt = db.prepare('INSERT OR IGNORE INTO jobs (job_id, company_slug, title, location) VALUES (?, ?, ?, ?)');
+    const info = stmt.run(jobId, companySlug, title, location);
+    return info.changes > 0;
+  } catch (err) {
+    console.error(`Error inserting job ${jobId}:`, err);
+    return false;
+  }
+}
+
+function getCompany(slug) {
+  return db.prepare('SELECT * FROM companies WHERE slug = ?').get(slug);
+}
+
+function getJob(jobId) {
+  return db.prepare('SELECT * FROM jobs WHERE job_id = ?').get(jobId);
+}
+
+module.exports = {
+  db,
+  insertCompany,
+  insertJob,
+  getCompany,
+  getJob
+};

package/skills/yc-intent-radar-skill/yc-jobs-scraper/scripts/export_radar_candidates.js

@@ -0,0 +1,40 @@
+const Database = require('better-sqlite3');
+const path = require('path');
+const fs = require('fs');
+
+const dbPath = path.join(__dirname, 'jobs.db');
+const db = new Database(dbPath);
+
+const query = `
+  SELECT 
+    c.name as company_name,
+    c.slug as company_slug,
+    GROUP_CONCAT(j.title, ' | ') as matching_roles
+  FROM jobs j 
+  JOIN companies c ON j.company_slug = c.slug 
+  WHERE 
+    j.title LIKE '%GTM%' OR 
+    j.title LIKE '%DevRel%' OR 
+    j.title LIKE '%Growth%' OR 
+    j.title LIKE '%Content%' OR 
+    j.title LIKE '%Marketing%' OR
+    j.title LIKE '%Developer Advocate%' OR
+    j.title LIKE '%Community%'
+  GROUP BY c.slug, c.name
+`;
+
+const rows = db.prepare(query).all();
+
+const candidates = rows.map(row => ({
+  company_name: row.company_name,
+  company_slug: row.company_slug,
+  yc_url: `https://www.ycombinator.com/companies/${row.company_slug}`,
+  matching_roles: row.matching_roles
+}));
+
+fs.writeFileSync(
+  path.join(__dirname, 'radar_candidates.json'), 
+  JSON.stringify(candidates, null, 2)
+);
+
+console.log(`Found ${candidates.length} unique candidate companies hiring for target roles! Saved to radar_candidates.json`);