@dalmasonto/taskflow-mcp 1.0.35 → 2.0.0

package/dist/resources.js

@@ -1,89 +0,0 @@
-import { ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { getDb } from './db.js';
-import { getAgentInstructions } from './tools/agent.js';
-export function registerResources(server) {
-    // ─── Agent Instructions Resource ────────────────────────────────────
-    // Auto-loaded by MCP clients on connection — ensures rules are always present
-    server.resource('agent-instructions', 'taskflow://instructions', { description: 'TaskFlow agent onboarding instructions — rules, workflow, and live project context', mimeType: 'application/json' }, async (uri) => {
-        const instructions = await getAgentInstructions();
-        return {
-            contents: [{
-                    uri: uri.href,
-                    text: JSON.stringify(instructions, null, 2),
-                    mimeType: 'application/json',
-                }],
-        };
-    });
-    // ─── Projects Resource ──────────────────────────────────────────────
-    server.resource('projects', new ResourceTemplate('taskflow://projects/{id}', {
-        list: async () => {
-            const db = getDb();
-            const projects = db.prepare('SELECT * FROM projects ORDER BY updated_at DESC').all();
-            return {
-                resources: projects.map(p => ({
-                    uri: `taskflow://projects/${p.id}`,
-                    name: p.name,
-                    description: p.description ?? undefined,
-                    mimeType: 'application/json',
-                })),
-            };
-        },
-    }), { description: 'TaskFlow projects', mimeType: 'application/json' }, async (uri, variables) => {
-        const db = getDb();
-        const id = Number(variables.id);
-        const project = db.prepare('SELECT * FROM projects WHERE id = ?').get(id);
-        if (!project) {
-            return { contents: [{ uri: uri.href, text: JSON.stringify({ error: 'Project not found' }), mimeType: 'application/json' }] };
-        }
-        // Include task count and recent tasks
-        const taskCount = db.prepare('SELECT COUNT(*) as count FROM tasks WHERE project_id = ?').get(id);
-        const recentTasks = db.prepare('SELECT id, title, status, priority FROM tasks WHERE project_id = ? ORDER BY updated_at DESC LIMIT 10').all(id);
-        return {
-            contents: [{
-                    uri: uri.href,
-                    text: JSON.stringify({ ...project, task_count: taskCount.count, recent_tasks: recentTasks }, null, 2),
-                    mimeType: 'application/json',
-                }],
-        };
-    });
-    // ─── Tasks Resource ─────────────────────────────────────────────────
-    server.resource('tasks', new ResourceTemplate('taskflow://tasks/{id}', {
-        list: async () => {
-            const db = getDb();
-            // List active tasks (not done) for discoverability
-            const tasks = db.prepare("SELECT * FROM tasks WHERE status != 'done' ORDER BY updated_at DESC LIMIT 50").all();
-            return {
-                resources: tasks.map(t => ({
-                    uri: `taskflow://tasks/${t.id}`,
-                    name: `[${t.status}] ${t.title}`,
-                    description: t.description?.slice(0, 100) ?? undefined,
-                    mimeType: 'application/json',
-                })),
-            };
-        },
-    }), { description: 'TaskFlow tasks', mimeType: 'application/json' }, async (uri, variables) => {
-        const db = getDb();
-        const id = Number(variables.id);
-        const task = db.prepare('SELECT * FROM tasks WHERE id = ?').get(id);
-        if (!task) {
-            return { contents: [{ uri: uri.href, text: JSON.stringify({ error: 'Task not found' }), mimeType: 'application/json' }] };
-        }
-        // Include time tracking and dependencies
-        const sessions = db.prepare('SELECT * FROM sessions WHERE task_id = ? ORDER BY start DESC LIMIT 5').all(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(id);
-        const deps = db.prepare('SELECT dependency_id FROM task_dependencies WHERE task_id = ?').all(id);
-        return {
-            contents: [{
-                    uri: uri.href,
-                    text: JSON.stringify({
-                        ...task,
-                        tags: task.tags ? JSON.parse(task.tags) : [],
-                        total_time_ms: totalTime.total ?? 0,
-                        recent_sessions: sessions,
-                        dependencies: deps.map(d => d.dependency_id),
-                    }, null, 2),
-                    mimeType: 'application/json',
-                }],
-        };
-    });
-}

package/dist/retry.d.ts

@@ -1,34 +0,0 @@
-/**
- * Retry policy engine for TaskFlow.
- * Provides exponential backoff with jitter for network/external calls.
- */
-export interface RetryPolicy {
-    maxRetries: number;
-    initialBackoffMs: number;
-    maxBackoffMs: number;
-}
-export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
-/** Thrown when an HTTP response has a retryable status code */
-export declare class RetryableHttpError extends Error {
-    readonly status: number;
-    constructor(status: number, message: string);
-}
-/** Thrown when all retry attempts are exhausted */
-export declare class RetriesExhaustedError extends Error {
-    readonly attempts: number;
-    readonly lastError: unknown;
-    constructor(attempts: number, lastError: unknown);
-}
-/**
- * Execute `fn` with automatic retry on transient errors.
- *
- * @param label  Short description for activity log entries (e.g. "relay push")
- * @param fn     Async function to execute. Should throw RetryableHttpError for bad HTTP responses.
- * @param policy Retry configuration (defaults to DEFAULT_RETRY_POLICY)
- */
-export declare function withRetry<T>(label: string, fn: () => Promise<T>, policy?: RetryPolicy): Promise<T>;
-/**
- * Wrapper around fetch() that throws RetryableHttpError for transient HTTP failures.
- * Drop-in for fetch() calls that should participate in retry logic.
- */
-export declare function fetchWithRetry(label: string, url: string, options?: RequestInit, policy?: RetryPolicy): Promise<Response>;

package/dist/retry.js

@@ -1,94 +0,0 @@
-/**
- * Retry policy engine for TaskFlow.
- * Provides exponential backoff with jitter for network/external calls.
- */
-import { logActivity } from './helpers.js';
-export const DEFAULT_RETRY_POLICY = {
-    maxRetries: 2,
-    initialBackoffMs: 200,
-    maxBackoffMs: 2000,
-};
-/** HTTP status codes considered transient and safe to retry */
-const RETRYABLE_STATUS_CODES = new Set([408, 429, 500, 502, 503, 504]);
-/** Classify whether an error is worth retrying */
-function isRetryable(err) {
-    if (err instanceof RetriesExhaustedError)
-        return false;
-    if (err instanceof TypeError)
-        return true; // network failure, DNS, ECONNREFUSED
-    if (err instanceof RetryableHttpError)
-        return true;
-    return false;
-}
-/** Thrown when an HTTP response has a retryable status code */
-export class RetryableHttpError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-        this.name = 'RetryableHttpError';
-    }
-}
-/** Thrown when all retry attempts are exhausted */
-export class RetriesExhaustedError extends Error {
-    attempts;
-    lastError;
-    constructor(attempts, lastError) {
-        const cause = lastError instanceof Error ? lastError.message : String(lastError);
-        super(`Retries exhausted after ${attempts} attempt(s): ${cause}`);
-        this.attempts = attempts;
-        this.lastError = lastError;
-        this.name = 'RetriesExhaustedError';
-    }
-}
-/**
- * Compute the next backoff delay with full jitter.
- * delay = min(initial * 2^attempt, max) * random(0.5, 1.0)
- */
-function backoffMs(policy, attempt) {
-    const base = Math.min(policy.initialBackoffMs * Math.pow(2, attempt), policy.maxBackoffMs);
-    return Math.floor(base * (0.5 + Math.random() * 0.5));
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
- * Execute `fn` with automatic retry on transient errors.
- *
- * @param label  Short description for activity log entries (e.g. "relay push")
- * @param fn     Async function to execute. Should throw RetryableHttpError for bad HTTP responses.
- * @param policy Retry configuration (defaults to DEFAULT_RETRY_POLICY)
- */
-export async function withRetry(label, fn, policy = DEFAULT_RETRY_POLICY) {
-    let lastError;
-    for (let attempt = 0; attempt <= policy.maxRetries; attempt++) {
-        try {
-            return await fn();
-        }
-        catch (err) {
-            lastError = err;
-            if (!isRetryable(err) || attempt === policy.maxRetries) {
-                break;
-            }
-            const delay = backoffMs(policy, attempt);
-            logActivity('debug_log', `[retry] ${label} — attempt ${attempt + 1} failed, retrying in ${delay}ms`, {
-                entityType: 'system',
-            });
-            await sleep(delay);
-        }
-    }
-    throw new RetriesExhaustedError(policy.maxRetries + 1, lastError);
-}
-/**
- * Wrapper around fetch() that throws RetryableHttpError for transient HTTP failures.
- * Drop-in for fetch() calls that should participate in retry logic.
- */
-export async function fetchWithRetry(label, url, options, policy) {
-    return withRetry(label, async () => {
-        const res = await fetch(url, options);
-        if (RETRYABLE_STATUS_CODES.has(res.status)) {
-            throw new RetryableHttpError(res.status, `${label}: HTTP ${res.status}`);
-        }
-        return res;
-    }, policy);
-}

package/dist/sse.d.ts

@@ -1,10 +0,0 @@
-export declare function startSSEServer(): Promise<void>;
-export declare function markSSEActive(): void;
-/**
- * Broadcast an SSE event. If this process owns the SSE server, send directly.
- * Otherwise, relay via HTTP to the process that does.
- * Also pushes to the remote relay server if configured.
- */
-export declare function broadcast(event: string, data: object): void;
-/** Returns the port the SSE server is actively using */
-export declare function getActivePort(): number;