@dalmasonto/taskflow-mcp 1.0.35 → 2.0.0

package/dist/tools/analytics.js

@@ -1,191 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { successResponse, errorResponse } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function getAnalytics(params) {
-    const db = getDb();
-    const { start_date, end_date } = params;
-    // Build date filter for sessions
-    const sessionConditions = [];
-    const sessionValues = [];
-    if (start_date) {
-        sessionConditions.push('start >= ?');
-        sessionValues.push(start_date);
-    }
-    if (end_date) {
-        sessionConditions.push('start <= ?');
-        sessionValues.push(end_date);
-    }
-    const sessionWhere = sessionConditions.length > 0
-        ? `WHERE ${sessionConditions.join(' AND ')}`
-        : '';
-    // Total focused time (sum of all session durations in ms)
-    const durationFormula = `(julianday(COALESCE(end, datetime('now'))) - julianday(start)) * 86400000`;
-    const timeRow = db.prepare(`SELECT COALESCE(SUM(${durationFormula}), 0) AS total_focused_time FROM sessions ${sessionWhere}`).get(...sessionValues);
-    const total_focused_time = Math.round(timeRow.total_focused_time);
-    // Task counts by status
-    const taskRows = db.prepare('SELECT status, COUNT(*) AS count FROM tasks GROUP BY status').all();
-    const status_distribution = {};
-    let tasks_completed = 0;
-    let tasks_in_progress = 0;
-    let total_tasks = 0;
-    for (const row of taskRows) {
-        status_distribution[row.status] = row.count;
-        total_tasks += row.count;
-        if (row.status === 'done')
-            tasks_completed = row.count;
-        if (row.status === 'in_progress')
-            tasks_in_progress = row.count;
-    }
-    // Time per project (only tasks that belong to a project)
-    const projectTimeRows = db.prepare(`SELECT
-       t.project_id,
-       p.name AS project_name,
-       COALESCE(SUM(${durationFormula.replace(/start/g, 's.start').replace(/end/g, 's.end')}), 0) AS total_time
-     FROM sessions s
-     JOIN tasks t ON s.task_id = t.id
-     JOIN projects p ON t.project_id = p.id
-     ${sessionWhere.replace(/start/g, 's.start')}
-     GROUP BY t.project_id, p.name`).all(...sessionValues);
-    const time_per_project = projectTimeRows.map(row => ({
-        project_id: row.project_id,
-        project_name: row.project_name,
-        total_time: Math.round(row.total_time),
-    }));
-    return successResponse({
-        total_focused_time,
-        tasks_completed,
-        tasks_in_progress,
-        total_tasks,
-        status_distribution,
-        time_per_project,
-    });
-}
-export async function getTimeline(params) {
-    const db = getDb();
-    const { start_date, end_date, group_by = 'day' } = params;
-    const periodExpr = group_by === 'week'
-        ? `strftime('%Y-W%W', start)`
-        : `strftime('%Y-%m-%d', start)`;
-    const durationFormula = `(julianday(COALESCE(end, datetime('now'))) - julianday(start)) * 86400000`;
-    const conditions = [];
-    const values = [];
-    if (start_date) {
-        conditions.push('start >= ?');
-        values.push(start_date);
-    }
-    if (end_date) {
-        conditions.push('start <= ?');
-        values.push(end_date);
-    }
-    const where = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-    const rows = db.prepare(`SELECT
-       ${periodExpr} AS period,
-       COALESCE(SUM(${durationFormula}), 0) AS total_time,
-       COUNT(*) AS session_count
-     FROM sessions
-     ${where}
-     GROUP BY period
-     ORDER BY period ASC`).all(...values);
-    const timeline = rows.map(row => ({
-        period: row.period,
-        total_time: Math.round(row.total_time),
-        session_count: row.session_count,
-    }));
-    return successResponse(timeline);
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerAnalyticsTools(server) {
-    server.tool('get_analytics', 'Get a high-level analytics summary: total focused time, task completion rates, status distribution, and time per project. Useful for standup reports or understanding workload.', {
-        start_date: z.string().optional(),
-        end_date: z.string().optional(),
-    }, { readOnlyHint: true }, async (params) => getAnalytics(params));
-    server.tool('get_timeline', 'Get focused time grouped by day or week. Use for visualizing work patterns over time.', {
-        start_date: z.string().optional(),
-        end_date: z.string().optional(),
-        group_by: z.enum(['day', 'week']).optional(),
-    }, { readOnlyHint: true }, async (params) => getTimeline(params));
-    server.tool('get_tool_stats', 'Get tool execution statistics: call count, success rate, average duration per tool. Shows which tools are used most and which are slow or failing.', {
-        since: z.string().optional().describe('ISO date to filter from (e.g. "2026-04-01"). Defaults to all time.'),
-        tool_name: z.string().optional().describe('Filter to a specific tool name'),
-    }, { readOnlyHint: true }, async (params) => {
-        const db = getDb();
-        const conditions = [];
-        const values = [];
-        if (params.since) {
-            conditions.push('created_at >= ?');
-            values.push(params.since);
-        }
-        if (params.tool_name) {
-            conditions.push('tool_name = ?');
-            values.push(params.tool_name);
-        }
-        const where = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
-        const stats = db.prepare(`
-        SELECT
-          tool_name,
-          COUNT(*) as call_count,
-          SUM(CASE WHEN success = 1 THEN 1 ELSE 0 END) as success_count,
-          SUM(CASE WHEN success = 0 THEN 1 ELSE 0 END) as failure_count,
-          ROUND(AVG(duration_ms)) as avg_duration_ms,
-          MAX(duration_ms) as max_duration_ms,
-          MIN(created_at) as first_call,
-          MAX(created_at) as last_call
-        FROM tool_executions${where}
-        GROUP BY tool_name
-        ORDER BY call_count DESC
-      `).all(...values);
-        const total = db.prepare(`SELECT COUNT(*) as count FROM tool_executions${where}`).get(...values);
-        return successResponse({ total_executions: total.count, tools: stats });
-    });
-    server.tool('get_task_cost', 'Get per-task cost metrics: tool calls made during active timer sessions, total execution time, and tool breakdown. Useful for understanding which tasks consume the most resources.', {
-        task_id: z.number().optional().describe('Get cost for a specific task. Omit for all tasks.'),
-        project_id: z.number().optional().describe('Get cost for all tasks in a project'),
-    }, { readOnlyHint: true }, async (params) => {
-        const db = getDb();
-        if (params.task_id) {
-            // Cost for a single task — use subqueries to avoid cross-join inflation
-            const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
-            if (!task)
-                return errorResponse(`Task ${params.task_id} not found`, 'NOT_FOUND');
-            const sessionTime = db.prepare('SELECT COALESCE(SUM(CASE WHEN end IS NOT NULL THEN (julianday(end) - julianday(start)) * 86400000 ELSE 0 END), 0) as total FROM sessions WHERE task_id = ?').get(params.task_id);
-            // Tool calls that occurred during any session for this task
-            const toolCalls = db.prepare(`
-          SELECT COUNT(*) as total, COALESCE(SUM(te.duration_ms), 0) as duration_ms,
-            SUM(CASE WHEN te.success = 0 THEN 1 ELSE 0 END) as failed
-          FROM tool_executions te
-          WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = ? AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))
-        `).get(params.task_id);
-            // Tool breakdown for this task
-            const tools = db.prepare(`
-          SELECT te.tool_name, COUNT(*) as call_count, ROUND(AVG(te.duration_ms)) as avg_ms
-          FROM tool_executions te
-          WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = ? AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))
-          GROUP BY te.tool_name
-          ORDER BY call_count DESC
-        `).all(params.task_id);
-            return successResponse({
-                task: { task_id: task.id, title: task.title, status: task.status, tool_calls: toolCalls.total, total_tool_duration_ms: toolCalls.duration_ms, failed_calls: toolCalls.failed, total_session_time_ms: sessionTime.total },
-                tool_breakdown: tools,
-            });
-        }
-        // All tasks (optionally filtered by project) — use subqueries to avoid cross-join
-        const projectFilter = params.project_id ? 'WHERE t.project_id = ?' : '';
-        const filterValues = params.project_id ? [params.project_id] : [];
-        const tasks = db.prepare(`
-        SELECT
-          t.id as task_id,
-          t.title,
-          t.status,
-          (SELECT COUNT(*) FROM tool_executions te WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = t.id AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))) as tool_calls,
-          (SELECT COALESCE(SUM(te.duration_ms), 0) FROM tool_executions te WHERE EXISTS (SELECT 1 FROM sessions s WHERE s.task_id = t.id AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end))) as total_tool_duration_ms,
-          (SELECT COALESCE(SUM(CASE WHEN end IS NOT NULL THEN (julianday(end) - julianday(start)) * 86400000 ELSE 0 END), 0) FROM sessions WHERE task_id = t.id) as total_session_time_ms
-        FROM tasks t
-        ${projectFilter}
-        HAVING tool_calls > 0
-        ORDER BY tool_calls DESC
-        LIMIT 30
-      `).all(...filterValues);
-        return successResponse({ tasks });
-    });
-}

package/dist/tools/checkpoint.d.ts

@@ -1,27 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function createCheckpoint(params: {
-    task_id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function getCheckpoint(params: {
-    task_id: number;
-    latest?: boolean;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function listCheckpoints(params: {
-    task_id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerCheckpointTools(server: McpServer): void;

package/dist/tools/checkpoint.js

@@ -1,105 +0,0 @@
-import { z } from 'zod';
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
-import { homedir } from 'os';
-import { getDb } from '../db.js';
-import { successResponse, errorResponse } from '../helpers.js';
-const CHECKPOINTS_DIR = resolve(homedir(), '.taskflow/checkpoints');
-const MAX_CHECKPOINTS_PER_TASK = 10;
-function getTaskDir(taskId) {
-    const dir = resolve(CHECKPOINTS_DIR, String(taskId));
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-export async function createCheckpoint(params) {
-    const db = getDb();
-    const task = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.task_id);
-    if (!task)
-        return errorResponse(`Task ${params.task_id} not found`, 'NOT_FOUND');
-    // Gather task state
-    const deps = db.prepare('SELECT dependency_id FROM task_dependencies WHERE task_id = ?').all(params.task_id);
-    const recentActivity = db.prepare('SELECT * FROM activity_logs WHERE entity_id = ? AND entity_type = ? ORDER BY created_at DESC LIMIT 20').all(params.task_id, 'task');
-    const activeSession = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
-    const totalTime = db.prepare('SELECT SUM(CASE WHEN end IS NOT NULL THEN (julianday(end) - julianday(start)) * 86400000 ELSE 0 END) as total FROM sessions WHERE task_id = ?').get(params.task_id);
-    // Tool stats during this task's sessions
-    const toolStats = db.prepare(`
-    SELECT te.tool_name, COUNT(*) as calls, ROUND(AVG(te.duration_ms)) as avg_ms
-    FROM tool_executions te
-    JOIN sessions s ON s.task_id = ? AND te.created_at >= s.start AND (s.end IS NULL OR te.created_at <= s.end)
-    GROUP BY te.tool_name ORDER BY calls DESC LIMIT 10
-  `).all(params.task_id);
-    const checkpoint = {
-        task_id: params.task_id,
-        timestamp: new Date().toISOString(),
-        task,
-        dependencies: deps.map(d => d.dependency_id),
-        recent_activity: recentActivity,
-        active_session: activeSession,
-        total_time_ms: totalTime.total ?? 0,
-        tool_stats: toolStats,
-    };
-    // Write checkpoint file
-    const taskDir = getTaskDir(params.task_id);
-    const filename = `${checkpoint.timestamp.replace(/[:.]/g, '-')}.json`;
-    const filepath = resolve(taskDir, filename);
-    writeFileSync(filepath, JSON.stringify(checkpoint, null, 2), 'utf-8');
-    // Prune old checkpoints
-    const files = readdirSync(taskDir).filter(f => f.endsWith('.json')).sort();
-    while (files.length > MAX_CHECKPOINTS_PER_TASK) {
-        const oldest = files.shift();
-        try {
-            unlinkSync(resolve(taskDir, oldest));
-        }
-        catch { /* ignore */ }
-    }
-    return successResponse({
-        task_id: params.task_id,
-        checkpoint: filename,
-        path: filepath,
-        total_checkpoints: Math.min(files.length, MAX_CHECKPOINTS_PER_TASK),
-    });
-}
-export async function getCheckpoint(params) {
-    const taskDir = resolve(CHECKPOINTS_DIR, String(params.task_id));
-    let files;
-    try {
-        files = readdirSync(taskDir).filter(f => f.endsWith('.json')).sort();
-    }
-    catch {
-        return errorResponse(`No checkpoints found for task ${params.task_id}`, 'NOT_FOUND');
-    }
-    if (files.length === 0) {
-        return errorResponse(`No checkpoints found for task ${params.task_id}`, 'NOT_FOUND');
-    }
-    // Return latest by default
-    const file = files[files.length - 1];
-    const data = JSON.parse(readFileSync(resolve(taskDir, file), 'utf-8'));
-    return successResponse({
-        checkpoint: file,
-        data,
-        available_checkpoints: files.length,
-    });
-}
-export async function listCheckpoints(params) {
-    const taskDir = resolve(CHECKPOINTS_DIR, String(params.task_id));
-    let files;
-    try {
-        files = readdirSync(taskDir).filter(f => f.endsWith('.json')).sort();
-    }
-    catch {
-        return successResponse({ task_id: params.task_id, checkpoints: [] });
-    }
-    return successResponse({
-        task_id: params.task_id,
-        checkpoints: files.map(f => ({
-            filename: f,
-            timestamp: f.replace('.json', '').replace(/-/g, (m, offset) => offset <= 9 ? '-' : offset <= 15 ? ':' : '.'),
-        })),
-    });
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerCheckpointTools(server) {
-    server.tool('create_checkpoint', 'Create a checkpoint snapshot of a task\'s current state. Captures: task data, dependencies, recent activity, active timer, tool stats. Useful before context switches or at key milestones.', { task_id: z.number().describe('The task ID to checkpoint') }, { readOnlyHint: false }, async (params) => createCheckpoint(params));
-    server.tool('get_checkpoint', 'Get the latest checkpoint for a task. Returns the full task snapshot — useful for resuming work after an interruption.', { task_id: z.number().describe('The task ID to get checkpoint for') }, { readOnlyHint: true }, async (params) => getCheckpoint(params));
-    server.tool('list_checkpoints', 'List all available checkpoints for a task.', { task_id: z.number().describe('The task ID to list checkpoints for') }, { readOnlyHint: true }, async (params) => listCheckpoints(params));
-}

package/dist/tools/notifications.d.ts

@@ -1,31 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function listNotifications(params: {
-    limit?: number;
-    unread_only?: boolean;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function markNotificationRead(params: {
-    id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function markAllNotificationsRead(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function clearNotifications(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerNotificationTools(server: McpServer): void;

package/dist/tools/notifications.js

@@ -1,59 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { errorResponse, successResponse, broadcastChange } from '../helpers.js';
-// ─── exported handler functions ───────────────────────────────────────
-export async function listNotifications(params) {
-    const db = getDb();
-    const limit = params.limit ?? 50;
-    let sql = 'SELECT * FROM notifications';
-    const values = [];
-    if (params.unread_only) {
-        sql += ' WHERE read = 0';
-    }
-    sql += ' ORDER BY created_at DESC LIMIT ?';
-    values.push(limit);
-    const rows = db.prepare(sql).all(...values);
-    return successResponse(rows);
-}
-export async function markNotificationRead(params) {
-    const db = getDb();
-    const result = db
-        .prepare('UPDATE notifications SET read = 1 WHERE id = ?')
-        .run(params.id);
-    if (result.changes === 0) {
-        return errorResponse('Notification not found', 'NOT_FOUND');
-    }
-    const row = db
-        .prepare('SELECT * FROM notifications WHERE id = ?')
-        .get(params.id);
-    const notification = row;
-    broadcastChange('notification', 'notification_updated', notification);
-    return successResponse(notification);
-}
-export async function markAllNotificationsRead() {
-    const db = getDb();
-    const result = db
-        .prepare('UPDATE notifications SET read = 1 WHERE read = 0')
-        .run();
-    broadcastChange('notification', 'notifications_all_read', {});
-    return successResponse({ updated: result.changes });
-}
-export async function clearNotifications() {
-    const db = getDb();
-    const countRow = db
-        .prepare('SELECT COUNT(*) AS count FROM notifications')
-        .get();
-    db.prepare('DELETE FROM notifications').run();
-    broadcastChange('notification', 'notifications_cleared', {});
-    return successResponse({ deleted: countRow.count, message: 'Notifications cleared' });
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerNotificationTools(server) {
-    server.tool('list_notifications', 'List notifications. Check with unread_only=true at conversation start to surface important updates for the user.', {
-        limit: z.number().optional(),
-        unread_only: z.boolean().optional(),
-    }, { readOnlyHint: true }, async (params) => listNotifications(params));
-    server.tool('mark_notification_read', 'Mark a notification as read after surfacing it to the user.', { id: z.number() }, { readOnlyHint: false }, async (params) => markNotificationRead(params));
-    server.tool('mark_all_notifications_read', 'Mark all unread notifications as read. Call after the user has been briefed on pending notifications.', {}, { readOnlyHint: false }, async () => markAllNotificationsRead());
-    server.tool('clear_notifications', 'Delete all notifications. Use with caution — this is irreversible.', {}, { destructiveHint: true }, async () => clearNotifications());
-}

package/dist/tools/projects.d.ts

@@ -1,55 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function createProject(params: {
-    name: string;
-    color?: string;
-    type?: string;
-    description?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function listProjects(): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function getProject(params: {
-    id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function updateProject(params: {
-    id: number;
-    name?: string;
-    color?: string;
-    type?: string;
-    description?: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function deleteProject(params: {
-    id: number;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function searchProjects(params: {
-    query: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerProjectTools(server: McpServer): void;

package/dist/tools/projects.js

@@ -1,112 +0,0 @@
-import { z } from 'zod';
-import { getDb } from '../db.js';
-import { logActivity, errorResponse, successResponse, now, broadcastChange } from '../helpers.js';
-import { ProjectType } from '../types.js';
-function parseTask(row) {
-    return {
-        ...row,
-        dependencies: JSON.parse(row.dependencies),
-        links: JSON.parse(row.links),
-        tags: JSON.parse(row.tags),
-    };
-}
-// ─── exported handler functions ───────────────────────────────────────
-export async function createProject(params) {
-    const db = getDb();
-    const { name, color = '#de8eff', type = 'active_project', description, } = params;
-    const ts = now();
-    const result = db.prepare(`INSERT INTO projects (name, color, type, description, created_at, updated_at)
-     VALUES (?, ?, ?, ?, ?, ?)`).run(name, color, type, description ?? null, ts, ts);
-    const project = db.prepare('SELECT * FROM projects WHERE id = ?').get(result.lastInsertRowid);
-    logActivity('project_created', name, { entityType: 'project', entityId: project.id });
-    const createdProject = project;
-    broadcastChange('project', 'project_created', createdProject);
-    return successResponse(createdProject);
-}
-export async function listProjects() {
-    const db = getDb();
-    const rows = db.prepare(`SELECT projects.*, COUNT(tasks.id) AS task_count
-     FROM projects
-     LEFT JOIN tasks ON tasks.project_id = projects.id
-     GROUP BY projects.id`).all();
-    return successResponse(rows);
-}
-export async function getProject(params) {
-    const db = getDb();
-    const project = db.prepare('SELECT * FROM projects WHERE id = ?').get(params.id);
-    if (!project)
-        return errorResponse('Project not found', 'NOT_FOUND');
-    const tasks = db.prepare('SELECT * FROM tasks WHERE project_id = ?').all(params.id);
-    return successResponse({
-        ...project,
-        tasks: tasks.map(parseTask),
-    });
-}
-export async function updateProject(params) {
-    const db = getDb();
-    const existing = db.prepare('SELECT * FROM projects WHERE id = ?').get(params.id);
-    if (!existing)
-        return errorResponse('Project not found', 'NOT_FOUND');
-    const updates = {};
-    if (params.name !== undefined)
-        updates.name = params.name;
-    if (params.color !== undefined)
-        updates.color = params.color;
-    if (params.type !== undefined)
-        updates.type = params.type;
-    if (params.description !== undefined)
-        updates.description = params.description;
-    if (Object.keys(updates).length === 0) {
-        return successResponse(existing);
-    }
-    updates.updated_at = now();
-    const setClauses = Object.keys(updates).map(k => `${k} = ?`).join(', ');
-    const vals = Object.values(updates);
-    db.prepare(`UPDATE projects SET ${setClauses} WHERE id = ?`).run(...vals, params.id);
-    logActivity('project_updated', params.name ?? existing.name, { entityType: 'project', entityId: params.id });
-    const updated = db.prepare('SELECT * FROM projects WHERE id = ?').get(params.id);
-    const updatedProject = updated;
-    broadcastChange('project', 'project_updated', updatedProject);
-    return successResponse(updatedProject);
-}
-export async function deleteProject(params) {
-    const db = getDb();
-    const project = db.prepare('SELECT * FROM projects WHERE id = ?').get(params.id);
-    if (!project)
-        return errorResponse('Project not found', 'NOT_FOUND');
-    // FK ON DELETE SET NULL handles unlinking tasks automatically
-    db.prepare('DELETE FROM projects WHERE id = ?').run(params.id);
-    logActivity('project_deleted', project.name, { entityType: 'project', entityId: params.id });
-    broadcastChange('project', 'project_deleted', { id: params.id });
-    return successResponse({ deleted: true, id: params.id });
-}
-export async function searchProjects(params) {
-    const db = getDb();
-    const like = `%${params.query}%`;
-    const rows = db.prepare(`SELECT projects.*, COUNT(tasks.id) AS task_count
-     FROM projects
-     LEFT JOIN tasks ON tasks.project_id = projects.id
-     WHERE projects.name LIKE ? COLLATE NOCASE OR projects.description LIKE ? COLLATE NOCASE
-     GROUP BY projects.id`).all(like, like);
-    return successResponse(rows);
-}
-// ─── MCP registration ─────────────────────────────────────────────────
-export function registerProjectTools(server) {
-    server.tool('create_project', 'Create a new project. Projects group related tasks and track time across them.', {
-        name: z.string(),
-        color: z.string().optional(),
-        type: ProjectType.optional(),
-        description: z.string().optional(),
-    }, { readOnlyHint: false }, async (params) => createProject(params));
-    server.tool('list_projects', 'List all projects with task count. Call this at conversation start to understand the workspace.', {}, { readOnlyHint: true }, async () => listProjects());
-    server.tool('get_project', 'Get a project by ID with all its tasks. Use this to understand the full scope of a project before starting work.', { id: z.number() }, { readOnlyHint: true }, async (params) => getProject(params));
-    server.tool('update_project', 'Update project fields such as name, color, type, or description.', {
-        id: z.number(),
-        name: z.string().optional(),
-        color: z.string().optional(),
-        type: ProjectType.optional(),
-        description: z.string().optional(),
-    }, { readOnlyHint: false }, async (params) => updateProject(params));
-    server.tool('delete_project', 'Delete a project by ID. Tasks under this project will be unlinked (project_id set to NULL), not deleted.', { id: z.number() }, { destructiveHint: true }, async (params) => deleteProject(params));
-    server.tool('search_projects', 'Search projects by name or description. Use this to find projects related to your current work.', { query: z.string() }, { readOnlyHint: true }, async (params) => searchProjects(params));
-}

package/dist/tools/settings.d.ts

@@ -1,19 +0,0 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare function getSetting(params: {
-    key: string;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function updateSetting(params: {
-    key: string;
-    value: unknown;
-}): Promise<{
-    content: {
-        type: "text";
-        text: string;
-    }[];
-}>;
-export declare function registerSettingsTools(server: McpServer): void;