@j0hanz/memdb 1.1.5 → 1.2.1

package/dist/schemas.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { MEMORY_TYPES } from './types.js';
 const hashSchema = z.string().regex(/^[a-f0-9]{32}$/i);
 const tagSchema = z
     .string()
@@ -8,17 +9,36 @@ const tagSchema = z
 const tagsSchema = z.array(tagSchema);
 const contentSchema = z.string().min(1).max(100000);
 const querySchema = z.string().trim().min(1).max(1000);
+const importanceSchema = z.number().int().min(0).max(10);
+const memoryTypeSchema = z.enum(MEMORY_TYPES);
+const relationTypeSchema = z
+    .string()
+    .min(1)
+    .max(50)
+    .regex(/^\S+$/, 'Relation type must not contain whitespace');
 export const StoreMemoryInputSchema = z.strictObject({
     content: contentSchema.meta({ description: 'The content of the memory' }),
     tags: tagsSchema.min(1).max(100).meta({
         description: 'Tags to categorize the memory (1-100 tags, no whitespace, max 50 chars each)',
     }),
+    importance: importanceSchema.optional().meta({
+        description: 'Priority level 0-10 (0=lowest, 10=critical). Higher importance memories surface first in search.',
+    }),
+    memory_type: memoryTypeSchema.optional().meta({
+        description: 'Category: general, fact, plan, decision, reflection, lesson, error, gradient',
+    }),
 });
 const StoreMemoryItemSchema = z.strictObject({
     content: contentSchema.meta({ description: 'The content of the memory' }),
     tags: tagsSchema.min(1).max(100).meta({
         description: 'Tags to categorize the memory',
     }),
+    importance: importanceSchema.optional().meta({
+        description: 'Priority level 0-10 (0=lowest, 10=critical)',
+    }),
+    memory_type: memoryTypeSchema.optional().meta({
+        description: 'Category: general, fact, plan, decision, reflection, lesson, error, gradient',
+    }),
 });
 export const StoreMemoriesInputSchema = z.strictObject({
     items: z.array(StoreMemoryItemSchema).min(1).max(50).meta({
@@ -52,6 +72,44 @@ export const UpdateMemoryInputSchema = z.strictObject({
 export const MemoryStatsInputSchema = z
     .strictObject({})
     .meta({ description: 'No parameters required' });
+export const CreateRelationshipInputSchema = z.strictObject({
+    from_hash: hashSchema.meta({
+        description: 'MD5 hash of the source memory',
+    }),
+    to_hash: hashSchema.meta({
+        description: 'MD5 hash of the target memory',
+    }),
+    relation_type: relationTypeSchema.meta({
+        description: 'Type of relationship (e.g., "related_to", "causes", "depends_on", "part_of", "follows")',
+    }),
+});
+export const GetRelationshipsInputSchema = z.strictObject({
+    hash: hashSchema.meta({
+        description: 'MD5 hash of the memory to get relationships for',
+    }),
+    direction: z.enum(['outgoing', 'incoming', 'both']).optional().meta({
+        description: 'Direction: outgoing (from this memory), incoming (to this memory), both (default)',
+    }),
+});
+export const DeleteRelationshipInputSchema = z.strictObject({
+    from_hash: hashSchema.meta({
+        description: 'MD5 hash of the source memory',
+    }),
+    to_hash: hashSchema.meta({
+        description: 'MD5 hash of the target memory',
+    }),
+    relation_type: relationTypeSchema.meta({
+        description: 'Type of relationship to delete',
+    }),
+});
+export const RecallInputSchema = z.strictObject({
+    query: querySchema.meta({
+        description: 'Search query to find initial memories',
+    }),
+    depth: z.number().int().min(0).max(3).optional().meta({
+        description: 'How many relationship hops to follow (0-3, default 1). 0 = search only, no graph traversal.',
+    }),
+});
 const ErrorSchema = z.strictObject({
     code: z.string(),
     message: z.string(),

package/dist/stdio-transport.d.ts

@@ -0,0 +1,29 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Stdio transport that explicitly rejects JSON-RPC batch arrays.
+ *
+ * MCP protocol revisions >= 2025-06-18 removed JSON-RPC batching; servers must reject array payloads.
+ */
+export declare class BatchRejectingStdioServerTransport implements Transport {
+    onclose: () => void;
+    onerror: (error: Error) => void;
+    onmessage: NonNullable<Transport['onmessage']>;
+    private readonly stdin;
+    private readonly stdout;
+    private readonly readBuffer;
+    private started;
+    private readonly onData;
+    private readonly onStdinError;
+    constructor(stdin?: NodeJS.ReadableStream, stdout?: NodeJS.WritableStream);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+    private sendInvalidRequest;
+    private sendInvalidRequestUnknownId;
+    private sendParseError;
+    private handleBatch;
+    private handleNonBatch;
+    private handleLine;
+    private processReadBuffer;
+}

package/dist/stdio-transport.js

@@ -0,0 +1,250 @@
+import process from 'node:process';
+import { JSONRPCMessageSchema } from '@modelcontextprotocol/sdk/types.js';
+const MAX_LINE_BYTES = 16 * 1024 * 1024;
+class LineBuffer {
+    maxBytes;
+    chunks = [];
+    totalLength = 0;
+    constructor(maxBytes) {
+        this.maxBytes = maxBytes;
+    }
+    append(chunk) {
+        this.chunks.push(chunk);
+        this.totalLength += chunk.length;
+    }
+    readLine() {
+        if (this.totalLength === 0)
+            return null;
+        const found = this.findNewline();
+        if (!found) {
+            this.assertLineLength(this.totalLength);
+            return null;
+        }
+        const lineLength = found.offset + found.newlineIndex;
+        this.assertLineLength(lineLength);
+        const lineBuffer = this.buildLineBuffer(found.chunkIndex, found.newlineIndex, lineLength);
+        this.consumeLine(found.chunkIndex, found.newlineIndex, lineLength);
+        return lineBuffer.toString('utf8').replace(/\r$/, '');
+    }
+    assertLineLength(length) {
+        if (length > this.maxBytes) {
+            throw new Error('Input line exceeds maximum size');
+        }
+    }
+    findNewline() {
+        let offset = 0;
+        for (let i = 0; i < this.chunks.length; i++) {
+            const chunk = this.chunks[i];
+            if (!chunk)
+                continue;
+            const newlineIndex = chunk.indexOf('\n');
+            if (newlineIndex !== -1) {
+                return { chunkIndex: i, newlineIndex, offset };
+            }
+            offset += chunk.length;
+        }
+        return null;
+    }
+    buildLineBuffer(chunkIndex, newlineIndex, lineLength) {
+        const lineBuffer = Buffer.allocUnsafe(lineLength);
+        let writeOffset = 0;
+        for (let i = 0; i < chunkIndex; i++) {
+            const part = this.chunks[i];
+            if (!part)
+                continue;
+            part.copy(lineBuffer, writeOffset);
+            writeOffset += part.length;
+        }
+        const chunk = this.chunks[chunkIndex];
+        if (chunk && newlineIndex > 0) {
+            chunk.copy(lineBuffer, writeOffset, 0, newlineIndex);
+        }
+        return lineBuffer;
+    }
+    consumeLine(chunkIndex, newlineIndex, lineLength) {
+        const remaining = [];
+        const chunk = this.chunks[chunkIndex];
+        if (chunk) {
+            const rest = chunk.subarray(newlineIndex + 1);
+            if (rest.length > 0)
+                remaining.push(rest);
+        }
+        for (let i = chunkIndex + 1; i < this.chunks.length; i++) {
+            const tail = this.chunks[i];
+            if (!tail)
+                continue;
+            remaining.push(tail);
+        }
+        this.chunks = remaining;
+        this.totalLength -= lineLength + 1;
+    }
+    clear() {
+        this.chunks = [];
+        this.totalLength = 0;
+    }
+}
+const isObject = (value) => typeof value === 'object' && value !== null;
+const getRequestIdResult = (value) => {
+    if (!isObject(value))
+        return { ok: false, reason: 'missing' };
+    const candidate = Reflect.get(value, 'id');
+    if (candidate === undefined)
+        return { ok: false, reason: 'missing' };
+    if (typeof candidate === 'string' || typeof candidate === 'number') {
+        return { ok: true, id: candidate };
+    }
+    return { ok: false, reason: 'invalid-type' };
+};
+const invalidRequestError = (id) => id === undefined
+    ? {
+        jsonrpc: '2.0',
+        error: {
+            code: -32600,
+            message: 'Invalid request',
+        },
+    }
+    : {
+        jsonrpc: '2.0',
+        id,
+        error: {
+            code: -32600,
+            message: 'Invalid request',
+        },
+    };
+const parseError = () => ({
+    jsonrpc: '2.0',
+    error: {
+        code: -32700,
+        message: 'Parse error',
+    },
+});
+/**
+ * Stdio transport that explicitly rejects JSON-RPC batch arrays.
+ *
+ * MCP protocol revisions >= 2025-06-18 removed JSON-RPC batching; servers must reject array payloads.
+ */
+export class BatchRejectingStdioServerTransport {
+    onclose = () => { };
+    onerror = () => { };
+    onmessage = () => { };
+    stdin;
+    stdout;
+    readBuffer = new LineBuffer(MAX_LINE_BYTES);
+    started = false;
+    // Arrow functions keep identity for off().
+    onData = (chunk) => {
+        try {
+            this.readBuffer.append(chunk);
+            this.processReadBuffer();
+        }
+        catch (error) {
+            this.onerror(error instanceof Error ? error : new Error(String(error)));
+        }
+    };
+    onStdinError = (error) => {
+        this.onerror(error);
+    };
+    constructor(stdin = process.stdin, stdout = process.stdout) {
+        this.stdin = stdin;
+        this.stdout = stdout;
+    }
+    start() {
+        if (this.started) {
+            throw new Error('BatchRejectingStdioServerTransport already started! If using McpServer.connect(), note that connect() calls start() automatically.');
+        }
+        this.started = true;
+        this.stdin.on('data', this.onData);
+        this.stdin.on('error', this.onStdinError);
+        return Promise.resolve();
+    }
+    close() {
+        this.stdin.off('data', this.onData);
+        this.stdin.off('error', this.onStdinError);
+        const remainingDataListeners = this.stdin.listenerCount('data');
+        if (remainingDataListeners === 0) {
+            this.stdin.pause();
+        }
+        this.readBuffer.clear();
+        this.onclose();
+        return Promise.resolve();
+    }
+    send(message) {
+        return new Promise((resolve) => {
+            const json = `${JSON.stringify(message)}\n`;
+            if (this.stdout.write(json)) {
+                resolve();
+            }
+            else {
+                this.stdout.once('drain', resolve);
+            }
+        });
+    }
+    sendInvalidRequest(id) {
+        void this.send(invalidRequestError(id));
+    }
+    sendInvalidRequestUnknownId() {
+        void this.send(invalidRequestError());
+    }
+    sendParseError() {
+        void this.send(parseError());
+    }
+    handleBatch(raw) {
+        let sentAny = false;
+        for (const item of raw) {
+            const idResult = getRequestIdResult(item);
+            if (!idResult.ok)
+                continue;
+            this.sendInvalidRequest(idResult.id);
+            sentAny = true;
+        }
+        if (!sentAny) {
+            this.sendInvalidRequestUnknownId();
+        }
+    }
+    handleNonBatch(raw) {
+        const idResult = getRequestIdResult(raw);
+        if (idResult.ok) {
+            this.sendInvalidRequest(idResult.id);
+            return;
+        }
+        if (idResult.reason === 'invalid-type') {
+            this.sendInvalidRequestUnknownId();
+        }
+    }
+    handleLine(line) {
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            this.sendParseError();
+            return;
+        }
+        if (Array.isArray(raw)) {
+            this.handleBatch(raw);
+            return;
+        }
+        const parsed = JSONRPCMessageSchema.safeParse(raw);
+        if (!parsed.success) {
+            this.handleNonBatch(raw);
+            return;
+        }
+        this.onmessage(parsed.data);
+    }
+    processReadBuffer() {
+        try {
+            for (let line = this.readBuffer.readLine(); line !== null; line = this.readBuffer.readLine()) {
+                try {
+                    this.handleLine(line);
+                }
+                catch (error) {
+                    this.onerror(error instanceof Error ? error : new Error(String(error)));
+                }
+            }
+        }
+        catch {
+            this.readBuffer.clear();
+            this.sendParseError();
+        }
+    }
+}

package/dist/tools.d.ts

@@ -1,14 +1,19 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { deleteMemories } from './core/memory-read.js';
 import { createMemories, createMemory, updateMemory } from './core/memory-write.js';
-import { searchMemories } from './core/search.js';
-import type { BatchDeleteResult, BatchStoreResult, Memory, MemoryInsertResult, MemoryStats, MemoryUpdateResult, SearchResult, StatementResult } from './types.js';
+import { createRelationship, deleteRelationship, getRelationships } from './core/relationships.js';
+import { recallMemories, searchMemories } from './core/search.js';
+import type { BatchDeleteResult, BatchStoreResult, CreateRelationshipResult, Memory, MemoryInsertResult, MemoryStats, MemoryUpdateResult, RecallResult, Relationship, SearchResult, StatementResult } from './types.js';
 type MaybePromise<T> = T | Promise<T>;
 type CreateMemoryInput = Parameters<typeof createMemory>[0];
 type CreateMemoriesInput = Parameters<typeof createMemories>[0];
 type UpdateMemoryArgs = Parameters<typeof updateMemory>;
 type SearchInput = Parameters<typeof searchMemories>[0];
 type DeleteMemoriesInput = Parameters<typeof deleteMemories>[0];
+type CreateRelationshipInput = Parameters<typeof createRelationship>[0];
+type GetRelationshipsInput = Parameters<typeof getRelationships>[0];
+type DeleteRelationshipInput = Parameters<typeof deleteRelationship>[0];
+type RecallInput = Parameters<typeof recallMemories>[0];
 export interface ToolDependencies {
     createMemory: (input: CreateMemoryInput) => MaybePromise<MemoryInsertResult>;
     createMemories: (input: CreateMemoriesInput) => MaybePromise<BatchStoreResult>;
@@ -18,6 +23,10 @@ export interface ToolDependencies {
     deleteMemories: (input: DeleteMemoriesInput) => MaybePromise<BatchDeleteResult>;
     searchMemories: (input: SearchInput) => MaybePromise<SearchResult[]>;
     getStats: () => MaybePromise<MemoryStats>;
+    createRelationship: (input: CreateRelationshipInput) => MaybePromise<CreateRelationshipResult>;
+    getRelationships: (input: GetRelationshipsInput) => MaybePromise<Relationship[]>;
+    deleteRelationship: (input: DeleteRelationshipInput) => MaybePromise<StatementResult>;
+    recallMemories: (input: RecallInput) => MaybePromise<RecallResult>;
 }
 export declare function registerAllTools(server: McpServer, deps?: ToolDependencies): void;
 export {};

package/dist/tools.js

@@ -1,7 +1,8 @@
 import { deleteMemories, deleteMemory, getMemory, getStats, } from './core/memory-read.js';
 import { createMemories, createMemory, updateMemory, } from './core/memory-write.js';
-import { searchMemories } from './core/search.js';
-import { DefaultOutputSchema, DeleteMemoriesInputSchema, DeleteMemoryInputSchema, GetMemoryInputSchema, MemoryStatsInputSchema, SearchMemoriesInputSchema, StoreMemoriesInputSchema, StoreMemoryInputSchema, UpdateMemoryInputSchema, } from './schemas.js';
+import { createRelationship, deleteRelationship, getRelationships, } from './core/relationships.js';
+import { recallMemories, searchMemories } from './core/search.js';
+import { CreateRelationshipInputSchema, DefaultOutputSchema, DeleteMemoriesInputSchema, DeleteMemoryInputSchema, DeleteRelationshipInputSchema, GetMemoryInputSchema, GetRelationshipsInputSchema, MemoryStatsInputSchema, RecallInputSchema, SearchMemoriesInputSchema, StoreMemoriesInputSchema, StoreMemoryInputSchema, UpdateMemoryInputSchema, } from './schemas.js';
 const defaultDeps = {
     createMemory,
     createMemories,
@@ -11,6 +12,10 @@ const defaultDeps = {
     deleteMemories,
     searchMemories,
     getStats,
+    createRelationship,
+    getRelationships,
+    deleteRelationship,
+    recallMemories,
 };
 const getErrorMessage = (error) => {
     if (error instanceof Error)
@@ -64,6 +69,10 @@ const buildCoreTools = (deps) => [
             const result = await deps.createMemory({
                 content: input.content,
                 tags: input.tags,
+                ...(input.importance !== undefined && { importance: input.importance }),
+                ...(input.memory_type !== undefined && {
+                    memory_type: input.memory_type,
+                }),
             });
             return ok(result);
         }),
@@ -79,7 +88,15 @@ const buildCoreTools = (deps) => [
         },
         handler: wrapHandler('E_STORE_MEMORIES', async (params) => {
             const input = StoreMemoriesInputSchema.parse(params);
-            const result = await deps.createMemories(input.items);
+            const items = input.items.map((item) => ({
+                content: item.content,
+                tags: item.tags,
+                ...(item.importance !== undefined && { importance: item.importance }),
+                ...(item.memory_type !== undefined && {
+                    memory_type: item.memory_type,
+                }),
+            }));
+            const result = await deps.createMemories(items);
             return ok(result);
         }),
     },
@@ -169,6 +186,86 @@ const buildSearchTools = (deps) => [
             return ok(result);
         }),
     },
+    {
+        name: 'recall',
+        options: {
+            title: 'Recall Memories',
+            description: 'Search for memories and traverse relationships to return a connected graph cluster. ' +
+                'Use this for deeper context retrieval that follows knowledge graph connections.',
+            inputSchema: RecallInputSchema,
+            outputSchema: DefaultOutputSchema,
+            annotations: { readOnlyHint: true },
+        },
+        handler: wrapHandler('E_RECALL', async (params) => {
+            const input = RecallInputSchema.parse(params);
+            const result = await deps.recallMemories({
+                query: input.query,
+                ...(input.depth !== undefined && { depth: input.depth }),
+            });
+            return ok(result);
+        }),
+    },
+];
+const buildRelationshipTools = (deps) => [
+    {
+        name: 'create_relationship',
+        options: {
+            title: 'Create Relationship',
+            description: 'Link two memories with a typed relationship. Creates a knowledge graph edge between memories.',
+            inputSchema: CreateRelationshipInputSchema,
+            outputSchema: DefaultOutputSchema,
+            annotations: { idempotentHint: true },
+        },
+        handler: wrapHandler('E_CREATE_RELATIONSHIP', async (params) => {
+            const input = CreateRelationshipInputSchema.parse(params);
+            const result = await deps.createRelationship({
+                from_hash: normalizeHash(input.from_hash),
+                to_hash: normalizeHash(input.to_hash),
+                relation_type: input.relation_type,
+            });
+            return ok(result);
+        }),
+    },
+    {
+        name: 'get_relationships',
+        options: {
+            title: 'Get Relationships',
+            description: 'Get all relationships for a memory. Returns linked memories with relationship types.',
+            inputSchema: GetRelationshipsInputSchema,
+            outputSchema: DefaultOutputSchema,
+            annotations: { readOnlyHint: true },
+        },
+        handler: wrapHandler('E_GET_RELATIONSHIPS', async (params) => {
+            const input = GetRelationshipsInputSchema.parse(params);
+            const result = await deps.getRelationships({
+                hash: normalizeHash(input.hash),
+                ...(input.direction !== undefined && { direction: input.direction }),
+            });
+            return ok(result);
+        }),
+    },
+    {
+        name: 'delete_relationship',
+        options: {
+            title: 'Delete Relationship',
+            description: 'Remove a relationship between two memories.',
+            inputSchema: DeleteRelationshipInputSchema,
+            outputSchema: DefaultOutputSchema,
+            annotations: { destructiveHint: true },
+        },
+        handler: wrapHandler('E_DELETE_RELATIONSHIP', async (params) => {
+            const input = DeleteRelationshipInputSchema.parse(params);
+            const result = await deps.deleteRelationship({
+                from_hash: normalizeHash(input.from_hash),
+                to_hash: normalizeHash(input.to_hash),
+                relation_type: input.relation_type,
+            });
+            if (result.changes === 0) {
+                return createErrorResponse('E_NOT_FOUND', 'Relationship not found');
+            }
+            return ok({ deleted: true });
+        }),
+    },
 ];
 const buildStatsTools = (deps) => [
     {
@@ -190,6 +287,7 @@ const buildStatsTools = (deps) => [
 const buildTools = (deps) => [
     ...buildCoreTools(deps),
     ...buildSearchTools(deps),
+    ...buildRelationshipTools(deps),
     ...buildStatsTools(deps),
 ];
 export function registerAllTools(server, deps = defaultDeps) {

package/dist/types.d.ts

@@ -1,7 +1,11 @@
+export declare const MEMORY_TYPES: readonly ["general", "fact", "plan", "decision", "reflection", "lesson", "error", "gradient"];
+export type MemoryType = (typeof MEMORY_TYPES)[number];
 export interface Memory {
     readonly id: number;
     readonly content: string;
     readonly summary: string | undefined;
+    readonly importance: number;
+    readonly memory_type: MemoryType;
     readonly created_at: string;
     readonly accessed_at: string;
     readonly hash: string;
@@ -28,12 +32,16 @@ export interface MemoryStats {
     readonly oldestMemory: string | null;
     readonly newestMemory: string | null;
 }
-export interface BatchStoreItemResult {
+export type BatchStoreItemResult = {
+    readonly ok: true;
     readonly index: number;
-    readonly hash?: string;
-    readonly isNew?: boolean;
-    readonly error?: string;
-}
+    readonly hash: string;
+    readonly isNew: boolean;
+} | {
+    readonly ok: false;
+    readonly index: number;
+    readonly error: string;
+};
 export interface BatchStoreResult {
     readonly results: BatchStoreItemResult[];
     readonly succeeded: number;
@@ -49,3 +57,19 @@ export interface BatchDeleteResult {
     readonly succeeded: number;
     readonly failed: number;
 }
+export interface Relationship {
+    readonly id: number;
+    readonly from_hash: string;
+    readonly to_hash: string;
+    readonly relation_type: string;
+    readonly created_at: string;
+}
+export interface CreateRelationshipResult {
+    readonly id: number;
+    readonly isNew: boolean;
+}
+export interface RecallResult {
+    readonly memories: SearchResult[];
+    readonly relationships: Relationship[];
+    readonly depth: number;
+}

package/dist/types.js

@@ -1 +1,10 @@
-export {};
+export const MEMORY_TYPES = [
+    'general',
+    'fact',
+    'plan',
+    'decision',
+    'reflection',
+    'lesson',
+    'error',
+    'gradient',
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@j0hanz/memdb",
-  "version": "1.1.5",
+  "version": "1.2.1",
   "mcpName": "io.github.j0hanz/memdb",
   "description": "A SQLite-backed MCP memory server with local workspace storage.",
   "type": "module",
@@ -18,7 +18,6 @@
     "README.md"
   ],
   "scripts": {
-    "clean": "node -e \"require('fs').rmSync('dist', {recursive: true, force: true})\"",
     "build": "tsc -p tsconfig.build.json && node -e \"require('fs').chmodSync('dist/index.js', '755')\"",
     "prepare": "npm run build",
     "dev": "tsx watch src/index.ts",
@@ -29,7 +28,7 @@
     "lint": "eslint .",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "type-check": "tsc --noEmit",
+    "type-check": "tsc -p tsconfig.json --noEmit",
     "type-check:test": "tsc -p tsconfig.test.json --noEmit",
     "inspector": "npx @modelcontextprotocol/inspector",
     "prepublishOnly": "npm run lint && npm run type-check && npm run build"
@@ -62,6 +61,7 @@
     "eslint-plugin-depend": "^1.4.0",
     "eslint-plugin-sonarjs": "^3.0.5",
     "eslint-plugin-unused-imports": "^4.3.0",
+    "knip": "^5.80.2",
     "prettier": "^3.7.4",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",

package/dist/core/database-schema.d.ts

@@ -1,2 +0,0 @@
-export declare const SCHEMA_SQL = "\n  PRAGMA foreign_keys = ON;\n  PRAGMA journal_mode = WAL;\n  PRAGMA synchronous = NORMAL;\n\n  CREATE TABLE IF NOT EXISTS memories (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    content TEXT NOT NULL,\n    summary TEXT,\n    importance INTEGER DEFAULT 0,\n    memory_type TEXT DEFAULT 'general',\n    created_at TEXT DEFAULT CURRENT_TIMESTAMP,\n    accessed_at TEXT DEFAULT CURRENT_TIMESTAMP,\n    hash TEXT UNIQUE NOT NULL\n  ) STRICT;\n\n  CREATE TABLE IF NOT EXISTS tags (\n    memory_id INTEGER NOT NULL,\n    tag TEXT NOT NULL,\n    PRIMARY KEY (memory_id, tag),\n    FOREIGN KEY (memory_id) REFERENCES memories(id) ON DELETE CASCADE\n  ) STRICT;\n\n  CREATE INDEX IF NOT EXISTS idx_tags_tag_memory_id ON tags(tag, memory_id);\n\n  CREATE TABLE IF NOT EXISTS relationships (\n    id INTEGER PRIMARY KEY AUTOINCREMENT,\n    from_memory_id INTEGER NOT NULL,\n    to_memory_id INTEGER NOT NULL,\n    relation_type TEXT NOT NULL,\n    created_at TEXT DEFAULT CURRENT_TIMESTAMP,\n    FOREIGN KEY (from_memory_id) REFERENCES memories(id) ON DELETE CASCADE,\n    FOREIGN KEY (to_memory_id) REFERENCES memories(id) ON DELETE CASCADE,\n    UNIQUE(from_memory_id, to_memory_id, relation_type)\n  ) STRICT;\n\n  CREATE INDEX IF NOT EXISTS idx_relationships_to_memory_id ON relationships(to_memory_id);\n\n  CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(\n    content,\n    summary,\n    content_rowid='id'\n  );\n\n  CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN\n    INSERT INTO memories_fts(rowid, content, summary)\n    VALUES (new.id, new.content, new.summary);\n  END;\n\n  CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN\n    DELETE FROM memories_fts WHERE rowid = old.id;\n    INSERT INTO memories_fts(rowid, content, summary)\n    VALUES (new.id, new.content, new.summary);\n  END;\n\n  CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN\n    DELETE FROM memories_fts WHERE rowid = old.id;\n  END;\n";
-export declare const FTS_SYNC_SQL = "\n  INSERT INTO memories_fts(rowid, content, summary)\n  SELECT id, content, summary FROM memories\n  WHERE id NOT IN (SELECT rowid FROM memories_fts);\n";

package/dist/core/database-schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"database-schema.d.ts","sourceRoot":"","sources":["../../src/core/database-schema.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU,28DA0DtB,CAAC;AAEF,eAAO,MAAM,YAAY,8JAIxB,CAAC"}