@postnesia/cli 0.1.2

package/README.md

@@ -0,0 +1,117 @@
+# Postnesia Memory MCP Server
+
+Model Context Protocol server for main agent memory system. Exposes memory operations as standardized tools.
+
+## Installation
+
+```bash
+cd postnesia
+npm install
+npm run db:generate
+```
+
+## Configuration
+
+Add to your MCP settings (e.g., Claude Desktop config):
+
+```json
+{
+  "mcpServers": {
+    "postnesia": {
+      "command": "/absolute/path/to/tsx",
+      "env": {
+        "DATABASE_URL": "file:/absolute/path/to/memory.db",
+        "GEMINI_API_KEY": "token-for-gemini-embedding-model-api"
+      }
+    }
+  }
+}
+```
+
+Or use npm script:
+
+```json
+{
+  "mcpServers": {
+    "openmind": {
+      "command": "/absolute/path/to/tsx",
+      "env": {
+        "DATABASE_URL": "/absolute/path/to/memory.db",
+        "GEMINI_API_KEY": "token-for-gemini-embedding-model-api"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### memory_search
+Semantic search across memories.
+- `query` (required): Search text
+- `maxResults` (optional): Max results (default: 10)
+- `minScore` (optional): Min similarity 0-1 (default: 0.3)
+
+### memory_add
+Create a new memory.
+- `content` (required): Full memory text
+- `contentL1` (optional): Compressed form
+- `type` (required): event|decision|lesson|preference|person|technical
+- `importance` (required): 1-5
+- `tags` (required): Array of tags
+- `context` (optional): Creation context
+
+### memory_recent
+Get recent memories.
+- `hours` (optional): Hours to look back (default: 24)
+- `limit` (optional): Max results (default: 20)
+
+### memory_context
+Get contextually related memories.
+- `query` (required): Context query
+- `maxResults` (optional): Max results (default: 5)
+
+### memory_stats
+Get database statistics. No parameters.
+
+### memory_consolidate
+Run consolidation cycle (decay + boost). No parameters - always applies changes.
+
+### journal_add
+Add daily journal entry.
+- `date` (required): YYYY-MM-DD
+- `content` (required): Full narrative
+- `learned` (optional): What I learned
+- `learnedAboutRye` (optional): What I learned about Rye
+- `keyMoments` (optional): Key moments
+- `mood` (optional): Mood/feeling
+
+### journal_recent
+Get recent journal entries.
+- `days` (optional): Days to look back (default: 7)
+
+### memory_relationships
+View relationship graph for a memory.
+- `memoryId` (required): Memory ID to explore
+
+## Access Tracking
+
+All read operations (search, recent, context) automatically log accesses, which feed into the importance dynamics system.
+
+## Testing
+
+Test the server manually:
+
+```bash
+npm run mcp
+```
+
+Then send MCP requests via stdin (see MCP protocol docs).
+
+## Architecture
+
+- Built on Prisma + SQLite
+- Automatic access tracking
+- Dynamic importance scoring (decay + boost)
+- Relationship graph support
+- Journal integration

package/dist/index.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+/**
+ * Postnesia CLI
+ * Like-for-like Commander interface over the MCP tools.
+ * Each MCP tool becomes a subcommand; output mirrors MCP text responses.
+ */
+import 'dotenv/config';
+import { Command } from 'commander';
+import { getDb, queries, createMemory } from '@postnesia/db';
+import { embed } from '@postnesia/db/embeddings';
+import { logAccess } from '@postnesia/mcp/access';
+import { runConsolidation } from '@postnesia/mcp/importance';
+// ---------------------------------------------------------------------------
+// Bootstrap
+// ---------------------------------------------------------------------------
+const db = getDb();
+const program = new Command();
+program
+    .name('postnesia')
+    .description('Postnesia memory & task CLI')
+    .version('0.1.0');
+// ---------------------------------------------------------------------------
+// memory
+// ---------------------------------------------------------------------------
+const memory = program.command('memory').description('Memory operations');
+memory
+    .command('search <query>')
+    .description('Search memories by content')
+    .option('-l, --limit <n>', 'Max results', '10')
+    .action((query, opts) => {
+    const limit = parseInt(opts.limit, 10);
+    const pattern = `%${query.toLowerCase()}%`;
+    const results = queries.searchMemories(db).all(pattern, pattern, limit);
+    for (const r of results)
+        logAccess(r.id, 'search');
+    process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+});
+memory
+    .command('add <content>')
+    .description('Add a new memory')
+    .requiredOption('-t, --type <type>', 'Memory type: event|decision|lesson|preference|person|technical')
+    .requiredOption('-i, --importance <n>', 'Importance 1-5')
+    .requiredOption('--tags <tags>', 'Comma-separated tags')
+    .option('--content-l1 <summary>', 'Compressed L1 summary (auto-generated if omitted)')
+    .option('--context <ctx>', 'Optional context')
+    .option('--core', 'Mark as core memory')
+    .action(async (content, opts) => {
+    const importance = parseInt(opts.importance, 10);
+    const tags = opts.tags.split(',').map((t) => t.trim());
+    const content_l1 = opts.contentL1 ?? content.slice(0, 200);
+    const core = opts.core ? 1 : 0;
+    const embedding = await embed(content);
+    const id = createMemory(db, {
+        timestamp: new Date().toISOString(),
+        content,
+        content_l1,
+        type: opts.type,
+        core,
+        importance,
+        context: opts.context,
+        tags,
+        embedding,
+    });
+    process.stdout.write(`✓ Created memory #${id}\n  Type: ${opts.type}\n  Core: ${core ? 'yes' : 'no'}\n  Importance: ${'⭐'.repeat(importance)}\n  Tags: ${tags.join(', ')}\n`);
+});
+memory
+    .command('update-core <memoryId>')
+    .description('Update content of an existing core memory in place')
+    .requiredOption('--content <content>', 'New full content')
+    .requiredOption('--content-l1 <summary>', 'New compressed L1 summary')
+    .action(async (memoryId, opts) => {
+    const id = parseInt(memoryId, 10);
+    const existing = db.prepare('SELECT id, core FROM memory WHERE id = ?').get(id);
+    if (!existing)
+        throw new Error(`Memory #${id} not found`);
+    if (!existing.core)
+        throw new Error(`Memory #${id} is not a core memory.`);
+    const embedding = await embed(opts.content);
+    db.prepare(`UPDATE memory SET content = ?, content_l1 = ?, updated_at = datetime('now') WHERE id = ?`)
+        .run(opts.content, opts.contentL1, id);
+    db.prepare('DELETE FROM vec_memories WHERE memory_id = ?').run(BigInt(id));
+    db.prepare('INSERT INTO vec_memories(memory_id, embedding) VALUES (?, ?)').run(BigInt(id), Buffer.from(embedding.buffer));
+    process.stdout.write(`✓ Updated core memory #${id}\n`);
+});
+memory
+    .command('recent')
+    .description('Get recent memories')
+    .option('--hours <n>', 'Hours to look back', '24')
+    .option('-l, --limit <n>', 'Max results', '20')
+    .action((opts) => {
+    const hours = parseInt(opts.hours, 10);
+    const limit = parseInt(opts.limit, 10);
+    const results = queries.getRecentMemories(db).all(`-${hours} hours`, limit);
+    for (const r of results)
+        logAccess(r.id, 'recent');
+    process.stdout.write(JSON.stringify(results, null, 2) + '\n');
+});
+memory
+    .command('stats')
+    .description('Database statistics')
+    .action(() => {
+    const stats = queries.getStats(db).all();
+    const total = db.prepare('SELECT COUNT(*) as count FROM memory').get().count;
+    const tagCount = db.prepare('SELECT COUNT(*) as count FROM tag').get().count;
+    const relCount = db.prepare('SELECT COUNT(*) as count FROM relationship').get().count;
+    const logCount = db.prepare('SELECT COUNT(*) as count FROM access_log').get().count;
+    const rows = stats
+        .map((s) => `  ${s.type.padEnd(15)} ${s.count.toString().padStart(3)} memories (avg importance: ${s.avg_importance?.toFixed(1)})`)
+        .join('\n');
+    process.stdout.write(`Memory Statistics:\n\n${rows}\n\n  Total:         ${total} memories\n  Tags:          ${tagCount}\n  Relationships: ${relCount}\n  Access Logs:   ${logCount}\n`);
+});
+memory
+    .command('consolidate')
+    .description('Run memory consolidation cycle')
+    .action(() => {
+    const r = runConsolidation();
+    process.stdout.write(`Consolidation Complete\n\nReviewed:  ${r.reviewed}\nBoosted:   ${r.boosted}\nDecayed:   ${r.decayed}\nUnchanged: ${r.unchanged}\n`);
+});
+memory
+    .command('relationships <memoryId>')
+    .description('View relationship graph for a memory')
+    .action((memoryId) => {
+    const id = parseInt(memoryId, 10);
+    const relationships = queries.getMemoryRelationships(db).all(id, id);
+    process.stdout.write(JSON.stringify(relationships, null, 2) + '\n');
+});
+// ---------------------------------------------------------------------------
+// journal
+// ---------------------------------------------------------------------------
+const journal = program.command('journal').description('Journal operations');
+journal
+    .command('add <date> <content>')
+    .description('Add a daily journal entry (date: YYYY-MM-DD)')
+    .option('--learned <text>', 'What was learned')
+    .option('--learned-about-rye <text>', 'What was learned about Rye')
+    .option('--key-moments <text>', 'Key moments')
+    .option('--mood <text>', 'Mood/feeling')
+    .action((date, content, opts) => {
+    const combinedLearned = [opts.learned, opts.learnedAboutRye].filter(Boolean).join('\n\n') || null;
+    queries.insertJournal(db).run(date, content, combinedLearned, opts.keyMoments ?? null, opts.mood ?? null);
+    process.stdout.write(`✓ Journal entry created for ${date}\n`);
+});
+journal
+    .command('recent')
+    .description('Get recent journal entries')
+    .option('--days <n>', 'Days to look back', '7')
+    .action((opts) => {
+    const days = parseInt(opts.days, 10);
+    const entries = queries.getRecentJournals(db).all(`-${days} days`);
+    process.stdout.write(JSON.stringify(entries, null, 2) + '\n');
+});
+// ---------------------------------------------------------------------------
+// task
+// ---------------------------------------------------------------------------
+const task = program.command('task').description('Task operations');
+task
+    .command('create <title>')
+    .description('Create a new task')
+    .option('-d, --description <text>', 'Task description')
+    .option('-s, --session-id <id>', 'Project/feature label')
+    .option('-m, --memory-id <n>', 'Related memory ID')
+    .action((title, opts) => {
+    const result = queries.insertTask(db).run(title, opts.description ?? null, opts.sessionId ?? null, opts.memoryId != null ? parseInt(opts.memoryId, 10) : null);
+    const id = Number(result.lastInsertRowid);
+    process.stdout.write(`✓ Created task #${id}: ${title}${opts.sessionId ? `\n  Session: ${opts.sessionId}` : ''}\n`);
+});
+task
+    .command('update <taskId>')
+    .description('Update a task')
+    .option('-s, --status <status>', 'pending|in_progress|completed|cancelled')
+    .option('-t, --title <title>', 'New title')
+    .option('-d, --description <text>', 'New description')
+    .action((taskId, opts) => {
+    const id = parseInt(taskId, 10);
+    const existing = queries.getTaskById(db).get(id);
+    if (!existing)
+        throw new Error(`Task #${id} not found`);
+    queries.updateTask(db).run(opts.status ?? null, opts.title ?? null, opts.description ?? null, id);
+    const updated = queries.getTaskById(db).get(id);
+    process.stdout.write(`✓ Task #${id} updated\n  Status: ${updated.status}\n  Title: ${updated.title}\n`);
+});
+task
+    .command('list')
+    .description('List tasks')
+    .option('-s, --status <status>', 'Filter by status')
+    .option('--session-id <id>', 'Filter by session/project label')
+    .option('-l, --limit <n>', 'Max results', '50')
+    .action((opts) => {
+    const conditions = [];
+    const params = [];
+    if (opts.status) {
+        conditions.push('status = ?');
+        params.push(opts.status);
+    }
+    if (opts.sessionId) {
+        conditions.push('session_id = ?');
+        params.push(opts.sessionId);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+    params.push(parseInt(opts.limit, 10));
+    const tasks = db.prepare(`SELECT * FROM task ${where} ORDER BY created_at ASC LIMIT ?`).all(...params);
+    process.stdout.write(JSON.stringify(tasks, null, 2) + '\n');
+});
+// ---------------------------------------------------------------------------
+// Run
+// ---------------------------------------------------------------------------
+try {
+    await program.parseAsync(process.argv);
+}
+catch (error) {
+    const e = error;
+    process.stderr.write(`Error: ${e.message}\n`);
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@postnesia/cli",
+  "version": "0.1.2",
+  "description": "Commander CLI for Postnesia — direct tool access for agents",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "postnesia": "./dist/index.js"
+  },
+  "dependencies": {
+    "@postnesia/db": "0.1.2",
+    "@postnesia/mcp": "0.1.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "tsx src/index.ts"
+  }
+}