memorandum-mcp 0.1.0

package/dist/document-store.d.ts

@@ -0,0 +1,145 @@
+import type { Logger } from 'pino';
+import type { Config, ResolvedPaths } from './config.js';
+import type { IndexFile, DocumentRestoreResult } from './document-types.js';
+import type { SemanticIndex } from './semantic-index.js';
+/**
+ * Manages document storage, indexing, and CRUD operations.
+ * Supports inline (markdown with frontmatter) and binary (blob with YAML sidecar) documents.
+ */
+export declare class DocumentStore {
+    private readonly config;
+    private readonly logger;
+    private readonly documentsPath;
+    private readonly blobsPath;
+    private readonly indexPath;
+    private index;
+    private semanticIndex;
+    private dirty;
+    constructor(config: Config, paths: ResolvedPaths, logger: Logger);
+    /** Assigns the semantic index used for embedding-based search. */
+    setSemanticIndex(index: SemanticIndex): void;
+    /** Creates the documents and blobs directories if they do not already exist. */
+    ensureDirectories(): void;
+    /** Loads the document index from disk, rebuilding it if the file is missing or corrupt. */
+    loadIndex(): void;
+    /**
+     * Persists the in-memory index to disk if it has been modified.
+     * @returns `true` if the index was written, `false` if no save was needed.
+     */
+    saveIndex(): boolean;
+    /** Reconstructs the index by scanning all document files on disk. */
+    rebuildIndex(): void;
+    /**
+     * Extracts YAML frontmatter and body from a markdown string.
+     * @param content - Raw file content with optional `---` delimited frontmatter.
+     * @returns Parsed metadata object and the remaining body text.
+     */
+    parseFrontmatter(content: string): {
+        metadata: Record<string, unknown>;
+        body: string;
+    };
+    /**
+     * Combines metadata and body into a markdown string with YAML frontmatter.
+     * @param metadata - Key-value pairs to serialize as frontmatter.
+     * @param body - The document body text.
+     * @returns Formatted string with `---` delimited frontmatter followed by the body.
+     */
+    serializeFrontmatter(metadata: Record<string, unknown>, body: string): string;
+    /**
+     * Writes a file atomically by writing to a temporary file first, then renaming.
+     * @param filePath - Destination file path.
+     * @param content - String or Buffer content to write.
+     */
+    atomicWriteFile(filePath: string, content: string | Buffer): void;
+    /**
+     * Generates and returns the next unique document ID (e.g., `doc-001`).
+     * Increments the internal counter and marks the index as dirty.
+     */
+    getNextId(): string;
+    /** Returns the current in-memory index. */
+    getIndex(): IndexFile;
+    /** Replaces the in-memory index with the provided one. */
+    setIndex(index: IndexFile): void;
+    /** Absolute path to the documents directory. */
+    get documentsDir(): string;
+    /** Absolute path to the blobs subdirectory. */
+    get blobsDir(): string;
+    /** Maximum allowed document size in bytes. */
+    get maxDocumentSize(): number;
+    private validateDocumentId;
+    private validateBodySize;
+    private validateMetadataKeys;
+    private resolveFilePath;
+    private injectFileContent;
+    /**
+     * Creates or updates a document based on the `_mode` field.
+     * Handles both inline (text) and binary content, including file imports.
+     * @returns The document ID and whether it was newly created.
+     */
+    write(input: {
+        _mode: 'create' | 'update';
+        id?: string;
+        title?: string;
+        content_type?: string;
+        topic?: string;
+        description?: string;
+        tags?: string[];
+        body?: string;
+        file_path?: string;
+        metadata?: Record<string, unknown>;
+    }): {
+        id: string;
+        created: boolean;
+    };
+    private writeCreate;
+    private writeUpdate;
+    /**
+     * Reads a document by ID, returning its metadata and optionally its body content.
+     * @param input.id - Document ID (e.g., `doc-001`).
+     * @param input.include_body - Whether to include the body content (defaults to `true`).
+     * @returns Document metadata and body. Binary bodies are base64-encoded.
+     */
+    read(input: {
+        id: string;
+        include_body?: boolean;
+    }): Record<string, unknown>;
+    /**
+     * Lists documents matching the given filters.
+     * Supports filtering by tag, topic, content type, text search, and custom metadata.
+     * @returns Matching documents (up to `limit`) and the total count.
+     */
+    list(input: {
+        tag?: string;
+        topic?: string;
+        content_type?: string;
+        search?: string;
+        metadata?: Record<string, unknown>;
+        limit?: number;
+    }): {
+        documents: Record<string, unknown>[];
+        total: number;
+    };
+    /**
+     * Deletes a document by ID, removing its files from disk and the index entry.
+     * @param input.id - Document ID to delete.
+     * @returns `{ deleted: true }` if found and removed, `{ deleted: false }` if not found.
+     */
+    delete(input: {
+        id: string;
+    }): {
+        deleted: boolean;
+    };
+    /**
+     * Restores a document from the store to a file on disk.
+     * Verifies SHA256 integrity for binary documents. Refuses to overwrite
+     * existing files unless force=true.
+     *
+     * @param input - Restore parameters: id, target_path, force
+     * @returns Result with success status, path, and optional integrity info
+     */
+    restore(input: {
+        id: string;
+        target_path: string;
+        force: boolean;
+    }): DocumentRestoreResult;
+}