@alexgorbatchev/pi-skill-library 0.1.0 → 1.0.0

package/README.md

@@ -27,7 +27,7 @@ The extension looks for `skills-library` in these places:
 
 - `<cwd>/.pi/skills-library`
 - `<cwd>` and ancestor `.agents/skills-library` directories, stopping at the git root (or filesystem root when no git root exists)
-- `~/.pi/agent/cskills-library`
+- `~/.pi/agent/skills-library`
 - `~/.agents/skills-library`
 - package-local `skills-library` directories derived from discovered package skill roots
 - extra paths configured via Pi settings under `@alexgorbatchev/pi-skills-library.paths`

package/package.json

@@ -1,9 +1,18 @@
 {
   "name": "@alexgorbatchev/pi-skill-library",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Pi extension that exposes skills-library roots through /library:<skill-name> commands.",
   "type": "module",
+  "author": "Alex Gorbatchev",
   "license": "MIT",
+  "homepage": "https://github.com/alexgorbatchev/pi-skill-library#readme",
+  "bugs": {
+    "url": "https://github.com/alexgorbatchev/pi-skill-library/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alexgorbatchev/pi-skill-library.git"
+  },
   "packageManager": "bun@1.3.10",
   "keywords": [
     "pi-package",
@@ -14,7 +23,6 @@
   ],
   "files": [
     "src",
-    "skills-library",
     "README.md",
     "LICENSE"
   ],

package/skills-library/opencode-config/SKILL.md

@@ -1,51 +0,0 @@
----
-name: opencode-config
-description: >-
-  Set up and configure opencode.jsonc for OpenCode projects. Use when creating a
-  new opencode.jsonc configuration file, adding instruction file paths, or
-  configuring OpenCode settings for a repository.
-targets:
-  - '*'
----
-
-# OpenCode Config
-
-## Overview
-
-Create and configure `opencode.jsonc` in the repository root to customize OpenCode behavior per project.
-
-## Setup
-
-1. Create `opencode.jsonc` in the repository root
-2. Add the schema reference for validation and autocompletion
-3. Add instruction file paths to the `instructions` array
-
-### Minimal Configuration
-
-```jsonc
-{
-  "$schema": "https://opencode.ai/config.json",
-}
-```
-
-### .github Instructions
-
-If there is `.github/instructions` folder update config to include `instructions` field, like so:
-
-```jsonc
-"instructions": [
-  ".github/instructions/*.instructions.md",
-],
-```
-
-### .github Skills
-
-If there is `.github/skills` folder update config to include `skills` field, like so:
-
-```jsonc
-"skills": {
-  "paths": [
-    ".github/skills",
-  ]
-}
-```

package/skills-library/react-development/SKILL.md

@@ -1,135 +0,0 @@
----
-name: react-development
-description: >-
-  Build and modify React components, hooks, context providers, and JSX render
-  trees. Use when implementing or refactoring React UI code, component APIs,
-  render branches, shared primitives, hook-driven state, DOM structure, or test
-  ID conventions. Covers the required `data-testid` naming contract and the ban
-  on using `createElement` from React in regular application code.
----
-
-# React Development
-
-Use existing React patterns before introducing new ones. Preserve accessibility, composability, and readable JSX.
-
-## Workflow
-
-1. Inspect the existing component, shared primitives, hooks, and nearby tests before editing.
-2. Reuse an existing component or hook when one already expresses the pattern.
-3. Keep rendering in JSX. Extract helpers or hooks instead of switching to `createElement`.
-4. Apply the test ID contract exactly when a tagged element is needed.
-5. Run the narrowest relevant validation first, then broader lint and test commands.
-
-## Non-negotiable rules
-
-### 1. Use the test ID contract exactly
-
-Apply these rules exactly unless the repository documents a different contract:
-
-- Use the plain component name on the root rendered element of a component.
-- Use `ComponentName--thing` for tagged child elements inside that component.
-- Use kebab-case for `thing`.
-- Use semantic targets, not positional names.
-- Use the local helper component name when a helper component renders its own tagged root.
-- Do not invent `--root` or other suffixes on the root unless the repository explicitly requires them.
-
-Valid:
-
-```tsx
-export function PlanChat() {
-  return (
-    <section data-testid='PlanChat'>
-      <div data-testid='PlanChat--thread-viewport' />
-    </section>
-  );
-}
-```
-
-```tsx
-function ReasoningPart() {
-  return <ToolCallCard testId='ReasoningPart' />;
-}
-```
-
-Invalid:
-
-```tsx
-<section data-testid='PlanChat--root' />
-```
-
-```tsx
-<div data-testid='thread-viewport' />
-```
-
-```tsx
-function ReasoningPart() {
-  return <ToolCallCard testId='PlanChat--reasoning-card' />;
-}
-```
-
-Prefer accessible queries in tests. Add `data-testid` only when the element is not reliably targetable through role, label, text, or stable semantic structure.
-
-### 2. Keep regular React code in JSX
-
-Do not use `createElement` or `React.createElement` in ordinary application code.
-
-Use JSX for:
-
-- normal component bodies
-- conditional rendering
-- lists and mapping
-- wrapper composition
-- provider trees
-- tool or widget registries that can be expressed directly in JSX
-
-Allow `createElement` only when a specific domain constraint requires it and that requirement is documented explicitly at the use site or in adjacent documentation. Typical exceptions are rare and include cases such as:
-
-- schema-driven renderers
-- AST or MDX renderers
-- plugin systems that receive component types dynamically
-- framework integration points that require raw element factory calls
-
-Do not introduce `createElement` just to:
-
-- avoid JSX syntax
-- build dynamic props more mechanically
-- mimic framework internals
-- shorten code that JSX already expresses clearly
-
-When an exception is truly required, isolate it, document why JSX is insufficient, and test it.
-
-## Component design rules
-
-- Prefer function components and hooks over class components unless the codebase already requires a class boundary.
-- Keep props narrow and typed.
-- Extract pure transforms into helpers instead of embedding large calculations in render.
-- Extract repeated stateful behavior into hooks only when more than one caller needs it or the component becomes hard to read.
-- Reuse shared primitives for buttons, inputs, dialogs, cards, and layout shells before adding one-off markup.
-- Keep render branches explicit. Make loading, empty, error, and success states easy to read.
-- Preserve accessible names and roles when refactoring structure.
-
-## Review checklist
-
-Before finishing a React change, verify all of the following:
-
-- root test IDs use the plain component name
-- child test IDs use `ComponentName--thing`
-- helper components with their own tagged roots use their own names
-- no new `createElement` usage was introduced without an explicit documented exception
-- shared primitives were reused where appropriate
-- accessible queries remain possible for user-facing controls
-- relevant lint, type, and test commands were run
-
-## References
-
-- Read `references/oxlint.md` when adding or changing React-specific lint rules, custom Oxlint plugins, test ID enforcement, or `createElement` bans.
-- Read `references/reactPolicyPlugin.js` for a concrete local Oxlint plugin example.
-- Read `references/reactPolicyPlugin.test.ts` for a concrete Bun test harness for the plugin.
-- Read `references/oxlintrc.json` for a concrete scoped config example.
-
-## Companion skills
-
-Use related skills when the task goes deeper in those areas:
-
-- `react-testing` for Storybook stories, play functions, and interaction coverage
-- `typescript-code-quality` when TypeScript structure and type-safety rules matter heavily

package/skills-library/react-development/references/oxlint.md

@@ -1,144 +0,0 @@
-# Oxlint for React Repositories
-
-Read this file when the task involves adding, tightening, or debugging React lint rules, custom Oxlint plugins, or CI enforcement.
-
-## Enforcement strategy
-
-Use Oxlint for fast editor and CI feedback.
-
-Split enforcement into two groups:
-
-1. **Built-in rules** for generic quality and correctness
-2. **Local JS plugins** for repository-specific React contracts
-
-Prefer built-in rules when they express the requirement directly. Use a local plugin only when the rule is specific to the repository and cannot be expressed well with built-ins.
-
-## High-value React policies to enforce
-
-### 1. Ban `createElement` in regular application code
-
-Use a linter rule or repo-local plugin to reject:
-
-- `import { createElement } from 'react'`
-- `React.createElement(...)`
-
-Scope exceptions explicitly to:
-
-- tests
-- Storybook setup/mocks
-- documented framework boundaries
-- documented schema/plugin renderers
-
-If the repository allows a rare production exception, require a short comment at the use site explaining why JSX is insufficient.
-
-## 2. Enforce the test ID naming contract
-
-If the repository uses test IDs, prefer a custom plugin for exact policy enforcement.
-
-Example policy:
-
-- component root: `ComponentName`
-- child elements: `ComponentName--thing`
-- helper components with their own tagged roots use their own names
-
-Use a local plugin when the policy depends on component names, render branches, or JSX structure.
-
-## 3. Scope rules by file type
-
-Do not run React-specific rules on the whole repository.
-
-Use `overrides` to target the file types the policy actually governs.
-
-For repositories where every `.tsx` file is in scope for React UI policy, prefer this broad pattern so new files are not missed:
-
-```json
-{
-  "$schema": "./node_modules/oxlint/configuration_schema.json",
-  "jsPlugins": ["./scripts/oxlint/reactPolicyPlugin.js"],
-  "overrides": [
-    {
-      "files": ["**/*.tsx"],
-      "rules": {
-        "repo-react/no-regular-create-element": "error",
-        "repo-react/require-component-root-testid": "error"
-      }
-    }
-  ]
-}
-```
-
-Use narrower globs only when the repository deliberately excludes some `.tsx` categories from the policy.
-
-## Local plugin guidance
-
-Implement a local plugin when the repository needs React-specific contracts that built-ins do not cover.
-
-Concrete reference files in this skill:
-
-- `references/reactPolicyPlugin.js` — example plugin with `no-regular-create-element` and `require-component-root-testid`
-- `references/reactPolicyPlugin.test.ts` — Bun tests that run Oxlint against temp fixtures
-- `references/oxlintrc.json` — scoped config example wiring the plugin into Oxlint
-
-Typical cases:
-
-- test ID naming derived from component names
-- banning `createElement` except in scoped files
-- repository-specific wrapper conventions
-- enforcing root render wrappers for provider-only components
-
-Keep plugins small and exact. One repository contract per rule is usually the right granularity.
-
-## Rule design guidance
-
-### `no-regular-create-element`
-
-The rule should:
-
-- flag `createElement` imports from `react`
-- flag `React.createElement(...)`
-- ignore test files and documented exception paths through config scoping, not heuristics
-- report a direct message: use JSX instead of `createElement` in regular React code
-
-### `require-component-root-testid`
-
-The rule should:
-
-- detect exported PascalCase components
-- inspect all non-null render branches
-- require exact root test IDs
-- validate child test IDs against the component name
-- ignore nested functions and nested classes while traversing one component body
-
-Use a repository-level test in addition to the plugin when the rule performs AST-heavy structural checks.
-
-## Validation workflow
-
-When adding or changing React lint rules:
-
-1. Run the targeted Oxlint command on the affected files first.
-2. Run the plugin tests if a local plugin changed.
-3. Run the type checker.
-4. Run adjacent React tests.
-5. Run the broader repo lint command last.
-
-Example:
-
-```bash
-bun x oxlint -c oxlintrc.json --deny-warnings src/components
-bun test scripts/oxlint/__tests__/reactPolicyPlugin.test.ts
-bun x tsgo -p . --noEmit
-bun test src/components --max-concurrency=1
-```
-
-## Failure policy
-
-Do not weaken a React lint rule just to get a change through.
-
-If the rule blocks valid code, fix one of these instead:
-
-- the component structure
-- the rule implementation
-- the file scope in config
-- the documented policy
-
-Do not add blanket ignores when a scoped override or a better rule is the correct solution.

package/skills-library/react-development/references/oxlintrc.json

@@ -1,16 +0,0 @@
-{
-  "$schema": "./node_modules/oxlint/configuration_schema.json",
-  "jsPlugins": ["./scripts/oxlint/reactPolicyPlugin.js"],
-  "rules": {
-    "eqeqeq": "error"
-  },
-  "overrides": [
-    {
-      "files": ["**/*.tsx"],
-      "rules": {
-        "repo-react/no-regular-create-element": "error",
-        "repo-react/require-component-root-testid": "error"
-      }
-    }
-  ]
-}

package/skills-library/react-development/references/reactPolicyPlugin.js

@@ -1,549 +0,0 @@
-const noRegularCreateElementRule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Ban React createElement in regular application code; use JSX instead',
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      ImportDeclaration(node) {
-        if (node.source?.value !== 'react') {
-          return;
-        }
-
-        node.specifiers.forEach((specifier) => {
-          if (specifier.type !== 'ImportSpecifier') {
-            return;
-          }
-
-          if (specifier.imported.type !== 'Identifier' || specifier.imported.name !== 'createElement') {
-            return;
-          }
-
-          context.report({
-            node: specifier,
-            message: 'Use JSX instead of importing createElement from react in regular application code.',
-          });
-        });
-      },
-      CallExpression(node) {
-        if (
-          node.callee.type !== 'MemberExpression'
-          || node.callee.computed
-          || node.callee.object.type !== 'Identifier'
-          || node.callee.object.name !== 'React'
-          || node.callee.property.type !== 'Identifier'
-          || node.callee.property.name !== 'createElement'
-        ) {
-          return;
-        }
-
-        context.report({
-          node,
-          message: 'Use JSX instead of React.createElement in regular application code.',
-        });
-      },
-    };
-  },
-};
-
-const requireComponentRootTestIdRule = {
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Require exported React component roots to use ComponentName and child test ids to use ComponentName--thing',
-    },
-    schema: [],
-  },
-  create(context) {
-    return {
-      Program(program) {
-        const componentDefinitions = readComponentDefinitions(program);
-
-        componentDefinitions.forEach((componentDefinition) => {
-          const rootBranches = readRootBranchesForComponent(componentDefinition);
-          const rootNodes = new Set();
-
-          rootBranches.forEach((rootBranch) => {
-            rootBranch.testIdEntries.forEach((testIdEntry) => {
-              rootNodes.add(testIdEntry.node);
-            });
-
-            if (componentDefinition.isExported) {
-              reportInvalidExportedRoot(context, componentDefinition.name, rootBranch);
-            } else {
-              reportInvalidLocalRoot(context, componentDefinition.name, rootBranch);
-            }
-          });
-
-          const componentTestIdEntries = readComponentTestIdEntries(componentDefinition);
-          componentTestIdEntries.forEach((testIdEntry) => {
-            if (rootNodes.has(testIdEntry.node)) {
-              return;
-            }
-
-            testIdEntry.candidates.forEach((candidate) => {
-              if (isValidChildTestId(candidate, componentDefinition.name)) {
-                return;
-              }
-
-              context.report({
-                node: testIdEntry.node,
-                message:
-                  `Component "${componentDefinition.name}" must use child test ids in the format "${componentDefinition.name}--thing". Received "${candidate}".`,
-              });
-            });
-          });
-        });
-      },
-    };
-  },
-};
-
-const plugin = {
-  meta: {
-    name: 'repo-react',
-  },
-  rules: {
-    'no-regular-create-element': noRegularCreateElementRule,
-    'require-component-root-testid': requireComponentRootTestIdRule,
-  },
-};
-
-export default plugin;
-
-function readComponentDefinitions(program) {
-  return program.body.flatMap((statement) => readStatementComponentDefinitions(statement, false));
-}
-
-function readStatementComponentDefinitions(statement, isExported) {
-  if (statement.type === 'ExportNamedDeclaration') {
-    return statement.declaration ? readDeclarationComponentDefinitions(statement.declaration, true) : [];
-  }
-
-  if (statement.type === 'ExportDefaultDeclaration') {
-    return readDefaultComponentDefinitions(statement.declaration, true);
-  }
-
-  return readDeclarationComponentDefinitions(statement, isExported);
-}
-
-function readDeclarationComponentDefinitions(declaration, isExported) {
-  if (declaration.type === 'FunctionDeclaration') {
-    if (!declaration.id || !isPascalCase(declaration.id.name)) {
-      return [];
-    }
-
-    return [{ name: declaration.id.name, kind: 'function', node: declaration, isExported }];
-  }
-
-  if (declaration.type === 'ClassDeclaration') {
-    if (!declaration.id || !isPascalCase(declaration.id.name)) {
-      return [];
-    }
-
-    return [{ name: declaration.id.name, kind: 'class', node: declaration, isExported }];
-  }
-
-  if (declaration.type !== 'VariableDeclaration') {
-    return [];
-  }
-
-  return declaration.declarations.flatMap((declarator) => {
-    if (declarator.id.type !== 'Identifier' || !isPascalCase(declarator.id.name)) {
-      return [];
-    }
-
-    const componentNode = readWrappedFunctionLike(declarator.init);
-    if (!componentNode) {
-      return [];
-    }
-
-    return [{ name: declarator.id.name, kind: 'function', node: componentNode, isExported }];
-  });
-}
-
-function readDefaultComponentDefinitions(declaration, isExported) {
-  if (declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') {
-    if (!declaration.id || !isPascalCase(declaration.id.name)) {
-      return [];
-    }
-
-    return declaration.type === 'FunctionDeclaration'
-      ? [{ name: declaration.id.name, kind: 'function', node: declaration, isExported }]
-      : [{ name: declaration.id.name, kind: 'class', node: declaration, isExported }];
-  }
-
-  const componentNode = readWrappedFunctionLike(declaration);
-  if (!componentNode || !componentNode.id || !isPascalCase(componentNode.id.name)) {
-    return [];
-  }
-
-  return [{ name: componentNode.id.name, kind: 'function', node: componentNode, isExported }];
-}
-
-function readWrappedFunctionLike(initializer) {
-  if (!initializer) {
-    return null;
-  }
-
-  if (initializer.type === 'ArrowFunctionExpression' || initializer.type === 'FunctionExpression') {
-    return initializer;
-  }
-
-  if (initializer.type !== 'CallExpression') {
-    return null;
-  }
-
-  const wrappedInitializer = initializer.arguments[0];
-  if (!wrappedInitializer || wrappedInitializer.type === 'SpreadElement') {
-    return null;
-  }
-
-  return readWrappedFunctionLike(wrappedInitializer);
-}
-
-function readRootBranchesForComponent(componentDefinition) {
-  const returnExpressions = componentDefinition.kind === 'class'
-    ? readClassRenderReturnExpressions(componentDefinition.node)
-    : readFunctionReturnExpressions(componentDefinition.node);
-
-  return returnExpressions.flatMap((returnExpression) => readRootBranches(returnExpression));
-}
-
-function readClassRenderReturnExpressions(classDeclaration) {
-  const renderMethod = classDeclaration.body.body.find((member) => {
-    return member.type === 'MethodDefinition'
-      && !member.computed
-      && member.key.type === 'Identifier'
-      && member.key.name === 'render';
-  });
-
-  if (!renderMethod || !renderMethod.value.body) {
-    return [];
-  }
-
-  return readReturnExpressionsFromBlock(renderMethod.value.body, renderMethod.value);
-}
-
-function readFunctionReturnExpressions(functionNode) {
-  if (!functionNode.body) {
-    return [];
-  }
-
-  if (functionNode.body.type !== 'BlockStatement') {
-    return [functionNode.body];
-  }
-
-  return readReturnExpressionsFromBlock(functionNode.body, functionNode);
-}
-
-function readReturnExpressionsFromBlock(blockNode, rootFunctionNode) {
-  const returnExpressions = [];
-
-  visitNode(blockNode);
-  return returnExpressions;
-
-  function visitNode(node) {
-    if (!isAstNode(node)) {
-      return;
-    }
-
-    if (node !== rootFunctionNode && isNestedFunctionNode(node)) {
-      return;
-    }
-
-    if (node !== rootFunctionNode && isNestedClassNode(node)) {
-      return;
-    }
-
-    if (node.type === 'ReturnStatement') {
-      if (node.argument) {
-        returnExpressions.push(node.argument);
-      }
-      return;
-    }
-
-    readChildNodes(node).forEach(visitNode);
-  }
-}
-
-function readRootBranches(expression) {
-  const unwrappedExpression = unwrapExpression(expression);
-
-  if (unwrappedExpression.type === 'ConditionalExpression') {
-    return [
-      ...readRootBranches(unwrappedExpression.consequent),
-      ...readRootBranches(unwrappedExpression.alternate),
-    ];
-  }
-
-  if (unwrappedExpression.type === 'LogicalExpression' && unwrappedExpression.operator === '&&') {
-    return readRootBranches(unwrappedExpression.right);
-  }
-
-  if (isNullLiteral(unwrappedExpression)) {
-    return [{ kind: 'null', node: unwrappedExpression, testIdEntries: [] }];
-  }
-
-  if (unwrappedExpression.type === 'JSXFragment') {
-    return [{ kind: 'fragment', node: unwrappedExpression, testIdEntries: [] }];
-  }
-
-  if (unwrappedExpression.type === 'JSXElement') {
-    return [{
-      kind: 'jsx',
-      node: unwrappedExpression,
-      testIdEntries: readJsxAttributeTestIdEntries(unwrappedExpression.openingElement.attributes),
-    }];
-  }
-
-  if (unwrappedExpression.type === 'JSXSelfClosingElement') {
-    return [{
-      kind: 'jsx',
-      node: unwrappedExpression,
-      testIdEntries: readJsxAttributeTestIdEntries(unwrappedExpression.attributes),
-    }];
-  }
-
-  return [{ kind: 'other', node: unwrappedExpression, testIdEntries: [], summary: summarizeNode(unwrappedExpression) }];
-}
-
-function readComponentTestIdEntries(componentDefinition) {
-  const componentBody = componentDefinition.kind === 'class'
-    ? readClassRenderBody(componentDefinition.node)
-    : componentDefinition.node.body;
-
-  if (!componentBody) {
-    return [];
-  }
-
-  return readTestIdEntriesFromNode(componentBody, componentBody);
-}
-
-function readClassRenderBody(classDeclaration) {
-  const renderMethod = classDeclaration.body.body.find((member) => {
-    return member.type === 'MethodDefinition'
-      && !member.computed
-      && member.key.type === 'Identifier'
-      && member.key.name === 'render';
-  });
-
-  return renderMethod?.value.body ?? null;
-}
-
-function readTestIdEntriesFromNode(rootNode, boundaryNode) {
-  const testIdEntries = [];
-
-  visitNode(rootNode);
-  return testIdEntries;
-
-  function visitNode(node) {
-    if (!isAstNode(node)) {
-      return;
-    }
-
-    if (node !== boundaryNode && isNestedFunctionNode(node)) {
-      return;
-    }
-
-    if (node !== boundaryNode && isNestedClassNode(node)) {
-      return;
-    }
-
-    if (node.type === 'JSXElement') {
-      testIdEntries.push(...readJsxAttributeTestIdEntries(node.openingElement.attributes));
-      node.children.forEach(visitNode);
-      return;
-    }
-
-    if (node.type === 'JSXSelfClosingElement') {
-      testIdEntries.push(...readJsxAttributeTestIdEntries(node.attributes));
-      return;
-    }
-
-    readChildNodes(node).forEach(visitNode);
-  }
-}
-
-function readJsxAttributeTestIdEntries(attributesNode) {
-  return attributesNode.filter((attribute) => {
-    return attribute.type === 'JSXAttribute' && isTestIdAttributeName(readJsxAttributeName(attribute.name));
-  }).map((attribute) => ({
-    node: attribute,
-    candidates: readTestIdCandidatesFromJsxAttribute(attribute),
-  }));
-}
-
-function readTestIdCandidatesFromJsxAttribute(attribute) {
-  const initializer = attribute.value;
-  if (!initializer) {
-    return [];
-  }
-
-  if (initializer.type === 'Literal' && typeof initializer.value === 'string') {
-    return [initializer.value];
-  }
-
-  if (
-    initializer.type !== 'JSXExpressionContainer' || !initializer.expression
-    || initializer.expression.type === 'JSXEmptyExpression'
-  ) {
-    return [];
-  }
-
-  return readExpressionStringCandidates(initializer.expression);
-}
-
-function readExpressionStringCandidates(expression) {
-  const unwrappedExpression = unwrapExpression(expression);
-
-  if (unwrappedExpression.type === 'Literal') {
-    return typeof unwrappedExpression.value === 'string' ? [unwrappedExpression.value] : [];
-  }
-
-  if (unwrappedExpression.type === 'TemplateLiteral') {
-    if (unwrappedExpression.expressions.length !== 0 || unwrappedExpression.quasis.length !== 1) {
-      return [];
-    }
-
-    const cookedValue = unwrappedExpression.quasis[0]?.value.cooked;
-    return typeof cookedValue === 'string' ? [cookedValue] : [];
-  }
-
-  if (unwrappedExpression.type === 'ConditionalExpression') {
-    return [
-      ...readExpressionStringCandidates(unwrappedExpression.consequent),
-      ...readExpressionStringCandidates(unwrappedExpression.alternate),
-    ];
-  }
-
-  return [];
-}
-
-function reportInvalidExportedRoot(context, componentName, rootBranch) {
-  if (rootBranch.kind === 'null') {
-    return;
-  }
-
-  if (rootBranch.kind === 'fragment') {
-    context.report({
-      node: rootBranch.node,
-      message: `Exported component "${componentName}" returns a fragment root; wrap it in a DOM element with data-testid="${componentName}".`,
-    });
-    return;
-  }
-
-  if (rootBranch.kind === 'other') {
-    context.report({
-      node: rootBranch.node,
-      message: `Exported component "${componentName}" returns ${rootBranch.summary}; render a root data-testid="${componentName}" instead.`,
-    });
-    return;
-  }
-
-  const hasExactRootTestId = rootBranch.testIdEntries.some((testIdEntry) => {
-    return testIdEntry.candidates.some((candidate) => candidate === componentName);
-  });
-
-  if (hasExactRootTestId) {
-    return;
-  }
-
-  context.report({
-    node: rootBranch.testIdEntries[0]?.node ?? rootBranch.node,
-    message: `Exported component "${componentName}" must render a root data-testid or testId exactly equal to "${componentName}".`,
-  });
-}
-
-function reportInvalidLocalRoot(context, componentName, rootBranch) {
-  if (rootBranch.kind === 'null' || rootBranch.testIdEntries.length === 0) {
-    return;
-  }
-
-  rootBranch.testIdEntries.forEach((testIdEntry) => {
-    testIdEntry.candidates.forEach((candidate) => {
-      if (candidate === componentName) {
-        return;
-      }
-
-      context.report({
-        node: testIdEntry.node,
-        message: `Component "${componentName}" must use the plain root test id "${componentName}" on its root element. Received "${candidate}".`,
-      });
-    });
-  });
-}
-
-function isValidChildTestId(value, componentName) {
-  return new RegExp(`^${componentName}--[a-z0-9]+(?:-[a-z0-9]+)*$`, 'u').test(value);
-}
-
-function unwrapExpression(expression) {
-  let currentExpression = expression;
-
-  while (currentExpression.type === 'ParenthesizedExpression') {
-    currentExpression = currentExpression.expression;
-  }
-
-  return currentExpression;
-}
-
-function isTestIdAttributeName(attributeName) {
-  return attributeName === 'data-testid' || attributeName === 'testId';
-}
-
-function readJsxAttributeName(attributeName) {
-  if (attributeName.type === 'JSXIdentifier') {
-    return attributeName.name;
-  }
-
-  if (attributeName.type === 'JSXNamespacedName') {
-    return `${attributeName.namespace.name}:${attributeName.name.name}`;
-  }
-
-  return '';
-}
-
-function summarizeNode(node) {
-  const rawName = node.type.replace(/Expression$/u, ' expression');
-  return rawName.toLowerCase();
-}
-
-function readChildNodes(node) {
-  return Object.entries(node).flatMap(([key, value]) => {
-    if (key === 'parent' || key === 'loc' || key === 'range') {
-      return [];
-    }
-
-    if (Array.isArray(value)) {
-      return value.filter(isAstNode);
-    }
-
-    return isAstNode(value) ? [value] : [];
-  });
-}
-
-function isNestedFunctionNode(node) {
-  return node.type === 'FunctionDeclaration'
-    || node.type === 'FunctionExpression'
-    || node.type === 'ArrowFunctionExpression';
-}
-
-function isNestedClassNode(node) {
-  return node.type === 'ClassDeclaration' || node.type === 'ClassExpression';
-}
-
-function isAstNode(value) {
-  return value !== null && typeof value === 'object' && typeof value.type === 'string';
-}
-
-function isNullLiteral(node) {
-  return node.type === 'Literal' && node.value === null;
-}
-
-function isPascalCase(value) {
-  return /^[A-Z][A-Za-z0-9]*$/u.test(value);
-}

package/skills-library/react-development/references/reactPolicyPlugin.test.ts

@@ -1,152 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-
-const PLUGIN_FILE_PATH = path.resolve(import.meta.dir, 'reactPolicyPlugin.js');
-
-describe('reactPolicyPlugin', () => {
-  test('accepts valid root and child test ids', () => {
-    const result = runOxlint(`
-      export function Valid() {
-        return (
-          <section data-testid='Valid'>
-            <div data-testid='Valid--body'>Ready</div>
-          </section>
-        );
-      }
-    `);
-
-    expect(result.exitCode).toBe(0);
-    expect(result.messages).toEqual([]);
-  });
-
-  test('reports imported createElement usage', () => {
-    const result = runOxlint(`
-      import { createElement } from 'react';
-
-      export function Broken() {
-        return createElement('div', { 'data-testid': 'Broken' });
-      }
-    `, {
-      rules: {
-        'repo-react/no-regular-create-element': 'error',
-      },
-    });
-
-    expect(result.exitCode).toBe(1);
-    expect(result.messages).toEqual([
-      {
-        code: 'repo-react(no-regular-create-element)',
-        message: 'Use JSX instead of importing createElement from react in regular application code.',
-      },
-    ]);
-  });
-
-  test('reports React.createElement usage', () => {
-    const result = runOxlint(`
-      export function Broken() {
-        return React.createElement('div', { 'data-testid': 'Broken' });
-      }
-    `, {
-      rules: {
-        'repo-react/no-regular-create-element': 'error',
-      },
-    });
-
-    expect(result.exitCode).toBe(1);
-    expect(result.messages).toEqual([
-      {
-        code: 'repo-react(no-regular-create-element)',
-        message: 'Use JSX instead of React.createElement in regular application code.',
-      },
-    ]);
-  });
-
-  test('reports root and child test id violations', () => {
-    const result = runOxlint(`
-      export function Broken() {
-        return (
-          <div data-testid='Broken--root'>
-            <button data-testid='Wrong--action'>Action</button>
-          </div>
-        );
-      }
-    `);
-
-    expect(result.exitCode).toBe(1);
-    expect(result.messages).toEqual([
-      {
-        code: 'repo-react(require-component-root-testid)',
-        message: 'Exported component "Broken" must render a root data-testid or testId exactly equal to "Broken".',
-      },
-      {
-        code: 'repo-react(require-component-root-testid)',
-        message: 'Component "Broken" must use child test ids in the format "Broken--thing". Received "Wrong--action".',
-      },
-    ]);
-  });
-});
-
-interface IOxlintResult {
-  exitCode: number;
-  messages: Array<{
-    code: string;
-    message: string;
-  }>;
-}
-
-function runOxlint(
-  fileContents: string,
-  options: {
-    rules?: Record<string, 'error'>;
-    fileName?: string;
-  } = {},
-): IOxlintResult {
-  const tempDir = mkdtempSync(path.join(tmpdir(), 'react-policy-plugin-'));
-
-  try {
-    const fixtureFilePath = path.join(tempDir, options.fileName ?? 'fixture.tsx');
-    const configFilePath = path.join(tempDir, '.oxlintrc.json');
-
-    writeFileSync(fixtureFilePath, fileContents.trimStart());
-    writeFileSync(
-      configFilePath,
-      JSON.stringify({
-        jsPlugins: [PLUGIN_FILE_PATH],
-        rules: options.rules ?? {
-          'repo-react/require-component-root-testid': 'error',
-        },
-      }),
-    );
-
-    const spawnResult = Bun.spawnSync({
-      cmd: [process.execPath, 'x', 'oxlint', '-c', configFilePath, '-f', 'json', fixtureFilePath],
-      stdout: 'pipe',
-      stderr: 'pipe',
-    });
-
-    const stdout = new TextDecoder().decode(spawnResult.stdout);
-    const stderr = new TextDecoder().decode(spawnResult.stderr);
-
-    assert.equal(stderr, '');
-
-    const payload = JSON.parse(stdout) as {
-      diagnostics?: Array<{
-        code?: string;
-        message?: string;
-      }>;
-    };
-
-    return {
-      exitCode: spawnResult.exitCode,
-      messages: (payload.diagnostics ?? []).map((diagnostic) => ({
-        code: diagnostic.code ?? '',
-        message: diagnostic.message ?? '',
-      })),
-    };
-  } finally {
-    rmSync(tempDir, { recursive: true, force: true });
-  }
-}