@jigyasudham/veto 1.2.16 → 1.2.19

package/dist/server.js

@@ -1,12 +1,12 @@
 #!/usr/bin/env node
-// Veto MCP Server — 45 tools, 19 phases complete, auto-learning router
+// Veto MCP Server — 46 tools, 21 phases complete, auto-learning router
 // Suppress node:sqlite experimental warning — it would corrupt the MCP stdio protocol
 process.removeAllListeners('warning');
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { buildContextString } from './context/reader.js';
-import { saveSession, restoreSession, listSessions, closeSession, getDbPath, saveCouncilOutcome, storeKnowledge, searchKnowledge, deleteKnowledge, updateProjectMap, getProjectMap, upsertPattern, getPatterns, getContextStatus, fetchAndCacheDocs, saveTaskPlan, getUsageStatus, getAuditLog, getHealthStats, CONTEXT_WINDOWS, logUsage, getUsageLogs, } from './memory/local.js';
+import { saveSession, restoreSession, listSessions, closeSession, getDbPath, saveCouncilOutcome, storeKnowledge, searchKnowledge, deleteKnowledge, updateProjectMap, getProjectMap, upsertPattern, getPatterns, getContextStatus, fetchAndCacheDocs, saveTaskPlan, getUsageStatus, getAuditLog, getHealthStats, CONTEXT_WINDOWS, logUsage, getUsageLogs, getDb, storeScanDiagnostics, clearScanDiagnostics, updateSession, } from './memory/local.js';
 import { exportMemory, importMemory } from './memory/sync.js';
 import { runDebate } from './council/index.js';
 import { routeTask, getRateStatus, trackTokens, recordOutcome, getLearningStats, getLearnedThresholds, applyLearnedThresholds, getAgentPerformanceStats, getTaskTypeBreakdown, getCouncilInsights, getRecommendedAgent } from './router/index.js';
@@ -52,7 +52,7 @@ function maybeAutoSave(token_count, platform) {
         if (elapsed < autoSave.cooldown_ms)
             return { triggered: false };
     }
-    const result = saveSession({ ...autoSave.cached, token_count, platform });
+    const result = saveSession({ ...autoSave.cached, token_count, platform, save_type: 'auto' });
     autoSave.last_save_at = result.saved_at;
     autoSave.last_session_id = result.session_id;
     return { triggered: true, session_id: result.session_id, usage_pct };
@@ -90,6 +90,7 @@ const TOOL_ANNOTATIONS = {
     veto_discover: { readOnlyHint: true },
     veto_summarize: { readOnlyHint: true },
     veto_explain: { readOnlyHint: true },
+    veto_benchmark: { readOnlyHint: false, destructiveHint: false },
     // read-only + open world (external network)
     veto_docs_fetch: { readOnlyHint: true, openWorldHint: true },
     veto_pr_review: { readOnlyHint: true, openWorldHint: true },
@@ -150,7 +151,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: 'veto_session_save',
-            description: 'Saves the current session context to SQLite for later restoration across AI platforms.',
+            description: 'Saves the current session context to SQLite. Pass session_id to update an existing session instead of creating a new one — use this when refreshing context mid-conversation rather than starting a new snapshot.',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -184,6 +185,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         type: 'number',
                         description: 'Approximate tokens used this session. Veto uses this for context window monitoring.',
                     },
+                    session_id: {
+                        type: 'string',
+                        description: 'Optional. UUID of an existing session to update in-place. When provided, Veto updates that row instead of inserting a new one — prevents session inflation when refreshing mid-conversation.',
+                    },
                 },
                 required: ['summary', 'context'],
             },
@@ -322,12 +327,13 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: 'veto_code_review',
-            description: 'Runs the Code Reviewer agent on provided code. Returns scored findings (complexity, error handling, magic numbers, nesting, dead code) with severity and fixes.',
+            description: 'Runs the Code Reviewer agent on provided code. Returns scored findings (complexity, error handling, magic numbers, nesting, dead code) with severity and fixes. Pass file_path to surface findings as VS Code inline diagnostics (squiggles).',
             inputSchema: {
                 type: 'object',
                 properties: {
                     code: { type: 'string', description: 'The code to review.' },
                     context: { type: 'string', description: 'Optional: file name, module description, or review focus.' },
+                    file_path: { type: 'string', description: 'Optional: absolute path to the file being reviewed. When provided, findings are stored as VS Code inline diagnostics.' },
                 },
                 required: ['code'],
             },
@@ -347,23 +353,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
         },
         {
             name: 'veto_security_scan',
-            description: 'Runs the Security Scanner (OWASP Top 10) on provided code. Returns vulnerabilities with severity, CWE/OWASP category, and remediation steps.',
+            description: 'Runs the Security Scanner (OWASP Top 10) on provided code. Returns vulnerabilities with severity, CWE/OWASP category, and remediation steps. Pass file_path to surface findings as VS Code inline diagnostics.',
             inputSchema: {
                 type: 'object',
                 properties: {
                     code: { type: 'string', description: 'The code to scan.' },
                     context: { type: 'string', description: 'Optional: language, framework, or specific concerns.' },
+                    file_path: { type: 'string', description: 'Optional: absolute path to the file being scanned. When provided, findings are stored as VS Code inline diagnostics.' },
                 },
                 required: ['code'],
             },
         },
         {
             name: 'veto_secrets_scan',
-            description: 'Scans text or code for exposed credentials — API keys, tokens, passwords, connection strings, private keys. Returns findings with masked values and line numbers.',
+            description: 'Scans text or code for exposed credentials — API keys, tokens, passwords, connection strings, private keys. Returns findings with masked values and line numbers. Pass file_path to surface findings as VS Code inline diagnostics.',
             inputSchema: {
                 type: 'object',
                 properties: {
                     text: { type: 'string', description: 'The text or code to scan for secrets.' },
+                    file_path: { type: 'string', description: 'Optional: absolute path to the file being scanned. When provided, findings are stored as VS Code inline diagnostics.' },
                 },
                 required: ['text'],
             },
@@ -825,6 +833,21 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                 required: [],
             },
         },
+        {
+            name: 'veto_benchmark',
+            description: 'Compares two competing approaches by running a full council debate on each in parallel, then returns a structured winner analysis with verdict, confidence delta, warning counts, and council reasoning. Use when you have two valid options and want an unbiased council judgment before committing.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: { type: 'string', description: 'The decision context — what problem are both approaches solving?' },
+                    approach_a: { type: 'string', description: 'First approach to evaluate. Be specific about tech choices, trade-offs, and constraints.' },
+                    approach_b: { type: 'string', description: 'Second approach to evaluate. Same level of detail as approach_a.' },
+                    context: { type: 'string', description: 'Optional: shared context for both debates (architecture notes, constraints, team size, etc.).' },
+                    project_dir: { type: 'string', description: 'Optional: auto-inject package.json and git diff context.' },
+                },
+                required: ['task', 'approach_a', 'approach_b'],
+            },
+        },
     ];
     return { tools: tools.map(t => ({ ...t, annotations: TOOL_ANNOTATIONS[t.name] ?? {} })) };
 });
@@ -847,11 +870,31 @@ async function runTripleScan(diff, context) {
     autoRecord('scan', 'secrets', (secretsResult.analysis?.findings?.length ?? 0) === 0 ? 100 : secretsResult.analysis?.score ?? Math.round(secretsResult.output.confidence * 100));
     return { reviewResult, secResult, secretsResult, verdict };
 }
+function parseLineFromLocation(location) {
+    if (!location)
+        return 1;
+    const m = location.match(/(?:^|line\s+)(\d+)/i);
+    return m ? parseInt(m[1], 10) : 1;
+}
+function mapSeverityToVscode(severity) {
+    if (severity === 'critical' || severity === 'high')
+        return 'error';
+    if (severity === 'medium')
+        return 'warning';
+    return 'information';
+}
 // Auto-learning helper — records a learning_data row from any agent result.
 // Keeps call sites to one line rather than repeating the tier/quality logic.
+// After every 20 outcomes the thresholds are applied automatically.
 function autoRecord(taskType, agent, quality, complexity = 50) {
     const tier = quality >= 80 ? 1 : quality >= 40 ? 2 : 3;
     recordOutcome(taskType.slice(0, 50), complexity, tier, agent, quality);
+    try {
+        const count = getDb().prepare('SELECT COUNT(*) as c FROM learning_data').get().c;
+        if (count >= 20 && count % 20 === 0)
+            applyLearnedThresholds();
+    }
+    catch { /* never interrupt the caller */ }
 }
 // Auto-store helper — writes a knowledge_base entry when a scan produces critical/blocking issues.
 // This is what populates the Memory panel in the VS Code extension automatically.
@@ -938,7 +981,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const saveSummary = String(args?.summary ?? '');
             const saveContext = String(args?.context ?? '');
             const saveTaskState = args?.task_state ? String(args.task_state) : undefined;
-            const result = saveSession({
+            const existingId = args?.session_id ? String(args.session_id) : undefined;
+            const sessionInput = {
                 summary: saveSummary,
                 context: saveContext,
                 task_state: saveTaskState,
@@ -946,20 +990,37 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 connection_type: args?.connection_type ? String(args.connection_type) : 'subscription',
                 project_dir: sessionProjectDir,
                 token_count: typeof args?.token_count === 'number' ? args.token_count : 0,
-            });
+            };
+            let result;
+            let wasUpdate = false;
+            if (existingId) {
+                const updated = updateSession(existingId, sessionInput);
+                if (updated) {
+                    result = { session_id: updated.session_id, saved_at: updated.saved_at, usage_pct: 0, context_warning: false, continuation_prompt: null };
+                    wasUpdate = true;
+                }
+                else {
+                    result = saveSession(sessionInput);
+                }
+            }
+            else {
+                result = saveSession(sessionInput);
+            }
             // Cache for auto-save: future veto_status calls with high token_count will re-save this context
             autoSave.cached = { summary: saveSummary, context: saveContext, task_state: saveTaskState, platform: savePlatform, project_dir: sessionProjectDir };
             autoSave.last_save_at = result.saved_at;
             autoSave.last_session_id = result.session_id;
             const responseObj = {
                 success: true,
-                message: result.context_warning
-                    ? `⚠️ Context at ${result.usage_pct}% — consider handing off soon.`
-                    : 'Session saved. Use this ID to restore on any AI platform.',
+                message: wasUpdate
+                    ? `Session updated in-place. ID unchanged: ${result.session_id}`
+                    : result.context_warning
+                        ? `⚠️ Context at ${result.usage_pct}% — consider handing off soon.`
+                        : 'Session saved. Use this ID to restore on any AI platform.',
                 session_id: result.session_id,
                 saved_at: result.saved_at,
-                usage_pct: result.usage_pct,
-                context_warning: result.context_warning,
+                updated: wasUpdate,
+                ...(wasUpdate ? {} : { usage_pct: result.usage_pct, context_warning: result.context_warning }),
             };
             if (result.continuation_prompt)
                 responseObj.continuation_prompt = result.continuation_prompt;
@@ -1170,11 +1231,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (!code) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'code is required.' }) }], isError: true };
             }
+            const reviewFilePath = args?.file_path ? String(args.file_path) : undefined;
             const result = await executeOne({ id: 'review-1', agent: 'reviewer', task: 'review this code', code, context: args?.context ? String(args.context) : undefined });
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
             autoRecord('code review', 'reviewer', result.analysis?.score ?? Math.round(result.output.confidence * 100));
+            if (reviewFilePath && result.analysis?.findings) {
+                storeScanDiagnostics(reviewFilePath, result.analysis.findings.map((f) => ({
+                    line: parseLineFromLocation(f.location),
+                    message: f.description ?? '',
+                    severity: mapSeverityToVscode(f.severity),
+                })), 'code-review');
+            }
+            else if (reviewFilePath) {
+                clearScanDiagnostics(reviewFilePath);
+            }
             return { content: [{ type: 'text', text: JSON.stringify(result.analysis, null, 2) }] };
         }
         case 'veto_diff_review': {
@@ -1265,11 +1337,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (!code) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'code is required.' }) }], isError: true };
             }
+            const secFilePath = args?.file_path ? String(args.file_path) : undefined;
             const result = await executeOne({ id: 'scan-1', agent: 'security-scanner', task: 'scan this code for security issues', code, context: args?.context ? String(args.context) : undefined });
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
             autoRecord('security scan', 'security-scanner', result.analysis?.score ?? Math.round(result.output.confidence * 100));
+            if (secFilePath && result.analysis?.findings) {
+                storeScanDiagnostics(secFilePath, result.analysis.findings.map((f) => ({
+                    line: parseLineFromLocation(f.location),
+                    message: f.description ?? '',
+                    severity: mapSeverityToVscode(f.severity),
+                })), 'security');
+            }
+            else if (secFilePath) {
+                clearScanDiagnostics(secFilePath);
+            }
             return { content: [{ type: 'text', text: JSON.stringify(result.analysis, null, 2) }] };
         }
         case 'veto_secrets_scan': {
@@ -1277,11 +1360,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             if (!text) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, message: 'text is required.' }) }], isError: true };
             }
+            const secretsFilePath = args?.file_path ? String(args.file_path) : undefined;
             const result = await executeOne({ id: 'secrets-1', agent: 'secrets', task: 'scan for exposed credentials', code: text });
             if (result.error) {
                 return { content: [{ type: 'text', text: JSON.stringify({ success: false, error: result.error }) }], isError: true };
             }
             autoRecord('secrets scan', 'secrets', (result.analysis?.findings?.length ?? 0) === 0 ? 100 : result.analysis?.score ?? Math.round(result.output.confidence * 100));
+            if (secretsFilePath && result.analysis?.findings) {
+                storeScanDiagnostics(secretsFilePath, result.analysis.findings.map((f) => ({
+                    line: parseLineFromLocation(f.location),
+                    message: f.description ?? '',
+                    severity: mapSeverityToVscode(f.severity),
+                })), 'secrets');
+            }
+            else if (secretsFilePath) {
+                clearScanDiagnostics(secretsFilePath);
+            }
             return { content: [{ type: 'text', text: JSON.stringify(result.analysis, null, 2) }] };
         }
         case 'veto_execute_parallel': {
@@ -2092,6 +2186,86 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             agent_used: 'project-mapper', duration_ms: Date.now() - sumStart,
                         }, null, 2) }] };
         }
+        case 'veto_benchmark': {
+            const task = String(args?.task ?? '');
+            const approachA = String(args?.approach_a ?? '');
+            const approachB = String(args?.approach_b ?? '');
+            const ctx = args?.context ? String(args.context) : undefined;
+            const projectDir = args?.project_dir ? String(args.project_dir) : undefined;
+            if (!task || !approachA || !approachB) {
+                throw new Error('veto_benchmark requires task, approach_a, and approach_b');
+            }
+            const bmStart = Date.now();
+            // Run both debates synchronously (council agents are all sync)
+            const debateA = runDebate({ task: `${task}\n\nApproach A: ${approachA}`, context: ctx, project_dir: projectDir });
+            const debateB = runDebate({ task: `${task}\n\nApproach B: ${approachB}`, context: ctx, project_dir: projectDir });
+            // Score: GREEN=3, YELLOW=2, RED=1, DEADLOCK=0
+            const verdictScore = { GREEN: 3, YELLOW: 2, RED: 1, DEADLOCK: 0 };
+            const scoreA = verdictScore[debateA.final_verdict] ?? 0;
+            const scoreB = verdictScore[debateB.final_verdict] ?? 0;
+            const warnCountA = debateA.warnings.length;
+            const warnCountB = debateB.warnings.length;
+            const blockCountA = debateA.block_reasons.length;
+            const blockCountB = debateB.block_reasons.length;
+            let winner;
+            let confidence;
+            let reasoning;
+            if (scoreA !== scoreB) {
+                winner = scoreA > scoreB ? 'A' : 'B';
+                const diff = Math.abs(scoreA - scoreB);
+                confidence = diff >= 2 ? 'high' : 'medium';
+                reasoning = `Approach ${winner} received a ${winner === 'A' ? debateA.final_verdict : debateB.final_verdict} verdict vs ${winner === 'A' ? debateB.final_verdict : debateA.final_verdict} for Approach ${winner === 'A' ? 'B' : 'A'}.`;
+            }
+            else {
+                // Same verdict — break tie on warnings, then block reasons
+                if (warnCountA !== warnCountB) {
+                    winner = warnCountA < warnCountB ? 'A' : 'B';
+                    confidence = 'low';
+                    reasoning = `Both approaches received ${debateA.final_verdict}. Approach ${winner} had fewer warnings (${winner === 'A' ? warnCountA : warnCountB} vs ${winner === 'A' ? warnCountB : warnCountA}).`;
+                }
+                else if (blockCountA !== blockCountB) {
+                    winner = blockCountA < blockCountB ? 'A' : 'B';
+                    confidence = 'low';
+                    reasoning = `Both approaches received ${debateA.final_verdict} with equal warnings. Approach ${winner} had fewer blocking concerns.`;
+                }
+                else {
+                    winner = 'TIE';
+                    confidence = 'low';
+                    reasoning = `Both approaches received ${debateA.final_verdict} with equal warnings and blocks. Council cannot differentiate — consider a more specific framing.`;
+                }
+            }
+            // Auto-record both debates
+            const qMap = { GREEN: 90, YELLOW: 60, RED: 20, DEADLOCK: 50 };
+            autoRecord('benchmark', 'council', qMap[debateA.final_verdict] ?? 50);
+            autoRecord('benchmark', 'council', qMap[debateB.final_verdict] ?? 50);
+            return { content: [{ type: 'text', text: JSON.stringify({
+                            winner,
+                            confidence,
+                            reasoning,
+                            recommendation: winner !== 'TIE'
+                                ? `Use Approach ${winner}. ${winner === 'A' ? debateA.recommended : debateB.recommended}`
+                                : `No clear winner. ${debateA.recommended}`,
+                            approach_a: {
+                                label: 'A',
+                                description: approachA.slice(0, 120),
+                                verdict: debateA.final_verdict,
+                                warnings: warnCountA,
+                                block_reasons: blockCountA,
+                                recommended: debateA.recommended,
+                                votes: Object.fromEntries(Object.entries(debateA.votes).map(([k, v]) => [k, v.verdict])),
+                            },
+                            approach_b: {
+                                label: 'B',
+                                description: approachB.slice(0, 120),
+                                verdict: debateB.final_verdict,
+                                warnings: warnCountB,
+                                block_reasons: blockCountB,
+                                recommended: debateB.recommended,
+                                votes: Object.fromEntries(Object.entries(debateB.votes).map(([k, v]) => [k, v.verdict])),
+                            },
+                            duration_ms: Date.now() - bmStart,
+                        }, null, 2) }] };
+        }
         default:
             throw new Error(`Unknown tool: ${name}`);
     }