@enjoys/context-engine 1.3.1 → 1.4.1

package/data/implementation/angular.json

@@ -0,0 +1,22 @@
+{
+  "language": "angular",
+  "implementationPatterns": [
+    { "name": "OnInit", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bOnInit\\b", "captureGroup": 1, "description": "Class implementing OnInit lifecycle interface" },
+    { "name": "OnDestroy", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bOnDestroy\\b", "captureGroup": 1, "description": "Class implementing OnDestroy lifecycle interface" },
+    { "name": "OnChanges", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bOnChanges\\b", "captureGroup": 1, "description": "Class implementing OnChanges lifecycle interface" },
+    { "name": "AfterViewInit", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bAfterViewInit\\b", "captureGroup": 1, "description": "Class implementing AfterViewInit lifecycle interface" },
+    { "name": "AfterContentInit", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bAfterContentInit\\b", "captureGroup": 1, "description": "Class implementing AfterContentInit lifecycle interface" },
+    { "name": "DoCheck", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bDoCheck\\b", "captureGroup": 1, "description": "Class implementing DoCheck lifecycle interface" },
+    { "name": "AfterViewChecked", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bAfterViewChecked\\b", "captureGroup": 1, "description": "Class implementing AfterViewChecked lifecycle interface" },
+    { "name": "AfterContentChecked", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bAfterContentChecked\\b", "captureGroup": 1, "description": "Class implementing AfterContentChecked lifecycle interface" },
+    { "name": "CanActivate", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bCanActivate\\b", "captureGroup": 1, "description": "Class implementing CanActivate route guard interface" },
+    { "name": "CanDeactivate", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bCanDeactivate\\b", "captureGroup": 1, "description": "Class implementing CanDeactivate route guard interface" },
+    { "name": "Resolve", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bResolve\\b", "captureGroup": 1, "description": "Class implementing Resolve route resolver interface" },
+    { "name": "HttpInterceptor", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bHttpInterceptor\\b", "captureGroup": 1, "description": "Class implementing HttpInterceptor interface" },
+    { "name": "PipeTransform", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bPipeTransform\\b", "captureGroup": 1, "description": "Class implementing PipeTransform interface" },
+    { "name": "ControlValueAccessor", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bControlValueAccessor\\b", "captureGroup": 1, "description": "Class implementing ControlValueAccessor for custom form controls" },
+    { "name": "Validator", "pattern": "class\\s+(\\w+)[^{]*implements\\s+[^{]*\\bValidator\\b", "captureGroup": 1, "description": "Class implementing Validator interface for custom validation" },
+    { "name": "NgModule", "pattern": "@NgModule\\s*\\([^)]*\\)\\s*(?:export\\s+)?class\\s+(\\w+)", "captureGroup": 1, "description": "Angular module class decorated with @NgModule" },
+    { "name": "ErrorHandler", "pattern": "class\\s+(\\w+)[^{]*(?:implements\\s+[^{]*\\bErrorHandler\\b|extends\\s+ErrorHandler)", "captureGroup": 1, "description": "Class implementing or extending ErrorHandler" }
+  ]
+}

package/data/implementation/nestjs.json

@@ -0,0 +1,24 @@
+{
+  "language": "nestjs",
+  "implementationPatterns": [
+    { "interface": "CanActivate", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+CanActivate", "description": "Guard implementations" },
+    { "interface": "PipeTransform", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+PipeTransform", "description": "Pipe implementations" },
+    { "interface": "NestInterceptor", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+NestInterceptor", "description": "Interceptor implementations" },
+    { "interface": "ExceptionFilter", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+ExceptionFilter", "description": "Exception filter implementations" },
+    { "interface": "NestMiddleware", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+NestMiddleware", "description": "Middleware implementations" },
+    { "interface": "NestModule", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+NestModule", "description": "Module configure implementations" },
+    { "interface": "OnModuleInit", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)[^{]*implements[^{]*OnModuleInit", "description": "OnModuleInit lifecycle hook" },
+    { "interface": "OnModuleDestroy", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)[^{]*implements[^{]*OnModuleDestroy", "description": "OnModuleDestroy lifecycle hook" },
+    { "interface": "OnApplicationBootstrap", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)[^{]*implements[^{]*OnApplicationBootstrap", "description": "OnApplicationBootstrap lifecycle hook" },
+    { "interface": "OnApplicationShutdown", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)[^{]*implements[^{]*OnApplicationShutdown", "description": "OnApplicationShutdown lifecycle hook" },
+    { "interface": "BeforeApplicationShutdown", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)[^{]*implements[^{]*BeforeApplicationShutdown", "description": "BeforeApplicationShutdown lifecycle hook" },
+    { "interface": "CallHandler", "implementationKeyword": "implements", "pattern": "intercept\\([^)]*\\).*Observable", "description": "Interceptor intercept method" },
+    { "interface": "ArgumentsHost", "implementationKeyword": "catch", "pattern": "catch\\(\\s*\\w+[^,)]*,\\s*\\w+:\\s*ArgumentsHost", "description": "Exception filter catch method" },
+    { "interface": "HealthIndicator", "implementationKeyword": "extends", "pattern": "class\\s+(\\w+)\\s+extends\\s+HealthIndicator", "description": "Health check implementations" },
+    { "interface": "TypeOrmModuleOptions", "implementationKeyword": "implements", "pattern": "class\\s+(\\w+)\\s+implements\\s+TypeOrmOptionsFactory", "description": "TypeORM config factory" }
+  ],
+  "keywords": {
+    "interface": ["interface", "abstract class", "CanActivate", "PipeTransform", "NestInterceptor", "ExceptionFilter", "NestMiddleware", "NestModule", "OnModuleInit", "OnModuleDestroy"],
+    "implementation": ["implements", "extends", "class", "@Injectable", "@Controller", "@Module"]
+  }
+}

package/data/implementation/nextjs.json

@@ -0,0 +1,137 @@
+{
+  "language": "nextjs",
+  "implementationPatterns": [
+    {
+      "interface": "Page",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+(?:async\\s+)?function\\s+\\w+\\s*\\(\\s*(?:\\{\\s*(?:params|searchParams)[^}]*\\})?",
+      "description": "App Router page component implementing the page file convention"
+    },
+    {
+      "interface": "Layout",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+(?:async\\s+)?function\\s+\\w+\\s*\\(\\s*\\{\\s*children",
+      "description": "App Router layout component implementing the layout file convention"
+    },
+    {
+      "interface": "Loading",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+function\\s+Loading\\s*\\(",
+      "description": "Loading UI component implementing the loading file convention"
+    },
+    {
+      "interface": "Error",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+function\\s+Error\\s*\\(\\s*\\{\\s*error\\s*,\\s*reset",
+      "description": "Error boundary component implementing the error file convention"
+    },
+    {
+      "interface": "NotFound",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+function\\s+NotFound\\s*\\(",
+      "description": "Not-found component implementing the not-found file convention"
+    },
+    {
+      "interface": "RouteHandler",
+      "implementationKeyword": "export async function",
+      "pattern": "export\\s+(?:async\\s+)?function\\s+(?:GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\\s*\\(",
+      "description": "App Router Route Handler implementing HTTP method handlers"
+    },
+    {
+      "interface": "Middleware",
+      "implementationKeyword": "export function middleware",
+      "pattern": "export\\s+(?:async\\s+)?function\\s+middleware\\s*\\(\\s*(?:request|req)\\s*:\\s*NextRequest",
+      "description": "Middleware function implementing the middleware file convention"
+    },
+    {
+      "interface": "ServerAction",
+      "implementationKeyword": "use server",
+      "pattern": "['\"]use server['\"]\\s*;?\\s*(?:export\\s+)?async\\s+function\\s+\\w+",
+      "description": "Server Action implementing the 'use server' directive convention"
+    },
+    {
+      "interface": "GetServerSideProps",
+      "implementationKeyword": "export const getServerSideProps",
+      "pattern": "export\\s+(?:const\\s+getServerSideProps|async\\s+function\\s+getServerSideProps)",
+      "description": "Pages Router server-side data fetching implementation"
+    },
+    {
+      "interface": "GetStaticProps",
+      "implementationKeyword": "export const getStaticProps",
+      "pattern": "export\\s+(?:const\\s+getStaticProps|async\\s+function\\s+getStaticProps)",
+      "description": "Pages Router static generation implementation"
+    },
+    {
+      "interface": "GetStaticPaths",
+      "implementationKeyword": "export const getStaticPaths",
+      "pattern": "export\\s+(?:const\\s+getStaticPaths|async\\s+function\\s+getStaticPaths)",
+      "description": "Pages Router static paths implementation for dynamic routes"
+    },
+    {
+      "interface": "APIRoute",
+      "implementationKeyword": "export default function handler",
+      "pattern": "export\\s+default\\s+(?:async\\s+)?function\\s+handler\\s*\\(\\s*req\\s*:\\s*NextApiRequest",
+      "description": "Pages Router API route handler implementation"
+    },
+    {
+      "interface": "GenerateMetadata",
+      "implementationKeyword": "export async function generateMetadata",
+      "pattern": "export\\s+async\\s+function\\s+generateMetadata\\s*\\(",
+      "description": "Dynamic metadata generation function implementation"
+    },
+    {
+      "interface": "GenerateStaticParams",
+      "implementationKeyword": "export async function generateStaticParams",
+      "pattern": "export\\s+async\\s+function\\s+generateStaticParams\\s*\\(",
+      "description": "Static params generation function implementation"
+    },
+    {
+      "interface": "Template",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+function\\s+Template\\s*\\(\\s*\\{\\s*children",
+      "description": "Template component implementing the template file convention"
+    },
+    {
+      "interface": "GlobalError",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+function\\s+GlobalError\\s*\\(\\s*\\{\\s*error\\s*,\\s*reset",
+      "description": "Global error boundary implementing the global-error file convention"
+    },
+    {
+      "interface": "Default",
+      "implementationKeyword": "export default function",
+      "pattern": "export\\s+default\\s+function\\s+Default\\s*\\(",
+      "description": "Default component for parallel route slots implementing the default file convention"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "Page",
+      "Layout",
+      "Loading",
+      "Error",
+      "NotFound",
+      "Template",
+      "GlobalError",
+      "Default",
+      "RouteHandler",
+      "Middleware",
+      "ServerAction",
+      "APIRoute",
+      "GetServerSideProps",
+      "GetStaticProps",
+      "GetStaticPaths",
+      "GenerateMetadata",
+      "GenerateStaticParams"
+    ],
+    "implementation": [
+      "export default function",
+      "export default async function",
+      "export async function",
+      "export const",
+      "export function",
+      "use server",
+      "use client"
+    ]
+  }
+}

package/data/implementation/react.json

@@ -0,0 +1,125 @@
+{
+  "language": "react",
+  "implementationPatterns": [
+    {
+      "interface": "React.Component",
+      "implementationKeyword": "extends",
+      "pattern": "class\\s+(\\w+)\\s+extends\\s+(?:React\\.)?Component",
+      "description": "Class component extending React.Component with lifecycle methods and state"
+    },
+    {
+      "interface": "React.PureComponent",
+      "implementationKeyword": "extends",
+      "pattern": "class\\s+(\\w+)\\s+extends\\s+(?:React\\.)?PureComponent",
+      "description": "Class component extending React.PureComponent with shallow prop/state comparison"
+    },
+    {
+      "interface": "React.memo",
+      "implementationKeyword": "memo",
+      "pattern": "(?:const|let)\\s+(\\w+)\\s*=\\s*(?:React\\.)?memo\\s*\\(",
+      "description": "Memoized component implementation using React.memo wrapper"
+    },
+    {
+      "interface": "React.forwardRef",
+      "implementationKeyword": "forwardRef",
+      "pattern": "(?:const|let)\\s+(\\w+)\\s*=\\s*(?:React\\.)?forwardRef\\s*[<(]",
+      "description": "Component with ref forwarding using React.forwardRef"
+    },
+    {
+      "interface": "Context.Provider",
+      "implementationKeyword": "Provider",
+      "pattern": "<(\\w+Context)\\.Provider\\s+value=",
+      "description": "Context Provider implementation that supplies context value to descendants"
+    },
+    {
+      "interface": "Context.Consumer",
+      "implementationKeyword": "Consumer",
+      "pattern": "<(\\w+Context)\\.Consumer>",
+      "description": "Context Consumer implementation using render props pattern"
+    },
+    {
+      "interface": "useContext",
+      "implementationKeyword": "useContext",
+      "pattern": "(?:const|let)\\s+(\\w+)\\s*=\\s*useContext\\s*\\(",
+      "description": "Context consumption using useContext hook"
+    },
+    {
+      "interface": "CustomHook",
+      "implementationKeyword": "function",
+      "pattern": "(?:export\\s+)?(?:function|const)\\s+(use[A-Z]\\w*)\\s*(?:=|\\()",
+      "description": "Custom hook implementation following the use* naming convention"
+    },
+    {
+      "interface": "ErrorBoundary",
+      "implementationKeyword": "componentDidCatch",
+      "pattern": "class\\s+(\\w+)\\s+extends\\s+(?:React\\.)?Component[^{]*\\{[^}]*componentDidCatch",
+      "description": "Error boundary implementation with componentDidCatch lifecycle method"
+    },
+    {
+      "interface": "ErrorBoundary.getDerivedStateFromError",
+      "implementationKeyword": "getDerivedStateFromError",
+      "pattern": "static\\s+getDerivedStateFromError\\s*\\(",
+      "description": "Error boundary static method for deriving state from caught errors"
+    },
+    {
+      "interface": "HOC",
+      "implementationKeyword": "with",
+      "pattern": "(?:export\\s+)?(?:function|const)\\s+(with[A-Z]\\w*)\\s*(?:=\\s*)?[<(]",
+      "description": "Higher-Order Component implementation following the with* naming convention"
+    },
+    {
+      "interface": "React.lazy",
+      "implementationKeyword": "lazy",
+      "pattern": "(?:const|let)\\s+(\\w+)\\s*=\\s*(?:React\\.)?lazy\\s*\\(",
+      "description": "Lazy-loaded component implementation using dynamic import"
+    },
+    {
+      "interface": "useReducer",
+      "implementationKeyword": "reducer",
+      "pattern": "(?:function|const)\\s+(\\w+(?:Reducer|reducer))\\s*(?:=|\\()\\s*(?:\\(state|\\(prevState)",
+      "description": "Reducer function implementation for useReducer hook"
+    },
+    {
+      "interface": "EventHandler",
+      "implementationKeyword": "handle",
+      "pattern": "(?:const|function)\\s+(handle[A-Z]\\w*)\\s*=?\\s*(?:useCallback\\s*\\()?\\s*(?:async\\s*)?\\(",
+      "description": "Event handler implementation following the handle* naming convention"
+    },
+    {
+      "interface": "React.FC",
+      "implementationKeyword": "FC",
+      "pattern": "(?:const|let)\\s+(\\w+)\\s*:\\s*(?:React\\.)?FC",
+      "description": "Function component typed with React.FC type annotation"
+    }
+  ],
+  "keywords": {
+    "interface": [
+      "React.Component",
+      "React.PureComponent",
+      "React.FC",
+      "React.ForwardRefRenderFunction",
+      "React.ComponentType",
+      "React.MemoExoticComponent",
+      "React.LazyExoticComponent",
+      "React.Context",
+      "React.Reducer",
+      "React.ErrorInfo",
+      "React.RefObject",
+      "React.MutableRefObject"
+    ],
+    "implementation": [
+      "extends Component",
+      "extends PureComponent",
+      "React.memo(",
+      "React.forwardRef(",
+      "React.lazy(",
+      "createContext(",
+      "useContext(",
+      "useReducer(",
+      "componentDidCatch",
+      "getDerivedStateFromError",
+      "useImperativeHandle(",
+      "forwardRef("
+    ]
+  }
+}

package/data/implementation/shadcn.json

@@ -0,0 +1,89 @@
+{
+  "language": "shadcn",
+  "implementationPatterns": [
+    {
+      "name": "ForwardRef Component",
+      "pattern": "const\\s+(\\w+)\\s*=\\s*React\\.forwardRef<",
+      "captureGroup": 1,
+      "description": "React.forwardRef component implementation"
+    },
+    {
+      "name": "Component DisplayName",
+      "pattern": "(\\w+)\\.displayName\\s*=",
+      "captureGroup": 1,
+      "description": "Component displayName assignment for DevTools"
+    },
+    {
+      "name": "CVA Variant Implementation",
+      "pattern": "const\\s+(\\w+Variants?)\\s*=\\s*cva\\(",
+      "captureGroup": 1,
+      "description": "cva() class-variance-authority variant definition"
+    },
+    {
+      "name": "cn() Utility Function",
+      "pattern": "function\\s+(cn)\\(\\.\\.\\.",
+      "captureGroup": 1,
+      "description": "cn() class merging utility function implementation"
+    },
+    {
+      "name": "cn() Arrow Utility",
+      "pattern": "(?:export\\s+)?const\\s+(cn)\\s*=\\s*\\(",
+      "captureGroup": 1,
+      "description": "cn() utility implemented as arrow function"
+    },
+    {
+      "name": "useToast Hook",
+      "pattern": "function\\s+(useToast)\\s*\\(",
+      "captureGroup": 1,
+      "description": "useToast hook implementation for toast notifications"
+    },
+    {
+      "name": "Toast Reducer",
+      "pattern": "(?:const|function)\\s+(\\w*[Rr]educer)\\s*[=(]",
+      "captureGroup": 1,
+      "description": "Toast state reducer implementation"
+    },
+    {
+      "name": "FormField Context Provider",
+      "pattern": "<FormFieldContext\\.Provider\\s+value=\\{([^}]+)\\}",
+      "captureGroup": 1,
+      "description": "FormField context provider wrapping form fields"
+    },
+    {
+      "name": "Custom Hook Implementation",
+      "pattern": "(?:export\\s+)?function\\s+(use\\w+)\\s*\\(",
+      "captureGroup": 1,
+      "description": "Custom React hook implementation"
+    },
+    {
+      "name": "Radix Primitive Wrapper",
+      "pattern": "<(\\w+Primitive)\\b",
+      "captureGroup": 1,
+      "description": "Wrapper around a Radix UI primitive component"
+    },
+    {
+      "name": "DataTable Implementation",
+      "pattern": "function\\s+(DataTable)[<(]",
+      "captureGroup": 1,
+      "description": "DataTable component implementation with TanStack Table"
+    },
+    {
+      "name": "Column Accessor Implementation",
+      "pattern": "(?:accessorKey|accessorFn):\\s*[\"']?(\\w+)",
+      "captureGroup": 1,
+      "description": "DataTable column accessor definition"
+    },
+    {
+      "name": "Form Validation Schema",
+      "pattern": "const\\s+(\\w+Schema)\\s*=\\s*z\\.",
+      "captureGroup": 1,
+      "description": "Zod validation schema implementation for forms"
+    },
+    {
+      "name": "Component Composition with Slot",
+      "pattern": "asChild\\s*(?:\\?|&&)\\s*.*<(Slot)\\b",
+      "captureGroup": 1,
+      "description": "Component composition using Radix Slot for asChild pattern"
+    }
+  ]
+}

package/data/implementation/shell.json

@@ -18,17 +18,73 @@
       "implementationKeyword": "source",
       "pattern": "(?:source|\\.)\\s+([\\w./]+)",
       "description": "Sourcing another script (include)"
+    },
+    {
+      "interface": "callback_pattern",
+      "implementationKeyword": "function",
+      "pattern": "^\\s*(?:function\\s+)?(\\w+_(?:callback|handler|hook))\\s*\\(\\s*\\)",
+      "description": "Functions following callback/handler/hook naming convention"
+    },
+    {
+      "interface": "completion_function",
+      "implementationKeyword": "complete -F",
+      "pattern": "^\\s*(?:function\\s+)?(_\\w+)\\s*\\(\\s*\\).*#.*completion",
+      "description": "Programmable completion functions (typically prefixed with _)"
+    },
+    {
+      "interface": "trap_handler",
+      "implementationKeyword": "trap",
+      "pattern": "^\\s*(?:function\\s+)?(cleanup|on_exit|on_err|handle_\\w+)\\s*\\(\\s*\\)",
+      "description": "Functions used as trap signal handlers"
+    },
+    {
+      "interface": "subcommand_pattern",
+      "implementationKeyword": "case",
+      "pattern": "^\\s*(?:function\\s+)?cmd_(\\w+)\\s*\\(\\s*\\)|^\\s*(?:function\\s+)?subcmd_(\\w+)",
+      "description": "Functions implementing CLI subcommands (cmd_* or subcmd_* prefix)"
+    },
+    {
+      "interface": "Widget",
+      "implementationKeyword": "zle",
+      "pattern": "zle\\s+-N\\s+(\\w+)",
+      "description": "ZLE widget registration"
+    },
+    {
+      "interface": "Completion",
+      "implementationKeyword": "compdef",
+      "pattern": "compdef\\s+(\\w+)",
+      "description": "Completion function binding"
+    },
+    {
+      "interface": "Autoload",
+      "implementationKeyword": "autoload",
+      "pattern": "autoload\\s+(?:-[Uz]+\\s+)*(\\w+)",
+      "description": "Autoloaded function"
     }
   ],
   "keywords": {
     "interface": [
       "function name",
-      "alias"
+      "alias",
+      "callback",
+      "handler",
+      "hook",
+      "plugin",
+      "override",
+      "autoload",
+      "zle -N",
+      "compdef"
     ],
     "implementation": [
       "function...{}",
       "() {}",
-      "alias...="
-    ]
+      "alias...=",
+      "function",
+      "complete -F",
+      "trap",
+      "() {",
+      "autoload -Uz"
+    ],
+    "note": "Bash does not have formal interface/implementation constructs. Patterns here detect convention-based implementations like callback naming and completion functions."
   }
 }

package/data/inlayHints/angular.json

@@ -0,0 +1,24 @@
+{
+  "language": "angular",
+  "inlayHintPatterns": [
+    { "pattern": "(\\w+)\\s*=\\s*inject\\s*\\(\\s*(\\w+)\\s*\\)", "captureGroup": 1, "label": ": ${2}", "kind": 1, "tooltip": "Injected type from inject() call", "position": "after" },
+    { "pattern": "(\\w+)\\s*=\\s*signal\\s*<([^>]+)>\\s*\\(", "captureGroup": 1, "label": ": WritableSignal<${2}>", "kind": 1, "tooltip": "Writable signal type", "position": "after" },
+    { "pattern": "(\\w+)\\s*=\\s*signal\\s*\\(\\s*(['\"])(.+?)\\2\\s*\\)", "captureGroup": 1, "label": ": WritableSignal<string>", "kind": 1, "tooltip": "Signal inferred as string type", "position": "after" },
+    { "pattern": "(\\w+)\\s*=\\s*computed\\s*\\(", "captureGroup": 1, "label": ": Signal<…>", "kind": 1, "tooltip": "Computed signal return type", "position": "after" },
+    { "pattern": "(\\w+)\\s*=\\s*input(?:\\.required)?\\s*<([^>]+)>\\s*\\(", "captureGroup": 1, "label": ": InputSignal<${2}>", "kind": 1, "tooltip": "Signal-based input type", "position": "after" },
+    { "pattern": "(\\w+)\\s*=\\s*output\\s*<([^>]+)>\\s*\\(", "captureGroup": 1, "label": ": OutputEmitterRef<${2}>", "kind": 1, "tooltip": "Signal-based output event type", "position": "after" },
+    { "pattern": "\\|\\s*(\\w+)\\b", "captureGroup": 1, "label": "→ transformed", "kind": 2, "tooltip": "Pipe transform return value", "position": "after" },
+    { "pattern": "new\\s+FormControl\\s*<([^>]+)>\\s*\\(", "captureGroup": 1, "label": "FormControl<${1}>", "kind": 1, "tooltip": "Typed form control value type", "position": "after" },
+    { "pattern": "\\.subscribe\\s*\\(\\s*(\\w+)\\s*=>", "captureGroup": 1, "label": ": Observable emission", "kind": 1, "tooltip": "Observable subscription callback parameter", "position": "after" },
+    { "pattern": "this\\.route\\.(?:params|queryParams|paramMap)\\b", "captureGroup": 0, "label": ": Observable<Params>", "kind": 1, "tooltip": "Route parameter observable type", "position": "after" }
+  ],
+  "typeInferenceRules": [
+    { "pattern": "(\\w+)\\s*=\\s*signal\\s*\\(\\s*(\\d+)\\s*\\)", "inferredType": "WritableSignal<number>", "description": "Numeric literal initializer infers number signal" },
+    { "pattern": "(\\w+)\\s*=\\s*signal\\s*\\(\\s*true|false\\s*\\)", "inferredType": "WritableSignal<boolean>", "description": "Boolean literal initializer infers boolean signal" },
+    { "pattern": "(\\w+)\\s*=\\s*signal\\s*\\(\\s*['\"].*?['\"]\\s*\\)", "inferredType": "WritableSignal<string>", "description": "String literal initializer infers string signal" },
+    { "pattern": "(\\w+)\\s*=\\s*signal\\s*\\(\\s*\\[\\]\\s*\\)", "inferredType": "WritableSignal<any[]>", "description": "Empty array initializer infers array signal" },
+    { "pattern": "(\\w+)\\s*=\\s*inject\\s*\\(\\s*(\\w+)\\s*\\)", "inferredType": "${2}", "description": "inject() call infers the type of the provided token" },
+    { "pattern": "new\\s+FormControl\\s*\\(\\s*['\"].*?['\"]\\s*\\)", "inferredType": "FormControl<string | null>", "description": "FormControl with string initial value" },
+    { "pattern": "new\\s+FormGroup\\s*\\(\\s*\\{", "inferredType": "FormGroup", "description": "FormGroup inferred from object literal controls" }
+  ]
+}

package/data/inlayHints/nestjs.json

@@ -0,0 +1,24 @@
+{
+  "language": "nestjs",
+  "inlayHintPatterns": [
+    { "pattern": "constructor\\((?:private|protected|public)\\s+(?:readonly\\s+)?(\\w+):\\s*(\\w+)", "kind": 1, "label": ": {type}", "position": "after_capture_1", "paddingLeft": true, "description": "Show injected service types" },
+    { "pattern": "@(Body|Param|Query|Headers)\\((?:['\"]([^'\"]+)['\"])?\\)\\s+(\\w+)", "kind": 2, "label": "{param_name}:", "position": "before_capture_3", "paddingRight": true, "description": "Show decorator parameter source" },
+    { "pattern": "(\\w+)\\s*=\\s*(?:await\\s+)?this\\.(\\w+Service)\\.(\\w+)\\(", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Infer service method return type" },
+    { "pattern": "(?:const|let)\\s+(\\w+)\\s*=\\s*(?:await\\s+)?this\\.configService\\.get(?:<[^>]+>)?\\(['\"]([^'\"]+)['\"]\\)", "kind": 1, "label": ": {config_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Config value type hint" },
+    { "pattern": "@HttpCode\\((\\d+)\\)", "kind": 2, "label": "HTTP {status}", "position": "after_capture_1", "paddingLeft": true, "description": "HTTP status code meaning" },
+    { "pattern": "@(Get|Post|Put|Patch|Delete)\\(['\"]([^'\"]*)['\"]\\)", "kind": 2, "label": "{method} {path}", "position": "after_capture_0", "paddingLeft": true, "description": "Full route path hint" },
+    { "pattern": "\\bnew\\s+(\\w+Exception)\\(", "kind": 1, "label": "extends HttpException", "position": "after_capture_1", "paddingLeft": true, "description": "Exception class hierarchy" },
+    { "pattern": "module\\.get<(\\w+)>\\((\\w+)\\)", "kind": 1, "label": ": {type}", "position": "after_capture_0", "paddingLeft": true, "description": "Testing module.get return type" },
+    { "pattern": "(\\w+)\\s*=\\s*(.+)", "kind": 1, "label": ": {inferred_type}", "position": "after_capture_1", "paddingLeft": true, "description": "Variable type inference" }
+  ],
+  "typeInferenceRules": {
+    "string_literal": { "pattern": "['\"].*['\"]", "type": "string" },
+    "number_literal": { "pattern": "\\d+(\\.\\d+)?", "type": "number" },
+    "boolean_literal": { "pattern": "\\b(true|false)\\b", "type": "boolean" },
+    "array_literal": { "pattern": "\\[.*\\]", "type": "array" },
+    "object_literal": { "pattern": "\\{.*\\}", "type": "object" },
+    "null_literal": { "pattern": "\\b(null|undefined)\\b", "type": "null" },
+    "new_instance": { "pattern": "new\\s+(\\w+)\\(", "type": "{capture_1}" },
+    "await_expression": { "pattern": "await\\s+", "type": "Promise<unknown>" }
+  }
+}