@martinloop/mcp 0.5.1 → 0.5.5

package/dist/vendor/presentation/table.js

@@ -0,0 +1,47 @@
+import { padRightVisible, truncateVisible, visibleWidth } from "./text.js";
+function columnWidth(rows, column) {
+    const contentWidth = Math.max(visibleWidth(column.header), ...rows.map((row) => visibleWidth(column.value(row))), column.minWidth ?? 0);
+    return Math.min(contentWidth, column.maxWidth ?? Number.POSITIVE_INFINITY);
+}
+function fitWidths(naturalWidths, columns, availableWidth) {
+    const widths = [...naturalWidths];
+    const floors = columns.map((column, index) => Math.min(widths[index] ?? 0, Math.max(4, visibleWidth(column.header))));
+    while (widths.reduce((sum, width) => sum + width, 0) > availableWidth) {
+        let candidate = -1;
+        let largestSlack = 0;
+        for (let index = 0; index < widths.length; index += 1) {
+            const slack = (widths[index] ?? 0) - (floors[index] ?? 0);
+            if (slack > largestSlack) {
+                candidate = index;
+                largestSlack = slack;
+            }
+        }
+        if (candidate < 0) {
+            break;
+        }
+        widths[candidate] = (widths[candidate] ?? 0) - 1;
+    }
+    return widths;
+}
+export function renderTable(rows, columns, options = {}) {
+    if (columns.length === 0) {
+        return "";
+    }
+    const normalizedOptions = typeof options === "number" ? { width: options } : options;
+    const separator = normalizedOptions.separator ?? " │ ";
+    const naturalWidths = columns.map((column) => columnWidth(rows, column));
+    const separatorWidth = visibleWidth(separator) * (columns.length - 1);
+    const availableWidth = normalizedOptions.width === undefined
+        ? Number.POSITIVE_INFINITY
+        : Math.max(columns.length * 4, normalizedOptions.width - separatorWidth);
+    const widths = Number.isFinite(availableWidth)
+        ? fitWidths(naturalWidths, columns, availableWidth)
+        : naturalWidths;
+    const renderCells = (cells) => cells
+        .map((cell, index) => padRightVisible(truncateVisible(cell, widths[index] ?? 0), widths[index] ?? 0))
+        .join(separator);
+    const header = renderCells(columns.map((column) => column.header));
+    const divider = widths.map((width) => "─".repeat(width)).join("─┼─");
+    const body = rows.map((row) => renderCells(columns.map((column) => column.value(row))));
+    return [header, divider, ...body].join("\n");
+}

package/dist/vendor/presentation/text.d.ts

@@ -0,0 +1,6 @@
+export declare function stripAnsi(value: string): string;
+export declare function visibleWidth(value: string): number;
+export declare function padRightVisible(value: string, width: number): string;
+export declare function truncateVisible(value: string, width: number): string;
+export declare function terminalWidth(width?: number): number;
+export declare function horizontalRule(width: number, character?: string): string;

package/dist/vendor/presentation/text.js

@@ -0,0 +1,30 @@
+const csiPattern = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+const oscPattern = /\u001B\][^\u0007]*(?:\u0007|\u001B\\)/g;
+export function stripAnsi(value) {
+    return value.replace(oscPattern, "").replace(csiPattern, "");
+}
+export function visibleWidth(value) {
+    return Array.from(stripAnsi(value)).length;
+}
+export function padRightVisible(value, width) {
+    return value + " ".repeat(Math.max(0, width - visibleWidth(value)));
+}
+export function truncateVisible(value, width) {
+    if (width <= 0) {
+        return "";
+    }
+    if (visibleWidth(value) <= width) {
+        return value;
+    }
+    if (width === 1) {
+        return "…";
+    }
+    return Array.from(stripAnsi(value)).slice(0, width - 1).join("") + "…";
+}
+export function terminalWidth(width) {
+    const resolved = width ?? process.stdout.columns ?? 80;
+    return Math.max(40, Math.min(160, Math.floor(resolved)));
+}
+export function horizontalRule(width, character = "─") {
+    return character.repeat(Math.max(0, width));
+}

package/dist/vendor/presentation/theme.d.ts

@@ -0,0 +1,31 @@
+export type MartinTone = "brand" | "success" | "danger" | "warning" | "info" | "muted" | "plain";
+export interface RenderEnvironment {
+    readonly color?: "auto" | "always" | "never";
+    readonly isTty?: boolean;
+    readonly noColor?: boolean;
+    readonly term?: string;
+    readonly colorDepth?: number;
+}
+export declare const palette: {
+    readonly brand: readonly [107, 85, 198];
+    readonly success: readonly [94, 225, 115];
+    readonly danger: readonly [255, 93, 93];
+    readonly warning: readonly [244, 200, 74];
+    readonly info: readonly [85, 199, 243];
+    readonly muted: readonly [148, 163, 184];
+    readonly plain: readonly [248, 250, 252];
+};
+declare function rgb(red: number, green: number, blue: number): string;
+export declare function resolveColorEnabled(env?: RenderEnvironment): boolean;
+export declare function paint(value: string, tone: MartinTone, env?: RenderEnvironment): string;
+export declare function bold(value: string, env?: RenderEnvironment): string;
+export declare function dim(value: string, env?: RenderEnvironment): string;
+export declare const terminalAnsi: {
+    readonly reset: string;
+    readonly hideCursor: string;
+    readonly showCursor: string;
+    readonly eraseLine: string;
+    readonly cursorHome: "\r";
+    readonly rgb: typeof rgb;
+};
+export {};

package/dist/vendor/presentation/theme.js

@@ -0,0 +1,82 @@
+const escape = "\u001B[";
+const basic = {
+    reset: escape + "0m",
+    bold: escape + "1m",
+    dim: escape + "2m",
+    brand: escape + "35m",
+    success: escape + "32m",
+    danger: escape + "31m",
+    warning: escape + "33m",
+    info: escape + "36m",
+    muted: escape + "90m",
+    plain: "",
+};
+export const palette = {
+    brand: [107, 85, 198],
+    success: [94, 225, 115],
+    danger: [255, 93, 93],
+    warning: [244, 200, 74],
+    info: [85, 199, 243],
+    muted: [148, 163, 184],
+    plain: [248, 250, 252],
+};
+function rgb(red, green, blue) {
+    return escape + "38;2;" + red + ";" + green + ";" + blue + "m";
+}
+function resolveColorDepth() {
+    const stream = process.stdout;
+    try {
+        return stream.getColorDepth?.() ?? 1;
+    }
+    catch {
+        return 1;
+    }
+}
+export function resolveColorEnabled(env = {}) {
+    if (env.color === "always") {
+        return true;
+    }
+    if (env.color === "never") {
+        return false;
+    }
+    const noColor = env.noColor ?? Object.prototype.hasOwnProperty.call(process.env, "NO_COLOR");
+    if (noColor) {
+        return false;
+    }
+    const term = env.term ?? process.env.TERM;
+    if (term === "dumb") {
+        return false;
+    }
+    return env.isTty ?? process.stdout.isTTY === true;
+}
+function toneCode(tone, env) {
+    if (tone === "plain") {
+        return "";
+    }
+    const depth = env.colorDepth ?? resolveColorDepth();
+    if (depth >= 24) {
+        const [red, green, blue] = palette[tone];
+        return rgb(red, green, blue);
+    }
+    return basic[tone];
+}
+export function paint(value, tone, env = {}) {
+    if (!resolveColorEnabled(env) || tone === "plain") {
+        return value;
+    }
+    return toneCode(tone, env) + value + basic.reset;
+}
+export function bold(value, env = {}) {
+    return resolveColorEnabled(env) ? basic.bold + value + basic.reset : value;
+}
+export function dim(value, env = {}) {
+    return resolveColorEnabled(env) ? basic.dim + value + basic.reset : value;
+}
+export const terminalAnsi = {
+    reset: basic.reset,
+    hideCursor: escape + "?25l",
+    showCursor: escape + "?25h",
+    eraseLine: escape + "2K",
+    cursorHome: "\r",
+    rgb,
+};

package/dist/vendor/presentation/verified-handoff.d.ts

@@ -0,0 +1,15 @@
+import type { VerifiedHandoffV1 } from "../contracts/index.js";
+import { type RenderEnvironment } from "./theme.js";
+export interface VerifiedHandoffRenderOptions {
+    readonly width?: number;
+    readonly environment?: RenderEnvironment;
+}
+export declare function renderVerifiedHandoff(handoff: VerifiedHandoffV1, options?: VerifiedHandoffRenderOptions): string;
+/**
+ * Renders a VerifiedHandoffV1 as plain Markdown (no ANSI).
+ *
+ * CRITICAL: replicates the exact effectiveOutcome trust-authority check from
+ * renderVerifiedHandoff so that CLI and MCP surfaces always agree on
+ * VERIFIED / NEEDS REVIEW / STOPPED for the same input.
+ */
+export declare function renderVerifiedHandoffMarkdown(handoff: VerifiedHandoffV1, options?: VerifiedHandoffRenderOptions): string;

package/dist/vendor/presentation/verified-handoff.js

@@ -0,0 +1,151 @@
+import { renderTable } from "./table.js";
+import { horizontalRule, terminalWidth, truncateVisible } from "./text.js";
+import { bold, paint, } from "./theme.js";
+function outcomeTone(outcome) {
+    if (outcome === "VERIFIED") {
+        return "success";
+    }
+    if (outcome === "STOPPED") {
+        return "danger";
+    }
+    return "warning";
+}
+function evidenceTone(status) {
+    if (status === "PASSED") {
+        return "success";
+    }
+    if (status === "FAILED" || status === "CONTRADICTED") {
+        return "danger";
+    }
+    return "warning";
+}
+function humanize(value) {
+    return value.replaceAll("_", " ").toLowerCase();
+}
+function formatCost(usd, provenance) {
+    if (provenance === "unavailable") {
+        return "unavailable";
+    }
+    const amount = "$" + usd.toFixed(2);
+    if (provenance === "actual") {
+        return amount + " provider-settled actual";
+    }
+    if (provenance === "calculated") {
+        return amount + " calculated from observed usage";
+    }
+    return amount + " estimated";
+}
+function checkSymbol(status) {
+    if (status === "PASSED") {
+        return "✓";
+    }
+    if (status === "FAILED" || status === "CONTRADICTED") {
+        return "✕";
+    }
+    return "•";
+}
+/**
+ * Single source of truth for the trust-authority outcome calculation.
+ * Both terminal and Markdown renderers call this — never duplicate.
+ * Fail-closed: omitting executionMode or governanceClaimEligible downgrades
+ * VERIFIED → NEEDS_REVIEW, so legacy handoffs cannot claim full governance.
+ */
+function resolveHandoffAuthority(handoff) {
+    const executionMode = handoff.executionMode ?? "simulated";
+    const governanceClaimEligible = executionMode === "governed" && handoff.governanceClaimEligible === true;
+    const effectiveOutcome = handoff.outcome === "VERIFIED" && !governanceClaimEligible
+        ? "NEEDS_REVIEW"
+        : handoff.outcome;
+    return { executionMode, governanceClaimEligible, effectiveOutcome };
+}
+export function renderVerifiedHandoff(handoff, options = {}) {
+    const environment = options.environment ?? {};
+    const width = terminalWidth(options.width);
+    const bounded = (line) => truncateVisible(line, width);
+    const { executionMode, governanceClaimEligible, effectiveOutcome } = resolveHandoffAuthority(handoff);
+    const outcome = effectiveOutcome.replace("_", " ");
+    const checks = handoff.verification.checks.map((check) => ({
+        check: check.command,
+        status: paint(checkSymbol(check.status) + " " + check.status.replace("_", " "), evidenceTone(check.status), environment),
+    }));
+    const lines = [
+        horizontalRule(width, "━"),
+        bold("MARTINLOOP VERIFIED HANDOFF", environment) +
+            " — " +
+            paint(outcome, outcomeTone(effectiveOutcome), environment),
+        horizontalRule(width, "━"),
+        "",
+        bounded("Task".padEnd(20) + handoff.task.objective),
+        bounded("Run".padEnd(20) + handoff.loopId),
+        bounded("Execution Mode".padEnd(20) + executionMode.replaceAll("_", " ")),
+        bounded("Governed Claim".padEnd(20) + (governanceClaimEligible ? "ELIGIBLE" : "INELIGIBLE")),
+        bounded("Verification".padEnd(20) + handoff.verification.status.replace("_", " ")),
+        bounded("Scope".padEnd(20) + handoff.scope.status.replaceAll("_", " ")),
+        bounded("Test Integrity".padEnd(20) + handoff.testIntegrity.verdict),
+        bounded("Receipt Integrity".padEnd(20) + handoff.receiptIntegrity.state),
+        bounded("Attempts".padEnd(20) + handoff.usage.attempts),
+        bounded("Cost".padEnd(20) +
+            formatCost(handoff.usage.actualUsd, handoff.usage.costProvenance)),
+    ];
+    if (checks.length > 0) {
+        lines.push("", bold("VERIFICATION EVIDENCE", environment), renderTable(checks, [
+            { header: "CHECK", value: (row) => row.check, minWidth: 24 },
+            { header: "STATUS", value: (row) => row.status, minWidth: 18 },
+        ], width));
+    }
+    if (handoff.stopReason) {
+        lines.push("", bold("STOP REASON", environment), bounded("  " + paint(humanize(handoff.stopReason), "danger", environment)));
+    }
+    lines.push("", bold("UNRESOLVED", environment));
+    if (handoff.unresolvedWork.length === 0) {
+        lines.push("  None recorded.");
+    }
+    else {
+        lines.push(...handoff.unresolvedWork.map((item) => bounded("  - " + item)));
+    }
+    lines.push("", bold("RECOVERY", environment), bounded("  " + handoff.recovery.summary), "", bold("NEXT", environment), bounded("  " + handoff.nextAction), horizontalRule(width, "━"));
+    return lines.map(bounded).join("\n");
+}
+/**
+ * Renders a VerifiedHandoffV1 as plain Markdown (no ANSI).
+ *
+ * CRITICAL: replicates the exact effectiveOutcome trust-authority check from
+ * renderVerifiedHandoff so that CLI and MCP surfaces always agree on
+ * VERIFIED / NEEDS REVIEW / STOPPED for the same input.
+ */
+export function renderVerifiedHandoffMarkdown(handoff, options = {}) {
+    void options; // width/environment unused in plain Markdown
+    const { executionMode, governanceClaimEligible, effectiveOutcome } = resolveHandoffAuthority(handoff);
+    const outcome = effectiveOutcome.replace("_", " ");
+    const lines = [
+        `## MartinLoop Verified Handoff — ${outcome}`,
+        "",
+        "| Field | Value |",
+        "|-------|-------|",
+        `| Task | ${handoff.task.objective} |`,
+        `| Run | ${handoff.loopId} |`,
+        `| Execution Mode | ${executionMode.replaceAll("_", " ")} |`,
+        `| Governed Claim | ${governanceClaimEligible ? "ELIGIBLE" : "INELIGIBLE"} |`,
+        `| Verification | ${handoff.verification.status.replace("_", " ")} |`,
+        `| Scope | ${handoff.scope.status.replaceAll("_", " ")} |`,
+        `| Test Integrity | ${handoff.testIntegrity.verdict} |`,
+        `| Receipt Integrity | ${handoff.receiptIntegrity.state} |`,
+        `| Attempts | ${handoff.usage.attempts} |`,
+        `| Cost | ${formatCost(handoff.usage.actualUsd, handoff.usage.costProvenance)} |`,
+    ];
+    if (handoff.verification.checks.length > 0) {
+        lines.push("", "### Verification Evidence", "", "| Check | Status |", "|-------|--------|", ...handoff.verification.checks.map((check) => `| ${check.command} | ${checkSymbol(check.status)} ${check.status.replace("_", " ")} |`));
+    }
+    if (handoff.stopReason) {
+        lines.push("", "### Stop Reason", "", handoff.stopReason.replaceAll("_", " ").toLowerCase());
+    }
+    lines.push("", "### Unresolved");
+    if (handoff.unresolvedWork.length === 0) {
+        lines.push("", "None recorded.");
+    }
+    else {
+        lines.push("", ...handoff.unresolvedWork.map((item) => `- ${item}`));
+    }
+    lines.push("", "### Recovery", "", handoff.recovery.summary, "", "### Next", "", handoff.nextAction);
+    return lines.join("\n");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@martinloop/mcp",
-  "version": "0.5.1",
+  "version": "0.5.5",
   "mcpName": "io.github.Keesan12/martin-loop",
   "private": false,
   "type": "module",
@@ -75,6 +75,7 @@
   },
   "devDependencies": {
     "@anthropic-ai/mcpb": "2.1.2",
-    "@martin/contracts": "workspace:*"
+    "@martin/contracts": "workspace:*",
+    "@martin/presentation": "workspace:*"
   }
 }

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/Keesan12/martin-loop",
     "source": "github"
   },
-  "version": "0.5.1",
+  "version": "0.5.5",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@martinloop/mcp",
-      "version": "0.5.1",
+      "version": "0.5.5",
       "transport": {
         "type": "stdio"
       }