devstack 0.1.0

package/vendor/skills/skills/vitest/references/features-context.md

@@ -0,0 +1,240 @@
+---
+name: test-context-fixtures
+description: Test context, custom fixtures with test.extend
+---
+
+# Test Context & Fixtures
+
+## Built-in Context
+
+Every test receives context as first argument:
+
+```ts
+test("context", ({ task, expect, skip }) => {
+  console.log(task.name); // Test name
+  expect(1).toBe(1); // Context-bound expect
+  skip(); // Skip test dynamically
+});
+```
+
+### Context Properties
+
+- `task` - Test metadata (name, file, etc.)
+- `expect` - Expect bound to this test (important for concurrent tests)
+- `skip(condition?, message?)` - Skip the test
+- `onTestFinished(fn)` - Cleanup after test
+- `onTestFailed(fn)` - Run on failure only
+
+## Custom Fixtures with test.extend
+
+Create reusable test utilities:
+
+```ts
+import { test as base } from "vitest";
+
+// Define fixture types
+interface Fixtures {
+  db: Database;
+  user: User;
+}
+
+// Create extended test
+export const test = base.extend<Fixtures>({
+  // Fixture with setup/teardown
+  db: async ({}, use) => {
+    const db = await createDatabase();
+    await use(db); // Provide to test
+    await db.close(); // Cleanup
+  },
+
+  // Fixture depending on another fixture
+  user: async ({ db }, use) => {
+    const user = await db.createUser({ name: "Test" });
+    await use(user);
+    await db.deleteUser(user.id);
+  },
+});
+```
+
+Using fixtures:
+
+```ts
+test("query user", async ({ db, user }) => {
+  const found = await db.findUser(user.id);
+  expect(found).toEqual(user);
+});
+```
+
+## Fixture Initialization
+
+Fixtures only initialize when accessed:
+
+```ts
+const test = base.extend({
+  expensive: async ({}, use) => {
+    console.log("initializing"); // Only runs if test uses it
+    await use("value");
+  },
+});
+
+test("no fixture", () => {}); // expensive not called
+test("uses fixture", ({ expensive }) => {}); // expensive called
+```
+
+## Auto Fixtures
+
+Run fixture for every test:
+
+```ts
+const test = base.extend({
+  setup: [
+    async ({}, use) => {
+      await globalSetup();
+      await use();
+      await globalTeardown();
+    },
+    { auto: true }, // Always run
+  ],
+});
+```
+
+## Scoped Fixtures
+
+### File Scope
+
+Initialize once per file:
+
+```ts
+const test = base.extend({
+  connection: [
+    async ({}, use) => {
+      const conn = await connect();
+      await use(conn);
+      await conn.close();
+    },
+    { scope: "file" },
+  ],
+});
+```
+
+### Worker Scope
+
+Initialize once per worker:
+
+```ts
+const test = base.extend({
+  sharedResource: [
+    async ({}, use) => {
+      await use(globalResource);
+    },
+    { scope: "worker" },
+  ],
+});
+```
+
+## Injected Fixtures (from Config)
+
+Override fixtures per project:
+
+```ts
+// test file
+const test = base.extend({
+  apiUrl: ["/default", { injected: true }],
+});
+
+// vitest.config.ts
+defineConfig({
+  test: {
+    projects: [
+      {
+        test: {
+          name: "prod",
+          provide: { apiUrl: "https://api.prod.com" },
+        },
+      },
+    ],
+  },
+});
+```
+
+## Scoped Values per Suite
+
+Override fixture for specific suite:
+
+```ts
+const test = base.extend({
+  environment: "development",
+});
+
+describe("production tests", () => {
+  test.scoped({ environment: "production" });
+
+  test("uses production", ({ environment }) => {
+    expect(environment).toBe("production");
+  });
+});
+
+test("uses default", ({ environment }) => {
+  expect(environment).toBe("development");
+});
+```
+
+## Extended Test Hooks
+
+Type-aware hooks with fixtures:
+
+```ts
+const test = base.extend<{ db: Database }>({
+  db: async ({}, use) => {
+    const db = await createDb();
+    await use(db);
+    await db.close();
+  },
+});
+
+// Hooks know about fixtures
+test.beforeEach(({ db }) => {
+  db.seed();
+});
+
+test.afterEach(({ db }) => {
+  db.clear();
+});
+```
+
+## Composing Fixtures
+
+Extend from another extended test:
+
+```ts
+// base-test.ts
+export const test = base.extend<{ db: Database }>({
+  db: async ({}, use) => {
+    /* ... */
+  },
+});
+
+// admin-test.ts
+import { test as dbTest } from "./base-test";
+
+export const test = dbTest.extend<{ admin: User }>({
+  admin: async ({ db }, use) => {
+    const admin = await db.createAdmin();
+    await use(admin);
+  },
+});
+```
+
+## Key Points
+
+- Use `{ }` destructuring to access fixtures
+- Fixtures are lazy - only initialize when accessed
+- Return cleanup function from fixtures
+- Use `{ auto: true }` for setup fixtures
+- Use `{ scope: 'file' }` for expensive shared resources
+- Fixtures compose - extend from extended tests
+
+<!--
+Source references:
+- https://vitest.dev/guide/test-context.html
+-->

package/vendor/skills/skills/vitest/references/features-coverage.md

@@ -0,0 +1,202 @@
+---
+name: code-coverage
+description: Code coverage with V8 or Istanbul providers
+---
+
+# Code Coverage
+
+## Setup
+
+```bash
+# Run tests with coverage
+vitest run --coverage
+```
+
+## Configuration
+
+```ts
+// vitest.config.ts
+defineConfig({
+  test: {
+    coverage: {
+      // Provider: 'v8' (default, faster) or 'istanbul' (more compatible)
+      provider: "v8",
+
+      // Enable coverage
+      enabled: true,
+
+      // Reporters
+      reporter: ["text", "json", "html"],
+
+      // Files to include
+      include: ["src/**/*.{ts,tsx}"],
+
+      // Files to exclude
+      exclude: ["node_modules/", "tests/", "**/*.d.ts", "**/*.test.ts"],
+
+      // Report uncovered files
+      all: true,
+
+      // Thresholds
+      thresholds: {
+        lines: 80,
+        functions: 80,
+        branches: 80,
+        statements: 80,
+      },
+    },
+  },
+});
+```
+
+## Providers
+
+### V8 (Default)
+
+```bash
+npm i -D @vitest/coverage-v8
+```
+
+- Faster, no pre-instrumentation
+- Uses V8's native coverage
+- Recommended for most projects
+
+### Istanbul
+
+```bash
+npm i -D @vitest/coverage-istanbul
+```
+
+- Pre-instruments code
+- Works in any JS runtime
+- More overhead but widely compatible
+
+## Reporters
+
+```ts
+coverage: {
+  reporter: [
+    'text',           // Terminal output
+    'text-summary',   // Summary only
+    'json',           // JSON file
+    'html',           // HTML report
+    'lcov',           // For CI tools
+    'cobertura',      // XML format
+  ],
+  reportsDirectory: './coverage',
+}
+```
+
+## Thresholds
+
+Fail tests if coverage is below threshold:
+
+```ts
+coverage: {
+  thresholds: {
+    // Global thresholds
+    lines: 80,
+    functions: 75,
+    branches: 70,
+    statements: 80,
+
+    // Per-file thresholds
+    perFile: true,
+
+    // Auto-update thresholds (for gradual improvement)
+    autoUpdate: true,
+  },
+}
+```
+
+## Ignoring Code
+
+### V8
+
+```ts
+/* v8 ignore next -- @preserve */
+function ignored() {
+  return "not covered";
+}
+
+/* v8 ignore start -- @preserve */
+// All code here ignored
+/* v8 ignore stop -- @preserve */
+```
+
+### Istanbul
+
+```ts
+/* istanbul ignore next -- @preserve */
+function ignored() {}
+
+/* istanbul ignore if -- @preserve */
+if (condition) {
+  // ignored
+}
+```
+
+Note: `@preserve` keeps comments through esbuild.
+
+## Package.json Scripts
+
+```json
+{
+  "scripts": {
+    "test": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:coverage:watch": "vitest --coverage"
+  }
+}
+```
+
+## Vitest UI Coverage
+
+Enable HTML coverage in Vitest UI:
+
+```ts
+coverage: {
+  enabled: true,
+  reporter: ['text', 'html'],
+}
+```
+
+Run with `vitest --ui` to view coverage visually.
+
+## CI Integration
+
+```yaml
+# GitHub Actions
+- name: Run tests with coverage
+  run: npm run test:coverage
+
+- name: Upload coverage to Codecov
+  uses: codecov/codecov-action@v3
+  with:
+    files: ./coverage/lcov.info
+```
+
+## Coverage with Sharding
+
+Merge coverage from sharded runs:
+
+```bash
+vitest run --shard=1/3 --coverage --reporter=blob
+vitest run --shard=2/3 --coverage --reporter=blob
+vitest run --shard=3/3 --coverage --reporter=blob
+
+vitest --merge-reports --coverage --reporter=json
+```
+
+## Key Points
+
+- V8 is faster, Istanbul is more compatible
+- Use `--coverage` flag or `coverage.enabled: true`
+- Include `all: true` to see uncovered files
+- Set thresholds to enforce minimum coverage
+- Use `@preserve` comment to keep ignore hints
+
+<!--
+Source references:
+- https://vitest.dev/guide/coverage.html
+-->

package/vendor/skills/skills/vitest/references/features-filtering.md

@@ -0,0 +1,208 @@
+---
+name: test-filtering
+description: Filter tests by name, file patterns, and tags
+---
+
+# Test Filtering
+
+## CLI Filtering
+
+### By File Path
+
+```bash
+# Run files containing "user"
+vitest user
+
+# Multiple patterns
+vitest user auth
+
+# Specific file
+vitest src/user.test.ts
+
+# By line number
+vitest src/user.test.ts:25
+```
+
+### By Test Name
+
+```bash
+# Tests matching pattern
+vitest -t "login"
+vitest --testNamePattern "should.*work"
+
+# Regex patterns
+vitest -t "/user|auth/"
+```
+
+## Changed Files
+
+```bash
+# Uncommitted changes
+vitest --changed
+
+# Since specific commit
+vitest --changed HEAD~1
+vitest --changed abc123
+
+# Since branch
+vitest --changed origin/main
+```
+
+## Related Files
+
+Run tests that import specific files:
+
+```bash
+vitest related src/utils.ts src/api.ts --run
+```
+
+Useful with lint-staged:
+
+```js
+// .lintstagedrc.js
+export default {
+  "*.{ts,tsx}": "vitest related --run",
+};
+```
+
+## Focus Tests (.only)
+
+```ts
+test.only("only this runs", () => {});
+
+describe.only("only this suite", () => {
+  test("runs", () => {});
+});
+```
+
+In CI, `.only` throws error unless configured:
+
+```ts
+defineConfig({
+  test: {
+    allowOnly: true, // Allow .only in CI
+  },
+});
+```
+
+## Skip Tests
+
+```ts
+test.skip("skipped", () => {});
+
+// Conditional
+test.skipIf(process.env.CI)("not in CI", () => {});
+test.runIf(!process.env.CI)("local only", () => {});
+
+// Dynamic skip
+test("dynamic", ({ skip }) => {
+  skip(someCondition, "reason");
+});
+```
+
+## Tags
+
+Filter by custom tags:
+
+```ts
+test("database test", { tags: ["db"] }, () => {});
+test("slow test", { tags: ["slow", "integration"] }, () => {});
+```
+
+Run tagged tests:
+
+```bash
+vitest --tags db
+vitest --tags "db,slow"      # OR
+vitest --tags db --tags slow # OR
+```
+
+Configure allowed tags:
+
+```ts
+defineConfig({
+  test: {
+    tags: ["db", "slow", "integration"],
+    strictTags: true, // Fail on unknown tags
+  },
+});
+```
+
+## Include/Exclude Patterns
+
+```ts
+defineConfig({
+  test: {
+    // Test file patterns
+    include: ["**/*.{test,spec}.{ts,tsx}"],
+
+    // Exclude patterns
+    exclude: ["**/node_modules/**", "**/e2e/**", "**/*.skip.test.ts"],
+
+    // Include source for in-source testing
+    includeSource: ["src/**/*.ts"],
+  },
+});
+```
+
+## Watch Mode Filtering
+
+In watch mode, press:
+
+- `p` - Filter by filename pattern
+- `t` - Filter by test name pattern
+- `a` - Run all tests
+- `f` - Run only failed tests
+
+## Projects Filtering
+
+Run specific project:
+
+```bash
+vitest --project unit
+vitest --project integration --project e2e
+```
+
+## Environment-based Filtering
+
+```ts
+const isDev = process.env.NODE_ENV === "development";
+const isCI = process.env.CI;
+
+describe.skipIf(isCI)("local only tests", () => {});
+describe.runIf(isDev)("dev tests", () => {});
+```
+
+## Combining Filters
+
+```bash
+# File pattern + test name + changed
+vitest user -t "login" --changed
+
+# Related files + run mode
+vitest related src/auth.ts --run
+```
+
+## List Tests Without Running
+
+```bash
+vitest list                 # Show all test names
+vitest list -t "user"       # Filter by name
+vitest list --filesOnly     # Show only file paths
+vitest list --json          # JSON output
+```
+
+## Key Points
+
+- Use `-t` for test name pattern filtering
+- `--changed` runs only tests affected by changes
+- `--related` runs tests importing specific files
+- Tags provide semantic test grouping
+- Use `.only` for debugging, but configure CI to reject it
+- Watch mode has interactive filtering
+
+<!--
+Source references:
+- https://vitest.dev/guide/filtering.html
+- https://vitest.dev/guide/cli.html
+-->