erne-universal 0.2.0 → 0.3.0

package/scripts/daily-news/scan-rn-expo.js

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+
+/**
+ * Daily React Native & Expo News Scanner
+ *
+ * Scans multiple sources for RN/Expo updates and creates ClickUp tasks.
+ * Uses keyword-based relevance filtering (no API credits needed).
+ *
+ * Sources:
+ * - GitHub releases (react-native, expo, key libraries)
+ * - React Native blog RSS
+ * - Expo blog RSS
+ */
+
+const SOURCES = {
+  github_releases: [
+    'facebook/react-native',
+    'expo/expo',
+    'expo/router',
+    'software-mansion/react-native-reanimated',
+    'software-mansion/react-native-screens',
+    'Shopify/flash-list',
+    'callstack/react-native-paper',
+    'react-native-community/cli',
+    'mrousavy/react-native-vision-camera',
+    'margelo/react-native-nitro-modules',
+  ],
+  rss_feeds: [
+    'https://reactnative.dev/blog/rss.xml',
+    'https://blog.expo.dev/feed',
+  ],
+};
+
+const CLICKUP_API = 'https://api.clickup.com/api/v2';
+
+// Keywords for prioritization
+const HIGH_PRIORITY_KEYWORDS = [
+  'breaking', 'deprecat', 'removed', 'migration', 'upgrade required',
+  'security', 'critical', 'major',
+];
+
+const ERNE_KEYWORDS = [
+  'expo-router', 'file-based', 'typescript', 'hermes',
+  'new architecture', 'fabric', 'turbo', 'bridgeless',
+  'flashlist', 'reanimated', 'gesture',
+];
+
+async function fetchGitHubReleases(repo) {
+  const res = await fetch(
+    `https://api.github.com/repos/${repo}/releases?per_page=3`,
+    {
+      headers: {
+        Authorization: `token ${process.env.GITHUB_TOKEN}`,
+        Accept: 'application/vnd.github.v3+json',
+      },
+    }
+  );
+  if (!res.ok) return [];
+  const releases = await res.json();
+
+  const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+  return releases
+    .filter((r) => new Date(r.published_at).getTime() > oneDayAgo)
+    .map((r) => ({
+      type: 'release',
+      source: repo,
+      title: `${repo} ${r.tag_name}`,
+      body: r.body?.slice(0, 1000) || '',
+      url: r.html_url,
+      date: r.published_at,
+    }));
+}
+
+async function fetchRSS(url) {
+  try {
+    const res = await fetch(url);
+    if (!res.ok) return [];
+    const xml = await res.text();
+
+    const items = [];
+    const itemRegex = /<item>([\s\S]*?)<\/item>/g;
+    let match;
+    while ((match = itemRegex.exec(xml)) !== null) {
+      const item = match[1];
+      const title = item.match(/<title><!\[CDATA\[(.*?)\]\]>|<title>(.*?)<\/title>/);
+      const link = item.match(/<link>(.*?)<\/link>/);
+      const pubDate = item.match(/<pubDate>(.*?)<\/pubDate>/);
+      const desc = item.match(/<description><!\[CDATA\[(.*?)\]\]>|<description>(.*?)<\/description>/);
+
+      if (title && pubDate) {
+        const date = new Date(pubDate[1]);
+        const oneDayAgo = Date.now() - 24 * 60 * 60 * 1000;
+        if (date.getTime() > oneDayAgo) {
+          items.push({
+            type: 'blog',
+            source: new URL(url).hostname,
+            title: title[1] || title[2],
+            body: (desc?.[1] || desc?.[2] || '').slice(0, 500),
+            url: link?.[1] || '',
+            date: date.toISOString(),
+          });
+        }
+      }
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+
+function analyzeRelevance(items) {
+  if (items.length === 0) return [];
+
+  return items.map((item) => {
+    const text = `${item.title} ${item.body}`.toLowerCase();
+
+    const isHighPriority = HIGH_PRIORITY_KEYWORDS.some((kw) => text.includes(kw));
+    const isErneRelevant = ERNE_KEYWORDS.some((kw) => text.includes(kw));
+    const isRelease = item.type === 'release';
+    const isBlog = item.type === 'blog';
+
+    // All releases and blog posts are relevant
+    if (!isRelease && !isBlog && !isHighPriority && !isErneRelevant) {
+      return null;
+    }
+
+    const priority = isHighPriority ? 'high' : isErneRelevant ? 'normal' : 'low';
+
+    return {
+      title: `[${item.type.toUpperCase()}] ${item.title}`,
+      description: item.body.slice(0, 300) || 'New update detected',
+      action: isHighPriority
+        ? 'Urgent: Check for breaking changes affecting ERNE'
+        : 'Review for potential ERNE updates',
+      priority,
+      source_url: item.url,
+    };
+  }).filter(Boolean);
+}
+
+async function createClickUpTask(task) {
+  const listId = process.env.CLICKUP_LIST_ID;
+  if (!listId) {
+    console.log('CLICKUP_LIST_ID not set, skipping task creation');
+    console.log('Task:', task.title);
+    return;
+  }
+
+  const priorityMap = { urgent: 1, high: 2, normal: 3, low: 4 };
+
+  const res = await fetch(`${CLICKUP_API}/list/${listId}/task`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: process.env.CLICKUP_API_TOKEN,
+    },
+    body: JSON.stringify({
+      name: task.title,
+      markdown_description: [
+        `## Summary`,
+        task.description,
+        '',
+        `## Action Required`,
+        task.action,
+        '',
+        `**Source:** [${task.source_url}](${task.source_url})`,
+        '',
+        `---`,
+        `*Auto-generated by ERNE Daily Scanner*`,
+      ].join('\n'),
+      priority: priorityMap[task.priority] || 3,
+    }),
+  });
+
+  if (res.ok) {
+    const data = await res.json();
+    console.log(`Created task: ${task.title} (${data.id})`);
+  } else {
+    console.error(`Failed to create task: ${task.title}`, res.status);
+  }
+}
+
+async function main() {
+  console.log('=== ERNE Daily RN/Expo News Scanner ===');
+  console.log(`Date: ${new Date().toISOString()}\n`);
+
+  const allItems = [];
+
+  // GitHub releases
+  console.log('Fetching GitHub releases...');
+  for (const repo of SOURCES.github_releases) {
+    const releases = await fetchGitHubReleases(repo);
+    allItems.push(...releases);
+    if (releases.length > 0) {
+      console.log(`  ${repo}: ${releases.length} new release(s)`);
+    }
+  }
+
+  // RSS feeds
+  console.log('Fetching RSS feeds...');
+  for (const feed of SOURCES.rss_feeds) {
+    const posts = await fetchRSS(feed);
+    allItems.push(...posts);
+    if (posts.length > 0) {
+      console.log(`  ${new URL(feed).hostname}: ${posts.length} new post(s)`);
+    }
+  }
+
+  console.log(`\nTotal items found: ${allItems.length}`);
+
+  if (allItems.length === 0) {
+    console.log('No new items today. Exiting.');
+    return;
+  }
+
+  console.log('\nAnalyzing relevance...');
+  const relevant = analyzeRelevance(allItems);
+  console.log(`Relevant items: ${relevant.length}`);
+
+  if (relevant.length > 0) {
+    console.log('\nCreating ClickUp tasks...');
+    for (const task of relevant) {
+      await createClickUpTask(task);
+    }
+  }
+
+  console.log('\nDone!');
+}
+
+main().catch((err) => {
+  console.error('Scanner failed:', err);
+  process.exit(1);
+});

package/scripts/hooks/dashboard-event.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+'use strict';
+
+const http = require('http');
+const fs = require('fs');
+
+// Read stdin
+let stdinData = '';
+try {
+  stdinData = fs.readFileSync(0, 'utf8');
+} catch {
+  process.exit(0);
+}
+
+let hookContext;
+try {
+  hookContext = JSON.parse(stdinData);
+} catch {
+  process.exit(0);
+}
+
+const DASHBOARD_PORT = parseInt(process.env.ERNE_DASHBOARD_PORT || '3333', 10);
+
+const AGENT_KEYWORDS = [
+  'architect', 'code-reviewer', 'tdd-guide', 'performance-profiler',
+  'native-bridge-builder', 'expo-config-resolver', 'ui-designer', 'upgrade-assistant',
+  'senior-developer', 'feature-builder',
+];
+
+function detectAgent(text) {
+  if (!text) return null;
+  const lower = text.toLowerCase();
+  for (const keyword of AGENT_KEYWORDS) {
+    if (lower.includes(keyword)) return keyword;
+  }
+  return null;
+}
+
+function extractTaskDescription(text) {
+  if (!text) return '';
+  return text.slice(0, 100).split('\n')[0];
+}
+
+const event = hookContext.event || '';
+const toolName = hookContext.tool_name || hookContext.toolName || '';
+const toolInput = hookContext.tool_input || hookContext.toolInput || {};
+
+if (toolName !== 'Agent' && toolName !== 'agent') {
+  process.exit(0);
+}
+
+const prompt = toolInput.prompt || toolInput.description || '';
+const agentName = detectAgent(prompt);
+
+if (!agentName) {
+  process.exit(0);
+}
+
+let eventType;
+if (event.toLowerCase().includes('pre')) {
+  eventType = 'agent:start';
+} else if (event.toLowerCase().includes('post')) {
+  eventType = 'agent:complete';
+} else {
+  process.exit(0);
+}
+
+const payload = JSON.stringify({
+  type: eventType,
+  agent: agentName,
+  task: extractTaskDescription(prompt),
+});
+
+const req = http.request(
+  {
+    hostname: '127.0.0.1',
+    port: DASHBOARD_PORT,
+    path: '/api/events',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    timeout: 2000,
+  },
+  () => { process.exit(0); }
+);
+
+req.on('error', () => { process.exit(0); });
+req.on('timeout', () => { req.destroy(); process.exit(0); });
+req.write(payload);
+req.end();

package/scripts/sync/issue-to-clickup.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+
+/**
+ * GitHub Issue → ClickUp Task Sync
+ *
+ * Routes issues to the correct ClickUp list based on labels:
+ * - bug → Dev Tasks
+ * - enhancement, feature → Backlog
+ * - partnership → Discussion
+ * - skill-proposal → Backlog
+ * - discussion, question → Discussion
+ * - Default → Backlog
+ */
+
+const CLICKUP_API = 'https://api.clickup.com/api/v2';
+
+const LABEL_TO_LIST = {
+  bug: process.env.CLICKUP_DEV_LIST_ID,
+  enhancement: process.env.CLICKUP_BACKLOG_LIST_ID,
+  'skill-proposal': process.env.CLICKUP_BACKLOG_LIST_ID,
+  partnership: process.env.CLICKUP_DISCUSSION_LIST_ID,
+  discussion: process.env.CLICKUP_DISCUSSION_LIST_ID,
+  question: process.env.CLICKUP_DISCUSSION_LIST_ID,
+};
+
+const LABEL_TO_PRIORITY = {
+  bug: 2, // high
+  enhancement: 3, // normal
+  'skill-proposal': 3,
+  partnership: 3,
+  discussion: 4, // low
+  question: 4,
+};
+
+function getListId(labels) {
+  const labelList = labels.split(',').map((l) => l.trim().toLowerCase());
+  for (const label of labelList) {
+    if (LABEL_TO_LIST[label]) return LABEL_TO_LIST[label];
+  }
+  return process.env.CLICKUP_BACKLOG_LIST_ID;
+}
+
+function getPriority(labels) {
+  const labelList = labels.split(',').map((l) => l.trim().toLowerCase());
+  for (const label of labelList) {
+    if (LABEL_TO_PRIORITY[label]) return LABEL_TO_PRIORITY[label];
+  }
+  return 3; // normal
+}
+
+async function createClickUpTask() {
+  const { ISSUE_TITLE, ISSUE_BODY, ISSUE_URL, ISSUE_LABELS, ISSUE_NUMBER, ISSUE_AUTHOR } =
+    process.env;
+
+  const listId = getListId(ISSUE_LABELS || '');
+  if (!listId) {
+    console.error('No ClickUp list ID configured for labels:', ISSUE_LABELS);
+    process.exit(1);
+  }
+
+  const priority = getPriority(ISSUE_LABELS || '');
+  const labels = (ISSUE_LABELS || '').split(',').filter(Boolean);
+
+  const description = [
+    `## GitHub Issue #${ISSUE_NUMBER}`,
+    '',
+    `**Author:** @${ISSUE_AUTHOR}`,
+    `**Labels:** ${labels.length > 0 ? labels.join(', ') : 'none'}`,
+    `**Link:** [#${ISSUE_NUMBER} on GitHub](${ISSUE_URL})`,
+    '',
+    '---',
+    '',
+    ISSUE_BODY || '*No description provided*',
+    '',
+    '---',
+    `*Synced from GitHub by ERNE Issue Sync*`,
+  ].join('\n');
+
+  const res = await fetch(`${CLICKUP_API}/list/${listId}/task`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: process.env.CLICKUP_API_TOKEN,
+    },
+    body: JSON.stringify({
+      name: `[GH-${ISSUE_NUMBER}] ${ISSUE_TITLE}`,
+      markdown_description: description,
+      priority,
+    }),
+  });
+
+  if (res.ok) {
+    const data = await res.json();
+    console.log(`Created ClickUp task: ${data.id} for GitHub issue #${ISSUE_NUMBER}`);
+    console.log(`  List: ${listId}`);
+    console.log(`  Priority: ${priority}`);
+    console.log(`  Labels: ${labels.join(', ')}`);
+  } else {
+    const err = await res.text();
+    console.error(`Failed to create ClickUp task:`, res.status, err);
+    process.exit(1);
+  }
+}
+
+createClickUpTask().catch((err) => {
+  console.error('Sync failed:', err);
+  process.exit(1);
+});

package/scripts/validate-all.js

@@ -60,7 +60,7 @@ console.log('\n  ERNE Content Validation\n');
 
 // Agents
 console.log('  Agents:');
-validateCount('agents', '.md', 8, 'agents/');
+validateCount('agents', '.md', 10, 'agents/');
 const agentFiles = fs.readdirSync('agents').filter(f => f.endsWith('.md'));
 for (const f of agentFiles) {
   validateFrontmatter(path.join('agents', f), ['name', 'description']);