midnight-mcp 0.0.2 → 0.0.5

package/dist/utils/config.d.ts

@@ -1,10 +1,9 @@
 import { z } from "zod";
 declare const ConfigSchema: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<["hosted", "local"]>>;
+    hostedApiUrl: z.ZodDefault<z.ZodString>;
     githubToken: z.ZodOptional<z.ZodString>;
     chromaUrl: z.ZodDefault<z.ZodString>;
-    qdrantUrl: z.ZodOptional<z.ZodString>;
-    pineconeApiKey: z.ZodOptional<z.ZodString>;
-    pineconeIndex: z.ZodOptional<z.ZodString>;
     openaiApiKey: z.ZodOptional<z.ZodString>;
     embeddingModel: z.ZodDefault<z.ZodString>;
     logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
@@ -13,6 +12,8 @@ declare const ConfigSchema: z.ZodObject<{
     dataDir: z.ZodDefault<z.ZodString>;
     cacheDir: z.ZodDefault<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    mode: "hosted" | "local";
+    hostedApiUrl: string;
     chromaUrl: string;
     embeddingModel: string;
     logLevel: "debug" | "info" | "warn" | "error";
@@ -21,16 +22,12 @@ declare const ConfigSchema: z.ZodObject<{
     dataDir: string;
     cacheDir: string;
     githubToken?: string | undefined;
-    qdrantUrl?: string | undefined;
-    pineconeApiKey?: string | undefined;
-    pineconeIndex?: string | undefined;
     openaiApiKey?: string | undefined;
 }, {
+    mode?: "hosted" | "local" | undefined;
+    hostedApiUrl?: string | undefined;
     githubToken?: string | undefined;
     chromaUrl?: string | undefined;
-    qdrantUrl?: string | undefined;
-    pineconeApiKey?: string | undefined;
-    pineconeIndex?: string | undefined;
     openaiApiKey?: string | undefined;
     embeddingModel?: string | undefined;
     logLevel?: "debug" | "info" | "warn" | "error" | undefined;
@@ -41,6 +38,8 @@ declare const ConfigSchema: z.ZodObject<{
 }>;
 export type Config = z.infer<typeof ConfigSchema>;
 export declare const config: {
+    mode: "hosted" | "local";
+    hostedApiUrl: string;
     chromaUrl: string;
     embeddingModel: string;
     logLevel: "debug" | "info" | "warn" | "error";
@@ -49,11 +48,16 @@ export declare const config: {
     dataDir: string;
     cacheDir: string;
     githubToken?: string | undefined;
-    qdrantUrl?: string | undefined;
-    pineconeApiKey?: string | undefined;
-    pineconeIndex?: string | undefined;
     openaiApiKey?: string | undefined;
 };
+/**
+ * Check if running in hosted mode (default)
+ */
+export declare function isHostedMode(): boolean;
+/**
+ * Check if running in local mode
+ */
+export declare function isLocalMode(): boolean;
 export interface RepositoryConfig {
     owner: string;
     repo: string;

package/dist/utils/config.js

@@ -2,14 +2,17 @@ import { z } from "zod";
 import dotenv from "dotenv";
 dotenv.config();
 const ConfigSchema = z.object({
+    // Mode: 'hosted' (default) or 'local'
+    mode: z.enum(["hosted", "local"]).default("hosted"),
+    // Hosted API URL (used when mode is 'hosted')
+    hostedApiUrl: z
+        .string()
+        .default("https://midnight-mcp-api.midnightmcp.workers.dev"),
     // GitHub
     githubToken: z.string().optional(),
-    // Vector Database
+    // Vector Database (only needed for local mode)
     chromaUrl: z.string().default("http://localhost:8000"),
-    qdrantUrl: z.string().optional(),
-    pineconeApiKey: z.string().optional(),
-    pineconeIndex: z.string().optional(),
-    // Embeddings
+    // Embeddings (only needed for local mode)
     openaiApiKey: z.string().optional(),
     embeddingModel: z.string().default("text-embedding-3-small"),
     // Server
@@ -21,12 +24,14 @@ const ConfigSchema = z.object({
     cacheDir: z.string().default("./cache"),
 });
 function loadConfig() {
+    // Determine mode: local if MIDNIGHT_LOCAL=true or if OPENAI_API_KEY is set
+    const isLocalMode = process.env.MIDNIGHT_LOCAL === "true" ||
+        (process.env.OPENAI_API_KEY && process.env.CHROMA_URL);
     const rawConfig = {
+        mode: isLocalMode ? "local" : "hosted",
+        hostedApiUrl: process.env.MIDNIGHT_API_URL,
         githubToken: process.env.GITHUB_TOKEN,
         chromaUrl: process.env.CHROMA_URL,
-        qdrantUrl: process.env.QDRANT_URL,
-        pineconeApiKey: process.env.PINECONE_API_KEY,
-        pineconeIndex: process.env.PINECONE_INDEX,
         openaiApiKey: process.env.OPENAI_API_KEY,
         embeddingModel: process.env.EMBEDDING_MODEL,
         logLevel: process.env.LOG_LEVEL,
@@ -42,6 +47,18 @@ function loadConfig() {
     return ConfigSchema.parse(cleanConfig);
 }
 export const config = loadConfig();
+/**
+ * Check if running in hosted mode (default)
+ */
+export function isHostedMode() {
+    return config.mode === "hosted";
+}
+/**
+ * Check if running in local mode
+ */
+export function isLocalMode() {
+    return config.mode === "local";
+}
 export const DEFAULT_REPOSITORIES = [
     // Core Language & SDK
     {

package/dist/utils/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * User-friendly error messages and error handling utilities
+ */
+export declare class MCPError extends Error {
+    readonly code: string;
+    readonly suggestion?: string;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code: string, suggestion?: string, details?: Record<string, unknown>);
+    toJSON(): {
+        details?: Record<string, unknown> | undefined;
+        error: string;
+        code: string;
+        suggestion: string | undefined;
+    };
+}
+/**
+ * Common error codes
+ */
+export declare const ErrorCodes: {
+    readonly RATE_LIMIT: "RATE_LIMIT_EXCEEDED";
+    readonly NOT_FOUND: "RESOURCE_NOT_FOUND";
+    readonly NETWORK: "NETWORK_ERROR";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+    readonly UNKNOWN_REPO: "UNKNOWN_REPOSITORY";
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    readonly CHROMADB_UNAVAILABLE: "CHROMADB_UNAVAILABLE";
+    readonly OPENAI_UNAVAILABLE: "OPENAI_UNAVAILABLE";
+};
+/**
+ * Create user-friendly error from various error types
+ */
+export declare function createUserError(error: unknown, context?: string): MCPError;
+/**
+ * Format error for MCP response
+ */
+export declare function formatErrorResponse(error: unknown, context?: string): {
+    error: string;
+    code: string;
+    suggestion?: string;
+};
+/**
+ * Wrap a function with error handling
+ */
+export declare function withErrorHandling<T extends (...args: unknown[]) => Promise<unknown>>(fn: T, context: string): T;
+//# sourceMappingURL=errors.d.ts.map

package/dist/utils/errors.js

@@ -0,0 +1,95 @@
+/**
+ * User-friendly error messages and error handling utilities
+ */
+export class MCPError extends Error {
+    code;
+    suggestion;
+    details;
+    constructor(message, code, suggestion, details) {
+        super(message);
+        this.name = "MCPError";
+        this.code = code;
+        this.suggestion = suggestion;
+        this.details = details;
+    }
+    toJSON() {
+        return {
+            error: this.message,
+            code: this.code,
+            suggestion: this.suggestion,
+            ...(this.details && { details: this.details }),
+        };
+    }
+}
+/**
+ * Common error codes
+ */
+export const ErrorCodes = {
+    RATE_LIMIT: "RATE_LIMIT_EXCEEDED",
+    NOT_FOUND: "RESOURCE_NOT_FOUND",
+    NETWORK: "NETWORK_ERROR",
+    INVALID_INPUT: "INVALID_INPUT",
+    UNKNOWN_REPO: "UNKNOWN_REPOSITORY",
+    PARSE_ERROR: "PARSE_ERROR",
+    CHROMADB_UNAVAILABLE: "CHROMADB_UNAVAILABLE",
+    OPENAI_UNAVAILABLE: "OPENAI_UNAVAILABLE",
+};
+/**
+ * Create user-friendly error from various error types
+ */
+export function createUserError(error, context) {
+    const message = error instanceof Error ? error.message : String(error);
+    const ctx = context ? ` while ${context}` : "";
+    // Rate limit errors
+    if (message.includes("rate limit") ||
+        message.includes("403") ||
+        message.includes("API rate limit")) {
+        return new MCPError(`GitHub API rate limit exceeded${ctx}`, ErrorCodes.RATE_LIMIT, "Add GITHUB_TOKEN to your config to increase limits from 60 to 5000 requests/hour. " +
+            "Get a token at https://github.com/settings/tokens");
+    }
+    // Not found errors
+    if (message.includes("404") || message.includes("Not Found")) {
+        return new MCPError(`Resource not found${ctx}`, ErrorCodes.NOT_FOUND, "Check that the repository, file, or version exists and is publicly accessible.");
+    }
+    // Network errors
+    if (message.includes("network") ||
+        message.includes("ECONNREFUSED") ||
+        message.includes("ETIMEDOUT") ||
+        message.includes("timeout")) {
+        return new MCPError(`Network error${ctx}`, ErrorCodes.NETWORK, "Check your internet connection and try again. If the problem persists, " +
+            "the service may be temporarily unavailable.");
+    }
+    // ChromaDB errors
+    if (message.includes("chroma") || message.includes("8000")) {
+        return new MCPError(`ChromaDB is not available${ctx}`, ErrorCodes.CHROMADB_UNAVAILABLE, "ChromaDB is optional. Without it, search uses keyword matching instead of semantic search. " +
+            "To enable semantic search, run: docker run -d -p 8000:8000 chromadb/chroma");
+    }
+    // OpenAI errors
+    if (message.includes("openai") || message.includes("embedding")) {
+        return new MCPError(`OpenAI API error${ctx}`, ErrorCodes.OPENAI_UNAVAILABLE, "OpenAI is optional. Without it, search uses keyword matching. " +
+            "To enable semantic search, add OPENAI_API_KEY to your config.");
+    }
+    // Default error
+    return new MCPError(`An error occurred${ctx}: ${message}`, "UNKNOWN_ERROR", "If this problem persists, please report it at https://github.com/Olanetsoft/midnight-mcp/issues");
+}
+/**
+ * Format error for MCP response
+ */
+export function formatErrorResponse(error, context) {
+    const mcpError = error instanceof MCPError ? error : createUserError(error, context);
+    return mcpError.toJSON();
+}
+/**
+ * Wrap a function with error handling
+ */
+export function withErrorHandling(fn, context) {
+    return (async (...args) => {
+        try {
+            return await fn(...args);
+        }
+        catch (error) {
+            throw createUserError(error, context);
+        }
+    });
+}
+//# sourceMappingURL=errors.js.map

package/dist/utils/health.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Health check utilities for MCP server monitoring
+ */
+export interface HealthStatus {
+    status: "healthy" | "degraded" | "unhealthy";
+    timestamp: string;
+    version: string;
+    uptime: number;
+    checks: {
+        name: string;
+        status: "pass" | "warn" | "fail";
+        message?: string;
+        latency?: number;
+    }[];
+}
+/**
+ * Perform a full health check
+ */
+export declare function getHealthStatus(): Promise<HealthStatus>;
+/**
+ * Get a quick health check (no external calls)
+ */
+export declare function getQuickHealthStatus(): Omit<HealthStatus, "checks"> & {
+    checks: {
+        name: string;
+        status: "pass";
+    }[];
+};
+//# sourceMappingURL=health.d.ts.map

package/dist/utils/health.js

@@ -0,0 +1,132 @@
+/**
+ * Health check utilities for MCP server monitoring
+ */
+import { githubClient } from "../pipeline/index.js";
+// Track server start time
+const startTime = Date.now();
+// Get package version
+const VERSION = process.env.npm_package_version || "0.0.3";
+/**
+ * Check if GitHub API is accessible
+ */
+async function checkGitHubAPI() {
+    const start = Date.now();
+    try {
+        // Try to get rate limit info (lightweight API call)
+        const rateLimit = await githubClient.getRateLimit();
+        const latency = Date.now() - start;
+        if (rateLimit.remaining < 100) {
+            return {
+                status: "warn",
+                message: `Rate limit low: ${rateLimit.remaining}/${rateLimit.limit} remaining`,
+                latency,
+            };
+        }
+        return {
+            status: "pass",
+            message: `Rate limit: ${rateLimit.remaining}/${rateLimit.limit}`,
+            latency,
+        };
+    }
+    catch (error) {
+        return {
+            status: "fail",
+            message: `GitHub API error: ${error instanceof Error ? error.message : String(error)}`,
+            latency: Date.now() - start,
+        };
+    }
+}
+/**
+ * Check if ChromaDB is accessible (optional dependency)
+ */
+async function checkVectorStore() {
+    try {
+        // Import dynamically to handle optional dependency
+        const { vectorStore } = await import("../db/index.js");
+        // Check if vector store is initialized
+        if (vectorStore) {
+            return {
+                status: "pass",
+                message: "Vector store available",
+            };
+        }
+        return {
+            status: "warn",
+            message: "Vector store not initialized (semantic search unavailable)",
+        };
+    }
+    catch {
+        return {
+            status: "warn",
+            message: "Vector store not configured (semantic search unavailable)",
+        };
+    }
+}
+/**
+ * Check memory usage
+ */
+function checkMemory() {
+    const usage = process.memoryUsage();
+    const heapUsedMB = Math.round(usage.heapUsed / 1024 / 1024);
+    const heapTotalMB = Math.round(usage.heapTotal / 1024 / 1024);
+    const percentUsed = Math.round((usage.heapUsed / usage.heapTotal) * 100);
+    if (percentUsed > 90) {
+        return {
+            status: "fail",
+            message: `High memory usage: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`,
+        };
+    }
+    if (percentUsed > 75) {
+        return {
+            status: "warn",
+            message: `Elevated memory usage: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`,
+        };
+    }
+    return {
+        status: "pass",
+        message: `Memory: ${heapUsedMB}MB/${heapTotalMB}MB (${percentUsed}%)`,
+    };
+}
+/**
+ * Perform a full health check
+ */
+export async function getHealthStatus() {
+    const checks = [];
+    // Run all health checks in parallel
+    const [githubCheck, vectorCheck] = await Promise.all([
+        checkGitHubAPI(),
+        checkVectorStore(),
+    ]);
+    const memoryCheck = checkMemory();
+    checks.push({ name: "github_api", ...githubCheck }, { name: "vector_store", ...vectorCheck }, { name: "memory", ...memoryCheck });
+    // Determine overall status
+    const hasFailure = checks.some((c) => c.status === "fail");
+    const hasWarning = checks.some((c) => c.status === "warn");
+    let status = "healthy";
+    if (hasFailure) {
+        status = "unhealthy";
+    }
+    else if (hasWarning) {
+        status = "degraded";
+    }
+    return {
+        status,
+        timestamp: new Date().toISOString(),
+        version: VERSION,
+        uptime: Math.round((Date.now() - startTime) / 1000),
+        checks,
+    };
+}
+/**
+ * Get a quick health check (no external calls)
+ */
+export function getQuickHealthStatus() {
+    return {
+        status: "healthy",
+        timestamp: new Date().toISOString(),
+        version: VERSION,
+        uptime: Math.round((Date.now() - startTime) / 1000),
+        checks: [{ name: "server", status: "pass" }],
+    };
+}
+//# sourceMappingURL=health.js.map

package/dist/utils/hosted-api.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Client for the hosted Midnight MCP API
+ * Used when running in hosted mode (default)
+ */
+export interface HostedSearchResult {
+    code?: string;
+    content?: string;
+    relevanceScore: number;
+    source: {
+        repository: string;
+        filePath: string;
+        lines?: string;
+        section?: string;
+    };
+    codeType?: string;
+    name?: string;
+    isExported?: boolean;
+}
+export interface HostedSearchResponse {
+    results: HostedSearchResult[];
+    totalResults: number;
+    query: string;
+    category?: string;
+    warnings?: string[];
+}
+export interface HostedSearchFilter {
+    language?: string;
+    repository?: string;
+}
+/**
+ * Search Compact code via hosted API
+ */
+export declare function searchCompactHosted(query: string, limit?: number): Promise<HostedSearchResponse>;
+/**
+ * Search TypeScript code via hosted API
+ */
+export declare function searchTypeScriptHosted(query: string, limit?: number, includeTypes?: boolean): Promise<HostedSearchResponse>;
+/**
+ * Search documentation via hosted API
+ */
+export declare function searchDocsHosted(query: string, limit?: number, category?: string): Promise<HostedSearchResponse>;
+/**
+ * Generic search via hosted API
+ */
+export declare function searchHosted(query: string, limit?: number, filter?: HostedSearchFilter): Promise<HostedSearchResponse>;
+/**
+ * Check if the hosted API is available
+ */
+export declare function checkHostedApiHealth(): Promise<{
+    available: boolean;
+    documentsIndexed?: number;
+    error?: string;
+}>;
+/**
+ * Get hosted API stats
+ */
+export declare function getHostedApiStats(): Promise<{
+    documentsIndexed: number;
+    repositories: number;
+}>;
+//# sourceMappingURL=hosted-api.d.ts.map

package/dist/utils/hosted-api.js

@@ -0,0 +1,106 @@
+/**
+ * Client for the hosted Midnight MCP API
+ * Used when running in hosted mode (default)
+ */
+import { config, logger } from "./index.js";
+const API_TIMEOUT = 10000; // 10 seconds
+/**
+ * Make a request to the hosted API
+ */
+async function apiRequest(endpoint, options = {}) {
+    const url = `${config.hostedApiUrl}${endpoint}`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), API_TIMEOUT);
+    try {
+        const response = await fetch(url, {
+            ...options,
+            signal: controller.signal,
+            headers: {
+                "Content-Type": "application/json",
+                "User-Agent": "midnight-mcp",
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            const errorData = (await response
+                .json()
+                .catch(() => ({ error: "Unknown error" })));
+            throw new Error(errorData.error || `API error: ${response.status}`);
+        }
+        return (await response.json());
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error("API request timed out. The hosted service may be unavailable.");
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Search Compact code via hosted API
+ */
+export async function searchCompactHosted(query, limit = 10) {
+    logger.debug("Searching Compact code via hosted API", { query });
+    return apiRequest("/v1/search/compact", {
+        method: "POST",
+        body: JSON.stringify({ query, limit }),
+    });
+}
+/**
+ * Search TypeScript code via hosted API
+ */
+export async function searchTypeScriptHosted(query, limit = 10, includeTypes = true) {
+    logger.debug("Searching TypeScript code via hosted API", { query });
+    return apiRequest("/v1/search/typescript", {
+        method: "POST",
+        body: JSON.stringify({ query, limit, includeTypes }),
+    });
+}
+/**
+ * Search documentation via hosted API
+ */
+export async function searchDocsHosted(query, limit = 10, category = "all") {
+    logger.debug("Searching documentation via hosted API", { query });
+    return apiRequest("/v1/search/docs", {
+        method: "POST",
+        body: JSON.stringify({ query, limit, category }),
+    });
+}
+/**
+ * Generic search via hosted API
+ */
+export async function searchHosted(query, limit = 10, filter) {
+    logger.debug("Searching via hosted API", { query, filter });
+    return apiRequest("/v1/search", {
+        method: "POST",
+        body: JSON.stringify({ query, limit, filter }),
+    });
+}
+/**
+ * Check if the hosted API is available
+ */
+export async function checkHostedApiHealth() {
+    try {
+        const response = await apiRequest("/health");
+        return {
+            available: response.status === "healthy",
+            documentsIndexed: response.vectorStore?.documentsIndexed,
+        };
+    }
+    catch (error) {
+        return {
+            available: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Get hosted API stats
+ */
+export async function getHostedApiStats() {
+    return apiRequest("/v1/stats");
+}
+//# sourceMappingURL=hosted-api.js.map

package/dist/utils/index.d.ts

@@ -1,5 +1,16 @@
-export { config } from "./config.js";
+export { config, isHostedMode, isLocalMode } from "./config.js";
 export type { Config, RepositoryConfig } from "./config.js";
 export { DEFAULT_REPOSITORIES } from "./config.js";
 export { logger } from "./logger.js";
+export { MCPError, ErrorCodes, createUserError, formatErrorResponse, withErrorHandling, } from "./errors.js";
+export { validateQuery, validateRepository, validatePath, validateRef, validateNumber, validateToolArgs, sanitizeString, } from "./validation.js";
+export type { ValidationResult } from "./validation.js";
+export { getHealthStatus, getQuickHealthStatus } from "./health.js";
+export type { HealthStatus } from "./health.js";
+export { updateRateLimitFromHeaders, updateRateLimit, getRateLimitStatus, shouldProceedWithRequest, getTimeUntilReset, formatRateLimitStatus, decrementRemaining, } from "./rate-limit.js";
+export type { RateLimitInfo, RateLimitStatus } from "./rate-limit.js";
+export { Cache, createCacheKey, searchCache, fileCache, metadataCache, pruneAllCaches, } from "./cache.js";
+export type { CacheOptions, CacheEntry, CacheStats } from "./cache.js";
+export { searchCompactHosted, searchTypeScriptHosted, searchDocsHosted, searchHosted, checkHostedApiHealth, getHostedApiStats, } from "./hosted-api.js";
+export type { HostedSearchResult, HostedSearchResponse, HostedSearchFilter, } from "./hosted-api.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -1,4 +1,15 @@
-export { config } from "./config.js";
+export { config, isHostedMode, isLocalMode } from "./config.js";
 export { DEFAULT_REPOSITORIES } from "./config.js";
 export { logger } from "./logger.js";
+export { MCPError, ErrorCodes, createUserError, formatErrorResponse, withErrorHandling, } from "./errors.js";
+// Validation utilities
+export { validateQuery, validateRepository, validatePath, validateRef, validateNumber, validateToolArgs, sanitizeString, } from "./validation.js";
+// Health check utilities
+export { getHealthStatus, getQuickHealthStatus } from "./health.js";
+// Rate limit tracking
+export { updateRateLimitFromHeaders, updateRateLimit, getRateLimitStatus, shouldProceedWithRequest, getTimeUntilReset, formatRateLimitStatus, decrementRemaining, } from "./rate-limit.js";
+// Caching utilities
+export { Cache, createCacheKey, searchCache, fileCache, metadataCache, pruneAllCaches, } from "./cache.js";
+// Hosted API client
+export { searchCompactHosted, searchTypeScriptHosted, searchDocsHosted, searchHosted, checkHostedApiHealth, getHostedApiStats, } from "./hosted-api.js";
 //# sourceMappingURL=index.js.map

package/dist/utils/logger.d.ts

@@ -1,13 +1,42 @@
 type LogLevel = "debug" | "info" | "warn" | "error";
+type LogFormat = "text" | "json";
 declare class Logger {
     private level;
-    constructor(level?: LogLevel);
+    private format;
+    private service;
+    constructor(level?: LogLevel, format?: LogFormat, service?: string);
+    /**
+     * Set log format at runtime
+     */
+    setFormat(format: LogFormat): void;
+    /**
+     * Set log level at runtime
+     */
+    setLevel(level: LogLevel): void;
     private shouldLog;
+    private formatTextMessage;
+    private formatJsonMessage;
     private formatMessage;
     debug(message: string, meta?: object): void;
     info(message: string, meta?: object): void;
     warn(message: string, meta?: object): void;
     error(message: string, meta?: object): void;
+    /**
+     * Create a child logger with additional context
+     */
+    child(context: object): ChildLogger;
+}
+/**
+ * Child logger that includes additional context in all log messages
+ */
+declare class ChildLogger {
+    private parent;
+    private context;
+    constructor(parent: Logger, context: object);
+    debug(message: string, meta?: object): void;
+    info(message: string, meta?: object): void;
+    warn(message: string, meta?: object): void;
+    error(message: string, meta?: object): void;
 }
 export declare const logger: Logger;
 export {};