#!/usr/bin/env node
/**
* AgentKits Memory Viewer CLI
*
* Simple CLI to view memory database contents.
*
* Usage:
* npx @aitytech/agentkits-memory viewer [options]
*
* Options:
* --stats Show database statistics
* --list List all entries
* --namespace=X Filter by namespace
* --limit=N Limit results (default: 20)
* --json Output as JSON
* --export Export all to JSON file
*
* @module @agentkits/memory/cli/viewer
*/
import * as fs from 'node:fs';
import * as path from 'node:path';
import Database from 'better-sqlite3';
import type { Database as BetterDatabase } from 'better-sqlite3';
const args = process.argv.slice(2);
const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
function parseArgs(): Record<string, string | boolean> {
const parsed: Record<string, string | boolean> = {};
for (const arg of args) {
if (arg.startsWith('--')) {
const [key, value] = arg.slice(2).split('=');
parsed[key] = value ?? true;
}
}
return parsed;
}
function loadDatabase(): BetterDatabase | null {
const dbPath = path.join(projectDir, '.claude/memory/memory.db');
if (fs.existsSync(dbPath)) {
return new Database(dbPath);
} else {
console.log(`\n📭 No database found at: ${dbPath}\n`);
console.log('Run Claude Code with memory MCP server to create entries.');
return null;
}
}
function main() {
const options = parseArgs();
const limit = parseInt(options.limit as string, 10) || 20;
const namespace = options.namespace as string | undefined;
const asJson = !!options.json;
try {
const db = loadDatabase();
if (!db) {
process.exit(0);
}
if (options.stats) {
// Get stats
const totalRow = db.prepare('SELECT COUNT(*) as count FROM memory_entries').get() as { count: number };
const total = totalRow?.count || 0;
const nsRows = db.prepare('SELECT namespace, COUNT(*) as count FROM memory_entries GROUP BY namespace').all() as { namespace: string; count: number }[];
const byNamespace: Record<string, number> = {};
for (const row of nsRows) {
byNamespace[row.namespace] = row.count;
}
const typeRows = db.prepare('SELECT type, COUNT(*) as count FROM memory_entries GROUP BY type').all() as { type: string; count: number }[];
const byType: Record<string, number> = {};
for (const row of typeRows) {
byType[row.type] = row.count;
}
if (asJson) {
console.log(JSON.stringify({ total, byNamespace, byType }, null, 2));
} else {
console.log('\n📊 Memory Database Statistics\n');
console.log(`Total Entries: ${total}`);
console.log('\nEntries by Namespace:');
for (const [ns, count] of Object.entries(byNamespace)) {
console.log(` ${ns}: ${count}`);
}
console.log('\nEntries by Type:');
for (const [type, count] of Object.entries(byType)) {
console.log(` ${type}: ${count}`);
}
console.log(`\nDatabase: ${projectDir}/.claude/memory/memory.db\n`);
}
db.close();
return;
}
if (options.export) {
const rows = db.prepare('SELECT * FROM memory_entries').all() as Record<string, unknown>[];
if (rows.length === 0) {
console.log('No entries to export.');
db.close();
return;
}
const filename = `memory-export-${Date.now()}.json`;
fs.writeFileSync(filename, JSON.stringify({ entries: rows, exportedAt: new Date().toISOString() }, null, 2));
console.log(`✓ Exported ${rows.length} entries to ${filename}`);
db.close();
return;
}
// Default: list entries
let query = 'SELECT id, key, content, type, namespace, tags, created_at FROM memory_entries';
const params: (string | number)[] = [];
if (namespace) {
query += ' WHERE namespace = ?';
params.push(namespace);
}
query += ' ORDER BY created_at DESC LIMIT ?';
params.push(limit);
const entries = db.prepare(query).all(...params) as {
id: string;
key: string;
content: string;
type: string;
namespace: string;
tags: string;
created_at: number;
}[];
if (entries.length === 0) {
console.log('\n📭 No memories found in database.\n');
console.log(`Database: ${projectDir}/.claude/memory/memory.db`);
db.close();
return;
}
if (asJson) {
console.log(JSON.stringify(entries, null, 2));
db.close();
return;
}
console.log(`\n📚 Memory Database (${entries.length} entries)\n`);
console.log(`Database: ${projectDir}/.claude/memory/memory.db\n`);
console.log('─'.repeat(80));
for (const entry of entries) {
const date = new Date(entry.created_at).toLocaleString();
const content = entry.content.length > 100
? entry.content.slice(0, 100) + '...'
: entry.content;
const tags = JSON.parse(entry.tags || '[]').join(', ') || 'none';
console.log(`\n[${entry.namespace}] ${entry.key}`);
console.log(` Type: ${entry.type} | Tags: ${tags}`);
console.log(` Created: ${date}`);
console.log(` Content: ${content}`);
console.log('─'.repeat(80));
}
// Get total count
const countRow = db.prepare('SELECT COUNT(*) as count FROM memory_entries').get() as { count: number };
const totalCount = countRow?.count || entries.length;
console.log(`\nShowing ${entries.length} of ${totalCount} total entries`);
console.log('Use --limit=N to see more, --namespace=X to filter\n');
db.close();
} catch (error) {
console.error('Error:', error instanceof Error ? error.message : error);
process.exit(1);
}
}
main();
