kimi-plugin-cc 2.4.4 → 2.5.1

package/plugins/kimi-dsh/dist/render.js

@@ -0,0 +1,177 @@
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { getManagedCommandConfig } from "./commands/registry.js";
+import { RuntimeError } from "./errors.js";
+import { parseReviewGateOutput } from "./schemas/review-gate-output.js";
+const EMPTY_SUMMARY_FALLBACK = "Rescue did not return a final message.";
+export async function writeArtifact(paths, job, markdown) {
+    const artifactPath = path.join(paths.artifactsDir, `${job.command_type}-${job.job_id}.md`);
+    await writeFile(artifactPath, markdown.endsWith("\n") ? markdown : `${markdown}\n`, "utf8");
+    return artifactPath;
+}
+export async function readArtifact(artifactPath) {
+    return readFile(artifactPath, "utf8");
+}
+export function renderManagedJobOutput(job, finalText) {
+    assertOutputModeConsistency(job.command_type, finalText);
+    switch (job.command_type) {
+        case "ask": {
+            const trimmed = finalText.trim();
+            if (!trimmed) {
+                throw new RuntimeError("ASK_EMPTY_OUTPUT", "ask returned an empty final response.", "ask.prompt");
+            }
+            return {
+                output: trimmed,
+                rendered: renderAskArtifact(trimmed),
+                summary: trimmed.slice(0, 160),
+                error: null,
+            };
+        }
+        case "review":
+        case "challenge": {
+            const trimmed = finalText.trim();
+            if (!trimmed) {
+                throw new RuntimeError(job.command_type === "challenge" ? "CHALLENGE_EMPTY_OUTPUT" : "REVIEW_EMPTY_OUTPUT", `${job.command_type} returned an empty final response.`, `${job.command_type}.prompt`);
+            }
+            return {
+                output: trimmed,
+                rendered: renderReviewArtifact(job, trimmed),
+                summary: firstMeaningfulLine(trimmed),
+                error: null,
+            };
+        }
+        case "review_gate": {
+            const output = parseReviewGateOutput(finalText.trim());
+            return {
+                output,
+                rendered: renderReviewGateArtifact(job, output),
+                summary: output.summary,
+                error: null,
+            };
+        }
+        case "rescue": {
+            const trimmed = finalText.trim();
+            if (!trimmed) {
+                throw new RuntimeError("RESCUE_EMPTY_OUTPUT", "Rescue returned empty output.", "rescue.runtime");
+            }
+            return {
+                output: finalText,
+                rendered: renderRescueArtifact(finalText),
+                summary: firstMeaningfulLine(finalText),
+                error: null,
+            };
+        }
+        default:
+            return assertNever(job.command_type);
+    }
+}
+export function assertOutputModeConsistency(commandType, finalText) {
+    const { outputMode } = getManagedCommandConfig(commandType);
+    switch (outputMode) {
+        case "passthrough":
+            return;
+        case "parsed":
+            try {
+                JSON.parse(finalText);
+            }
+            catch (error) {
+                throw new RuntimeError(`${commandType.toUpperCase()}_PARSE_FAILED`, `${commandType} is configured for parsed output but returned malformed JSON: ${error.message}`, `${commandType}.parse`, error instanceof Error ? { cause: error } : undefined);
+            }
+            return;
+        default:
+            return assertNever(outputMode);
+    }
+}
+export function renderAskArtifact(output) {
+    return output.trim();
+}
+export function renderReviewArtifact(job, output) {
+    const header = [
+        `# ${job.command_type === "challenge" ? "Challenge" : "Review"} Result`,
+        "",
+        `- Job: ${job.job_id}`,
+        ...(job.kimi_session_id ? [`- Kimi session: ${job.kimi_session_id}`] : []),
+    ].join("\n");
+    // Blank line between header and body, plus trailing newline so the rendered
+    // string is well-formed even before writeArtifact's newline normalization.
+    return `${header}\n\n${output.trim()}\n`;
+}
+export function renderRescueArtifact(rawOutput) {
+    return rawOutput.endsWith("\n") ? rawOutput : `${rawOutput}\n`;
+}
+export function firstMeaningfulLine(text, fallback = EMPTY_SUMMARY_FALLBACK) {
+    const line = String(text ?? "")
+        .split(/\r?\n/)
+        .map((value) => value.trim())
+        .find(Boolean);
+    return line ?? fallback;
+}
+export function renderReviewGateArtifact(job, output) {
+    const lines = [
+        "# Review Gate Result",
+        "",
+        `- Job: ${job.job_id}`,
+        `- Decision: ${output.decision}`,
+        `- Confidence: ${output.confidence}`,
+        `- Summary: ${output.summary}`,
+        ...(job.kimi_session_id ? [`- Kimi session: ${job.kimi_session_id}`] : []),
+    ];
+    if (output.issues.length === 0) {
+        lines.push("", "No issues.");
+        return `${lines.join("\n")}\n`;
+    }
+    lines.push("", "## Issues");
+    for (const issue of output.issues) {
+        lines.push("", `### ${issue.title}`, `- Severity: ${issue.severity}`, issue.body);
+    }
+    return `${lines.join("\n")}\n`;
+}
+export function formatBudgetDuration(ms) {
+    if (ms % 3_600_000 === 0)
+        return `${ms / 3_600_000}h`;
+    if (ms % 60_000 === 0)
+        return `${ms / 60_000}m`;
+    if (ms % 1_000 === 0)
+        return `${ms / 1_000}s`;
+    return `${ms}ms`;
+}
+export function renderTerminalJobArtifact(job, partialOutput) {
+    const lines = [
+        `# ${capitalize(job.status)} Job`,
+        "",
+        `- Job: ${job.job_id}`,
+        `- Command: ${job.command_type}`,
+        `- Status: ${job.status}`,
+        `- Summary: ${job.summary}`,
+        ...(job.kimi_session_id ? [`- Kimi session: ${job.kimi_session_id}`] : []),
+    ];
+    if (job.error) {
+        lines.push("", "## Error", `- Code: ${job.error.code}`, `- Stage: ${job.error.stage}`, job.error.message);
+        // Structured context (e.g. `drift_axis` / `retryable_after_setup`) so a
+        // caller reading the rendered artifact — not just `result --json` — can
+        // branch on it. Deterministic key order keeps artifacts stable.
+        const details = job.error.details;
+        if (details !== undefined && Object.keys(details).length > 0) {
+            lines.push("", "### Details");
+            for (const key of Object.keys(details).sort()) {
+                lines.push(`- ${key}: ${JSON.stringify(details[key])}`);
+            }
+        }
+    }
+    if (partialOutput) {
+        lines.push("", `## Partial output (budget exhausted after ${formatBudgetDuration(partialOutput.budgetMs)} — NOT a final answer)`, "", partialOutput.text.trim()
+            ? partialOutput.text
+            : partialOutput.recordCount === 0
+                ? "No stream records arrived before the budget expired (the model had not produced any output yet)."
+                : partialOutput.toolCalls
+                    ? "No assistant prose was emitted before the budget (tool calls only)."
+                    : "No assistant prose was emitted before the budget.");
+    }
+    return lines.join("\n");
+}
+function capitalize(value) {
+    return value.slice(0, 1).toUpperCase() + value.slice(1);
+}
+function assertNever(value) {
+    throw new RuntimeError("UNSUPPORTED_COMMAND_TYPE", `Unsupported command type for rendering: ${String(value)}`, "render");
+}