@vibecodetown/mcp-server 1.3.1 → 1.5.0

package/build/mcp/a2a/history/builder.d.ts

@@ -0,0 +1,78 @@
+/**
+ * A2A Run History Index Builder
+ * Builds and queries execution history
+ */
+import type { RunHistoryIndex, ExecutionStep, HistoryStatus, HistoryVerdict, AgentRole, MessageType, ActionType, StepStatus, RetryRecord, RecoveryAction, TriggerVerdict, ToolResultArtifact, VerdictArtifact, GateDecisionArtifact, PatchArtifact, LogArtifact, ReportArtifact, RepoContext, HistoryQuery } from "./types.js";
+export interface HistoryBuilderOptions {
+    run_id: string;
+    trace_id?: string;
+    project_id?: string;
+    policy_version?: string;
+    repo_context?: Partial<RepoContext>;
+}
+export declare class HistoryBuilder {
+    private index;
+    private indexPath;
+    private sequenceCounter;
+    constructor(options: HistoryBuilderOptions);
+    get runId(): string;
+    get traceId(): string;
+    get status(): HistoryStatus;
+    getIndex(): Readonly<RunHistoryIndex>;
+    addStep(step: {
+        agent: AgentRole;
+        message_type: MessageType;
+        action_id: string;
+        action_type: ActionType;
+        parent_step_id?: string;
+        input_hash?: string;
+    }): string;
+    completeStep(stepId: string, result: {
+        status: StepStatus;
+        verdict?: HistoryVerdict;
+        output_hash?: string;
+        error?: {
+            code: string;
+            message: string;
+            recoverable: boolean;
+        };
+    }): boolean;
+    addArtifactToStep(stepId: string, artifactPath: string): boolean;
+    markRetry(stepId: string, reason: string): boolean;
+    indexObservationLog(logPath: string, lineCount: number): void;
+    indexToolResult(artifact: Omit<ToolResultArtifact, "type">): void;
+    indexVerdict(artifact: Omit<VerdictArtifact, "type">): void;
+    indexGateDecision(artifact: Omit<GateDecisionArtifact, "type">): void;
+    indexPatch(artifact: Omit<PatchArtifact, "type">): void;
+    indexLog(artifact: Omit<LogArtifact, "type">): void;
+    indexReport(artifact: Omit<ReportArtifact, "type">): void;
+    recordRetry(record: {
+        step_id: string;
+        action_id: string;
+        attempt: number;
+        max_attempts: number;
+        reason: string;
+        trigger_verdict: TriggerVerdict;
+        error_type: string;
+        recovery_action: RecoveryAction;
+        previous_error_hash?: string;
+        backoff_ms?: number;
+    }): string;
+    markRetrySuccess(retryId: string): boolean;
+    complete(verdict: HistoryVerdict): void;
+    fail(verdict?: HistoryVerdict): void;
+    abort(): void;
+    query(query: HistoryQuery): ExecutionStep[];
+    getStepsByVerdict(verdict: HistoryVerdict): ExecutionStep[];
+    getStepsByAgent(agent: AgentRole): ExecutionStep[];
+    getRetryHistory(stepId: string): RetryRecord[];
+    save(basePath: string): string;
+    static load(indexPath: string): HistoryBuilder;
+    private updateTimestamp;
+    private updateAgentActivity;
+    private calculateFinalMetrics;
+    private computeHash;
+    private getFileStats;
+}
+export declare function createHistoryBuilder(options: HistoryBuilderOptions): HistoryBuilder;
+export declare function loadHistoryIndex(indexPath: string): HistoryBuilder;

package/build/mcp/a2a/history/builder.js

@@ -0,0 +1,399 @@
+/**
+ * A2A Run History Index Builder
+ * Builds and queries execution history
+ */
+import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as crypto from "node:crypto";
+// ============================================================================
+// Default Values
+// ============================================================================
+function createDefaultAgentActivity() {
+    return {
+        message_count: 0,
+        action_count: 0,
+        first_activity: null,
+        last_activity: null,
+        total_duration_ms: 0,
+        error_count: 0,
+    };
+}
+function createDefaultArtifactIndex() {
+    return {
+        observations: null,
+        tool_results: [],
+        verdicts: [],
+        gate_decisions: [],
+        patches: [],
+        logs: [],
+        reports: [],
+    };
+}
+function createDefaultMetrics() {
+    return {
+        total_steps: 0,
+        total_actions: 0,
+        total_retries: 0,
+        total_duration_ms: 0,
+        lines_changed: 0,
+        files_modified: 0,
+        verdict_counts: {
+            GO: 0,
+            FIX: 0,
+            BLOCK: 0,
+        },
+    };
+}
+export class HistoryBuilder {
+    index;
+    indexPath = null;
+    sequenceCounter = 0;
+    constructor(options) {
+        const now = new Date().toISOString();
+        this.index = {
+            schema_version: "1.0",
+            run_id: options.run_id,
+            trace_id: options.trace_id ?? randomUUID(),
+            project_id: options.project_id ?? "",
+            policy_version: options.policy_version ?? "policy.v1.0",
+            timestamps: {
+                created_at: now,
+                updated_at: now,
+                started_at: now,
+                completed_at: null,
+            },
+            status: "IN_PROGRESS",
+            final_verdict: null,
+            execution_timeline: [],
+            artifact_index: createDefaultArtifactIndex(),
+            retry_history: [],
+            agent_activity: {
+                planner: createDefaultAgentActivity(),
+                executor: createDefaultAgentActivity(),
+                reviewer: createDefaultAgentActivity(),
+                gatekeeper: createDefaultAgentActivity(),
+            },
+            metrics: createDefaultMetrics(),
+            repo_context: {
+                root: options.repo_context?.root ?? process.cwd(),
+                branch: options.repo_context?.branch ?? "main",
+                commit_sha: options.repo_context?.commit_sha ?? "",
+                clean: options.repo_context?.clean ?? true,
+            },
+        };
+    }
+    // ==========================================================================
+    // Getters
+    // ==========================================================================
+    get runId() {
+        return this.index.run_id;
+    }
+    get traceId() {
+        return this.index.trace_id;
+    }
+    get status() {
+        return this.index.status;
+    }
+    getIndex() {
+        return this.index;
+    }
+    // ==========================================================================
+    // Step Management
+    // ==========================================================================
+    addStep(step) {
+        const stepId = randomUUID();
+        const now = new Date().toISOString();
+        const executionStep = {
+            step_id: stepId,
+            parent_step_id: step.parent_step_id ?? null,
+            sequence: this.sequenceCounter++,
+            timestamp: now,
+            end_timestamp: null,
+            duration_ms: 0,
+            agent: step.agent,
+            message_type: step.message_type,
+            action_id: step.action_id,
+            action_type: step.action_type,
+            status: "IN_PROGRESS",
+            verdict: null,
+            retry_count: 0,
+            retry_reason: null,
+            envelope_ref: `observation.v1.jsonl:${this.index.execution_timeline.length}`,
+            artifact_refs: [],
+            error: null,
+            input_hash: step.input_hash ?? this.computeHash(JSON.stringify(step)),
+            output_hash: "",
+        };
+        this.index.execution_timeline.push(executionStep);
+        this.updateAgentActivity(step.agent, "action");
+        this.index.metrics.total_steps++;
+        this.index.metrics.total_actions++;
+        this.updateTimestamp();
+        return stepId;
+    }
+    completeStep(stepId, result) {
+        const step = this.index.execution_timeline.find((s) => s.step_id === stepId);
+        if (!step)
+            return false;
+        const now = new Date().toISOString();
+        step.end_timestamp = now;
+        step.duration_ms = new Date(now).getTime() - new Date(step.timestamp).getTime();
+        step.status = result.status;
+        step.verdict = result.verdict ?? null;
+        step.output_hash = result.output_hash ?? this.computeHash(JSON.stringify(result));
+        step.error = result.error ?? null;
+        if (result.verdict) {
+            this.index.metrics.verdict_counts[result.verdict]++;
+        }
+        if (result.error) {
+            this.updateAgentActivity(step.agent, "error");
+        }
+        this.updateTimestamp();
+        return true;
+    }
+    addArtifactToStep(stepId, artifactPath) {
+        const step = this.index.execution_timeline.find((s) => s.step_id === stepId);
+        if (!step)
+            return false;
+        step.artifact_refs.push(artifactPath);
+        return true;
+    }
+    markRetry(stepId, reason) {
+        const step = this.index.execution_timeline.find((s) => s.step_id === stepId);
+        if (!step)
+            return false;
+        step.retry_count++;
+        step.retry_reason = reason;
+        step.status = "RETRIED";
+        this.index.metrics.total_retries++;
+        return true;
+    }
+    // ==========================================================================
+    // Artifact Indexing
+    // ==========================================================================
+    indexObservationLog(logPath, lineCount) {
+        const stats = this.getFileStats(logPath);
+        this.index.artifact_index.observations = {
+            path: logPath,
+            type: "observation_log",
+            size_bytes: stats.size,
+            line_count: lineCount,
+            checksum: stats.checksum,
+        };
+    }
+    indexToolResult(artifact) {
+        this.index.artifact_index.tool_results.push({
+            ...artifact,
+            type: "tool_result",
+        });
+    }
+    indexVerdict(artifact) {
+        this.index.artifact_index.verdicts.push({
+            ...artifact,
+            type: "verdict",
+        });
+    }
+    indexGateDecision(artifact) {
+        this.index.artifact_index.gate_decisions.push({
+            ...artifact,
+            type: "gate_decision",
+        });
+    }
+    indexPatch(artifact) {
+        this.index.artifact_index.patches.push({
+            ...artifact,
+            type: "diff",
+        });
+        this.index.metrics.lines_changed += artifact.lines_added + artifact.lines_removed;
+        this.index.metrics.files_modified += artifact.files_affected.length;
+    }
+    indexLog(artifact) {
+        this.index.artifact_index.logs.push({
+            ...artifact,
+            type: "log",
+        });
+    }
+    indexReport(artifact) {
+        this.index.artifact_index.reports.push({
+            ...artifact,
+            type: "report",
+        });
+    }
+    // ==========================================================================
+    // Retry History
+    // ==========================================================================
+    recordRetry(record) {
+        const retryId = randomUUID();
+        const retryRecord = {
+            retry_id: retryId,
+            step_id: record.step_id,
+            action_id: record.action_id,
+            attempt: record.attempt,
+            max_attempts: record.max_attempts,
+            timestamp: new Date().toISOString(),
+            reason: record.reason,
+            trigger_verdict: record.trigger_verdict,
+            error_type: record.error_type,
+            previous_error_hash: record.previous_error_hash ?? null,
+            recovery_action: record.recovery_action,
+            success: false, // Will be updated when retry completes
+            backoff_ms: record.backoff_ms ?? 0,
+        };
+        this.index.retry_history.push(retryRecord);
+        this.updateTimestamp();
+        return retryId;
+    }
+    markRetrySuccess(retryId) {
+        const record = this.index.retry_history.find((r) => r.retry_id === retryId);
+        if (!record)
+            return false;
+        record.success = true;
+        return true;
+    }
+    // ==========================================================================
+    // Status Management
+    // ==========================================================================
+    complete(verdict) {
+        this.index.status = "COMPLETED";
+        this.index.final_verdict = verdict;
+        this.index.timestamps.completed_at = new Date().toISOString();
+        this.calculateFinalMetrics();
+    }
+    fail(verdict = "BLOCK") {
+        this.index.status = "FAILED";
+        this.index.final_verdict = verdict;
+        this.index.timestamps.completed_at = new Date().toISOString();
+        this.calculateFinalMetrics();
+    }
+    abort() {
+        this.index.status = "ABORTED";
+        this.index.timestamps.completed_at = new Date().toISOString();
+        this.calculateFinalMetrics();
+    }
+    // ==========================================================================
+    // Queries
+    // ==========================================================================
+    query(query) {
+        let results = [...this.index.execution_timeline];
+        if (query.by_step_id) {
+            results = results.filter((s) => s.step_id === query.by_step_id);
+        }
+        if (query.by_action_id) {
+            results = results.filter((s) => s.action_id === query.by_action_id);
+        }
+        if (query.by_verdict) {
+            results = results.filter((s) => s.verdict === query.by_verdict);
+        }
+        if (query.by_agent) {
+            results = results.filter((s) => s.agent === query.by_agent);
+        }
+        if (query.from_timestamp) {
+            const from = new Date(query.from_timestamp).getTime();
+            results = results.filter((s) => new Date(s.timestamp).getTime() >= from);
+        }
+        if (query.to_timestamp) {
+            const to = new Date(query.to_timestamp).getTime();
+            results = results.filter((s) => new Date(s.timestamp).getTime() <= to);
+        }
+        return results;
+    }
+    getStepsByVerdict(verdict) {
+        return this.query({ by_verdict: verdict });
+    }
+    getStepsByAgent(agent) {
+        return this.query({ by_agent: agent });
+    }
+    getRetryHistory(stepId) {
+        return this.index.retry_history.filter((r) => r.step_id === stepId);
+    }
+    // ==========================================================================
+    // Persistence
+    // ==========================================================================
+    save(basePath) {
+        const runDir = path.join(basePath, ".vibe", "runs", this.index.run_id);
+        fs.mkdirSync(runDir, { recursive: true });
+        this.indexPath = path.join(runDir, "run_history_index.v1.json");
+        fs.writeFileSync(this.indexPath, JSON.stringify(this.index, null, 2));
+        return this.indexPath;
+    }
+    static load(indexPath) {
+        const data = fs.readFileSync(indexPath, "utf-8");
+        const index = JSON.parse(data);
+        const builder = new HistoryBuilder({ run_id: index.run_id });
+        builder.index = index;
+        builder.indexPath = indexPath;
+        builder.sequenceCounter = index.execution_timeline.length;
+        return builder;
+    }
+    // ==========================================================================
+    // Helpers
+    // ==========================================================================
+    updateTimestamp() {
+        this.index.timestamps.updated_at = new Date().toISOString();
+    }
+    updateAgentActivity(agent, type) {
+        // Map agent roles to activity keys
+        const activityKey = agent;
+        if (!(activityKey in this.index.agent_activity))
+            return;
+        const activity = this.index.agent_activity[activityKey];
+        const now = new Date().toISOString();
+        if (!activity.first_activity) {
+            activity.first_activity = now;
+        }
+        activity.last_activity = now;
+        if (type === "action") {
+            activity.message_count++;
+            activity.action_count++;
+        }
+        else {
+            activity.error_count++;
+        }
+    }
+    calculateFinalMetrics() {
+        const { execution_timeline, agent_activity } = this.index;
+        // Calculate total duration
+        if (execution_timeline.length > 0) {
+            const firstStep = execution_timeline[0];
+            const lastStep = execution_timeline[execution_timeline.length - 1];
+            const endTime = lastStep.end_timestamp ?? lastStep.timestamp;
+            this.index.metrics.total_duration_ms =
+                new Date(endTime).getTime() - new Date(firstStep.timestamp).getTime();
+        }
+        // Calculate agent durations
+        for (const [, activity] of Object.entries(agent_activity)) {
+            if (activity.first_activity && activity.last_activity) {
+                activity.total_duration_ms =
+                    new Date(activity.last_activity).getTime() -
+                        new Date(activity.first_activity).getTime();
+            }
+        }
+    }
+    computeHash(content) {
+        return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+    }
+    getFileStats(filePath) {
+        try {
+            const stats = fs.statSync(filePath);
+            const content = fs.readFileSync(filePath);
+            const checksum = crypto
+                .createHash("sha256")
+                .update(content)
+                .digest("hex");
+            return { size: stats.size, checksum };
+        }
+        catch {
+            return { size: 0, checksum: "" };
+        }
+    }
+}
+// ============================================================================
+// Factory Functions
+// ============================================================================
+export function createHistoryBuilder(options) {
+    return new HistoryBuilder(options);
+}
+export function loadHistoryIndex(indexPath) {
+    return HistoryBuilder.load(indexPath);
+}

package/build/mcp/a2a/history/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A2A Run History Module
+ * Exports types and builder for run history indexing
+ */
+export * from "./types.js";
+export * from "./builder.js";

package/build/mcp/a2a/history/index.js

@@ -0,0 +1,6 @@
+/**
+ * A2A Run History Module
+ * Exports types and builder for run history indexing
+ */
+export * from "./types.js";
+export * from "./builder.js";

package/build/mcp/a2a/history/types.d.ts

@@ -0,0 +1,185 @@
+/**
+ * A2A Run History Index Types
+ * Based on run_history_index.v1.json schema
+ */
+export type HistoryStatus = "IN_PROGRESS" | "COMPLETED" | "FAILED" | "ABORTED";
+export type HistoryVerdict = "GO" | "FIX" | "BLOCK";
+export type AgentRole = "planner" | "executor" | "reviewer" | "gatekeeper" | "orchestrator" | "observer";
+export type MessageType = "EXEC_REQUEST" | "EXEC_RESULT" | "GATE_CHECK" | "GATE_VERDICT" | "RISK_SCAN" | "RISK_REPORT" | "OBSERVE_EVENT" | "HEARTBEAT";
+export type ActionType = "tool_call" | "file_edit" | "analysis_only" | "clarify_request" | "no_op";
+export type StepStatus = "PENDING" | "IN_PROGRESS" | "COMPLETED" | "FAILED" | "SKIPPED" | "RETRIED";
+export type RecoveryAction = "AUTO_INIT_RUN_CONTEXT" | "RETRY_ORIGINAL_TOOL" | "APPLY_PATCH" | "ROLLBACK" | "ESCALATE_TO_GATE";
+export type TriggerVerdict = "FIX" | "ERROR";
+export type LogType = "stdout" | "stderr" | "combined" | "debug";
+export type ReportType = "test_report" | "coverage_report" | "lint_report" | "security_scan" | "risk_analysis";
+export type GateDecisionType = "PROCEED" | "RETRY" | "ASK_CLARIFICATION" | "BLOCK" | "FINALIZE";
+export type PatchFormat = "unified_diff" | "git_diff" | "json_patch";
+export interface StepError {
+    code: string;
+    message: string;
+    recoverable: boolean;
+}
+export interface ExecutionStep {
+    step_id: string;
+    parent_step_id: string | null;
+    sequence: number;
+    timestamp: string;
+    end_timestamp: string | null;
+    duration_ms: number;
+    agent: AgentRole;
+    message_type: MessageType;
+    action_id: string;
+    action_type: ActionType;
+    status: StepStatus;
+    verdict: HistoryVerdict | null;
+    retry_count: number;
+    retry_reason: string | null;
+    envelope_ref: string;
+    artifact_refs: string[];
+    error: StepError | null;
+    input_hash: string;
+    output_hash: string;
+}
+export interface BaseArtifact {
+    path: string;
+    type: string;
+    size_bytes: number;
+    checksum: string;
+    created_at: string;
+    step_id: string;
+}
+export interface ObservationArtifact {
+    path: string;
+    type: "observation_log";
+    size_bytes: number;
+    line_count: number;
+    checksum: string;
+}
+export interface ToolResultArtifact extends BaseArtifact {
+    type: "tool_result";
+    tool_name: string;
+    exit_code: number;
+    stdout_path: string | null;
+    stderr_path: string | null;
+}
+export interface VerdictArtifact extends BaseArtifact {
+    type: "verdict";
+    verdict_id: string;
+    signal: HistoryVerdict;
+    violation_count: number;
+    checks_performed: string[];
+}
+export interface GateDecisionArtifact extends BaseArtifact {
+    type: "gate_decision";
+    decision_id: string;
+    decision: GateDecisionType;
+    budget_remaining: {
+        retries: number;
+        files: number;
+        lines: number;
+    };
+}
+export interface PatchArtifact extends BaseArtifact {
+    type: "diff";
+    format: PatchFormat;
+    files_affected: string[];
+    lines_added: number;
+    lines_removed: number;
+}
+export interface LogArtifact extends BaseArtifact {
+    type: "log";
+    log_type: LogType;
+    line_count: number;
+}
+export interface ReportArtifact extends BaseArtifact {
+    type: "report";
+    report_type: ReportType;
+    summary: string;
+}
+export interface ArtifactIndex {
+    observations: ObservationArtifact | null;
+    tool_results: ToolResultArtifact[];
+    verdicts: VerdictArtifact[];
+    gate_decisions: GateDecisionArtifact[];
+    patches: PatchArtifact[];
+    logs: LogArtifact[];
+    reports: ReportArtifact[];
+}
+export interface RetryRecord {
+    retry_id: string;
+    step_id: string;
+    action_id: string;
+    attempt: number;
+    max_attempts: number;
+    timestamp: string;
+    reason: string;
+    trigger_verdict: TriggerVerdict;
+    error_type: string;
+    previous_error_hash: string | null;
+    recovery_action: RecoveryAction;
+    success: boolean;
+    backoff_ms: number;
+}
+export interface AgentActivitySummary {
+    message_count: number;
+    action_count: number;
+    first_activity: string | null;
+    last_activity: string | null;
+    total_duration_ms: number;
+    error_count: number;
+}
+export interface AgentActivity {
+    planner: AgentActivitySummary;
+    executor: AgentActivitySummary;
+    reviewer: AgentActivitySummary;
+    gatekeeper: AgentActivitySummary;
+}
+export interface VerdictCounts {
+    GO: number;
+    FIX: number;
+    BLOCK: number;
+}
+export interface RunMetrics {
+    total_steps: number;
+    total_actions: number;
+    total_retries: number;
+    total_duration_ms: number;
+    lines_changed: number;
+    files_modified: number;
+    verdict_counts: VerdictCounts;
+}
+export interface RepoContext {
+    root: string;
+    branch: string;
+    commit_sha: string;
+    clean: boolean;
+}
+export interface RunHistoryIndex {
+    schema_version: "1.0";
+    run_id: string;
+    trace_id: string;
+    project_id: string;
+    policy_version: string;
+    timestamps: {
+        created_at: string;
+        updated_at: string;
+        started_at: string;
+        completed_at: string | null;
+    };
+    status: HistoryStatus;
+    final_verdict: HistoryVerdict | null;
+    execution_timeline: ExecutionStep[];
+    artifact_index: ArtifactIndex;
+    retry_history: RetryRecord[];
+    agent_activity: AgentActivity;
+    metrics: RunMetrics;
+    repo_context: RepoContext;
+}
+export interface HistoryQuery {
+    by_step_id?: string;
+    by_action_id?: string;
+    by_verdict?: HistoryVerdict;
+    by_agent?: AgentRole;
+    from_timestamp?: string;
+    to_timestamp?: string;
+}

package/build/mcp/a2a/history/types.js

@@ -0,0 +1,5 @@
+/**
+ * A2A Run History Index Types
+ * Based on run_history_index.v1.json schema
+ */
+export {};

package/build/mcp/a2a/index.d.ts

@@ -0,0 +1,7 @@
+export type { MessageType, AgentRole, A2AEnvelope, ExecRequestPayload, ExecResultPayload, FileMutation, CommandExecution, DryRunResult, } from "./types.js";
+export { createEnvelope, createExecRequest, createExecResult, serializeEnvelope, parseEnvelope, } from "./envelope.js";
+export * from "./executor/index.js";
+export * from "./orchestrator/index.js";
+export * from "./state/index.js";
+export * as history from "./history/index.js";
+export * from "./intent/index.js";