@hasna/knowledge 0.2.26 → 0.2.28

package/dist/knowledge-db.d.ts

@@ -0,0 +1,27 @@
+import { Database } from 'bun:sqlite';
+export declare const CURRENT_SCHEMA_VERSION = 5;
+export interface KnowledgeDbStats {
+    schema_version: number;
+    sources: number;
+    source_revisions: number;
+    chunks: number;
+    wiki_pages: number;
+    citations: number;
+    indexes: number;
+    runs: number;
+    run_events: number;
+    redaction_findings: number;
+    audit_events: number;
+    approval_gates: number;
+    storage_objects: number;
+    embeddings: number;
+    vector_entries: number;
+    reindex_queue: number;
+}
+export declare function openKnowledgeDb(path: string): Database;
+export declare function migrateKnowledgeDb(path: string): {
+    path: string;
+    schema_version: number;
+};
+export declare function getSchemaVersion(db: Database): number;
+export declare function getKnowledgeDbStats(path: string): KnowledgeDbStats;

package/dist/manifest-ingest.d.ts

@@ -0,0 +1,35 @@
+import type { KnowledgeConfig } from './workspace';
+import { type SafetyPolicy } from './safety';
+export interface ManifestIngestOptions {
+    dbPath: string;
+    input: string;
+    config?: KnowledgeConfig;
+    safetyPolicy?: SafetyPolicy;
+    now?: Date;
+    maxChunkChars?: number;
+    chunkOverlapChars?: number;
+}
+export interface ManifestItemsIngestOptions {
+    dbPath: string;
+    items: ManifestObject[];
+    sourceLabel: string;
+    readAction?: string;
+    safetyPolicy?: SafetyPolicy;
+    now?: Date;
+    maxChunkChars?: number;
+    chunkOverlapChars?: number;
+}
+export interface ManifestIngestResult {
+    path: string;
+    db_path: string;
+    items_seen: number;
+    sources_upserted: number;
+    revisions_upserted: number;
+    chunks_inserted: number;
+    chunks_deleted: number;
+    redactions: number;
+    skipped: number;
+}
+export type ManifestObject = Record<string, unknown>;
+export declare function ingestOpenFilesManifest(options: ManifestIngestOptions): Promise<ManifestIngestResult>;
+export declare function ingestOpenFilesManifestItems(options: ManifestItemsIngestOptions): Promise<ManifestIngestResult>;

package/dist/outbox-consume.d.ts

@@ -0,0 +1,25 @@
+import type { KnowledgeConfig } from './workspace';
+import { type SafetyPolicy } from './safety';
+export interface OutboxConsumeOptions {
+    dbPath: string;
+    input: string;
+    config?: KnowledgeConfig;
+    safetyPolicy?: SafetyPolicy;
+    now?: Date;
+}
+export interface OutboxConsumeResult {
+    path: string;
+    db_path: string;
+    run_id: string;
+    events_seen: number;
+    sources_touched: number;
+    revisions_touched: number;
+    chunks_deleted: number;
+    embeddings_deleted: number;
+    stale_revisions: number;
+    deleted_sources: number;
+    moved_sources: number;
+    permission_updates: number;
+    vector_entries_deleted: number;
+}
+export declare function consumeOpenFilesOutbox(options: OutboxConsumeOptions): Promise<OutboxConsumeResult>;

package/dist/provenance.d.ts

@@ -0,0 +1,50 @@
+export interface KnowledgeProvenance {
+    source_owner: 'open-files';
+    source_ref: string | null;
+    source_uri: string | null;
+    source_kind: string | null;
+    source_revision_id: string | null;
+    revision: string | null;
+    hash: string | null;
+    chunk_id: string | null;
+    start_offset: number | null;
+    end_offset: number | null;
+    status: string | null;
+    read_only: true;
+    citation_required: boolean;
+    resolver: string | null;
+    stale: boolean;
+}
+export interface GeneratedArtifactProvenance {
+    source_owner: 'open-files';
+    generated_from: string;
+    artifact_key: string;
+    source_refs: string[];
+    read_only_sources: true;
+    citation_required: boolean;
+    raw_source_bytes_stored_in_open_knowledge: false;
+}
+export interface SourceProvenanceInput {
+    source_ref?: string | null;
+    source_uri?: string | null;
+    source_kind?: string | null;
+    source_revision_id?: string | null;
+    revision?: string | null;
+    hash?: string | null;
+    chunk_id?: string | null;
+    start_offset?: number | null;
+    end_offset?: number | null;
+    status?: string | null;
+    resolver?: string | null;
+}
+export declare function isStaleStatus(status: string | null | undefined): boolean;
+export declare function sourceProvenance(input: SourceProvenanceInput): KnowledgeProvenance;
+export declare function generatedArtifactProvenance(input: {
+    generated_from: string;
+    artifact_key: string;
+    source_refs?: string[];
+    citation_required?: boolean;
+}): GeneratedArtifactProvenance;
+export declare function withProvenance<T extends Record<string, unknown>>(metadata: T, provenance: KnowledgeProvenance | GeneratedArtifactProvenance): T & {
+    provenance: KnowledgeProvenance | GeneratedArtifactProvenance;
+};

package/dist/providers.d.ts

@@ -0,0 +1,89 @@
+import type { Database } from 'bun:sqlite';
+import type { KnowledgeConfig } from './workspace';
+export type AiProviderId = 'openai' | 'anthropic' | 'deepseek';
+export interface AiProviderSettings {
+    api_key_env: string;
+    base_url?: string;
+    default_model: string;
+}
+export interface AiProvidersConfig {
+    default_model?: string;
+    aliases?: Record<string, string>;
+    openai?: Partial<AiProviderSettings>;
+    anthropic?: Partial<AiProviderSettings>;
+    deepseek?: Partial<AiProviderSettings>;
+}
+export interface ModelCapabilities {
+    text_generation: boolean;
+    structured_output: boolean;
+    tool_usage: boolean;
+    tool_streaming: boolean;
+    image_input: boolean;
+    native_web_search: boolean;
+    reasoning: boolean;
+    embeddings: boolean;
+}
+export interface ModelRegistryEntry {
+    alias: string;
+    model_ref: string;
+    provider: AiProviderId;
+    model: string;
+    default: boolean;
+    capabilities: ModelCapabilities;
+}
+export interface ProviderCredentialStatus {
+    provider: AiProviderId;
+    api_key_env: string;
+    configured: boolean;
+    source: 'env' | 'missing';
+    base_url: string | null;
+    default_model: string;
+}
+export interface ProviderStatusResult {
+    default_model: string;
+    providers: ProviderCredentialStatus[];
+    models: ModelRegistryEntry[];
+}
+export interface NormalizedProviderUsage {
+    provider: string;
+    model: string;
+    input_tokens: number;
+    output_tokens: number;
+    cost_usd: number;
+    metadata: Record<string, unknown>;
+}
+type ProviderFactory = (settings: {
+    apiKey: string;
+    baseURL?: string;
+}) => unknown;
+export interface AiProviderRuntimeOptions {
+    config?: KnowledgeConfig;
+    env?: Record<string, string | undefined>;
+    factories?: Partial<Record<AiProviderId, ProviderFactory>>;
+}
+export declare function providerSettings(config: KnowledgeConfig | undefined, provider: AiProviderId): AiProviderSettings;
+export declare function modelAliases(config?: KnowledgeConfig): Record<string, string>;
+export declare function parseModelRef(modelRef: string): {
+    provider: AiProviderId;
+    model: string;
+};
+export declare function resolveModelRef(aliasOrRef: string, config?: KnowledgeConfig): string;
+export declare function listModelRegistry(config?: KnowledgeConfig): ModelRegistryEntry[];
+export declare function providerCredentialStatus(config: KnowledgeConfig | undefined, env?: Record<string, string | undefined>): ProviderCredentialStatus[];
+export declare function providerStatus(config?: KnowledgeConfig, env?: Record<string, string | undefined>): ProviderStatusResult;
+export declare function assertProviderCredentials(provider: AiProviderId, config?: KnowledgeConfig, env?: Record<string, string | undefined>): ProviderCredentialStatus;
+export declare function createAiSdkProviderRegistry(options?: AiProviderRuntimeOptions): Promise<import("ai").ProviderRegistryProvider<never, ":">>;
+export declare function languageModelFor(aliasOrRef: string, options?: AiProviderRuntimeOptions): Promise<import("@ai-sdk/provider").LanguageModelV3>;
+export declare function normalizeAiSdkUsage(input: {
+    provider: string;
+    model: string;
+    usage?: Record<string, unknown> | null;
+    providerMetadata?: Record<string, unknown> | null;
+    costUsd?: number;
+}): NormalizedProviderUsage;
+export declare function recordProviderUsage(db: Database, input: NormalizedProviderUsage & {
+    run_id?: string | null;
+    created_at?: string;
+}): string;
+export declare function createDeterministicFakeProvider(provider: AiProviderId): ProviderFactory;
+export {};

package/dist/reindex.d.ts

@@ -0,0 +1,37 @@
+import { indexKnowledgeEmbeddings, type EmbeddingRuntimeOptions } from './embeddings';
+import type { KnowledgeConfig } from './workspace';
+export interface ReindexRuntimeOptions extends EmbeddingRuntimeOptions {
+    dbPath: string;
+    config?: KnowledgeConfig;
+    now?: Date;
+}
+export interface ReindexHealthResult {
+    schema_version: number;
+    chunks: number;
+    vector_entries: number;
+    missing_embeddings: number;
+    queued: Record<string, number>;
+    stale_revisions: number;
+}
+export interface ReindexEnqueueResult {
+    enqueued: number;
+    already_queued: number;
+    reason: string;
+}
+export interface ReindexEmbeddingsResult {
+    run_id: string;
+    full: boolean;
+    deleted_embeddings: number;
+    deleted_vector_entries: number;
+    queued: ReindexEnqueueResult;
+    indexed: Awaited<ReturnType<typeof indexKnowledgeEmbeddings>>;
+    completed_queue_items: number;
+}
+export declare function reindexHealth(options: ReindexRuntimeOptions): ReindexHealthResult;
+export declare function enqueueMissingEmbeddings(options: ReindexRuntimeOptions & {
+    reason?: string;
+}): ReindexEnqueueResult;
+export declare function refreshEmbeddingIndex(options: ReindexRuntimeOptions & {
+    full?: boolean;
+    limit?: number;
+}): Promise<ReindexEmbeddingsResult>;

package/dist/remote-client.d.ts

@@ -0,0 +1,108 @@
+import type { KnowledgeConfig } from './workspace';
+export declare const REMOTE_KNOWLEDGE_CONTRACT_VERSION: 1;
+export type RemoteKnowledgeRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'canceled';
+export interface RemoteKnowledgeSourceContract {
+    owner: 'open-files';
+    preferred_ref: 'open-files';
+    allowed_schemes: string[];
+    raw_source_bytes_stored_in_open_knowledge: false;
+}
+export interface RemoteKnowledgeArtifactContract {
+    storage_type: 'local' | 's3' | 'managed';
+    uri_prefix: string | null;
+    generated_only: true;
+}
+export interface RemoteKnowledgeRegistryContract {
+    contract_version: typeof REMOTE_KNOWLEDGE_CONTRACT_VERSION;
+    service: 'open-knowledge';
+    mode: 'local' | 'hosted';
+    capabilities: string[];
+    endpoints: {
+        registry: string;
+        search: string;
+        ask: string;
+        build: string;
+        sync: string;
+        run_status: string;
+        run_logs: string;
+        run_artifacts: string;
+    };
+    source_contract: RemoteKnowledgeSourceContract;
+    artifact_contract: RemoteKnowledgeArtifactContract;
+}
+export interface RemoteKnowledgeRunContract {
+    contract_version: typeof REMOTE_KNOWLEDGE_CONTRACT_VERSION;
+    id?: string;
+    type?: 'search' | 'ask' | 'build' | 'sync' | 'artifact' | 'status';
+    status?: RemoteKnowledgeRunStatus | string;
+    query?: string;
+    prompt?: string;
+    output_preview?: unknown;
+    citations?: unknown[];
+    artifacts?: unknown[];
+    usage?: Record<string, unknown>;
+    created_at?: string;
+    started_at?: string;
+    completed_at?: string;
+    duration_ms?: number;
+    error_code?: string;
+    error_message?: string;
+    error?: string;
+    details?: unknown;
+}
+export interface RemoteKnowledgeSearchRequest {
+    query: string;
+    limit?: number;
+    semantic?: boolean;
+    source_refs?: string[];
+}
+export interface RemoteKnowledgePromptRequest extends RemoteKnowledgeSearchRequest {
+    prompt: string;
+    generate?: boolean;
+    approve_write?: boolean;
+}
+export interface RemoteKnowledgeSyncRequest {
+    source_refs?: string[];
+    artifact_prefix?: string;
+    mode?: 'pull' | 'push' | 'both';
+}
+export interface RemoteKnowledgeLogEntry {
+    id?: string;
+    run_id?: string;
+    level?: string;
+    event?: string;
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+export interface RemoteKnowledgeArtifact {
+    id?: string;
+    uri?: string;
+    key?: string;
+    kind?: string;
+    content_type?: string;
+    hash?: string;
+    size_bytes?: number;
+    metadata?: Record<string, unknown>;
+}
+export declare function normalizeRemoteKnowledgeRunContract(payload: unknown, fallback?: Partial<RemoteKnowledgeRunContract>): RemoteKnowledgeRunContract;
+export declare function knowledgeRegistryContract(input: {
+    mode: 'local' | 'hosted';
+    sourceSchemes: string[];
+    storageType: 'local' | 's3' | 'managed';
+    artifactUriPrefix: string | null;
+}): RemoteKnowledgeRegistryContract;
+export declare class RemoteKnowledgeClient {
+    private readonly apiKey;
+    private readonly apiUrl;
+    constructor(apiKey: string, apiUrl: string);
+    static fromConfig(config?: KnowledgeConfig, env?: Record<string, string | undefined>): RemoteKnowledgeClient | null;
+    private request;
+    registry(): Promise<RemoteKnowledgeRegistryContract>;
+    search(request: RemoteKnowledgeSearchRequest): Promise<RemoteKnowledgeRunContract>;
+    ask(request: RemoteKnowledgePromptRequest): Promise<RemoteKnowledgeRunContract>;
+    build(request: RemoteKnowledgePromptRequest): Promise<RemoteKnowledgeRunContract>;
+    sync(request?: RemoteKnowledgeSyncRequest): Promise<RemoteKnowledgeRunContract>;
+    runStatus(runId: string): Promise<RemoteKnowledgeRunContract | null>;
+    runLogs(runId: string): Promise<RemoteKnowledgeLogEntry[]>;
+    runArtifacts(runId: string): Promise<RemoteKnowledgeArtifact[]>;
+}

package/dist/retrieval.d.ts

@@ -0,0 +1,71 @@
+import { type HybridSearchEntry, type HybridSearchOptions, type HybridSearchResult, type SearchProvenance } from './search';
+export interface RetrievalOptions extends HybridSearchOptions {
+    contextChars?: number;
+}
+export interface RerankedSearchEntry extends HybridSearchEntry {
+    rerank: {
+        base_score: number;
+        final_score: number;
+        exact_score: number;
+        citation_score: number;
+        freshness_score: number;
+        authority_score: number;
+    };
+}
+export interface RetrievalCitation {
+    id: string;
+    result_id: string;
+    kind: HybridSearchEntry['kind'];
+    source_uri: string | null;
+    source_ref: string | null;
+    artifact_uri: string | null;
+    artifact_path: string | null;
+    revision: string | null;
+    hash: string | null;
+    chunk_id: string | null;
+    start_offset: number | null;
+    end_offset: number | null;
+    quote: string | null;
+    provenance: SearchProvenance | null;
+}
+export interface RetrievalExcerpt {
+    id: string;
+    result_id: string;
+    citation_id: string | null;
+    kind: HybridSearchEntry['kind'];
+    text: string;
+    score: number;
+}
+export interface RetrievalGraphEvidence {
+    citations: Array<{
+        id: string;
+        chunk_id: string | null;
+        wiki_page_id: string | null;
+        source_uri: string;
+        quote: string | null;
+        start_offset: number | null;
+        end_offset: number | null;
+    }>;
+    backlinks: Array<{
+        from_page_id: string;
+        to_page_id: string;
+        label: string | null;
+    }>;
+}
+export interface KnowledgeContextPack {
+    query: string;
+    normalized_query: string;
+    created_at: string;
+    mode: HybridSearchResult['mode'];
+    warnings: string[];
+    search_counts: HybridSearchResult['counts'];
+    results: RerankedSearchEntry[];
+    citations: RetrievalCitation[];
+    excerpts: RetrievalExcerpt[];
+    graph: RetrievalGraphEvidence;
+    notes: {
+        permissions: string[];
+        freshness: string[];
+    };
+}
+export declare function retrieveKnowledgeContext(options: RetrievalOptions): Promise<KnowledgeContextPack>;

package/dist/safety.d.ts

@@ -0,0 +1,70 @@
+import type { Database } from 'bun:sqlite';
+import type { KnowledgeConfig, KnowledgeWorkspace } from './workspace';
+export type SafetyDecision = 'allow' | 'deny' | 'requires_approval';
+export interface SafetyPolicy {
+    mode: 'local' | 'hosted';
+    allowWriteRoots: string[];
+    readOnlySourceAccess: boolean;
+    network: {
+        webSearchEnabled: boolean;
+        s3ReadsEnabled: boolean;
+        allowedS3Buckets: string[];
+    };
+    redaction: {
+        enabled: boolean;
+    };
+    approvals: {
+        generatedWritesRequireApproval: boolean;
+    };
+}
+export interface SafetyAuditInput {
+    event_type: string;
+    action: string;
+    target_uri?: string | null;
+    decision: SafetyDecision | 'redacted' | 'info';
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}
+export interface RedactionFinding {
+    type: string;
+    severity: 'low' | 'medium' | 'high';
+    start: number;
+    end: number;
+}
+export interface RedactionResult {
+    text: string;
+    findings: RedactionFinding[];
+}
+export declare function resolveSafetyPolicy(config: KnowledgeConfig, workspace: KnowledgeWorkspace): SafetyPolicy;
+export declare function assertWriteAllowed(targetPath: string, policy: SafetyPolicy): void;
+export declare function assertS3ReadAllowed(uri: string, policy: SafetyPolicy): void;
+export declare function assertWebSearchAllowed(policy: SafetyPolicy): void;
+export declare function redactSecrets(text: string, policy?: Pick<SafetyPolicy, 'redaction'>): RedactionResult;
+export declare function auditId(input: SafetyAuditInput): string;
+export declare function recordAuditEvent(db: Database, input: SafetyAuditInput): string;
+export declare function recordRedactionFindings(db: Database, input: {
+    source_uri?: string | null;
+    run_id?: string | null;
+    findings: RedactionFinding[];
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}): number;
+export declare function createApprovalGate(db: Database, input: {
+    action: string;
+    target_uri?: string | null;
+    reason?: string | null;
+    approved_by?: string | null;
+    metadata?: Record<string, unknown>;
+    created_at?: string;
+}): {
+    id: string;
+    status: 'approved';
+};
+export declare function hasApproval(db: Database, action: string, targetUri?: string | null): boolean;
+export declare function approvalStatus(db: Database, policy: SafetyPolicy, action: string, targetUri?: string | null): {
+    action: string;
+    target_uri: string | null;
+    approval_required: boolean;
+    approved: boolean;
+    decision: SafetyDecision;
+};

package/dist/sdk.d.ts

@@ -0,0 +1,72 @@
+import { KnowledgeService, type KnowledgeServiceOptions } from './service.js';
+export type KnowledgeClientOptions = KnowledgeServiceOptions;
+export type KnowledgeSetupOptions = Parameters<KnowledgeService['setup']>[0];
+export type KnowledgeAuthInput = Parameters<KnowledgeService['saveAuth']>[0];
+export type KnowledgeAskOptions = Omit<Parameters<KnowledgeService['runPrompt']>[0], 'prompt'>;
+export type KnowledgeSearchOptions = Parameters<KnowledgeService['search']>[0];
+export type KnowledgeContextOptions = Parameters<KnowledgeService['retrieveContext']>[0];
+export type KnowledgeWebSearchOptions = Parameters<KnowledgeService['webSearch']>[0];
+export interface KnowledgeClient {
+    /**
+     * Escape hatch for advanced integrations. Prefer the grouped SDK methods for
+     * app-facing code; this service may expose lower-level operations over time.
+     */
+    readonly unstable_service: KnowledgeService;
+    readonly paths: () => ReturnType<KnowledgeService['paths']>;
+    readonly setup: (options?: KnowledgeSetupOptions) => ReturnType<KnowledgeService['setup']>;
+    readonly auth: {
+        readonly status: (env?: Record<string, string | undefined>) => ReturnType<KnowledgeService['authStatus']>;
+        readonly login: (input: KnowledgeAuthInput, env?: Record<string, string | undefined>) => ReturnType<KnowledgeService['saveAuth']>;
+        readonly logout: (env?: Record<string, string | undefined>) => ReturnType<KnowledgeService['clearAuth']>;
+    };
+    readonly remote: {
+        readonly contract: () => ReturnType<KnowledgeService['remoteContract']>;
+        readonly client: (env?: Record<string, string | undefined>) => ReturnType<KnowledgeService['remoteClient']>;
+    };
+    readonly storage: {
+        readonly status: () => ReturnType<KnowledgeService['storageContract']>;
+        readonly validate: () => ReturnType<KnowledgeService['validateStorage']>;
+        readonly artifactStore: () => ReturnType<KnowledgeService['artifactStore']>;
+    };
+    readonly db: {
+        readonly init: () => ReturnType<KnowledgeService['initDb']>;
+        readonly stats: () => ReturnType<KnowledgeService['dbStats']>;
+    };
+    readonly wiki: {
+        readonly init: () => ReturnType<KnowledgeService['initWiki']>;
+        readonly compile: (options?: Parameters<KnowledgeService['compileWiki']>[0]) => ReturnType<KnowledgeService['compileWiki']>;
+        readonly fileAnswer: (options: Parameters<KnowledgeService['fileAnswer']>[0]) => ReturnType<KnowledgeService['fileAnswer']>;
+        readonly lint: () => ReturnType<KnowledgeService['lintWiki']>;
+    };
+    readonly ingest: {
+        readonly manifest: (input: string) => ReturnType<KnowledgeService['ingestManifest']>;
+        readonly source: (sourceRef: string, purpose?: string) => ReturnType<KnowledgeService['ingestSource']>;
+    };
+    readonly sources: {
+        readonly resolve: (sourceRef: string, options?: Parameters<KnowledgeService['resolveSource']>[1]) => ReturnType<KnowledgeService['resolveSource']>;
+        readonly consumeOutbox: (input: string) => ReturnType<KnowledgeService['consumeOutbox']>;
+    };
+    readonly reindex: {
+        readonly health: (options?: Parameters<KnowledgeService['reindexHealth']>[0]) => ReturnType<KnowledgeService['reindexHealth']>;
+        readonly enqueue: (options?: Parameters<KnowledgeService['enqueueReindex']>[0]) => ReturnType<KnowledgeService['enqueueReindex']>;
+        readonly refreshEmbeddings: (options?: Parameters<KnowledgeService['refreshEmbeddings']>[0]) => ReturnType<KnowledgeService['refreshEmbeddings']>;
+    };
+    readonly providers: {
+        readonly status: (env?: Record<string, string | undefined>) => ReturnType<KnowledgeService['providerStatus']>;
+        readonly models: () => ReturnType<KnowledgeService['modelRegistry']>;
+    };
+    readonly embeddings: {
+        readonly status: () => ReturnType<KnowledgeService['embeddingStatus']>;
+        readonly index: (options?: Parameters<KnowledgeService['indexEmbeddings']>[0]) => ReturnType<KnowledgeService['indexEmbeddings']>;
+        readonly search: (options: Parameters<KnowledgeService['semanticSearch']>[0]) => ReturnType<KnowledgeService['semanticSearch']>;
+    };
+    readonly search: (options: KnowledgeSearchOptions) => ReturnType<KnowledgeService['search']>;
+    readonly retrieveContext: (options: KnowledgeContextOptions) => ReturnType<KnowledgeService['retrieveContext']>;
+    readonly ask: (prompt: string, options?: KnowledgeAskOptions) => ReturnType<KnowledgeService['runPrompt']>;
+    readonly build: (prompt: string, options?: KnowledgeAskOptions) => ReturnType<KnowledgeService['runPrompt']>;
+    readonly web: {
+        readonly search: (options: KnowledgeWebSearchOptions) => ReturnType<KnowledgeService['webSearch']>;
+    };
+}
+export declare function createKnowledgeClient(options?: KnowledgeClientOptions): KnowledgeClient;
+export declare const createKnowledgeSdk: typeof createKnowledgeClient;

package/dist/search.d.ts

@@ -0,0 +1,65 @@
+import { type EmbeddingRuntimeOptions } from './embeddings';
+import { type GeneratedArtifactProvenance, type KnowledgeProvenance } from './provenance';
+import type { KnowledgeConfig } from './workspace';
+export type SearchResultKind = 'source_chunk' | 'wiki_chunk' | 'wiki_page' | 'knowledge_index';
+export type SearchProvenance = KnowledgeProvenance | GeneratedArtifactProvenance;
+export interface HybridSearchOptions extends EmbeddingRuntimeOptions {
+    dbPath: string;
+    query: string;
+    limit?: number;
+    semantic?: boolean;
+    config?: KnowledgeConfig;
+}
+export interface HybridSearchResult {
+    query: string;
+    limit: number;
+    mode: {
+        keyword: true;
+        catalog: true;
+        semantic: boolean;
+    };
+    semantic_provider: string | null;
+    semantic_model: string | null;
+    semantic_dimensions: number | null;
+    counts: {
+        keyword_results: number;
+        catalog_results: number;
+        semantic_results: number;
+        merged_results: number;
+    };
+    warnings: string[];
+    results: HybridSearchEntry[];
+}
+export interface HybridSearchEntry {
+    kind: SearchResultKind;
+    id: string;
+    title: string | null;
+    text: string | null;
+    score: number;
+    scores: {
+        keyword?: number;
+        semantic?: number;
+        catalog?: number;
+    };
+    source: {
+        uri: string | null;
+        ref: string | null;
+        kind: string | null;
+        revision: string | null;
+        hash: string | null;
+    } | null;
+    citation: {
+        chunk_id: string | null;
+        start_offset: number | null;
+        end_offset: number | null;
+    } | null;
+    artifact: {
+        uri: string | null;
+        path: string | null;
+        hash: string | null;
+        shard_key: string | null;
+    } | null;
+    provenance: SearchProvenance | null;
+    reasons: string[];
+}
+export declare function hybridSearch(options: HybridSearchOptions): Promise<HybridSearchResult>;