feat: add first rule and GitHub Actions CI

- Implement no-single-variable-message rule
- Add 20 test cases for the rule
- Set up GitHub Actions workflow (test, lint, build jobs)
- Format codebase with new prettier settings

Author: swernerx

.cursor/rules/project-infrastructure.mdc

@@ -177,3 +177,30 @@ Note: `jiti` is required by ESLint 9 for loading TypeScript config files (`eslin
 - `npm run test` - Run tests
 - `npm run test:watch` - Run tests in watch mode
 - `npm run typecheck` - Type-check without emitting
+
+## CI/CD
+
+### GitHub Actions
+
+The project uses GitHub Actions for continuous integration with three parallel jobs:
+
+```yaml
+# .github/workflows/ci.yml
+jobs:
+  test:        # typecheck + unit tests
+  lint:        # eslint + prettier
+  build:       # compile + upload artifact
+```
+
+### CI Checks
+
+| Job | Steps |
+|-----|-------|
+| **test** | `npm run typecheck`, `npm test` |
+| **lint** | `npm run lint`, `npm run format:check` |
+| **build** | `npm run build`, upload `dist/` artifact |
+
+### Triggers
+
+- **Push** to `main` branch
+- **Pull requests** targeting `main`

.github/workflows/ci.yml

@@ -0,0 +1,68 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - run: npm ci
+
+      - run: npm run typecheck
+        name: Type Check
+
+      - run: npm test
+        name: Unit Tests
+
+  lint:
+    name: Lint & Format
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - run: npm ci
+
+      - run: npm run lint
+        name: ESLint
+
+      - run: npm run format:check
+        name: Prettier
+
+  build:
+    name: Build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 24
+          cache: npm
+
+      - run: npm ci
+
+      - run: npm run build
+        name: Build
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 7

eslint.config.ts

@@ -1,5 +1,5 @@
-import eslint from "@eslint/js";
-import tseslint from "typescript-eslint";
+import eslint from "@eslint/js"
+import tseslint from "typescript-eslint"
 
 export default [
   eslint.configs.recommended,
@@ -9,12 +9,12 @@ export default [
     languageOptions: {
       parserOptions: {
         projectService: {
-          allowDefaultProject: ["*.config.ts"],
+          allowDefaultProject: ["*.config.ts"]
         },
-        tsconfigRootDir: import.meta.dirname,
+        tsconfigRootDir: import.meta.dirname
       },
-      ecmaVersion: 2024,
-    },
+      ecmaVersion: 2024
+    }
   },
   {
     rules: {
@@ -23,24 +23,24 @@ export default [
         "error",
         {
           argsIgnorePattern: "^_",
-          varsIgnorePattern: "^_",
-        },
+          varsIgnorePattern: "^_"
+        }
       ],
       "@typescript-eslint/consistent-type-imports": [
         "error",
         {
           prefer: "type-imports",
-          fixStyle: "inline-type-imports",
-        },
+          fixStyle: "inline-type-imports"
+        }
       ],
       "@typescript-eslint/consistent-type-definitions": ["error", "interface"],
       "@typescript-eslint/no-unnecessary-condition": "error",
       "@typescript-eslint/prefer-nullish-coalescing": "error",
       "@typescript-eslint/prefer-optional-chain": "error",
-      "@typescript-eslint/strict-boolean-expressions": "error",
-    },
+      "@typescript-eslint/strict-boolean-expressions": "error"
+    }
   },
   {
-    ignores: ["dist/**", "node_modules/**", "coverage/**"],
-  },
-];
+    ignores: ["dist/**", "node_modules/**", "coverage/**"]
+  }
+]

src/index.ts

@@ -4,32 +4,29 @@
  * @packageDocumentation
  */
 
-// TODO: Import rules when implemented
-// import { noComplexExpressionsInMessage } from "./rules/no-complex-expressions-in-message.js";
+import { noSingleVariableMessage } from "./rules/no-single-variable-message.js"
 
 const plugin = {
   meta: {
     name: "eslint-plugin-lingui-typescript",
-    version: "1.0.0",
+    version: "1.0.0"
   },
   rules: {
-    // Rules will be added here as they are implemented
+    "no-single-variable-message": noSingleVariableMessage
   },
-  configs: {},
+  configs: {} as Record<string, unknown>
 }
 
-// Add self-reference for flat config
-const flatRecommended = {
-  plugins: {
-    "lingui-ts": plugin,
-  },
-  rules: {
-    // Recommended rules will be added here
-  },
-};
-
+// Add flat config with self-reference
 plugin.configs = {
-  "flat/recommended": flatRecommended,
-};
+  "flat/recommended": {
+    plugins: {
+      "lingui-ts": plugin
+    },
+    rules: {
+      "lingui-ts/no-single-variable-message": "error"
+    }
+  }
+}
 
-export default plugin;
+export default plugin

src/rules/no-single-variable-message.test.ts

@@ -0,0 +1,85 @@
+import { RuleTester } from "@typescript-eslint/rule-tester"
+import { afterAll, describe, it } from "vitest"
+
+import { noSingleVariableMessage } from "./no-single-variable-message.js"
+
+RuleTester.afterAll = afterAll
+RuleTester.describe = describe
+RuleTester.it = it
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaVersion: 2022,
+      sourceType: "module",
+      ecmaFeatures: {
+        jsx: true
+      }
+    }
+  }
+})
+
+ruleTester.run("no-single-variable-message", noSingleVariableMessage, {
+  valid: [
+    // Template with text and variable
+    "t`Hello ${name}`",
+    "t`Status: ${status}`",
+    "t`${count} items`",
+
+    // Template with only text
+    "t`Hello World`",
+
+    // Template with multiple variables
+    "t`${first} and ${second}`",
+
+    // JSX with text and variable
+    "<Trans>Hello {name}</Trans>",
+    "<Trans>Status: {status}</Trans>",
+    "<Trans>{count} items</Trans>",
+
+    // JSX with only text
+    "<Trans>Hello World</Trans>",
+
+    // JSX with multiple children
+    "<Trans>{first} and {second}</Trans>",
+
+    // Non-Lingui tagged templates (should be ignored)
+    "css`${variable}`",
+    "html`${content}`",
+
+    // Non-Trans JSX elements (should be ignored)
+    "<Plural>{count}</Plural>",
+    "<div>{content}</div>"
+  ],
+  invalid: [
+    // Template with only variable
+    {
+      code: "t`${status}`",
+      errors: [{ messageId: "singleVariable" }]
+    },
+    {
+      code: "t`${user.name}`",
+      errors: [{ messageId: "singleVariable" }]
+    },
+    // Template with variable and whitespace only
+    {
+      code: "t` ${status} `",
+      errors: [{ messageId: "singleVariable" }]
+    },
+
+    // JSX with only variable
+    {
+      code: "<Trans>{status}</Trans>",
+      errors: [{ messageId: "singleVariable" }]
+    },
+    {
+      code: "<Trans>{user.name}</Trans>",
+      errors: [{ messageId: "singleVariable" }]
+    },
+    // JSX with variable and whitespace only
+    {
+      code: "<Trans>  {status}  </Trans>",
+      errors: [{ messageId: "singleVariable" }]
+    }
+  ]
+})

src/rules/no-single-variable-message.ts

@@ -0,0 +1,86 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils"
+
+import { createRule } from "../utils/create-rule.js"
+
+type MessageId = "singleVariable"
+
+/**
+ * Checks if a tagged template has only a single expression and no text content.
+ */
+function isSingleVariableTemplate(node: TSESTree.TemplateLiteral): boolean {
+  // Must have exactly one expression
+  if (node.expressions.length !== 1) {
+    return false
+  }
+
+  // All quasis must be empty (no text content)
+  return node.quasis.every((quasi) => quasi.value.raw.trim() === "")
+}
+
+/**
+ * Checks if a JSX element has only a single expression child and no text content.
+ */
+function isSingleVariableJSX(children: TSESTree.JSXChild[]): boolean {
+  const meaningfulChildren = children.filter((child) => {
+    if (child.type === AST_NODE_TYPES.JSXText) {
+      return child.value.trim() !== ""
+    }
+    return true
+  })
+
+  // Must have exactly one meaningful child that is an expression
+  if (meaningfulChildren.length !== 1) {
+    return false
+  }
+
+  const onlyChild = meaningfulChildren[0]
+  return onlyChild?.type === AST_NODE_TYPES.JSXExpressionContainer
+}
+
+export const noSingleVariableMessage = createRule<[], MessageId>({
+  name: "no-single-variable-message",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Lingui messages that consist only of a single variable"
+    },
+    messages: {
+      singleVariable:
+        "Translation message should not consist only of a single variable. Add surrounding text for context."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      // Check t`${variable}` pattern
+      TaggedTemplateExpression(node): void {
+        if (node.tag.type !== AST_NODE_TYPES.Identifier || node.tag.name !== "t") {
+          return
+        }
+
+        if (isSingleVariableTemplate(node.quasi)) {
+          context.report({
+            node,
+            messageId: "singleVariable"
+          })
+        }
+      },
+
+      // Check <Trans>{variable}</Trans> pattern
+      JSXElement(node): void {
+        const openingElement = node.openingElement
+        if (openingElement.name.type !== AST_NODE_TYPES.JSXIdentifier || openingElement.name.name !== "Trans") {
+          return
+        }
+
+        if (isSingleVariableJSX(node.children)) {
+          context.report({
+            node,
+            messageId: "singleVariable"
+          })
+        }
+      }
+    }
+  }
+})

src/utils/create-rule.ts

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils"
+
+/**
+ * Creates a typed ESLint rule with documentation URL generation.
+ */
+export const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/user/eslint-plugin-lingui-typescript/blob/main/docs/rules/${name}.md`
+)