chore: add doctor tooling, tests, and CI workflows

- Upgrade biome to v2.3.8
- Add CI and release workflows
- Add lefthook for git hooks
- Add test suite with 7 tests
- Update README credits

Author: shtse8

.github/workflows/ci.yml

@@ -0,0 +1,32 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Lint
+        run: bun run lint
+
+      - name: Type check
+        run: bun run typecheck
+
+      - name: Test
+        run: bun test
+
+      - name: Build
+        run: bun run build

.github/workflows/release.yml

@@ -0,0 +1,10 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+
+jobs:
+  release:
+    uses: SylphxAI/.github/.github/workflows/release.yml@main
+    secrets: inherit

README.md

@@ -97,4 +97,6 @@ Extract entity data type from a StandardEntity type.
 
 ## Powered by Sylphx
 
+Built with [@sylphx/tsconfig](https://github.com/SylphxAI/tsconfig), [@sylphx/biome-config](https://github.com/SylphxAI/biome-config), [@sylphx/doctor](https://github.com/SylphxAI/doctor), and [@sylphx/bump](https://github.com/SylphxAI/bump).
+
 https://github.com/SylphxAI

biome.json

@@ -1,4 +1,4 @@
 {
-	"$schema": "https://biomejs.dev/schemas/1.9.4/schema.json",
+	"$schema": "https://biomejs.dev/schemas/2.3.8/schema.json",
 	"extends": ["@sylphx/biome-config"]
 }

lefthook.yml

@@ -0,0 +1,12 @@
+# Managed by @sylphx/doctor
+# https://github.com/evilmartians/lefthook
+
+pre-commit:
+  commands:
+    doctor:
+      run: bunx @sylphx/doctor precommit --fix
+
+pre-push:
+  commands:
+    doctor:
+      run: bunx @sylphx/doctor prepush

package.json

@@ -11,13 +11,16 @@
 			"import": "./dist/index.js"
 		}
 	},
-	"files": ["dist"],
+	"files": [
+		"dist"
+	],
 	"scripts": {
 		"build": "tsc",
 		"typecheck": "tsc --noEmit",
 		"lint": "biome check .",
 		"format": "biome format --write .",
-		"prepublishOnly": "echo 'Use CI to publish' && exit 1"
+		"prepublishOnly": "bunx @sylphx/doctor prepublish && echo 'Use CI to publish' && exit 1",
+		"test": "bun test"
 	},
 	"keywords": [
 		"standard-entity",
@@ -38,10 +41,13 @@
 		"url": "https://github.com/SylphxAI/standard-entity/issues"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^1.9.4",
+		"@biomejs/biome": "^2.3.8",
 		"@sylphx/biome-config": "^0.4.0",
+		"@sylphx/bump": "^1.4.11",
+		"@sylphx/doctor": "^1.26.0",
 		"@sylphx/tsconfig": "^0.3.0",
 		"@types/bun": "^1.2.17",
+		"lefthook": "^2.0.4",
 		"typescript": "^5.8.3"
 	}
 }

progress.md

@@ -0,0 +1,13 @@
+# Progress
+
+## Status: 🚧 In Development
+
+## Completed
+- [ ] Initial setup
+
+## In Progress
+- [ ] Core features
+
+## Planned
+- [ ] Documentation
+- [ ] Tests

src/index.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from 'bun:test'
+import {
+	type EntityMarker,
+	type InferEntityName,
+	type InferEntityType,
+	isStandardEntity,
+	type SimpleEntity,
+	type StandardEntity,
+} from './index'
+
+describe('StandardEntity', () => {
+	test('isStandardEntity returns true for valid entity', () => {
+		const entity: StandardEntity<'User', { id: string }> = {
+			'~entity': {
+				name: 'User',
+				type: undefined as unknown as { id: string },
+			},
+		}
+
+		expect(isStandardEntity(entity)).toBe(true)
+	})
+
+	test('isStandardEntity returns false for non-entity', () => {
+		expect(isStandardEntity(null)).toBe(false)
+		expect(isStandardEntity(undefined)).toBe(false)
+		expect(isStandardEntity({})).toBe(false)
+		expect(isStandardEntity({ name: 'User' })).toBe(false)
+		expect(isStandardEntity({ '~entity': null })).toBe(false)
+		expect(isStandardEntity({ '~entity': {} })).toBe(false)
+	})
+
+	test('isStandardEntity returns true for entity with fields', () => {
+		const entity = {
+			'~entity': {
+				name: 'Post',
+				type: undefined,
+			},
+			fields: {
+				title: { type: 'string' },
+			},
+		}
+
+		expect(isStandardEntity(entity)).toBe(true)
+	})
+})
+
+describe('Type inference', () => {
+	test('InferEntityName extracts name', () => {
+		type UserEntity = StandardEntity<'User', { id: string }>
+		type Name = InferEntityName<UserEntity>
+
+		// Type-level test - if this compiles, it works
+		const name: Name = 'User'
+		expect(name).toBe('User')
+	})
+
+	test('InferEntityType extracts data type', () => {
+		type UserData = { id: string; name: string }
+		type UserEntity = StandardEntity<'User', UserData>
+		type Data = InferEntityType<UserEntity>
+
+		// Type-level test - if this compiles, it works
+		const data: Data = { id: '1', name: 'Alice' }
+		expect(data.id).toBe('1')
+		expect(data.name).toBe('Alice')
+	})
+})
+
+describe('EntityMarker', () => {
+	test('can create entity with EntityMarker', () => {
+		interface MyEntity<N extends string, D> extends EntityMarker<N, D> {
+			readonly customProp: string
+		}
+
+		const entity: MyEntity<'Custom', { value: number }> = {
+			'~entity': {
+				name: 'Custom',
+				type: undefined as unknown as { value: number },
+			},
+			customProp: 'test',
+		}
+
+		expect(isStandardEntity(entity)).toBe(true)
+		expect(entity['~entity'].name).toBe('Custom')
+		expect(entity.customProp).toBe('test')
+	})
+})
+
+describe('SimpleEntity', () => {
+	test('SimpleEntity is a valid StandardEntity', () => {
+		const entity: SimpleEntity<'Simple', { foo: string }> = {
+			'~entity': {
+				name: 'Simple',
+				type: undefined as unknown as { foo: string },
+			},
+		}
+
+		expect(isStandardEntity(entity)).toBe(true)
+		expect(entity['~entity'].name).toBe('Simple')
+	})
+})

src/index.ts

@@ -75,20 +75,20 @@ export interface StandardEntity<TName extends string = string, TData = unknown>
 	 * Standard Entity marker with phantom types.
 	 * The `~` prefix is a convention indicating this is a protocol marker.
 	 */
-	readonly "~entity": {
+	readonly '~entity': {
 		/** Entity name as a string literal type */
-		readonly name: TName;
+		readonly name: TName
 		/**
 		 * Entity data type.
 		 * Can be `unknown` if type is inferred from `fields` property.
 		 */
-		readonly type: TData;
-	};
+		readonly type: TData
+	}
 	/**
 	 * Optional fields for type inference.
 	 * Libraries like Lens use this for field-based type inference.
 	 */
-	readonly fields?: unknown;
+	readonly fields?: unknown
 }
 
 // =============================================================================
@@ -107,13 +107,13 @@ export interface StandardEntity<TName extends string = string, TData = unknown>
  */
 export function isStandardEntity(value: unknown): value is StandardEntity {
 	return (
-		typeof value === "object" &&
+		typeof value === 'object' &&
 		value !== null &&
-		"~entity" in value &&
-		typeof (value as StandardEntity)["~entity"] === "object" &&
-		(value as StandardEntity)["~entity"] !== null &&
-		"name" in (value as StandardEntity)["~entity"]
-	);
+		'~entity' in value &&
+		typeof (value as StandardEntity)['~entity'] === 'object' &&
+		(value as StandardEntity)['~entity'] !== null &&
+		'name' in (value as StandardEntity)['~entity']
+	)
 }
 
 // =============================================================================
@@ -128,7 +128,7 @@ export function isStandardEntity(value: unknown): value is StandardEntity {
  * type Name = InferEntityName<typeof User>;  // "User"
  * ```
  */
-export type InferEntityName<T> = T extends StandardEntity<infer N, unknown> ? N : never;
+export type InferEntityName<T> = T extends StandardEntity<infer N, unknown> ? N : never
 
 /**
  * Extract entity data type from StandardEntity.
@@ -142,7 +142,7 @@ export type InferEntityName<T> = T extends StandardEntity<infer N, unknown> ? N
  * type Data = InferEntityType<typeof User>;  // { id: string; name: string; }
  * ```
  */
-export type InferEntityType<T> = T extends StandardEntity<string, infer D> ? D : never;
+export type InferEntityType<T> = T extends StandardEntity<string, infer D> ? D : never
 
 // =============================================================================
 // Utility Types for Implementers
@@ -160,10 +160,10 @@ export type InferEntityType<T> = T extends StandardEntity<string, infer D> ? D :
  * ```
  */
 export interface EntityMarker<TName extends string, TData = unknown> {
-	readonly "~entity": {
-		readonly name: TName;
-		readonly type: TData;
-	};
+	readonly '~entity': {
+		readonly name: TName
+		readonly type: TData
+	}
 }
 
 /**
@@ -177,4 +177,4 @@ export interface EntityMarker<TName extends string, TData = unknown> {
  * };
  * ```
  */
-export type SimpleEntity<TName extends string, TData> = EntityMarker<TName, TData>;
+export type SimpleEntity<TName extends string, TData> = EntityMarker<TName, TData>