erne-universal 0.2.0 → 0.3.0

package/lib/init.js

@@ -0,0 +1,294 @@
+// lib/init.js — Interactive project initializer
+// Implements the 4-step install flow from spec Section 6
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline/promises');
+const { stdin, stdout } = require('process');
+
+module.exports = async function init() {
+  const rl = readline.createInterface({ input: stdin, output: stdout });
+  const cwd = process.cwd();
+
+  console.log('\n  erne — Setting up AI agent harness for React Native & Expo\n');
+
+  // ─── Step 1: Detect project type ───
+  console.log('  Step 1: Scanning project...');
+  const detection = detectProject(cwd);
+  printDetection(detection);
+
+  if (!detection.isRNProject) {
+    console.log('\n  ⚠ No React Native project detected in current directory.');
+    const proceed = await rl.question('  Continue anyway? (y/N) ');
+    if (proceed.toLowerCase() !== 'y') {
+      console.log('  Aborted.');
+      rl.close();
+      return;
+    }
+  }
+
+  // ─── Step 2: Choose hook profile ───
+  console.log('\n  Step 2: Select hook profile:\n');
+  console.log('    (a) minimal  — fast iteration, minimal checks');
+  console.log('    (b) standard — balanced quality + speed [recommended]');
+  console.log('    (c) strict   — production-grade enforcement');
+  console.log();
+
+  let profileChoice = await rl.question('  Profile (a/b/c) [b]: ');
+  profileChoice = profileChoice.toLowerCase() || 'b';
+  const profileMap = { a: 'minimal', b: 'standard', c: 'strict' };
+  const profile = profileMap[profileChoice] || 'standard';
+
+  // ─── Step 3: Select MCP integrations ───
+  console.log('\n  Step 3: MCP server integrations:\n');
+
+  const mcpSelections = {};
+
+  // Recommended servers
+  console.log('  Recommended:');
+  const agentDevice = await rl.question('    [Y/n] agent-device — Control iOS Simulator & Android Emulator: ');
+  mcpSelections['agent-device'] = agentDevice.toLowerCase() !== 'n';
+
+  const github = await rl.question('    [Y/n] GitHub — PR management, issue tracking: ');
+  mcpSelections['github'] = github.toLowerCase() !== 'n';
+
+  // Optional servers
+  console.log('\n  Optional (press Enter to skip):');
+  const optionalServers = [
+    { key: 'supabase', label: 'Supabase — Database & auth' },
+    { key: 'firebase', label: 'Firebase — Analytics & push' },
+    { key: 'figma', label: 'Figma — Design token sync' },
+    { key: 'sentry', label: 'Sentry — Error tracking' },
+  ];
+
+  for (const server of optionalServers) {
+    const answer = await rl.question(`    [y/N] ${server.label}: `);
+    mcpSelections[server.key] = answer.toLowerCase() === 'y';
+  }
+
+  rl.close();
+
+  // ─── Step 4: Generate config ───
+  console.log('\n  Step 4: Generating configuration...\n');
+
+  const erneRoot = path.resolve(__dirname, '..');
+  const claudeDir = path.join(cwd, '.claude');
+
+  // Ensure .claude/ exists
+  fs.mkdirSync(claudeDir, { recursive: true });
+
+  // Copy agents
+  copyDir(path.join(erneRoot, 'agents'), path.join(claudeDir, 'agents'));
+  console.log('    ✓ .claude/agents/ (8 agents)');
+
+  // Copy commands
+  copyDir(path.join(erneRoot, 'commands'), path.join(claudeDir, 'commands'));
+  console.log('    ✓ .claude/commands/ (16 commands)');
+
+  // Copy applicable rules
+  const ruleLayers = determineRuleLayers(detection);
+  const rulesTarget = path.join(claudeDir, 'rules');
+  fs.mkdirSync(rulesTarget, { recursive: true });
+  for (const layer of ruleLayers) {
+    copyDir(path.join(erneRoot, 'rules', layer), path.join(rulesTarget, layer));
+  }
+  console.log(`    ✓ .claude/rules/ (layers: ${ruleLayers.join(', ')})`);
+
+  // Copy selected hook profile
+  const hooksSource = path.join(erneRoot, 'hooks');
+  const hooksTarget = path.join(claudeDir);
+  const profileSource = path.join(hooksSource, 'profiles', `${profile}.json`);
+  const masterHooks = JSON.parse(fs.readFileSync(path.join(hooksSource, 'hooks.json'), 'utf8'));
+  const profileHooks = JSON.parse(fs.readFileSync(profileSource, 'utf8'));
+  const mergedHooks = mergeHookProfile(masterHooks, profileHooks, profile);
+  fs.writeFileSync(path.join(hooksTarget, 'hooks.json'), JSON.stringify(mergedHooks, null, 2));
+  console.log(`    ✓ .claude/hooks.json (${profile} profile)`);
+
+  // Copy hook scripts
+  const scriptsTarget = path.join(claudeDir, 'scripts', 'hooks');
+  copyDir(path.join(erneRoot, 'scripts', 'hooks'), scriptsTarget);
+  console.log('    ✓ .claude/scripts/hooks/ (hook implementations)');
+
+  // Copy contexts
+  copyDir(path.join(erneRoot, 'contexts'), path.join(claudeDir, 'contexts'));
+  console.log('    ✓ .claude/contexts/ (3 contexts)');
+
+  // Copy selected MCP configs
+  const mcpTarget = path.join(claudeDir, 'mcp-configs');
+  fs.mkdirSync(mcpTarget, { recursive: true });
+  let mcpCount = 0;
+  for (const [key, enabled] of Object.entries(mcpSelections)) {
+    if (enabled) {
+      const src = path.join(erneRoot, 'mcp-configs', `${key}.json`);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, path.join(mcpTarget, `${key}.json`));
+        mcpCount++;
+      }
+    }
+  }
+  console.log(`    ✓ .claude/mcp-configs/ (${mcpCount} servers)`);
+
+  // Copy skills
+  copyDir(path.join(erneRoot, 'skills'), path.join(claudeDir, 'skills'));
+  console.log('    ✓ .claude/skills/ (8 skills)');
+
+  // Generate CLAUDE.md
+  const claudeMd = generateClaudeMd(detection, profile, ruleLayers);
+  fs.writeFileSync(path.join(cwd, 'CLAUDE.md'), claudeMd);
+  console.log('    ✓ CLAUDE.md (with correct rule imports)');
+
+  // Generate settings.json
+  const settings = {
+    hookProfile: profile,
+    erneVersion: require('../package.json').version,
+    detectedProject: detection.type,
+    installedAt: new Date().toISOString()
+  };
+  fs.writeFileSync(
+    path.join(claudeDir, 'settings.json'),
+    JSON.stringify(settings, null, 2)
+  );
+  console.log('    ✓ .claude/settings.json');
+
+  console.log('\n  Done! Run /plan to start your first feature.\n');
+};
+
+
+// ─── Helper functions ───
+
+function detectProject(cwd) {
+  const result = {
+    isRNProject: false,
+    type: 'unknown',
+    hasExpo: false,
+    hasBareRN: false,
+    hasIOS: false,
+    hasAndroid: false,
+  };
+
+  // Check for app.json / app.config.js / app.config.ts (Expo)
+  const expoConfigs = ['app.json', 'app.config.js', 'app.config.ts'];
+  result.hasExpo = expoConfigs.some(f => fs.existsSync(path.join(cwd, f)));
+
+  // Check for ios/ directory with Swift files
+  const iosDir = path.join(cwd, 'ios');
+  if (fs.existsSync(iosDir) && fs.statSync(iosDir).isDirectory()) {
+    result.hasIOS = hasFilesWithExtension(iosDir, '.swift');
+  }
+
+  // Check for android/ directory with Kotlin files
+  const androidDir = path.join(cwd, 'android');
+  if (fs.existsSync(androidDir) && fs.statSync(androidDir).isDirectory()) {
+    result.hasAndroid = hasFilesWithExtension(androidDir, '.kt');
+  }
+
+  // Check for bare RN indicators
+  const packageJsonPath = path.join(cwd, 'package.json');
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps['react-native']) {
+        result.isRNProject = true;
+        result.hasBareRN = !result.hasExpo;
+      }
+      if (deps['expo']) {
+        result.isRNProject = true;
+        result.hasExpo = true;
+      }
+    } catch { /* ignore parse errors */ }
+  }
+
+  // Determine type
+  if (result.hasExpo) result.type = 'expo-managed';
+  else if (result.hasBareRN) result.type = 'bare-rn';
+
+  return result;
+}
+
+function hasFilesWithExtension(dir, ext) {
+  try {
+    const entries = fs.readdirSync(dir, { recursive: true });
+    return entries.some(entry => entry.endsWith(ext));
+  } catch {
+    return false;
+  }
+}
+
+function printDetection(detection) {
+  const ok = (msg) => console.log(`    ✓ ${msg}`);
+  const no = (msg) => console.log(`    ✗ ${msg}`);
+
+  if (detection.hasExpo) ok('Expo config found → Expo managed workflow');
+  else no('No Expo config detected');
+
+  if (detection.hasBareRN) ok('Bare React Native project detected');
+
+  if (detection.hasIOS) ok('ios/ contains Swift files → iOS native rules enabled');
+  else no('No iOS native code found');
+
+  if (detection.hasAndroid) ok('android/ contains Kotlin files → Android native rules enabled');
+  else no('No Android native code found');
+}
+
+function determineRuleLayers(detection) {
+  const layers = ['common'];
+  if (detection.hasExpo) layers.push('expo');
+  if (detection.hasBareRN) layers.push('bare-rn');
+  if (detection.hasIOS) layers.push('native-ios');
+  if (detection.hasAndroid) layers.push('native-android');
+  return layers;
+}
+
+function mergeHookProfile(masterHooks, profileHooks, profileName) {
+  // Filter master hooks to only include those enabled in the profile
+  const enabledEvents = profileHooks.enabledEvents || [];
+  const result = {};
+
+  for (const [event, hooks] of Object.entries(masterHooks)) {
+    if (event === '_meta') {
+      result._meta = { ...masterHooks._meta, activeProfile: profileName };
+      continue;
+    }
+
+    if (Array.isArray(hooks)) {
+      result[event] = hooks.filter(hook => {
+        // Include hook if the profile enables its event
+        // or if the hook has no profile restriction
+        const hookProfiles = hook.profiles || ['minimal', 'standard', 'strict'];
+        return hookProfiles.includes(profileName);
+      });
+      // Remove empty arrays
+      if (result[event].length === 0) delete result[event];
+    }
+  }
+
+  return result;
+}
+
+function generateClaudeMd(detection, profile, ruleLayers) {
+  const lines = [
+    '# Project Configuration (ERNE)',
+    '',
+    `Hook profile: ${profile}`,
+    `Project type: ${detection.type}`,
+    '',
+    '## Rules',
+    '',
+  ];
+
+  for (const layer of ruleLayers) {
+    lines.push(`@import .claude/rules/${layer}/`);
+  }
+
+  lines.push('', '## Skills', '', '@import .claude/skills/', '');
+
+  return lines.join('\n');
+}
+
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.cpSync(src, dest, { recursive: true });
+}

package/lib/start.js

@@ -0,0 +1,26 @@
+// lib/start.js — Initialize project and launch dashboard in background
+'use strict';
+
+const { fork } = require('child_process');
+const path = require('path');
+
+const SERVER_PATH = path.resolve(__dirname, '..', 'dashboard', 'server.js');
+const DEFAULT_PORT = 3333;
+
+module.exports = async function start() {
+  const init = require('./init');
+  await init();
+
+  const port = DEFAULT_PORT;
+
+  const child = fork(SERVER_PATH, [], {
+    env: { ...process.env, ERNE_DASHBOARD_PORT: String(port) },
+    detached: true,
+    stdio: 'ignore',
+  });
+
+  child.unref();
+
+  const url = `http://localhost:${port}`;
+  console.log(`\n  ERNE Dashboard running at ${url}\n`);
+};

package/lib/update.js

@@ -0,0 +1,60 @@
+// lib/update.js — Update ERNE to latest version
+// Usage: npx erne-universal update
+
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+module.exports = async function update() {
+  const cwd = process.cwd();
+  const claudeDir = path.join(cwd, '.claude');
+  const settingsPath = path.join(claudeDir, 'settings.json');
+
+  console.log('\n  erne — Checking for updates...\n');
+
+  // Check if ERNE is installed in this project
+  if (!fs.existsSync(settingsPath)) {
+    console.log('  ⚠ ERNE not found in this project.');
+    console.log('  Run "npx erne-universal init" to set up.');
+    return;
+  }
+
+  const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+  console.log(`  Current version: ${settings.erneVersion}`);
+
+  // Fetch latest version from npm
+  let latestVersion;
+  try {
+    latestVersion = execSync('npm view erne-universal version', { encoding: 'utf8' }).trim();
+  } catch {
+    console.log('  ⚠ Could not check npm for latest version.');
+    console.log('  Check https://erne.dev for updates.');
+    return;
+  }
+
+  console.log(`  Latest version:  ${latestVersion}`);
+
+  if (settings.erneVersion === latestVersion) {
+    console.log('\n  Already up to date!\n');
+    return;
+  }
+
+  console.log(`\n  Updating ${settings.erneVersion} → ${latestVersion}...`);
+
+  // Re-run init with preserved settings
+  // The init command detects existing settings and preserves user choices
+  console.log('  Running: npx erne-universal@latest init');
+  console.log('  Your profile and MCP selections will be preserved.\n');
+
+  try {
+    execSync(`npx erne-universal@${latestVersion} init`, {
+      stdio: 'inherit',
+      cwd,
+    });
+  } catch (err) {
+    console.error('  Update failed:', err.message);
+    console.error('  Manual update: npm install -g erne-universal@latest && erne init');
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "erne-universal",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Complete AI coding agent harness for React Native and Expo development",
   "keywords": [
     "react-native",
@@ -29,6 +29,8 @@
     "hooks/",
     "contexts/",
     "mcp-configs/",
+    "dashboard/",
+    "lib/",
     "scripts/",
     "examples/",
     "schemas/",

package/scripts/daily-news/scan-ai-agents.js

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Daily AI Agent Ecosystem News Scanner
+ *
+ * Scans for AI coding agent updates relevant to ERNE:
+ * - Claude Code updates
+ * - Competitor agent tools (Codex, Cursor, Windsurf, Antigravity)
+ * - Skills marketplace changes
+ * - New agent skills in the ecosystem
+ *
+ * Uses keyword-based relevance filtering (no API credits needed).
+ */
+
+const SOURCES = {
+  github_releases: [
+    'anthropics/claude-code',
+    'anthropics/skills',
+    'openai/codex',
+    'VoltAgent/awesome-agent-skills',
+    'callstackincubator/agent-skills',
+    'expo/skills',
+    'vercel-labs/agent-skills',
+  ],
+  github_repos_activity: [
+    'anthropics/claude-code',
+    'google/anthropic-antigravity',
+  ],
+};
+
+const CLICKUP_API = 'https://api.clickup.com/api/v2';
+
+// Keywords that indicate high relevance to ERNE
+const HIGH_PRIORITY_KEYWORDS = [
+  'breaking', 'deprecat', 'removed', 'migration', 'upgrade',
+  'skill', 'plugin', 'marketplace', 'CLAUDE.md', 'AGENTS.md',
+  'react-native', 'expo', 'agent',
+];
+
+const NORMAL_KEYWORDS = [
+  'feature', 'new', 'add', 'support', 'improve', 'update',
+  'fix', 'bug', 'release', 'version',
+];
+
+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 fetchRepoCommits(repo) {
+  const since = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
+  const res = await fetch(
+    `https://api.github.com/repos/${repo}/commits?since=${since}&per_page=10`,
+    {
+      headers: {
+        Authorization: `token ${process.env.GITHUB_TOKEN}`,
+        Accept: 'application/vnd.github.v3+json',
+      },
+    }
+  );
+  if (!res.ok) return [];
+  const commits = await res.json();
+
+  if (commits.length === 0) return [];
+
+  return [
+    {
+      type: 'commits',
+      source: repo,
+      title: `${repo}: ${commits.length} new commit(s)`,
+      body: commits
+        .slice(0, 5)
+        .map((c) => `- ${c.commit.message.split('\n')[0]}`)
+        .join('\n'),
+      url: `https://github.com/${repo}/commits`,
+      date: commits[0]?.commit.author.date,
+    },
+  ];
+}
+
+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 isRelease = item.type === 'release';
+
+    // All releases are relevant, commits only if they match keywords
+    if (!isRelease && !isHighPriority && !NORMAL_KEYWORDS.some((kw) => text.includes(kw))) {
+      return null;
+    }
+
+    const priority = isHighPriority ? 'high' : 'normal';
+
+    return {
+      title: `[${item.type.toUpperCase()}] ${item.title}`,
+      description: item.body.slice(0, 300) || 'New activity detected',
+      action: isRelease
+        ? 'Review release notes for ERNE compatibility'
+        : 'Review changes for potential impact',
+      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 AI Agent 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 AI Agent 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)`);
+    }
+  }
+
+  // Repo activity
+  console.log('Fetching repo activity...');
+  for (const repo of SOURCES.github_repos_activity) {
+    const commits = await fetchRepoCommits(repo);
+    allItems.push(...commits);
+    if (commits.length > 0) {
+      console.log(`  ${repo}: new activity`);
+    }
+  }
+
+  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);
+});