# What Is the Pre-Send Check in I-Have-ADHD? Hook-Based Validation Explained

> Understand the pre-send check in I-Have-ADHD. Learn how this automated ESLint validation pipeline ensures code quality before agent requests are processed, preventing execution on failures.

- Repository: [Ayoub Ghriss/i-have-adhd](https://github.com/ayghri/i-have-adhd)
- Tags: deep-dive
- Published: 2026-09-09

---

**The pre-send check in I-Have-ADHD is an automated ESLint validation pipeline that executes via the hook system before any agent request is processed, halting execution immediately if code quality checks fail.**

The **pre-send check** serves as a critical quality gate in the I-Have-ADHD repository, ensuring that only lint-free, syntactically correct code reaches the ADHD-friendly agent. Implemented through a JSON hook configuration and Node.js scripts, this validation layer prevents malformed inputs from triggering downstream failures.

## How the Pre-Send Check Works

### Hook Configuration in [`hooks/hooks.json`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/hooks.json)

The validation pipeline originates in [`hooks/hooks.json`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/hooks.json), where the `pre` array specifies commands that must succeed before the skill executes. According to the source code, the configuration declares a mandatory linting step:

```json
{
  "hooks": {
    "i-have-adhd": {
      "description": "Runs i-have-adhd skill",
      "pre": [
        "npm run lint"
      ],
      "post": [
        "npm test"
      ]
    }
  }
}

```

When the agent receives a request, the system processes the `pre` array sequentially. If any command returns a non-zero exit code—indicating ESLint errors—the request aborts before reaching the skill logic.

### ESLint Integration via [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/package.json)

The actual validation logic resides in the `lint` script defined in [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/package.json). This script invokes **ESLint** across the entire codebase, targeting TypeScript and JavaScript files:

```json
{
  "name": "i-have-adhd",
  "version": "1.0.0",
  "scripts": {
    "lint": "eslint . --ext .ts,.js",
    "test": "npm run lint && jest"
  }
}

```

The `eslint . --ext .ts,.js` command recursively scans all source files, enforcing style rules and catching syntax errors. Because the test script also invokes linting, the pre-send check effectively gatekeeps both execution and testing phases.

### Verification Helper in [`scripts/check_context_compat.ts`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/check_context_compat.ts)

The repository includes a compatibility checker at [`scripts/check_context_compat.ts`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/check_context_compat.ts) that validates hook configurations programmatically. The script parses [`hooks.json`](https://github.com/ayghri/i-have-adhd/blob/main/hooks.json) and inspects each entry for the presence of pre-hooks:

```typescript
import { readFileSync } from "fs";
import { resolve } from "path";

const cwd = resolve(process.argv[2] ?? ".");
const file = readFileSync(resolve(cwd, "hooks", "hooks.json"));
const json = JSON.parse(file.toString());

for (const [name, hook] of Object.entries(json.hooks)) {
  if (hook?.pre?.length) {
    // TODO: verify the pre hook...
  }
}

```

While currently contains a placeholder TODO comment, this utility ensures that hooks declaring `pre` arrays are flagged for verification during development workflows.

## Extending Validation with the OpenCode Plugin

The I-Have-ADHD project provides a runtime extension point for custom pre-send logic via the OpenCode plugin architecture. Located at `.opencode/plugins/i-have-adhd.mjs`, the current implementation offers an async `pre` hook placeholder:

```javascript
export default {
  name: "i-have-adhd",
  description: "ADHD‑friendly agent behavior",
  hooks: {
    pre: async (context) => {
      // TODO: implement pre‑send validation
    },
    post: async (context) => {
      // placeholder post‑hook
    }
  }
};

```

Developers can extend this hook to implement request-specific validations. For example, enforcing prompt length limits:

```javascript
pre: async (context) => {
  if (context.prompt.length > 500) {
    throw new Error("Prompt too long – pre‑send check failed");
  }
}

```

## Running the Pre-Send Check Manually

While the hook system triggers validation automatically, developers can execute the pre-send check independently using npm:

```bash

# Execute ESLint validation directly

npm run lint

# Or run the full check sequence (lint + test)

npm test

```

Manual execution proves useful during development to verify fixes before committing changes that would trigger the automated hook.

## Summary

- **Hook-driven architecture**: The pre-send check is defined in [`hooks/hooks.json`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/hooks.json) through the `pre` array, which executes before skill processing begins.
- **ESLint enforcement**: The validation runs `eslint . --ext .ts,.js` via the `npm run lint` command, ensuring TypeScript and JavaScript files meet quality standards.
- **Execution blocking**: If linting detects errors, the process exits with a non-zero code, preventing the agent from processing malformed requests.
- **Extensible runtime**: The OpenCode plugin at `.opencode/plugins/i-have-adhd.mjs` provides an async `pre` hook for implementing custom validation logic beyond static analysis.
- **Development utilities**: [`scripts/check_context_compat.ts`](https://github.com/ayghri/i-have-adhd/blob/main/scripts/check_context_compat.ts) offers programmatic verification of hook configurations during build processes.

## Frequently Asked Questions

### What happens if the pre-send check fails?

If ESLint detects syntax errors or style violations during the `npm run lint` execution, the command returns a non-zero exit code. This failure propagates through the hook system, causing the agent to abort the request immediately before any skill logic executes. The user receives the linting error output rather than a processed response.

### Can I customize the pre-send validation rules?

Yes. You can modify the ESLint configuration by editing `.eslintrc` files or updating the `lint` script in [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/package.json) to include additional flags or directories. For runtime validations—such as checking input length or content filtering—implement custom logic in the `pre` async function within `.opencode/plugins/i-have-adhd.mjs`.

### Where exactly is the pre-send check configured?

The primary configuration resides in [`hooks/hooks.json`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/hooks.json) under the `i-have-adhd` hook definition, specifically within the `pre` array. The actual command executed (`npm run lint`) is defined in [`package.json`](https://github.com/ayghri/i-have-adhd/blob/main/package.json) scripts section. This separation allows the hook system to remain agnostic of the specific linting implementation while enforcing execution order.

### Does the pre-send check run automatically on every request?

Yes. When the I-Have-ADHD agent processes a request, the hook system automatically executes all commands listed in the `pre` array of [`hooks/hooks.json`](https://github.com/ayghri/i-have-adhd/blob/main/hooks/hooks.json). This occurs before any skill-specific code runs, ensuring consistent code quality checks without requiring manual intervention for each interaction.