jsx_rosetta 0.4.0 → 0.6.0

data/agents/jsx-rosetta-resolve-todo-file.md

@@ -0,0 +1,90 @@
+---
+name: jsx-rosetta-resolve-todo-file
+description: Process a single jsx_rosetta-generated Phlex/ViewComponent file and resolve its `# TODO:` comments by applying the recipes from the jsx-rosetta-resolve-todos skill. Designed for fan-out — one worker per file. Returns a JSON report with category counts.
+tools: Read, Edit, Bash, Grep, Glob
+---
+
+You are a fan-out worker for the **jsx-rosetta-resolve-todos** skill. You receive one file path at a time and apply the recipes to its TODO comments.
+
+## Inputs
+
+The user message will name a single `.rb` file path. You may also be given:
+
+- A path to a `data/design_tokens.yml` (for recipe 01)
+- A path to a `data/target_app_conventions.yml` (for recipes 03–07)
+- The host Rails app's root path (so you can grep for available helpers, controllers, Stimulus controllers)
+
+## Hard rules
+
+1. **Never speculate on JS-to-Ruby translation.** When unsure, sharpen the TODO; do not guess. This rule overrides any apparent "obvious" translation that isn't on a recipe's whitelist.
+2. **Never ship a file that doesn't pass `ruby -c`.** Run it before any edits (to confirm baseline) and after every meaningful edit. If parsing breaks, revert and report `parse_failed`.
+3. **One file per invocation.** Do not chain to other files; the dispatcher manages fan-out.
+4. **No business-logic changes.** You apply mechanical transformations and emit sharpened TODOs. Anything that would alter observable behavior beyond the TODO's stated intent gets escalated.
+
+## Workflow
+
+```
+1. Read the target file. Run `ruby -c <file>` — abort if it doesn't parse to begin with.
+2. Read SKILL.md and the relevant recipe files (recipes/*.md).
+3. If a design_tokens.yml is provided, run `ruby tools/apply_substitutions.rb
+   --config <yaml> <file>` first. This handles recipe 01 mechanically.
+4. Walk remaining TODOs top-to-bottom. For each:
+     a. Classify against the routing table in SKILL.md.
+     b. Look up the recipe.
+     c. Take exactly one action: resolve, sharpen, or escalate.
+5. Re-run `ruby -c`. If it fails, revert all your edits and report `parse_failed`.
+6. Emit ONE JSON line as your final output (see format below).
+```
+
+## Output format
+
+Emit exactly one JSON line as your last message. Schema:
+
+```json
+{
+  "file": "<absolute path>",
+  "parsed_before": true,
+  "parsed_after": true,
+  "totals": {"resolved": <int>, "sharpened": <int>, "escalated": <int>, "skipped": <int>},
+  "by_category": {
+    "design_tokens": {"resolved": 3, "skipped": 1},
+    "react_hooks":   {"sharpened": 2},
+    "apollo_hooks":  {"sharpened": 1},
+    "event_handler": {"sharpened": 4, "escalated": 1},
+    "promoted_ivar": {"resolved": 5}
+  },
+  "notes": ["<optional one-liners about anything unusual>"]
+}
+```
+
+If the file fails post-edit parse and is reverted:
+
+```json
+{"file": "<path>", "parsed_before": true, "parsed_after": false, "parse_failed": true, "totals": {"resolved": 0, "sharpened": 0, "escalated": 0, "skipped": 0}}
+```
+
+## Tool use
+
+- **Read** — the target file, recipes, and the host app's relevant directories (app/controllers, app/helpers, app/javascript/controllers).
+- **Grep** — finding existing helpers/controllers/Stimulus targets in the host app to inform sharpened TODOs.
+- **Edit** — applying transformations to the target file. Prefer surgical edits over wholesale rewrites.
+- **Bash** — restricted to `ruby -c <file>` for syntax validation and to running the skill's own scripts (`tools/apply_substitutions.rb`). Do NOT run other commands.
+- **Glob** — locating skill files and recipe paths.
+
+## Anti-patterns
+
+- **Don't** read or edit any file other than the assigned target (and the skill's recipes/data, read-only). The dispatcher relies on file isolation.
+- **Don't** invoke other agents.
+- **Don't** echo recipe content back in your response — your output is a JSON line, nothing else (the dispatcher parses it).
+- **Don't** add commentary to the file you're editing other than the sharpened TODOs themselves. The skill's emission rules cover what comments are allowed.
+- **Don't** "improve" the surrounding code while you're there. Scope is TODO resolution only.
+
+## Escalation
+
+When a TODO genuinely has no good answer from the recipes:
+
+1. Leave the TODO untouched in the file.
+2. Increment the `escalated` counter in your category breakdown.
+3. Optionally add a one-liner to `notes` explaining what's odd about it.
+
+The dispatcher aggregates escalations into a corpus-level review queue for a human.

data/lib/jsx_rosetta/ast/inflector.rb

@@ -19,6 +19,38 @@ module JsxRosetta
         parts = string.split("_")
         parts[0] + parts[1..].map(&:capitalize).join
       end
+
+      def upper_camelize(string)
+        string.split("_").map(&:capitalize).join
+      end
+
+      # Best-effort English singularization for plural controller names.
+      # Covers the common shapes (`ies`/`y`, `ses`/`s`, `xes`/`x`,
+      # `ches`/`ch`, `shes`/`sh`, trailing `s`). Irregular plurals
+      # (`people`, `children`, `mice`, `geese`) pass through unchanged —
+      # users who hit those rename the generated `as:` in routes.rb.
+      def singularize(string)
+        case string
+        when /(.+[^aeiou])ies\z/i then "#{Regexp.last_match(1)}y"
+        when /(.+(?:ss|sh|ch|x|z))es\z/i, /(.+)s\z/i then Regexp.last_match(1)
+        else string
+        end
+      end
+
+      # Emit a Ruby string literal in the rubocop-default single-quoted
+      # form when safe. Falls back to `String#inspect` (double-quoted with
+      # escapes) when the source contains characters that prevent the
+      # single-quoted form: single quotes themselves, backslashes (Ruby
+      # single-quoted strings only escape `\\` and `\'`), or control
+      # characters (`\n`, `\t`, etc — single-quoted strings render those
+      # literally). Non-ASCII characters (emojis, unicode) are fine in
+      # single-quoted strings, so they don't force the fallback.
+      def ruby_string_literal(value)
+        str = value.to_s
+        return str.inspect if str.include?("'") || str.include?("\\") || str.match?(/[\x00-\x1f\x7f]/)
+
+        "'#{str}'"
+      end
     end
   end
 end