@opendirectory.dev/skills 0.1.0

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

@@ -0,0 +1,12 @@
+{
+  "name": "yc-jobs-scraper",
+  "version": "1.0.0",
+  "description": "Scrapes Workatastartup and YCombinator for new jobs",
+  "main": "scraper.js",
+  "dependencies": {
+    "better-sqlite3": "^11.10.0",
+    "dotenv": "^16.4.7",
+    "playwright": "^1.50.1",
+    "sqlite3": "^5.1.7"
+  }
+}

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

@@ -0,0 +1,217 @@
+const { chromium } = require('playwright');
+const fs = require('fs');
+const db = require('./db');
+
+const QUERY_URLS = [
+  'https://www.workatastartup.com/companies?companySize=seed&demographic=any&hasEquity=any&hasSalary=any&industry=B2B%20Software%20and%20Services&interviewProcess=any&jobType=fulltime&layout=list-compact&query=GTM&role=marketing&role=sales&sortBy=keyword&tab=any&usVisaNotRequired=any',
+  'https://www.workatastartup.com/companies?companySize=seed&demographic=any&hasEquity=any&hasSalary=any&industry=B2B%20Software%20and%20Services&interviewProcess=any&jobType=fulltime&layout=list-compact&query=Growth&role=sales&role=marketing&sortBy=keyword&tab=any&usVisaNotRequired=any',
+  'https://www.workatastartup.com/companies?companySize=seed&demographic=any&hasEquity=any&hasSalary=any&industry=B2B%20Software%20and%20Services&interviewProcess=any&jobType=fulltime&layout=list-compact&query=Founding%20GTM&role=sales&role=marketing&sortBy=keyword&tab=any&usVisaNotRequired=any',
+  'https://www.workatastartup.com/companies?companySize=seed&demographic=any&hasEquity=any&hasSalary=any&industry=B2B%20Software%20and%20Services&interviewProcess=any&jobType=fulltime&layout=list-compact&query=DevRel&role=sales&role=marketing&sortBy=keyword&tab=any&usVisaNotRequired=any',
+  'https://www.workatastartup.com/companies?companySize=seed&demographic=any&hasEquity=any&hasSalary=any&industry=B2B%20Software%20and%20Services&interviewProcess=any&jobType=fulltime&layout=list-compact&query=creator&role=sales&role=marketing&sortBy=keyword&tab=any&usVisaNotRequired=any'
+];
+
+async function extractCompaniesFromQuery(page, url) {
+  console.log(`Scraping query URL: ${url.substring(0, 100)}...`);
+  await page.goto(url, { waitUntil: 'networkidle' });
+
+  // Wait specifically for the element that contains the data-page attribute
+  try {
+    await page.waitForSelector('[data-page]', { timeout: 10000 });
+  } catch (e) {
+    console.log("Timeout waiting for [data-page]. Page might have failed to load or requires auth.");
+  }
+
+  const companies = await page.evaluate(() => {
+    // Some inertia apps use #app, but let's just find anything with data-page
+    const appDiv = document.querySelector('[data-page]');
+    if (!appDiv) {
+        console.log("CRITICAL: No element with data-page found on the page!");
+        return [];
+    }
+    
+    try {
+      const data = JSON.parse(appDiv.dataset.page);
+      
+      console.log("DATA KEYS:", Object.keys(data));
+      if (data.props) console.log("PROPS KEYS:", Object.keys(data.props));
+      if (data.props && data.props.initialState) console.log("INITIAL STATE KEYS:", Object.keys(data.props.initialState));
+      
+      const results = [];
+      const extractedSlugs = new Set();
+      
+      // Let's try to grab from JSON first (the robust way)
+      if (data && data.props && data.props.companies) {
+         // Usually it's an array or a paginated object
+         const comps = Array.isArray(data.props.companies) ? data.props.companies : (data.props.companies.results || data.props.companies.data || []);
+         for (const c of comps) {
+             if (c.slug) {
+                 extractedSlugs.add(c.slug);
+                 results.push({ slug: c.slug, name: c.name || c.slug });
+             }
+         }
+      }
+
+      // Fallback: If JSON extraction fails, scrape the DOM links
+      if (results.length === 0) {
+          const links = document.querySelectorAll('a[href^="/companies/"]');
+          links.forEach(link => {
+            const href = link.getAttribute('href');
+            const parts = href.split('/');
+            if (parts.length >= 3 && parts[1] === 'companies') {
+              const slug = parts[2];
+              // Ignore standard routes that aren't company slugs
+              if (!['edit', 'new', 'search'].includes(slug) && !extractedSlugs.has(slug)) {
+                extractedSlugs.add(slug);
+                results.push({ slug, name: slug });
+              }
+            }
+          });
+      }
+      
+      return results;
+    } catch (e) {
+      console.error("Error parsing data-page:", e);
+      return [];
+    }
+  });
+  
+  return companies;
+}
+
+async function scrapeCompanyJobs(page, company) {
+  console.log(`Scraping jobs for company: ${company.slug}`);
+  const internalUrl = `https://www.workatastartup.com/companies/${company.slug}`;
+  
+  try {
+    // === METHOD 1: Try authenticated JSON extraction first (Most Reliable) ===
+    await page.goto(internalUrl, { waitUntil: 'networkidle' });
+    
+    try {
+      await page.waitForSelector('[data-page]', { timeout: 8000 });
+      
+      const internalJobs = await page.evaluate(() => {
+        const appDiv = document.querySelector('[data-page]');
+        if (!appDiv) return null;
+        
+        try {
+          const data = JSON.parse(appDiv.dataset.page);
+          const companyData = data.props.company || data.props.rawCompany || {};
+          const jobsList = companyData.jobs || [];
+          
+          if (jobsList.length > 0) {
+            return jobsList.map(job => ({
+              id: job.id ? String(job.id) : null,
+              title: job.title || '',
+              location: job.location || ''
+            }));
+          }
+        } catch (e) {
+          return null;
+        }
+        return null;
+      });
+
+      if (internalJobs && internalJobs.length > 0) {
+        return internalJobs;
+      }
+    } catch (e) {
+      console.log(`  -> Internal JSON extraction failed for ${company.slug}, attempting public fallback...`);
+    }
+
+    // === METHOD 2: Fallback to public HTML extraction (User's Idea) ===
+    const publicUrl = `https://www.ycombinator.com/companies/${company.slug}/jobs`;
+    const response = await page.goto(publicUrl, { waitUntil: 'networkidle' });
+    
+    if (response && response.status() === 404) {
+      console.log(`  -> No public jobs page found for ${company.slug}`);
+      return [];
+    }
+
+    const publicJobs = await page.evaluate(() => {
+      const jobCards = Array.from(document.querySelectorAll('.flex.w-full.flex-row.justify-between'));
+      const parsedJobs = [];
+
+      for (let i = 0; i < jobCards.length; i++) {
+        const card = jobCards[i];
+        const titleEl = card.querySelector('.font-bold');
+        const title = titleEl ? titleEl.textContent.trim() : null;
+
+        if (title) {
+          const detailsEl = card.querySelectorAll('div > span');
+          let location = "Unknown";
+          
+          if (detailsEl.length > 0) {
+            location = detailsEl[0].textContent.trim();
+          }
+
+          parsedJobs.push({
+            id: `yc_${Date.now()}_${i}_${title.replace(/\s+/g, '_')}`,
+            title: title,
+            location: location
+          });
+        }
+      }
+      return parsedJobs;
+    });
+
+    return publicJobs;
+
+  } catch (error) {
+    console.error(`Error scraping jobs for ${company.slug}:`, error.message);
+    return [];
+  }
+}
+
+async function runScraper() {
+  if (!fs.existsSync('state.json')) {
+    console.error('ERROR: state.json not found. Please run auth.js first to log in.');
+    process.exit(1);
+  }
+
+  const browser = await chromium.launch({ headless: true });
+  const context = await browser.newContext({ storageState: 'state.json' });
+  const page = await context.newPage();
+
+  const allFoundCompanies = new Map();
+
+  for (const url of QUERY_URLS) {
+    const companies = await extractCompaniesFromQuery(page, url);
+    for (const c of companies) {
+      if (!allFoundCompanies.has(c.slug)) {
+        allFoundCompanies.set(c.slug, c);
+      }
+    }
+  }
+
+  console.log(`Found ${allFoundCompanies.size} unique companies across all queries.`);
+
+  let newCompaniesCount = 0;
+  let newJobsCount = 0;
+
+  for (const [slug, company] of allFoundCompanies) {
+    const isNewCompany = db.insertCompany(slug, company.name);
+    if (isNewCompany) newCompaniesCount++;
+
+    const jobs = await scrapeCompanyJobs(page, company);
+    
+    for (const job of jobs) {
+      if (job.id && job.title) {
+        const isNewJob = db.insertJob(job.id, slug, job.title, job.location);
+        if (isNewJob) {
+          console.log(`[NEW JOB] ${slug} - ${job.title} (${job.location})`);
+          newJobsCount++;
+        }
+      }
+    }
+    
+    await page.waitForTimeout(1000);
+  }
+
+  console.log('--- SCRAPE COMPLETE ---');
+  console.log(`New Companies Added: ${newCompaniesCount}`);
+  console.log(`New Jobs Found: ${newJobsCount}`);
+
+  await browser.close();
+}
+
+runScraper().catch(console.error);

package/src/e2e.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { execSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+describe('CLI End-to-End Tests', () => {
+  let tempDir: string;
+  let cliPath: string;
+
+  beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'opendirectory-cli-test-'));
+    cliPath = path.resolve(__dirname, '../dist/index.js');
+    
+    if (!fs.existsSync(cliPath)) {
+      execSync('pnpm run build', { cwd: path.resolve(__dirname, '..') });
+    }
+  });
+
+  afterAll(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should install a skill for opencode locally', () => {
+    const skillName = 'claude-md-generator';
+    
+    execSync(`node "${cliPath}" install ${skillName} --target opencode`, { cwd: tempDir });
+    
+    const expectedPath = path.join(tempDir, '.opencode', 'skills', skillName, 'SKILL.md');
+    expect(fs.existsSync(expectedPath)).toBe(true);
+    
+    const content = fs.readFileSync(expectedPath, 'utf-8');
+    expect(content.length).toBeGreaterThan(0);
+  });
+});

package/src/fs-adapters.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { resolvePath, safeWriteFile, safeAppendFile } from './fs-adapters';
+
+describe('fs-adapters', () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'fs-adapters-test-'));
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('resolvePath', () => {
+    it('should resolve ~ to home directory', () => {
+      const home = os.homedir();
+      expect(resolvePath('~/foo/bar')).toBe(path.join(home, 'foo/bar'));
+      expect(resolvePath('~')).toBe(home);
+    });
+
+    it('should resolve absolute paths', () => {
+      const absPath = path.resolve('/foo/bar');
+      expect(resolvePath('/foo/bar')).toBe(absPath);
+    });
+
+    it('should resolve relative paths', () => {
+      const relPath = path.resolve('foo/bar');
+      expect(resolvePath('foo/bar')).toBe(relPath);
+    });
+  });
+
+  describe('safeWriteFile', () => {
+    it('should create directory and write file', async () => {
+      const filePath = path.join(tempDir, 'nested', 'dir', 'test.txt');
+      await safeWriteFile(filePath, 'hello world');
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toBe('hello world');
+    });
+
+    it('should overwrite existing file', async () => {
+      const filePath = path.join(tempDir, 'test.txt');
+      await safeWriteFile(filePath, 'hello world');
+      await safeWriteFile(filePath, 'new content');
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toBe('new content');
+    });
+  });
+
+  describe('safeAppendFile', () => {
+    it('should create file if it does not exist', async () => {
+      const filePath = path.join(tempDir, 'nested', 'test.txt');
+      await safeAppendFile(filePath, 'hello world');
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toBe('hello world');
+    });
+
+    it('should append to existing file', async () => {
+      const filePath = path.join(tempDir, 'test.txt');
+      await safeWriteFile(filePath, 'line 1\n');
+      await safeAppendFile(filePath, 'line 2');
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toBe('line 1\nline 2');
+    });
+
+    it('should add newline if existing file does not end with one', async () => {
+      const filePath = path.join(tempDir, 'test.txt');
+      await safeWriteFile(filePath, 'line 1');
+      await safeAppendFile(filePath, 'line 2');
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toBe('line 1\nline 2');
+    });
+
+    it('should not append if content already exists', async () => {
+      const filePath = path.join(tempDir, 'test.txt');
+      await safeWriteFile(filePath, 'existing content\nmore stuff');
+      await safeAppendFile(filePath, 'existing content');
+      
+      const content = await fs.readFile(filePath, 'utf-8');
+      expect(content).toBe('existing content\nmore stuff');
+    });
+  });
+});

package/src/fs-adapters.ts

@@ -0,0 +1,65 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+
+export function resolvePath(p: string): string {
+  if (p.startsWith('~/') || p === '~') {
+    return path.resolve(p.replace(/^~/, os.homedir()));
+  }
+  return path.resolve(p);
+}
+
+export async function safeWriteFile(filePath: string, content: string): Promise<void> {
+  const resolvedPath = resolvePath(filePath);
+  const dir = path.dirname(resolvedPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(resolvedPath, content, 'utf-8');
+}
+
+export async function safeAppendFile(filePath: string, content: string): Promise<void> {
+  const resolvedPath = resolvePath(filePath);
+  const dir = path.dirname(resolvedPath);
+  await fs.mkdir(dir, { recursive: true });
+
+  try {
+    const existingContent = await fs.readFile(resolvedPath, 'utf-8');
+    if (existingContent.includes(content)) {
+      return;
+    }
+    
+    const prefix = existingContent.length > 0 && !existingContent.endsWith('\n') ? '\n' : '';
+    await fs.appendFile(resolvedPath, prefix + content, 'utf-8');
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      await fs.writeFile(resolvedPath, content, 'utf-8');
+    } else {
+      throw error;
+    }
+  }
+}
+
+export async function updateHermesConfig(): Promise<void> {
+  const configPath = resolvePath('~/.hermes/config.yaml');
+  
+  try {
+    let content = await fs.readFile(configPath, 'utf-8');
+    
+    if (!content.includes('skills:')) {
+      const prefix = content.length > 0 && !content.endsWith('\n') ? '\n' : '';
+      content += prefix + 'skills:\n  external_dirs:\n    - "./.hermes/skills"\n';
+    } else if (!content.includes('external_dirs:')) {
+      content = content.replace(/(skills:\s*\n)/, '$1  external_dirs:\n    - "./.hermes/skills"\n');
+    } else if (!content.includes('./.hermes/skills')) {
+      content = content.replace(/(external_dirs:\s*\n)/, '$1    - "./.hermes/skills"\n');
+    }
+    
+    await fs.writeFile(configPath, content, 'utf-8');
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      const initialContent = `skills:\n  external_dirs:\n    - "./.hermes/skills"\n`;
+      await safeWriteFile('~/.hermes/config.yaml', initialContent);
+    } else {
+      throw error;
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { Skill } from './transformers';
+import { safeWriteFile } from './fs-adapters';
+import chalk from 'chalk';
+import ora from 'ora';
+import Table from 'cli-table3';
+
+const program = new Command();
+
+program
+  .name('@opendirectory.dev/cli')
+  .description(chalk.blue.bold('CLI to install OpenDirectory skills'))
+  .version('0.1.0');
+
+const getProjectRoot = () => {
+  return path.resolve(__dirname, '..');
+};
+
+program
+  .command('list')
+  .description('List available skills in the Open Directory registry')
+  .action(async () => {
+    const spinner = ora('Fetching available skills...').start();
+    try {
+      const root = getProjectRoot();
+      const registryPath = path.join(root, 'registry.json');
+      
+      let skills: any[] = [];
+      try {
+        const registryContent = await fs.readFile(registryPath, 'utf-8');
+        skills = JSON.parse(registryContent);
+      } catch (e) {
+        const skillsDir = path.join(root, 'skills');
+        const entries = await fs.readdir(skillsDir, { withFileTypes: true });
+        skills = entries
+          .filter(entry => entry.isDirectory())
+          .map(entry => ({ name: entry.name, description: `Skill: ${entry.name}` }));
+      }
+
+      spinner.stop();
+      console.log(chalk.green('Successfully loaded Open Directory registry!\n'));
+
+      const table = new Table({
+        head: [chalk.cyan.bold('Skill Name'), chalk.cyan.bold('Description')],
+        colWidths: [35, 75],
+        wordWrap: true
+      });
+
+      for (const skill of skills) {
+        let desc = skill.description || '';
+        desc = desc.replace(/<img[^>]*>/g, '').trim();
+        if (desc.length > 100) desc = desc.substring(0, 97) + '...';
+        
+        table.push([chalk.yellow(skill.name), desc]);
+      }
+      
+      console.log(table.toString());
+      console.log(chalk.gray(`\nRun \`${chalk.white('npx @opendirectory.dev/cli install <skill-name> --target <agent>')}\` to install a skill.`));
+
+    } catch (error) {
+      spinner.stop();
+      console.error(chalk.red('Failed to list skills.'));
+      console.error(error);
+    }
+  });
+
+program
+  .command('install <skill>')
+  .description('Install a skill for your AI agent')
+  .requiredOption('-t, --target <tool>', 'Target agent (opencode, claude, codex, gemini, anti-gravity, openclaw, hermes)')
+  .option('-g, --global', 'Install globally for all projects')
+  .action(async (skillName, options) => {
+    const spinner = ora(`Installing ${chalk.yellow(skillName)}...`).start();
+    try {
+      const root = getProjectRoot();
+      const repoDir = path.join(root, 'skills', skillName);
+      
+      let skillDir = repoDir;
+      let skillMdPath = path.join(skillDir, 'SKILL.md');
+      
+      try {
+        await fs.access(skillMdPath);
+      } catch (e) {
+        try {
+          const entries = await fs.readdir(repoDir, { withFileTypes: true });
+          for (const entry of entries) {
+            if (entry.isDirectory()) {
+              const possiblePath = path.join(repoDir, entry.name, 'SKILL.md');
+              try {
+                await fs.access(possiblePath);
+                skillDir = path.join(repoDir, entry.name);
+                skillMdPath = possiblePath;
+                break;
+              } catch (err) {}
+            }
+          }
+          if (skillDir === repoDir) {
+            for (const entry of entries) {
+              if (entry.isDirectory() && entry.name !== 'node_modules' && entry.name !== '.git') {
+                const subDir = path.join(repoDir, entry.name);
+                const subEntries = await fs.readdir(subDir, { withFileTypes: true });
+                for (const subEntry of subEntries) {
+                  if (subEntry.isDirectory()) {
+                    const possiblePath = path.join(subDir, subEntry.name, 'SKILL.md');
+                    try {
+                      await fs.access(possiblePath);
+                      skillDir = path.join(subDir, subEntry.name);
+                      skillMdPath = possiblePath;
+                      break;
+                    } catch (err) {}
+                  }
+                }
+              }
+            }
+          }
+        } catch (dirErr) {
+          spinner.stop();
+          console.error(chalk.red(`Error: Repository '${skillName}' not found.`));
+          console.log(chalk.gray(`Try running \`${chalk.white('npx @opendirectory.dev/cli list')}\` to see available skills.`));
+          process.exit(1);
+        }
+      }
+
+      try {
+        await fs.access(skillMdPath);
+      } catch (e) {
+        spinner.stop();
+        console.error(chalk.red(`Error: Skill '${skillName}' missing SKILL.md in registry.`));
+        process.exit(1);
+      }
+      
+      const actualSkillFolderName = path.basename(skillDir);
+      const finalSkillName = actualSkillFolderName === skillName ? skillName : actualSkillFolderName;
+
+      const target = options.target.toLowerCase();
+      const isGlobal = options.global;
+
+      const validTargets = ['opencode', 'claude', 'codex', 'gemini', 'anti-gravity', 'openclaw', 'hermes'];
+
+      if (validTargets.includes(target)) {
+        let targetFolder = '';
+        if (target === 'opencode') targetFolder = isGlobal ? `~/.config/opencode/skills/${finalSkillName}` : `./.opencode/skills/${finalSkillName}`;
+        if (target === 'claude') targetFolder = isGlobal ? `~/.claude/skills/${finalSkillName}` : `./.claude/skills/${finalSkillName}`;
+        if (target === 'codex') targetFolder = isGlobal ? `~/.codex/skills/${finalSkillName}` : `./.codex/skills/${finalSkillName}`;
+        if (target === 'gemini') targetFolder = isGlobal ? `~/.gemini/skills/${finalSkillName}` : `./.gemini/skills/${finalSkillName}`;
+        if (target === 'anti-gravity') targetFolder = isGlobal ? `~/.gemini/antigravity/skills/${finalSkillName}` : `./.agent/skills/${finalSkillName}`;
+        if (target === 'openclaw') targetFolder = isGlobal ? `~/.openclaw/skills/${finalSkillName}` : `./.openclaw/skills/${finalSkillName}`;
+        if (target === 'hermes') targetFolder = isGlobal ? `~/.hermes/skills/${finalSkillName}` : `./.hermes/skills/${finalSkillName}`;
+        
+        const { resolvePath, updateHermesConfig } = require('./fs-adapters');
+        const resolvedDest = resolvePath(targetFolder);
+        await fs.mkdir(resolvedDest, { recursive: true });
+        await fs.cp(skillDir, resolvedDest, { recursive: true });
+        
+        if (target === 'hermes' && !isGlobal) {
+          await updateHermesConfig();
+        }
+        
+        spinner.stop();
+        console.log(chalk.green(`Successfully installed ${chalk.bold(finalSkillName)}!`));
+        console.log(`\n  ${chalk.cyan('Agent:')}   ${target}`);
+        console.log(`  ${chalk.cyan('Scope:')}   ${isGlobal ? 'Global' : 'Local Project'}`);
+        console.log(`  ${chalk.cyan('Path:')}    ${targetFolder}\n`);
+      } else {
+        spinner.stop();
+        console.error(chalk.red(`Error: Unsupported target '${target}'.`));
+        console.log(chalk.gray(`Supported targets: ${validTargets.join(', ')}`));
+        process.exit(1);
+      }
+    } catch (error) {
+      spinner.stop();
+      console.error(chalk.red('Failed to install skill.'));
+      console.error(error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/transformers.ts

@@ -0,0 +1,6 @@
+export interface Skill {
+  name: string;
+  description: string;
+  content: string;
+  globs?: string;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*"]
+}