cozo-memory 1.0.5 → 1.0.7

package/dist/cli.js

@@ -0,0 +1,490 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Pure CLI for CozoDB Memory
+ * Usage: cozo-memory <command> [options]
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const cli_commands_js_1 = require("./cli-commands.js");
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs"));
+const program = new commander_1.Command();
+const cli = new cli_commands_js_1.CLICommands();
+// Helper to format output
+function formatOutput(data, format = 'pretty') {
+    if (format === 'json') {
+        console.log(JSON.stringify(data, null, 2));
+    }
+    else {
+        console.log(chalk_1.default.cyan(JSON.stringify(data, null, 2)));
+    }
+}
+// Helper to handle errors
+function handleError(error) {
+    console.error(chalk_1.default.red('Error:'), error.message || error);
+    process.exit(1);
+}
+program
+    .name('cozo-memory')
+    .description('CLI for CozoDB Memory - Local-first persistent memory for AI agents')
+    .version('1.0.6');
+// Entity commands
+const entity = program.command('entity').description('Entity operations');
+entity
+    .command('create')
+    .description('Create a new entity')
+    .requiredOption('-n, --name <name>', 'Entity name')
+    .requiredOption('-t, --type <type>', 'Entity type')
+    .option('-m, --metadata <json>', 'Metadata as JSON string')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+        const result = await cli.createEntity(options.name, options.type, metadata);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+entity
+    .command('get')
+    .description('Get entity details')
+    .requiredOption('-i, --id <id>', 'Entity ID')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.getEntity(options.id);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+entity
+    .command('delete')
+    .description('Delete an entity')
+    .requiredOption('-i, --id <id>', 'Entity ID')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.deleteEntity(options.id);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// Observation commands
+const observation = program.command('observation').alias('obs').description('Observation operations');
+observation
+    .command('add')
+    .description('Add observation to entity')
+    .requiredOption('-i, --entity-id <id>', 'Entity ID')
+    .requiredOption('-t, --text <text>', 'Observation text')
+    .option('-m, --metadata <json>', 'Metadata as JSON string')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+        const result = await cli.addObservation(options.entityId, options.text, metadata);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// Relation commands
+const relation = program.command('relation').alias('rel').description('Relation operations');
+relation
+    .command('create')
+    .description('Create relation between entities')
+    .requiredOption('--from <id>', 'From entity ID')
+    .requiredOption('--to <id>', 'To entity ID')
+    .requiredOption('--type <type>', 'Relation type')
+    .option('-s, --strength <number>', 'Relation strength (0-1)', parseFloat)
+    .option('-m, --metadata <json>', 'Metadata as JSON string')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+        const result = await cli.createRelation(options.from, options.to, options.type, options.strength, metadata);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// Search commands
+const search = program.command('search').description('Search operations');
+search
+    .command('query')
+    .description('Search memory')
+    .requiredOption('-q, --query <query>', 'Search query')
+    .option('-l, --limit <number>', 'Result limit', parseInt, 10)
+    .option('-t, --types <types>', 'Entity types (comma-separated)')
+    .option('--no-entities', 'Exclude entities')
+    .option('--no-observations', 'Exclude observations')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const entityTypes = options.types ? options.types.split(',') : undefined;
+        const result = await cli.search(options.query, options.limit, entityTypes, options.entities, options.observations);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+search
+    .command('context')
+    .description('Get contextual information')
+    .requiredOption('-q, --query <query>', 'Context query')
+    .option('-w, --window <number>', 'Context window', parseInt)
+    .option('-h, --hours <number>', 'Time range in hours', parseInt)
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.context(options.query, options.window, options.hours);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// Graph commands
+const graph = program.command('graph').description('Graph operations');
+graph
+    .command('explore')
+    .description('Explore graph from entity')
+    .requiredOption('-s, --start <id>', 'Start entity ID')
+    .option('-e, --end <id>', 'End entity ID (for path finding)')
+    .option('-h, --hops <number>', 'Max hops', parseInt, 3)
+    .option('-t, --types <types>', 'Relation types (comma-separated)')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const relationTypes = options.types ? options.types.split(',') : undefined;
+        const result = await cli.explore(options.start, options.end, options.hops, relationTypes);
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+graph
+    .command('pagerank')
+    .description('Calculate PageRank')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.pagerank();
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+graph
+    .command('communities')
+    .description('Detect communities')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.communities();
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// System commands
+const system = program.command('system').alias('sys').description('System operations');
+system
+    .command('health')
+    .description('Check system health')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.health();
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+system
+    .command('metrics')
+    .description('Get system metrics')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.metrics();
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// Export/Import commands
+const exportCmd = program.command('export').description('Export memory');
+exportCmd
+    .command('json')
+    .description('Export as JSON')
+    .option('-o, --output <file>', 'Output file')
+    .option('--include-metadata', 'Include metadata')
+    .option('--include-relationships', 'Include relationships')
+    .option('--include-observations', 'Include observations')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.exportMemory('json', {
+            includeMetadata: options.includeMetadata,
+            includeRelationships: options.includeRelationships,
+            includeObservations: options.includeObservations
+        });
+        const jsonData = typeof result.data === 'string' ? result.data : JSON.stringify(result.data, null, 2);
+        if (options.output) {
+            fs.writeFileSync(options.output, jsonData);
+            console.log(chalk_1.default.green(`✓ Exported to ${options.output}`));
+        }
+        else {
+            console.log(jsonData);
+        }
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+exportCmd
+    .command('markdown')
+    .description('Export as Markdown')
+    .option('-o, --output <file>', 'Output file')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.exportMemory('markdown');
+        if (options.output) {
+            fs.writeFileSync(options.output, result.data);
+            console.log(chalk_1.default.green(`✓ Exported to ${options.output}`));
+        }
+        else {
+            console.log(result.data);
+        }
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+exportCmd
+    .command('obsidian')
+    .description('Export as Obsidian ZIP')
+    .requiredOption('-o, --output <file>', 'Output ZIP file')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.exportMemory('obsidian');
+        // Obsidian export returns zipBuffer, not data
+        const buffer = result.zipBuffer || result.data;
+        if (!buffer) {
+            throw new Error('No buffer returned from export');
+        }
+        fs.writeFileSync(options.output, buffer);
+        console.log(chalk_1.default.green(`✓ Exported to ${options.output}`));
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+const importCmd = program.command('import').description('Import memory');
+importCmd
+    .command('file')
+    .description('Import from file')
+    .requiredOption('-i, --input <file>', 'Input file')
+    .requiredOption('-f, --format <format>', 'Source format (cozo|mem0|memgpt|markdown)')
+    .option('-s, --strategy <strategy>', 'Merge strategy (skip|overwrite|merge)', 'skip')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const data = fs.readFileSync(options.input, 'utf-8');
+        const result = await cli.importMemory(data, options.format, {
+            mergeStrategy: options.strategy
+        });
+        formatOutput(result, 'pretty');
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// Ingest commands
+const ingest = program.command('ingest').description('Ingest files');
+ingest
+    .command('file')
+    .description('Ingest file into entity')
+    .requiredOption('-i, --entity-id <id>', 'Entity ID')
+    .requiredOption('-p, --path <path>', 'File path')
+    .requiredOption('-f, --format <format>', 'File format (markdown|json|pdf)')
+    .option('-c, --chunking <type>', 'Chunking type (none|paragraphs)', 'paragraphs')
+    .option('-m, --max <number>', 'Max observations', parseInt)
+    .option('--no-deduplicate', 'Disable deduplication')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.ingestFile(options.entityId, options.format, options.path, undefined, {
+            chunking: options.chunking,
+            maxObservations: options.max,
+            deduplicate: options.deduplicate
+        });
+        formatOutput(result, 'pretty');
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+// User Profile commands
+const profile = program.command('profile').description('User profile management');
+profile
+    .command('show')
+    .description('Show current user profile')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const result = await cli.getUserProfile();
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+profile
+    .command('update')
+    .description('Update user profile metadata')
+    .option('-n, --name <name>', 'Profile name')
+    .option('-t, --type <type>', 'Profile type')
+    .option('-m, --metadata <json>', 'Metadata as JSON string')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+        const result = await cli.editUserProfile({
+            name: options.name,
+            type: options.type,
+            metadata
+        });
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+profile
+    .command('add-preference')
+    .description('Add preference to user profile')
+    .requiredOption('-t, --text <text>', 'Preference text')
+    .option('-m, --metadata <json>', 'Metadata as JSON string')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const metadata = options.metadata ? JSON.parse(options.metadata) : undefined;
+        const result = await cli.editUserProfile({
+            observations: [{ text: options.text, metadata }]
+        });
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+profile
+    .command('reset')
+    .description('Clear all preferences and optionally set new ones')
+    .option('-t, --text <text>', 'New preference text (can be used multiple times)')
+    .option('-f, --format <format>', 'Output format (json|pretty)', 'pretty')
+    .action(async (options) => {
+    try {
+        await cli.init();
+        const observations = options.text ? [{ text: options.text }] : [];
+        const result = await cli.editUserProfile({
+            clear_observations: true,
+            observations
+        });
+        formatOutput(result, options.format);
+        await cli.close();
+    }
+    catch (error) {
+        handleError(error);
+    }
+});
+program.parse();

package/dist/embedding-service.js

@@ -108,7 +108,7 @@ class EmbeddingService {
             "onnx-community/Qwen3-Embedding-0.6B-ONNX": 1024,
         };
         this.dimensions = dimensionMap[this.modelId] || 1024;
-        console.log(`[EmbeddingService] Using model: ${this.modelId} (${this.dimensions} dimensions)`);
+        console.error(`[EmbeddingService] Using model: ${this.modelId} (${this.dimensions} dimensions)`);
     }
     // Public getter for dimensions
     getDimensions() {

package/dist/hybrid-search.js

@@ -184,7 +184,7 @@ class HybridSearch {
         console.error('--- DEBUG: Cozo Datalog Query ---');
         console.error(datalogQuery);
         console.error('--- DEBUG: Params ---');
-        console.dir(params, { depth: null });
+        console.error(JSON.stringify(params, null, 2));
         try {
             const results = await this.db.run(datalogQuery, params);
             let searchResults = results.rows.map((r) => ({
@@ -234,8 +234,13 @@ class HybridSearch {
         const { limit: queryLimit = 10, filters, graphConstraints, vectorParams } = options;
         // @ts-ignore
         const { topk = 5, efSearch = 50 } = vectorParams || {};
-        // Fallback Mock
-        return [];
+        // Use advancedSearch as the default implementation
+        return this.advancedSearch({
+            ...options,
+            vectorParams: {
+                efSearch: 100
+            }
+        });
     }
     async graphRag(options) {
         console.error("[HybridSearch] Starting graphRag with options:", JSON.stringify(options, null, 2));

package/dist/index.js

@@ -1032,7 +1032,8 @@ class MemoryServer {
         [$id, [${now}, true], $name, $type, $embedding, $name_embedding, $metadata]
       ] :insert entity {id, created_at => name, type, embedding, name_embedding, metadata}
     `, { id, name, type, embedding, name_embedding, metadata: metadata || {} });
-        return { id, name, type, status: "Entity created" };
+        const created_at_iso = new Date(Math.floor(now / 1000)).toISOString();
+        return { id, name, type, created_at: now, created_at_iso, status: "Entity created" };
     }
     async initUserProfile() {
         try {
@@ -1191,9 +1192,12 @@ class MemoryServer {
             // Optional: Automatic inference after new observation (in background)
             const suggestionsRaw = await this.inferenceEngine.inferRelations(entityId);
             const suggestions = await this.formatInferredRelationsForContext(suggestionsRaw);
+            const created_at_iso = new Date(Math.floor(now / 1000)).toISOString();
             return {
                 id,
                 entity_id: entityId,
+                created_at: now,
+                created_at_iso,
                 status: "Observation saved",
                 inferred_suggestions: suggestions
             };
@@ -1247,7 +1251,15 @@ class MemoryServer {
             strength: args.strength ?? 1.0,
             metadata: args.metadata || {}
         });
-        return { status: "Relationship created" };
+        const created_at_iso = new Date(Math.floor(now / 1000)).toISOString();
+        return {
+            from_id: args.from_id,
+            to_id: args.to_id,
+            relation_type: args.relation_type,
+            created_at: now,
+            created_at_iso,
+            status: "Relationship created"
+        };
     }
     async exploreGraph(args) {
         await this.initPromise;
@@ -2161,6 +2173,64 @@ ids[id] <- $ids
             defaultEntityType: args.defaultEntityType
         });
     }
+    async editUserProfile(args) {
+        try {
+            const current = await this.db.run('?[name, type, metadata] := *entity{id: $id, name, type, metadata, @ "NOW"}', { id: exports.USER_ENTITY_ID });
+            if (current.rows.length === 0) {
+                return { error: "User profile not found. Initialize it first." };
+            }
+            if (args.name || args.type || args.metadata) {
+                const updateResult = await this.updateEntity({
+                    id: exports.USER_ENTITY_ID,
+                    name: args.name,
+                    type: args.type,
+                    metadata: args.metadata
+                });
+                if (updateResult.error) {
+                    return updateResult;
+                }
+            }
+            if (args.clear_observations) {
+                const existingObs = await this.db.run('?[id] := *observation{id, entity_id: $eid, @ "NOW"}', { eid: exports.USER_ENTITY_ID });
+                for (const row of existingObs.rows) {
+                    await this.db.run('?[id, entity_id, text, embedding, metadata, created_at] := *observation{id, entity_id, text, embedding, metadata, created_at, @ "NOW"}, id = $id :delete observation {id, entity_id, text, embedding, metadata, created_at}', { id: row[0] });
+                }
+            }
+            if (args.observations && args.observations.length > 0) {
+                for (const obs of args.observations) {
+                    await this.addObservation({
+                        entity_id: exports.USER_ENTITY_ID,
+                        text: obs.text,
+                        metadata: { ...obs.metadata, kind: "user_preference" },
+                        deduplicate: true
+                    });
+                }
+            }
+            const updated = await this.db.run('?[name, type, metadata] := *entity{id: $id, name, type, metadata, @ "NOW"}', { id: exports.USER_ENTITY_ID });
+            const observations = await this.db.run('?[id, text, metadata] := *observation{id, entity_id: $eid, text, metadata, @ "NOW"}', { eid: exports.USER_ENTITY_ID });
+            return {
+                status: "User profile updated",
+                profile: {
+                    id: exports.USER_ENTITY_ID,
+                    name: updated.rows[0][0],
+                    type: updated.rows[0][1],
+                    metadata: updated.rows[0][2],
+                    observations: observations.rows.map((r) => ({
+                        id: r[0],
+                        text: r[1],
+                        metadata: r[2]
+                    }))
+                }
+            };
+        }
+        catch (error) {
+            console.error("[UserProfile] Error editing user profile:", error);
+            return {
+                error: "Failed to edit user profile",
+                message: error.message || String(error)
+            };
+        }
+    }
     registerTools() {
         const MetadataSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.any());
         const MutateMemorySchema = zod_1.z.discriminatedUnion("action", [
@@ -3366,6 +3436,42 @@ Supported actions:
                 return JSON.stringify({ error: "Unknown action" });
             },
         });
+        // User Profile Management Tool
+        this.mcp.addTool({
+            name: "edit_user_profile",
+            description: `Direct management of the global user profile ('global_user_profile').
+This tool allows manual editing of user preferences, work style, and profile metadata.
+
+The user profile is automatically boosted in all searches (50% score boost) and used for personalization.
+
+Parameters:
+- name?: string - Update the profile name (default: "The User")
+- type?: string - Update the profile type (default: "User")
+- metadata?: object - Update or merge profile metadata
+- observations?: Array<{ text: string, metadata?: object }> - Add new preference observations
+- clear_observations?: boolean - Remove all existing observations before adding new ones
+
+Examples:
+- Add preferences: { observations: [{ text: "Prefers TypeScript over JavaScript" }] }
+- Update metadata: { metadata: { timezone: "Europe/Berlin", language: "de" } }
+- Reset and set new preferences: { clear_observations: true, observations: [{ text: "New preference" }] }
+
+Note: Use 'mutate_memory' with action='add_observation' and entity_id='global_user_profile' for implicit preference updates.`,
+            parameters: zod_1.z.object({
+                name: zod_1.z.string().optional().describe("New name for the user profile"),
+                type: zod_1.z.string().optional().describe("New type for the user profile"),
+                metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Metadata to merge with existing metadata"),
+                observations: zod_1.z.array(zod_1.z.object({
+                    text: zod_1.z.string().describe("Preference or work style description"),
+                    metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.any()).optional().describe("Optional metadata for this observation")
+                })).optional().describe("New observations to add to the profile"),
+                clear_observations: zod_1.z.boolean().optional().default(false).describe("Clear all existing observations before adding new ones")
+            }),
+            execute: async (args) => {
+                await this.initPromise;
+                return JSON.stringify(await this.editUserProfile(args));
+            }
+        });
     }
     async start() {
         await this.mcp.start({ transportType: "stdio" });

package/dist/temporal-normalizer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });