pixelweaver 0.1.0

package/scripts/eslint-wave-a-status.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+# Counts Wave A target rule violations (no-non-null-assertion + restrict-template-expressions)
+# Usage: ./scripts/eslint-wave-a-status.sh [path...]
+# Without args, checks src/ plugins/
+set -euo pipefail
+PATHS=("$@")
+if [ ${#PATHS[@]} -eq 0 ]; then
+  PATHS=(src/ plugins/)
+fi
+npx eslint "${PATHS[@]}" -f json 2>/dev/null | node -e '
+let input = "";
+process.stdin.on("data", d => input += d);
+process.stdin.on("end", () => {
+  const data = JSON.parse(input);
+  let non = 0, tpl = 0, other = 0, total = 0;
+  for (const f of data) for (const m of f.messages) {
+    if (m.severity !== 2) continue;
+    total++;
+    if (m.ruleId === "@typescript-eslint/no-non-null-assertion") non++;
+    else if (m.ruleId === "@typescript-eslint/restrict-template-expressions") tpl++;
+    else other++;
+  }
+  console.log(`total=${total} non-null=${non} template=${tpl} other=${other}`);
+});
+'

package/scripts/fix-index-signature-access.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Apply targeted fixes for noPropertyAccessFromIndexSignature (TS4111) errors.
+
+TS4111 format:
+    path(line,col): error TS4111: Property 'foo' comes from an index
+        signature, so it must be accessed with ['foo'].
+
+At the reported column in the source line, we expect either:
+    - `.foo`  -> replace with `["foo"]`
+    - `?.foo` -> replace with `?.["foo"]` (optional chaining form)
+
+The column from tsc points to the start of the property name `foo`, so we
+look back to see if the preceding character is `.`. If so we rewrite it.
+We process columns right-to-left on the same line so earlier edits don't
+shift later positions.
+
+Usage: scripts/fix-index-signature-access.py <tsc-errors.log> [--apply]
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from collections import defaultdict
+
+ERROR_LINE_RE = re.compile(
+    r"^(?P<path>[^(]+)\((?P<line>\d+),(?P<col>\d+)\): error TS4111: "
+    r"Property '(?P<prop>[^']+)' comes from an index signature"
+)
+
+
+def parse_errors(log_path: Path) -> dict[Path, list[tuple[int, int, str]]]:
+    errs: dict[Path, list[tuple[int, int, str]]] = defaultdict(list)
+    for raw in log_path.read_text().splitlines():
+        m = ERROR_LINE_RE.match(raw)
+        if not m:
+            continue
+        path = Path(m.group("path"))
+        errs[path].append((int(m.group("line")), int(m.group("col")), m.group("prop")))
+    return errs
+
+
+def fix_line(line: str, col: int, prop: str) -> str | None:
+    """
+    col is 1-based and points to the first character of `prop`.
+    We look at line[col-2] which should be `.`.
+    If the char before that is also `?` (optional chain), handle `?.foo`.
+    Replace with `["prop"]` or `?.["prop"]` (keep the ? chain).
+    """
+    # Convert to 0-based
+    start = col - 1
+    end = start + len(prop)
+    if end > len(line):
+        return None
+    if line[start:end] != prop:
+        # The column may be slightly off; try a nearby match
+        return None
+    if start == 0 or line[start - 1] != ".":
+        return None
+    # Check for optional chaining ?.
+    if start >= 2 and line[start - 2] == "?":
+        # `?.foo` -> `?.["foo"]`
+        prefix = line[: start - 2]
+        suffix = line[end:]
+        return prefix + '?.["' + prop + '"]' + suffix
+    else:
+        # `.foo` -> `["foo"]`
+        prefix = line[: start - 1]
+        suffix = line[end:]
+        return prefix + '["' + prop + '"]' + suffix
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print(__doc__)
+        return 1
+    log = Path(sys.argv[1])
+    apply = "--apply" in sys.argv[2:]
+    errs = parse_errors(log)
+    total_fixed = 0
+    total_files = 0
+    total_skipped = 0
+    for path, positions in errs.items():
+        if not path.exists():
+            continue
+        lines = path.read_text().splitlines(keepends=True)
+        # Sort positions: by line ascending, then col DESCENDING so that
+        # replacements on the same line don't shift earlier columns.
+        positions.sort(key=lambda p: (p[0], -p[1]))
+        file_fixed = 0
+        file_skipped = 0
+        for lineno, col, prop in positions:
+            idx = lineno - 1
+            if idx >= len(lines):
+                continue
+            original = lines[idx]
+            eol = ""
+            if original.endswith("\r\n"):
+                eol = "\r\n"
+                content = original[:-2]
+            elif original.endswith("\n"):
+                eol = "\n"
+                content = original[:-1]
+            else:
+                content = original
+            new = fix_line(content, col, prop)
+            if new is not None and new != content:
+                lines[idx] = new + eol
+                file_fixed += 1
+            else:
+                file_skipped += 1
+        if file_fixed:
+            total_fixed += file_fixed
+            total_files += 1
+            if apply:
+                path.write_text("".join(lines))
+            print(f"{'FIX' if apply else 'DRY'} {path}: {file_fixed} line(s), {file_skipped} skipped")
+        elif file_skipped:
+            print(f"SKIP {path}: {file_skipped} skipped")
+        total_skipped += file_skipped
+    print(f"Total: {total_fixed} fix(es) across {total_files} file(s), {total_skipped} skipped")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/fix-unchecked-index.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""
+Apply targeted fixes for noUncheckedIndexedAccess errors in test files.
+
+For each line reported by tsc, if the pattern is a simple `arr[N].foo`
+or `arr[key].foo`, it rewrites to `arr[N]!.foo`. It's meant to be run
+iteratively; rerun tsc after each pass.
+
+Usage: scripts/fix-unchecked-index.py <tsc-errors.log> [--apply]
+
+Without --apply, it only prints what it would do. Operates only on .test.ts
+files by default.
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from collections import defaultdict
+
+ERROR_LINE_RE = re.compile(
+    r"^(?P<path>[^(]+)\((?P<line>\d+),(?P<col>\d+)\): error TS(?P<code>\d+): (?P<msg>.*)$"
+)
+
+# Match identifier/call chain followed by [index] followed by .prop.
+# Captures: group 3 is the `.` after `[...]`. Handles identifiers, member
+# accesses (`a.b.c`), and calls (`a.b()`), including multiple chained calls.
+BRACKET_DOT_RE = re.compile(
+    r"([A-Za-z_$][\w$]*(?:\??\.[A-Za-z_$][\w$]*|\([^()]*\))*)\[([^\]\[]+)\](\.)"
+)
+
+
+def parse_errors(log_path: Path, only_tests: bool) -> dict[Path, list[tuple[int, int]]]:
+    errs: dict[Path, list[tuple[int, int]]] = defaultdict(list)
+    for raw in log_path.read_text().splitlines():
+        m = ERROR_LINE_RE.match(raw)
+        if not m:
+            continue
+        code = m.group("code")
+        if code not in ("2532", "18048"):
+            continue
+        path = Path(m.group("path"))
+        if only_tests and not path.name.endswith(".test.ts"):
+            continue
+        errs[path].append((int(m.group("line")), int(m.group("col"))))
+    return errs
+
+
+def fix_line(line: str, col: int) -> str | None:
+    """
+    Look for `identifier[idx].` where the `.` (or at least the `]`) is near `col`.
+    Add `!` before the `.` so it becomes `identifier[idx]!.`.
+    Prefer the match whose `]` is closest to (but before or at) col-1.
+    Returns new line or None if no change.
+    """
+    matches = list(BRACKET_DOT_RE.finditer(line))
+    if not matches:
+        return None
+    # Column from tsc is 1-based and usually points to start of the whole expr
+    # or the `.` position; in practice it's the start of the object. Pick the
+    # first match at-or-after col-1 if any, else the last one on the line.
+    chosen = None
+    target = col - 1
+    for m in matches:
+        if m.start() >= target:
+            chosen = m
+            break
+    if chosen is None:
+        chosen = matches[0]
+    # Insert ! before the dot. `chosen.end(3)` is index after the dot; the dot
+    # is group(3). Position of dot: chosen.start(3).
+    dot_pos = chosen.start(3)
+    # Ensure there is no ! right before the dot already
+    if dot_pos > 0 and line[dot_pos - 1] == "!":
+        return None
+    return line[:dot_pos] + "!" + line[dot_pos:]
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print(__doc__)
+        return 1
+    log = Path(sys.argv[1])
+    apply = "--apply" in sys.argv[2:]
+    only_tests = "--all" not in sys.argv[2:]
+    errs = parse_errors(log, only_tests=only_tests)
+    total_fixed = 0
+    total_files = 0
+    for path, positions in errs.items():
+        if not path.exists():
+            continue
+        lines = path.read_text().splitlines(keepends=True)
+        # Sort positions descending so we fix later cols first on same line.
+        # Actually sort by (line, -col) so we process multiple cols on a line
+        # from right to left, preserving indices.
+        positions.sort(key=lambda p: (p[0], -p[1]))
+        file_fixed = 0
+        for lineno, col in positions:
+            idx = lineno - 1
+            if idx >= len(lines):
+                continue
+            original = lines[idx]
+            # Strip trailing newline for regex, reattach after
+            eol = ""
+            if original.endswith("\r\n"):
+                eol = "\r\n"
+                content = original[:-2]
+            elif original.endswith("\n"):
+                eol = "\n"
+                content = original[:-1]
+            else:
+                content = original
+            new = fix_line(content, col)
+            if new is not None and new != content:
+                lines[idx] = new + eol
+                file_fixed += 1
+        if file_fixed:
+            total_fixed += file_fixed
+            total_files += 1
+            if apply:
+                path.write_text("".join(lines))
+            print(f"{'FIX' if apply else 'DRY'} {path}: {file_fixed} line(s)")
+    print(f"Total: {total_fixed} fix(es) across {total_files} file(s)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/fix-unchecked-vars.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""
+Fix TS18048/TS2532 by chasing "X is possibly undefined" errors back to a
+variable declaration of the form `const X = <expr>[key];` and appending `!`.
+
+Usage: scripts/fix-unchecked-vars.py <tsc-errors.log> [--apply] [--all]
+"""
+from __future__ import annotations
+
+import re
+import sys
+from pathlib import Path
+from collections import defaultdict
+
+ERROR_LINE_RE = re.compile(
+    r"^(?P<path>[^(]+)\((?P<line>\d+),(?P<col>\d+)\): error TS(?P<code>\d+): (?P<msg>.*)$"
+)
+POSSIBLY_UNDEF_RE = re.compile(r"'([A-Za-z_$][\w$]*)' is possibly 'undefined'")
+
+# const NAME = <expr>[<key>]; or  const NAME = <expr>.get(...);
+# Append ! before the trailing ; (or end of statement) if not already present
+DECL_INDEX_RE = re.compile(
+    r"^(?P<pre>\s*(?:const|let|var)\s+(?P<name>[A-Za-z_$][\w$]*)\s*=\s*[^;]*?\])(?P<post>\s*;?\s*)$"
+)
+DECL_GET_RE = re.compile(
+    r"^(?P<pre>\s*(?:const|let|var)\s+(?P<name>[A-Za-z_$][\w$]*)\s*=\s*[^;]*\.get\([^;]*\))(?P<post>\s*;?\s*)$"
+)
+
+
+def parse_errors(log_path: Path, only_tests: bool) -> dict[Path, list[tuple[int, str]]]:
+    errs: dict[Path, set[tuple[int, str]]] = defaultdict(set)
+    for raw in log_path.read_text().splitlines():
+        m = ERROR_LINE_RE.match(raw)
+        if not m:
+            continue
+        code = m.group("code")
+        if code not in ("2532", "18048"):
+            continue
+        msg = m.group("msg")
+        mm = POSSIBLY_UNDEF_RE.match(msg)
+        if not mm:
+            continue
+        name = mm.group(1)
+        path = Path(m.group("path"))
+        if only_tests and not path.name.endswith(".test.ts"):
+            continue
+        errs[path].add((int(m.group("line")), name))
+    return {p: sorted(s) for p, s in errs.items()}
+
+
+def find_decl(lines: list[str], use_line_idx: int, name: str) -> int | None:
+    """Search backwards for `const|let|var NAME =` declaration."""
+    pattern = re.compile(rf"^\s*(?:const|let|var)\s+{re.escape(name)}\s*=")
+    for i in range(use_line_idx, -1, -1):
+        if pattern.match(lines[i]):
+            return i
+    return None
+
+
+def try_fix_decl_line(content: str) -> str | None:
+    # index form
+    m = DECL_INDEX_RE.match(content)
+    if m:
+        pre = m.group("pre")
+        post = m.group("post")
+        if pre.endswith("!"):
+            return None
+        return pre + "!" + post
+    m = DECL_GET_RE.match(content)
+    if m:
+        pre = m.group("pre")
+        post = m.group("post")
+        if pre.endswith("!"):
+            return None
+        return pre + "!" + post
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print(__doc__)
+        return 1
+    log = Path(sys.argv[1])
+    apply = "--apply" in sys.argv[2:]
+    only_tests = "--all" not in sys.argv[2:]
+    errs = parse_errors(log, only_tests=only_tests)
+    total_fixed = 0
+    total_files = 0
+    for path, positions in errs.items():
+        if not path.exists():
+            continue
+        lines = path.read_text().splitlines(keepends=True)
+        fixed_decls: set[int] = set()
+        file_fixed = 0
+        for lineno, name in positions:
+            idx = lineno - 1
+            if idx >= len(lines):
+                continue
+            decl_idx = find_decl(lines, idx, name)
+            if decl_idx is None or decl_idx in fixed_decls:
+                continue
+            # Strip EOL
+            original = lines[decl_idx]
+            eol = ""
+            if original.endswith("\r\n"):
+                eol, content = "\r\n", original[:-2]
+            elif original.endswith("\n"):
+                eol, content = "\n", original[:-1]
+            else:
+                content = original
+            new = try_fix_decl_line(content)
+            if new and new != content:
+                lines[decl_idx] = new + eol
+                fixed_decls.add(decl_idx)
+                file_fixed += 1
+        if file_fixed:
+            total_fixed += file_fixed
+            total_files += 1
+            if apply:
+                path.write_text("".join(lines))
+            print(f"{'FIX' if apply else 'DRY'} {path}: {file_fixed} decl(s)")
+    print(f"Total: {total_fixed} fix(es) across {total_files} file(s)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/fix-wave-a-bangs.py

@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+"""
+Mechanically replace `x!.prop` with `x?.prop` in expect() contexts in test files.
+Safe when the result is immediately chained with .toBe/.toEqual/etc, because
+`expect(undefined).toBe(expected)` still fails the assertion cleanly.
+
+Usage: fix-wave-a-bangs.py <file>...
+"""
+import re
+import sys
+
+# Pattern: something like "arr[0]!" or "foo.bar!" or "foo()!" followed by .prop
+# We only rewrite when the `!.` is followed by an identifier (method/prop access).
+# This avoids touching `x!` standalone statements.
+
+BANG_DOT = re.compile(r'!\.')
+
+def fix_file(path: str) -> int:
+    with open(path, 'r') as f:
+        content = f.read()
+    # Only rewrite lines that start with whitespace + "expect(" to be safe for tests.
+    # Actually also handle const x = foo[0]!.bar patterns. Let's be more aggressive
+    # and replace ALL `!.` occurrences, then let tsc verify.
+    new_content, n = BANG_DOT.subn('?.', content)
+    if n > 0:
+        with open(path, 'w') as f:
+            f.write(new_content)
+    return n
+
+if __name__ == '__main__':
+    total = 0
+    for p in sys.argv[1:]:
+        n = fix_file(p)
+        print(f'{p}: {n} replacements')
+        total += n
+    print(f'TOTAL: {total}')

package/scripts/fix-wave-a-templates.py

@@ -0,0 +1,108 @@
+#!/usr/bin/env python3
+"""
+Wrap template-literal interpolations in String(...) ONLY at locations flagged
+by eslint's restrict-template-expressions rule. Reads JSON ESLint output from
+stdin or generates it itself.
+
+Usage:
+  ./scripts/fix-wave-a-templates.py <path> [<path>...]
+
+The script:
+  1. Runs `npx eslint <paths> -f json` to discover restrict-template-expressions
+     errors with their line:column locations.
+  2. For each file, reads its content and at each flagged column finds the
+     enclosing ${...} expression and wraps the inner expression in String(...).
+  3. Writes the file back if any changes were made.
+
+Skips expressions that are already inside String(), are string literals, or
+contain `instanceof Error` (likely error-handling already correct).
+"""
+import json
+import subprocess
+import sys
+from collections import defaultdict
+
+
+def run_eslint(paths: list[str]) -> dict:
+    res = subprocess.run(
+        ['npx', 'eslint', *paths, '-f', 'json'],
+        capture_output=True, text=True
+    )
+    return json.loads(res.stdout)
+
+
+def collect_errors(eslint_data) -> dict:
+    by_file = defaultdict(list)
+    for f in eslint_data:
+        for m in f['messages']:
+            if m.get('severity') != 2: continue
+            if m.get('ruleId') != '@typescript-eslint/restrict-template-expressions': continue
+            by_file[f['filePath']].append((m['line'], m['column']))
+    return by_file
+
+
+def fix_file(path: str, locations: list[tuple[int, int]]) -> int:
+    with open(path, 'r') as f:
+        lines = f.readlines()
+    # Process from bottom to top so column offsets stay valid for earlier edits.
+    locations = sorted(set(locations), key=lambda lc: (-lc[0], -lc[1]))
+    fixed = 0
+    for line_no, col in locations:
+        idx = line_no - 1
+        if idx >= len(lines): continue
+        line = lines[idx]
+        # The reported column is 1-based and points at the start of the
+        # offending expression *inside* the ${...}. Walk left to find the '$'
+        # that opened it, then find the matching '}'.
+        c = col - 1  # 0-based
+        # find '${' just before c, looking back at most 200 chars
+        start = -1
+        for k in range(c - 1, max(0, c - 200) - 1, -1):
+            if line[k] == '{' and k > 0 and line[k-1] == '$':
+                start = k - 1  # index of '$'
+                break
+        if start == -1:
+            continue
+        # find matching '}' from c onward
+        depth = 1
+        j = start + 2
+        while j < len(line) and depth > 0:
+            if line[j] == '{': depth += 1
+            elif line[j] == '}':
+                depth -= 1
+                if depth == 0: break
+            j += 1
+        if depth != 0:
+            continue
+        expr = line[start+2:j]
+        stripped = expr.strip()
+        if stripped.startswith('String(') and stripped.endswith(')'):
+            continue
+        if stripped.startswith(("'", '"', '`')):
+            continue
+        if 'instanceof Error' in stripped:
+            continue
+        # Wrap
+        new_segment = '${String(' + stripped + ')}'
+        new_line = line[:start] + new_segment + line[j+1:]
+        lines[idx] = new_line
+        fixed += 1
+    if fixed > 0:
+        with open(path, 'w') as f:
+            f.writelines(lines)
+    return fixed
+
+
+if __name__ == '__main__':
+    if len(sys.argv) < 2:
+        print("Usage: fix-wave-a-templates.py <path> [<path>...]", file=sys.stderr)
+        sys.exit(2)
+    paths = sys.argv[1:]
+    data = run_eslint(paths)
+    by_file = collect_errors(data)
+    total = 0
+    for fpath, locs in by_file.items():
+        n = fix_file(fpath, locs)
+        print(f'{fpath}: {n} wrappings')
+        total += n
+    print(f'TOTAL: {total}')