@rotifer/playground 0.5.0-alpha.1 → 0.7.0

package/genes/grammar-checker/index.ts

@@ -0,0 +1,168 @@
+interface GrammarInput {
+  text: string;
+  strict?: boolean;
+}
+
+interface GrammarIssue {
+  rule: string;
+  message: string;
+  position: number;
+  suggestion: string;
+}
+
+interface GrammarOutput {
+  issues: GrammarIssue[];
+  score: number;
+  summary: string;
+}
+
+interface Rule {
+  id: string;
+  pattern: RegExp;
+  message: string;
+  suggestion: (match: RegExpExecArray) => string;
+  strict?: boolean;
+}
+
+const RULES: Rule[] = [
+  {
+    id: "double-space",
+    pattern: /  +/g,
+    message: "Multiple consecutive spaces",
+    suggestion: () => "Use a single space",
+  },
+  {
+    id: "sentence-capitalization",
+    pattern: /(?:^|[.!?]\s+)([a-z])/gm,
+    message: "Sentence should start with a capital letter",
+    suggestion: (m) => `Capitalize "${m[1]}" → "${m[1].toUpperCase()}"`,
+  },
+  {
+    id: "repeated-word",
+    pattern: /\b(\w{2,})\s+\1\b/gi,
+    message: "Repeated word",
+    suggestion: (m) => `Remove duplicate "${m[1]}"`,
+  },
+  {
+    id: "missing-period",
+    pattern: /[a-zA-Z]\s*$/,
+    message: "Text does not end with punctuation",
+    suggestion: () => "Add a period at the end",
+  },
+  {
+    id: "space-before-punctuation",
+    pattern: /\s+[,;:!?.]/g,
+    message: "Space before punctuation",
+    suggestion: () => "Remove space before punctuation mark",
+  },
+  {
+    id: "no-space-after-punctuation",
+    pattern: /[,;:][^\s\n"')\]]/g,
+    message: "Missing space after punctuation",
+    suggestion: () => "Add a space after the punctuation mark",
+  },
+  {
+    id: "a-an-mismatch",
+    pattern: /\ba\s+(?=[aeiouAEIOU]\w)/g,
+    message: '"a" before a vowel sound — should be "an"',
+    suggestion: () => 'Use "an" before vowel sounds',
+  },
+  {
+    id: "an-consonant-mismatch",
+    pattern: /\ban\s+(?=[bcdfgjklmnpqrstvwxyzBCDFGJKLMNPQRSTVWXYZ]\w)/g,
+    message: '"an" before a consonant sound — should be "a"',
+    suggestion: () => 'Use "a" before consonant sounds',
+  },
+  {
+    id: "its-confusion",
+    pattern: /\bits\s+(?=a\b|the\b|not\b|been\b|going\b|time\b)/gi,
+    message: 'Possible "it\'s" (it is) instead of "its" (possessive)',
+    suggestion: () => 'Consider "it\'s" if you mean "it is"',
+  },
+  {
+    id: "then-than",
+    pattern: /\bmore\s+\w+\s+then\b/gi,
+    message: '"then" should be "than" in comparisons',
+    suggestion: () => 'Use "than" for comparisons',
+  },
+  {
+    id: "double-negative",
+    pattern: /\b(?:don't|doesn't|didn't|won't|wouldn't|can't|couldn't)\s+\w*\s*(?:no|nothing|nobody|nowhere|never)\b/gi,
+    message: "Double negative detected",
+    suggestion: () => "Rewrite to use a single negative",
+  },
+  {
+    id: "oxford-comma",
+    pattern: /,\s+\w+\s+and\s+/gi,
+    message: "Consider Oxford comma before 'and' in a list",
+    suggestion: () => "Add comma before 'and' in lists of three or more",
+    strict: true,
+  },
+  {
+    id: "passive-voice",
+    pattern: /\b(?:is|are|was|were|been|being)\s+\w+ed\b/gi,
+    message: "Passive voice detected",
+    suggestion: () => "Consider rewriting in active voice",
+    strict: true,
+  },
+  {
+    id: "very-qualifier",
+    pattern: /\bvery\s+\w+/gi,
+    message: 'Weak qualifier "very" — consider a stronger word',
+    suggestion: () => 'Replace "very + adjective" with a single stronger adjective',
+    strict: true,
+  },
+  {
+    id: "trailing-whitespace",
+    pattern: /[ \t]+$/gm,
+    message: "Trailing whitespace at end of line",
+    suggestion: () => "Remove trailing whitespace",
+  },
+];
+
+/**
+ * Grammar Checker Gene
+ *
+ * Rule-based English grammar checker with ~15 rules.
+ * Detects common errors like double spaces, capitalization, repeated words, etc.
+ */
+export async function express(input: GrammarInput): Promise<GrammarOutput> {
+  const text = (input.text || "").trim();
+  const strict = input.strict ?? false;
+
+  if (!text) {
+    return { issues: [], score: 100, summary: "No text provided." };
+  }
+
+  const issues: GrammarIssue[] = [];
+
+  for (const rule of RULES) {
+    if (rule.strict && !strict) continue;
+
+    const regex = new RegExp(rule.pattern.source, rule.pattern.flags);
+    let match: RegExpExecArray | null;
+
+    while ((match = regex.exec(text)) !== null) {
+      issues.push({
+        rule: rule.id,
+        message: rule.message,
+        position: match.index,
+        suggestion: rule.suggestion(match),
+      });
+      if (!regex.global) break;
+    }
+  }
+
+  issues.sort((a, b) => a.position - b.position);
+
+  const wordCount = text.split(/\s+/).filter((w) => w.length > 0).length;
+  const penalty = Math.min(issues.length * 5, 100);
+  const score = Math.max(0, 100 - penalty);
+
+  const summary =
+    issues.length === 0
+      ? `No issues found in ${wordCount} words. Clean text!`
+      : `Found ${issues.length} issue${issues.length > 1 ? "s" : ""} in ${wordCount} words.`;
+
+  return { issues, score, summary };
+}

package/genes/grammar-checker/package.json

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

package/genes/grammar-checker/phenotype.json

@@ -0,0 +1,52 @@
+{
+  "domain": "content.grammar",
+  "description": "Check grammar, spelling, and punctuation in written content. Identify common errors and provide corrections. Use when reviewing any written content for grammatical accuracy.",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "text": {
+        "type": "string",
+        "description": "English text to check for grammar issues"
+      },
+      "strict": {
+        "type": "boolean",
+        "description": "Enable additional rules (passive voice, excessive adverbs)",
+        "default": false
+      }
+    },
+    "required": ["text"]
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "issues": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "rule": { "type": "string" },
+            "message": { "type": "string" },
+            "position": { "type": "number" },
+            "suggestion": { "type": "string" }
+          },
+          "required": ["rule", "message", "position", "suggestion"]
+        }
+      },
+      "score": {
+        "type": "number",
+        "description": "0-100, higher = fewer issues"
+      },
+      "summary": {
+        "type": "string"
+      }
+    },
+    "required": ["issues", "score", "summary"]
+  },
+  "dependencies": [],
+  "version": "0.2.0",
+  "author": "rotifer-team",
+  "createdAt": 1771939397858,
+  "fidelity": "Native",
+  "transparency": "Open",
+  "source": "skill"
+}

package/genes/json-validator/.cloud-manifest.json

@@ -0,0 +1,6 @@
+{
+  "cloud_id": "2770db73-0925-435a-9cd7-f978b95c9e86",
+  "owner": "Rotifer Protocol",
+  "version": "0.1.0",
+  "published_at": "2026-03-17T14:13:02.716Z"
+}

package/genes/json-validator/README.md

@@ -0,0 +1,42 @@
+# json-validator
+
+A Native Gene that validates JSON data against a JSON Schema definition.
+
+## Usage
+
+```bash
+rotifer test json-validator --input '{
+  "data": {"name": "Alice", "age": "not-a-number"},
+  "schema": {
+    "type": "object",
+    "properties": {
+      "name": {"type": "string"},
+      "age": {"type": "number"}
+    },
+    "required": ["name", "age"]
+  }
+}'
+```
+
+## Features
+
+- Full JSON Schema Draft-07 validation
+- Detailed error messages with JSON path locations
+- Strict mode for disallowing extra properties
+- Nested schema support
+
+## Input
+
+| Field | Type | Required | Description |
+|-------|------|----------|-------------|
+| `data` | any | Yes | The JSON data to validate |
+| `schema` | object | Yes | JSON Schema definition |
+| `strict` | boolean | No | Disallow additional properties (default: false) |
+
+## Output
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `valid` | boolean | Whether validation passed |
+| `errors` | array | Validation errors with path, message, keyword |
+| `errorCount` | number | Total error count |

package/genes/json-validator/index.ts

@@ -0,0 +1,112 @@
+interface ValidatorInput {
+  data: unknown;
+  schema: Record<string, unknown>;
+  strict?: boolean;
+}
+
+interface ValidationError {
+  path: string;
+  message: string;
+  keyword: string;
+}
+
+interface ValidatorOutput {
+  valid: boolean;
+  errors: ValidationError[];
+  errorCount: number;
+}
+
+function validate(
+  data: unknown,
+  schema: Record<string, unknown>,
+  path: string,
+  strict: boolean,
+): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  if (schema.type) {
+    const expected = schema.type as string;
+    const actual = Array.isArray(data) ? "array" : data === null ? "null" : typeof data;
+    if (expected !== actual) {
+      errors.push({ path, message: `Expected ${expected}, got ${actual}`, keyword: "type" });
+      return errors;
+    }
+  }
+
+  if (schema.enum && Array.isArray(schema.enum)) {
+    if (!schema.enum.includes(data)) {
+      errors.push({ path, message: `Value must be one of: ${schema.enum.join(", ")}`, keyword: "enum" });
+    }
+  }
+
+  if (typeof data === "number") {
+    if (typeof schema.minimum === "number" && data < schema.minimum) {
+      errors.push({ path, message: `Value ${data} is below minimum ${schema.minimum}`, keyword: "minimum" });
+    }
+    if (typeof schema.maximum === "number" && data > schema.maximum) {
+      errors.push({ path, message: `Value ${data} exceeds maximum ${schema.maximum}`, keyword: "maximum" });
+    }
+  }
+
+  if (typeof data === "string") {
+    if (typeof schema.minLength === "number" && data.length < schema.minLength) {
+      errors.push({ path, message: `String length ${data.length} is below minLength ${schema.minLength}`, keyword: "minLength" });
+    }
+    if (typeof schema.maxLength === "number" && data.length > schema.maxLength) {
+      errors.push({ path, message: `String length ${data.length} exceeds maxLength ${schema.maxLength}`, keyword: "maxLength" });
+    }
+    if (schema.pattern) {
+      const re = new RegExp(schema.pattern as string);
+      if (!re.test(data)) {
+        errors.push({ path, message: `String does not match pattern "${schema.pattern}"`, keyword: "pattern" });
+      }
+    }
+  }
+
+  if (Array.isArray(data) && schema.type === "array") {
+    if (typeof schema.minItems === "number" && data.length < (schema.minItems as number)) {
+      errors.push({ path, message: `Array has ${data.length} items, minimum is ${schema.minItems}`, keyword: "minItems" });
+    }
+    if (typeof schema.maxItems === "number" && data.length > (schema.maxItems as number)) {
+      errors.push({ path, message: `Array has ${data.length} items, maximum is ${schema.maxItems}`, keyword: "maxItems" });
+    }
+    if (schema.items && typeof schema.items === "object") {
+      for (let i = 0; i < data.length; i++) {
+        errors.push(...validate(data[i], schema.items as Record<string, unknown>, `${path}[${i}]`, strict));
+      }
+    }
+  }
+
+  if (data !== null && typeof data === "object" && !Array.isArray(data) && schema.type === "object") {
+    const obj = data as Record<string, unknown>;
+    const props = (schema.properties || {}) as Record<string, Record<string, unknown>>;
+    const required = (schema.required || []) as string[];
+
+    for (const key of required) {
+      if (!(key in obj)) {
+        errors.push({ path: `${path}.${key}`, message: `Required property "${key}" is missing`, keyword: "required" });
+      }
+    }
+
+    for (const [key, value] of Object.entries(obj)) {
+      if (props[key]) {
+        errors.push(...validate(value, props[key], `${path}.${key}`, strict));
+      } else if (strict && schema.additionalProperties === false) {
+        errors.push({ path: `${path}.${key}`, message: `Additional property "${key}" is not allowed`, keyword: "additionalProperties" });
+      }
+    }
+  }
+
+  return errors;
+}
+
+export async function express(input: ValidatorInput): Promise<ValidatorOutput> {
+  const { data, schema, strict = false } = input;
+
+  if (!schema || typeof schema !== "object") {
+    return { valid: false, errors: [{ path: "$", message: "Invalid schema provided", keyword: "schema" }], errorCount: 1 };
+  }
+
+  const errors = validate(data, schema, "$", strict);
+  return { valid: errors.length === 0, errors, errorCount: errors.length };
+}

package/genes/json-validator/phenotype.json

@@ -0,0 +1,42 @@
+{
+  "domain": "data.validate",
+  "description": "Validates JSON data against a JSON Schema definition, returning detailed validation errors with paths.",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "data": { "description": "The JSON data to validate (any type)" },
+      "schema": { "type": "object", "description": "JSON Schema to validate against" },
+      "strict": { "type": "boolean", "description": "Disallow additional properties not in schema", "default": false }
+    },
+    "required": ["data", "schema"]
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "valid": { "type": "boolean", "description": "Whether the data passes validation" },
+      "errors": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "path": { "type": "string", "description": "JSON path to the error (e.g. $.items[0].name)" },
+            "message": { "type": "string", "description": "Human-readable error message" },
+            "keyword": { "type": "string", "description": "The schema keyword that failed (e.g. type, required)" }
+          }
+        },
+        "description": "List of validation errors (empty if valid)"
+      },
+      "errorCount": { "type": "number", "description": "Total number of validation errors" }
+    }
+  },
+  "dependencies": [],
+  "version": "0.1.0",
+  "author": "rotifer-genesis",
+  "fidelity": "Native",
+  "transparency": "Open",
+  "semantic_requirements": {
+    "timeModel": "Sync",
+    "concurrencyModel": "Stateless",
+    "failureSemantics": "Fail"
+  }
+}

package/genes/license-advisor/.cloud-manifest.json

@@ -0,0 +1,6 @@
+{
+  "cloud_id": "ec039e24-9b85-4f49-8661-96edb5959d01",
+  "owner": "Rotifer Protocol",
+  "version": "0.1.0",
+  "published_at": "2026-03-17T14:13:04.660Z"
+}

package/genes/license-advisor/.gene-manifest.json

@@ -0,0 +1,8 @@
+{
+  "geneId": "157314d0eb6da3529235d9ad6cf877b22a46a8aec461bafeba1825040ab1841a",
+  "name": "license-advisor",
+  "domain": "legal.licensing",
+  "fidelity": "Wrapped",
+  "wrappedAt": "2026-02-24T13:23:40.260Z",
+  "fromSkill": "../.cursor/skills/license-advisor/SKILL.md"
+}

package/genes/license-advisor/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: license-advisor
+description: Analyze project requirements and recommend suitable open source licenses (MIT, Apache, GPL, AGPL, LGPL, MPL, BSL, SSPL, etc.). Use when the user asks about licensing, choosing a license, open source strategy, or mentions license names like MIT/GPL/Apache.
+---
+
+# License Advisor
+
+Help users select the most appropriate open source license by analyzing their product requirements, business model, and goals.
+
+## Analysis Process
+
+### Step 1: Gather Project Context
+
+Ask the user about:
+
+1. **Project type**: Library, framework, application, SaaS, developer tool?
+2. **Business model**: Open core, SaaS, support/consulting, donations, fully open?
+3. **Key concerns**: (rank by priority)
+   - Monetization and commercial protection
+   - Preventing cloud providers from competing
+   - Maximizing adoption and contributions
+   - Ensuring derivatives stay open
+   - Patent protection
+
+### Step 2: Apply Decision Matrix
+
+| Requirement | Recommended Licenses |
+|-------------|---------------------|
+| Maximum adoption, minimal restrictions | MIT, ISC, Unlicense |
+| Adoption + patent protection | Apache 2.0 |
+| Derivatives must stay open (weak copyleft) | LGPL, MPL 2.0 |
+| All derivatives must be open (strong copyleft) | GPL v3 |
+| Network/SaaS derivatives must be open | AGPL v3 |
+| Time-delayed open source | BSL 1.1 |
+| Prevent cloud competition | SSPL, Elastic License, FSL |
+| Dual licensing strategy | GPL + Commercial |
+
+### Step 3: Provide Recommendation
+
+Format your recommendation as:
+
+```markdown
+## License Recommendation
+
+**Primary recommendation**: [License Name]
+**Alternative options**: [Other suitable licenses]
+
+### Why this license fits your needs
+
+[2-3 bullet points explaining the match]
+
+### Key considerations
+
+- [Important implication 1]
+- [Important implication 2]
+
+### Compatibility notes
+
+[Dependencies, ecosystem considerations]
+```
+
+## Quick Reference
+
+### Permissive Licenses (Business-friendly)
+
+| License | Patent Grant | Attribution | Key Use Case |
+|---------|-------------|-------------|--------------|
+| MIT | No | Yes | Maximum adoption |
+| Apache 2.0 | Yes | Yes | Corporate-friendly, patent protection |
+| BSD 3-Clause | No | Yes | Similar to MIT |
+| ISC | No | Yes | Simplified MIT |
+
+### Copyleft Licenses (Community-focused)
+
+| License | Scope | Network Trigger | Key Use Case |
+|---------|-------|-----------------|--------------|
+| GPL v3 | Full | No | Ensure all derivatives open |
+| LGPL v3 | Library boundary | No | Open libraries, closed apps OK |
+| MPL 2.0 | File-level | No | Per-file copyleft |
+| AGPL v3 | Full | Yes | SaaS must share code |
+
+### Source-Available Licenses (Commercial protection)
+
+| License | After Delay | Cloud Restriction | Key Use Case |
+|---------|-------------|-------------------|--------------|
+| BSL 1.1 | Configurable (typically 4yr) | Production use restricted | Delayed open source |
+| SSPL | Never (not OSI) | Must open entire stack | Anti-cloud provider |
+| Elastic 2.0 | No | SaaS restriction | Similar to SSPL, less strict |
+| FSL | 2 years → Apache/MIT | Production restricted | Functional Source |
+
+## Common Scenarios
+
+### "I want maximum adoption"
+→ **MIT** or **Apache 2.0** (if patent protection needed)
+
+### "I'm building a SaaS and competitors might use my code"
+→ **AGPL v3** (if open source important) or **BSL/SSPL** (if commercial protection priority)
+
+### "I want contributions back but allow commercial use"
+→ **LGPL v3** (for libraries) or **MPL 2.0** (file-level copyleft)
+
+### "I want to sell commercial licenses"
+→ **GPL v3 + Commercial dual license** or **BSL 1.1**
+
+### "I hate cloud providers using my work"
+→ **SSPL**, **Elastic License 2.0**, or **FSL**
+
+## Detailed Reference
+
+For comprehensive license details, compatibility matrices, and legal considerations, see [LICENSES.md](LICENSES.md).
+
+## Important Caveats
+
+1. **Not legal advice**: Always recommend consulting a lawyer for commercial decisions
+2. **Dependency compatibility**: Check that chosen license is compatible with dependencies
+3. **CLA considerations**: For contributions, consider if a CLA is needed
+4. **Relicensing**: Changing licenses later requires all contributors' consent (or CLA)

package/genes/license-advisor/phenotype.json

@@ -0,0 +1,28 @@
+{
+  "domain": "legal.licensing",
+  "description": "Analyze project requirements and recommend suitable open source licenses (MIT, Apache, GPL, AGPL, LGPL, MPL, BSL, SSPL, etc.). Use when the user asks about licensing, choosing a license, open source strategy, or mentions license names like MIT/GPL/Apache.",
+  "inputSchema": {
+    "type": "object",
+    "properties": {
+      "prompt": {
+        "type": "string"
+      }
+    },
+    "required": []
+  },
+  "outputSchema": {
+    "type": "object",
+    "properties": {
+      "result": {
+        "type": "string"
+      }
+    }
+  },
+  "dependencies": [],
+  "version": "0.1.0",
+  "author": "rotifer-team",
+  "createdAt": 1771939420260,
+  "fidelity": "Wrapped",
+  "transparency": "Open",
+  "source": "skill"
+}

package/genes/logic-architect/.cloud-manifest.json

@@ -0,0 +1,6 @@
+{
+  "cloud_id": "73fb7cc6-27ae-4ecc-8d82-aa0aef317827",
+  "owner": "Rotifer Protocol",
+  "version": "0.1.0",
+  "published_at": "2026-03-17T14:13:06.466Z"
+}

package/genes/logic-architect/.gene-manifest.json

@@ -0,0 +1,8 @@
+{
+  "geneId": "571243178fd0054cf51dda771e71ba83ff0f48e336b485e64054983f9c6d60fc",
+  "name": "logic-architect",
+  "domain": "code.architecture",
+  "fidelity": "Wrapped",
+  "wrappedAt": "2026-02-24T13:23:27.334Z",
+  "fromSkill": "../.cursor/skills/logic-architect/SKILL.md"
+}