@opendirectory.dev/skills 0.1.0

package/skills/hackernews-intel/README.md

@@ -0,0 +1,161 @@
+# hackernews-intel
+
+<img width="1280" height="640" alt="hackernews-intel" src="https://github.com/user-attachments/assets/8d75cba9-7c2b-4693-8365-00779ed2b3d3" />
+
+
+Monitor Hacker News for keywords. Get a Slack alert every time a new post matches your topics, without duplicates. Run it manually, on a cron schedule, or via GitHub Actions.
+
+## What It Does
+
+- Fetches new posts from HN using the free Algolia search API (no API key needed)
+- Checks each match against a local SQLite cache and never alerts on the same post twice
+- Sends a Slack notification with title, URL, points, and comment count
+- Supports dry-run mode to preview matches without sending alerts
+- Configurable lookback window, minimum points threshold, and comment inclusion
+
+## Requirements
+
+| Requirement | Purpose | Where to Get It |
+|------------|---------|-----------------|
+| HN_KEYWORDS | Keywords to monitor | Set in .env, comma-separated list |
+| SLACK_WEBHOOK | Slack alerts | https://api.slack.com/apps, Incoming Webhooks |
+| Node.js 20+ | Running the script | https://nodejs.org |
+
+No API key needed for Hacker News. The HN Algolia API is free and public.
+
+## Setup
+
+### 1. Install dependencies
+
+```bash
+cd hackernews-intel
+npm install
+```
+
+### 2. Configure environment variables
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env`:
+
+```bash
+HN_KEYWORDS=claude code,LLM agents,deno runtime
+SLACK_WEBHOOK=https://hooks.slack.com/services/your/webhook/url
+HN_MIN_POINTS=0
+```
+
+### 3. Create a Slack webhook
+
+1. Go to https://api.slack.com/apps and create or select your app
+2. Enable "Incoming Webhooks" in the app settings
+3. Add a webhook to your workspace and select the target channel
+4. Copy the webhook URL (starts with `https://hooks.slack.com/services/`)
+5. Set it as `SLACK_WEBHOOK` in `.env`
+
+## How to Use
+
+Preview the last 7 days without sending alerts:
+
+```bash
+npm run dry-run:week
+# or
+node scripts/monitor-hn.js --dry-run --days=7
+```
+
+Live run:
+
+```bash
+npm run monitor
+# or
+node scripts/monitor-hn.js
+```
+
+Schedule via cron (every 4 hours):
+
+```bash
+crontab -e
+# Add:
+0 */4 * * * cd /path/to/hackernews-intel && node scripts/monitor-hn.js >> /tmp/hn-intel.log 2>&1
+```
+
+Schedule via GitHub Actions:
+
+```yaml
+name: HN Intel Monitor
+on:
+  schedule:
+    - cron: '0 */4 * * *'
+  workflow_dispatch:
+jobs:
+  monitor:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - run: npm install
+      - run: node scripts/monitor-hn.js
+        env:
+          HN_KEYWORDS: ${{ secrets.HN_KEYWORDS }}
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+```
+
+Add `HN_KEYWORDS` and `SLACK_WEBHOOK` as repository secrets.
+
+## Slack Alert Format
+
+Each alert looks like:
+
+```
+Story Title Here
+47 points  23 comments  authorname
+Keyword: claude code  |  HN discussion
+```
+
+## Options
+
+| Variable | Default | Purpose |
+|----------|---------|---------|
+| `HN_KEYWORDS` | required | Comma-separated keywords |
+| `SLACK_WEBHOOK` | required | Slack Incoming Webhook URL |
+| `HN_MIN_POINTS` | `0` | Minimum points to alert |
+| `HN_INCLUDE_COMMENTS` | `false` | Also monitor HN comments |
+| `HN_DB_PATH` | `./hn-intel.db` | SQLite cache file path |
+
+## CLI Flags
+
+| Flag | Purpose |
+|------|---------|
+| `--dry-run` | Preview matches without sending Slack alerts |
+| `--days=N` | Lookback window for the first run (default: 1) |
+| `--reset` | Clear the cache and start fresh |
+
+## GitHub Actions Note
+
+GitHub Actions does not persist files between workflow runs. The SQLite cache resets on each run, and the script re-fetches the last 1 day of posts every time. Posts from the previous run will be alerted again.
+
+To fix this, either:
+- Store `hn-intel.db` in an S3 bucket and download/upload it around the script run
+- Use a self-hosted runner with persistent storage
+- Use a cron job on your own machine instead
+
+## Project Structure
+
+```
+hackernews-intel/
+├── SKILL.md
+├── README.md
+├── .env.example
+├── package.json
+├── evals/
+│   └── evals.json
+└── scripts/
+    └── monitor-hn.js
+```
+
+## License
+
+MIT

package/skills/hackernews-intel/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: hackernews-intel
+description: Monitors Hacker News for user-configured keywords, deduplicates against a local SQLite cache, and sends Slack alerts for new matching posts. Use when asked to monitor Hacker News for mentions, track keywords on HN, get alerts when something is posted about a topic on Hacker News, or set up HN keyword monitoring. Trigger when a user mentions Hacker News alerts, HN monitoring, keyword tracking on HN, or wants to know when a topic appears on Hacker News.
+compatibility: [claude-code, gemini-cli, github-copilot]
+author: OpenDirectory
+version: 1.0.0
+---
+
+# Hacker News Intel
+
+Monitor Hacker News for keywords. On each run, fetch new posts via the HN Algolia API, deduplicate against a local SQLite cache, and send Slack alerts for unseen matches. Run manually or schedule via cron or GitHub Actions.
+
+---
+
+## Step 1: Check Setup
+
+**1a. Verify required environment variables**
+
+Check that these are set:
+- `HN_KEYWORDS` (required): comma-separated list of keywords to monitor
+- `SLACK_WEBHOOK` (required): Slack Incoming Webhook URL for alerts
+
+If either is missing, stop and tell the user:
+- `HN_KEYWORDS`: list the topics you want to monitor, comma-separated. Example: `claude code,LLM agents,deno runtime`
+- `SLACK_WEBHOOK`: create an Incoming Webhook at https://api.slack.com/apps. Select your workspace, enable Incoming Webhooks, and copy the URL.
+
+**1b. Verify script dependencies**
+
+```bash
+ls /Users/ksd/Desktop/Varnan_skills/hackernews-intel/node_modules/better-sqlite3 2>/dev/null
+```
+
+If missing:
+
+```bash
+cd /Users/ksd/Desktop/Varnan_skills/hackernews-intel && npm install
+```
+
+---
+
+## Step 2: Run the Monitor
+
+```bash
+cd /Users/ksd/Desktop/Varnan_skills/hackernews-intel && node scripts/monitor-hn.js
+```
+
+**Flags:**
+- `--dry-run`: print matches to stdout without sending any Slack alerts. Use this to preview what would be alerted before committing.
+- `--days=N`: on the first run, look back N days (default: 1). Only applies when the SQLite cache is empty.
+- `--reset`: clear the cache and start fresh. Use when you change your keyword list significantly.
+
+**What the script does:**
+1. Reads `HN_KEYWORDS` from environment, splits by comma, trims whitespace
+2. Opens (or creates) a SQLite database at the path in `HN_DB_PATH` (default: `./hn-intel.db`)
+3. For each keyword, calls `https://hn.algolia.com/api/v1/search_by_date` with `numericFilters=created_at_i>lastSeen`
+4. For each result, checks if the `objectID` is already in `seen_posts` — skips if yes
+5. If `HN_MIN_POINTS` is set, skips posts below that threshold
+6. For new matching posts, sends a Slack alert and inserts the `objectID` into the cache
+7. Updates `poll_log` with the run summary
+8. Prints a summary to stdout
+
+---
+
+## Step 3: Review Results
+
+After the script runs, read its stdout output. It will report:
+
+```
+Run complete.
+  Keywords checked: N
+  Posts found: N
+  Posts alerted: N
+  Posts skipped (already seen): N
+  Errors: N
+```
+
+If `Posts found: 0` and you expect results, check:
+- Are the keywords specific enough? Very broad terms (e.g. "AI") may return 0 results if HN Algolia returns too many and the time window is narrow
+- Is the `--days` window large enough for the first run? Try `--days=7`
+- Is the DB cache too aggressive? Try `--reset` to clear it and rerun
+
+If `Posts alerted: 0` but `Posts found: N`, the deduplication is working — those posts were seen in a previous run.
+
+---
+
+## Step 4: Schedule the Monitor
+
+**Option A: cron (macOS/Linux)**
+
+Add to crontab to run every 4 hours:
+
+```bash
+crontab -e
+```
+
+Add this line (adjust the path to match your install):
+
+```
+0 */4 * * * cd /Users/ksd/Desktop/Varnan_skills/hackernews-intel && node scripts/monitor-hn.js >> /tmp/hn-intel.log 2>&1
+```
+
+**Option B: GitHub Actions (recommended for teams)**
+
+Create `.github/workflows/hn-intel.yml` in any repo:
+
+```yaml
+name: HN Intel Monitor
+on:
+  schedule:
+    - cron: '0 */4 * * *'
+  workflow_dispatch:
+
+jobs:
+  monitor:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      - name: Install dependencies
+        run: npm install
+        working-directory: hackernews-intel
+      - name: Run monitor
+        run: node scripts/monitor-hn.js
+        working-directory: hackernews-intel
+        env:
+          HN_KEYWORDS: ${{ secrets.HN_KEYWORDS }}
+          SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK }}
+          HN_MIN_POINTS: ${{ secrets.HN_MIN_POINTS }}
+```
+
+Add `HN_KEYWORDS`, `SLACK_WEBHOOK`, and optionally `HN_MIN_POINTS` as repository secrets.
+
+Note: GitHub Actions does not persist files between runs, so the SQLite cache resets each run. This means every run will find all posts within the default 1-day lookback window again. For persistent dedup on GitHub Actions, store the DB in a persistent location (S3, artifact cache, or a dedicated branch).
+
+---
+
+## Step 5: Tune Keywords and Thresholds
+
+**Adding or changing keywords:**
+Update `HN_KEYWORDS` in your `.env` or environment. No restart needed — the script reads it fresh each run.
+
+**Setting a minimum points threshold:**
+Set `HN_MIN_POINTS=10` to only alert on posts with 10 or more points. This cuts noise for broad keywords.
+
+**Including comments (not just stories):**
+Set `HN_INCLUDE_COMMENTS=true` to also monitor comments mentioning the keyword. Off by default — comments generate significantly more volume.
+
+**Resetting the cache:**
+Run `node scripts/monitor-hn.js --reset` to clear `seen_posts` and `poll_log`. The next run fetches fresh from the lookback window.
+
+**Testing a new keyword:**
+Run `node scripts/monitor-hn.js --dry-run --days=7` to see the last 7 days of matching posts without alerting anyone.
+
+

package/skills/hackernews-intel/evals/evals.json

@@ -0,0 +1,35 @@
+{
+  "skill_name": "hackernews-intel",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "Set up HN monitoring for my product — monitor for 'claude code' and 'anthropic' mentions",
+      "expected_output": "Agent checks HN_KEYWORDS and SLACK_WEBHOOK are set. Runs npm install if node_modules is missing. Runs node scripts/monitor-hn.js --dry-run --days=7 first to show what posts would have been found in the last week. Reports the found posts with titles, URLs, points, and authors. Asks user to confirm the keywords look right before setting up live monitoring. On confirmation, runs node scripts/monitor-hn.js for a live run.",
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "Run the HN monitor again",
+      "expected_output": "Agent runs node scripts/monitor-hn.js. The script reads the existing SQLite cache (hn-intel.db). For each keyword, it calls search_by_date with numericFilters=created_at_i>MAX(created_at_i from seen_posts). Only posts with objectIDs not in seen_posts are alerted. Script prints 'Posts skipped (already seen): N' showing the deduplication is working. New posts (if any) are alerted to Slack and inserted into the cache.",
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "Preview what the monitor would alert without sending anything to Slack",
+      "expected_output": "Agent runs node scripts/monitor-hn.js --dry-run. Script fetches posts, checks dedup, but does NOT call the Slack webhook. Prints each matching new post with title, URL, points, and author. Prints '[DRY RUN] Would send Slack alert' for each. Final summary shows 'Alerts sent: N (dry run)' indicating no real alerts were sent.",
+      "files": []
+    },
+    {
+      "id": 4,
+      "prompt": "The monitor found nothing — I know there were posts about 'deno' this week",
+      "expected_output": "Agent diagnoses the issue. First checks if HN_MIN_POINTS is too high (filtering out low-point posts). Then runs node scripts/monitor-hn.js --dry-run --days=7 to widen the lookback window. If the cache was recently reset or this is the first run, the default 1-day window may miss older posts. If still no results after --days=7, checks if the keyword in the cache covers the exact term — 'deno' as a keyword may not match 'Deno 2.0' in the title without substring matching. Reports findings clearly.",
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "Set up a cron job to run HN monitoring every 4 hours",
+      "expected_output": "Agent shows the user how to add a crontab entry: '0 */4 * * * cd /path/to/hackernews-intel && node scripts/monitor-hn.js >> /tmp/hn-intel.log 2>&1'. Also shows the GitHub Actions workflow YAML as an alternative. Notes that GitHub Actions does not persist the SQLite file between runs, so the DB resets each run — explains the tradeoff (more re-alerts vs self-hosting). Recommends self-hosted cron if persistent dedup is needed.",
+      "files": []
+    }
+  ]
+}

package/skills/hackernews-intel/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "hackernews-intel",
+  "version": "1.0.0",
+  "description": "Monitor Hacker News for keywords and send Slack alerts for new matching posts",
+  "type": "module",
+  "scripts": {
+    "monitor": "node scripts/monitor-hn.js",
+    "dry-run": "node scripts/monitor-hn.js --dry-run",
+    "dry-run:week": "node scripts/monitor-hn.js --dry-run --days=7",
+    "reset": "node scripts/monitor-hn.js --reset"
+  },
+  "dependencies": {
+    "better-sqlite3": "^9.4.3"
+  }
+}

package/skills/hackernews-intel/scripts/monitor-hn.js

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * monitor-hn.js
+ * Monitors Hacker News for keywords via the Algolia search API.
+ * Deduplicates via SQLite. Sends Slack alerts for new matching posts.
+ *
+ * Usage:
+ *   node monitor-hn.js                  # Normal run
+ *   node monitor-hn.js --dry-run        # Preview matches, no Slack alerts
+ *   node monitor-hn.js --days=7         # Look back 7 days on first run
+ *   node monitor-hn.js --reset          # Clear cache and start fresh
+ *
+ * Required env vars:
+ *   HN_KEYWORDS     Comma-separated keywords (e.g. "claude code,LLM agents,deno")
+ *   SLACK_WEBHOOK   Slack Incoming Webhook URL
+ *
+ * Optional env vars:
+ *   HN_MIN_POINTS        Minimum points to alert (default: 0 = all posts)
+ *   HN_INCLUDE_COMMENTS  Include comments in search (default: false)
+ *   HN_DB_PATH           SQLite DB file path (default: ./hn-intel.db)
+ */
+
+import Database from 'better-sqlite3';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Parse CLI args
+const args = process.argv.slice(2);
+const DRY_RUN = args.includes('--dry-run');
+const RESET = args.includes('--reset');
+const daysArg = args.find(a => a.startsWith('--days='));
+const FIRST_RUN_DAYS = daysArg ? parseInt(daysArg.split('=')[1], 10) : 1;
+
+// Config from environment
+const RAW_KEYWORDS = process.env.HN_KEYWORDS || '';
+const SLACK_WEBHOOK = process.env.SLACK_WEBHOOK || '';
+const MIN_POINTS = parseInt(process.env.HN_MIN_POINTS || '0', 10);
+const INCLUDE_COMMENTS = process.env.HN_INCLUDE_COMMENTS === 'true';
+const DB_PATH = process.env.HN_DB_PATH || join(__dirname, '..', 'hn-intel.db');
+
+// Validate required config
+if (!RAW_KEYWORDS.trim()) {
+  console.error('ERROR: HN_KEYWORDS is not set.');
+  console.error('Set it to a comma-separated list: HN_KEYWORDS="claude code,LLM agents"');
+  process.exit(1);
+}
+
+if (!SLACK_WEBHOOK && !DRY_RUN) {
+  console.error('ERROR: SLACK_WEBHOOK is not set.');
+  console.error('Create one at: https://api.slack.com/apps');
+  console.error('Or run with --dry-run to preview without sending alerts.');
+  process.exit(1);
+}
+
+const keywords = RAW_KEYWORDS.split(',').map(k => k.trim()).filter(Boolean);
+
+// Initialize SQLite
+const db = new Database(DB_PATH);
+
+if (RESET) {
+  db.exec('DROP TABLE IF EXISTS seen_posts');
+  db.exec('DROP TABLE IF EXISTS poll_log');
+  console.log('Cache cleared.');
+}
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS seen_posts (
+    objectID   TEXT PRIMARY KEY,
+    title      TEXT,
+    url        TEXT,
+    points     INTEGER,
+    author     TEXT,
+    keyword    TEXT,
+    created_at_i INTEGER,
+    alerted_at INTEGER
+  );
+  CREATE TABLE IF NOT EXISTS poll_log (
+    id           INTEGER PRIMARY KEY AUTOINCREMENT,
+    polled_at    INTEGER,
+    posts_found  INTEGER,
+    posts_alerted INTEGER
+  );
+`);
+
+// Prepared statements
+const insertPost = db.prepare(`
+  INSERT OR IGNORE INTO seen_posts (objectID, title, url, points, author, keyword, created_at_i, alerted_at)
+  VALUES (@objectID, @title, @url, @points, @author, @keyword, @created_at_i, @alerted_at)
+`);
+const hasPost = db.prepare('SELECT 1 FROM seen_posts WHERE objectID = ?');
+const insertLog = db.prepare(`
+  INSERT INTO poll_log (polled_at, posts_found, posts_alerted)
+  VALUES (@polled_at, @posts_found, @posts_alerted)
+`);
+
+// Get the timestamp of the last seen post (for incremental polling)
+function getLastSeenTimestamp() {
+  const row = db.prepare('SELECT MAX(created_at_i) as ts FROM seen_posts').get();
+  if (row && row.ts) return row.ts;
+  // First run: use FIRST_RUN_DAYS lookback
+  return Math.floor(Date.now() / 1000) - FIRST_RUN_DAYS * 86400;
+}
+
+// Fetch posts from HN Algolia API
+async function fetchPosts(keyword, sinceTimestamp) {
+  const tags = INCLUDE_COMMENTS ? 'story,comment' : 'story';
+  const url =
+    `https://hn.algolia.com/api/v1/search_by_date` +
+    `?query=${encodeURIComponent(keyword)}` +
+    `&tags=${tags}` +
+    `&numericFilters=created_at_i>${sinceTimestamp}` +
+    `&hitsPerPage=50`;
+
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`HN API returned ${res.status} for keyword "${keyword}"`);
+  }
+  const data = await res.json();
+  return data.hits || [];
+}
+
+// Send a Slack alert for a single post
+async function sendSlackAlert(post, keyword) {
+  const storyUrl = post.url || `https://news.ycombinator.com/item?id=${post.objectID}`;
+  const hnUrl = `https://news.ycombinator.com/item?id=${post.objectID}`;
+
+  const payload = {
+    blocks: [
+      {
+        type: 'section',
+        text: {
+          type: 'mrkdwn',
+          text: `*<${storyUrl}|${post.title}>*\n:arrow_up: ${post.points ?? 0} points  :speech_balloon: ${post.num_comments ?? 0} comments  :bust_in_silhouette: ${post.author}`,
+        },
+      },
+      {
+        type: 'context',
+        elements: [
+          {
+            type: 'mrkdwn',
+            text: `Keyword: \`${keyword}\`  |  <${hnUrl}|HN discussion>`,
+          },
+        ],
+      },
+    ],
+  };
+
+  const res = await fetch(SLACK_WEBHOOK, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`Slack webhook returned ${res.status}: ${body}`);
+  }
+}
+
+// Sleep helper for rate limiting between keyword queries
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+async function main() {
+  console.log(`HN Intel Monitor`);
+  console.log(`  Keywords: ${keywords.join(', ')}`);
+  console.log(`  Min points: ${MIN_POINTS}`);
+  console.log(`  Include comments: ${INCLUDE_COMMENTS}`);
+  console.log(`  Mode: ${DRY_RUN ? 'DRY RUN (no alerts)' : 'LIVE'}`);
+  console.log('');
+
+  const sinceTimestamp = getLastSeenTimestamp();
+  const sinceDate = new Date(sinceTimestamp * 1000).toISOString();
+  console.log(`Fetching posts since: ${sinceDate}`);
+  console.log('');
+
+  let totalFound = 0;
+  let totalAlerted = 0;
+  let totalErrors = 0;
+
+  for (let i = 0; i < keywords.length; i++) {
+    const keyword = keywords[i];
+
+    // Rate limit: 1 second between keyword queries
+    if (i > 0) await sleep(1000);
+
+    let hits;
+    try {
+      hits = await fetchPosts(keyword, sinceTimestamp);
+    } catch (err) {
+      console.error(`  ERROR fetching "${keyword}": ${err.message}`);
+      totalErrors++;
+      continue;
+    }
+
+    const filtered = hits.filter(hit => (hit.points ?? 0) >= MIN_POINTS);
+    const newPosts = filtered.filter(hit => !hasPost.get(hit.objectID));
+
+    console.log(`"${keyword}": ${hits.length} hits, ${filtered.length} above min points, ${newPosts.length} new`);
+
+    for (const post of newPosts) {
+      totalFound++;
+
+      const storyUrl = post.url || `https://news.ycombinator.com/item?id=${post.objectID}`;
+      console.log(`  [NEW] ${post.title}`);
+      console.log(`        ${storyUrl}`);
+      console.log(`        Points: ${post.points ?? 0}  Comments: ${post.num_comments ?? 0}  Author: ${post.author}`);
+
+      if (!DRY_RUN) {
+        try {
+          await sendSlackAlert(post, keyword);
+          totalAlerted++;
+          console.log(`        Slack alert sent.`);
+        } catch (err) {
+          console.error(`        ERROR sending Slack alert: ${err.message}`);
+          totalErrors++;
+        }
+      } else {
+        console.log(`        [DRY RUN] Would send Slack alert.`);
+        totalAlerted++;
+      }
+
+      // Insert into cache regardless of Slack success (avoid double-alerting on retry)
+      insertPost.run({
+        objectID: post.objectID,
+        title: post.title || '',
+        url: post.url || '',
+        points: post.points ?? 0,
+        author: post.author || '',
+        keyword,
+        created_at_i: post.created_at_i,
+        alerted_at: Math.floor(Date.now() / 1000),
+      });
+    }
+  }
+
+  // Log this run
+  insertLog.run({
+    polled_at: Math.floor(Date.now() / 1000),
+    posts_found: totalFound,
+    posts_alerted: totalAlerted,
+  });
+
+  console.log('');
+  console.log('Run complete.');
+  console.log(`  Keywords checked: ${keywords.length}`);
+  console.log(`  New posts found: ${totalFound}`);
+  console.log(`  Alerts sent: ${totalAlerted}${DRY_RUN ? ' (dry run)' : ''}`);
+  if (totalErrors > 0) console.log(`  Errors: ${totalErrors}`);
+}
+
+main().catch(err => {
+  console.error('Unexpected error:', err);
+  process.exit(1);
+});

package/skills/kill-the-standup/.env.example

@@ -0,0 +1,22 @@
+# kill-the-standup — Environment Variables
+# ==========================================
+# No API keys needed for the AI — the agent reads Linear and GitHub directly.
+# Only Linear and Slack credentials are required.
+
+# Required: Linear API key
+# Get it: Linear → Settings → API → Personal API keys → Create key
+LINEAR_API_KEY=your_linear_api_key_here
+
+# Required: Slack Incoming Webhook URL
+# Get it: api.slack.com/apps → Create/select app → Incoming Webhooks → Add New Webhook
+# The URL format is: https://hooks.slack.com/services/T.../B.../...
+SLACK_WEBHOOK_URL=your_slack_webhook_url_here
+
+# Optional: GitHub repo to pull commit activity from (owner/repo format)
+# If not set, the GitHub section is skipped and only Linear issues appear in the standup
+# Example: GITHUB_REPO=Varnan-Tech/my-app
+GITHUB_REPO=owner/repo
+
+# Optional: GitHub username for filtering commits to your own work
+# If not set, the skill uses the username from your active gh auth session
+GITHUB_USERNAME=your_github_username