@jigyasudham/veto 0.8.2 → 1.0.0

package/dist/watcher/index.js

@@ -0,0 +1,77 @@
+import { watch } from 'node:fs';
+import { extname, basename, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+const sessions = new Map();
+const EXT_RULES = [
+    [(f) => basename(f) === 'package.json', 'dependency-audit', 'veto_agent_plan', 'package.json changed — check for new CVEs or unwanted deps'],
+    [(f) => /\.(env|env\..+)$/.test(basename(f)), 'secrets', 'veto_secrets_scan', '.env file changed — scan for exposed credentials'],
+    [(f, e) => ['.sql', '.prisma'].includes(e), 'database', 'veto_agent_plan', 'Database schema file changed'],
+    [(f, e) => /\.(test|spec)\.(ts|js|tsx|jsx)$/.test(f), 'tester', 'veto_agent_plan', 'Test file changed — review test coverage'],
+    [(f, e) => ['.ts', '.tsx', '.js', '.jsx'].includes(e), 'code-quality', 'veto_code_review', 'Source file saved — code quality check recommended'],
+    [(f, e) => ['.yaml', '.yml', '.toml'].includes(e), 'devops', 'veto_agent_plan', 'Config file changed'],
+    [(f, e) => e === '.json' && basename(f) !== 'package.json', 'coder', 'veto_agent_plan', 'JSON config changed'],
+];
+function classify(file) {
+    const ext = extname(file).toLowerCase();
+    for (const [match, agent, tool, reason] of EXT_RULES) {
+        if (match(file, ext))
+            return { agent, tool, reason };
+    }
+    return { agent: 'coder', tool: 'veto_agent_plan', reason: 'File changed' };
+}
+export function startWatch(projectDir) {
+    const dir = resolve(projectDir);
+    const id = randomUUID().slice(0, 8);
+    const watcher = watch(dir, { recursive: true }, (eventType, filename) => {
+        if (!filename)
+            return;
+        // ignore node_modules, .git, dist
+        if (/node_modules|\.git|dist|\.veto/.test(filename))
+            return;
+        const session = sessions.get(id);
+        if (!session)
+            return;
+        const { agent, tool, reason } = classify(filename);
+        session.events.push({
+            event_type: eventType === 'rename' ? 'rename' : 'change',
+            file: filename,
+            ext: extname(filename).toLowerCase(),
+            triggered_at: new Date().toISOString(),
+            recommended_agent: agent,
+            suggested_tool: tool,
+            reason,
+        });
+    });
+    sessions.set(id, {
+        watcher,
+        project_dir: dir,
+        events: [],
+        started_at: new Date().toISOString(),
+    });
+    return id;
+}
+export function pollWatch(watchId) {
+    const session = sessions.get(watchId);
+    if (!session)
+        return { found: false, events: [] };
+    const events = [...session.events];
+    session.events = [];
+    return { found: true, events, project_dir: session.project_dir };
+}
+export function stopWatch(watchId) {
+    const session = sessions.get(watchId);
+    if (!session)
+        return false;
+    session.watcher.close();
+    sessions.delete(watchId);
+    return true;
+}
+export function listWatches() {
+    return Array.from(sessions.entries()).map(([id, s]) => ({
+        id,
+        project_dir: s.project_dir,
+        started_at: s.started_at,
+        pending_events: s.events.length,
+    }));
+}
+//# sourceMappingURL=index.js.map

package/dist/workflow/pipeline.js

@@ -0,0 +1,64 @@
+import { executeOne } from '../agents/executor.js';
+export async function runPipeline(steps, globalProjectDir) {
+    const results = [];
+    const start = Date.now();
+    let stoppedAt;
+    let stopReason;
+    for (const step of steps) {
+        const result = await executeOne({
+            id: step.id,
+            agent: step.agent,
+            task: step.task,
+            code: step.code,
+            context: step.context,
+            project_dir: step.project_dir ?? globalProjectDir,
+        });
+        const confidence = result.output.confidence;
+        const confidencePct = Math.round(confidence * 100);
+        if (result.error) {
+            results.push({
+                id: step.id, agent: step.agent, status: 'error',
+                confidence: 0, severity: 'critical',
+                recommendation: result.error,
+                gate: step.gate, duration_ms: result.duration_ms, error: result.error,
+            });
+            stoppedAt = step.id;
+            stopReason = `Step "${step.id}" errored: ${result.error}`;
+            break;
+        }
+        const gateFailed = step.gate !== undefined && confidencePct < step.gate;
+        results.push({
+            id: step.id, agent: step.agent,
+            status: gateFailed ? 'failed_gate' : 'passed',
+            confidence: confidencePct,
+            severity: result.output.severity,
+            recommendation: result.output.recommendation,
+            gate: step.gate,
+            duration_ms: result.duration_ms,
+        });
+        if (gateFailed) {
+            stoppedAt = step.id;
+            stopReason = `Step "${step.id}" confidence ${confidencePct}% below gate ${step.gate}%`;
+            // mark remaining steps as skipped
+            const remaining = steps.slice(steps.indexOf(step) + 1);
+            for (const s of remaining) {
+                results.push({ id: s.id, agent: s.agent, status: 'skipped', confidence: 0, severity: 'info', recommendation: 'Skipped — upstream gate failed', gate: s.gate, duration_ms: 0 });
+            }
+            break;
+        }
+    }
+    const passed = results.filter(r => r.status === 'passed').length;
+    const failed = results.filter(r => r.status === 'failed_gate' || r.status === 'error').length;
+    const verdict = failed === 0 ? 'passed' : passed > 0 ? 'partial' : 'failed';
+    return {
+        verdict,
+        steps_total: steps.length,
+        steps_passed: passed,
+        steps_failed: failed,
+        stopped_at: stoppedAt,
+        stop_reason: stopReason,
+        results,
+        total_duration_ms: Date.now() - start,
+    };
+}
+//# sourceMappingURL=pipeline.js.map

package/package.json

@@ -1,14 +1,23 @@
 {
   "name": "@jigyasudham/veto",
-  "version": "0.8.2",
-  "description": "50 agents. 28 skills. 3 AIs. Self-learning. Zero extra cost.",
+  "version": "1.0.0",
+  "description": "50 agents. 34 tools. 3 AIs. Self-learning. Zero extra cost.",
   "keywords": [
     "mcp",
     "ai",
     "claude",
     "agents",
     "memory",
-    "council"
+    "council",
+    "gemini",
+    "codex",
+    "cursor",
+    "windsurf",
+    "vscode",
+    "self-learning",
+    "router",
+    "workflow",
+    "code-review"
   ],
   "author": "Jigyasu Dham <jigyasudham18@gmail.com>",
   "license": "MIT",

package/.claude/settings.local.json

@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "PowerShell(Get-ChildItem D:\\\\Veto\\\\src -Recurse -File | Where-Object { $_.FullName -notmatch \"node_modules\" } | Select-Object FullName | ForEach-Object { $_.FullName.Replace\\(\"D:\\\\Veto\\\\\", \"\"\\) })",
-      "PowerShell(cd D:\\\\Veto; npm run build 2>&1; Write-Host \"Exit: $LASTEXITCODE\")",
-      "PowerShell(Get-ChildItem D:\\\\Veto\\\\docs -File | Select-Object FullName; Get-ChildItem D:\\\\Veto -File | Where-Object { $_.Extension -eq \".md\" } | Select-Object FullName)"
-    ]
-  }
-}

package/src/adapters/claude.ts

@@ -1,70 +0,0 @@
-// Claude Code adapter — connection config, rate signal detection, handoff format
-
-export const PLATFORM = 'claude' as const;
-
-export type AdapterSetup = {
-  platform: string;
-  mcp_config: object;
-  setup_steps: string[];
-  rate_limit_signals: string[];
-  continue_command: string;
-  notes: string[];
-};
-
-export function getSetup(vetoServerPath: string): AdapterSetup {
-  return {
-    platform: 'claude',
-    mcp_config: {
-      mcpServers: {
-        veto: {
-          command: 'node',
-          args: [vetoServerPath],
-        },
-      },
-    },
-    setup_steps: [
-      `1. Build veto: npm run build`,
-      `2. Add to ~/.claude/mcp_servers.json:\n${JSON.stringify({ mcpServers: { veto: { command: 'node', args: [vetoServerPath] } } }, null, 2)}`,
-      `3. Restart Claude Code`,
-      `4. Verify: call veto_status — should return { "status": "running", "version": "0.7.0" }`,
-    ],
-    rate_limit_signals: [
-      'rate limit exceeded',
-      'too many requests',
-      '429',
-      'overloaded',
-      'capacity',
-      'quota exceeded',
-    ],
-    continue_command: 'veto_continue',
-    notes: [
-      'Claude Code connects to Veto via stdio MCP — the server runs as a child process',
-      'All veto_* tools are available natively in Claude Code once connected',
-      'Rate limits are tracked by Veto per day — call veto_rate_status to check headroom',
-      'Before hitting the limit: call veto_handoff to get a session ID and switch instructions',
-    ],
-  };
-}
-
-export function detectRateLimit(errorText: string): boolean {
-  const signals = ['rate limit', 'too many requests', '429', 'overloaded', 'quota'];
-  return signals.some(s => errorText.toLowerCase().includes(s));
-}
-
-export function formatHandoffMessage(sessionId: string, targetPlatform: 'gemini' | 'codex'): string {
-  const target = targetPlatform === 'gemini' ? 'Gemini CLI' : 'Codex CLI';
-  return [
-    `Claude is approaching its rate limit. Switching to ${target}.`,
-    ``,
-    `Session saved. ID: ${sessionId}`,
-    ``,
-    `On ${target}, run:`,
-    `  veto_continue`,
-    ``,
-    `Veto will restore full context automatically. Nothing needs to be re-explained.`,
-  ].join('\n');
-}
-
-export function formatSwitchPrompt(sessionId: string): string {
-  return `Rate limit approaching. Session saved (ID: ${sessionId}). Call veto_continue on the next platform to resume instantly.`;
-}

package/src/adapters/codex.ts

@@ -1,71 +0,0 @@
-// Codex CLI adapter — connection config, rate signal detection, handoff format
-// Codex CLI: https://github.com/openai/codex
-
-export const PLATFORM = 'codex' as const;
-
-export type AdapterSetup = {
-  platform: string;
-  mcp_config: object;
-  setup_steps: string[];
-  rate_limit_signals: string[];
-  continue_command: string;
-  notes: string[];
-};
-
-export function getSetup(vetoServerPath: string): AdapterSetup {
-  return {
-    platform: 'codex',
-    mcp_config: {
-      mcpServers: {
-        veto: {
-          command: 'node',
-          args: [vetoServerPath],
-        },
-      },
-    },
-    setup_steps: [
-      `1. Install Codex CLI: npm install -g @openai/codex`,
-      `2. Set API key: export OPENAI_API_KEY=your-key`,
-      `3. Add to ~/.codex/config.json:\n${JSON.stringify({ mcpServers: { veto: { command: 'node', args: [vetoServerPath] } } }, null, 2)}`,
-      `4. Restart Codex CLI`,
-      `5. Verify: call veto_status — should return { "status": "running", "version": "0.7.0" }`,
-    ],
-    rate_limit_signals: [
-      'rate limit reached',
-      'too many requests',
-      '429',
-      'insufficient quota',
-      'rate_limit_exceeded',
-      'quota_exceeded',
-    ],
-    continue_command: 'veto_continue',
-    notes: [
-      'Codex CLI connects to Veto via stdio MCP — same server instance as Claude and Gemini',
-      'Config path: ~/.codex/config.json (created automatically on first run)',
-      'All veto_* tools work identically on Codex as on Claude and Gemini',
-      'Codex is the Tier 1/2 overflow when both Claude and Gemini are rate-limited',
-      'Uses GPT-4o / o4-mini depending on the tier assigned by the Veto router',
-      'ChatGPT web app does NOT support MCP — Codex CLI is the only OpenAI option',
-    ],
-  };
-}
-
-export function detectRateLimit(errorText: string): boolean {
-  const signals = ['rate limit', 'too many requests', '429', 'insufficient quota', 'rate_limit_exceeded'];
-  return signals.some(s => errorText.toLowerCase().includes(s.toLowerCase()));
-}
-
-export function formatHandoffMessage(sessionId: string, fromPlatform: 'claude' | 'gemini'): string {
-  const from = fromPlatform === 'claude' ? 'Claude' : 'Gemini';
-  return [
-    `${from} handed off to Codex. Session restored.`,
-    ``,
-    `Session ID: ${sessionId}`,
-    ``,
-    `Codex has full context. Continue the task as if nothing interrupted.`,
-  ].join('\n');
-}
-
-export function formatContinueInstructions(): string {
-  return 'Run: veto_continue\nVeto will restore the most recent session automatically.';
-}

package/src/adapters/gemini.ts

@@ -1,71 +0,0 @@
-// Gemini CLI adapter — connection config, rate signal detection, handoff format
-// Gemini CLI MCP support: https://github.com/google-gemini/gemini-cli
-
-export const PLATFORM = 'gemini' as const;
-
-export type AdapterSetup = {
-  platform: string;
-  mcp_config: object;
-  setup_steps: string[];
-  rate_limit_signals: string[];
-  continue_command: string;
-  notes: string[];
-};
-
-export function getSetup(vetoServerPath: string): AdapterSetup {
-  return {
-    platform: 'gemini',
-    mcp_config: {
-      mcpServers: {
-        veto: {
-          command: 'node',
-          args: [vetoServerPath],
-        },
-      },
-    },
-    setup_steps: [
-      `1. Install Gemini CLI: npm install -g @google/gemini-cli`,
-      `2. Authenticate: gemini auth`,
-      `3. Add to ~/.gemini/settings.json:\n${JSON.stringify({ mcpServers: { veto: { command: 'node', args: [vetoServerPath] } } }, null, 2)}`,
-      `4. Restart Gemini CLI`,
-      `5. Verify: call veto_status — should return { "status": "running", "version": "0.7.0" }`,
-    ],
-    rate_limit_signals: [
-      'quota exceeded',
-      'resource exhausted',
-      '429',
-      'rate limit',
-      'too many requests',
-      'RESOURCE_EXHAUSTED',
-    ],
-    continue_command: 'veto_continue',
-    notes: [
-      'Gemini CLI connects to Veto via stdio MCP — same server instance as Claude',
-      'Gemini CLI uses the same ~/.gemini/settings.json for MCP server config',
-      'All veto_* tools work identically on Gemini as on Claude',
-      'Gemini Flash is the default Tier 1/2 overflow platform when Claude is rate-limited',
-      'Free tier: 1,500 requests/day (15 RPM) — Veto tracks this in rate_usage table',
-    ],
-  };
-}
-
-export function detectRateLimit(errorText: string): boolean {
-  const signals = ['quota exceeded', 'resource exhausted', '429', 'rate limit', 'RESOURCE_EXHAUSTED'];
-  return signals.some(s => errorText.toLowerCase().includes(s.toLowerCase()));
-}
-
-export function formatHandoffMessage(sessionId: string, fromPlatform: 'claude' | 'codex'): string {
-  const from = fromPlatform === 'claude' ? 'Claude' : 'Codex';
-  return [
-    `${from} handed off to Gemini. Session restored.`,
-    ``,
-    `Session ID: ${sessionId}`,
-    ``,
-    `Gemini has full context. Continue the task as if nothing interrupted.`,
-    `Call veto_session_restore { "session_id": "${sessionId}" } if context needs refreshing.`,
-  ].join('\n');
-}
-
-export function formatContinueInstructions(): string {
-  return 'Run: veto_continue\nVeto will restore the most recent session automatically.';
-}

package/src/adapters/index.ts

@@ -1,217 +0,0 @@
-// Handoff engine — platform detection, session save+switch, continue restore
-
-import { getRateStatus, trackRequest } from '../router/rate-monitor.js';
-import { saveSession, listSessions, restoreSession } from '../memory/local.js';
-import type { Platform } from '../router/rate-monitor.js';
-import * as claude from './claude.js';
-import * as gemini from './gemini.js';
-import * as codex from './codex.js';
-
-export type HandoffResult = {
-  session_id: string;
-  saved_at: string;
-  from_platform: Platform;
-  to_platform: Platform;
-  reason: string;
-  rate_status: ReturnType<typeof getRateStatus>;
-  instructions: string;
-  one_liner: string;
-};
-
-export type ContinueResult = {
-  found: boolean;
-  session_id?: string;
-  platform?: string;
-  summary?: string;
-  context?: unknown;
-  task_state?: unknown;
-  next_action?: string;
-  project_dir?: string;
-  token_count?: number;
-  message: string;
-  restored_at: string;
-};
-
-export type PlatformSetupResult = {
-  platform: Platform;
-  mcp_config: object;
-  setup_steps: string[];
-  rate_limit_signals: string[];
-  continue_command: string;
-  notes: string[];
-};
-
-// ─── Handoff ──────────────────────────────────────────────────────────────────
-
-export function handoff(options: {
-  summary?: string;
-  context?: string;
-  task_state?: string;
-  from_platform?: Platform;
-  to_platform?: Platform;
-  token_count?: number;
-  project_dir?: string;
-}): HandoffResult {
-  const rateStatus = getRateStatus();
-  const from: Platform = options.from_platform ?? 'claude';
-
-  // Pick the best available target platform
-  const to: Platform = options.to_platform ?? selectTarget(from, rateStatus);
-
-  const reason = rateStatus[from].status === 'critical'
-    ? `${from} is at ${rateStatus[from].used_percent}% of daily limit`
-    : rateStatus[from].status === 'warning'
-    ? `${from} is at ${rateStatus[from].used_percent}% — switching proactively`
-    : 'Manual platform switch requested';
-
-  const { session_id, saved_at } = saveSession({
-    platform: from,
-    summary: options.summary ?? `Session handed off from ${from} to ${to}`,
-    context: options.context,
-    task_state: options.task_state,
-    token_count: options.token_count ?? 0,
-    project_dir: options.project_dir,
-  });
-
-  const instructions = buildInstructions(session_id, from, to, rateStatus);
-  const one_liner = `Session saved (${session_id.slice(0, 8)}…). On ${to}: call veto_continue`;
-
-  return {
-    session_id,
-    saved_at,
-    from_platform: from,
-    to_platform: to,
-    reason,
-    rate_status: rateStatus,
-    instructions,
-    one_liner,
-  };
-}
-
-// ─── Continue ─────────────────────────────────────────────────────────────────
-
-export function continueSession(sessionId?: string): ContinueResult {
-  const now = new Date().toISOString();
-
-  if (sessionId) {
-    const result = restoreSession(sessionId);
-    if (!result.found || !result.session) {
-      return { found: false, message: `No session found with ID: ${sessionId}`, restored_at: now };
-    }
-    return buildContinueResult(result.session, now);
-  }
-
-  // No ID given — find the most recent session
-  const sessions = listSessions(1);
-  if (sessions.length === 0) {
-    return {
-      found: false,
-      message: 'No saved sessions found. Save a session first with veto_handoff or veto_session_save.',
-      restored_at: now,
-    };
-  }
-
-  const result = restoreSession(sessions[0].id);
-  if (!result.found || !result.session) {
-    return { found: false, message: 'Could not restore the most recent session.', restored_at: now };
-  }
-
-  return buildContinueResult(result.session, now);
-}
-
-function buildContinueResult(session: ReturnType<typeof listSessions>[0], now: string): ContinueResult {
-  let context: unknown = null;
-  let task_state: unknown = null;
-  let next_action: string | undefined;
-
-  try {
-    context = session.context ? JSON.parse(session.context) : null;
-  } catch { context = session.context; }
-
-  try {
-    let ts: unknown = session.task_state ? JSON.parse(session.task_state) : null;
-    // saveSession double-stringifies when given a pre-serialised string — unwrap if needed
-    if (typeof ts === 'string') { try { ts = JSON.parse(ts); } catch { /* keep as string */ } }
-    task_state = ts;
-    if (ts && typeof ts === 'object' && 'nextAction' in ts) {
-      next_action = String((ts as Record<string, unknown>)['nextAction']);
-    }
-  } catch { task_state = session.task_state; }
-
-  const message = [
-    `Session restored from ${session.platform} (saved ${session.started_at.slice(0, 16)}).`,
-    session.summary ? `\nSummary: ${session.summary}` : '',
-    next_action ? `\nNext action: ${next_action}` : '',
-    `\nContinue exactly where you left off. Nothing needs to be re-explained.`,
-  ].filter(Boolean).join('');
-
-  return {
-    found: true,
-    session_id: session.id,
-    platform: session.platform,
-    summary: session.summary ?? undefined,
-    context,
-    task_state,
-    next_action,
-    project_dir: session.project_dir ?? undefined,
-    token_count: session.token_count,
-    message,
-    restored_at: now,
-  };
-}
-
-// ─── Platform Setup ───────────────────────────────────────────────────────────
-
-export function getPlatformSetup(platform: Platform, vetoServerPath: string): PlatformSetupResult {
-  if (platform === 'claude') return claude.getSetup(vetoServerPath) as PlatformSetupResult;
-  if (platform === 'gemini') return gemini.getSetup(vetoServerPath) as PlatformSetupResult;
-  return codex.getSetup(vetoServerPath) as PlatformSetupResult;
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-function selectTarget(from: Platform, rateStatus: ReturnType<typeof getRateStatus>): Platform {
-  const order: Platform[] = from === 'claude'
-    ? ['gemini', 'codex']
-    : from === 'gemini'
-    ? ['codex', 'claude']
-    : ['claude', 'gemini'];
-
-  for (const p of order) {
-    if (rateStatus[p].status !== 'critical') return p;
-  }
-  // All critical — pick the one with most headroom remaining
-  return order.reduce((best, p) =>
-    rateStatus[p].used_percent < rateStatus[best].used_percent ? p : best
-  , order[0]);
-}
-
-function buildInstructions(
-  sessionId: string,
-  from: Platform,
-  to: Platform,
-  rateStatus: ReturnType<typeof getRateStatus>
-): string {
-  const toStatus = rateStatus[to];
-  const lines: string[] = [
-    `── Veto Handoff ──────────────────────────────────────────`,
-    `From:     ${from.padEnd(8)} (${rateStatus[from].used_percent}% used)`,
-    `To:       ${to.padEnd(8)} (${toStatus.used_percent}% used)`,
-    `Session:  ${sessionId}`,
-    ``,
-    `On ${to}:`,
-    `  1. Open a new terminal with ${to} CLI`,
-    `  2. Veto is already running — same server, same memory`,
-    `  3. Call:  veto_continue`,
-    `     Veto restores full context automatically.`,
-    `     Nothing needs to be re-explained.`,
-    ``,
-    `Or if you have the session ID:`,
-    `  veto_continue { "session_id": "${sessionId}" }`,
-    ``,
-    `Rate resets at: ${rateStatus[from].resets_at.slice(0, 16)} UTC`,
-    `─────────────────────────────────────────────────────────`,
-  ];
-
-  return lines.join('\n');
-}