typescript

SKILL.md

TypeScript style and type-safety conventions for consistent, maintainable code across the project.

Enforce strict typing: avoid implicit any, prefer interface for object shapes and type for unions, use as const satisfies patterns, and leverage type inference where possible

Async-first patterns: use async/await over callbacks, promise-based APIs from fs/promises, and Promise.all/Promise.race for concurrent operations

Import discipline: separate type imports with import type { ... }, keep type and value imports as distinct statements, and sort specifiers alphabetically

UI and performance: use @lobehub/ui and Ant Design components with antd-style tokens, prefer for…of loops, and reuse utilities from packages/utils

Logging safety: never log private data, always catch and log errors explicitly, and avoid silent .catch() handlers that hide failures

TypeScript Code Style Guide

Types and Type Safety

Avoid explicit type annotations when TypeScript can infer

Avoid implicitly any; explicitly type when necessary

Use accurate types: prefer Record<PropertyKey, unknown> over object or any

Prefer interface for object shapes (e.g., React props); use type for unions/intersections

Prefer as const satisfies XyzInterface over plain as const

Prefer @ts-expect-error over @ts-ignore over as any

Avoid meaningless null/undefined parameters; design strict function contracts

Prefer ES module augmentation (declare module '...') over namespace; do not introduce namespace-based extension patterns

When a type needs extensibility, expose a small mergeable interface at the source type and let each feature/plugin augment it locally instead of centralizing all extension fields in one registry file

For package-local extensibility patterns like PipelineContext.metadata, define the metadata fields next to the processor/provider/plugin that reads or writes them

Async Patterns