erne-universal 0.1.0

package/scripts/validate-all.js

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+// scripts/validate-all.js — Validate all ERNE content files
+// Checks: frontmatter format, JSON validity, required fields, file counts
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+let errors = 0;
+let warnings = 0;
+let checked = 0;
+
+function error(msg) { errors++; console.error(`  ✗ ${msg}`); }
+function warn(msg) { warnings++; console.warn(`  ⚠ ${msg}`); }
+function ok(msg) { console.log(`  ✓ ${msg}`); }
+
+// ─── Validate frontmatter in .md files ───
+function validateFrontmatter(filePath, requiredFields) {
+  checked++;
+  const content = fs.readFileSync(filePath, 'utf8');
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+
+  if (!match) {
+    error(`${filePath}: Missing frontmatter`);
+    return;
+  }
+
+  const frontmatter = match[1];
+  for (const field of requiredFields) {
+    if (!frontmatter.includes(`${field}:`)) {
+      error(`${filePath}: Missing required field '${field}'`);
+    }
+  }
+}
+
+// ─── Validate JSON files ───
+function validateJson(filePath) {
+  checked++;
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    JSON.parse(content);
+  } catch (e) {
+    error(`${filePath}: Invalid JSON — ${e.message}`);
+  }
+}
+
+// ─── Validate directory file counts ───
+function validateCount(dir, ext, expected, label) {
+  const files = fs.readdirSync(dir).filter(f => f.endsWith(ext));
+  if (files.length !== expected) {
+    error(`${label}: Expected ${expected} files, found ${files.length}`);
+  } else {
+    ok(`${label}: ${files.length} files`);
+  }
+}
+
+// ─── Main validation ───
+console.log('\n  ERNE Content Validation\n');
+
+// Agents
+console.log('  Agents:');
+validateCount('agents', '.md', 8, 'agents/');
+const agentFiles = fs.readdirSync('agents').filter(f => f.endsWith('.md'));
+for (const f of agentFiles) {
+  validateFrontmatter(path.join('agents', f), ['name', 'description']);
+}
+
+// Commands
+console.log('  Commands:');
+validateCount('commands', '.md', 16, 'commands/');
+const cmdFiles = fs.readdirSync('commands').filter(f => f.endsWith('.md'));
+for (const f of cmdFiles) {
+  validateFrontmatter(path.join('commands', f), ['name', 'description']);
+}
+
+// Rules
+console.log('  Rules:');
+const ruleLayers = ['common', 'expo', 'bare-rn', 'native-ios', 'native-android'];
+for (const layer of ruleLayers) {
+  const layerDir = path.join('rules', layer);
+  if (!fs.existsSync(layerDir)) {
+    error(`rules/${layer}/: Missing directory`);
+    continue;
+  }
+  const ruleFiles = fs.readdirSync(layerDir).filter(f => f.endsWith('.md'));
+  ok(`rules/${layer}/: ${ruleFiles.length} files`);
+  for (const f of ruleFiles) {
+    validateFrontmatter(path.join(layerDir, f), ['description']);
+  }
+}
+
+// Hook profiles
+console.log('  Hooks:');
+validateJson('hooks/hooks.json');
+for (const profile of ['minimal', 'standard', 'strict']) {
+  validateJson(path.join('hooks', 'profiles', `${profile}.json`));
+}
+
+// MCP configs
+console.log('  MCP Configs:');
+const mcpFiles = fs.readdirSync('mcp-configs').filter(f => f.endsWith('.json'));
+ok(`mcp-configs/: ${mcpFiles.length} files`);
+for (const f of mcpFiles) {
+  validateJson(path.join('mcp-configs', f));
+}
+
+// Contexts
+console.log('  Contexts:');
+validateCount('contexts', '.md', 3, 'contexts/');
+
+// Skills
+console.log('  Skills:');
+const skillDirs = fs.readdirSync('skills', { withFileTypes: true })
+  .filter(d => d.isDirectory())
+  .map(d => d.name);
+ok(`skills/: ${skillDirs.length} skill directories`);
+for (const dir of skillDirs) {
+  const skillMd = path.join('skills', dir, 'SKILL.md');
+  if (!fs.existsSync(skillMd)) {
+    error(`skills/${dir}/: Missing SKILL.md`);
+  } else {
+    checked++;
+  }
+}
+
+// Schemas
+console.log('  Schemas:');
+validateJson('schemas/hooks.schema.json');
+validateJson('schemas/plugin.schema.json');
+
+// Summary
+console.log(`\n  Checked ${checked} files: ${errors} errors, ${warnings} warnings\n`);
+
+if (errors > 0) {
+  process.exit(1);
+}

package/skills/coding-standards/SKILL.md

@@ -0,0 +1,88 @@
+---
+name: coding-standards
+description: Enforce React Native coding standards as an actionable workflow
+---
+
+# Coding Standards Enforcement
+
+You are enforcing coding standards for a React Native project. This skill turns passive rules into an active audit workflow.
+
+## When to Use This Skill
+
+Invoke when:
+- Starting work on a new codebase
+- Reviewing code for standards compliance
+- Setting up a new project's conventions
+
+## Audit Process
+
+### Step 1: Detect Project Configuration
+
+Read the project's `.claude/rules/` to understand which standards apply:
+- `common/` rules always apply
+- `expo/` rules if Expo managed project
+- `bare-rn/` rules if bare React Native
+- `native-ios/` if iOS native code present
+- `native-android/` if Android native code present
+
+### Step 2: Scan for Violations
+
+Check each category systematically:
+
+**Component Structure:**
+- [ ] Functional components only (no class components)
+- [ ] Named exports (not default exports)
+- [ ] Props interface defined above component
+- [ ] Proper TypeScript types (no `any`)
+
+**Styling:**
+- [ ] NativeWind/Tailwind classes used (no `StyleSheet.create`)
+- [ ] Consistent color usage (design tokens, not hex literals)
+- [ ] Responsive design using NativeWind breakpoints
+- [ ] Dark mode support via `dark:` variants
+
+**State Management:**
+- [ ] Zustand for client state (no Redux, no Context for global state)
+- [ ] TanStack Query for server state (no manual fetch+useState)
+- [ ] No prop drilling beyond 2 levels
+- [ ] Computed values derived, not stored
+
+**Navigation:**
+- [ ] Expo Router file-based routing
+- [ ] Typed routes using `href` type safety
+- [ ] Proper layout files (`_layout.tsx`)
+- [ ] Deep linking configured
+
+**Performance:**
+- [ ] `FlashList` for lists (not `FlatList`)
+- [ ] `expo-image` for images (not `Image`)
+- [ ] Memoization where appropriate (`useMemo`, `useCallback`)
+- [ ] Animations on UI thread (Reanimated worklets)
+
+**Testing:**
+- [ ] Tests exist for new code
+- [ ] Tests use RNTL (not Enzyme)
+- [ ] Tests test behavior, not implementation
+- [ ] Mock at boundaries only
+
+### Step 3: Generate Report
+
+```
+## Coding Standards Audit
+
+### Summary
+- Files scanned: N
+- Violations found: N
+- Auto-fixable: N
+
+### Violations by Category
+[Category]: [count]
+  - [file:line] — [description]
+
+### Recommendations
+[Prioritized list of fixes]
+```
+
+### Step 4: Apply Fixes
+
+For auto-fixable violations (imports, styling patterns), offer to fix them. For manual fixes (architecture changes), provide specific guidance.

package/skills/continuous-learning-v2/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: continuous-learning-v2
+description: Auto-generate skills and rules from observed React Native development patterns
+---
+
+# Continuous Learning v2
+
+This skill manages the continuous learning pipeline — observing patterns during development sessions and converting them into persistent rules and skills.
+
+## Architecture
+
+```
+PostToolUse hook (real-time)
+  → continuous-learning-observer.cjs (lightweight pattern capture)
+  → patterns stored in .claude/memory/observations/
+
+/learn command (manual, comprehensive)
+  → extract-session-patterns.js (full session analysis)
+  → analyze-patterns.js (pattern clustering + dedup)
+  → skill-generator prompt (create new content)
+  → validate-content.js (verify new content is valid)
+
+/retrospective command (session end)
+  → evaluate-session.js (quality metrics + suggestions)
+```
+
+## How It Works
+
+### Real-Time (Automatic)
+
+The `continuous-learning-observer.cjs` hook runs on `PostToolUse` events. It:
+1. Captures the tool name, file paths, and outcome
+2. Detects repeated patterns (same fix applied > 3 times)
+3. Stores observations in `.claude/memory/observations/` as JSON
+4. Lightweight — adds < 50ms to each tool call
+
+### Manual Analysis (`/learn`)
+
+When the user runs `/learn`, the pipeline:
+1. Reads all observations from the current session
+2. Clusters them by type (style fix, import pattern, architecture choice)
+3. Compares against existing rules and skills
+4. Generates candidates for new content
+5. Presents candidates for user approval
+6. Writes approved content to `.claude/rules/` or `.claude/skills/`
+
+### Session Evaluation (`/retrospective`)
+
+At session end, `evaluate-session.js`:
+1. Aggregates all metrics (files changed, tests added, build status)
+2. Evaluates which rules triggered and their usefulness
+3. Suggests rule calibration (tighten/loosen globs, adjust content)
+4. Generates a session quality report
+
+## Configuration
+
+See `config.json` for tuning parameters:
+- `observationThreshold`: How many times a pattern must repeat before flagging (default: 3)
+- `maxObservationsPerSession`: Prevent memory bloat (default: 100)
+- `autoApprove`: If true, auto-approve low-risk content (default: false)
+- `contentTypes`: What types to generate — `["rule", "skill"]`

package/skills/continuous-learning-v2/agent-prompts/pattern-analyzer.md

@@ -0,0 +1,51 @@
+---
+name: pattern-analyzer
+description: Internal prompt for analyzing collected patterns — NOT a top-level agent
+---
+
+# Pattern Analysis Prompt
+
+You are analyzing patterns observed during a React Native development session. Your job is to identify recurring patterns worth capturing as rules or skills.
+
+## Input
+
+You receive a JSON array of observations:
+```json
+[
+  {
+    "timestamp": "2024-03-10T14:30:00Z",
+    "tool": "Edit",
+    "files": ["src/components/Button.tsx"],
+    "pattern": "Replaced StyleSheet.create with NativeWind classes",
+    "count": 5
+  }
+]
+```
+
+## Analysis Process
+
+1. **Group by category** — Cluster similar observations
+2. **Filter by threshold** — Only patterns with 3+ occurrences
+3. **Check novelty** — Compare against existing rules in `.claude/rules/`
+4. **Assess value** — Is this pattern worth encoding as a rule?
+
+## Output
+
+For each candidate:
+```json
+{
+  "type": "rule",
+  "category": "common/coding-style",
+  "title": "Prefer NativeWind over StyleSheet",
+  "confidence": "high",
+  "occurrences": 5,
+  "suggestedContent": "..."
+}
+```
+
+## Rules for Analysis
+
+- High confidence: Pattern appeared 5+ times with same fix
+- Medium confidence: Pattern appeared 3-4 times
+- Low confidence: Pattern appeared but context varied
+- Skip: One-off patterns, project-specific hacks, temporary workarounds

package/skills/continuous-learning-v2/agent-prompts/skill-generator.md

@@ -0,0 +1,74 @@
+---
+name: skill-generator
+description: Internal prompt for generating new skill content from analyzed patterns — NOT a top-level agent
+---
+
+# Skill/Rule Generation Prompt
+
+You are generating a new Claude Code rule or skill from an analyzed pattern. Create content that follows ERNE conventions.
+
+## Input
+
+You receive a pattern analysis:
+```json
+{
+  "type": "rule",
+  "category": "common/coding-style",
+  "title": "Prefer NativeWind over StyleSheet",
+  "confidence": "high",
+  "occurrences": 5,
+  "examples": ["..."]
+}
+```
+
+## Generation Rules
+
+### For Rules (`.claude/rules/*.md`)
+
+Format:
+```markdown
+---
+description: [One-line description of what this rule enforces]
+globs: [File patterns this applies to, e.g., "src/**/*.tsx"]
+alwaysApply: false
+---
+
+# [Rule Title]
+
+[Clear statement of the rule]
+
+## Do This
+[Correct example with code]
+
+## Don't Do This
+[Incorrect example with code]
+
+## Why
+[Brief rationale]
+```
+
+### For Skills (`.claude/skills/*/SKILL.md`)
+
+Format:
+```markdown
+---
+name: [kebab-case-name]
+description: [One-line description]
+---
+
+# [Skill Title]
+
+[When to invoke]
+[Step-by-step workflow]
+[Examples]
+[Expected output]
+```
+
+## Quality Checks
+
+Before outputting:
+- [ ] Frontmatter is valid YAML
+- [ ] Content is specific and actionable (not generic advice)
+- [ ] Code examples are correct and runnable
+- [ ] Rule doesn't conflict with existing rules
+- [ ] Skill has clear invocation criteria

package/skills/continuous-learning-v2/config.json

@@ -0,0 +1,25 @@
+{
+  "version": "2.0.0",
+  "observationThreshold": 3,
+  "maxObservationsPerSession": 100,
+  "autoApprove": false,
+  "contentTypes": ["rule", "skill"],
+  "observationDir": ".claude/memory/observations",
+  "generatedDir": ".claude/memory/generated",
+  "patterns": {
+    "minOccurrences": 3,
+    "categories": [
+      "style-fix",
+      "import-pattern",
+      "architecture-choice",
+      "error-handling",
+      "testing-pattern",
+      "performance-fix"
+    ]
+  },
+  "generation": {
+    "ruleTemplate": "agent-prompts/skill-generator.md",
+    "analyzerPrompt": "agent-prompts/pattern-analyzer.md",
+    "validationScript": "scripts/validate-content.js"
+  }
+}

package/skills/continuous-learning-v2/hook-templates/evaluate-session.cjs.template

@@ -0,0 +1,69 @@
+// Template for evaluate-session.cjs hook
+// This runs on session end to generate a retrospective
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG = {
+  observationDir: '{{observationDir}}',
+  generatedDir: '{{generatedDir}}',
+};
+
+module.exports = async () => {
+  // Read all session observations
+  const obsDir = CONFIG.observationDir;
+  if (!fs.existsSync(obsDir)) {
+    return { message: 'No observations found for this session.' };
+  }
+
+  const sessionFiles = fs.readdirSync(obsDir)
+    .filter(f => f.startsWith('session-'))
+    .sort();
+
+  if (sessionFiles.length === 0) {
+    return { message: 'No observations found for this session.' };
+  }
+
+  // Aggregate observations
+  let allObservations = [];
+  for (const file of sessionFiles) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(obsDir, file), 'utf8'));
+      allObservations = allObservations.concat(data);
+    } catch { /* skip corrupt files */ }
+  }
+
+  // Generate metrics
+  const metrics = {
+    totalObservations: allObservations.length,
+    toolUsage: {},
+    filesModified: new Set(),
+    timespan: {
+      start: allObservations[0]?.timestamp,
+      end: allObservations[allObservations.length - 1]?.timestamp,
+    },
+  };
+
+  for (const obs of allObservations) {
+    metrics.toolUsage[obs.tool] = (metrics.toolUsage[obs.tool] || 0) + 1;
+    (obs.files || []).forEach(f => metrics.filesModified.add(f));
+  }
+
+  metrics.filesModified = [...metrics.filesModified];
+
+  // Write retrospective
+  const retro = {
+    timestamp: new Date().toISOString(),
+    metrics,
+    observations: allObservations,
+  };
+
+  fs.mkdirSync(CONFIG.generatedDir, { recursive: true });
+  const retroFile = path.join(CONFIG.generatedDir, `retro-${Date.now()}.json`);
+  fs.writeFileSync(retroFile, JSON.stringify(retro, null, 2));
+
+  return {
+    message: `Retrospective saved to ${retroFile}`,
+    metrics,
+  };
+};

package/skills/continuous-learning-v2/hook-templates/observer-hook.cjs.template

@@ -0,0 +1,54 @@
+// Template for continuous-learning-observer.cjs hook
+// This runs on PostToolUse events and captures patterns
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG = {
+  observationDir: '{{observationDir}}',
+  maxPerSession: {{maxObservationsPerSession}},
+  threshold: {{observationThreshold}},
+};
+
+module.exports = async ({ tool, filePaths, result }) => {
+  // Only observe file-editing tools
+  if (!['Edit', 'Write', 'NotebookEdit'].includes(tool)) return;
+
+  const sessionFile = path.join(CONFIG.observationDir, `session-${Date.now()}.json`);
+
+  // Ensure observation directory exists
+  fs.mkdirSync(CONFIG.observationDir, { recursive: true });
+
+  // Read existing observations for this session
+  let observations = [];
+  const sessionFiles = fs.readdirSync(CONFIG.observationDir)
+    .filter(f => f.startsWith('session-'))
+    .sort()
+    .slice(-1);
+
+  if (sessionFiles.length > 0) {
+    try {
+      observations = JSON.parse(
+        fs.readFileSync(path.join(CONFIG.observationDir, sessionFiles[0]), 'utf8')
+      );
+    } catch { /* fresh session */ }
+  }
+
+  // Don't exceed max observations
+  if (observations.length >= CONFIG.maxPerSession) return;
+
+  // Record observation
+  observations.push({
+    timestamp: new Date().toISOString(),
+    tool,
+    files: filePaths || [],
+    resultPreview: typeof result === 'string' ? result.slice(0, 200) : '',
+  });
+
+  // Write back
+  const targetFile = sessionFiles.length > 0
+    ? path.join(CONFIG.observationDir, sessionFiles[0])
+    : sessionFile;
+
+  fs.writeFileSync(targetFile, JSON.stringify(observations, null, 2));
+};

package/skills/continuous-learning-v2/scripts/analyze-patterns.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+// Analyze extracted patterns and generate candidates
+
+const fs = require('fs');
+const path = require('path');
+
+const CONFIG_PATH = path.resolve(__dirname, '../config.json');
+const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+
+function analyzePatterns(patterns) {
+  const candidates = [];
+
+  // Find repeated edits to same file patterns
+  const filePatterns = {};
+  for (const obs of patterns) {
+    for (const file of (obs.files || [])) {
+      const dir = path.dirname(file);
+      const ext = path.extname(file);
+      const key = `${dir}/*${ext}`;
+      if (!filePatterns[key]) filePatterns[key] = { count: 0, files: [] };
+      filePatterns[key].count++;
+      filePatterns[key].files.push(file);
+    }
+  }
+
+  // Generate candidates for patterns above threshold
+  for (const [pattern, data] of Object.entries(filePatterns)) {
+    if (data.count >= config.observationThreshold) {
+      candidates.push({
+        type: 'rule',
+        pattern,
+        occurrences: data.count,
+        files: [...new Set(data.files)].slice(0, 5),
+        confidence: data.count >= 5 ? 'high' : 'medium',
+      });
+    }
+  }
+
+  return candidates;
+}
+
+// Read from stdin or file
+const input = process.argv[2];
+if (input && fs.existsSync(input)) {
+  const data = JSON.parse(fs.readFileSync(input, 'utf8'));
+  const candidates = analyzePatterns(data);
+  console.log(JSON.stringify(candidates, null, 2));
+} else {
+  console.log('Usage: node analyze-patterns.js <observations.json>');
+}

package/skills/continuous-learning-v2/scripts/extract-session-patterns.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// Extract patterns from session observations for /learn command
+
+const fs = require('fs');
+const path = require('path');
+
+const OBS_DIR = path.resolve('.claude/memory/observations');
+
+function extractPatterns() {
+  if (!fs.existsSync(OBS_DIR)) {
+    console.log('No observations directory found.');
+    process.exit(0);
+  }
+
+  const files = fs.readdirSync(OBS_DIR).filter(f => f.endsWith('.json'));
+  let allObs = [];
+
+  for (const file of files) {
+    try {
+      const data = JSON.parse(fs.readFileSync(path.join(OBS_DIR, file), 'utf8'));
+      allObs = allObs.concat(Array.isArray(data) ? data : [data]);
+    } catch (e) {
+      console.error(`Skipping corrupt file: ${file}`);
+    }
+  }
+
+  console.log(`Loaded ${allObs.length} observations from ${files.length} files.`);
+
+  // Group by file extension to find patterns
+  const byExtension = {};
+  for (const obs of allObs) {
+    for (const file of (obs.files || [])) {
+      const ext = path.extname(file);
+      if (!byExtension[ext]) byExtension[ext] = [];
+      byExtension[ext].push(obs);
+    }
+  }
+
+  // Group by tool to find repeated fix patterns
+  const byTool = {};
+  for (const obs of allObs) {
+    if (!byTool[obs.tool]) byTool[obs.tool] = [];
+    byTool[obs.tool].push(obs);
+  }
+
+  // Output summary
+  console.log('\n=== Pattern Summary ===');
+  console.log(`File types modified: ${Object.keys(byExtension).join(', ')}`);
+  console.log(`Tools used: ${JSON.stringify(byTool, (k, v) => Array.isArray(v) ? v.length : v)}`);
+
+  return { byExtension, byTool, total: allObs.length };
+}
+
+extractPatterns();