@dalmasonto/taskflow-mcp 1.0.0

package/dist/tools/tasks.js

@@ -0,0 +1,351 @@
+import { z } from 'zod';
+import { getDb } from '../db.js';
+import { logActivity, errorResponse, successResponse, now, broadcastChange } from '../helpers.js';
+import { TaskStatus, TaskPriority, LinkSchema, VALID_TRANSITIONS } from '../types.js';
+function parseTask(row) {
+    return {
+        ...row,
+        dependencies: JSON.parse(row.dependencies),
+        links: JSON.parse(row.links),
+        tags: JSON.parse(row.tags),
+    };
+}
+function detectCycle(taskId, proposedDeps) {
+    const db = getDb();
+    const allTasks = db.prepare('SELECT id, dependencies FROM tasks').all();
+    // Build adjacency list: task -> its dependencies (task depends on dep means edge task->dep)
+    // A cycle means: taskId depends on X which depends on Y ... which depends on taskId
+    // We need to check: from any of proposedDeps, can we reach taskId by following dependencies?
+    // Actually, the direction matters. If task A depends on B, it means B must be done before A.
+    // A cycle: A depends on B, B depends on A.
+    // Adjacency: A -> [B], B -> [A]. Starting from A's deps [B], follow B's deps [A], found A = cycle.
+    const adj = new Map();
+    for (const t of allTasks) {
+        const deps = JSON.parse(t.dependencies);
+        if (t.id === taskId) {
+            // Use proposed deps instead of current
+            adj.set(t.id, proposedDeps);
+        }
+        else {
+            adj.set(t.id, deps);
+        }
+    }
+    // If task doesn't exist yet (create), add it
+    if (!adj.has(taskId)) {
+        adj.set(taskId, proposedDeps);
+    }
+    // DFS from taskId following dependency edges to see if we return to taskId
+    const visited = new Set();
+    const inStack = new Set();
+    function dfs(node) {
+        if (inStack.has(node))
+            return true; // back-edge = cycle
+        if (visited.has(node))
+            return false;
+        visited.add(node);
+        inStack.add(node);
+        const deps = adj.get(node) || [];
+        for (const dep of deps) {
+            if (dfs(dep))
+                return true;
+        }
+        inStack.delete(node);
+        return false;
+    }
+    return dfs(taskId);
+}
+// ─── exported handler functions ───────────────────────────────────────
+export async function createTask(params) {
+    const db = getDb();
+    const { title, description, status = 'not_started', priority = 'medium', project_id, dependencies = [], tags = [], links = [], due_date, estimated_time, } = params;
+    // Validate project_id
+    if (project_id != null) {
+        const proj = db.prepare('SELECT id FROM projects WHERE id = ?').get(project_id);
+        if (!proj)
+            return errorResponse('Project not found', 'NOT_FOUND');
+    }
+    // Validate dependencies exist
+    if (dependencies.length > 0) {
+        const placeholders = dependencies.map(() => '?').join(',');
+        const existing = db.prepare(`SELECT id FROM tasks WHERE id IN (${placeholders})`).all(...dependencies);
+        if (existing.length !== dependencies.length) {
+            return errorResponse('One or more dependency task IDs do not exist', 'VALIDATION_ERROR');
+        }
+    }
+    // Check for cycles — we need a temporary ID; use max(id)+1 as placeholder
+    if (dependencies.length > 0) {
+        const maxRow = db.prepare('SELECT COALESCE(MAX(id), 0) + 1 AS next_id FROM tasks').get();
+        if (detectCycle(maxRow.next_id, dependencies)) {
+            return errorResponse('Adding these dependencies would create a cycle', 'CYCLE_DETECTED');
+        }
+    }
+    const ts = now();
+    const result = db.prepare(`INSERT INTO tasks (title, description, status, priority, project_id, dependencies, links, tags, due_date, estimated_time, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(title, description ?? null, status, priority, project_id ?? null, JSON.stringify(dependencies), JSON.stringify(links), JSON.stringify(tags), due_date ?? null, estimated_time ?? null, ts, ts);
+    const task = db.prepare('SELECT * FROM tasks WHERE id = ?').get(result.lastInsertRowid);
+    logActivity('task_created', title, { entityType: 'task', entityId: task.id });
+    const createdTask = parseTask(task);
+    broadcastChange('task', 'task_created', createdTask);
+    return successResponse(createdTask);
+}
+export async function listTasks(params) {
+    const db = getDb();
+    const conditions = [];
+    const values = [];
+    if (params.status) {
+        conditions.push('status = ?');
+        values.push(params.status);
+    }
+    if (params.project_id != null) {
+        conditions.push('project_id = ?');
+        values.push(params.project_id);
+    }
+    if (params.priority) {
+        conditions.push('priority = ?');
+        values.push(params.priority);
+    }
+    let sql = 'SELECT * FROM tasks';
+    if (conditions.length > 0) {
+        sql += ' WHERE ' + conditions.join(' AND ');
+    }
+    let rows = db.prepare(sql).all(...values);
+    // Filter by tag in-memory (JSON column)
+    if (params.tag) {
+        rows = rows.filter(r => {
+            const tags = JSON.parse(r.tags);
+            return tags.includes(params.tag);
+        });
+    }
+    return successResponse(rows.map(parseTask));
+}
+export async function getTask(params) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
+    if (!row)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    const timeRow = db.prepare(`SELECT
+       COUNT(*) AS session_count,
+       COALESCE(SUM((julianday(COALESCE(end, datetime('now'))) - julianday(start)) * 86400000), 0) AS total_time
+     FROM sessions WHERE task_id = ?`).get(params.id);
+    return successResponse({
+        ...parseTask(row),
+        total_time: Math.round(timeRow.total_time),
+        session_count: timeRow.session_count,
+    });
+}
+export async function updateTask(params) {
+    const db = getDb();
+    const old = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
+    if (!old)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    const oldParsed = parseTask(old);
+    // Validate dependencies
+    const newDeps = params.dependencies ?? oldParsed.dependencies;
+    if (params.dependencies && params.dependencies.length > 0) {
+        const placeholders = params.dependencies.map(() => '?').join(',');
+        const existing = db.prepare(`SELECT id FROM tasks WHERE id IN (${placeholders})`).all(...params.dependencies);
+        if (existing.length !== params.dependencies.length) {
+            return errorResponse('One or more dependency task IDs do not exist', 'VALIDATION_ERROR');
+        }
+        // Cycle detection
+        if (detectCycle(params.id, params.dependencies)) {
+            return errorResponse('Adding these dependencies would create a cycle', 'CYCLE_DETECTED');
+        }
+    }
+    // Validate project_id if changing
+    if (params.project_id != null) {
+        const proj = db.prepare('SELECT id FROM projects WHERE id = ?').get(params.project_id);
+        if (!proj)
+            return errorResponse('Project not found', 'NOT_FOUND');
+    }
+    const ts = now();
+    const updates = {};
+    if (params.title !== undefined)
+        updates.title = params.title;
+    if (params.description !== undefined)
+        updates.description = params.description;
+    if (params.status !== undefined)
+        updates.status = params.status;
+    if (params.priority !== undefined)
+        updates.priority = params.priority;
+    if (params.project_id !== undefined)
+        updates.project_id = params.project_id;
+    if (params.dependencies !== undefined)
+        updates.dependencies = JSON.stringify(params.dependencies);
+    if (params.tags !== undefined)
+        updates.tags = JSON.stringify(params.tags);
+    if (params.links !== undefined)
+        updates.links = JSON.stringify(params.links);
+    if (params.due_date !== undefined)
+        updates.due_date = params.due_date;
+    if (params.estimated_time !== undefined)
+        updates.estimated_time = params.estimated_time;
+    if (Object.keys(updates).length === 0) {
+        return successResponse(oldParsed);
+    }
+    updates.updated_at = ts;
+    const setClauses = Object.keys(updates).map(k => `${k} = ?`).join(', ');
+    const vals = Object.values(updates);
+    db.prepare(`UPDATE tasks SET ${setClauses} WHERE id = ?`).run(...vals, params.id);
+    // Log granular changes for deps, tags, links
+    if (params.dependencies !== undefined) {
+        const added = params.dependencies.filter(d => !oldParsed.dependencies.includes(d));
+        const removed = oldParsed.dependencies.filter(d => !params.dependencies.includes(d));
+        for (const d of added) {
+            logActivity('dependency_added', oldParsed.title, { detail: `Dependency ${d} added`, entityType: 'task', entityId: params.id });
+        }
+        for (const d of removed) {
+            logActivity('dependency_removed', oldParsed.title, { detail: `Dependency ${d} removed`, entityType: 'task', entityId: params.id });
+        }
+    }
+    if (params.tags !== undefined) {
+        const added = params.tags.filter(t => !oldParsed.tags.includes(t));
+        const removed = oldParsed.tags.filter(t => !params.tags.includes(t));
+        for (const t of added) {
+            logActivity('tag_added', oldParsed.title, { detail: `Tag "${t}" added`, entityType: 'task', entityId: params.id });
+        }
+        for (const t of removed) {
+            logActivity('tag_removed', oldParsed.title, { detail: `Tag "${t}" removed`, entityType: 'task', entityId: params.id });
+        }
+    }
+    if (params.links !== undefined) {
+        const oldUrls = new Set(oldParsed.links.map(l => l.url));
+        const newUrls = new Set(params.links.map(l => l.url));
+        const added = params.links.filter(l => !oldUrls.has(l.url));
+        const removed = oldParsed.links.filter(l => !newUrls.has(l.url));
+        for (const l of added) {
+            logActivity('link_added', oldParsed.title, { detail: `Link "${l.label}" added`, entityType: 'task', entityId: params.id });
+        }
+        for (const l of removed) {
+            logActivity('task_unlinked', oldParsed.title, { detail: `Link "${l.label}" removed`, entityType: 'task', entityId: params.id });
+        }
+    }
+    const updated = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
+    const updatedTask = parseTask(updated);
+    broadcastChange('task', 'task_updated', updatedTask);
+    return successResponse(updatedTask);
+}
+export async function updateTaskStatus(params) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
+    if (!row)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    const currentStatus = row.status;
+    const allowed = VALID_TRANSITIONS[currentStatus];
+    if (!allowed || !allowed.includes(params.status)) {
+        return errorResponse(`Cannot transition from "${currentStatus}" to "${params.status}"`, 'INVALID_TRANSITION');
+    }
+    const ts = now();
+    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(params.status, ts, params.id);
+    // Log appropriate action
+    let statusAction;
+    if (params.status === 'done') {
+        logActivity('task_completed', row.title, { entityType: 'task', entityId: params.id });
+        statusAction = 'task_completed';
+    }
+    else if (params.status === 'partial_done') {
+        logActivity('task_partial_done', row.title, { entityType: 'task', entityId: params.id });
+        statusAction = 'task_partial_done';
+    }
+    else {
+        logActivity('task_status_changed', row.title, {
+            detail: `${currentStatus} -> ${params.status}`,
+            entityType: 'task',
+            entityId: params.id,
+        });
+        statusAction = 'task_status_changed';
+    }
+    const updated = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
+    const updatedTask = parseTask(updated);
+    broadcastChange('task', statusAction, updatedTask);
+    return successResponse(updatedTask);
+}
+export async function deleteTask(params) {
+    const db = getDb();
+    const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(params.id);
+    if (!row)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    db.prepare('DELETE FROM tasks WHERE id = ?').run(params.id);
+    logActivity('task_deleted', row.title, { entityType: 'task', entityId: params.id });
+    broadcastChange('task', 'task_deleted', { id: params.id });
+    return successResponse({ deleted: true, id: params.id });
+}
+export async function bulkCreateTasks(params) {
+    const db = getDb();
+    const ts = now();
+    const created = [];
+    const insertStmt = db.prepare(`INSERT INTO tasks (title, description, status, priority, project_id, dependencies, links, tags, due_date, estimated_time, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+    const transaction = db.transaction(() => {
+        for (const t of params.tasks) {
+            const result = insertStmt.run(t.title, t.description ?? null, t.status ?? 'not_started', t.priority ?? 'medium', t.project_id ?? null, JSON.stringify(t.dependencies ?? []), '[]', JSON.stringify(t.tags ?? []), null, null, ts, ts);
+            const row = db.prepare('SELECT * FROM tasks WHERE id = ?').get(result.lastInsertRowid);
+            created.push(parseTask(row));
+        }
+    });
+    transaction();
+    logActivity('tasks_bulk_created', `${created.length} tasks created`, {
+        detail: created.map(t => t.title).join(', '),
+    });
+    const createdTasks = created;
+    broadcastChange('task', 'tasks_bulk_created', { tasks: createdTasks });
+    return successResponse(createdTasks);
+}
+export async function searchTasks(params) {
+    const db = getDb();
+    const like = `%${params.query}%`;
+    const rows = db.prepare(`SELECT * FROM tasks WHERE title LIKE ? COLLATE NOCASE OR description LIKE ? COLLATE NOCASE`).all(like, like);
+    return successResponse(rows.map(parseTask));
+}
+// ─── MCP registration ─────────────────────────────────────────────────
+export function registerTaskTools(server) {
+    server.tool('create_task', 'Create a new task. Use this when starting new work to keep TaskFlow in sync. Supports dependencies, tags, links, and time estimates.', {
+        title: z.string(),
+        description: z.string().optional(),
+        status: TaskStatus.optional(),
+        priority: TaskPriority.optional(),
+        project_id: z.number().optional(),
+        dependencies: z.array(z.number()).optional(),
+        tags: z.array(z.string()).optional(),
+        links: z.array(LinkSchema).optional(),
+        due_date: z.string().optional(),
+        estimated_time: z.number().optional(),
+    }, async (params) => createTask(params));
+    server.tool('list_tasks', 'List tasks with optional filters. Use at conversation start to see what is in progress or blocked. Filter by status, project, priority, or tag.', {
+        status: TaskStatus.optional(),
+        project_id: z.number().optional(),
+        priority: TaskPriority.optional(),
+        tag: z.string().optional(),
+    }, async (params) => listTasks(params));
+    server.tool('get_task', 'Get a task by ID with time tracking info. Read the description carefully — it often contains implementation details and acceptance criteria.', { id: z.number() }, async (params) => getTask(params));
+    server.tool('update_task', 'Update task fields. Use this to add details, update descriptions with progress notes, or adjust priority as you learn more.', {
+        id: z.number(),
+        title: z.string().optional(),
+        description: z.string().optional(),
+        status: TaskStatus.optional(),
+        priority: TaskPriority.optional(),
+        project_id: z.number().optional(),
+        dependencies: z.array(z.number()).optional(),
+        tags: z.array(z.string()).optional(),
+        links: z.array(LinkSchema).optional(),
+        due_date: z.string().optional(),
+        estimated_time: z.number().optional(),
+    }, async (params) => updateTask(params));
+    server.tool('update_task_status', 'Update task status with transition validation. Use when a task becomes blocked, is partially done, or needs to be reopened.', {
+        id: z.number(),
+        status: TaskStatus,
+    }, async (params) => updateTaskStatus(params));
+    server.tool('delete_task', 'Delete a task by ID. Use sparingly — prefer updating status to "done" instead of deleting.', { id: z.number() }, async (params) => deleteTask(params));
+    server.tool('bulk_create_tasks', 'Create multiple tasks in a single transaction. Useful when breaking down a feature into subtasks.', {
+        tasks: z.array(z.object({
+            title: z.string(),
+            description: z.string().optional(),
+            priority: TaskPriority.optional(),
+            project_id: z.number().optional(),
+            status: TaskStatus.optional(),
+            dependencies: z.array(z.number()).optional(),
+            tags: z.array(z.string()).optional(),
+        })),
+    }, async (params) => bulkCreateTasks(params));
+    server.tool('search_tasks', 'Search tasks by title or description. Use this to find tasks related to your current work before creating duplicates.', { query: z.string() }, async (params) => searchTasks(params));
+}

package/dist/tools/timer.d.ts

@@ -0,0 +1,37 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function startTimer(params: {
+    task_id: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function pauseTimer(params: {
+    task_id: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function stopTimer(params: {
+    task_id: number;
+    final_status?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function listSessions(params: {
+    task_id?: number;
+    start_date?: string;
+    end_date?: string;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;
+export declare function registerTimerTools(server: McpServer): void;

package/dist/tools/timer.js

@@ -0,0 +1,131 @@
+import { z } from 'zod';
+import { getDb } from '../db.js';
+import { logActivity, errorResponse, successResponse, now, broadcastChange } from '../helpers.js';
+import { VALID_TRANSITIONS } from '../types.js';
+// ─── exported handler functions ───────────────────────────────────────
+export async function startTimer(params) {
+    const db = getDb();
+    const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
+    if (!task)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    // Check no open session exists
+    const openSession = db.prepare('SELECT id FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
+    if (openSession)
+        return errorResponse('A timer session is already active for this task', 'SESSION_ALREADY_ACTIVE');
+    // Check valid transition to in_progress
+    const currentStatus = task.status;
+    const allowed = VALID_TRANSITIONS[currentStatus];
+    if (!allowed || !allowed.includes('in_progress')) {
+        return errorResponse(`Cannot transition from "${currentStatus}" to "in_progress"`, 'INVALID_TRANSITION');
+    }
+    const ts = now();
+    // Create session
+    const result = db.prepare('INSERT INTO sessions (task_id, start, end) VALUES (?, ?, ?)').run(params.task_id, ts, null);
+    // Update task status to in_progress
+    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run('in_progress', ts, params.task_id);
+    logActivity('timer_started', task.title, { entityType: 'task', entityId: params.task_id });
+    const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(result.lastInsertRowid);
+    broadcastChange('timer', 'timer_started', { task_id: params.task_id, session, task_status: 'in_progress' });
+    return successResponse(session);
+}
+export async function pauseTimer(params) {
+    const db = getDb();
+    const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
+    if (!task)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    // Find open session
+    const session = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
+    if (!session)
+        return errorResponse('No active timer session for this task', 'NO_ACTIVE_SESSION');
+    const endTime = now();
+    const duration = new Date(endTime).getTime() - new Date(session.start).getTime();
+    // Close session
+    db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(endTime, session.id);
+    // Update task to paused
+    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run('paused', endTime, params.task_id);
+    logActivity('timer_paused', task.title, {
+        detail: `Duration: ${duration}ms`,
+        entityType: 'task',
+        entityId: params.task_id,
+    });
+    const pausedSession = { ...session, end: endTime, duration };
+    broadcastChange('timer', 'timer_paused', { task_id: params.task_id, session: pausedSession, task_status: 'paused' });
+    return successResponse(pausedSession);
+}
+export async function stopTimer(params) {
+    const db = getDb();
+    const task = db.prepare('SELECT id, title, status FROM tasks WHERE id = ?').get(params.task_id);
+    if (!task)
+        return errorResponse('Task not found', 'NOT_FOUND');
+    // Find open session
+    const session = db.prepare('SELECT * FROM sessions WHERE task_id = ? AND end IS NULL').get(params.task_id);
+    if (!session)
+        return errorResponse('No active timer session for this task', 'NO_ACTIVE_SESSION');
+    const finalStatus = params.final_status ?? 'done';
+    const endTime = now();
+    const duration = new Date(endTime).getTime() - new Date(session.start).getTime();
+    // Close session
+    db.prepare('UPDATE sessions SET end = ? WHERE id = ?').run(endTime, session.id);
+    // Update task to final_status
+    db.prepare('UPDATE tasks SET status = ?, updated_at = ? WHERE id = ?').run(finalStatus, endTime, params.task_id);
+    logActivity('timer_stopped', task.title, {
+        detail: `Duration: ${duration}ms, final status: ${finalStatus}`,
+        entityType: 'task',
+        entityId: params.task_id,
+    });
+    // Also log status-specific action
+    if (finalStatus === 'done') {
+        logActivity('task_completed', task.title, { entityType: 'task', entityId: params.task_id });
+    }
+    else if (finalStatus === 'partial_done') {
+        logActivity('task_partial_done', task.title, { entityType: 'task', entityId: params.task_id });
+    }
+    const stoppedSession = { ...session, end: endTime, duration };
+    broadcastChange('timer', 'timer_stopped', { task_id: params.task_id, session: stoppedSession, task_status: finalStatus });
+    return successResponse(stoppedSession);
+}
+export async function listSessions(params) {
+    const db = getDb();
+    const conditions = [];
+    const values = [];
+    if (params.task_id != null) {
+        conditions.push('task_id = ?');
+        values.push(params.task_id);
+    }
+    if (params.start_date) {
+        conditions.push('start >= ?');
+        values.push(params.start_date);
+    }
+    if (params.end_date) {
+        conditions.push('start <= ?');
+        values.push(params.end_date);
+    }
+    let sql = 'SELECT * FROM sessions';
+    if (conditions.length > 0) {
+        sql += ' WHERE ' + conditions.join(' AND ');
+    }
+    sql += ' ORDER BY start ASC';
+    const rows = db.prepare(sql).all(...values);
+    const nowMs = Date.now();
+    const sessions = rows.map(row => {
+        const startMs = new Date(row.start).getTime();
+        const endMs = row.end ? new Date(row.end).getTime() : nowMs;
+        const duration = endMs - startMs;
+        return { ...row, duration };
+    });
+    return successResponse(sessions);
+}
+// ─── MCP registration ─────────────────────────────────────────────────
+export function registerTimerTools(server) {
+    server.tool('start_timer', 'Start a timer session for a task. Call this before beginning work on any task to track focused time. Automatically transitions the task to "in_progress".', { task_id: z.number() }, async (params) => startTimer(params));
+    server.tool('pause_timer', 'Pause the active timer session for a task. Call when switching context or waiting for user input. The task transitions to "paused".', { task_id: z.number() }, async (params) => pauseTimer(params));
+    server.tool('stop_timer', 'Stop the active timer and set a final status. Call when finishing work — use "done" if complete, "partial_done" if more remains, "blocked" if stuck.', {
+        task_id: z.number(),
+        final_status: z.enum(['done', 'partial_done', 'blocked']).optional(),
+    }, async (params) => stopTimer(params));
+    server.tool('list_sessions', 'List timer sessions with optional filters. Use to review time spent on a task or across a date range.', {
+        task_id: z.number().optional(),
+        start_date: z.string().optional(),
+        end_date: z.string().optional(),
+    }, async (params) => listSessions(params));
+}

package/dist/types.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const TaskStatus: z.ZodEnum<{
+    not_started: "not_started";
+    in_progress: "in_progress";
+    paused: "paused";
+    blocked: "blocked";
+    partial_done: "partial_done";
+    done: "done";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatus>;
+export declare const TaskPriority: z.ZodEnum<{
+    low: "low";
+    medium: "medium";
+    high: "high";
+    critical: "critical";
+}>;
+export type TaskPriority = z.infer<typeof TaskPriority>;
+export declare const ProjectType: z.ZodEnum<{
+    active_project: "active_project";
+    project_idea: "project_idea";
+}>;
+export type ProjectType = z.infer<typeof ProjectType>;
+export declare const NotificationType: z.ZodEnum<{
+    info: "info";
+    success: "success";
+    warning: "warning";
+    error: "error";
+}>;
+export type NotificationType = z.infer<typeof NotificationType>;
+export declare const ActivityAction: z.ZodEnum<{
+    task_created: "task_created";
+    task_deleted: "task_deleted";
+    task_status_changed: "task_status_changed";
+    task_completed: "task_completed";
+    task_partial_done: "task_partial_done";
+    timer_started: "timer_started";
+    timer_paused: "timer_paused";
+    timer_stopped: "timer_stopped";
+    project_created: "project_created";
+    project_deleted: "project_deleted";
+    project_updated: "project_updated";
+    tasks_bulk_created: "tasks_bulk_created";
+    settings_saved: "settings_saved";
+    data_seeded: "data_seeded";
+    data_cleared: "data_cleared";
+    task_linked: "task_linked";
+    task_unlinked: "task_unlinked";
+    dependency_added: "dependency_added";
+    dependency_removed: "dependency_removed";
+    link_added: "link_added";
+    tag_added: "tag_added";
+    tag_removed: "tag_removed";
+    debug_log: "debug_log";
+}>;
+export type ActivityAction = z.infer<typeof ActivityAction>;
+export declare const VALID_TRANSITIONS: Record<TaskStatus, TaskStatus[]>;
+export type ErrorCode = 'NOT_FOUND' | 'INVALID_TRANSITION' | 'VALIDATION_ERROR' | 'CYCLE_DETECTED' | 'SESSION_ALREADY_ACTIVE' | 'NO_ACTIVE_SESSION';
+export declare const LinkSchema: z.ZodObject<{
+    label: z.ZodString;
+    url: z.ZodString;
+}, z.core.$strip>;

package/dist/types.js

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export const TaskStatus = z.enum([
+    'not_started', 'in_progress', 'paused', 'blocked', 'partial_done', 'done'
+]);
+export const TaskPriority = z.enum(['low', 'medium', 'high', 'critical']);
+export const ProjectType = z.enum(['active_project', 'project_idea']);
+export const NotificationType = z.enum(['info', 'success', 'warning', 'error']);
+export const ActivityAction = z.enum([
+    'task_created', 'task_deleted', 'task_status_changed', 'task_completed',
+    'task_partial_done', 'timer_started', 'timer_paused', 'timer_stopped',
+    'project_created', 'project_deleted', 'project_updated',
+    'tasks_bulk_created', 'settings_saved', 'data_seeded', 'data_cleared',
+    'task_linked', 'task_unlinked', 'dependency_added', 'dependency_removed',
+    'link_added', 'tag_added', 'tag_removed', 'debug_log',
+]);
+export const VALID_TRANSITIONS = {
+    not_started: ['in_progress', 'blocked'],
+    in_progress: ['paused', 'blocked', 'partial_done', 'done'],
+    paused: ['in_progress', 'blocked', 'partial_done', 'done'],
+    blocked: ['not_started', 'in_progress'],
+    partial_done: ['in_progress', 'done'],
+    done: ['in_progress'],
+};
+export const LinkSchema = z.object({ label: z.string(), url: z.string() });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@dalmasonto/taskflow-mcp",
+  "version": "1.0.0",
+  "description": "MCP server for TaskFlow — manage projects, tasks, timers, analytics via AI agents",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "taskflow-mcp": "dist/index.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "task-manager",
+    "ai-agent",
+    "claude",
+    "cursor",
+    "windsurf",
+    "productivity",
+    "time-tracking",
+    "sqlite"
+  ],
+  "author": "dalmasonto",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dalmasonto/task_flow",
+    "directory": "mcp-server"
+  },
+  "homepage": "https://github.com/dalmasonto/task_flow#mcp-server-ai-agent-tools",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "latest",
+    "better-sqlite3": "latest",
+    "zod": "latest"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "latest",
+    "@types/node": "latest",
+    "typescript": "latest",
+    "vitest": "latest"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}