ccrecall 0.0.4 → 0.0.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "ccrecall",
-	"version": "0.0.4",
+	"version": "0.0.5",
 	"description": "Sync Claude Code transcripts to SQLite and recall context from past sessions",
 	"type": "module",
 	"bin": {

package/src/cli.ts

@@ -92,6 +92,331 @@ Database: ${db_path}
 	},
 });
 
+export const query = defineCommand({
+	meta: {
+		name: 'query',
+		description: 'Execute raw SQL against the database',
+	},
+	args: {
+		...sharedArgs,
+		sql: {
+			type: 'positional' as const,
+			description: 'SQL query to execute',
+			required: true,
+		},
+		format: {
+			type: 'string',
+			alias: 'f',
+			description: 'Output format: table, json, csv (default: table)',
+		},
+		limit: {
+			type: 'string',
+			alias: 'l',
+			description: 'Limit rows (appends LIMIT clause if not present)',
+		},
+	},
+	async run({ args }) {
+		const { Database: BunDB } = await import('bun:sqlite');
+		const { existsSync } = await import('fs');
+
+		const db_path = args.db ?? DEFAULT_DB_PATH;
+		if (!existsSync(db_path)) {
+			console.error(`Database not found: ${db_path}`);
+			process.exit(1);
+		}
+
+		const db = new BunDB(db_path, { readonly: true });
+
+		try {
+			let sql = args.sql;
+			const format = args.format ?? 'table';
+
+			// Add LIMIT if specified and not already present
+			if (args.limit && !/\bLIMIT\b/i.test(sql)) {
+				sql = `${sql.replace(/;?\s*$/, '')} LIMIT ${parseInt(args.limit, 10)}`;
+			}
+
+			const rows = db.prepare(sql).all() as Record<string, unknown>[];
+
+			if (rows.length === 0) {
+				console.log('No results.');
+				return;
+			}
+
+			const columns = Object.keys(rows[0]);
+
+			if (format === 'json') {
+				console.log(JSON.stringify(rows, null, 2));
+			} else if (format === 'csv') {
+				console.log(columns.join(','));
+				for (const row of rows) {
+					const values = columns.map((c) => {
+						const v = row[c];
+						if (v === null) return '';
+						const s = String(v);
+						return s.includes(',') ||
+							s.includes('"') ||
+							s.includes('\n')
+							? `"${s.replace(/"/g, '""')}"`
+							: s;
+					});
+					console.log(values.join(','));
+				}
+			} else {
+				// table format
+				const widths = columns.map((c) =>
+					Math.max(
+						c.length,
+						...rows.map(
+							(r) => String(r[c] ?? '').slice(0, 50).length,
+						),
+					),
+				);
+
+				const header = columns
+					.map((c, i) => c.padEnd(widths[i]))
+					.join(' | ');
+				const sep = widths.map((w) => '-'.repeat(w)).join('-+-');
+
+				console.log(header);
+				console.log(sep);
+				for (const row of rows) {
+					const line = columns
+						.map((c, i) =>
+							String(row[c] ?? '')
+								.slice(0, 50)
+								.padEnd(widths[i]),
+						)
+						.join(' | ');
+					console.log(line);
+				}
+				console.log(`\n${rows.length} row(s)`);
+			}
+		} catch (err) {
+			console.error('SQL error:', (err as Error).message);
+			process.exit(1);
+		} finally {
+			db.close();
+		}
+	},
+});
+
+export const tools = defineCommand({
+	meta: {
+		name: 'tools',
+		description: 'Show most-used tools',
+	},
+	args: {
+		...sharedArgs,
+		top: {
+			type: 'string',
+			alias: 't',
+			description: 'Number of tools to show (default: 10)',
+		},
+		project: {
+			type: 'string',
+			alias: 'p',
+			description: 'Filter by project path',
+		},
+		format: {
+			type: 'string',
+			alias: 'f',
+			description: 'Output format: table, json (default: table)',
+		},
+	},
+	async run({ args }) {
+		const { Database } = await import('./db.ts');
+
+		const db_path = args.db ?? DEFAULT_DB_PATH;
+		const db = new Database(db_path);
+
+		try {
+			const results = db.get_tool_stats({
+				limit: args.top ? parseInt(args.top, 10) : undefined,
+				project: args.project,
+			});
+
+			if (results.length === 0) {
+				console.log('No tool usage data found.');
+				return;
+			}
+
+			if (args.format === 'json') {
+				console.log(JSON.stringify(results, null, 2));
+				return;
+			}
+
+			const maxNameLen = Math.max(
+				4,
+				...results.map((r) => r.tool_name.length),
+			);
+			const maxCountLen = Math.max(
+				5,
+				...results.map((r) => r.count.toString().length),
+			);
+
+			console.log(
+				`${'Tool'.padEnd(maxNameLen)}  ${'Count'.padStart(maxCountLen)}  %`,
+			);
+			console.log(
+				`${'-'.repeat(maxNameLen)}  ${'-'.repeat(maxCountLen)}  ------`,
+			);
+
+			for (const r of results) {
+				console.log(
+					`${r.tool_name.padEnd(maxNameLen)}  ${r.count.toString().padStart(maxCountLen)}  ${r.percentage.toFixed(1).padStart(5)}%`,
+				);
+			}
+		} finally {
+			db.close();
+		}
+	},
+});
+
+export const search = defineCommand({
+	meta: {
+		name: 'search',
+		description: 'Full-text search across messages',
+	},
+	args: {
+		...sharedArgs,
+		term: {
+			type: 'positional' as const,
+			description:
+				'Search term (supports FTS5 syntax: AND, OR, NOT, "phrase", prefix*)',
+			required: true,
+		},
+		limit: {
+			type: 'string',
+			alias: 'l',
+			description: 'Maximum results (default: 20)',
+		},
+		project: {
+			type: 'string',
+			alias: 'p',
+			description: 'Filter by project path',
+		},
+		rebuild: {
+			type: 'boolean',
+			description: 'Rebuild FTS index before searching',
+		},
+	},
+	async run({ args }) {
+		const { Database } = await import('./db.ts');
+
+		const db_path = args.db ?? DEFAULT_DB_PATH;
+		const db = new Database(db_path);
+
+		try {
+			if (args.rebuild) {
+				console.log('Rebuilding FTS index...');
+				db.rebuild_fts();
+			}
+
+			const results = db.search(args.term, {
+				limit: args.limit ? parseInt(args.limit, 10) : undefined,
+				project: args.project,
+			});
+
+			if (results.length === 0) {
+				console.log('No matches found.');
+				return;
+			}
+
+			console.log(`Found ${results.length} matches:\n`);
+
+			for (const r of results) {
+				const date = new Date(r.timestamp)
+					.toISOString()
+					.split('T')[0];
+				const project = r.project_path.split('/').slice(-2).join('/');
+				console.log(`[${date}] ${project}`);
+				console.log(`  ${r.snippet.replace(/\n/g, ' ')}`);
+				console.log(`  session: ${r.session_id.slice(0, 8)}...\n`);
+			}
+		} finally {
+			db.close();
+		}
+	},
+});
+
+export const sessions = defineCommand({
+	meta: {
+		name: 'sessions',
+		description: 'List recent sessions',
+	},
+	args: {
+		...sharedArgs,
+		limit: {
+			type: 'string',
+			alias: 'l',
+			description: 'Maximum sessions to show (default: 10)',
+		},
+		project: {
+			type: 'string',
+			alias: 'p',
+			description: 'Filter by project path',
+		},
+		format: {
+			type: 'string',
+			alias: 'f',
+			description: 'Output format: table or json (default: table)',
+		},
+	},
+	async run({ args }) {
+		const { Database } = await import('./db.ts');
+
+		const db_path = args.db ?? DEFAULT_DB_PATH;
+		const db = new Database(db_path);
+
+		try {
+			const results = db.get_sessions({
+				limit: args.limit ? parseInt(args.limit, 10) : undefined,
+				project: args.project,
+			});
+
+			if (results.length === 0) {
+				console.log('No sessions found.');
+				return;
+			}
+
+			if (args.format === 'json') {
+				console.log(JSON.stringify(results, null, 2));
+				return;
+			}
+
+			// Table format
+			console.log(
+				'Date       | Project                          | Msgs | Tokens    | Duration',
+			);
+			console.log(
+				'-----------|----------------------------------|------|-----------|----------',
+			);
+
+			for (const s of results) {
+				const date = new Date(s.first_timestamp)
+					.toISOString()
+					.split('T')[0];
+				const project = s.project_path
+					.split('/')
+					.slice(-2)
+					.join('/')
+					.padEnd(32)
+					.slice(0, 32);
+				const msgs = String(s.message_count).padStart(4);
+				const tokens = s.total_tokens.toLocaleString().padStart(9);
+				const duration =
+					s.duration_mins > 0 ? `${s.duration_mins}m` : '<1m';
+				console.log(
+					`${date} | ${project} | ${msgs} | ${tokens} | ${duration.padStart(8)}`,
+				);
+			}
+		} finally {
+			db.close();
+		}
+	},
+});
+
 export const main = defineCommand({
 	meta: {
 		name: 'ccrecall',
@@ -109,5 +434,9 @@ export const main = defineCommand({
 	subCommands: {
 		sync,
 		stats,
+		search,
+		sessions,
+		query,
+		tools,
 	},
 });

package/src/db.ts

@@ -119,6 +119,27 @@ CREATE INDEX IF NOT EXISTS idx_teams_lead_session ON teams(lead_session_id);
 CREATE INDEX IF NOT EXISTS idx_team_members_team ON team_members(team_id);
 CREATE INDEX IF NOT EXISTS idx_team_tasks_team ON team_tasks(team_id);
 CREATE INDEX IF NOT EXISTS idx_team_tasks_status ON team_tasks(status);
+
+-- FTS5 full-text search index for messages
+CREATE VIRTUAL TABLE IF NOT EXISTS messages_fts USING fts5(
+  content_text,
+  content='messages',
+  content_rowid='rowid'
+);
+
+-- Triggers to keep FTS index in sync with messages table
+CREATE TRIGGER IF NOT EXISTS messages_fts_insert AFTER INSERT ON messages BEGIN
+  INSERT INTO messages_fts(rowid, content_text) VALUES (new.rowid, new.content_text);
+END;
+
+CREATE TRIGGER IF NOT EXISTS messages_fts_delete AFTER DELETE ON messages BEGIN
+  INSERT INTO messages_fts(messages_fts, rowid, content_text) VALUES('delete', old.rowid, old.content_text);
+END;
+
+CREATE TRIGGER IF NOT EXISTS messages_fts_update AFTER UPDATE ON messages BEGIN
+  INSERT INTO messages_fts(messages_fts, rowid, content_text) VALUES('delete', old.rowid, old.content_text);
+  INSERT INTO messages_fts(rowid, content_text) VALUES (new.rowid, new.content_text);
+END;
 `;
 
 export class Database {
@@ -444,6 +465,147 @@ export class Database {
 		this.db.run('DELETE FROM sync_state');
 	}
 
+	search(
+		term: string,
+		options: { limit?: number; project?: string } = {},
+	): Array<{
+		uuid: string;
+		session_id: string;
+		project_path: string;
+		content_text: string;
+		timestamp: number;
+		snippet: string;
+	}> {
+		const limit = options.limit ?? 20;
+		let query = `
+			SELECT
+				m.uuid,
+				m.session_id,
+				s.project_path,
+				m.content_text,
+				m.timestamp,
+				snippet(messages_fts, 0, '>>>', '<<<', '...', 32) as snippet
+			FROM messages_fts
+			JOIN messages m ON m.rowid = messages_fts.rowid
+			JOIN sessions s ON s.id = m.session_id
+			WHERE messages_fts MATCH ?
+		`;
+		const params: (string | number)[] = [term];
+
+		if (options.project) {
+			query += ` AND s.project_path LIKE ?`;
+			params.push(`%${options.project}%`);
+		}
+
+		query += ` ORDER BY rank LIMIT ?`;
+		params.push(limit);
+
+		return this.db.prepare(query).all(...params) as Array<{
+			uuid: string;
+			session_id: string;
+			project_path: string;
+			content_text: string;
+			timestamp: number;
+			snippet: string;
+		}>;
+	}
+
+	rebuild_fts() {
+		this.db.run(
+			`INSERT INTO messages_fts(messages_fts) VALUES('rebuild')`,
+		);
+	}
+
+	get_sessions(
+		options: { limit?: number; project?: string } = {},
+	): Array<{
+		id: string;
+		project_path: string;
+		first_timestamp: number;
+		last_timestamp: number;
+		message_count: number;
+		total_tokens: number;
+		duration_mins: number;
+	}> {
+		const limit = options.limit ?? 10;
+		let query = `
+			SELECT
+				s.id,
+				s.project_path,
+				s.first_timestamp,
+				s.last_timestamp,
+				COUNT(m.uuid) as message_count,
+				COALESCE(SUM(m.input_tokens + m.output_tokens), 0) as total_tokens,
+				CAST((s.last_timestamp - s.first_timestamp) / 60000.0 AS INTEGER) as duration_mins
+			FROM sessions s
+			LEFT JOIN messages m ON m.session_id = s.id
+		`;
+		const params: (string | number)[] = [];
+
+		if (options.project) {
+			query += ` WHERE s.project_path LIKE ?`;
+			params.push(`%${options.project}%`);
+		}
+
+		query += ` GROUP BY s.id ORDER BY s.last_timestamp DESC LIMIT ?`;
+		params.push(limit);
+
+		return this.db.prepare(query).all(...params) as Array<{
+			id: string;
+			project_path: string;
+			first_timestamp: number;
+			last_timestamp: number;
+			message_count: number;
+			total_tokens: number;
+			duration_mins: number;
+		}>;
+	}
+
+	get_tool_stats(
+		options: { limit?: number; project?: string } = {},
+	): Array<{
+		tool_name: string;
+		count: number;
+		percentage: number;
+	}> {
+		const limit = options.limit ?? 10;
+		let query = `
+			SELECT
+				tc.tool_name,
+				COUNT(*) as count
+			FROM tool_calls tc
+		`;
+		const params: (string | number)[] = [];
+
+		if (options.project) {
+			query += `
+				JOIN sessions s ON s.id = tc.session_id
+				WHERE s.project_path LIKE ?
+			`;
+			params.push(`%${options.project}%`);
+		}
+
+		query += `
+			GROUP BY tc.tool_name
+			ORDER BY count DESC
+			LIMIT ?
+		`;
+		params.push(limit);
+
+		const rows = this.db.prepare(query).all(...params) as Array<{
+			tool_name: string;
+			count: number;
+		}>;
+
+		const total = rows.reduce((sum, r) => sum + r.count, 0);
+
+		return rows.map((r) => ({
+			tool_name: r.tool_name,
+			count: r.count,
+			percentage: total > 0 ? (r.count / total) * 100 : 0,
+		}));
+	}
+
 	close() {
 		this.db.close();
 	}