@martinloop/mcp 0.2.0 → 0.2.5

package/dist/discovery-support.js

@@ -0,0 +1,224 @@
+import { resolveRunsRoot } from "./vendor/core/index.js";
+import { resolveSafeRepoRoot, resolveSafeRunsRootPath } from "./server-validation.js";
+import { loadLoopRecordForStatus } from "./tools/run-store.js";
+import { buildLoopPreview } from "./tools/tool-support.js";
+import { invalidArgumentsError } from "./tools/tool-errors.js";
+export function resolveMartinDiscoveryContext(input = {}) {
+    const fallbackRunsRoot = resolveRunsRoot(process.env);
+    return {
+        runsRoot: resolveSafeRunsRootPath(input.runsDir, fallbackRunsRoot),
+        workingDirectory: resolveSafeRepoRoot(input.workingDirectory),
+        ...(input.engine ? { engine: input.engine } : {})
+    };
+}
+export async function loadPersistedLoopRecord(input) {
+    const resolved = await loadLoopRecordForStatus({
+        loopId: input.loopId,
+        ...(input.runsDir ? { runsDir: input.runsDir } : {})
+    });
+    return {
+        source: resolved.source,
+        loop: resolved.loop
+    };
+}
+export function buildAttemptSnapshot(loop, requestedAttemptIndex, ledgerEvents = []) {
+    const attempt = requestedAttemptIndex === undefined
+        ? loop.attempts.at(-1)
+        : loop.attempts.find((candidate) => candidate.index === requestedAttemptIndex);
+    if (!attempt) {
+        throw invalidArgumentsError(requestedAttemptIndex === undefined
+            ? `Loop '${loop.loopId}' has no attempts yet.`
+            : `Attempt ${requestedAttemptIndex} was not found for loop '${loop.loopId}'.`, requestedAttemptIndex === undefined
+            ? "Run martin_run first or inspect a loop that has executed at least one attempt."
+            : "Choose an attemptIndex that exists in the loop record.");
+    }
+    const verification = buildVerificationSnapshotForAttempt(loop, attempt, ledgerEvents);
+    const warnings = collectVerificationSnapshots(loop, ledgerEvents).warnings;
+    return {
+        loopId: loop.loopId,
+        attemptIndex: attempt.index,
+        loop: buildPersistedLoopPreview(loop),
+        attempt,
+        ...(verification ? { verification } : {}),
+        warnings
+    };
+}
+export function buildVerificationHistorySnapshot(loop, ledgerEvents = []) {
+    const collected = collectVerificationSnapshots(loop, ledgerEvents);
+    const verificationHistory = collected.snapshots;
+    const latestVerification = selectLatestVerificationSnapshot(verificationHistory, collected.warnings);
+    return {
+        loopId: loop.loopId,
+        loop: buildPersistedLoopPreview(loop),
+        verificationCount: verificationHistory.length,
+        ...(latestVerification ? { latestVerification } : {}),
+        verificationHistory,
+        warnings: collected.warnings
+    };
+}
+export function buildPersistedLoopPreview(loop) {
+    return buildLoopPreview(loop);
+}
+export function parseAttemptIndex(value) {
+    if (!/^\d+$/u.test(value)) {
+        throw invalidArgumentsError("Invalid attemptIndex.", "attemptIndex must be a positive integer taken from the loop's attempts array.");
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+        throw invalidArgumentsError("Invalid attemptIndex.", "attemptIndex must be a positive integer taken from the loop's attempts array.");
+    }
+    return parsed;
+}
+export function toPrettyJson(value) {
+    return `${JSON.stringify(value, null, 2)}\n`;
+}
+function buildVerificationSnapshotForAttempt(loop, attempt, ledgerEvents = []) {
+    const matching = collectVerificationSnapshots(loop, ledgerEvents).snapshots.filter((verification) => verification.attemptIndex === attempt.index ||
+        (attempt.attemptId !== undefined && verification.attemptId === attempt.attemptId));
+    if (hasConflictingStatuses(matching)) {
+        return undefined;
+    }
+    return matching.at(-1);
+}
+function getVerificationEvents(loop) {
+    return (loop.events ?? []).filter((event) => event.type === "verification.completed");
+}
+function toVerificationSnapshot(loop, event) {
+    if (!isTrustedVerificationTimestamp(event.timestamp)) {
+        return undefined;
+    }
+    const payload = isRecord(event.payload) ? event.payload : undefined;
+    const attemptId = typeof payload?.["attemptId"] === "string" ? payload["attemptId"] : undefined;
+    const attemptIndex = typeof payload?.["attemptIndex"] === "number" && Number.isInteger(payload["attemptIndex"])
+        ? payload["attemptIndex"]
+        : undefined;
+    const matchedAttempt = attemptId
+        ? loop.attempts.find((attempt) => attempt.attemptId === attemptId)
+        : attemptIndex !== undefined
+            ? loop.attempts.find((attempt) => attempt.index === attemptIndex)
+            : undefined;
+    if (!matchedAttempt) {
+        return undefined;
+    }
+    return {
+        ...(matchedAttempt.attemptId ? { attemptId: matchedAttempt.attemptId } : {}),
+        attemptIndex: matchedAttempt.index,
+        timestamp: event.timestamp,
+        lifecycleState: event.lifecycleState,
+        ...(typeof payload?.["passed"] === "boolean" ? { passed: payload["passed"] } : {}),
+        ...(typeof payload?.["summary"] === "string" ? { summary: payload["summary"] } : {})
+    };
+}
+function collectVerificationSnapshots(loop, ledgerEvents) {
+    const seen = new Set();
+    const snapshots = [];
+    const warnings = getLedgerWarnings(ledgerEvents);
+    const futureEvidenceCount = [
+        ...getVerificationEvents(loop).map((event) => event.timestamp),
+        ...ledgerEvents.filter((candidate) => candidate.kind === "verification.completed").map((event) => event.timestamp)
+    ].filter(isFutureVerificationTimestamp).length;
+    if (futureEvidenceCount > 0) {
+        warnings.push(`Ignored ${futureEvidenceCount} future-dated verification evidence item(s) that cannot be trusted yet.`);
+    }
+    for (const event of getVerificationEvents(loop)) {
+        const snapshot = toVerificationSnapshot(loop, event);
+        if (!snapshot) {
+            continue;
+        }
+        const key = verificationSnapshotKey(snapshot);
+        seen.add(key);
+        snapshots.push(snapshot);
+    }
+    for (const event of ledgerEvents.filter((candidate) => candidate.kind === "verification.completed")) {
+        const snapshot = ledgerEventToVerificationSnapshot(loop, event);
+        if (!snapshot) {
+            continue;
+        }
+        const key = verificationSnapshotKey(snapshot);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        snapshots.push(snapshot);
+    }
+    snapshots.sort((left, right) => new Date(left.timestamp).getTime() - new Date(right.timestamp).getTime());
+    if (hasConflictingStatusesForLatestAttempt(snapshots)) {
+        warnings.push("Verification evidence conflicts for the latest attempt; reporting status as unavailable.");
+    }
+    return { snapshots, warnings };
+}
+function ledgerEventToVerificationSnapshot(loop, event) {
+    if (!isTrustedVerificationTimestamp(event.timestamp)) {
+        return undefined;
+    }
+    const payload = isRecord(event.payload) ? event.payload : undefined;
+    const matchedAttempt = event.attemptIndex !== undefined
+        ? loop.attempts.find((attempt) => attempt.index === event.attemptIndex)
+        : undefined;
+    if (!matchedAttempt) {
+        return undefined;
+    }
+    return {
+        ...(matchedAttempt?.attemptId ? { attemptId: matchedAttempt.attemptId } : {}),
+        ...(event.attemptIndex !== undefined ? { attemptIndex: event.attemptIndex } : {}),
+        timestamp: event.timestamp,
+        lifecycleState: loop.lifecycleState,
+        ...(typeof payload?.["passed"] === "boolean" ? { passed: payload["passed"] } : {}),
+        ...(typeof payload?.["summary"] === "string" ? { summary: payload["summary"] } : {})
+    };
+}
+function verificationSnapshotKey(snapshot) {
+    return [
+        snapshot.attemptIndex !== undefined ? `attempt:${snapshot.attemptIndex}` : `attempt-id:${snapshot.attemptId ?? ""}`,
+        `timestamp:${snapshot.timestamp}`,
+        `summary:${snapshot.summary ?? ""}`,
+        `passed:${String(snapshot.passed)}`
+    ].join(":");
+}
+function selectLatestVerificationSnapshot(snapshots, warnings) {
+    if (warnings.includes("Verification evidence conflicts for the latest attempt; reporting status as unavailable.")) {
+        return undefined;
+    }
+    return snapshots.at(-1);
+}
+function hasConflictingStatusesForLatestAttempt(snapshots) {
+    const latest = snapshots.at(-1);
+    if (!latest) {
+        return false;
+    }
+    const latestAttemptSnapshots = snapshots.filter((candidate) => latest.attemptId
+        ? candidate.attemptId === latest.attemptId
+        : latest.attemptIndex !== undefined
+            ? candidate.attemptIndex === latest.attemptIndex
+            : false);
+    return hasConflictingStatuses(latestAttemptSnapshots);
+}
+function hasConflictingStatuses(snapshots) {
+    const statuses = new Set(snapshots
+        .map((snapshot) => snapshot.passed)
+        .filter((status) => typeof status === "boolean"));
+    return statuses.size > 1;
+}
+function isTrustedVerificationTimestamp(value) {
+    const timestamp = new Date(value).getTime();
+    if (!Number.isFinite(timestamp)) {
+        return false;
+    }
+    return timestamp <= Date.now() + 5 * 60_000;
+}
+function isFutureVerificationTimestamp(value) {
+    const timestamp = new Date(value).getTime();
+    if (!Number.isFinite(timestamp)) {
+        return false;
+    }
+    return timestamp > Date.now() + 5 * 60_000;
+}
+function getLedgerWarnings(ledgerEvents) {
+    const diagnostics = ledgerEvents;
+    return Array.isArray(diagnostics.warnings)
+        ? diagnostics.warnings.filter((warning) => typeof warning === "string")
+        : [];
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/dist/package-version.d.ts

@@ -0,0 +1 @@
+export declare const MARTIN_MCP_PACKAGE_VERSION = "0.2.5";

package/dist/package-version.js

@@ -0,0 +1,3 @@
+// Keep this aligned with packages/mcp/package.json during version bumps so the
+// runtime does not depend on package.json being present in every hosted bundle.
+export const MARTIN_MCP_PACKAGE_VERSION = "0.2.5";

package/dist/prompts.d.ts

@@ -1,3 +1,13 @@
-import type { GetPromptResult, ListPromptsResult } from "@modelcontextprotocol/sdk/types.js";
-export declare function listMartinPrompts(): ListPromptsResult["prompts"];
-export declare function getMartinPrompt(name: string, args?: Record<string, unknown>): GetPromptResult;
+import type { GetPromptResult, Prompt } from "@modelcontextprotocol/sdk/types.js";
+export declare const MARTIN_PROMPTS: Prompt[];
+export interface MartinGetPromptInput {
+    name: string;
+    arguments?: Record<string, string>;
+    runsDir?: string;
+    workingDirectory?: string;
+    engine?: "claude" | "codex";
+}
+export declare function listMartinPrompts(): {
+    prompts: Prompt[];
+};
+export declare function getMartinPrompt(input: MartinGetPromptInput): Promise<GetPromptResult>;