@rotifer/playground 0.5.0-alpha.2 → 0.7.0

package/genes/readability-analyzer/SKILL.md

@@ -0,0 +1,357 @@
+---
+name: readability-analyzer
+description: Analyze and improve content readability. Evaluate sentence complexity, word choice, and overall accessibility. Use when ensuring content is appropriate for target audience reading level.
+---
+
+# Readability Analyzer
+
+**Goal**: Analyze and improve content readability, ensuring text is easy to understand for the target audience.
+
+---
+
+## 1. Readability Metrics
+
+### Flesch Reading Ease
+
+```markdown
+## Formula
+
+FRE = 206.835 - 1.015 × (total words / total sentences) - 84.6 × (total syllables / total words)
+
+## Score Interpretation
+
+| Score | Difficulty | Grade Level | Example |
+|-------|-----------|-------------|---------|
+| 90-100 | Very easy | 5th grade | Children's books |
+| 80-90 | Easy | 6th grade | Conversational |
+| 70-80 | Fairly easy | 7th grade | Popular media |
+| 60-70 | Standard | 8th-9th grade | Newspapers |
+| 50-60 | Fairly difficult | 10th-12th grade | Academic |
+| 30-50 | Difficult | College | Professional literature |
+| 0-30 | Very difficult | Graduate+ | Legal documents |
+
+## Target Scores
+
+- General audience: 60-70
+- Business documents: 50-60
+- Academic papers: 30-50
+```
+
+### Flesch-Kincaid Grade Level
+
+```markdown
+## Formula
+
+FKGL = 0.39 × (total words / total sentences) + 11.8 × (total syllables / total words) - 15.59
+
+## Interpretation
+
+The result represents the US grade level required to read the text.
+Example: FKGL = 8.0 means 8th grade reading ability is needed.
+
+## Recommendations
+
+- General audience: Grade 6-8
+- Professional content: Grade 10-12
+- Academic articles: Grade 12+
+```
+
+---
+
+## 2. Assessment Methods
+
+### Automated Analysis Tools
+
+```markdown
+## English Tools
+
+| Tool | Features | Link |
+|------|----------|------|
+| Hemingway Editor | Simplicity analysis | hemingwayapp.com |
+| Grammarly | Comprehensive analysis | grammarly.com |
+| Readable | Detailed reports | readable.com |
+| Yoast SEO | WordPress plugin | |
+
+## Manual Assessment
+
+1. Calculate average sentence length
+2. Count technical terms
+3. Evaluate structural clarity
+4. Have target readers review the text
+```
+
+### Assessment Report Template
+
+```markdown
+## Readability Analysis Report
+
+### Basic Statistics
+- Total word count:
+- Total sentence count:
+- Total paragraph count:
+- Average sentence length:
+- Average paragraph length:
+
+### Metric Scores
+- Flesch Reading Ease: /100
+- Estimated grade level:
+- Reading time: approx. X minutes
+
+### Issues Found
+- Overly long sentences: X instances
+- Complex vocabulary: X words
+- Passive voice: X instances
+- Long paragraphs: X instances
+
+### Recommendations
+1.
+2.
+3.
+```
+
+---
+
+## 3. Optimization Strategies
+
+### Sentence Optimization
+
+```markdown
+## Break Up Long Sentences
+
+Before: Due to the rapid development of artificial intelligence technology in recent years, particularly the breakthrough progress in deep learning and natural language processing, machines have become increasingly capable of accurately understanding and generating human language, which has had a profound impact on traditional industries such as translation, customer service, and content creation.
+
+After: Artificial intelligence has developed rapidly in recent years. Deep learning and NLP have achieved breakthrough progress. Machines can now understand and generate human language with increasing accuracy. This has profoundly impacted translation, customer service, and content creation.
+
+## Principles
+
+- One idea per sentence
+- Aim for 15-20 words per sentence in English
+- Use short sentences for rhythm variation
+```
+
+### Vocabulary Simplification
+
+```markdown
+## Replace Complex Words
+
+| Complex | Simple |
+|---------|--------|
+| utilize | use |
+| implement | do / carry out |
+| commence | start / begin |
+| facilitate | help |
+| demonstrate | show |
+
+## Explain Technical Terms
+
+Bad: The system uses a RAG architecture.
+
+Good: The system uses Retrieval-Augmented Generation (RAG) — it first retrieves relevant information, then generates answers based on those results.
+
+## Avoid Jargon Overload
+
+Bad: Leverage AI-powered SaaS platform for B2B digital transformation...
+
+Good: Use intelligent online software to help businesses go digital...
+```
+
+### Structure Optimization
+
+```markdown
+## Use Subheadings
+
+Bad: Large blocks of plain text
+
+Good:
+### Problem Background
+[Short paragraph]
+
+### Solution
+[Short paragraph]
+
+### Implementation Steps
+[List]
+
+## Use Lists
+
+Bad: We need to consider cost, time, quality, and risk factors.
+
+Good: Consider the following factors:
+- Cost
+- Time
+- Quality
+- Risk
+
+## Use Transition Words
+
+First... Next... Finally...
+Therefore... However... Additionally...
+```
+
+---
+
+## 4. Audience Adaptation
+
+### Adjust by Audience
+
+```markdown
+## General Public
+
+- Sentence length: < 20 words
+- Technical terms: minimal
+- Structure: simple and direct
+- Examples: use frequently
+
+## Professionals
+
+- Sentence length: moderate
+- Technical terms: industry standard
+- Structure: logical and rigorous
+- Examples: precise
+
+## Academic Readers
+
+- Sentence length: can be longer
+- Technical terms: specialized and formal
+- Structure: well-argued
+- Citations: complete and proper
+```
+
+### Genre Adaptation
+
+```markdown
+## News/Media
+- Flesch: 60-70
+- Sentence length: 15-20 words
+- Style: concise and objective
+
+## Business Documents
+- Flesch: 50-60
+- Sentence length: 18-22 words
+- Style: professional and clear
+
+## Technical Documentation
+- Flesch: 40-50
+- Sentence length: 20-25 words
+- Style: accurate and detailed
+
+## Academic Papers
+- Flesch: 30-40
+- Sentence length: 25-30 words
+- Style: rigorous and formal
+```
+
+---
+
+## 5. Visual Readability
+
+### Typography Recommendations
+
+```markdown
+## Line Length
+
+- Optimal: 45-75 characters per line
+- Too long causes reading fatigue
+
+## Line Height
+
+- Recommended: 1.5-2x line spacing
+- Body text: 1.5x
+- Headings: 1.2x
+
+## Paragraph Spacing
+
+- Leave one blank line between paragraphs
+- More space before subheadings
+
+## Font
+
+- Body: sans-serif font
+- Size: 14-16px
+- Contrast: sufficient clarity
+```
+
+### Formatting Elements
+
+```markdown
+## Effective Use
+
+- Bullet lists
+- Numbered steps
+- Comparison tables
+- Code blocks
+- Blockquotes
+- Selective bold text
+
+## Avoid
+
+- Bold everywhere
+- Too many colors
+- Mixed fonts
+- Lack of whitespace
+```
+
+---
+
+## 6. Checklist
+
+```markdown
+## Readability Checklist
+
+### Sentence Level
+- [ ] Average sentence length is moderate
+- [ ] No overly long sentences (>40 words)
+- [ ] Varied sentence structures
+- [ ] Clear logic
+
+### Vocabulary Level
+- [ ] Technical terms are explained
+- [ ] Word choice is concise
+- [ ] No obscure expressions
+- [ ] Vocabulary suits the audience
+
+### Structure Level
+- [ ] Subheadings used
+- [ ] Paragraph length is moderate
+- [ ] Logical hierarchy is clear
+- [ ] Transitions connect ideas
+
+### Visual Level
+- [ ] Clean layout
+- [ ] Sufficient whitespace
+- [ ] Consistent formatting
+- [ ] Lists and tables used where appropriate
+```
+
+---
+
+## Quick Reference
+
+### Readability Quick Check
+
+```markdown
+1. Sentence > 40 words? → Split it
+2. Paragraph > 5 sentences? → Break it up
+3. Unexplained jargon? → Add explanation
+4. Long text wall? → Add subheadings
+5. Can content be listed? → Convert to list
+```
+
+### Target Scores by Context
+
+| Context | Flesch Score | Avg Sentence Length |
+|---------|-------------|---------------------|
+| Social media | 70-80 | 10-15 words |
+| Blog posts | 60-70 | 15-20 words |
+| Business emails | 55-65 | 18-22 words |
+| Technical docs | 45-55 | 20-25 words |
+| Academic papers | 30-45 | 25-30 words |
+
+### Reading Time Estimation
+
+```markdown
+English: approx. 200-250 words/minute
+
+Formula:
+Reading time = Total words / Reading speed
+```

package/genes/readability-analyzer/index.ts

@@ -0,0 +1,123 @@
+interface ReadabilityInput {
+  text: string;
+}
+
+interface ReadabilityOutput {
+  fleschKincaid: number;
+  gradeLevel: number;
+  avgSentenceLength: number;
+  avgSyllablesPerWord: number;
+  wordCount: number;
+  sentenceCount: number;
+  complexWordRatio: number;
+  verdict: string;
+}
+
+function countSyllables(word: string): number {
+  word = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (word.length <= 2) return 1;
+
+  const vowelGroups = word.match(/[aeiouy]+/g);
+  let count = vowelGroups ? vowelGroups.length : 1;
+
+  if (word.endsWith("e") && !word.endsWith("le") && count > 1) count--;
+  if (word.endsWith("ed") && count > 1) count--;
+  if (word.endsWith("es") && !word.endsWith("ses") && !word.endsWith("zes") && count > 1) count--;
+
+  return Math.max(count, 1);
+}
+
+function splitSentences(text: string): string[] {
+  return text
+    .split(/[.!?]+/)
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+function splitWords(text: string): string[] {
+  return text
+    .split(/\s+/)
+    .map((w) => w.replace(/[^a-zA-Z'-]/g, ""))
+    .filter((w) => w.length > 0);
+}
+
+function getVerdict(score: number): string {
+  if (score >= 90) return "Very easy to read (5th grade)";
+  if (score >= 80) return "Easy to read (6th grade)";
+  if (score >= 70) return "Fairly easy to read (7th grade)";
+  if (score >= 60) return "Standard (8th-9th grade)";
+  if (score >= 50) return "Fairly difficult (10th-12th grade)";
+  if (score >= 30) return "Difficult (college level)";
+  return "Very difficult (graduate level)";
+}
+
+/**
+ * Readability Analyzer Gene
+ *
+ * Computes Flesch-Kincaid readability metrics for English text.
+ * Pure algorithmic implementation with no external dependencies.
+ */
+export async function express(input: ReadabilityInput): Promise<ReadabilityOutput> {
+  const text = (input.text || "").trim();
+  if (!text) {
+    return {
+      fleschKincaid: 0,
+      gradeLevel: 0,
+      avgSentenceLength: 0,
+      avgSyllablesPerWord: 0,
+      wordCount: 0,
+      sentenceCount: 0,
+      complexWordRatio: 0,
+      verdict: "No text provided",
+    };
+  }
+
+  const sentences = splitSentences(text);
+  const words = splitWords(text);
+  const sentenceCount = Math.max(sentences.length, 1);
+  const wordCount = words.length;
+
+  if (wordCount === 0) {
+    return {
+      fleschKincaid: 0,
+      gradeLevel: 0,
+      avgSentenceLength: 0,
+      avgSyllablesPerWord: 0,
+      wordCount: 0,
+      sentenceCount: 0,
+      complexWordRatio: 0,
+      verdict: "No words found",
+    };
+  }
+
+  const syllableCounts = words.map(countSyllables);
+  const totalSyllables = syllableCounts.reduce((a, b) => a + b, 0);
+  const complexWords = syllableCounts.filter((s) => s >= 3).length;
+
+  const avgSentenceLength = wordCount / sentenceCount;
+  const avgSyllablesPerWord = totalSyllables / wordCount;
+  const complexWordRatio = complexWords / wordCount;
+
+  // Flesch-Kincaid Reading Ease: 206.835 - 1.015*(words/sentences) - 84.6*(syllables/words)
+  const fleschKincaid = Math.max(
+    0,
+    Math.min(100, 206.835 - 1.015 * avgSentenceLength - 84.6 * avgSyllablesPerWord)
+  );
+
+  // Flesch-Kincaid Grade Level: 0.39*(words/sentences) + 11.8*(syllables/words) - 15.59
+  const gradeLevel = Math.max(
+    0,
+    0.39 * avgSentenceLength + 11.8 * avgSyllablesPerWord - 15.59
+  );
+
+  return {
+    fleschKincaid: Math.round(fleschKincaid * 100) / 100,
+    gradeLevel: Math.round(gradeLevel * 10) / 10,
+    avgSentenceLength: Math.round(avgSentenceLength * 10) / 10,
+    avgSyllablesPerWord: Math.round(avgSyllablesPerWord * 100) / 100,
+    wordCount,
+    sentenceCount,
+    complexWordRatio: Math.round(complexWordRatio * 1000) / 1000,
+    verdict: getVerdict(fleschKincaid),
+  };
+}

package/genes/readability-analyzer/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/genes/readability-analyzer/phenotype.json

@@ -0,0 +1,35 @@
+{
+  "domain": "content.readability",
+  "description": "Analyze and improve content readability. Evaluate sentence complexity, word choice, and overall accessibility. Use when ensuring content is appropriate for target audience reading level.",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "English text to analyze for readability"
+      }
+    },
+    "required": ["text"]
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "fleschKincaid": { "type": "number", "description": "Flesch-Kincaid reading ease score (0-100)" },
+      "gradeLevel": { "type": "number", "description": "US grade level" },
+      "avgSentenceLength": { "type": "number", "description": "Average words per sentence" },
+      "avgSyllablesPerWord": { "type": "number", "description": "Average syllables per word" },
+      "wordCount": { "type": "number", "description": "Total word count" },
+      "sentenceCount": { "type": "number", "description": "Total sentence count" },
+      "complexWordRatio": { "type": "number", "description": "Ratio of words with 3+ syllables" },
+      "verdict": { "type": "string", "description": "Readability verdict (e.g. Easy to read, College level)" }
+    },
+    "required": ["fleschKincaid", "gradeLevel", "avgSentenceLength", "avgSyllablesPerWord", "wordCount", "sentenceCount", "complexWordRatio", "verdict"]
+  },
+  "dependencies": [],
+  "version": "0.2.0",
+  "author": "rotifer-team",
+  "createdAt": 1771939401147,
+  "fidelity": "Native",
+  "transparency": "Open",
+  "source": "skill"
+}

package/genes/rotifer-protocol/SKILL.md

@@ -0,0 +1,121 @@
+---
+name: skill-to-gene
+description: Turn your static AI skills into evolving Genes that compete, improve, and self-select in a live Arena. Use when the user wants smarter skills, self-improving agents, or mentions evolution, fitness, arena, gene, or rotifer.
+---
+
+# Skill-to-Gene
+
+Your skills are static. Genes evolve.
+
+**Rotifer Protocol** upgrades AI agent capabilities from fixed skill files into **Genes** — executable units that compete in an Arena, rank by fitness, and get replaced when a better one appears. No manual maintenance. No stale tools.
+
+---
+
+## Why upgrade from Skills to Genes?
+
+| | Skill | Gene |
+|---|---|---|
+| **Updates** | Manual — you edit, you push | Autonomous — Genes mutate and compete |
+| **Quality** | Trust the author | Proven in Arena — fitness-ranked |
+| **Redundancy** | Multiple skills doing the same thing | Arena selects the best, eliminates the rest |
+| **Safety** | Hope for the best | L0 immutable constraint layer — cannot be bypassed |
+| **Composition** | Copy-paste between skills | Algebraic: Seq / Par / Cond / Try operators |
+| **Isolation** | Runs in your process | WASM sandbox — zero trust execution |
+
+---
+
+## Get started (30 seconds)
+
+```bash
+npm install -g @rotifer/playground
+rotifer init my-project && cd my-project
+```
+
+You'll see a live Arena with 5 Genesis Genes ranked by fitness. No configuration needed.
+
+---
+
+## Convert any function into a Gene
+
+```bash
+rotifer scan genes/              # Find candidate functions
+rotifer wrap my-function         # Wrap as a Gene
+rotifer test my-function         # Validate in WASM sandbox
+rotifer arena submit my-function # Submit to Arena — let it compete
+rotifer arena list               # Watch the rankings
+```
+
+---
+
+## Write a Gene in TypeScript
+
+```typescript
+// genes/my-search/index.ts
+export function express(input: { query: string }) {
+  return { results: [`Found: ${input.query}`], total: 1 };
+}
+```
+
+```bash
+rotifer wrap my-search --domain search
+rotifer compile my-search          # TS → WASM automatically
+rotifer arena submit my-search     # Compete against existing search Genes
+```
+
+---
+
+## Browse & install community Genes
+
+```bash
+rotifer search "code format"     # Find Genes on Cloud
+rotifer install <gene-id>        # Install to your project
+rotifer arena list               # See how it ranks locally
+```
+
+Browse: [rotifer.dev/genes](https://rotifer.dev/genes/)
+
+---
+
+## Compose Genes into Agents
+
+```bash
+rotifer agent create search-bot --genes web-search formatter --composition Seq
+rotifer agent create resilient --genes primary backup --composition Try
+rotifer agent run search-bot --input '{"query":"hello"}'
+```
+
+| Operator | What it does |
+|----------|-------------|
+| **Seq** | Pipeline: A → B → C |
+| **Par** | Parallel: run all, merge results |
+| **Cond** | Branch: pick Gene based on input |
+| **Try** | Fallback: primary with recovery |
+
+---
+
+## Full CLI
+
+| Command | Description |
+|---------|-------------|
+| `rotifer init` | Initialize project with Genesis Genes |
+| `rotifer scan` | Find gene candidates in source code |
+| `rotifer wrap` | Convert function to Gene |
+| `rotifer test` | Test in WASM sandbox |
+| `rotifer compile` | Compile TS → WASM → Rotifer IR |
+| `rotifer arena submit` | Submit to Arena |
+| `rotifer arena list` | View rankings |
+| `rotifer publish` | Publish Gene to Cloud |
+| `rotifer search` | Search Cloud registry |
+| `rotifer install` | Install from Cloud |
+| `rotifer agent create` | Build Agent from Genes |
+| `rotifer agent run` | Execute Agent pipeline |
+
+---
+
+## Links
+
+- [rotifer.dev](https://rotifer.dev) — Website
+- [rotifer.dev/genes](https://rotifer.dev/genes/) — Gene Store
+- [rotifer.dev/docs](https://rotifer.dev/docs/) — Documentation
+- [GitLab](https://gitlab.com/rotifer-protocol/rotifer-playground) — Source
+- [Discord](https://discord.gg/6d4JrfMr) — Community

package/genes/security-auditor/.cloud-manifest.json

@@ -0,0 +1,6 @@
+{
+  "cloud_id": "686236d2-4ad0-4f82-9f42-065ef3c32d00",
+  "owner": "Rotifer Protocol",
+  "version": "0.1.0",
+  "published_at": "2026-03-17T14:13:35.542Z"
+}

package/genes/security-auditor/.gene-manifest.json

@@ -0,0 +1,8 @@
+{
+  "geneId": "e884a901d023c20d5693dec5005280d5376cafddb6213a94fc91f452239550ca",
+  "name": "security-auditor",
+  "domain": "code.security",
+  "fidelity": "Wrapped",
+  "wrappedAt": "2026-02-24T13:23:31.218Z",
+  "fromSkill": "../.cursor/skills/security-auditor/SKILL.md"
+}