@rotifer/playground 0.8.0 → 0.8.5

package/genes/grammar-checker/index.ts

@@ -1,168 +0,0 @@
-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

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

package/genes/grammar-checker/phenotype.json

@@ -1,52 +0,0 @@
-{
-  "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/guard-balanced/.gene-manifest.json

@@ -1,8 +0,0 @@
-{
-  "geneId": "6ca9ed3958f3472001dcd416b50b756aacb4f0c299892b5a7571c5d7fda1368b",
-  "name": "guard-balanced",
-  "domain": "guard.code-review",
-  "fidelity": "Wrapped",
-  "wrappedAt": "2026-03-24T01:54:54.000Z",
-  "fromSkill": null
-}

package/genes/guard-balanced/phenotype.json

@@ -1,105 +0,0 @@
-{
-  "domain": "guard.code-review",
-  "description": "Balanced guard gene for code review output filtering. Equal weight on precision and recall — filters obvious false positives while preserving most true findings. Adds confidence scores without aggressive rejection. Part of the Code Review Assistant 3×2 arena competition.",
-  "inputSchema": {
-    "type": "object",
-    "properties": {
-      "reviewOutput": {
-        "type": "object",
-        "description": "Raw output from a Prompt Gene (code review findings)",
-        "properties": {
-          "findings": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "properties": {
-                "severity": { "type": "string" },
-                "category": { "type": "string" },
-                "message": { "type": "string" },
-                "line": { "type": "integer" },
-                "fix": { "type": "string" }
-              }
-            }
-          },
-          "summary": { "type": "string" }
-        }
-      },
-      "originalCode": {
-        "type": "string",
-        "description": "The original code being reviewed (for cross-checking)"
-      }
-    },
-    "required": ["reviewOutput"]
-  },
-  "outputSchema": {
-    "type": "object",
-    "properties": {
-      "filteredFindings": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "severity": { "type": "string" },
-            "category": { "type": "string" },
-            "message": { "type": "string" },
-            "line": { "type": "integer" },
-            "fix": { "type": "string" },
-            "confidence": { "type": "number" }
-          }
-        }
-      },
-      "rejected": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "originalMessage": { "type": "string" },
-            "rejectReason": { "type": "string" }
-          }
-        }
-      },
-      "guardStats": {
-        "type": "object",
-        "properties": {
-          "inputCount": { "type": "integer" },
-          "outputCount": { "type": "integer" },
-          "rejectRate": { "type": "number" }
-        }
-      }
-    }
-  },
-  "llmRequirements": {
-    "templateFormat": "mustache",
-    "templateVariables": ["reviewOutput", "originalCode"],
-    "targetModels": ["claude-3", "gpt-4"],
-    "minContextWindow": 8192,
-    "expectedOutputFormat": "json",
-    "temperatureHint": 0.1,
-    "maxOutputTokens": 4096,
-    "systemPromptPath": "system-prompt.md",
-    "chainOfThought": false
-  },
-  "guardConfig": {
-    "mode": "filter",
-    "vgContribution": "Security_Leak_Risk",
-    "strictness": "balanced",
-    "targetFalsePositiveRate": 0.15,
-    "targetFalseNegativeRate": 0.10
-  },
-  "fitnessConfig": {
-    "evaluationMethod": "template-quality",
-    "dimensions": {
-      "precision": { "weight": 0.30, "description": "1 - false positive rate" },
-      "recall": { "weight": 0.30, "description": "Fraction of true issues preserved" },
-      "rejectQuality": { "weight": 0.20, "description": "Correctness of reject reasons" },
-      "templateValidity": { "weight": 0.10, "description": "Template renders without error" },
-      "resourceEfficiency": { "weight": 0.10, "description": "Token efficiency" }
-    }
-  },
-  "dependencies": [],
-  "version": "0.1.0",
-  "author": "rotifer-team",
-  "fidelity": "Wrapped",
-  "transparency": "Open",
-  "source": "development-genome"
-}

package/genes/guard-balanced/system-prompt.md

@@ -1,23 +0,0 @@
-You are a BALANCED code review guard. Your job is to filter code review findings while preserving most genuine issues.
-
-Your philosophy: **Catch obvious false positives, but err on the side of including uncertain findings with lower confidence scores.**
-
-For each finding in the review output, evaluate:
-
-1. **Existence check**: If `originalCode` is provided, verify the described code pattern actually exists. REJECT only clear hallucinations.
-2. **Confidence scoring**: Assign a confidence score (0-1):
-   - 0.9-1.0: Finding references specific line and code pattern exists
-   - 0.7-0.9: Finding is plausible but line reference is approximate
-   - 0.5-0.7: Finding is generic but category is relevant to the code
-   - Below 0.5: REJECT — too vague or unsupported
-3. **Severity validation**: Only adjust severity if clearly wrong (e.g., "critical" for a style issue).
-4. **Deduplication**: If multiple findings describe the same issue, keep the most specific one.
-
-Pass findings with confidence >= 0.4 (lower threshold than strict mode).
-
-Output valid JSON with:
-- `filteredFindings`: findings that survived (with confidence scores)
-- `rejected`: only clearly false findings (with brief reason)
-- `guardStats`: input/output counts and reject rate
-
-The reject rate should typically be 10-25%. If you're rejecting >40%, you're being too strict.

package/genes/guard-strict/.gene-manifest.json

@@ -1,8 +0,0 @@
-{
-  "geneId": "9140b1416a649930a950e345746bf68996ef8043ec2fd83ab73474a6f1fd5875",
-  "name": "guard-strict",
-  "domain": "guard.code-review",
-  "fidelity": "Wrapped",
-  "wrappedAt": "2026-03-24T01:54:54.000Z",
-  "fromSkill": null
-}

package/genes/guard-strict/phenotype.json

@@ -1,107 +0,0 @@
-{
-  "domain": "guard.code-review",
-  "description": "Strict guard gene for code review output filtering. High precision, low recall — blocks false positives aggressively. Prefers missing a real issue over flagging a non-issue. Part of the Code Review Assistant 3×2 arena competition.",
-  "inputSchema": {
-    "type": "object",
-    "properties": {
-      "reviewOutput": {
-        "type": "object",
-        "description": "Raw output from a Prompt Gene (code review findings)",
-        "properties": {
-          "findings": {
-            "type": "array",
-            "items": {
-              "type": "object",
-              "properties": {
-                "severity": { "type": "string" },
-                "category": { "type": "string" },
-                "message": { "type": "string" },
-                "line": { "type": "integer" },
-                "fix": { "type": "string" }
-              }
-            }
-          },
-          "summary": { "type": "string" }
-        }
-      },
-      "originalCode": {
-        "type": "string",
-        "description": "The original code being reviewed (for cross-checking)"
-      }
-    },
-    "required": ["reviewOutput"]
-  },
-  "outputSchema": {
-    "type": "object",
-    "properties": {
-      "filteredFindings": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "severity": { "type": "string" },
-            "category": { "type": "string" },
-            "message": { "type": "string" },
-            "line": { "type": "integer" },
-            "fix": { "type": "string" },
-            "confidence": { "type": "number", "description": "0-1 confidence that this is a real issue" }
-          }
-        },
-        "description": "Only findings that pass strict validation"
-      },
-      "rejected": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "originalMessage": { "type": "string" },
-            "rejectReason": { "type": "string" }
-          }
-        },
-        "description": "Findings rejected with reason"
-      },
-      "guardStats": {
-        "type": "object",
-        "properties": {
-          "inputCount": { "type": "integer" },
-          "outputCount": { "type": "integer" },
-          "rejectRate": { "type": "number" }
-        }
-      }
-    }
-  },
-  "llmRequirements": {
-    "templateFormat": "mustache",
-    "templateVariables": ["reviewOutput", "originalCode"],
-    "targetModels": ["claude-3", "gpt-4"],
-    "minContextWindow": 8192,
-    "expectedOutputFormat": "json",
-    "temperatureHint": 0.0,
-    "maxOutputTokens": 4096,
-    "systemPromptPath": "system-prompt.md",
-    "chainOfThought": true
-  },
-  "guardConfig": {
-    "mode": "filter",
-    "vgContribution": "Security_Leak_Risk",
-    "strictness": "high",
-    "targetFalsePositiveRate": 0.05,
-    "targetFalseNegativeRate": 0.30
-  },
-  "fitnessConfig": {
-    "evaluationMethod": "template-quality",
-    "dimensions": {
-      "precision": { "weight": 0.40, "description": "1 - false positive rate" },
-      "recall": { "weight": 0.20, "description": "Fraction of true issues preserved" },
-      "rejectQuality": { "weight": 0.20, "description": "Correctness of reject reasons" },
-      "templateValidity": { "weight": 0.10, "description": "Template renders without error" },
-      "resourceEfficiency": { "weight": 0.10, "description": "Token efficiency" }
-    }
-  },
-  "dependencies": [],
-  "version": "0.1.0",
-  "author": "rotifer-team",
-  "fidelity": "Wrapped",
-  "transparency": "Open",
-  "source": "development-genome"
-}

package/genes/guard-strict/system-prompt.md

@@ -1,18 +0,0 @@
-You are a STRICT code review guard. Your job is to filter code review findings, removing likely false positives.
-
-Your philosophy: **Better to miss a real issue than to waste developer time on a false alarm.**
-
-For each finding in the review output, evaluate:
-
-1. **Line reference check**: Does the finding reference a specific line? If the line number doesn't correspond to relevant code, REJECT.
-2. **Category validity**: Is the category (e.g., "injection", "memory-leak") supported by the actual code pattern? Reject vague or generic warnings.
-3. **Fix actionability**: Does the fix suggestion contain concrete code? Reject findings with only "consider reviewing" or "be careful" advice.
-4. **Hallucination check**: If `originalCode` is provided, verify the finding references actual code constructs. Reject if the finding describes code that doesn't exist.
-5. **Severity calibration**: Downgrade "critical" to "warning" if the exploit requires unlikely preconditions.
-
-Only pass findings with confidence >= 0.7.
-
-Output valid JSON with:
-- `filteredFindings`: findings that survived filtering (with confidence scores)
-- `rejected`: findings removed (with reject reasons for transparency)
-- `guardStats`: input/output counts and reject rate

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

@@ -1,6 +0,0 @@
-{
-  "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

@@ -1,42 +0,0 @@
-# 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

@@ -1,112 +0,0 @@
-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 };
-}