claude-brain 0.30.2 → 0.30.3

package/src/knowledge/entity-extractor.ts

@@ -1,443 +1,447 @@
-/**
- * Entity Extractor
- * Rule-based NER using compromise + technology dictionary
- */
-
-import type { EntityType } from './graph/schema'
-
-export interface ExtractedEntity {
-  name: string
-  normalizedName: string
-  type: EntityType
-  confidence: number
-  source: 'dictionary' | 'nlp' | 'rule' | 'model'
-  positions: number[]
-}
-
-const TECH_DICTIONARY: Record<string, { aliases: string[]; type: EntityType }> = {
-  // Languages
-  typescript: { aliases: ['ts', 'typescript', 'type-script'], type: 'technology' },
-  javascript: { aliases: ['js', 'javascript', 'ecmascript', 'es6', 'es2015', 'es2020', 'es2021', 'es2022'], type: 'technology' },
-  python: { aliases: ['py', 'python3', 'python2'], type: 'technology' },
-  rust: { aliases: ['rust-lang', 'rustlang'], type: 'technology' },
-  go: { aliases: ['golang', 'go-lang'], type: 'technology' },
-  java: { aliases: [], type: 'technology' },
-  csharp: { aliases: ['c#', 'c-sharp', 'dotnet', '.net'], type: 'technology' },
-  ruby: { aliases: ['rb'], type: 'technology' },
-  php: { aliases: [], type: 'technology' },
-  swift: { aliases: [], type: 'technology' },
-  kotlin: { aliases: ['kt'], type: 'technology' },
-  scala: { aliases: [], type: 'technology' },
-  elixir: { aliases: [], type: 'technology' },
-  clojure: { aliases: ['clj'], type: 'technology' },
-  haskell: { aliases: ['hs'], type: 'technology' },
-  lua: { aliases: [], type: 'technology' },
-  perl: { aliases: ['pl'], type: 'technology' },
-  r: { aliases: ['r-lang', 'rlang'], type: 'technology' },
-  dart: { aliases: [], type: 'technology' },
-  sql: { aliases: ['mysql', 'postgresql', 'postgres', 'sqlite', 'mssql', 'mariadb'], type: 'technology' },
-  html: { aliases: ['html5'], type: 'technology' },
-  css: { aliases: ['css3', 'scss', 'sass', 'less', 'stylus'], type: 'technology' },
-  graphql: { aliases: ['gql'], type: 'technology' },
-  yaml: { aliases: ['yml'], type: 'technology' },
-  json: { aliases: [], type: 'technology' },
-  markdown: { aliases: ['md'], type: 'technology' },
-  bash: { aliases: ['sh', 'shell', 'zsh', 'fish'], type: 'technology' },
-  c: { aliases: ['c-lang', 'ansi-c'], type: 'technology' },
-  cpp: { aliases: ['c++', 'cplusplus'], type: 'technology' },
-
-  // Frontend Frameworks
-  react: { aliases: ['reactjs', 'react.js', 'react-dom'], type: 'technology' },
-  vue: { aliases: ['vuejs', 'vue.js', 'vue3', 'vue2'], type: 'technology' },
-  angular: { aliases: ['angularjs', 'angular.js', 'ng'], type: 'technology' },
-  svelte: { aliases: ['sveltejs', 'sveltekit'], type: 'technology' },
-  nextjs: { aliases: ['next.js', 'next', 'nextjs'], type: 'technology' },
-  nuxt: { aliases: ['nuxtjs', 'nuxt.js'], type: 'technology' },
-  remix: { aliases: ['remix-run'], type: 'technology' },
-  astro: { aliases: ['astrojs'], type: 'technology' },
-  gatsby: { aliases: ['gatsbyjs'], type: 'technology' },
-  solid: { aliases: ['solidjs', 'solid-js'], type: 'technology' },
-  preact: { aliases: ['preactjs'], type: 'technology' },
-  htmx: { aliases: [], type: 'technology' },
-  jquery: { aliases: [], type: 'technology' },
-
-  // Backend Frameworks
-  express: { aliases: ['expressjs', 'express.js'], type: 'technology' },
-  fastify: { aliases: [], type: 'technology' },
-  hono: { aliases: [], type: 'technology' },
-  koa: { aliases: ['koajs'], type: 'technology' },
-  nestjs: { aliases: ['nest.js', 'nest'], type: 'technology' },
-  django: { aliases: [], type: 'technology' },
-  flask: { aliases: [], type: 'technology' },
-  fastapi: { aliases: ['fast-api'], type: 'technology' },
-  rails: { aliases: ['ruby-on-rails', 'ror'], type: 'technology' },
-  spring: { aliases: ['spring-boot', 'springboot'], type: 'technology' },
-  laravel: { aliases: [], type: 'technology' },
-  phoenix: { aliases: [], type: 'technology' },
-  gin: { aliases: [], type: 'technology' },
-  actix: { aliases: ['actix-web'], type: 'technology' },
-
-  // Databases
-  mongodb: { aliases: ['mongo'], type: 'technology' },
-  redis: { aliases: [], type: 'technology' },
-  elasticsearch: { aliases: ['elastic', 'es'], type: 'technology' },
-  dynamodb: { aliases: ['dynamo'], type: 'technology' },
-  cassandra: { aliases: [], type: 'technology' },
-  neo4j: { aliases: [], type: 'technology' },
-  couchdb: { aliases: ['couch'], type: 'technology' },
-  firebase: { aliases: ['firestore'], type: 'technology' },
-  supabase: { aliases: [], type: 'technology' },
-  prisma: { aliases: [], type: 'technology' },
-  drizzle: { aliases: ['drizzle-orm'], type: 'technology' },
-  sequelize: { aliases: [], type: 'technology' },
-  typeorm: { aliases: [], type: 'technology' },
-  chromadb: { aliases: ['chroma'], type: 'technology' },
-  pinecone: { aliases: [], type: 'technology' },
-  weaviate: { aliases: [], type: 'technology' },
-  qdrant: { aliases: [], type: 'technology' },
-
-  // Cloud & DevOps
-  aws: { aliases: ['amazon-web-services', 'amazon'], type: 'technology' },
-  gcp: { aliases: ['google-cloud', 'google-cloud-platform'], type: 'technology' },
-  azure: { aliases: ['microsoft-azure'], type: 'technology' },
-  docker: { aliases: ['dockerfile', 'docker-compose'], type: 'technology' },
-  kubernetes: { aliases: ['k8s', 'kube'], type: 'technology' },
-  terraform: { aliases: ['tf'], type: 'technology' },
-  ansible: { aliases: [], type: 'technology' },
-  jenkins: { aliases: [], type: 'technology' },
-  github: { aliases: ['gh'], type: 'technology' },
-  gitlab: { aliases: [], type: 'technology' },
-  vercel: { aliases: [], type: 'technology' },
-  netlify: { aliases: [], type: 'technology' },
-  cloudflare: { aliases: ['cf'], type: 'technology' },
-  nginx: { aliases: [], type: 'technology' },
-  caddy: { aliases: [], type: 'technology' },
-
-  // Tools & Libraries
-  webpack: { aliases: [], type: 'technology' },
-  vite: { aliases: [], type: 'technology' },
-  esbuild: { aliases: [], type: 'technology' },
-  rollup: { aliases: ['rollupjs'], type: 'technology' },
-  parcel: { aliases: [], type: 'technology' },
-  turbopack: { aliases: [], type: 'technology' },
-  bun: { aliases: ['bunjs'], type: 'technology' },
-  deno: { aliases: [], type: 'technology' },
-  node: { aliases: ['nodejs', 'node.js'], type: 'technology' },
-  npm: { aliases: [], type: 'technology' },
-  yarn: { aliases: [], type: 'technology' },
-  pnpm: { aliases: [], type: 'technology' },
-  git: { aliases: [], type: 'technology' },
-  jest: { aliases: [], type: 'technology' },
-  vitest: { aliases: [], type: 'technology' },
-  mocha: { aliases: [], type: 'technology' },
-  cypress: { aliases: [], type: 'technology' },
-  playwright: { aliases: [], type: 'technology' },
-  eslint: { aliases: [], type: 'technology' },
-  prettier: { aliases: [], type: 'technology' },
-  biome: { aliases: ['biomejs'], type: 'technology' },
-  tailwind: { aliases: ['tailwindcss', 'tailwind-css'], type: 'technology' },
-  bootstrap: { aliases: [], type: 'technology' },
-  zod: { aliases: [], type: 'technology' },
-  trpc: { aliases: ['t-rpc'], type: 'technology' },
-  grpc: { aliases: ['g-rpc'], type: 'technology' },
-  websocket: { aliases: ['ws', 'websockets'], type: 'technology' },
-  oauth: { aliases: ['oauth2', 'oauth2.0'], type: 'technology' },
-  jwt: { aliases: ['json-web-token'], type: 'technology' },
-  openai: { aliases: ['gpt', 'chatgpt', 'gpt-4'], type: 'technology' },
-  anthropic: { aliases: ['claude', 'claude-ai'], type: 'technology' },
-  langchain: { aliases: [], type: 'technology' },
-  llamaindex: { aliases: ['llama-index'], type: 'technology' },
-  huggingface: { aliases: ['hf', 'hugging-face'], type: 'technology' },
-  tensorflow: { aliases: ['tf'], type: 'technology' },
-  pytorch: { aliases: ['torch'], type: 'technology' },
-  pino: { aliases: [], type: 'technology' },
-  winston: { aliases: [], type: 'technology' },
-  storybook: { aliases: [], type: 'technology' },
-  nx: { aliases: [], type: 'technology' },
-  turborepo: { aliases: [], type: 'technology' },
-  lerna: { aliases: [], type: 'technology' },
-  compromise: { aliases: ['compromise-nlp'], type: 'technology' },
-  minisearch: { aliases: [], type: 'technology' },
-
-  // Concepts
-  microservices: { aliases: ['micro-services', 'microservice'], type: 'concept' },
-  monolith: { aliases: ['monolithic'], type: 'concept' },
-  serverless: { aliases: ['faas', 'lambda'], type: 'concept' },
-  rest: { aliases: ['restful', 'rest-api'], type: 'concept' },
-  api: { aliases: ['apis'], type: 'concept' },
-  ci: { aliases: ['continuous-integration'], type: 'concept' },
-  cd: { aliases: ['continuous-deployment', 'continuous-delivery'], type: 'concept' },
-  tdd: { aliases: ['test-driven-development'], type: 'concept' },
-  bdd: { aliases: ['behavior-driven-development'], type: 'concept' },
-  ddd: { aliases: ['domain-driven-design'], type: 'concept' },
-  cqrs: { aliases: ['command-query-responsibility-segregation'], type: 'concept' },
-  mvc: { aliases: ['model-view-controller'], type: 'concept' },
-  mvvm: { aliases: ['model-view-viewmodel'], type: 'concept' },
-  oop: { aliases: ['object-oriented-programming', 'object-oriented'], type: 'concept' },
-  fp: { aliases: ['functional-programming', 'functional'], type: 'concept' },
-  ssr: { aliases: ['server-side-rendering'], type: 'concept' },
-  ssg: { aliases: ['static-site-generation'], type: 'concept' },
-  spa: { aliases: ['single-page-application', 'single-page-app'], type: 'concept' },
-  pwa: { aliases: ['progressive-web-app'], type: 'concept' },
-  mcp: { aliases: ['model-context-protocol'], type: 'concept' },
-  rag: { aliases: ['retrieval-augmented-generation'], type: 'concept' },
-  embedding: { aliases: ['embeddings', 'vector-embedding'], type: 'concept' },
-  'vector-search': { aliases: ['semantic-search', 'vector-similarity'], type: 'concept' },
-}
-
-// Build reverse lookup: alias → normalized name
-const ALIAS_MAP = new Map<string, string>()
-for (const [normalized, entry] of Object.entries(TECH_DICTIONARY)) {
-  ALIAS_MAP.set(normalized.toLowerCase(), normalized)
-  for (const alias of entry.aliases) {
-    ALIAS_MAP.set(alias.toLowerCase(), normalized)
-  }
-}
-
-// File path regex - handles ./path, ~/path, /path, and relative paths
-const FILE_PATH_REGEX = /(?:^|[\s(,])((?:\.\/|~\/|\/)?(?:[\w-]+\/)+[\w.-]+\.\w+)/g
-// URL regex
-const URL_REGEX = /https?:\/\/[^\s),]+/g
-// Version number regex
-let nlpModule: any = null
-
-async function loadNlp(): Promise<any> {
-  if (!nlpModule) {
-    try {
-      nlpModule = (await import('compromise')).default
-    } catch {
-      nlpModule = null
-    }
-  }
-  return nlpModule
-}
-
-export class EntityExtractor {
-  private nlpLoaded = false
-  private nlp: any = null
-
-  async initialize(): Promise<void> {
-    this.nlp = await loadNlp()
-    this.nlpLoaded = this.nlp !== null
-  }
-
-  extract(text: string): ExtractedEntity[] {
-    const startTime = Date.now()
-    const entities: Map<string, ExtractedEntity> = new Map()
-
-    this.extractFromDictionary(text, entities)
-    this.extractFilePaths(text, entities)
-    this.extractUrls(text, entities)
-    this.extractDates(text, entities)
-
-    if (this.nlpLoaded && this.nlp) {
-      this.extractWithNlp(text, entities)
-    }
-
-    const result = Array.from(entities.values())
-      .sort((a, b) => b.confidence - a.confidence)
-
-    // SLM Phase 1A: Log extraction for training data collection
-    this._logTraining(text, result, startTime)
-
-    return result
-  }
-
-  /**
-   * SLM Phase 1A: Log entity extraction result for training data.
-   */
-  private _logTraining(text: string, entities: ExtractedEntity[], startTime: number): void {
-    try {
-      const { logTrainingData } = require('@/training/data-store')
-      logTrainingData({
-        task: 'entity' as const,
-        input: text,
-        output: JSON.stringify(entities.map(e => ({
-          text: e.name,
-          type: e.type,
-          normalized: e.normalizedName,
-          confidence: e.confidence,
-          source: e.source,
-          positions: e.positions,
-        }))),
-        metadata: JSON.stringify({ count: entities.length, elapsed_ms: Date.now() - startTime }),
-      })
-    } catch {
-      // Non-critical
-    }
-  }
-
-  extractBatch(texts: string[]): ExtractedEntity[][] {
-    return texts.map(text => this.extract(text))
-  }
-
-  private extractFromDictionary(text: string, entities: Map<string, ExtractedEntity>): void {
-    const lowerText = text.toLowerCase()
-    const words = lowerText.split(/[\s,;:()[\]{}"'`|/\\]+/)
-
-    for (const word of words) {
-      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
-      if (cleaned.length < 2) continue
-
-      const normalized = ALIAS_MAP.get(cleaned)
-      if (normalized) {
-        const dictEntry = TECH_DICTIONARY[normalized]
-        if (!dictEntry) continue
-
-        const existing = entities.get(normalized)
-        if (existing) {
-          existing.positions.push(lowerText.indexOf(cleaned))
-          existing.confidence = Math.min(1.0, existing.confidence + 0.05)
-        } else {
-          entities.set(normalized, {
-            name: cleaned,
-            normalizedName: normalized,
-            type: dictEntry.type,
-            confidence: 0.95,
-            source: 'dictionary',
-            positions: [lowerText.indexOf(cleaned)]
-          })
-        }
-      }
-    }
-
-    // Also check multi-word aliases
-    for (const [alias, normalized] of ALIAS_MAP) {
-      if (alias.includes('-') || alias.includes('.') || alias.includes(' ')) {
-        if (lowerText.includes(alias) && !entities.has(normalized)) {
-          const dictEntry = TECH_DICTIONARY[normalized]
-          if (!dictEntry) continue
-
-          entities.set(normalized, {
-            name: alias,
-            normalizedName: normalized,
-            type: dictEntry.type,
-            confidence: 0.95,
-            source: 'dictionary',
-            positions: [lowerText.indexOf(alias)]
-          })
-        }
-      }
-    }
-  }
-
-  private extractFilePaths(text: string, entities: Map<string, ExtractedEntity>): void {
-    let match: RegExpExecArray | null
-    const regex = new RegExp(FILE_PATH_REGEX.source, FILE_PATH_REGEX.flags)
-
-    while ((match = regex.exec(text)) !== null) {
-      const filePath = match[1]!.trim()
-      if (filePath.length < 4) continue
-
-      const key = `file:${filePath}`
-      if (!entities.has(key)) {
-        entities.set(key, {
-          name: filePath,
-          normalizedName: filePath,
-          type: 'file',
-          confidence: 0.85,
-          source: 'rule',
-          positions: [match.index]
-        })
-      }
-    }
-  }
-
-  private extractUrls(text: string, entities: Map<string, ExtractedEntity>): void {
-    let match: RegExpExecArray | null
-    const regex = new RegExp(URL_REGEX.source, URL_REGEX.flags)
-
-    while ((match = regex.exec(text)) !== null) {
-      const url = match[0]
-      const key = `url:${url}`
-      if (!entities.has(key)) {
-        entities.set(key, {
-          name: url,
-          normalizedName: url,
-          type: 'file',
-          confidence: 0.9,
-          source: 'rule',
-          positions: [match.index]
-        })
-      }
-    }
-  }
-
-  private extractDates(text: string, entities: Map<string, ExtractedEntity>): void {
-    // ISO date pattern
-    const isoDateRegex = /\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/g
-    let match: RegExpExecArray | null
-
-    while ((match = isoDateRegex.exec(text)) !== null) {
-      const dateStr = match[0]
-      const key = `date:${dateStr}`
-      if (!entities.has(key)) {
-        entities.set(key, {
-          name: dateStr,
-          normalizedName: dateStr,
-          type: 'date',
-          confidence: 0.9,
-          source: 'rule',
-          positions: [match.index]
-        })
-      }
-    }
-  }
-
-  private extractWithNlp(text: string, entities: Map<string, ExtractedEntity>): void {
-    try {
-      const doc = this.nlp(text)
-
-      // Extract people
-      const people = doc.people()
-      if (people && people.length > 0) {
-        for (const person of people.out('array') as string[]) {
-          const cleaned = person.trim()
-          if (cleaned.length < 2) continue
-          const key = `person:${cleaned.toLowerCase()}`
-          if (!entities.has(key)) {
-            entities.set(key, {
-              name: cleaned,
-              normalizedName: cleaned.toLowerCase(),
-              type: 'person',
-              confidence: 0.7,
-              source: 'nlp',
-              positions: [text.indexOf(cleaned)]
-            })
-          }
-        }
-      }
-
-      // Extract organizations
-      const orgs = doc.organizations()
-      if (orgs && orgs.length > 0) {
-        for (const org of orgs.out('array') as string[]) {
-          const cleaned = org.trim()
-          if (cleaned.length < 2) continue
-          // Check if it's already a known technology
-          const normalizedCheck = ALIAS_MAP.get(cleaned.toLowerCase())
-          if (normalizedCheck) continue
-
-          const key = `org:${cleaned.toLowerCase()}`
-          if (!entities.has(key)) {
-            entities.set(key, {
-              name: cleaned,
-              normalizedName: cleaned.toLowerCase(),
-              type: 'concept',
-              confidence: 0.65,
-              source: 'nlp',
-              positions: [text.indexOf(cleaned)]
-            })
-          }
-        }
-      }
-    } catch {
-      // NLP extraction failure is non-critical
-    }
-  }
-
-  static normalizeEntityName(name: string): string {
-    const lower = name.toLowerCase().trim()
-    return ALIAS_MAP.get(lower) || lower
-  }
-}
+/**
+ * Entity Extractor
+ * Rule-based NER using compromise + technology dictionary
+ */
+
+import type { EntityType } from './graph/schema'
+
+export interface ExtractedEntity {
+  name: string
+  normalizedName: string
+  type: EntityType
+  confidence: number
+  source: 'dictionary' | 'nlp' | 'rule' | 'model'
+  positions: number[]
+}
+
+const TECH_DICTIONARY: Record<string, { aliases: string[]; type: EntityType }> = {
+  // Languages
+  typescript: { aliases: ['ts', 'typescript', 'type-script'], type: 'technology' },
+  javascript: { aliases: ['js', 'javascript', 'ecmascript', 'es6', 'es2015', 'es2020', 'es2021', 'es2022'], type: 'technology' },
+  python: { aliases: ['py', 'python3', 'python2'], type: 'technology' },
+  rust: { aliases: ['rust-lang', 'rustlang'], type: 'technology' },
+  go: { aliases: ['golang', 'go-lang'], type: 'technology' },
+  java: { aliases: [], type: 'technology' },
+  csharp: { aliases: ['c#', 'c-sharp', 'dotnet', '.net'], type: 'technology' },
+  ruby: { aliases: ['rb'], type: 'technology' },
+  php: { aliases: [], type: 'technology' },
+  swift: { aliases: [], type: 'technology' },
+  kotlin: { aliases: ['kt'], type: 'technology' },
+  scala: { aliases: [], type: 'technology' },
+  elixir: { aliases: [], type: 'technology' },
+  clojure: { aliases: ['clj'], type: 'technology' },
+  haskell: { aliases: ['hs'], type: 'technology' },
+  lua: { aliases: [], type: 'technology' },
+  perl: { aliases: ['pl'], type: 'technology' },
+  r: { aliases: ['r-lang', 'rlang'], type: 'technology' },
+  dart: { aliases: [], type: 'technology' },
+  sql: { aliases: ['mysql', 'postgresql', 'postgres', 'sqlite', 'mssql', 'mariadb'], type: 'technology' },
+  html: { aliases: ['html5'], type: 'technology' },
+  css: { aliases: ['css3', 'scss', 'sass', 'less', 'stylus'], type: 'technology' },
+  graphql: { aliases: ['gql'], type: 'technology' },
+  yaml: { aliases: ['yml'], type: 'technology' },
+  json: { aliases: [], type: 'technology' },
+  markdown: { aliases: ['md'], type: 'technology' },
+  bash: { aliases: ['sh', 'shell', 'zsh', 'fish'], type: 'technology' },
+  c: { aliases: ['c-lang', 'ansi-c'], type: 'technology' },
+  cpp: { aliases: ['c++', 'cplusplus'], type: 'technology' },
+
+  // Frontend Frameworks
+  react: { aliases: ['reactjs', 'react.js', 'react-dom'], type: 'technology' },
+  vue: { aliases: ['vuejs', 'vue.js', 'vue3', 'vue2'], type: 'technology' },
+  angular: { aliases: ['angularjs', 'angular.js', 'ng'], type: 'technology' },
+  svelte: { aliases: ['sveltejs', 'sveltekit'], type: 'technology' },
+  nextjs: { aliases: ['next.js', 'next', 'nextjs'], type: 'technology' },
+  nuxt: { aliases: ['nuxtjs', 'nuxt.js'], type: 'technology' },
+  remix: { aliases: ['remix-run'], type: 'technology' },
+  astro: { aliases: ['astrojs'], type: 'technology' },
+  gatsby: { aliases: ['gatsbyjs'], type: 'technology' },
+  solid: { aliases: ['solidjs', 'solid-js'], type: 'technology' },
+  preact: { aliases: ['preactjs'], type: 'technology' },
+  htmx: { aliases: [], type: 'technology' },
+  jquery: { aliases: [], type: 'technology' },
+
+  // Backend Frameworks
+  express: { aliases: ['expressjs', 'express.js'], type: 'technology' },
+  fastify: { aliases: [], type: 'technology' },
+  hono: { aliases: [], type: 'technology' },
+  koa: { aliases: ['koajs'], type: 'technology' },
+  nestjs: { aliases: ['nest.js', 'nest'], type: 'technology' },
+  django: { aliases: [], type: 'technology' },
+  flask: { aliases: [], type: 'technology' },
+  fastapi: { aliases: ['fast-api'], type: 'technology' },
+  rails: { aliases: ['ruby-on-rails', 'ror'], type: 'technology' },
+  spring: { aliases: ['spring-boot', 'springboot'], type: 'technology' },
+  laravel: { aliases: [], type: 'technology' },
+  phoenix: { aliases: [], type: 'technology' },
+  gin: { aliases: [], type: 'technology' },
+  actix: { aliases: ['actix-web'], type: 'technology' },
+
+  // Databases
+  mongodb: { aliases: ['mongo'], type: 'technology' },
+  redis: { aliases: [], type: 'technology' },
+  elasticsearch: { aliases: ['elastic', 'es'], type: 'technology' },
+  dynamodb: { aliases: ['dynamo'], type: 'technology' },
+  cassandra: { aliases: [], type: 'technology' },
+  neo4j: { aliases: [], type: 'technology' },
+  couchdb: { aliases: ['couch'], type: 'technology' },
+  firebase: { aliases: ['firestore'], type: 'technology' },
+  supabase: { aliases: [], type: 'technology' },
+  prisma: { aliases: [], type: 'technology' },
+  drizzle: { aliases: ['drizzle-orm'], type: 'technology' },
+  sequelize: { aliases: [], type: 'technology' },
+  typeorm: { aliases: [], type: 'technology' },
+  chromadb: { aliases: ['chroma'], type: 'technology' },
+  pinecone: { aliases: [], type: 'technology' },
+  weaviate: { aliases: [], type: 'technology' },
+  qdrant: { aliases: [], type: 'technology' },
+
+  // Cloud & DevOps
+  aws: { aliases: ['amazon-web-services', 'amazon'], type: 'technology' },
+  gcp: { aliases: ['google-cloud', 'google-cloud-platform'], type: 'technology' },
+  azure: { aliases: ['microsoft-azure'], type: 'technology' },
+  docker: { aliases: ['dockerfile', 'docker-compose'], type: 'technology' },
+  kubernetes: { aliases: ['k8s', 'kube'], type: 'technology' },
+  terraform: { aliases: ['tf'], type: 'technology' },
+  ansible: { aliases: [], type: 'technology' },
+  jenkins: { aliases: [], type: 'technology' },
+  github: { aliases: ['gh'], type: 'technology' },
+  gitlab: { aliases: [], type: 'technology' },
+  vercel: { aliases: [], type: 'technology' },
+  netlify: { aliases: [], type: 'technology' },
+  cloudflare: { aliases: ['cf'], type: 'technology' },
+  nginx: { aliases: [], type: 'technology' },
+  caddy: { aliases: [], type: 'technology' },
+
+  // Tools & Libraries
+  webpack: { aliases: [], type: 'technology' },
+  vite: { aliases: [], type: 'technology' },
+  esbuild: { aliases: [], type: 'technology' },
+  rollup: { aliases: ['rollupjs'], type: 'technology' },
+  parcel: { aliases: [], type: 'technology' },
+  turbopack: { aliases: [], type: 'technology' },
+  bun: { aliases: ['bunjs'], type: 'technology' },
+  deno: { aliases: [], type: 'technology' },
+  node: { aliases: ['nodejs', 'node.js'], type: 'technology' },
+  npm: { aliases: [], type: 'technology' },
+  yarn: { aliases: [], type: 'technology' },
+  pnpm: { aliases: [], type: 'technology' },
+  git: { aliases: [], type: 'technology' },
+  jest: { aliases: [], type: 'technology' },
+  vitest: { aliases: [], type: 'technology' },
+  mocha: { aliases: [], type: 'technology' },
+  cypress: { aliases: [], type: 'technology' },
+  playwright: { aliases: [], type: 'technology' },
+  eslint: { aliases: [], type: 'technology' },
+  prettier: { aliases: [], type: 'technology' },
+  biome: { aliases: ['biomejs'], type: 'technology' },
+  tailwind: { aliases: ['tailwindcss', 'tailwind-css'], type: 'technology' },
+  bootstrap: { aliases: [], type: 'technology' },
+  zod: { aliases: [], type: 'technology' },
+  trpc: { aliases: ['t-rpc'], type: 'technology' },
+  grpc: { aliases: ['g-rpc'], type: 'technology' },
+  websocket: { aliases: ['ws', 'websockets'], type: 'technology' },
+  oauth: { aliases: ['oauth2', 'oauth2.0'], type: 'technology' },
+  jwt: { aliases: ['json-web-token'], type: 'technology' },
+  openai: { aliases: ['gpt', 'chatgpt', 'gpt-4'], type: 'technology' },
+  anthropic: { aliases: ['claude', 'claude-ai'], type: 'technology' },
+  langchain: { aliases: [], type: 'technology' },
+  llamaindex: { aliases: ['llama-index'], type: 'technology' },
+  huggingface: { aliases: ['hf', 'hugging-face'], type: 'technology' },
+  tensorflow: { aliases: ['tf'], type: 'technology' },
+  pytorch: { aliases: ['torch'], type: 'technology' },
+  pino: { aliases: [], type: 'technology' },
+  winston: { aliases: [], type: 'technology' },
+  storybook: { aliases: [], type: 'technology' },
+  nx: { aliases: [], type: 'technology' },
+  turborepo: { aliases: [], type: 'technology' },
+  lerna: { aliases: [], type: 'technology' },
+  compromise: { aliases: ['compromise-nlp'], type: 'technology' },
+  minisearch: { aliases: [], type: 'technology' },
+
+  // Concepts
+  microservices: { aliases: ['micro-services', 'microservice'], type: 'concept' },
+  monolith: { aliases: ['monolithic'], type: 'concept' },
+  serverless: { aliases: ['faas', 'lambda'], type: 'concept' },
+  rest: { aliases: ['restful', 'rest-api'], type: 'concept' },
+  api: { aliases: ['apis'], type: 'concept' },
+  ci: { aliases: ['continuous-integration'], type: 'concept' },
+  cd: { aliases: ['continuous-deployment', 'continuous-delivery'], type: 'concept' },
+  tdd: { aliases: ['test-driven-development'], type: 'concept' },
+  bdd: { aliases: ['behavior-driven-development'], type: 'concept' },
+  ddd: { aliases: ['domain-driven-design'], type: 'concept' },
+  cqrs: { aliases: ['command-query-responsibility-segregation'], type: 'concept' },
+  mvc: { aliases: ['model-view-controller'], type: 'concept' },
+  mvvm: { aliases: ['model-view-viewmodel'], type: 'concept' },
+  oop: { aliases: ['object-oriented-programming', 'object-oriented'], type: 'concept' },
+  fp: { aliases: ['functional-programming', 'functional'], type: 'concept' },
+  ssr: { aliases: ['server-side-rendering'], type: 'concept' },
+  ssg: { aliases: ['static-site-generation'], type: 'concept' },
+  spa: { aliases: ['single-page-application', 'single-page-app'], type: 'concept' },
+  pwa: { aliases: ['progressive-web-app'], type: 'concept' },
+  mcp: { aliases: ['model-context-protocol'], type: 'concept' },
+  rag: { aliases: ['retrieval-augmented-generation'], type: 'concept' },
+  embedding: { aliases: ['embeddings', 'vector-embedding'], type: 'concept' },
+  'vector-search': { aliases: ['semantic-search', 'vector-similarity'], type: 'concept' },
+}
+
+// Build reverse lookup: alias → normalized name
+const ALIAS_MAP = new Map<string, string>()
+for (const [normalized, entry] of Object.entries(TECH_DICTIONARY)) {
+  ALIAS_MAP.set(normalized.toLowerCase(), normalized)
+  for (const alias of entry.aliases) {
+    ALIAS_MAP.set(alias.toLowerCase(), normalized)
+  }
+}
+
+// File path regex - handles ./path, ~/path, /path, and relative paths
+const FILE_PATH_REGEX = /(?:^|[\s(,])((?:\.\/|~\/|\/)?(?:[\w-]+\/)+[\w.-]+\.\w+)/g
+// URL regex
+const URL_REGEX = /https?:\/\/[^\s),]+/g
+// Version number regex
+let nlpModule: unknown = null
+
+async function loadNlp(): Promise<unknown> {
+  if (!nlpModule) {
+    try {
+      nlpModule = (await import('compromise')).default
+    } catch {
+      nlpModule = null
+    }
+  }
+  return nlpModule
+}
+
+export class EntityExtractor {
+  private nlpLoaded = false
+  private nlp: unknown = null
+
+  async initialize(): Promise<void> {
+    this.nlp = await loadNlp()
+    this.nlpLoaded = this.nlp !== null
+  }
+
+  extract(text: string): ExtractedEntity[] {
+    const startTime = Date.now()
+    const entities: Map<string, ExtractedEntity> = new Map()
+
+    this.extractFromDictionary(text, entities)
+    this.extractFilePaths(text, entities)
+    this.extractUrls(text, entities)
+    this.extractDates(text, entities)
+
+    if (this.nlpLoaded && this.nlp) {
+      this.extractWithNlp(text, entities)
+    }
+
+    const result = Array.from(entities.values())
+      .sort((a, b) => b.confidence - a.confidence)
+
+    // SLM Phase 1A: Log extraction for training data collection
+    this._logTraining(text, result, startTime)
+
+    return result
+  }
+
+  /**
+   * SLM Phase 1A: Log entity extraction result for training data.
+   */
+  private _logTraining(text: string, entities: ExtractedEntity[], startTime: number): void {
+    try {
+      const { logTrainingData } = require('@/training/data-store')
+      logTrainingData({
+        task: 'entity' as const,
+        input: text,
+        output: JSON.stringify(entities.map(e => ({
+          text: e.name,
+          type: e.type,
+          normalized: e.normalizedName,
+          confidence: e.confidence,
+          source: e.source,
+          positions: e.positions,
+        }))),
+        metadata: JSON.stringify({ count: entities.length, elapsed_ms: Date.now() - startTime }),
+      })
+    } catch {
+      // Non-critical
+    }
+  }
+
+  extractBatch(texts: string[]): ExtractedEntity[][] {
+    return texts.map(text => this.extract(text))
+  }
+
+  private extractFromDictionary(text: string, entities: Map<string, ExtractedEntity>): void {
+    const lowerText = text.toLowerCase()
+    const words = lowerText.split(/[\s,;:()[\]{}"'`|/\\]+/)
+
+    for (const word of words) {
+      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+      if (cleaned.length < 2) continue
+
+      const normalized = ALIAS_MAP.get(cleaned)
+      if (normalized) {
+        const dictEntry = TECH_DICTIONARY[normalized]
+        if (!dictEntry) continue
+
+        const existing = entities.get(normalized)
+        if (existing) {
+          existing.positions.push(lowerText.indexOf(cleaned))
+          existing.confidence = Math.min(1.0, existing.confidence + 0.05)
+        } else {
+          entities.set(normalized, {
+            name: cleaned,
+            normalizedName: normalized,
+            type: dictEntry.type,
+            confidence: 0.95,
+            source: 'dictionary',
+            positions: [lowerText.indexOf(cleaned)]
+          })
+        }
+      }
+    }
+
+    // Also check multi-word aliases
+    for (const [alias, normalized] of ALIAS_MAP) {
+      if (alias.includes('-') || alias.includes('.') || alias.includes(' ')) {
+        if (lowerText.includes(alias) && !entities.has(normalized)) {
+          const dictEntry = TECH_DICTIONARY[normalized]
+          if (!dictEntry) continue
+
+          entities.set(normalized, {
+            name: alias,
+            normalizedName: normalized,
+            type: dictEntry.type,
+            confidence: 0.95,
+            source: 'dictionary',
+            positions: [lowerText.indexOf(alias)]
+          })
+        }
+      }
+    }
+  }
+
+  private extractFilePaths(text: string, entities: Map<string, ExtractedEntity>): void {
+    let match: RegExpExecArray | null
+    const regex = new RegExp(FILE_PATH_REGEX.source, FILE_PATH_REGEX.flags)
+
+    while ((match = regex.exec(text)) !== null) {
+      const filePath = match[1]!.trim()
+      if (filePath.length < 4) continue
+
+      const key = `file:${filePath}`
+      if (!entities.has(key)) {
+        entities.set(key, {
+          name: filePath,
+          normalizedName: filePath,
+          type: 'file',
+          confidence: 0.85,
+          source: 'rule',
+          positions: [match.index]
+        })
+      }
+    }
+  }
+
+  private extractUrls(text: string, entities: Map<string, ExtractedEntity>): void {
+    let match: RegExpExecArray | null
+    const regex = new RegExp(URL_REGEX.source, URL_REGEX.flags)
+
+    while ((match = regex.exec(text)) !== null) {
+      const url = match[0]
+      const key = `url:${url}`
+      if (!entities.has(key)) {
+        entities.set(key, {
+          name: url,
+          normalizedName: url,
+          type: 'file',
+          confidence: 0.9,
+          source: 'rule',
+          positions: [match.index]
+        })
+      }
+    }
+  }
+
+  private extractDates(text: string, entities: Map<string, ExtractedEntity>): void {
+    // ISO date pattern
+    const isoDateRegex = /\b\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/g
+    let match: RegExpExecArray | null
+
+    while ((match = isoDateRegex.exec(text)) !== null) {
+      const dateStr = match[0]
+      const key = `date:${dateStr}`
+      if (!entities.has(key)) {
+        entities.set(key, {
+          name: dateStr,
+          normalizedName: dateStr,
+          type: 'date',
+          confidence: 0.9,
+          source: 'rule',
+          positions: [match.index]
+        })
+      }
+    }
+  }
+
+  private extractWithNlp(text: string, entities: Map<string, ExtractedEntity>): void {
+    try {
+      const nlpFn = this.nlp as (text: string) => {
+        people(): { length: number; out(format: string): unknown }
+        organizations(): { length: number; out(format: string): unknown }
+      }
+      const doc = nlpFn(text)
+
+      // Extract people
+      const people = doc.people()
+      if (people && people.length > 0) {
+        for (const person of people.out('array') as string[]) {
+          const cleaned = person.trim()
+          if (cleaned.length < 2) continue
+          const key = `person:${cleaned.toLowerCase()}`
+          if (!entities.has(key)) {
+            entities.set(key, {
+              name: cleaned,
+              normalizedName: cleaned.toLowerCase(),
+              type: 'person',
+              confidence: 0.7,
+              source: 'nlp',
+              positions: [text.indexOf(cleaned)]
+            })
+          }
+        }
+      }
+
+      // Extract organizations
+      const orgs = doc.organizations()
+      if (orgs && orgs.length > 0) {
+        for (const org of orgs.out('array') as string[]) {
+          const cleaned = org.trim()
+          if (cleaned.length < 2) continue
+          // Check if it's already a known technology
+          const normalizedCheck = ALIAS_MAP.get(cleaned.toLowerCase())
+          if (normalizedCheck) continue
+
+          const key = `org:${cleaned.toLowerCase()}`
+          if (!entities.has(key)) {
+            entities.set(key, {
+              name: cleaned,
+              normalizedName: cleaned.toLowerCase(),
+              type: 'concept',
+              confidence: 0.65,
+              source: 'nlp',
+              positions: [text.indexOf(cleaned)]
+            })
+          }
+        }
+      }
+    } catch {
+      // NLP extraction failure is non-critical
+    }
+  }
+
+  static normalizeEntityName(name: string): string {
+    const lower = name.toLowerCase().trim()
+    return ALIAS_MAP.get(lower) || lower
+  }
+}