@brainfile/cli 0.15.1 → 0.16.0

package/dist/commands/mcp.js

@@ -39,6 +39,7 @@ const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
 const core_1 = require("@brainfile/core");
 const errorHandler_1 = require("../utils/errorHandler");
 const contractSpec_1 = require("../utils/contractSpec");
@@ -50,6 +51,7 @@ const core_2 = require("@brainfile/core");
 const contractRunner_1 = require("../lib/contractRunner");
 const archive_1 = require("../utils/archive");
 const core_3 = require("@brainfile/core");
+const dist_1 = require("../../../core/dist");
 const v2_detect_1 = require("../utils/v2-detect");
 function sanitizeTypesConfig(raw) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
@@ -129,6 +131,80 @@ function findGitRoot(startDir) {
     }
     return null;
 }
+const LEDGER_CONTRACT_STATUSES = [
+    'ready',
+    'in_progress',
+    'delivered',
+    'done',
+    'failed',
+    'blocked',
+];
+function resolveLedgerLogsDir(filePath) {
+    if ((0, v2_detect_1.isV2)(filePath)) {
+        return (0, v2_detect_1.getV2Dirs)(filePath).logsDir;
+    }
+    const absolutePath = path.resolve(filePath);
+    const parentDir = path.dirname(absolutePath);
+    const stateDir = path.basename(parentDir) === '.brainfile'
+        ? parentDir
+        : path.join(parentDir, '.brainfile');
+    return path.join(stateDir, 'logs');
+}
+function normalizePositiveInt(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function normalizeNonNegativeInt(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function toIsoDaysAgo(days) {
+    const now = Date.now();
+    const msPerDay = 24 * 60 * 60 * 1000;
+    return new Date(now - (days * msPerDay)).toISOString();
+}
+function inferFilesChangedFromGit(filePath) {
+    const repoRoot = findGitRoot(path.dirname(path.resolve(filePath)));
+    if (!repoRoot) {
+        return [];
+    }
+    const inferred = new Set();
+    const commands = ['git diff --name-only -- .', 'git diff --name-only --cached -- .'];
+    for (const command of commands) {
+        try {
+            const stdout = (0, child_process_1.execSync)(command, {
+                cwd: repoRoot,
+                encoding: 'utf-8',
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            for (const line of stdout.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed) {
+                    inferred.add(trimmed.replace(/\\/g, '/'));
+                }
+            }
+        }
+        catch {
+            // Ignore git inference errors and fall back to core defaults.
+        }
+    }
+    return Array.from(inferred);
+}
+function median(values) {
+    if (values.length === 0) {
+        return 0;
+    }
+    const sorted = [...values].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    const rawMedian = sorted.length % 2 === 0
+        ? (sorted[mid - 1] + sorted[mid]) / 2
+        : sorted[mid];
+    return Number(rawMedian.toFixed(3));
+}
 async function mcpCommand(options) {
     // Auto-discover brainfile if not specified
     let defaultFile = options.file;
@@ -681,7 +757,7 @@ async function mcpCommand(options) {
             (0, core_3.writeTaskFile)(taskPath, doc.task, doc.body);
             const shouldAutoComplete = resolvedTargetColumn.completionColumn === true && isTaskCompletable(doc.task.type, board.types);
             if (shouldAutoComplete) {
-                const completeResult = (0, core_3.completeTaskFile)(taskPath, dirs.logsDir);
+                const completeResult = (0, dist_1.completeTaskFile)(taskPath, dirs.logsDir);
                 if (!completeResult.success) {
                     return { content: [{ type: 'text', text: `Error: ${completeResult.error || `Failed to complete task: ${task}`}` }], isError: true };
                 }
@@ -1815,7 +1891,12 @@ async function mcpCommand(options) {
         if ('error' in result) {
             return { content: [{ type: 'text', text: `Error: ${result.error}` }], isError: true };
         }
-        return { content: [{ type: 'text', text: `Contract delivered: ${task}` }] };
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Contract delivered: ${task}\nReminder: prepare summary and filesChanged for the upcoming complete_task call.`
+                }]
+        };
     });
     server.registerTool('contract_validate', {
         title: 'Contract Validate',
@@ -1999,6 +2080,251 @@ async function mcpCommand(options) {
         };
     });
     // ==========================================================================
+    // LEDGER
+    // ==========================================================================
+    server.registerTool('get_task_context', {
+        title: 'Get Task Context',
+        description: 'Get scoped recent ledger history for a task based on relatedFiles and contract deliverables',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            taskId: zod_1.z.string().optional().describe('Task ID to scope context for'),
+            maxEntries: zod_1.z.number().optional().describe('Maximum matching entries to return (default: 5)'),
+            maxAgeDays: zod_1.z.number().optional().describe('Maximum age window in days (default: 90)'),
+            task_id: zod_1.z.string().optional().describe('Alias of taskId'),
+            max_entries: zod_1.z.number().optional().describe('Alias of maxEntries'),
+            max_age_days: zod_1.z.number().optional().describe('Alias of maxAgeDays'),
+        }
+    }, async ({ file, taskId, maxEntries, maxAgeDays, task_id, max_entries, max_age_days }) => {
+        const filePath = file || defaultFile;
+        const resolvedTaskId = taskId || task_id;
+        if (!resolvedTaskId) {
+            return { content: [{ type: 'text', text: 'Error: taskId is required' }], isError: true };
+        }
+        let relatedFiles = [];
+        let deliverables;
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const found = (0, v2_detect_1.findV2Task)(dirs, resolvedTaskId, true);
+            if (!found) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${resolvedTaskId}` }], isError: true };
+            }
+            relatedFiles = found.doc.task.relatedFiles || [];
+            deliverables = found.doc.task.contract?.deliverables;
+        }
+        else {
+            const boardResult = readBoard(filePath);
+            if ('error' in boardResult) {
+                return { content: [{ type: 'text', text: `Error: ${boardResult.error}` }], isError: true };
+            }
+            const taskInfo = (0, core_1.findTaskById)(boardResult.board, resolvedTaskId);
+            if (!taskInfo) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${resolvedTaskId}` }], isError: true };
+            }
+            relatedFiles = taskInfo.task.relatedFiles || [];
+            deliverables = taskInfo.task.contract?.deliverables;
+        }
+        const limit = normalizePositiveInt(maxEntries ?? max_entries, 5);
+        const ageDays = normalizeNonNegativeInt(maxAgeDays ?? max_age_days, 90);
+        const since = toIsoDaysAgo(ageDays);
+        const logsDir = resolveLedgerLogsDir(filePath);
+        const entries = (0, dist_1.getTaskContext)(logsDir, relatedFiles, deliverables, {
+            limit,
+            dateRange: { from: since },
+        });
+        const scopeFiles = new Set();
+        for (const value of relatedFiles) {
+            const trimmed = value.trim();
+            if (trimmed) {
+                scopeFiles.add(trimmed);
+            }
+        }
+        for (const deliverable of deliverables || []) {
+            const rawPath = typeof deliverable === 'string' ? deliverable : deliverable.path;
+            const trimmed = rawPath.trim();
+            if (trimmed) {
+                scopeFiles.add(trimmed);
+            }
+        }
+        const output = {
+            taskId: resolvedTaskId,
+            count: entries.length,
+            maxEntries: limit,
+            maxAgeDays: ageDays,
+            since,
+            scopeFiles: Array.from(scopeFiles),
+            entries,
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+    });
+    server.registerTool('query_ledger', {
+        title: 'Query Ledger',
+        description: 'Query ledger records by assignee, tags, date range, files, and contract status',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            assignee: zod_1.z.string().optional().describe('Filter by assignee'),
+            tags: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by tags (OR match)'),
+            since: zod_1.z.string().optional().describe('Filter completions since this ISO date/time'),
+            until: zod_1.z.string().optional().describe('Filter completions until this ISO date/time'),
+            files: zod_1.z.array(zod_1.z.string()).optional().describe('Filter by file paths touched'),
+            contractStatus: zod_1.z.union([
+                zod_1.z.enum(LEDGER_CONTRACT_STATUSES),
+                zod_1.z.array(zod_1.z.enum(LEDGER_CONTRACT_STATUSES)),
+            ]).optional().describe('Filter by contract status'),
+            contract_status: zod_1.z.union([
+                zod_1.z.enum(LEDGER_CONTRACT_STATUSES),
+                zod_1.z.array(zod_1.z.enum(LEDGER_CONTRACT_STATUSES)),
+            ]).optional().describe('Alias of contractStatus'),
+        }
+    }, async ({ file, assignee, tags, since, until, files, contractStatus, contract_status }) => {
+        const filePath = file || defaultFile;
+        const logsDir = resolveLedgerLogsDir(filePath);
+        const contractFilter = contractStatus ?? contract_status;
+        const dateRange = (since || until) ? { from: since, to: until } : undefined;
+        const records = (0, dist_1.queryLedger)(logsDir, {
+            assignee,
+            tags,
+            dateRange,
+            files,
+            contractStatus: contractFilter,
+        });
+        const output = {
+            count: records.length,
+            filters: {
+                assignee,
+                tags,
+                since,
+                until,
+                files,
+                contractStatus: contractFilter,
+            },
+            records,
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+    });
+    server.registerTool('get_stats', {
+        title: 'Get Stats',
+        description: 'Get aggregate completion analytics from the ledger with optional filters',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            assignee: zod_1.z.string().optional().describe('Filter analytics by assignee'),
+            since: zod_1.z.string().optional().describe('Only include completions since this ISO date/time'),
+            tag: zod_1.z.string().optional().describe('Filter analytics by a single tag'),
+        }
+    }, async ({ file, assignee, since, tag }) => {
+        const filePath = file || defaultFile;
+        const logsDir = resolveLedgerLogsDir(filePath);
+        const records = (0, dist_1.queryLedger)(logsDir, {
+            assignee,
+            tags: tag ? [tag] : undefined,
+            dateRange: since ? { from: since } : undefined,
+        });
+        const cycleTimes = records
+            .map((record) => record.cycleTimeHours)
+            .filter((hours) => typeof hours === 'number' && Number.isFinite(hours) && hours >= 0);
+        const cycleTimeTotal = Number(cycleTimes.reduce((sum, value) => sum + value, 0).toFixed(3));
+        const cycleTimeAverage = cycleTimes.length > 0
+            ? Number((cycleTimeTotal / cycleTimes.length).toFixed(3))
+            : 0;
+        const cycleTimeMin = cycleTimes.length > 0 ? Number(Math.min(...cycleTimes).toFixed(3)) : 0;
+        const cycleTimeMax = cycleTimes.length > 0 ? Number(Math.max(...cycleTimes).toFixed(3)) : 0;
+        const byType = {};
+        const byContractStatus = {};
+        const byAssignee = {};
+        const byTag = {};
+        const fileCounts = new Map();
+        let firstCompletionAt = null;
+        let lastCompletionAt = null;
+        let firstCompletionMs = null;
+        let lastCompletionMs = null;
+        for (const record of records) {
+            byType[record.type] = (byType[record.type] || 0) + 1;
+            if (record.contractStatus) {
+                byContractStatus[record.contractStatus] = (byContractStatus[record.contractStatus] || 0) + 1;
+            }
+            if (record.assignee) {
+                byAssignee[record.assignee] = (byAssignee[record.assignee] || 0) + 1;
+            }
+            for (const recordTag of record.tags || []) {
+                byTag[recordTag] = (byTag[recordTag] || 0) + 1;
+            }
+            for (const changedFile of record.filesChanged || []) {
+                fileCounts.set(changedFile, (fileCounts.get(changedFile) || 0) + 1);
+            }
+            const completedMs = Date.parse(record.completedAt);
+            if (Number.isFinite(completedMs)) {
+                if (firstCompletionMs === null || completedMs < firstCompletionMs) {
+                    firstCompletionMs = completedMs;
+                    firstCompletionAt = record.completedAt;
+                }
+                if (lastCompletionMs === null || completedMs > lastCompletionMs) {
+                    lastCompletionMs = completedMs;
+                    lastCompletionAt = record.completedAt;
+                }
+            }
+        }
+        const topFiles = Array.from(fileCounts.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([filePath, count]) => ({ filePath, count }));
+        const output = {
+            filters: { assignee, since, tag },
+            totals: {
+                completed: records.length,
+                uniqueFilesTouched: fileCounts.size,
+            },
+            cycleTimeHours: {
+                total: cycleTimeTotal,
+                average: cycleTimeAverage,
+                median: median(cycleTimes),
+                min: cycleTimeMin,
+                max: cycleTimeMax,
+            },
+            breakdown: {
+                byType,
+                byContractStatus,
+                byAssignee,
+                byTag,
+            },
+            topFiles,
+            window: {
+                firstCompletionAt,
+                lastCompletionAt,
+            },
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+    });
+    server.registerTool('get_file_history', {
+        title: 'Get File History',
+        description: 'Get recent completed records that touched a specific file path',
+        inputSchema: {
+            file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
+            filePath: zod_1.z.string().optional().describe('File path to query'),
+            last: zod_1.z.number().optional().describe('Maximum records to return (default: 10)'),
+            since: zod_1.z.string().optional().describe('Only include completions since this ISO date/time'),
+            file_path: zod_1.z.string().optional().describe('Alias of filePath'),
+        }
+    }, async ({ file, filePath: targetFilePath, last, since, file_path }) => {
+        const filePath = file || defaultFile;
+        const resolvedFilePath = targetFilePath || file_path;
+        if (!resolvedFilePath) {
+            return { content: [{ type: 'text', text: 'Error: filePath is required' }], isError: true };
+        }
+        const logsDir = resolveLedgerLogsDir(filePath);
+        const limit = normalizePositiveInt(last, 10);
+        const records = (0, dist_1.getFileHistory)(logsDir, resolvedFilePath, {
+            limit,
+            dateRange: since ? { from: since } : undefined,
+        });
+        const output = {
+            filePath: resolvedFilePath,
+            count: records.length,
+            last: limit,
+            since,
+            records,
+        };
+        return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+    });
+    // ==========================================================================
     // V2 NEW TOOLS: complete_task, search_logs, append_log
     // ==========================================================================
     // Complete task tool
@@ -2008,14 +2334,55 @@ async function mcpCommand(options) {
         inputSchema: {
             file: zod_1.z.string().optional().describe('Path to brainfile.md (default: brainfile.md)'),
             task: zod_1.z.string().describe('Task ID to complete'),
+            summary: zod_1.z.string().optional().describe('Completion summary (default: Completed: {title})'),
+            filesChanged: zod_1.z.array(zod_1.z.string()).optional().describe('Files changed during implementation (optional; inferred from git diff if omitted)'),
+            files_changed: zod_1.z.array(zod_1.z.string()).optional().describe('Alias of filesChanged'),
         }
-    }, async ({ file, task }) => {
+    }, async ({ file, task, summary, filesChanged, files_changed }) => {
         const filePath = file || defaultFile;
+        if ((0, v2_detect_1.isV2)(filePath)) {
+            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
+            const taskPath = path.join(dirs.boardDir, (0, core_3.taskFileName)(task));
+            const doc = (0, core_3.readTaskFile)(taskPath);
+            if (!doc) {
+                return { content: [{ type: 'text', text: `Error: Task not found: ${task}` }], isError: true };
+            }
+            const resolvedSummary = summary?.trim() || `Completed: ${doc.task.title}`;
+            const rawFiles = filesChanged ?? files_changed ?? [];
+            const providedFiles = rawFiles
+                .map((entry) => entry.trim())
+                .filter((entry) => entry.length > 0);
+            const inferredFiles = providedFiles.length > 0 ? providedFiles : inferFilesChangedFromGit(filePath);
+            const filesSource = providedFiles.length > 0
+                ? 'input'
+                : inferredFiles.length > 0
+                    ? 'git_diff'
+                    : 'core_default';
+            const completeResult = (0, dist_1.completeTaskFile)(taskPath, dirs.logsDir, {
+                summary: resolvedSummary,
+                filesChanged: inferredFiles.length > 0 ? inferredFiles : undefined,
+            });
+            if (!completeResult.success || !completeResult.task) {
+                return { content: [{ type: 'text', text: `Error: ${completeResult.error || `Failed to complete task: ${task}`}` }], isError: true };
+            }
+            const output = {
+                task,
+                completedAt: completeResult.task.completedAt,
+                summary: resolvedSummary,
+                filesChanged: inferredFiles,
+                filesSource,
+            };
+            return { content: [{ type: 'text', text: JSON.stringify(output, null, 2) }] };
+        }
         try {
             const { completeCommand } = await Promise.resolve().then(() => __importStar(require('./complete')));
             const result = completeCommand({ file: filePath, task }, { log: () => { }, warn: () => { }, error: () => { }, info: () => { } });
+            const hasLedgerOnlyParams = Boolean(summary) || ((filesChanged ?? files_changed)?.length || 0) > 0;
             return {
-                content: [{ type: 'text', text: `Task ${task} completed at ${result.completedAt}` }]
+                content: [{
+                        type: 'text',
+                        text: `Task ${task} completed at ${result.completedAt}${hasLedgerOnlyParams ? `\nNote: summary/filesChanged are only applied in v2 ledger mode.` : ''}`
+                    }]
             };
         }
         catch (e) {