import { IGlobal, IInstance, NoteKnowledgeSource, KnowledgeSearchOptions, BaseSearchResult, KnowledgeSearchSource, NoteKnowledgeConfigWithModels, KnowledgeDoctorResult, KnowledgeDoctorCheck, NoteStatus } from '@easbot/types';
export { BaseSearchResult, DatabaseConfig, GRAPH_ENTITY_TYPE_DEFINITIONS, GRAPH_RELATION_TYPE_DEFINITIONS, IndexerConfig, KnowledgeSearchOptions, KnowledgeSearchSource, NoteKnowledgeConfigWithModels, NoteKnowledgeSource, SearchConfig } from '@easbot/types';
import { EmbeddingModel, LanguageModel, RerankingModel } from 'ai';
export { EmbeddingModel, LanguageModel, RerankingModel } from 'ai';
import { ILLMInitConfig, ILLMCapabilities, ILLM } from '@easbot/llm';
import { LanguageModelV3Message } from '@ai-sdk/provider';
import { ZodTypeAny } from 'zod';
import { StdioServerConfig } from '@easbot/mcp';
import { SyncSqliteConnection } from '@easbot/database';

declare function setGlobalAdapter(global: IGlobal | null): void;
declare function resetGlobalAdapter(): void;
declare function getGlobal(): IGlobal;
declare function setInstanceAdapter(instance: IInstance | null): void;
declare function resetInstanceAdapter(): void;
declare function getInstance(): IInstance;
declare function getHomeDir(): string;
declare function getXdgData(): string;
declare function getWorktree(): string;
declare function getProjectDirectory(): string;

interface LlmModels {
    embeddingLlm?: EmbeddingModel;
    graphLlm?: LanguageModel;
    rerankLlm?: RerankingModel;
}
interface LlmInitConfig extends ILLMInitConfig {
    options?: {
        graph?: {
            maxOutputTokens?: number;
            temperature?: number;
        };
        rerankTopN?: number;
    };
}
declare namespace Llm {
    function init(config: ILLMInitConfig): void;
    function reset(): void;
    function isInitialized(): boolean;
    function capabilities(): ILLMCapabilities;
    function getEmbeddingLlm(): EmbeddingModel | undefined;
    function getGraphLlm(): LanguageModel | undefined;
    function getRerankLlm(): RerankingModel | undefined;
    function embedText(value: string): Promise<Float32Array>;
    function embedTexts(values: string[]): Promise<Float32Array[]>;
    function rerank(query: string, documents: string[], topN?: number): Promise<Array<{
        index: number;
        score: number;
    }>>;
    const embed: typeof embedText;
    const embedMany: typeof embedTexts;
}
declare const llm: ILLM;

interface ScannedFile {
    absolutePath: string;
    relativePath: string;
    source: NoteKnowledgeSource;
    contentHash: string;
    lastModified: number;
    size: number;
}
interface ScannerOptions {
    workspaceDir: string;
    extraPaths?: string[];
    sources?: NoteKnowledgeSource[];
    ignorePatterns?: string[];
}
declare class FileScanner {
    private readonly workspaceDir;
    private readonly extraPaths;
    private readonly sources;
    private readonly ignorePatterns;
    constructor(options: ScannerOptions);
    scanAll(progress?: (current: number, total: number, file: ScannedFile) => void): Promise<ScannedFile[]>;
    private toRelativePath;
    scanDirectory(dir: string, source: NoteKnowledgeSource): Promise<ScannedFile[]>;
    scanFile(filePath: string, source?: NoteKnowledgeSource): Promise<ScannedFile | null>;
    private getFileInfo;
    private shouldIgnore;
    private isMarkdownFile;
}

type NoteKnowledgeConfig = NoteKnowledgeConfigWithModels;
interface DocumentMetadata {
    title?: string;
    author?: string;
    date?: string;
    [key: string]: unknown;
}
interface Document {
    id: number;
    path: string;
    title?: string;
    contentHash: string;
    summary?: string;
    metadata?: DocumentMetadata;
    lastModified?: number;
    createdAt: number;
    updatedAt: number;
}
interface Node {
    id: number;
    name: string;
    type: string;
    properties?: Record<string, unknown>;
    createdAt: string;
    updatedAt: string;
}
interface Edge {
    id: number;
    source: number;
    target: number;
    relation: string;
    properties?: Record<string, unknown>;
    createdAt: string;
    targetNode?: Node;
}
interface NodeWithEdges extends Node {
    edges?: Edge[];
}
interface NodeQueryFilter {
    ids?: number[];
    name?: string;
    type?: string;
    limit?: number;
}
interface EdgeQueryFilter {
    ids?: number[];
    source?: number;
    target?: number;
    sourceOrTarget?: number[];
    relation?: string;
    limit?: number;
}
interface RelationQueryOptions {
    maxDepth?: number;
    relationTypes?: string[];
    direction?: 'incoming' | 'outgoing' | 'both';
    limit?: number;
}
interface CallGraphNode {
    callers: number[];
    callees: number[];
}
interface InheritanceQueryResult {
    ancestors: Node[];
    descendants: Node[];
}
interface Chunk {
    id: number;
    documentId: number;
    startLine: number;
    endLine: number;
    startChar: number;
    endChar: number;
    content: string;
    contentHash: string;
    nodeIds?: number[];
    createdAt: number;
}
interface VectorRecord {
    chunkId: number;
    embedding: Float32Array;
}
type SearchResultSource = KnowledgeSearchSource;
interface SearchResult$1 extends BaseSearchResult {
    chunk: Chunk & {
        path: string;
    };
    document: Document;
    nodes?: NodeWithEdges[];
    source: SearchResultSource;
}
type SearchOptions = KnowledgeSearchOptions;
interface IngestResult$1 {
    documentId: number;
    chunksCreated: number;
    vectorsCreated: number;
    entitiesExtracted?: number;
    relationsExtracted?: number;
    summary?: string;
}
interface NoteSyncResult {
    success: boolean;
    filesAdded: number;
    filesUpdated: number;
    filesDeleted: number;
    filesSkipped: number;
    chunksCreated: number;
    vectorsCreated: number;
    entitiesExtracted: number;
    relationsExtracted: number;
    errors: Array<{
        filePath: string;
        error: string;
    }>;
    duration: number;
}
interface LastSyncResult {
    timestamp: string;
    success: boolean;
    filesAdded: number;
    filesUpdated: number;
    filesDeleted: number;
    filesSkipped: number;
    chunksCreated: number;
    vectorsCreated: number;
    entitiesExtracted: number;
    relationsExtracted: number;
    errorCount: number;
    duration: number;
}
interface KnowledgeBaseStatus {
    dbPath: string;
    workspaceDir: string;
    documentsCount: number;
    chunksCount: number;
    nodesCount: number;
    edgesCount: number;
    embeddingLlmAvailable: boolean;
    graphLlmAvailable: boolean;
    rerankLlmAvailable: boolean;
    healthy: boolean;
    meta: Record<string, string>;
}
declare enum KnowledgeBaseErrorCode {
    DATABASE_INIT_FAILED = "DATABASE_INIT_FAILED",
    DATABASE_NOT_INITIALIZED = "DATABASE_NOT_INITIALIZED",
    DATABASE_QUERY_FAILED = "DATABASE_QUERY_FAILED",
    DOCUMENT_PARSE_FAILED = "DOCUMENT_PARSE_FAILED",
    EMBEDDING_FAILED = "EMBEDDING_FAILED",
    ENTITY_EXTRACTION_FAILED = "ENTITY_EXTRACTION_FAILED",
    SEARCH_FAILED = "SEARCH_FAILED",
    NODE_NOT_FOUND = "NODE_NOT_FOUND",
    EDGE_NOT_FOUND = "EDGE_NOT_FOUND",
    INVALID_CONFIG = "INVALID_CONFIG",
    MODEL_INJECTION_FAILED = "MODEL_INJECTION_FAILED"
}
declare class KnowledgeBaseError extends Error {
    code: KnowledgeBaseErrorCode;
    cause?: Error | undefined;
    constructor(message: string, code: KnowledgeBaseErrorCode, cause?: Error | undefined);
    toString(): string;
}
type LanguageModelPrompt = LanguageModelV3Message[];
interface INoteKnowledge {
    initialize(): Promise<void>;
    ingestDocument(filePath: string): Promise<IngestResult$1>;
    scanAndIngest(progress?: (current: number, total: number, file: ScannedFile) => void): Promise<IngestResult$1[]>;
    sync(progress?: (current: number, total: number, file: ScannedFile) => void): Promise<NoteSyncResult>;
    markDirty(): void;
    search(query: string, options?: SearchOptions): Promise<SearchResult$1[]>;
    queryNodes(filter: NodeQueryFilter): Promise<Node[]>;
    queryEdges(filter: EdgeQueryFilter): Promise<Edge[]>;
    findPath(startNode: string, endNode: string, maxDepth?: number): Promise<Node[][]>;
    queryNeighbors(nodeId: number, options?: RelationQueryOptions): Promise<{
        nodes: Node[];
        edges: Edge[];
    }>;
    queryCallGraph(nodeId: number, depth?: number): Promise<Map<number, CallGraphNode>>;
    queryInheritance(nodeId: number): Promise<InheritanceQueryResult>;
    getStatus(): KnowledgeBaseStatus;
    healthCheck(): Promise<boolean>;
    clear(): Promise<void>;
    close(): Promise<void>;
}

interface BaseServiceContext {
    workspaceDir: string;
    rootDir: string;
}
interface NoteServiceContext extends BaseServiceContext {
    dbPath: string;
    locale: 'zh-CN' | 'en-US';
    remote: boolean;
    config: NoteServiceConfig;
    scanRoot?: string;
    rerankLlm?: RerankLlmLike;
}
interface NoteServiceConfig extends NoteKnowledgeConfigWithModels {
    mode: 'conservative' | 'balanced' | 'tokenmax';
    maxResults: number;
    enableRerank?: boolean;
}
interface RerankLlmLike {
    doRerank(input: {
        query: string;
        chunks: string[];
        topN: number;
    }): Promise<{
        rankedIndices: number[];
    }>;
}
type ErrorCode = 'NOT_FOUND' | 'AMBIGUOUS' | 'INTERNAL' | 'NOT_INDEXED' | 'OPTIONAL_DEP_MISSING' | 'PATH_TRAVERSAL' | 'TRUST_DENIED' | 'CONTENT_REQUIRED' | 'INGEST_FAILED' | 'UNSUPPORTED_FORMAT' | 'JOB_NOT_FOUND' | 'JOB_TIMEOUT' | 'JOB_FAILED';
declare class ServiceError extends Error {
    readonly code: ErrorCode;
    readonly details?: Record<string, unknown> | undefined;
    constructor(message: string, code: ErrorCode, details?: Record<string, unknown> | undefined);
}
declare class NotFoundError extends ServiceError {
    constructor(name: string, candidates?: Array<{
        node: unknown;
        score: number;
    }>);
}
declare class AmbiguousError extends ServiceError {
    constructor(name: string, candidates: Array<{
        node: unknown;
        score: number;
    }>);
}

interface SearchHit {
    chunkId: number;
    documentId: number;
    documentPath: string;
    documentTitle: string | null;
    startLine: number;
    endLine: number;
    content: string;
    snippet: string;
    score: number;
    originalScore?: number;
    source: 'vector' | 'fts' | 'hybrid' | 'reranked';
    nodes?: Array<{
        id: number;
        name: string;
        type: string;
        edges?: Array<{
            id: number;
            source: number;
            target: number;
            relation: string;
            targetNode?: {
                id: number;
                name: string;
                type: string;
            };
        }>;
    }>;
}
interface SearchParams {
    query: string;
    mode?: 'conservative' | 'balanced' | 'tokenmax';
    file?: string;
    kind?: 'document' | 'chunk' | 'node';
    maxResults?: number;
    includeGraph?: boolean;
    sourceId?: string;
}
interface SearchResult {
    total: number;
    hits: SearchHit[];
    durationMs: number;
    truncated: boolean;
    appliedMode: 'conservative' | 'balanced' | 'tokenmax';
}

declare function initTokenizer(params?: {
    dictPath?: string[];
    hmm?: boolean;
}): Promise<void>;
declare function loadCustomDict(dictPath: string): Promise<void>;
declare function tokenize(text: string): string[];
declare function tokenizeForSearch(text: string): string[];
declare function addWord(word: string, freq?: number, tag?: string): void;
declare function isInitialized(): boolean;
declare function closeTokenizer(): Promise<void>;
declare function toFtsTokens(text: string): string;
declare function toFtsTokensForSearch(text: string): string;

declare function chunkText(text: string, limit: number, options?: {
    minLength?: number;
}): string[];
declare function chunkTextByBreakResolver(text: string, limit: number, resolveBreakIndex?: (window: string) => number): string[];

interface DoctorOptions {
    skipEmbeddingProbe?: boolean;
    skipLlm?: boolean;
}
interface DoctorResult extends KnowledgeDoctorResult {
    reports: KnowledgeDoctorCheck[];
    integrityStats?: {
        documents: number;
        chunks: number;
        vectors: number;
        embedding_cache: number;
        chunks_fts: number;
        nodes: number;
        edges: number;
        chunk_nodes: number;
        meta: number;
        schema_migrations: number;
    };
    backendAvailable: {
        'better-sqlite3': boolean;
        'node:sqlite': boolean;
        '@tursodatabase/database': boolean;
    };
}

type NoteOperationScope = 'read' | 'write' | 'admin';
interface NoteOperationAnnotations {
    readOnlyHint?: boolean;
    destructiveHint?: boolean;
    idempotentHint?: boolean;
}
interface NoteOperation<P, R> {
    name: string;
    description: string;
    scope: NoteOperationScope;
    localOnly?: boolean;
    input: ZodTypeAny;
    output: ZodTypeAny;
    toolDescription: string;
    annotations: NoteOperationAnnotations;
    handler: (ctx: NoteServiceContext, params: P) => Promise<R>;
}
type NoteOperationEntry = NoteOperation<any, any>;
type NoteOperationRegistry = readonly [
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>,
    NoteOperation<any, any>
];
declare function formatToolDescription(parts: {
    whenToUse: string[];
    afterThis: string[];
    notes: string[];
}): string;

interface IngestParams {
    path: string;
    force?: boolean;
}
interface IngestResult {
    documentId: number;
    path: string;
    chunksCreated: number;
    vectorsCreated: number;
    entitiesExtracted?: number;
    relationsExtracted?: number;
    durationMs: number;
    warnings: string[];
}

interface ExtractParams {
    chunkId?: number;
    documentId?: number;
    path?: string;
}
interface ExtractResult {
    entities: Array<{
        name: string;
        type: string;
    }>;
    relations: Array<{
        source: string;
        target: string;
        relation: string;
    }>;
    documentId?: number;
    chunkId?: number;
    durationMs: number;
}

interface RemoveParams {
    documentId?: number;
    path?: string;
}
interface RemoveResult {
    documentId: number;
    path: string;
    chunksDeleted: number;
    vectorsDeleted: number;
    nodesDeleted: number;
    edgesDeleted: number;
    durationMs: number;
}

interface SyncProgress {
    stage: 'scan' | 'delete' | 'ingest';
    processed: number;
    total: number;
    filePath?: string;
}
type SyncProgressCallback = (progress: SyncProgress) => void;
interface SyncParams {
    async?: boolean;
    force?: boolean;
    reEmbed?: boolean;
    repair?: boolean;
    repairOnly?: boolean;
    onProgress?: SyncProgressCallback;
}
interface SyncResult {
    success: boolean;
    durationMs: number;
    filesAdded: number;
    filesUpdated: number;
    filesDeleted: number;
    filesSkipped: number;
    chunksCreated: number;
    vectorsCreated: number;
    entitiesExtracted: number;
    relationsExtracted: number;
    errors: Array<{
        filePath: string;
        error: string;
    }>;
    reconcileStats?: {
        chunksLinked: number;
        documentsProcessed: number;
        nodesTotal: number;
        nodesEmbeddingFilled: number;
        nodesEmbeddingFromCache: number;
        nodesEmbeddingFromLlm: number;
        nodesEmbeddingSkipped: number;
        durationMs: number;
    };
    ftsRepairStats?: {
        ftsEntriesAdded: number;
        ftsEntriesRemoved: number;
        finalConsistent: boolean;
        durationMs: number;
    };
}

interface GraphNode {
    id: number;
    name: string;
    type: string;
    properties?: Record<string, unknown>;
}
interface GraphEdge {
    id: number;
    source: number;
    target: number;
    relation: string;
    properties?: Record<string, unknown>;
    targetNode?: GraphNode;
}
interface GraphQueryParams {
    mode?: 'neighbors' | 'path' | 'explain';
    nodeId?: number;
    targetNodeId?: number;
    chunkId?: number;
    maxDepth?: number;
    relationTypes?: string[];
    limit?: number;
}
interface GraphQueryResult {
    nodes: GraphNode[];
    edges: GraphEdge[];
    path?: number[];
    depth: number;
    durationMs: number;
}

interface StatusResult extends NoteStatus {
    documentsCount: number;
    chunksCount: number;
    nodesCount: number;
    edgesCount: number;
}

type StatusParams = Record<string, never>;

interface InitParams {
    dir?: string;
    force?: boolean;
    embeddingModel?: string;
    rerankModel?: string;
    graphModel?: string;
    entityExtractionPrompt?: string;
    relationExtractionPrompt?: string;
    skipAutoSync?: boolean;
}
interface InitResult {
    configPath: string;
    workspaceDir: string;
    dbPath: string;
    backend: string;
    schemaVersion: number;
    extractionVersion: number;
    created: boolean;
    migrationsApplied: number;
    tablesCreated: number;
    durationMs: number;
}

declare const NOTE_OPERATIONS: readonly [NoteOperation<SearchParams, SearchResult>, NoteOperation<IngestParams, IngestResult>, NoteOperation<ExtractParams, ExtractResult>, NoteOperation<RemoveParams, RemoveResult>, NoteOperation<SyncParams, SyncResult>, NoteOperation<GraphQueryParams, GraphQueryResult>, NoteOperation<StatusParams, StatusResult>, NoteOperation<DoctorOptions, DoctorResult>, NoteOperation<InitParams, InitResult>];
declare function assertNoteOperations(): void;
declare function findOperation(name: string): NoteOperationEntry | undefined;
declare function executeNoteOp(name: string, params: unknown, ctx: {
    remote?: boolean;
    [k: string]: unknown;
}): Promise<unknown>;

interface OperationSummary {
    total: number;
    truncated: boolean;
    extras?: Record<string, string | number | boolean>;
}
interface OperationRenderInput {
    toolName: string;
    title: string;
    summary: OperationSummary;
    body: string;
    footer?: string;
    signal?: string;
}
interface RenderMarkdownOptions {
    softLimit?: number;
    hardCeiling?: number;
    writeToDisk?: boolean;
}
declare function renderOperationMarkdown(input: OperationRenderInput, _options?: RenderMarkdownOptions): string;

interface CommandHelp {
    i18nKey: string;
    name: string;
    description: string;
    group: 'lifecycle' | 'content' | 'graph' | 'external';
}
declare const COMMANDS_HELP: readonly CommandHelp[];
interface NoteCliDeps {
    version: string;
    cwd?: string;
    locale?: string;
}
interface NoteCliResult {
    code: number;
    handled: boolean;
    command: string | null;
}
declare function renderBanner(): void;
declare function renderHelp(): void;
declare function handleNoteCli(args: string[], deps?: NoteCliDeps): Promise<NoteCliResult>;

interface NoteMcpCtxConfig {
    workspaceDir: string;
    dbPath?: string;
}
declare const TOOL_NAMES: readonly string[];
declare function toMcpText(text: string, isError?: boolean): {
    content: {
        type: 'text';
        text: string;
    }[];
    isError?: boolean;
};
interface OpHandlerContext {
    caller: 'remote' | 'local' | 'agent' | 'cli';
    sessionId?: string;
    workspaceDir: string;
    rootDir: string;
    dbPath: string;
    locale: 'zh-CN' | 'en-US';
    remote: boolean;
    config: NoteServiceConfig;
    scanRoot?: string;
    rerankLlm?: RerankLlmLike;
    [k: string]: unknown;
}
declare namespace NoteStdioServer {
    interface StartResult {
        id: string;
        name: string;
        version: string;
        tools: string[];
    }
    function start(_legacyKb?: unknown, config?: StdioServerConfig, ctxConfig?: NoteMcpCtxConfig): Promise<StartResult>;
    function getToolNames(): string[];
}

declare class NoteDatabaseManager {
    private db;
    private readonly dbPath;
    private closed;
    private ftsAvailable;
    constructor(dbPath: string);
    private checkFtsAvailability;
    getDb(): SyncSqliteConnection;
    isFtsAvailable(): boolean;
    getPath(): string;
    getMeta(key: string): string | null;
    setMeta(key: string, value: string): void;
    healthCheck(): boolean;
    checkIntegrity(): {
        issues: Array<{
            severity: 'error' | 'warn' | 'info';
            message: string;
        }>;
        stats: {
            documents: number;
            chunks: number;
            vectors: number;
            embedding_cache: number;
            chunks_fts: number;
            nodes: number;
            edges: number;
            chunk_nodes: number;
            meta: number;
            schema_migrations: number;
        };
    };
    close(): void;
}
declare function getNoteDbPath(input: string | {
    dir?: string;
    workspaceDir?: string;
}, _ctx?: unknown): string;

export { AmbiguousError, type BaseServiceContext, COMMANDS_HELP, type CallGraphNode, type Chunk, type CommandHelp, type Document, type DocumentMetadata, type Edge, type EdgeQueryFilter, FileScanner, type INoteKnowledge, type IngestResult$1 as IngestResult, type InheritanceQueryResult, KnowledgeBaseError, KnowledgeBaseErrorCode, type KnowledgeBaseStatus, type LanguageModelPrompt, type LastSyncResult, Llm, type LlmInitConfig, type LlmModels, NOTE_OPERATIONS, type Node, type NodeQueryFilter, type NodeWithEdges, NotFoundError, type NoteCliDeps, type NoteCliResult, NoteDatabaseManager, type NoteKnowledgeConfig, type NoteOperation, type NoteOperationAnnotations, type NoteOperationEntry, type NoteOperationRegistry, type NoteOperationScope, type NoteServiceConfig, type NoteServiceContext, NoteStdioServer, type NoteSyncResult, type OpHandlerContext, type RelationQueryOptions, type RerankLlmLike, type ScannedFile, type ScannerOptions, type SearchHit, type SearchOptions, type SearchResult, type SearchResultSource, ServiceError, TOOL_NAMES, type VectorRecord, addWord, assertNoteOperations, chunkText, chunkTextByBreakResolver, closeTokenizer, executeNoteOp, findOperation, formatToolDescription, getGlobal, getHomeDir, getInstance, getNoteDbPath, getProjectDirectory, getWorktree, getXdgData, handleNoteCli, initTokenizer, isInitialized, llm, loadCustomDict, renderBanner, renderHelp, renderOperationMarkdown, resetGlobalAdapter, resetInstanceAdapter, setGlobalAdapter, setInstanceAdapter, toFtsTokens, toFtsTokensForSearch, toMcpText, tokenize, tokenizeForSearch };