bluera-knowledge 0.13.3 → 0.14.1

package/tests/fixtures/corpus/VERSION.md

@@ -1,25 +0,0 @@
-# Test Corpus Version
-
-## Current Version: 3.0.0
-
-## Contents
-- **oss-repos/vue**: Vue.js core repository (~593 files) - complete source
-- **oss-repos/express**: Express.js repository (~206 files) - complete source
-- **oss-repos/hono**: Hono v4.6.0 (~191 files) - complete source
-- **documentation/**: Express.js and Node.js excerpts
-- **articles/**: Technical articles (React hooks, TypeScript, JWT)
-
-## Last Updated
-2025-12-18
-
-## Change Log
-- v3.0.0: Replaced sample files with full Vue.js and Express.js repositories
-- v2.0.0: Replaced Zod with Vue.js and Express.js for broader framework coverage
-- v1.0.0: Initial corpus with Zod, Hono, docs, and articles
-
-## Maintenance
-When updating corpus:
-1. Update version number above
-2. Update contents list
-3. Run `npm run test:corpus:index` to rebuild index
-4. Run `npm run test:quality -- --update-baseline` to set new baseline

package/tests/fixtures/corpus/articles/jwt-authentication.md

@@ -1,97 +0,0 @@
-# JWT Authentication in Node.js: A Complete Guide
-
-## What is JWT?
-
-JSON Web Tokens (JWT) are an open standard (RFC 7519) for securely transmitting information between parties as a JSON object. JWTs are commonly used for authentication and authorization.
-
-## Structure of a JWT
-
-A JWT consists of three parts separated by dots:
-
-```
-header.payload.signature
-```
-
-- **Header**: Contains the token type and signing algorithm
-- **Payload**: Contains claims (user data)
-- **Signature**: Verifies the token hasn't been tampered with
-
-## Implementing JWT Authentication
-
-### Installation
-
-```bash
-npm install jsonwebtoken bcryptjs
-```
-
-### Creating Tokens
-
-```javascript
-const jwt = require('jsonwebtoken')
-
-function generateAccessToken(user) {
-  return jwt.sign(
-    { userId: user.id, email: user.email },
-    process.env.JWT_SECRET,
-    { expiresIn: '15m' }
-  )
-}
-
-function generateRefreshToken(user) {
-  return jwt.sign(
-    { userId: user.id },
-    process.env.JWT_REFRESH_SECRET,
-    { expiresIn: '7d' }
-  )
-}
-```
-
-### Verifying Tokens
-
-```javascript
-function authenticateToken(req, res, next) {
-  const authHeader = req.headers['authorization']
-  const token = authHeader && authHeader.split(' ')[1]
-
-  if (!token) {
-    return res.status(401).json({ error: 'Access token required' })
-  }
-
-  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
-    if (err) {
-      return res.status(403).json({ error: 'Invalid or expired token' })
-    }
-    req.user = user
-    next()
-  })
-}
-```
-
-### Refresh Token Flow
-
-```javascript
-app.post('/token/refresh', (req, res) => {
-  const { refreshToken } = req.body
-
-  if (!refreshToken) {
-    return res.status(401).json({ error: 'Refresh token required' })
-  }
-
-  jwt.verify(refreshToken, process.env.JWT_REFRESH_SECRET, (err, user) => {
-    if (err) {
-      return res.status(403).json({ error: 'Invalid refresh token' })
-    }
-
-    const accessToken = generateAccessToken({ id: user.userId })
-    res.json({ accessToken })
-  })
-})
-```
-
-## Security Best Practices
-
-1. **Use short expiration times** for access tokens (15 minutes)
-2. **Store refresh tokens securely** (httpOnly cookies)
-3. **Implement token revocation** for logout
-4. **Use strong secrets** (at least 256 bits)
-5. **Always use HTTPS** in production

package/tests/fixtures/corpus/articles/react-hooks-patterns.md

@@ -1,127 +0,0 @@
-# React Hooks Patterns and Best Practices
-
-## Custom Hooks
-
-Custom hooks let you extract component logic into reusable functions.
-
-### useLocalStorage
-
-```typescript
-function useLocalStorage<T>(key: string, initialValue: T) {
-  const [storedValue, setStoredValue] = useState<T>(() => {
-    try {
-      const item = window.localStorage.getItem(key)
-      return item ? JSON.parse(item) : initialValue
-    } catch (error) {
-      return initialValue
-    }
-  })
-
-  const setValue = (value: T | ((val: T) => T)) => {
-    try {
-      const valueToStore = value instanceof Function ? value(storedValue) : value
-      setStoredValue(valueToStore)
-      window.localStorage.setItem(key, JSON.stringify(valueToStore))
-    } catch (error) {
-      console.error(error)
-    }
-  }
-
-  return [storedValue, setValue] as const
-}
-```
-
-### useDebounce
-
-```typescript
-function useDebounce<T>(value: T, delay: number): T {
-  const [debouncedValue, setDebouncedValue] = useState(value)
-
-  useEffect(() => {
-    const timer = setTimeout(() => {
-      setDebouncedValue(value)
-    }, delay)
-
-    return () => clearTimeout(timer)
-  }, [value, delay])
-
-  return debouncedValue
-}
-
-// Usage
-function SearchComponent() {
-  const [query, setQuery] = useState('')
-  const debouncedQuery = useDebounce(query, 300)
-
-  useEffect(() => {
-    if (debouncedQuery) {
-      searchAPI(debouncedQuery)
-    }
-  }, [debouncedQuery])
-}
-```
-
-### useFetch
-
-```typescript
-interface FetchState<T> {
-  data: T | null
-  loading: boolean
-  error: Error | null
-}
-
-function useFetch<T>(url: string): FetchState<T> {
-  const [state, setState] = useState<FetchState<T>>({
-    data: null,
-    loading: true,
-    error: null,
-  })
-
-  useEffect(() => {
-    const controller = new AbortController()
-
-    async function fetchData() {
-      try {
-        setState(prev => ({ ...prev, loading: true }))
-        const response = await fetch(url, { signal: controller.signal })
-        if (!response.ok) throw new Error(response.statusText)
-        const data = await response.json()
-        setState({ data, loading: false, error: null })
-      } catch (error) {
-        if (error.name !== 'AbortError') {
-          setState({ data: null, loading: false, error })
-        }
-      }
-    }
-
-    fetchData()
-    return () => controller.abort()
-  }, [url])
-
-  return state
-}
-```
-
-## Rules of Hooks
-
-1. **Only call hooks at the top level** - not inside loops, conditions, or nested functions
-2. **Only call hooks from React functions** - components or custom hooks
-3. **Name custom hooks with "use" prefix** - enables linting rules
-
-## Performance Patterns
-
-### useMemo for expensive calculations
-
-```typescript
-const expensiveResult = useMemo(() => {
-  return computeExpensiveValue(a, b)
-}, [a, b])
-```
-
-### useCallback for stable function references
-
-```typescript
-const handleClick = useCallback(() => {
-  doSomething(id)
-}, [id])
-```

package/tests/fixtures/corpus/articles/typescript-generics.md

@@ -1,111 +0,0 @@
-# TypeScript Generics: From Basics to Advanced Patterns
-
-## Why Generics?
-
-Generics allow you to write reusable code that works with multiple types while maintaining type safety.
-
-## Basic Generic Functions
-
-```typescript
-// Without generics - loses type information
-function identity(arg: any): any {
-  return arg
-}
-
-// With generics - preserves type
-function identity<T>(arg: T): T {
-  return arg
-}
-
-const str = identity<string>('hello') // string
-const num = identity(42) // number (inferred)
-```
-
-## Generic Constraints
-
-Constrain generics to types with specific properties:
-
-```typescript
-interface HasLength {
-  length: number
-}
-
-function logLength<T extends HasLength>(arg: T): T {
-  console.log(arg.length)
-  return arg
-}
-
-logLength('hello') // OK
-logLength([1, 2, 3]) // OK
-logLength(123) // Error: number doesn't have length
-```
-
-## Generic Interfaces
-
-```typescript
-interface Repository<T> {
-  find(id: string): Promise<T | null>
-  findAll(): Promise<T[]>
-  create(data: Omit<T, 'id'>): Promise<T>
-  update(id: string, data: Partial<T>): Promise<T>
-  delete(id: string): Promise<void>
-}
-
-interface User {
-  id: string
-  name: string
-  email: string
-}
-
-class UserRepository implements Repository<User> {
-  async find(id: string): Promise<User | null> {
-    // implementation
-  }
-  // ... other methods
-}
-```
-
-## Conditional Types
-
-```typescript
-type IsArray<T> = T extends any[] ? true : false
-
-type A = IsArray<string[]> // true
-type B = IsArray<number>   // false
-
-// Extract element type from array
-type ElementType<T> = T extends (infer E)[] ? E : never
-
-type C = ElementType<string[]> // string
-```
-
-## Mapped Types
-
-```typescript
-type Readonly<T> = {
-  readonly [K in keyof T]: T[K]
-}
-
-type Partial<T> = {
-  [K in keyof T]?: T[K]
-}
-
-type Required<T> = {
-  [K in keyof T]-?: T[K]
-}
-```
-
-## Utility Type Patterns
-
-```typescript
-// Make specific keys optional
-type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
-
-// Make specific keys required
-type RequiredBy<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>
-
-// Deep partial
-type DeepPartial<T> = {
-  [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K]
-}
-```

package/tests/fixtures/corpus/documentation/express-middleware.md

@@ -1,71 +0,0 @@
-# Express Middleware Guide
-
-## What is Middleware?
-
-Middleware functions are functions that have access to the request object (`req`), the response object (`res`), and the `next` function in the application's request-response cycle.
-
-Middleware functions can:
-- Execute any code
-- Make changes to the request and response objects
-- End the request-response cycle
-- Call the next middleware in the stack
-
-## Application-level Middleware
-
-Bind application-level middleware to an instance of the app object using `app.use()` and `app.METHOD()`.
-
-```javascript
-const express = require('express')
-const app = express()
-
-// Middleware with no mount path - executed for every request
-app.use((req, res, next) => {
-  console.log('Time:', Date.now())
-  next()
-})
-
-// Middleware mounted on /user/:id
-app.use('/user/:id', (req, res, next) => {
-  console.log('Request Type:', req.method)
-  next()
-})
-```
-
-## Error-handling Middleware
-
-Error-handling middleware always takes four arguments:
-
-```javascript
-app.use((err, req, res, next) => {
-  console.error(err.stack)
-  res.status(500).send('Something broke!')
-})
-```
-
-## Built-in Middleware
-
-Express has built-in middleware functions:
-
-- `express.static` - serves static assets
-- `express.json` - parses JSON payloads
-- `express.urlencoded` - parses URL-encoded payloads
-
-```javascript
-app.use(express.json())
-app.use(express.urlencoded({ extended: true }))
-app.use(express.static('public'))
-```
-
-## Third-party Middleware
-
-Common third-party middleware:
-
-```javascript
-const cors = require('cors')
-const helmet = require('helmet')
-const morgan = require('morgan')
-
-app.use(cors())
-app.use(helmet())
-app.use(morgan('dev'))
-```

package/tests/fixtures/corpus/documentation/express-routing.md

@@ -1,83 +0,0 @@
-# Express Routing Guide
-
-## Basic Routing
-
-Routing refers to how an application's endpoints (URIs) respond to client requests.
-
-```javascript
-const express = require('express')
-const app = express()
-
-// respond with "hello world" when a GET request is made to the homepage
-app.get('/', (req, res) => {
-  res.send('hello world')
-})
-
-// POST method route
-app.post('/', (req, res) => {
-  res.send('POST request to the homepage')
-})
-```
-
-## Route Methods
-
-Express supports methods that correspond to all HTTP request methods: `get`, `post`, `put`, `delete`, `patch`, etc.
-
-```javascript
-app.get('/user/:id', (req, res) => {
-  res.send(`User ${req.params.id}`)
-})
-
-app.put('/user/:id', (req, res) => {
-  res.send(`Updated user ${req.params.id}`)
-})
-
-app.delete('/user/:id', (req, res) => {
-  res.send(`Deleted user ${req.params.id}`)
-})
-```
-
-## Route Parameters
-
-Route parameters are named URL segments used to capture values at specific positions in the URL.
-
-```javascript
-// Route path: /users/:userId/books/:bookId
-// Request URL: /users/34/books/8989
-// req.params: { "userId": "34", "bookId": "8989" }
-
-app.get('/users/:userId/books/:bookId', (req, res) => {
-  res.send(req.params)
-})
-```
-
-## Route Handlers
-
-You can provide multiple callback functions that behave like middleware:
-
-```javascript
-app.get('/example/b', (req, res, next) => {
-  console.log('the response will be sent by the next function ...')
-  next()
-}, (req, res) => {
-  res.send('Hello from B!')
-})
-```
-
-## express.Router
-
-Use the `express.Router` class to create modular, mountable route handlers.
-
-```javascript
-const router = express.Router()
-
-router.get('/', (req, res) => {
-  res.send('Birds home page')
-})
-
-router.get('/about', (req, res) => {
-  res.send('About birds')
-})
-
-module.exports = router
-```

package/tests/fixtures/corpus/documentation/node-streams.md

@@ -1,78 +0,0 @@
-# Node.js Streams Guide
-
-## What are Streams?
-
-Streams are collections of data that might not be available all at once and don't have to fit in memory. They're ideal for working with large amounts of data or data from external sources.
-
-## Types of Streams
-
-1. **Readable** - streams from which data can be read (e.g., `fs.createReadStream()`)
-2. **Writable** - streams to which data can be written (e.g., `fs.createWriteStream()`)
-3. **Duplex** - streams that are both Readable and Writable (e.g., `net.Socket`)
-4. **Transform** - Duplex streams that can modify data as it passes through
-
-## Reading from Streams
-
-```javascript
-const fs = require('fs')
-
-const readStream = fs.createReadStream('large-file.txt', 'utf8')
-
-readStream.on('data', (chunk) => {
-  console.log('Received chunk:', chunk.length, 'bytes')
-})
-
-readStream.on('end', () => {
-  console.log('Finished reading')
-})
-
-readStream.on('error', (err) => {
-  console.error('Error:', err)
-})
-```
-
-## Writing to Streams
-
-```javascript
-const fs = require('fs')
-
-const writeStream = fs.createWriteStream('output.txt')
-
-writeStream.write('Hello, ')
-writeStream.write('World!')
-writeStream.end()
-
-writeStream.on('finish', () => {
-  console.log('Finished writing')
-})
-```
-
-## Piping Streams
-
-The `pipe()` method connects a readable stream to a writable stream:
-
-```javascript
-const fs = require('fs')
-
-const readStream = fs.createReadStream('input.txt')
-const writeStream = fs.createWriteStream('output.txt')
-
-readStream.pipe(writeStream)
-```
-
-## Transform Streams
-
-```javascript
-const { Transform } = require('stream')
-
-const upperCaseTransform = new Transform({
-  transform(chunk, encoding, callback) {
-    this.push(chunk.toString().toUpperCase())
-    callback()
-  }
-})
-
-process.stdin
-  .pipe(upperCaseTransform)
-  .pipe(process.stdout)
-```