solid2-agent-kit 0.4.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lightsound
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# solid2-agent-kit
+
+Teach AI coding agents to write correct **Solid 2.0** — not React, and not Solid 1.x.
+
+LLMs are heavily biased toward React when writing TSX, and their Solid knowledge is mostly
+Solid 1.x, which is incompatible with Solid 2.0. This kit installs layered guardrails into a
+project so agents stop destructuring props, reaching for `useEffect`/`createResource`, or
+writing `className` — and start writing idiomatic Solid 2.0.
+
+Supported agents: **Cursor** and **Claude Code**.
+
+## What it installs
+
+| Layer | Cursor | Claude Code | Role |
+|---|---|---|---|
+| Always-applied hard rules | `.cursor/rules/solid-2.mdc` (glob-attached to `*.tsx`/`*.jsx`) | managed block in `CLAUDE.md` | 23 hard rules + banned Solid 1.x API table + eslint-plugin-solid lint-heritage table. Injected without the agent having to decide to read anything |
+| Agent skill | `.cursor/skills/solid-2/` | `.claude/skills/solid-2/` | Execution-model primer, decision tables, canonical patterns, a “still runs / write the other form” table, review checklist, official-doc URL index |
+| Shared agent context | managed block in `AGENTS.md` | same (Claude Code users can reference it from `CLAUDE.md`) | Core principles and pointers, always in context |
+| Mechanical gate | `solid2-kit check` | same | Whole-file regex guard over `src/**/*.{ts,tsx}`: fails on props destructuring (including multi-line signatures), `{ ...props }` rest copies, `{list().map(...)}` in JSX, React imports/hooks/JSX props/`React.lazy`, Solid 1.x imports/APIs/components/JSX namespaces, `vite-plugin-solid`, old-router `<Route>`/`<HashRouter>`, `MetaProvider`, `Context.Provider`, camelCase style keys, `key` props, `value()!` hand-narrowing, hand-rolled loading signals, and `=== undefined` readiness branches |
+
+Managed blocks are delimited with `<!-- solid2-agent-kit:*:start/end -->` markers; everything
+outside them is yours. Kit-owned files (`solid-2.mdc`, the skill directories) are overwritten
+on sync.
+
+## Usage
+
+GitHub is the canonical distribution channel (the kit is intentionally not published to
+npm; consumers pin a commit through their lockfile):
+
+```sh
+# install guidance for both Cursor and Claude Code (default)
+npx github:lightsound/solid2-agent-kit init
+
+# one tool only
+npx github:lightsound/solid2-agent-kit init --cursor
+npx github:lightsound/solid2-agent-kit init --claude
+
+# run the mechanical pattern gate (default source dir: src)
+npx github:lightsound/solid2-agent-kit check
+npx github:lightsound/solid2-agent-kit check --dir app
+
+# pull in kit updates later (idempotent; replaces managed blocks and kit-owned files)
+npx github:lightsound/solid2-agent-kit sync
+```
+
+So that agents (and CI) can run the gate by name, add the kit as a devDependency and wire a
+script in the consuming project's `package.json` (with a local install, `npx`/`bunx`
+resolve the project-local bin, so the bare name is safe there):
+
+```json
+{
+  "devDependencies": { "solid2-agent-kit": "github:lightsound/solid2-agent-kit" },
+  "scripts": { "lint:solid": "solid2-agent-kit check" }
+}
+```
+
+Update later with `bun update solid2-agent-kit` (or the npm/pnpm equivalent) followed by
+`npx solid2-agent-kit sync`. Outside a project that has the kit installed, always use the
+`npx github:...` form — the bare package name is not claimed on the npm registry.
+
+## Why not eslint-plugin-solid?
+
+`eslint-plugin-solid` was built for Solid 1.x. Its analyzer predates the Solid 2 model and
+flags correct Solid 2 idioms — two-phase `createEffect(compute, apply)`, writable derivations
+(`createSignal(fn)`), draft store setters — steering agents back toward 1.x patterns. This
+kit carries over the plugin's still-valid intents (`no-destructure`,
+`components-return-once`, `reactivity`, `prefer-for`, `prefer-show`, `no-innerhtml`,
+`style-prop`, ...) as documented rules plus a regex gate, without the 1.x false positives.
+
+## Docs-drift CI
+
+Solid 2.0 is young and its docs move. A weekly GitHub Actions job
+(`.github/workflows/docs-drift.yml`) fetches the official docs corpus
+([llms-full.txt](https://v2-rebuild--solid-docs-v2.netlify.app/llms-full.txt)) and verifies
+that every API the kit recommends still exists: `create*` primitives are auto-extracted from
+the kit content, the rest come from an explicit list in `scripts/check-docs-drift.mjs`.
+Matching requires code-like contexts (backticked, import/JSX position, or a call), so
+common-word APIs such as `merge` or `action` cannot pass on prose alone. If Solid renames or
+removes an API, the job fails and the kit content gets fixed before it teaches agents stale
+names. The same workflow runs `tests/check.test.mjs` so the mechanical gate's new patterns
+keep matching.
+
+Note: the canonical docs site https://v2.solidjs.com/ sits behind bot protection, so the kit
+(and the guidance it installs) points agents at the official markdown mirror
+`https://v2-rebuild--solid-docs-v2.netlify.app` (`llms.txt` index; every page served as
+markdown with an `.md` suffix).
+
+## Layout
+
+```
+bin/solid2-kit.mjs                 CLI: init / sync / check
+files/shared/rules-body.md         hard rules (rendered into .mdc and CLAUDE.md)
+files/shared/agents-section.md     AGENTS.md managed-block content
+files/skills/solid-2/              SKILL.md + references/official-docs.md
+scripts/check-docs-drift.mjs       weekly docs cross-check
+tests/                             mechanical-gate fixtures (`npm test`)
+```
+
+## License
+
+MIT

package/bin/solid2-kit.mjs

@@ -0,0 +1,368 @@
+#!/usr/bin/env node
+// solid2-agent-kit CLI — installs and maintains Solid 2.0 guidance for AI
+// coding agents (Cursor and Claude Code), and runs a mechanical pattern gate.
+//
+//   solid2-kit init  [--cursor] [--claude] [--target <dir>]
+//   solid2-kit sync  [--cursor] [--claude] [--target <dir>]   (alias of init)
+//   solid2-kit check [--dir <srcdir>] [--target <dir>]
+//
+// `init`/`sync` are idempotent: kit-owned files are overwritten and managed
+// blocks in AGENTS.md / CLAUDE.md are replaced in place.
+
+import {
+  cpSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const KIT_ROOT = fileURLToPath(new URL('..', import.meta.url));
+const VERSION = JSON.parse(readFileSync(join(KIT_ROOT, 'package.json'), 'utf8')).version;
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function flagValue(name, fallback) {
+  const index = args.indexOf(name);
+  return index === -1 || index + 1 >= args.length ? fallback : args[index + 1];
+}
+
+// --- init / sync ------------------------------------------------------------
+
+function countOccurrences(haystack, needle) {
+  return haystack.split(needle).length - 1;
+}
+
+function upsertManagedBlock(filePath, blockId, body, createPreamble) {
+  const start = `<!-- solid2-agent-kit:${blockId}:start -->`;
+  const end = `<!-- solid2-agent-kit:${blockId}:end -->`;
+  const note = `<!-- Managed by solid2-agent-kit v${VERSION}. Do not edit inside this block; run \`solid2-kit sync\` to update. -->`;
+  const block = `${start}\n${note}\n\n${body.trim()}\n\n${end}`;
+
+  let content = existsSync(filePath) ? readFileSync(filePath, 'utf8') : '';
+  const starts = countOccurrences(content, start);
+  const ends = countOccurrences(content, end);
+
+  if (starts === 1 && ends === 1) {
+    // Function replacement: a plain string would have `$&`/`$'`-style
+    // sequences in the body interpreted as replacement patterns.
+    content = content.replace(new RegExp(`${start}[\\s\\S]*?${end}`), () => block);
+  } else if (starts === 0 && ends === 0) {
+    const base = content.trim() ? content.trimEnd() : (createPreamble ?? '').trimEnd();
+    content = `${base}${base ? '\n\n' : ''}${block}\n`;
+  } else {
+    // Malformed markers (a stray delete or a duplicated block). Touching the
+    // file could swallow user content between mismatched markers, so leave
+    // it alone and ask for a manual fix.
+    console.warn(
+      `solid2-kit — warning: malformed managed-block markers in ${filePath} (${starts} start / ${ends} end for "${blockId}"). File left untouched; repair the markers and re-run sync.`,
+    );
+    return null;
+  }
+  writeFileSync(filePath, content);
+  return filePath;
+}
+
+function writeKitOwnedFile(filePath, body) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, body);
+  return filePath;
+}
+
+function copySkill(targetSkillDir) {
+  // The skill directory is kit-owned: remove it first so files deleted in
+  // newer kit versions do not linger after a sync.
+  rmSync(targetSkillDir, { recursive: true, force: true });
+  mkdirSync(targetSkillDir, { recursive: true });
+  cpSync(join(KIT_ROOT, 'files/skills/solid-2'), targetSkillDir, { recursive: true });
+  return targetSkillDir;
+}
+
+function init() {
+  const target = resolve(flagValue('--target', '.'));
+  const onlyCursor = args.includes('--cursor') && !args.includes('--claude');
+  const onlyClaude = args.includes('--claude') && !args.includes('--cursor');
+  const wantCursor = !onlyClaude;
+  const wantClaude = !onlyCursor;
+
+  const rulesBody = readFileSync(join(KIT_ROOT, 'files/shared/rules-body.md'), 'utf8');
+  const agentsSection = readFileSync(join(KIT_ROOT, 'files/shared/agents-section.md'), 'utf8');
+  const written = [];
+
+  if (wantCursor) {
+    const mdc = [
+      '---',
+      'description: Solid 2.0 JSX and reactivity rules — prevents React and Solid 1.x patterns in TSX files',
+      'globs: **/*.tsx,**/*.jsx',
+      'alwaysApply: false',
+      '---',
+      '',
+      `<!-- Generated by solid2-agent-kit v${VERSION}. Do not edit; run \`solid2-kit sync\` to update. -->`,
+      '',
+      rulesBody.trim(),
+      '',
+    ].join('\n');
+    written.push(writeKitOwnedFile(join(target, '.cursor/rules/solid-2.mdc'), mdc));
+    written.push(copySkill(join(target, '.cursor/skills/solid-2')));
+  }
+
+  if (wantClaude) {
+    written.push(copySkill(join(target, '.claude/skills/solid-2')));
+    // Claude Code has no glob-attached rules mechanism; CLAUDE.md is always
+    // loaded, so the full rules body lives there in a managed block.
+    written.push(
+      upsertManagedBlock(
+        join(target, 'CLAUDE.md'),
+        'solid-rules',
+        rulesBody,
+        '# CLAUDE.md\n\nProject guidance for Claude Code.',
+      ),
+    );
+  }
+
+  written.push(
+    upsertManagedBlock(
+      join(target, 'AGENTS.md'),
+      'agents-section',
+      agentsSection,
+      '# AGENTS.md\n\nProject-specific context for coding agents.',
+    ),
+  );
+
+  console.log(`solid2-agent-kit v${VERSION} — installed for ${[wantCursor && 'Cursor', wantClaude && 'Claude Code'].filter(Boolean).join(' + ')}:`);
+  for (const path of written.filter(Boolean)) console.log(`  ${relative(target, path) || '.'}`);
+}
+
+// --- check ------------------------------------------------------------------
+
+const CHECKS = [
+  {
+    id: 'props-destructure-param',
+    pattern: /function\s+[A-Z]\w*\s*\(\s*\{|(?:const|let)\s+[A-Z]\w*\s*=\s*(?:async\s*)?\(\s*\{/g,
+    message:
+      'Destructured component props read getters once at setup and break reactivity. Take a single `props` parameter and read `props.x` inside JSX, memos, or effect computes.',
+  },
+  {
+    id: 'props-destructure-body',
+    pattern: /\}\s*=\s*props\b/g,
+    message:
+      'Destructuring `props` freezes the values. Keep `props.x` property accesses; name derivations instead: `const x = () => props.x`.',
+  },
+  {
+    id: 'react-import',
+    pattern: /from\s+['"]react(?:-dom)?(?:['"]|\/)/g,
+    message: 'React import in a Solid 2.0 codebase.',
+  },
+  {
+    id: 'solid1-import-path',
+    pattern: /from\s+['"]solid-js\/(?:store|web|h|html|universal|jsx-runtime|jsx-dev-runtime)['"]/g,
+    message:
+      'Solid 1.x import path. Stores/merge/omit come from "solid-js"; render/hydrate/Portal/Dynamic come from "@solidjs/web".',
+  },
+  {
+    id: 'react-jsx-prop',
+    pattern: /\b(?:className|htmlFor)=/g,
+    message: 'React JSX prop. Use `class` / `for`.',
+  },
+  {
+    id: 'solid1-classlist',
+    pattern: /\bclassList=/g,
+    message: 'Solid 1.x `classList` was removed. Use the object/array form of `class`.',
+  },
+  {
+    id: 'react-hook',
+    pattern:
+      /(?<![.\w])use(?:State|Effect|Memo|Ref|Callback|Reducer|LayoutEffect|Transition|SyncExternalStore|ImperativeHandle|Id|DeferredValue|InsertionEffect)\s*\(/g,
+    message: 'React hook. See the primitive mapping in the solid-2 rules.',
+  },
+  {
+    id: 'solid1-api',
+    pattern:
+      /(?<![.\w])(?:createResource|onMount|createMutable|modifyMutable|mergeProps|splitProps|produce|unwrap|createComputed|createSelector|createDeferred|startTransition|batch|onError|catchError|createDynamic|renderToStringAsync|clearDelegatedEvents)\s*\(/g,
+    message:
+      'Removed Solid 1.x API. Replacements: async createMemo, onSettled, createStore drafts, merge/omit/snapshot, automatic batching, Errored, dynamic(), renderToStream.',
+  },
+  {
+    id: 'solid1-component',
+    pattern: /<(?:Suspense|ErrorBoundary|SuspenseList|Index)[\s/>]/g,
+    message: 'Solid 1.x component. Use <Loading>, <Errored>, <Reveal>, <For keyed={false}>.',
+  },
+  {
+    id: 'context-provider',
+    pattern: /<\w+\.Provider\b/g,
+    message: 'Solid 2 contexts are their own provider: `<MyContext value={...}>`.',
+  },
+  {
+    // Matches a camelCase key in property position (right after `{{` or after a
+    // comma). Ternary branches inside values (`a ? fooBar : baz`) never sit in
+    // property position, so they are not flagged.
+    id: 'style-camelcase',
+    pattern: /style=\{\{\s*(?:[^{}]*,\s*)?[a-z]+[A-Z]\w*\s*:/g,
+    message:
+      'camelCase style key. Solid style objects use CSS property names: `"background-color"` (and no automatic px).',
+  },
+  {
+    id: 'react-key-prop',
+    pattern: /\skey=\{/g,
+    message: 'React `key` prop has no meaning in Solid. Row identity belongs on <For keyed={...}>.',
+  },
+  {
+    // `{todos().map((t) => <Row />)}` renders then recreates every row.
+    // `children().toArray().map` does not match (method is toArray, not a bare accessor).
+    id: 'jsx-accessor-map',
+    pattern: /\{\s*[A-Za-z_$][\w$]*\(\)\.map\s*\(/g,
+    message:
+      '`.map()` over a reactive accessor in JSX recreates every row. Use <For each={...}> (and a key function for server/refetched rows).',
+  },
+  {
+    id: 'for-each-map',
+    pattern: /\beach=\{\s*[^}]*\.map\s*\(/g,
+    message:
+      '<For each={list().map(...)}> still rebuilds the array every run. Derive the list first, then pass that list to each={...}.',
+  },
+  {
+    id: 'props-rest-copy',
+    pattern: /=\s*\{\s*\.\.\.\s*props\b/g,
+    message:
+      '`{ ...props }` is a snapshot. Forward leftover props with omit(props, "key") (a reactive proxy), then JSX-spread that.',
+  },
+  {
+    // A non-null assertion on a zero-arg call is almost always a reactive read
+    // narrowed by hand (`error()!.message`). Common zero-arg stdlib methods
+    // that legitimately pair with `!` are excluded.
+    id: 'accessor-non-null',
+    pattern: /(?<!\.pop|\.shift|\.next)\(\)!/g,
+    message:
+      'Non-null assertion on a zero-arg call. Narrow reactive reads with <Show when={...}> and its function child (narrowed accessor); use an explicit guard variable for non-reactive calls.',
+  },
+  {
+    id: 'manual-loading-signal',
+    pattern: /\[\s*(?:is)?[Ll]oading\s*,|\bset(?:Is)?Loading\s*\(/g,
+    message:
+      'Hand-rolled loading state. First-load UI belongs to a <Loading> fallback, refetch indicators to isPending(), in-flight values to latest(). Model the async work as a computation (promise / async iterable), not signals.',
+  },
+  {
+    id: 'react-lazy',
+    pattern: /\bReact\.lazy\s*\(/g,
+    message: 'React.lazy. Use `lazy(() => import("./X"))` from "solid-js" and read it under <Loading>.',
+  },
+  {
+    id: 'lazy-then-wrapper',
+    pattern: /\blazy\(\s*\(\)[\s\S]{0,160}?\.then\s*\(/g,
+    message:
+      'lazy().then((m) => ({ default: m.X })) breaks hydration. Pass { export: "X" } as the second argument: lazy(() => import("./mod"), { export: "X" }).',
+  },
+  {
+    id: 'dangerously-set-inner-html',
+    pattern: /\bdangerouslySetInnerHTML=/g,
+    message: 'React innerHTML prop. Use innerHTML={sanitizedHtml()} from Solid, never combined with JSX children.',
+  },
+  {
+    id: 'setter-as-handler',
+    pattern: /\bon[A-Z][A-Za-z]*=\{\s*set[A-Z]\w*\s*\}/g,
+    message:
+      'Passing a setter as an event handler writes the event object. Wrap it: onClick={() => setCount((c) => c + 1)}.',
+  },
+  {
+    id: 'vite-plugin-solid',
+    pattern: /from\s+['"]vite-plugin-solid['"]/g,
+    message: 'Solid 1.x Vite plugin. Import `solid` from "@solidjs/vite-plugin".',
+  },
+  {
+    id: 'solid1-jsx-namespace',
+    pattern: /\b(?:use|on|oncapture|attr|bool):[A-Za-z][\w-]*=/g,
+    message:
+      'Solid 1.x JSX namespace. Use ref callbacks (and directive factories), camelCase event props, and standard attributes.',
+  },
+  {
+    id: 'solid1-router',
+    pattern: /<(?:HashRouter|MemoryRouter|Route|Navigate)\b/g,
+    message:
+      'Solid Router 0.x/1.x JSX. Define routes with createRouter({ routes }) and plain <a href={Router.paths...}>.',
+  },
+  {
+    id: 'meta-provider',
+    pattern: /<MetaProvider\b/g,
+    message: 'Solid Meta 1.x has no provider. Render <Title>/<Meta>/<Link> from "@solidjs/meta" anywhere.',
+  },
+  {
+    // A zero-arg call compared against undefined/null is a manual async
+    // readiness branch (`data() === undefined ? ... : ...`).
+    id: 'async-undefined-check',
+    pattern: /\(\)\s*[!=]==?\s*(?:undefined|null)\b|\b(?:undefined|null)\s*[!=]==?\s*\w+\(\)/g,
+    message:
+      'Readiness branch on a zero-arg call. Read async values under <Loading> (first load) / isPending() (refetch) and let errors reach <Errored>. For non-reactive utils, assign to a variable and test that.',
+  },
+];
+
+// .ts / .tsx sources, excluding .d.ts declaration files.
+const SOURCE_FILE = /(?<!\.d)\.tsx?$/;
+
+function* walk(dir) {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) yield* walk(path);
+    else if (SOURCE_FILE.test(entry.name)) yield path;
+  }
+}
+
+function check() {
+  const target = resolve(flagValue('--target', '.'));
+  const srcDir = resolve(target, flagValue('--dir', 'src'));
+  if (!existsSync(srcDir)) {
+    console.error(`solid2-kit check — source directory not found: ${srcDir} (use --dir)`);
+    process.exit(2);
+  }
+
+  let findings = 0;
+  let files = 0;
+  for (const file of walk(srcDir)) {
+    files += 1;
+    const content = readFileSync(file, 'utf8');
+    const lines = content.split('\n');
+    for (const rule of CHECKS) {
+      for (const match of content.matchAll(rule.pattern)) {
+        findings += 1;
+        const lineNumber = content.slice(0, match.index).split('\n').length;
+        console.error(
+          `${relative(target, file)}:${lineNumber} [${rule.id}] ${rule.message}\n  > ${lines[lineNumber - 1].trim()}`,
+        );
+      }
+    }
+  }
+
+  if (findings > 0) {
+    console.error(`\nsolid2-kit check — ${findings} finding(s) in ${files} file(s).`);
+    process.exit(1);
+  }
+  console.log(`solid2-kit check — OK (${files} files scanned).`);
+}
+
+// --- entry ------------------------------------------------------------------
+
+switch (command) {
+  case 'init':
+  case 'sync':
+    init();
+    break;
+  case 'check':
+    check();
+    break;
+  default:
+    console.log(
+      [
+        `solid2-agent-kit v${VERSION}`,
+        '',
+        'Usage:',
+        '  solid2-kit init  [--cursor] [--claude] [--target <dir>]  install/update guidance (default: both tools)',
+        '  solid2-kit sync  [--cursor] [--claude] [--target <dir>]  alias of init (idempotent)',
+        '  solid2-kit check [--dir <srcdir>] [--target <dir>]       mechanical React/Solid 1.x pattern gate (default dir: src)',
+      ].join('\n'),
+    );
+    process.exit(command ? 2 : 0);
+}

package/files/shared/agents-section.md

@@ -0,0 +1,6 @@
+## Solid 2.0 (not React, not Solid 1.x)
+
+- All TSX in this project is Solid 2.0. Components run **once**; reactivity flows through signals/stores to JSX. React patterns (props destructuring, `className`, per-keystroke `onChange`, state-synced-by-effect, `.map()` lists) and Solid 1.x APIs (`createResource`, `onMount`, `solid-js/store`, `Suspense`, path setters) are bugs here.
+- Before writing TSX, read the `solid-2` skill (`.cursor/skills/solid-2/SKILL.md` for Cursor, `.claude/skills/solid-2/SKILL.md` for Claude Code): patterns, decision tables, official doc URLs. Hard rules auto-attach from `.cursor/rules/solid-2.mdc` in Cursor and live in a managed block in `CLAUDE.md` for Claude Code.
+- After editing TSX, run the `solid2-kit check` mechanical gate — it fails on React/Solid 1.x tokens and props destructuring. Use the project's `lint:solid` script if one exists; otherwise `npx solid2-agent-kit check` (with the kit as a devDependency) or `npx github:lightsound/solid2-agent-kit check`. Do not install `eslint-plugin-solid` (built for Solid 1.x; misreads Solid 2 idioms).
+- Solid 2.0 shipped recently and breaks with 1.x — never trust pre-2.0 Solid docs, tutorials, or training knowledge. Verify APIs against https://v2-rebuild--solid-docs-v2.netlify.app/llms.txt (markdown mirror of https://v2.solidjs.com/, which blocks non-browser fetchers). If the project has `@solidjs/router`, server functions, or `@solidjs/meta`, use those official pages (see the skill's official-docs index) — not React Router, Next.js, SolidStart 1.x, or Solid Router 0.x/1.x JSX `<Route>`/`<A>`.