fix: lint and pre-commit configuration

snus-kin · snus-kin · commit 20e55df696b3 · 2025-09-05T10:27:13.000+01:00
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
@@ -0,0 +1,30 @@
+# Pre-commit configuration for athena-nodejs-client
+# See https://pre-commit.com for more information
+# See https://pre-commit.com/hooks.html for more hooks
+repos:
+  # General file checks
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.5.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+      - id: check-json
+        exclude: ^samples/
+      - id: check-merge-conflict
+
+  # Node.js/npm hooks
+  - repo: local
+    hooks:
+      # Run all linting checks
+      - id: lint-all
+        name: Lint All (ESLint + Prettier + TypeScript)
+        entry: npm run lint:all
+        language: system
+        pass_filenames: false
+        always_run: true
+
+# Global settings
+default_stages: [pre-commit]
+fail_fast: true
diff --git a/README.md b/README.md
@@ -16,12 +16,79 @@ Athena is a gRPC-based image classification service designed for CSAM (Child Sex
 
 # Contributing
 
+## Code Quality and Pre-commit Hooks
+
+This project uses pre-commit hooks to ensure code quality and consistency. The hooks run linting, formatting, and type checking before each commit.
+
+### Setting up Pre-commit Hooks
+
+1. **Install pre-commit** (if not already installed):
+   ```sh
+   uvx pre-commit --help
+   ```
+   Or install globally:
+   ```sh
+   uv tool install pre-commit
+   ```
+
+2. **Install the hooks**:
+   ```sh
+   uvx pre-commit install
+   ```
+
+3. **Run all quality checks manually**:
+   ```sh
+   npm run lint:all
+   ```
+
+### What the Pre-commit Hooks Check
+
+- **ESLint**: Code quality and style issues
+- **Prettier**: Code formatting consistency
+- **TypeScript**: Type checking and compilation
+- **File checks**: Trailing whitespace, file endings, large files, etc.
+- **Submodule status**: Ensures submodules are properly tracked
+
+### Manual Quality Checks
+
+You can run individual checks manually:
+
+```sh
+# Run ESLint
+npm run lint
+
+# Check Prettier formatting
+npm run prettier:check
+
+# Fix Prettier formatting
+npm run prettier
+
+# TypeScript type checking
+npx tsc --noEmit
+
+# Run all checks at once
+npm run lint:all
+```
+
 ## Updating the Protobuf definitions
 
-Protobufs are stored in the [@crispthinking/athena-protobuffs](https://github.com/crispthinking/athena-protobufs) repository.
+Protobufs are stored as a git submodule from the [@crispthinking/athena-nodejs-client](https://github.com/crispthinking/athena-nodejs-client.git) repository.
 
-To update the protobuf definitions for client generation, run:
-`git subtree pull --prefix=athena-protobufs https://github.com/crispthinking/athena-protobufs.git <sha> --squash`
+To update the protobuf definitions for client generation:
+
+1. **Update the submodule to the latest version:**
+   ```sh
+   git submodule update --remote athena-protobufs
+   ```
+
+2. **Or update to a specific commit:**
+   ```sh
+   cd athena-protobufs
+   git checkout <commit-sha>
+   cd ..
+   git add athena-protobufs
+   git commit -m "Update protobuf definitions to <commit-sha>"
+   ```
 
 ## Regenerating the TypeScript gRPC Client
 
@@ -36,22 +103,33 @@ This project uses [`@protobuf-ts/plugin`](https://github.com/timostamm/protobuf-
 	```
 
 2. **Run the following command to regenerate the client and types:**
+	```sh
+	npm run codegen
+	```
+
+	Or manually with:
 	```sh
 	npx protoc \
 	  --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts \
 	  --ts_out=client_grpc1:./src/athena \
-	  --proto_path=./athena-protobufs/athena \
-	  ./athena-protobufs/athena/athena.proto
+	  --proto_path=./athena-protobufs/athena-protobufs/athena \
+	  ./athena-protobufs/athena-protobufs/athena/athena.proto
 	```
 	- This will generate `.ts` files in `src/athena/` including a gRPC client compatible with `@grpc/grpc-js`.
 
 3. **Update your imports in your code as needed:**
 	- The main client will be in `src/athena/athena.grpc-client.ts`.
 	- Message types and enums are in `src/athena/athena.ts`.
 
+3. **Format the generated code:**
+	```sh
+	npm run prettier
+	```
+
 ### Notes
-- If you add or change proto files, rerun the above command to keep the TypeScript client in sync.
+- If you update proto files in the submodule, rerun `npm run codegen` to keep the TypeScript client in sync.
 - If you see TypeScript errors about missing modules, ensure your `tsconfig.json` includes the `src/athena` directory and restart your IDE/tsserver.
+- The generated files are automatically formatted by the pre-commit hooks, but you can run `npm run prettier` manually if needed.
 
 ---
 
@@ -65,4 +143,4 @@ curl -LsSf https://astral.sh/uv/install.sh | sh
 uv sync
 cd docs
 make html
-The built documentation will be available in docs/build/html/index.html.
+The built documentation will be available in docs/build/html/index.html.
diff --git a/package.json b/package.json
@@ -52,6 +52,8 @@
     "build:release": "npm run clean && tsc -p tsconfig.release.json",
     "codegen": "npx protoc --plugin=protoc-gen-ts=./node_modules/.bin/protoc-gen-ts --ts_out=client_grpc1:./src/athena --proto_path=./athena-protobufs/athena-protobufs/athena ./athena-protobufs/athena-protobufs/athena/athena.proto",
     "lint": "eslint .",
+    "lint:all": "npm run lint && npm run prettier:check && npx tsc --noEmit",
+    "precommit:setup": "echo 'To install pre-commit hooks, run: uv tool install pre-commit && uvx pre-commit install'",
     "test": "vitest run unit --config __tests__/vitest.config.ts",
     "test:coverage": "vitest run unit --config __tests__/vitest.config.ts --coverage.enabled --coverage.all",
     "prettier": "prettier \"{src,__{tests}__}/**/*.{ts,mts}\" --config .prettierrc --write",
diff --git a/src/athena/athena.grpc-client.ts b/src/athena/athena.grpc-client.ts
@@ -1,14 +1,14 @@
 // @generated by protobuf-ts 2.11.1 with parameter client_grpc1
 // @generated from protobuf file "athena.proto" (package "athena", syntax proto3)
 // tslint:disable
-import { ClassifierService } from "./athena";
-import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
-import type { BinaryReadOptions } from "@protobuf-ts/runtime";
-import type { ListDeploymentsResponse } from "./athena";
-import type { Empty } from "./google/protobuf/empty";
-import type { ClassifyResponse } from "./athena";
-import type { ClassifyRequest } from "./athena";
-import * as grpc from "@grpc/grpc-js";
+import { ClassifierService } from './athena';
+import type { BinaryWriteOptions } from '@protobuf-ts/runtime';
+import type { BinaryReadOptions } from '@protobuf-ts/runtime';
+import type { ListDeploymentsResponse } from './athena';
+import type { Empty } from './google/protobuf/empty';
+import type { ClassifyResponse } from './athena';
+import type { ClassifyRequest } from './athena';
+import * as grpc from '@grpc/grpc-js';
 /**
  * The classifier service definition.
  * Provides image classification capabilities with session-based streaming
@@ -17,26 +17,59 @@ import * as grpc from "@grpc/grpc-js";
  * @generated from protobuf service athena.ClassifierService
  */
 export interface IClassifierServiceClient {
-    /**
-     * Classify images in a deployment-based streaming context
-     * Multiple affiliates can join the same deployment to share responses
-     * Supports bidirectional streaming for real-time classification
-     *
-     * @generated from protobuf rpc: Classify
-     */
-    classify(metadata: grpc.Metadata, options?: grpc.CallOptions): grpc.ClientDuplexStream<ClassifyRequest, ClassifyResponse>;
-    classify(options?: grpc.CallOptions): grpc.ClientDuplexStream<ClassifyRequest, ClassifyResponse>;
-    /**
-     * Retrieves a list of all active deployment IDs
-     * Returns the active deployment_id values that can be used in Classify requests
-     * Useful for monitoring and debugging active connections
-     *
-     * @generated from protobuf rpc: ListDeployments
-     */
-    listDeployments(input: Empty, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void): grpc.ClientUnaryCall;
-    listDeployments(input: Empty, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void): grpc.ClientUnaryCall;
-    listDeployments(input: Empty, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void): grpc.ClientUnaryCall;
-    listDeployments(input: Empty, callback: (err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void): grpc.ClientUnaryCall;
+  /**
+   * Classify images in a deployment-based streaming context
+   * Multiple affiliates can join the same deployment to share responses
+   * Supports bidirectional streaming for real-time classification
+   *
+   * @generated from protobuf rpc: Classify
+   */
+  classify(
+    metadata: grpc.Metadata,
+    options?: grpc.CallOptions,
+  ): grpc.ClientDuplexStream<ClassifyRequest, ClassifyResponse>;
+  classify(
+    options?: grpc.CallOptions,
+  ): grpc.ClientDuplexStream<ClassifyRequest, ClassifyResponse>;
+  /**
+   * Retrieves a list of all active deployment IDs
+   * Returns the active deployment_id values that can be used in Classify requests
+   * Useful for monitoring and debugging active connections
+   *
+   * @generated from protobuf rpc: ListDeployments
+   */
+  listDeployments(
+    input: Empty,
+    metadata: grpc.Metadata,
+    options: grpc.CallOptions,
+    callback: (
+      err: grpc.ServiceError | null,
+      value?: ListDeploymentsResponse,
+    ) => void,
+  ): grpc.ClientUnaryCall;
+  listDeployments(
+    input: Empty,
+    metadata: grpc.Metadata,
+    callback: (
+      err: grpc.ServiceError | null,
+      value?: ListDeploymentsResponse,
+    ) => void,
+  ): grpc.ClientUnaryCall;
+  listDeployments(
+    input: Empty,
+    options: grpc.CallOptions,
+    callback: (
+      err: grpc.ServiceError | null,
+      value?: ListDeploymentsResponse,
+    ) => void,
+  ): grpc.ClientUnaryCall;
+  listDeployments(
+    input: Empty,
+    callback: (
+      err: grpc.ServiceError | null,
+      value?: ListDeploymentsResponse,
+    ) => void,
+  ): grpc.ClientUnaryCall;
 }
 /**
  * The classifier service definition.
@@ -45,32 +78,82 @@ export interface IClassifierServiceClient {
  *
  * @generated from protobuf service athena.ClassifierService
  */
-export class ClassifierServiceClient extends grpc.Client implements IClassifierServiceClient {
-    private readonly _binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions>;
-    constructor(address: string, credentials: grpc.ChannelCredentials, options: grpc.ClientOptions = {}, binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions> = {}) {
-        super(address, credentials, options);
-        this._binaryOptions = binaryOptions;
-    }
-    /**
-     * Classify images in a deployment-based streaming context
-     * Multiple affiliates can join the same deployment to share responses
-     * Supports bidirectional streaming for real-time classification
-     *
-     * @generated from protobuf rpc: Classify
-     */
-    classify(metadata?: grpc.Metadata | grpc.CallOptions, options?: grpc.CallOptions): grpc.ClientDuplexStream<ClassifyRequest, ClassifyResponse> {
-        const method = ClassifierService.methods[0];
-        return this.makeBidiStreamRequest<ClassifyRequest, ClassifyResponse>(`/${ClassifierService.typeName}/${method.name}`, (value: ClassifyRequest): Buffer => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value: Buffer): ClassifyResponse => method.O.fromBinary(value, this._binaryOptions), (metadata as any), options);
-    }
-    /**
-     * Retrieves a list of all active deployment IDs
-     * Returns the active deployment_id values that can be used in Classify requests
-     * Useful for monitoring and debugging active connections
-     *
-     * @generated from protobuf rpc: ListDeployments
-     */
-    listDeployments(input: Empty, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void), callback?: ((err: grpc.ServiceError | null, value?: ListDeploymentsResponse) => void)): grpc.ClientUnaryCall {
-        const method = ClassifierService.methods[1];
-        return this.makeUnaryRequest<Empty, ListDeploymentsResponse>(`/${ClassifierService.typeName}/${method.name}`, (value: Empty): Buffer => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value: Buffer): ListDeploymentsResponse => method.O.fromBinary(value, this._binaryOptions), input, (metadata as any), (options as any), (callback as any));
-    }
+export class ClassifierServiceClient
+  extends grpc.Client
+  implements IClassifierServiceClient
+{
+  private readonly _binaryOptions: Partial<
+    BinaryReadOptions & BinaryWriteOptions
+  >;
+  constructor(
+    address: string,
+    credentials: grpc.ChannelCredentials,
+    options: grpc.ClientOptions = {},
+    binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions> = {},
+  ) {
+    super(address, credentials, options);
+    this._binaryOptions = binaryOptions;
+  }
+  /**
+   * Classify images in a deployment-based streaming context
+   * Multiple affiliates can join the same deployment to share responses
+   * Supports bidirectional streaming for real-time classification
+   *
+   * @generated from protobuf rpc: Classify
+   */
+  classify(
+    metadata?: grpc.Metadata | grpc.CallOptions,
+    options?: grpc.CallOptions,
+  ): grpc.ClientDuplexStream<ClassifyRequest, ClassifyResponse> {
+    const method = ClassifierService.methods[0];
+    return this.makeBidiStreamRequest<ClassifyRequest, ClassifyResponse>(
+      `/${ClassifierService.typeName}/${method.name}`,
+      (value: ClassifyRequest): Buffer =>
+        Buffer.from(method.I.toBinary(value, this._binaryOptions)),
+      (value: Buffer): ClassifyResponse =>
+        method.O.fromBinary(value, this._binaryOptions),
+      metadata as any,
+      options,
+    );
+  }
+  /**
+   * Retrieves a list of all active deployment IDs
+   * Returns the active deployment_id values that can be used in Classify requests
+   * Useful for monitoring and debugging active connections
+   *
+   * @generated from protobuf rpc: ListDeployments
+   */
+  listDeployments(
+    input: Empty,
+    metadata:
+      | grpc.Metadata
+      | grpc.CallOptions
+      | ((
+          err: grpc.ServiceError | null,
+          value?: ListDeploymentsResponse,
+        ) => void),
+    options?:
+      | grpc.CallOptions
+      | ((
+          err: grpc.ServiceError | null,
+          value?: ListDeploymentsResponse,
+        ) => void),
+    callback?: (
+      err: grpc.ServiceError | null,
+      value?: ListDeploymentsResponse,
+    ) => void,
+  ): grpc.ClientUnaryCall {
+    const method = ClassifierService.methods[1];
+    return this.makeUnaryRequest<Empty, ListDeploymentsResponse>(
+      `/${ClassifierService.typeName}/${method.name}`,
+      (value: Empty): Buffer =>
+        Buffer.from(method.I.toBinary(value, this._binaryOptions)),
+      (value: Buffer): ListDeploymentsResponse =>
+        method.O.fromBinary(value, this._binaryOptions),
+      input,
+      metadata as any,
+      options as any,
+      callback as any,
+    );
+  }
 }
diff --git a/src/athena/athena.ts b/src/athena/athena.ts
diff --git a/src/athena/google/protobuf/empty.ts b/src/athena/google/protobuf/empty.ts
