import type { TUI } from "@earendil-works/pi-tui";
import stripAnsi from "strip-ansi";
import { beforeAll, describe, expect, test, vi } from "vitest";
import {
COMPACTION_OUTCOME_CUSTOM_TYPE,
type CustomMessage,
convertToLlm,
createCompactionOutcomeMessage,
createManualContinuationMessage,
createSessionSlashCommandMessage,
createSessionSlashCommandResultMessage,
isCompactionOutcomeMessage,
isSessionSlashCommandMessage,
isSessionSlashCommandResultMessage,
MANUAL_CONTINUATION_CUSTOM_TYPE,
MANUAL_CONTINUATION_PROMPT,
SESSION_SLASH_COMMAND_CUSTOM_TYPE,
SESSION_SLASH_COMMAND_RESULT_CUSTOM_TYPE,
} from "../src/core/messages.js";
import { parseSessionSlashCommand } from "../src/core/slash-commands.js";
import { CompactionOutcomeMessageComponent } from "../src/modes/interactive/components/compaction-outcome-message.js";
import { buildConversationComponents } from "../src/modes/interactive/components/conversation-components.js";
import { SlashCommandMessageComponent } from "../src/modes/interactive/components/slash-command-message.js";
import { SlashCommandResultMessageComponent } from "../src/modes/interactive/components/slash-command-result-message.js";
import { initTheme } from "../src/modes/interactive/theme/theme.js";
const componentOptions = {
ui: { requestRender: vi.fn() } as unknown as TUI,
cwd: "/tmp",
toolOptions: {},
getToolDefinition: () => undefined,
};
function customMessage(customType: string, details?: unknown): CustomMessage {
return {
role: "custom",
customType,
content: "durable display text",
display: true,
details,
timestamp: 123,
};
}
describe("session command messages", () => {
beforeAll(() => {
initTheme("dark");
});
test("creates and recognizes typed command and result messages", () => {
const command = parseSessionSlashCommand("/goal\tship it");
expect(command).toBeDefined();
const commandMessage = createSessionSlashCommandMessage(command!, { commandEntryId: "entry-1" }, true, 123);
const attemptedOverwrite = Reflect.apply(createSessionSlashCommandMessage, undefined, [
command!,
{ command: { name: "compact", args: "", text: "/compact" } },
]);
const resultMessage = createSessionSlashCommandResultMessage(
"Goal unavailable",
{
command: command!,
success: false,
severity: "warning",
error: "Goal unavailable",
commandEntryId: "entry-1",
},
true,
124,
);
expect(commandMessage).toEqual({
role: "custom",
customType: SESSION_SLASH_COMMAND_CUSTOM_TYPE,
content: "/goal\tship it",
display: true,
details: {
command: { name: "goal", args: "ship it", text: "/goal\tship it" },
commandEntryId: "entry-1",
},
timestamp: 123,
});
expect(isSessionSlashCommandMessage(commandMessage)).toBe(true);
expect(attemptedOverwrite.details.command).toEqual(command);
expect(isSessionSlashCommandResultMessage(resultMessage)).toBe(true);
expect(
isSessionSlashCommandResultMessage({
...resultMessage,
details: { ...resultMessage.details, command: { ...command!, text: "/compact" } },
}),
).toBe(false);
expect(
isSessionSlashCommandResultMessage({
...resultMessage,
details: { ...resultMessage.details, severity: "fatal" },
}),
).toBe(false);
expect(
isSessionSlashCommandResultMessage({ ...resultMessage, details: { ...resultMessage.details, success: "no" } }),
).toBe(false);
expect(
isSessionSlashCommandResultMessage({
...resultMessage,
details: { ...resultMessage.details, commandEntryId: "" },
}),
).toBe(false);
expect(
isSessionSlashCommandMessage({
...commandMessage,
details: { command: { ...commandMessage.details.command, name: "compact" } },
}),
).toBe(false);
expect(
isSessionSlashCommandMessage({
...commandMessage,
details: { command: { ...commandMessage.details.command, args: "other" } },
}),
).toBe(false);
expect(
isSessionSlashCommandMessage({
...commandMessage,
details: { command: { ...commandMessage.details.command, text: "/goal other" } },
}),
).toBe(false);
expect(isSessionSlashCommandMessage({ ...commandMessage, timestamp: Number.NaN })).toBe(false);
expect(
isSessionSlashCommandMessage({
...commandMessage,
details: { ...commandMessage.details, commandEntryId: "" },
}),
).toBe(false);
});
test("creates and validates typed compaction outcome messages", () => {
const outcome = createCompactionOutcomeMessage(
"Requested compaction skipped: too short",
{ reason: "requested", outcome: "skipped" },
true,
123,
);
expect(outcome).toEqual({
role: "custom",
customType: COMPACTION_OUTCOME_CUSTOM_TYPE,
content: "Requested compaction skipped: too short",
display: true,
details: { reason: "requested", outcome: "skipped" },
timestamp: 123,
});
expect(isCompactionOutcomeMessage(outcome)).toBe(true);
expect(isCompactionOutcomeMessage({ ...outcome, details: { reason: "manual", outcome: "skipped" } })).toBe(false);
expect(isCompactionOutcomeMessage({ ...outcome, details: { reason: "requested", outcome: "success" } })).toBe(
false,
);
expect(isCompactionOutcomeMessage({ ...outcome, timestamp: Number.NaN })).toBe(false);
});
test("excludes durable command, result, and compaction outcome entries from LLM context", () => {
const command = parseSessionSlashCommand("/compact");
expect(command).toBeDefined();
expect(
convertToLlm([
createSessionSlashCommandMessage(command!),
createSessionSlashCommandResultMessage("Skipped", {
command: command!,
success: false,
severity: "warning",
}),
customMessage(SESSION_SLASH_COMMAND_CUSTOM_TYPE),
customMessage(SESSION_SLASH_COMMAND_RESULT_CUSTOM_TYPE),
customMessage(COMPACTION_OUTCOME_CUSTOM_TYPE),
]),
).toEqual([]);
});
test("converts manual continuation into hidden model context", () => {
const message = createManualContinuationMessage(123);
expect(message).toEqual({
role: "custom",
customType: MANUAL_CONTINUATION_CUSTOM_TYPE,
content: MANUAL_CONTINUATION_PROMPT,
display: false,
timestamp: 123,
});
expect(convertToLlm([message])).toEqual([
{
role: "user",
content: [{ type: "text", text: MANUAL_CONTINUATION_PROMPT }],
timestamp: 123,
},
]);
expect(buildConversationComponents([message], componentOptions)).toEqual([]);
});
test("continues to include ordinary custom messages", () => {
expect(convertToLlm([customMessage("extension_notice")])).toMatchObject([
{ role: "user", content: [{ type: "text", text: "durable display text" }] },
]);
});
test("dispatches valid messages and safely diagnoses malformed reserved entries", () => {
const command = parseSessionSlashCommand("/compact focus");
expect(command).toBeDefined();
const components = buildConversationComponents(
[
createSessionSlashCommandMessage(command!),
createSessionSlashCommandResultMessage("Compaction skipped", {
command: command!,
success: false,
severity: "warning",
}),
createCompactionOutcomeMessage("Auto-compaction skipped", {
reason: "threshold",
outcome: "skipped",
}),
customMessage(SESSION_SLASH_COMMAND_CUSTOM_TYPE, { command: "not-a-command" }),
customMessage(SESSION_SLASH_COMMAND_RESULT_CUSTOM_TYPE, { severity: "fatal" }),
customMessage(COMPACTION_OUTCOME_CUSTOM_TYPE, { reason: "manual", outcome: "skipped" }),
],
componentOptions,
);
const output = stripAnsi(components.flatMap((component) => component.render(80)).join("\n"));
expect(components[0]).toBeInstanceOf(SlashCommandMessageComponent);
expect(components[1]).toBeInstanceOf(SlashCommandResultMessageComponent);
expect(components[2]).toBeInstanceOf(CompactionOutcomeMessageComponent);
expect(output).toContain("Compaction skipped");
expect(output).toContain("Auto-compaction skipped");
expect(output.match(/\[Malformed session command message\]/g)).toHaveLength(2);
expect(output).toContain("[Malformed compaction outcome message]");
expect(output).not.toContain("durable display text");
});
});