efaimo 0.1.0

package/dist/clients/stateless.js

@@ -0,0 +1,121 @@
+import { RC_VERSION, rcMeta, postMessage, StdioSession } from "./rawprobe.js";
+/**
+ * 2026-07-28 introspection path: bare stateless requests, no initialize.
+ * The SDK client enforces the legacy handshake, so a stateless RC server makes
+ * client.connect() fail; this fallback lets weigh/check still work on exactly
+ * the servers the readiness rules are about. Returns undefined when the server
+ * does not answer the bare path either, so the caller can surface the original
+ * connect error.
+ */
+const MAX_PAGES = 20;
+export async function introspectStateless(target, opts = {}) {
+    // The legacy path already burned the caller's timeout once; keep this
+    // attempt tight so a genuinely dead server fails in bounded time.
+    const budget = Math.min(Math.max(opts.timeoutMs ?? 15000, 1), 15000);
+    try {
+        return target.kind === "stdio" ? await statelessStdio(target, budget) : await statelessHttp(target);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function statelessStdio(target, budget) {
+    const session = new StdioSession(target.command, target.args, target.env);
+    try {
+        const pages = [];
+        let rawFirst;
+        let cursor;
+        for (let page = 0; page < MAX_PAGES; page++) {
+            const params = cursor ? { ...rcMeta(), cursor } : rcMeta();
+            const reply = await session.request("tools/list", params, budget);
+            if (!reply.result) {
+                if (page === 0)
+                    return undefined; // no bare answer: not a stateless server
+                break;
+            }
+            if (page === 0)
+                rawFirst = reply.result;
+            pages.push(reply.result);
+            cursor = reply.result.nextCursor;
+            if (!cursor)
+                break;
+        }
+        const discover = await session.request("server/discover", rcMeta(), Math.min(budget, 10000));
+        return buildIntrospection(target.label, "stdio", undefined, pages, rawFirst, discover.result);
+    }
+    finally {
+        session.kill();
+    }
+}
+async function statelessHttp(target) {
+    const pages = [];
+    let rawFirst;
+    let cursor;
+    for (let page = 0; page < MAX_PAGES; page++) {
+        const params = cursor ? { ...rcMeta(), cursor } : rcMeta();
+        const reply = await postMessage(target.url, target.headers, { jsonrpc: "2.0", id: 100 + page, method: "tools/list", params }, undefined, RC_VERSION);
+        const result = reply.body?.result;
+        if (!result) {
+            if (page === 0)
+                return undefined;
+            break;
+        }
+        if (page === 0)
+            rawFirst = result;
+        pages.push(result);
+        cursor = result.nextCursor;
+        if (!cursor)
+            break;
+    }
+    const discover = await postMessage(target.url, target.headers, { jsonrpc: "2.0", id: 99, method: "server/discover", params: rcMeta() }, undefined, RC_VERSION).catch(() => undefined);
+    return buildIntrospection(target.label, "http", "streamable", pages, rawFirst, discover?.body?.result);
+}
+function buildIntrospection(label, transport, httpTransport, pages, rawFirst, discoverResult) {
+    const tools = [];
+    for (const page of pages) {
+        const list = Array.isArray(page.tools) ? (page.tools) : [];
+        for (const raw of list) {
+            const t = raw;
+            if (typeof t.name !== "string")
+                continue;
+            tools.push({
+                name: t.name,
+                title: typeof t.title === "string" ? t.title : undefined,
+                description: typeof t.description === "string" ? t.description : undefined,
+                inputSchema: t.inputSchema,
+                outputSchema: t.outputSchema,
+                annotations: t.annotations && typeof t.annotations === "object" ? t.annotations : undefined,
+            });
+        }
+    }
+    const discover = (discoverResult ?? undefined);
+    const notes = [
+        "introspected via bare stateless requests (2026-07-28 path); the server does not accept the legacy initialize handshake",
+    ];
+    if (!discover)
+        notes.push("server/discover did not answer, so server identity and capabilities are unknown");
+    const caps = discover?.capabilities;
+    if (caps && ("resources" in caps || "prompts" in caps)) {
+        notes.push("server declares resources/prompts; they are not enumerated on the stateless path yet");
+    }
+    return {
+        targetLabel: label,
+        transport,
+        httpTransport,
+        serverInfo: discover?.serverInfo
+            ? {
+                name: discover.serverInfo.name,
+                version: discover.serverInfo.version,
+                title: discover.serverInfo.title,
+            }
+            : undefined,
+        protocolVersion: discover?.supportedVersions?.includes(RC_VERSION) ? RC_VERSION : undefined,
+        instructions: discover?.instructions,
+        capabilities: caps,
+        tools,
+        resources: [],
+        prompts: [],
+        rawToolsListResult: rawFirst,
+        notes,
+    };
+}

package/dist/core/engine.d.ts

@@ -0,0 +1,6 @@
+import type { Finding, McpRuleContext } from "./types.js";
+/** Run a list of rules, isolating each: a broken rule must never break the audit. */
+export declare function runRules<Ctx>(rules: readonly {
+    check(ctx: Ctx): Finding[];
+}[], ctx: Ctx): Finding[];
+export declare function runMcpRules(ctx: McpRuleContext): Finding[];

package/dist/core/engine.js

@@ -0,0 +1,17 @@
+import { MCP_RULES } from "../rules/mcp/index.js";
+/** Run a list of rules, isolating each: a broken rule must never break the audit. */
+export function runRules(rules, ctx) {
+    const findings = [];
+    for (const rule of rules) {
+        try {
+            findings.push(...rule.check(ctx));
+        }
+        catch {
+            /* skip a throwing rule */
+        }
+    }
+    return findings;
+}
+export function runMcpRules(ctx) {
+    return runRules(MCP_RULES, ctx);
+}

package/dist/core/grade.d.ts

@@ -0,0 +1,8 @@
+import type { Finding, GradeInfo } from "./types.js";
+export declare function gradeFindings(findings: Finding[]): GradeInfo;
+export declare function countBySeverity(findings: Finding[]): {
+    error: number;
+    warn: number;
+    info: number;
+};
+export declare function sortFindings(findings: Finding[]): Finding[];

package/dist/core/grade.js

@@ -0,0 +1,19 @@
+const PENALTY = { error: 15, warn: 5, info: 1 };
+export function gradeFindings(findings) {
+    let score = 100;
+    for (const f of findings)
+        score -= PENALTY[f.severity] ?? 0;
+    score = Math.max(0, score);
+    const letter = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+    return { score, letter };
+}
+export function countBySeverity(findings) {
+    const counts = { error: 0, warn: 0, info: 0 };
+    for (const f of findings)
+        counts[f.severity]++;
+    return counts;
+}
+const SEV_ORDER = { error: 0, warn: 1, info: 2 };
+export function sortFindings(findings) {
+    return [...findings].sort((a, b) => SEV_ORDER[a.severity] - SEV_ORDER[b.severity] || a.ruleId.localeCompare(b.ruleId));
+}

package/dist/core/types.d.ts

@@ -0,0 +1,243 @@
+export type Severity = "error" | "warn" | "info";
+export interface Finding {
+    ruleId: string;
+    severity: Severity;
+    title: string;
+    message: string;
+    /** Tool name, skill name, or file path this finding is about. */
+    target?: string;
+    detail?: string;
+    fixHint?: string;
+}
+export type Surface = "mcp" | "skill";
+export interface ToolDef {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema?: unknown;
+    outputSchema?: unknown;
+    annotations?: Record<string, unknown>;
+}
+export interface ResourceDef {
+    uri: string;
+    name?: string;
+    description?: string;
+    mimeType?: string;
+}
+export interface PromptDef {
+    name: string;
+    title?: string;
+    description?: string;
+}
+export interface ServerIntrospection {
+    targetLabel: string;
+    transport: "stdio" | "http";
+    /** For http targets: which transport actually worked. */
+    httpTransport?: "streamable" | "sse-legacy";
+    serverInfo?: {
+        name?: string;
+        version?: string;
+        title?: string;
+    };
+    protocolVersion?: string;
+    instructions?: string;
+    capabilities?: Record<string, unknown>;
+    tools: ToolDef[];
+    resources: ResourceDef[];
+    prompts: PromptDef[];
+    /** Raw JSON-RPC result object of tools/list (first page), for spec-field checks. */
+    rawToolsListResult?: unknown;
+    /** Diagnostics collected while connecting (stderr snippets, fallbacks used). */
+    notes: string[];
+}
+export interface ProbeOutcome {
+    ok: boolean;
+    /** How a non-ok outcome failed: a JSON-RPC error, a timeout, or the process exiting. */
+    kind?: "ok" | "error" | "timeout" | "exit";
+    errorCode?: number;
+    errorMessage?: string;
+}
+export interface ProbeResults {
+    /** RC-style request without the legacy initialize handshake. */
+    bareToolsList?: ProbeOutcome | {
+        skipped: string;
+    };
+    /** server/discover support (SEP-2575). */
+    serverDiscover?: {
+        supported: boolean;
+        errorMessage?: string;
+    } | {
+        skipped: string;
+    };
+    /** Whether tools/list result carried the RC-required resultType field. */
+    resultTypePresent?: boolean;
+    /** Whether tools/list result carried both RC-required ttlMs and cacheScope (SEP-2549). */
+    cacheFieldsPresent?: boolean;
+    /** Same tool order across two fresh connections. */
+    toolsOrderDeterministic?: boolean;
+    /** Non-JSON noise observed on stdout before/between JSON-RPC messages (stdio only). */
+    stdoutNoise?: string;
+    httpAuth?: {
+        required: boolean;
+        wwwAuthenticate?: string;
+        resourceMetadataUrl?: string;
+        authorizationServer?: string;
+        dcrRegistrationEndpoint?: boolean;
+        cimdSupported?: boolean | undefined;
+    };
+    serverCard?: {
+        found: boolean;
+        url?: string;
+    } | {
+        skipped: string;
+    };
+}
+export interface RepoMatch {
+    category: "sampling" | "roots" | "logging" | "elicitation" | "sse-resume" | "session-state" | "subscribe" | "ping";
+    file: string;
+    line: number;
+    excerpt: string;
+}
+export interface RepoScan {
+    root: string;
+    sdk?: {
+        package: string;
+        range?: string;
+        language: "ts" | "python";
+        generation: "legacy" | "rc";
+    }[];
+    matches: RepoMatch[];
+    filesScanned: number;
+}
+export interface SerializedTokens {
+    rawJson: number;
+    claudeStyle: number;
+    openaiTools: number;
+}
+export interface ToolWeigh {
+    name: string;
+    tokens: SerializedTokens;
+    descriptionTokens: number;
+    schemaTokens: number;
+}
+export interface ServerWeighResult {
+    kind: "mcp";
+    label: string;
+    toolCount: number;
+    resourceCount: number;
+    promptCount: number;
+    perTool: ToolWeigh[];
+    totals: SerializedTokens;
+    /**
+     * Claude-style block framing: totals.claudeStyle minus the sum of per-tool
+     * lines, i.e. the <functions>/<function> wrapper the per-tool numbers
+     * exclude. perTool claudeStyle + this = totals.claudeStyle. Optional so
+     * pre-0.1.0 --diff baselines still parse.
+     */
+    framingTokens?: number;
+    instructionsTokens: number;
+    /** Exact count via Anthropic count_tokens API, when a key was provided. */
+    anthropicExactTotal?: number;
+    notes: string[];
+}
+export interface SkillWeighEntry {
+    name: string;
+    dir: string;
+    metadataTokens: number;
+    bodyTokens: number;
+    bodyLines: number;
+    refFileCount: number;
+    refFileTokens: number;
+}
+export interface SkillSetWeighResult {
+    kind: "skill";
+    label: string;
+    perSkill: SkillWeighEntry[];
+    totals: {
+        metadata: number;
+        body: number;
+        refFiles: number;
+    };
+    notes: string[];
+}
+export type WeighResult = ServerWeighResult | SkillSetWeighResult;
+export interface SkillInfo {
+    dir: string;
+    file: string;
+    name?: string;
+    description?: string;
+    frontmatter: Record<string, unknown>;
+    frontmatterRaw: string;
+    body: string;
+    bodyLines: number;
+    referencedPaths: {
+        raw: string;
+        resolved: string;
+        exists: boolean;
+        source: "link" | "code";
+    }[];
+    files: {
+        path: string;
+        bytes: number;
+    }[];
+    parseError?: string;
+}
+export interface SkillSet {
+    root: string;
+    skills: SkillInfo[];
+}
+export interface GradeInfo {
+    score: number;
+    letter: "A" | "B" | "C" | "D" | "F";
+}
+export interface CheckReport {
+    tool: "efaimo";
+    version: string;
+    surface: Surface;
+    target: string;
+    /** Graded findings: quality rules (and every skill rule). */
+    findings: Finding[];
+    counts: {
+        error: number;
+        warn: number;
+        info: number;
+    };
+    grade: GradeInfo;
+    /**
+     * MCP only: 2026-07-28 readiness findings (E101-E118), reported as an
+     * ungraded migration diff. The target spec is not final until 2026-07-28,
+     * so unreadiness is a to-do list, not a quality defect.
+     */
+    readiness?: {
+        findings: Finding[];
+        counts: {
+            error: number;
+            warn: number;
+            info: number;
+        };
+    };
+    notes: string[];
+}
+export interface McpRuleContext {
+    intro: ServerIntrospection;
+    probes?: ProbeResults;
+    repo?: RepoScan;
+    weigh?: ServerWeighResult;
+}
+export interface SkillRuleContext {
+    skill: SkillInfo;
+    set: SkillSet;
+    weigh?: SkillSetWeighResult;
+}
+export interface McpRule {
+    id: string;
+    title: string;
+    surface: "mcp";
+    check(ctx: McpRuleContext): Finding[];
+}
+export interface SkillRule {
+    id: string;
+    title: string;
+    surface: "skill";
+    check(ctx: SkillRuleContext): Finding[];
+}

package/dist/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./core/types.js";
+export { VERSION } from "./version.js";
+export { resolveTarget, type ResolvedTarget, type ResolveOptions } from "./targets/resolve.js";
+export { loadClientServers, SUPPORTED_CLIENTS } from "./targets/clientConfigs.js";
+export { introspectServer } from "./clients/introspect.js";
+export { weighServer, weighSkills } from "./weigh/weigh.js";
+export { diffServerWeigh, type WeighDiff } from "./weigh/diff.js";
+export { countTokens } from "./weigh/tokens.js";
+export { findSkills, parseSkillFile } from "./skills/parse.js";
+export { checkMcpTarget, checkMcpRepoOnly, checkSkillSet, type SkillReport, type CheckSkillResult } from "./check/check.js";
+export { parseScenario, runScenario, armSystems, type Scenario, type TestReport, type Runner, } from "./testing/harness.js";
+export { anthropicRunner } from "./testing/anthropicRunner.js";
+export { openaiRunner, providerForModel } from "./testing/openaiRunner.js";
+export { renderCheckPretty, renderSkillSetPretty, renderServerWeighPretty, renderSkillWeighPretty, renderDiffPretty, renderScenarioPlan, renderTestReportPretty, } from "./reporters/pretty.js";
+export { renderCheckMarkdown, renderSkillSetMarkdown, renderWeighMarkdown, renderDiffMarkdown, } from "./reporters/markdown.js";
+export { toJsonEnvelope } from "./reporters/json.js";

package/dist/index.js

@@ -0,0 +1,26 @@
+// Public library API. Kept deliberately small: only task-level entry points,
+// their types, and the renderers. Rule tables, the rule engine, injection
+// patterns, and grading internals are intentionally NOT exported so they stay
+// free to change without a breaking release. The CLI imports modules directly.
+export * from "./core/types.js";
+export { VERSION } from "./version.js";
+// Targets
+export { resolveTarget } from "./targets/resolve.js";
+export { loadClientServers, SUPPORTED_CLIENTS } from "./targets/clientConfigs.js";
+// Introspect + weigh
+export { introspectServer } from "./clients/introspect.js";
+export { weighServer, weighSkills } from "./weigh/weigh.js";
+export { diffServerWeigh } from "./weigh/diff.js";
+export { countTokens } from "./weigh/tokens.js";
+// Skills
+export { findSkills, parseSkillFile } from "./skills/parse.js";
+// Check (audit)
+export { checkMcpTarget, checkMcpRepoOnly, checkSkillSet } from "./check/check.js";
+// Test (skill A/B outcome harness)
+export { parseScenario, runScenario, armSystems, } from "./testing/harness.js";
+export { anthropicRunner } from "./testing/anthropicRunner.js";
+export { openaiRunner, providerForModel } from "./testing/openaiRunner.js";
+// Reporters (report -> string; stable value-in/string-out contract)
+export { renderCheckPretty, renderSkillSetPretty, renderServerWeighPretty, renderSkillWeighPretty, renderDiffPretty, renderScenarioPlan, renderTestReportPretty, } from "./reporters/pretty.js";
+export { renderCheckMarkdown, renderSkillSetMarkdown, renderWeighMarkdown, renderDiffMarkdown, } from "./reporters/markdown.js";
+export { toJsonEnvelope } from "./reporters/json.js";

package/dist/mcp/server.d.ts

@@ -0,0 +1,3 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function buildMcpServer(): Server;
+export declare function runMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,88 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { checkSkillSet } from "../check/check.js";
+import { weighSkills } from "../weigh/weigh.js";
+import { findSkills } from "../skills/parse.js";
+import { renderCheckMarkdown, renderSkillSetMarkdown, renderWeighMarkdown } from "../reporters/markdown.js";
+import { VERSION } from "../version.js";
+// Both tools only read local files, so the same hints apply: safe to call without
+// a confirmation, safe to repeat, and not reaching out to any external service.
+const READ_ONLY = { readOnlyHint: true, idempotentHint: true, openWorldHint: false };
+function requireString(args, key) {
+    const v = args[key];
+    if (typeof v !== "string" || v.trim() === "") {
+        throw new Error(`"${key}" is required and must be a non-empty string`);
+    }
+    return v;
+}
+const pathSchema = (what) => ({
+    type: "object",
+    properties: { path: { type: "string", description: what } },
+    required: ["path"],
+    additionalProperties: false,
+});
+const TOOLS = [
+    {
+        name: "efaimo_check_skill",
+        description: "Lint an Agent Skill, or a folder of skills, for spec compliance, trigger quality, " +
+            "context-window cost, reference integrity, and injection hygiene. Returns a grade from " +
+            "A to F and the findings. Read-only: reads files only.",
+        inputSchema: pathSchema("Path to a SKILL.md file or a directory that contains skills."),
+        annotations: READ_ONLY,
+        async run(args) {
+            const p = requireString(args, "path");
+            const res = await checkSkillSet(p, p);
+            if (res.perSkill.length === 1 && res.setFindings.length === 0) {
+                return renderCheckMarkdown(res.perSkill[0].report);
+            }
+            return renderSkillSetMarkdown(res);
+        },
+    },
+    {
+        name: "efaimo_weigh_skill",
+        description: "Measure the context-window token cost of an Agent Skill: the metadata loaded into every " +
+            "session and the body loaded when the skill triggers. Returns token counts per skill. " +
+            "Read-only: reads files only.",
+        inputSchema: pathSchema("Path to a SKILL.md file or a directory that contains skills."),
+        annotations: READ_ONLY,
+        async run(args) {
+            const p = requireString(args, "path");
+            const set = findSkills(p);
+            if (!set.skills.length)
+                throw new Error(`no SKILL.md found under "${p}"`);
+            return renderWeighMarkdown(await weighSkills(set));
+        },
+    },
+];
+export function buildMcpServer() {
+    const server = new Server({ name: "efaimo", version: VERSION }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: TOOLS.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+            annotations: t.annotations,
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const tool = TOOLS.find((t) => t.name === req.params.name);
+        if (!tool) {
+            return { content: [{ type: "text", text: `unknown tool: ${req.params.name}` }], isError: true };
+        }
+        try {
+            const text = await tool.run(req.params.arguments ?? {});
+            return { content: [{ type: "text", text }] };
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            return { content: [{ type: "text", text: `error: ${message}` }], isError: true };
+        }
+    });
+    return server;
+}
+export async function runMcpServer() {
+    const server = buildMcpServer();
+    await server.connect(new StdioServerTransport());
+    console.error(`efaimo mcp v${VERSION}: read-only skill tools ready on stdio`);
+}

package/dist/reporters/badge.d.ts

@@ -0,0 +1,12 @@
+import type { CheckReport, ServerWeighResult, SkillSetWeighResult } from "../core/types.js";
+/** Flat badge SVG in the shields style, self-contained (no external fonts). */
+export declare function makeBadgeSvg(label: string, message: string, color: string): string;
+export interface BadgeSpec {
+    label: string;
+    message: string;
+    color: string;
+}
+export declare function weighBadgeSpec(w: ServerWeighResult | SkillSetWeighResult): BadgeSpec;
+export declare function gradeBadgeSpec(report: CheckReport): BadgeSpec;
+/** shields.io endpoint JSON (https://shields.io/badges/endpoint-badge). */
+export declare function toShieldsEndpoint(spec: BadgeSpec): string;

package/dist/reporters/badge.js

@@ -0,0 +1,37 @@
+import { formatTokens } from "../util/misc.js";
+/** Flat badge SVG in the shields style, self-contained (no external fonts). */
+export function makeBadgeSvg(label, message, color) {
+    const charW = 6.5;
+    const pad = 10;
+    const lw = Math.round(label.length * charW + pad * 2);
+    const mw = Math.round(message.length * charW + pad * 2);
+    const w = lw + mw;
+    return `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="20" role="img" aria-label="${label}: ${message}">
+  <linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient>
+  <clipPath id="r"><rect width="${w}" height="20" rx="3" fill="#fff"/></clipPath>
+  <g clip-path="url(#r)">
+    <rect width="${lw}" height="20" fill="#555"/>
+    <rect x="${lw}" width="${mw}" height="20" fill="${color}"/>
+    <rect width="${w}" height="20" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+    <text x="${lw / 2}" y="14">${label}</text>
+    <text x="${lw + mw / 2}" y="14">${message}</text>
+  </g>
+</svg>
+`;
+}
+export function weighBadgeSpec(w) {
+    const total = w.kind === "mcp" ? w.totals.claudeStyle : w.totals.metadata + w.totals.body;
+    const color = total < 2000 ? "#3fb950" : total < 8000 ? "#d29922" : total < 20000 ? "#db6d28" : "#f85149";
+    return { label: "context cost", message: `${formatTokens(total)} tok (o200k)`, color };
+}
+export function gradeBadgeSpec(report) {
+    const g = report.grade;
+    const color = g.letter === "A" ? "#3fb950" : g.letter === "B" ? "#7bc043" : g.letter === "C" ? "#d29922" : g.letter === "D" ? "#db6d28" : "#f85149";
+    return { label: "efaimo", message: `${g.letter} (${g.score})`, color };
+}
+/** shields.io endpoint JSON (https://shields.io/badges/endpoint-badge). */
+export function toShieldsEndpoint(spec) {
+    return JSON.stringify({ schemaVersion: 1, label: spec.label, message: spec.message, color: spec.color.replace("#", "") }, null, 2);
+}

package/dist/reporters/json.d.ts

@@ -0,0 +1 @@
+export declare function toJsonEnvelope(kind: "check" | "weigh" | "test", data: unknown): string;

package/dist/reporters/json.js

@@ -0,0 +1,10 @@
+import { VERSION } from "../version.js";
+export function toJsonEnvelope(kind, data) {
+    return JSON.stringify({
+        tool: "efaimo",
+        version: VERSION,
+        kind,
+        generatedAt: new Date().toISOString(),
+        data,
+    }, null, 2);
+}

package/dist/reporters/markdown.d.ts

@@ -0,0 +1,7 @@
+import type { CheckReport, ServerWeighResult, SkillSetWeighResult } from "../core/types.js";
+import type { CheckSkillResult } from "../check/check.js";
+import type { WeighDiff } from "../weigh/diff.js";
+export declare function renderCheckMarkdown(report: CheckReport): string;
+export declare function renderSkillSetMarkdown(res: CheckSkillResult): string;
+export declare function renderWeighMarkdown(w: ServerWeighResult | SkillSetWeighResult): string;
+export declare function renderDiffMarkdown(d: WeighDiff): string;