@litfamily/litcodex 1.0.0

package/marketplace/plugins/litcodex/components/auto-update/dist/cli.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { runForegroundAutoUpdate } from "./auto-update.js";
+const packageManifest = createRequire(import.meta.url)("../package.json");
+const currentVersion = typeof packageManifest.version === "string" ? packageManifest.version : undefined;
+const effectiveCurrentVersion = process.env["LITCODEX_CURRENT_VERSION"] ?? currentVersion;
+const command = process.argv[2];
+const subcommand = process.argv[3];
+if (command === "hook" && subcommand === "session-start") {
+    await runSessionStartHook();
+}
+else if (command === "run-management") {
+    runManagementCommand();
+}
+else {
+    process.stderr.write("Usage: litcodex-auto-update hook session-start | run-management [options]\n");
+    process.exitCode = 1;
+}
+async function runSessionStartHook() {
+    const raw = await readStdin();
+    const parsed = parseJson(raw);
+    if (!isSessionStartPayload(parsed))
+        return;
+    const result = runForegroundAutoUpdate({
+        source: "session-start",
+        currentVersion: effectiveCurrentVersion,
+        ...(process.env["LITCODEX_INSTALL_FLOW"] === "marketplace" ? { installFlow: "marketplace" } : {}),
+        cwd: parsed.cwd,
+        env: process.env,
+    });
+    writeLifecycleResult(result, "SessionStart");
+}
+function runManagementCommand() {
+    const current = option("current-version") ?? effectiveCurrentVersion;
+    const latest = option("latest-version");
+    const argv = parseArgv(option("argv-json"));
+    const result = runForegroundAutoUpdate({
+        source: "management-command",
+        currentVersion: current,
+        ...(process.env["LITCODEX_INSTALL_FLOW"] === "marketplace" ? { installFlow: "marketplace" } : {}),
+        ...(latest === undefined ? {} : { latestVersion: latest }),
+        argv,
+        cwd: process.cwd(),
+        env: process.env,
+    });
+    processStdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === "failed" || result.status === "unknown-state")
+        process.exitCode = 3;
+}
+function writeLifecycleResult(result, hookEventName) {
+    if (result.status !== "updated" && result.status !== "failed" && result.status !== "unknown-state")
+        return;
+    const detail = result.status === "updated"
+        ? `Foreground update barrier applied ${result.packageName}@${result.latestVersion ?? "the latest stable release"} (version + doctor verified).`
+        : result.status === "unknown-state"
+            ? `BLOCKED: Foreground update barrier left installation state unknown (${result.reason ?? "rollback failed"}); stop before using this host and run litcodex doctor.`
+            : `Foreground update barrier failed (${result.reason ?? "unknown error"}); the current installation was preserved when possible.`;
+    processStdout.write(`${JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: `LitCodex: ${detail}` } })}\n`);
+    if (result.status === "unknown-state")
+        process.exitCode = 3;
+}
+function option(name) {
+    const prefix = `--${name}=`;
+    const value = process.argv.slice(3).find((arg) => arg.startsWith(prefix));
+    return value?.slice(prefix.length);
+}
+function parseArgv(raw) {
+    if (raw === undefined)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) && parsed.every((item) => typeof item === "string") ? parsed : [];
+    }
+    catch {
+        return [];
+    }
+}
+function parseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isSessionStartPayload(value) {
+    return isRecord(value) && value["hook_event_name"] === "SessionStart" && typeof value["cwd"] === "string";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        processStdin.setEncoding("utf8");
+        processStdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        processStdin.once("error", reject);
+        processStdin.once("end", () => resolve(data));
+    });
+}

package/marketplace/plugins/litcodex/components/auto-update/package.json

@@ -0,0 +1,22 @@
+{
+	"name": "@litcodex/auto-update",
+	"version": "1.0.0",
+	"description": "LitCodex foreground update barrier for the SessionStart and management lifecycles.",
+	"type": "module",
+	"private": true,
+	"bin": {
+		"litcodex-auto-update": "./dist/cli.js"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json",
+		"postbuild": "node ../../../../scripts/mark-cli-executable.mjs --workspace .",
+		"typecheck": "tsc --noEmit",
+		"test": "vitest --run --passWithNoTests=false"
+	},
+	"engines": {
+		"node": ">=22.0.0"
+	}
+}

package/marketplace/plugins/litcodex/components/comment-checker/dist/apply-patch.d.ts

@@ -0,0 +1,7 @@
+import type { CommentCheckRequest } from "./types.js";
+export declare function extractApplyPatchRequests(event: {
+    details?: unknown;
+    input: Record<string, unknown>;
+    toolName: string;
+}): CommentCheckRequest[];
+export declare function parseApplyPatchRequests(patch: string, sourceToolName?: string): CommentCheckRequest[];

package/marketplace/plugins/litcodex/components/comment-checker/dist/apply-patch.js

@@ -0,0 +1,173 @@
+import { getString, isRecord } from "./record.js";
+export function extractApplyPatchRequests(event) {
+    const metadataRequests = extractApplyPatchMetadataRequests(event.details, event.toolName);
+    if (metadataRequests.length > 0)
+        return metadataRequests;
+    const patch = getString(event.input, ["input", "patch", "command"]);
+    if (!patch)
+        return [];
+    return parseApplyPatchRequests(patch, event.toolName);
+}
+export function parseApplyPatchRequests(patch, sourceToolName = "apply_patch") {
+    const requests = [];
+    let current;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.operation === "add") {
+            const content = joinPatchLines(current.newLines);
+            if (content.length > 0) {
+                requests.push({
+                    sourceToolName,
+                    toolName: "Write",
+                    filePath: current.filePath,
+                    toolInput: {
+                        file_path: current.filePath,
+                        content,
+                    },
+                });
+            }
+        }
+        if (current.operation === "update") {
+            const newString = joinPatchLines(current.newLines);
+            if (newString.length > 0) {
+                const filePath = current.movePath ?? current.filePath;
+                requests.push({
+                    sourceToolName,
+                    toolName: "Edit",
+                    filePath,
+                    toolInput: {
+                        file_path: filePath,
+                        old_string: joinPatchLines(current.oldLines),
+                        new_string: newString,
+                    },
+                });
+            }
+        }
+        current = undefined;
+    };
+    for (const line of patch.split(/\r?\n/)) {
+        if (line === "*** Begin Patch" || line === "*** End Patch")
+            continue;
+        if (line.startsWith("*** Add File: ")) {
+            flush();
+            current = makeAccumulator("add", line.slice("*** Add File: ".length).trim());
+            continue;
+        }
+        if (line.startsWith("*** Update File: ")) {
+            flush();
+            current = makeAccumulator("update", line.slice("*** Update File: ".length).trim());
+            continue;
+        }
+        if (line.startsWith("*** Delete File: ")) {
+            flush();
+            current = makeAccumulator("delete", line.slice("*** Delete File: ".length).trim());
+            continue;
+        }
+        if (line.startsWith("*** Move to: ")) {
+            if (current?.operation === "update")
+                current.movePath = line.slice("*** Move to: ".length).trim();
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith("@@"))
+            continue;
+        if (current.operation === "add") {
+            if (line.startsWith("+"))
+                current.newLines.push(line.slice(1));
+            continue;
+        }
+        if (current.operation === "update") {
+            if (line.startsWith("+"))
+                current.newLines.push(line.slice(1));
+            if (line.startsWith("-"))
+                current.oldLines.push(line.slice(1));
+        }
+    }
+    flush();
+    return requests;
+}
+function extractApplyPatchMetadataRequests(details, sourceToolName) {
+    const metadataFiles = getApplyPatchMetadataFiles(details);
+    if (metadataFiles.length === 0)
+        return [];
+    const requests = [];
+    for (const file of metadataFiles) {
+        if (file.type === "delete")
+            continue;
+        const filePath = file.movePath ?? file.filePath;
+        if (file.before.length === 0) {
+            requests.push({
+                sourceToolName,
+                toolName: "Write",
+                filePath,
+                toolInput: {
+                    file_path: filePath,
+                    content: file.after,
+                },
+            });
+            continue;
+        }
+        requests.push({
+            sourceToolName,
+            toolName: "Edit",
+            filePath,
+            toolInput: {
+                file_path: filePath,
+                old_string: file.before,
+                new_string: file.after,
+            },
+        });
+    }
+    return requests;
+}
+function getApplyPatchMetadataFiles(details) {
+    if (!isRecord(details))
+        return [];
+    const direct = readApplyPatchMetadataFiles(details["files"]);
+    if (direct.length > 0)
+        return direct;
+    const resultDetails = details["result"];
+    const result = isRecord(resultDetails) ? readApplyPatchMetadataFiles(resultDetails["files"]) : [];
+    if (result.length > 0)
+        return result;
+    const metadataDetails = details["metadata"];
+    const metadata = isRecord(metadataDetails) ? readApplyPatchMetadataFiles(metadataDetails["files"]) : [];
+    return metadata;
+}
+function readApplyPatchMetadataFiles(value) {
+    if (!Array.isArray(value))
+        return [];
+    const files = [];
+    for (const item of value) {
+        if (!isRecord(item))
+            continue;
+        const filePath = getString(item, ["filePath", "file_path", "path"]);
+        const movePath = getString(item, ["movePath", "move_path"]);
+        const before = getString(item, ["before", "old", "oldString", "old_string"]);
+        const after = getString(item, ["after", "new", "newString", "new_string"]);
+        const type = getString(item, ["type", "operation"]);
+        if (!filePath || before === undefined || after === undefined)
+            continue;
+        files.push({
+            filePath,
+            before,
+            after,
+            ...(movePath === undefined ? {} : { movePath }),
+            ...(type === undefined ? {} : { type }),
+        });
+    }
+    return files;
+}
+function makeAccumulator(operation, filePath) {
+    return {
+        operation,
+        filePath,
+        oldLines: [],
+        newLines: [],
+    };
+}
+function joinPatchLines(lines) {
+    return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+}

package/marketplace/plugins/litcodex/components/comment-checker/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/marketplace/plugins/litcodex/components/comment-checker/dist/cli.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runCodexHookCli } from "./codex-hook.js";
+const [command, subcommand] = process.argv.slice(2);
+if (command === "hook" && subcommand === "post-tool-use") {
+    await runCodexHookCli();
+}
+else {
+    process.stderr.write("Usage: litcodex-comment-checker hook post-tool-use\n");
+    process.exitCode = 2;
+}

package/marketplace/plugins/litcodex/components/comment-checker/dist/codex-hook.d.ts

@@ -0,0 +1,22 @@
+import { type CommentCheckRequest } from "./core.js";
+import { type CommentCheckerRunner } from "./runner.js";
+export type CodexPostToolUseInput = {
+    session_id: string;
+    turn_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "PostToolUse";
+    model: string;
+    permission_mode: string;
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_response: unknown;
+    tool_use_id: string;
+};
+export type CodexHookOptions = {
+    run?: CommentCheckerRunner;
+};
+export declare function extractCodexCommentCheckRequests(input: CodexPostToolUseInput): CommentCheckRequest[];
+export declare function runCommentCheckerPostToolUse(input: CodexPostToolUseInput, options?: CodexHookOptions): Promise<string>;
+export declare function runCodexHookCli(): Promise<void>;
+export declare function parseCodexPostToolUseInput(input: string): CodexPostToolUseInput | undefined;

package/marketplace/plugins/litcodex/components/comment-checker/dist/codex-hook.js

@@ -0,0 +1,165 @@
+import { readFileSync } from "node:fs";
+import { stdin as processStdin, stdout as processStdout } from "node:process";
+import { extractCommentCheckRequests, isRecord, toHookInput, } from "./core.js";
+import { runCommentChecker } from "./runner.js";
+const DEFAULT_MAX_HOOK_FEEDBACK_CHARS = 8000;
+const CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS = 1200;
+const CONTEXT_PRESSURE_MARKERS = [
+    "context compacted",
+    "context_length_exceeded",
+    "skill descriptions were shortened",
+    "context_too_large",
+    "codex ran out of room in the model's context window",
+    "your input exceeds the context window",
+    "long threads and multiple compactions",
+];
+export function extractCodexCommentCheckRequests(input) {
+    return extractCommentCheckRequests(toToolResultLike(input));
+}
+export async function runCommentCheckerPostToolUse(input, options = {}) {
+    const requests = extractCodexCommentCheckRequests(input);
+    if (requests.length === 0)
+        return "";
+    const runner = options.run ?? runCommentChecker;
+    const warnings = [];
+    for (const request of requests) {
+        const context = {
+            sessionId: input.session_id,
+            cwd: input.cwd,
+            ...(input.transcript_path === null ? {} : { transcriptPath: input.transcript_path }),
+        };
+        const result = await runner(toHookInput(request, context));
+        if (result.status === "missing" || result.status === "pass")
+            continue;
+        if (result.status === "error")
+            continue;
+        const message = normalizeHookText(result.message);
+        if (message.length > 0) {
+            warnings.push({ filePath: request.filePath, message });
+        }
+    }
+    if (warnings.length === 0)
+        return "";
+    return JSON.stringify({
+        decision: "block",
+        reason: limitHookText(formatWarnings(warnings), hookFeedbackLimit(input.transcript_path)),
+    });
+}
+export async function runCodexHookCli() {
+    const input = await readStdin();
+    if (input.trim().length === 0)
+        return;
+    const parsed = parseCodexPostToolUseInput(input);
+    if (!parsed)
+        return;
+    const output = await runCommentCheckerPostToolUse(parsed);
+    if (output.length > 0) {
+        processStdout.write(output);
+        processStdout.write("\n");
+    }
+}
+export function parseCodexPostToolUseInput(input) {
+    let parsed;
+    try {
+        parsed = JSON.parse(input);
+    }
+    catch {
+        return undefined;
+    }
+    return isCodexPostToolUseInput(parsed) ? parsed : undefined;
+}
+function toToolResultLike(input) {
+    return {
+        toolName: input.tool_name,
+        input: normalizeToolInput(input.tool_name, input.tool_input),
+        content: normalizeToolResponse(input.tool_response),
+        isError: isErrorResponse(input.tool_response),
+        details: isRecord(input.tool_response) ? input.tool_response : undefined,
+    };
+}
+function normalizeToolInput(toolName, toolInput) {
+    if (toolName === "apply_patch" && typeof toolInput["command"] === "string") {
+        return {
+            ...toolInput,
+            input: toolInput["command"],
+            patch: toolInput["command"],
+        };
+    }
+    return toolInput;
+}
+function normalizeToolResponse(toolResponse) {
+    if (typeof toolResponse === "string") {
+        return [{ type: "text", text: toolResponse }];
+    }
+    if (isRecord(toolResponse) && typeof toolResponse["text"] === "string") {
+        return [{ type: "text", text: toolResponse["text"] }];
+    }
+    return [];
+}
+function isErrorResponse(toolResponse) {
+    return isRecord(toolResponse) && toolResponse["is_error"] === true;
+}
+function formatWarnings(warnings) {
+    return warnings
+        .map((warning) => `comment-checker found issues in ${warning.filePath}:\n${warning.message}`)
+        .join("\n\n");
+}
+function normalizeHookText(value) {
+    return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+}
+function hookFeedbackLimit(transcriptPath) {
+    return isContextPressureTranscript(transcriptPath)
+        ? CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS
+        : DEFAULT_MAX_HOOK_FEEDBACK_CHARS;
+}
+function isContextPressureTranscript(transcriptPath) {
+    if (transcriptPath === null)
+        return false;
+    try {
+        return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function hasContextPressureMarker(text) {
+    const normalizedText = text.toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+function limitHookText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const marker = `\n\n[Truncated hook output to ${maxChars} chars to avoid Codex context overflow.]`;
+    if (marker.length >= maxChars)
+        return marker.slice(0, maxChars);
+    const head = text.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
+    return `${head}${marker}`;
+}
+function isCodexPostToolUseInput(value) {
+    return (isRecord(value) &&
+        value["hook_event_name"] === "PostToolUse" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["turn_id"] === "string" &&
+        (typeof value["transcript_path"] === "string" || value["transcript_path"] === null) &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["tool_name"] === "string" &&
+        isRecord(value["tool_input"]) &&
+        typeof value["tool_use_id"] === "string");
+}
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        processStdin.setEncoding("utf-8");
+        processStdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        processStdin.once("error", reject);
+        processStdin.once("end", () => {
+            resolve(data);
+        });
+    });
+}

package/marketplace/plugins/litcodex/components/comment-checker/dist/core-values.d.ts

@@ -0,0 +1 @@
+export { getString, isRecord } from "./record.js";

package/marketplace/plugins/litcodex/components/comment-checker/dist/core-values.js

@@ -0,0 +1 @@
+export { getString, isRecord } from "./record.js";

package/marketplace/plugins/litcodex/components/comment-checker/dist/core.d.ts

@@ -0,0 +1,5 @@
+export { parseApplyPatchRequests } from "./apply-patch.js";
+export { toHookInput } from "./hook-input.js";
+export { isRecord } from "./record.js";
+export { extractCommentCheckRequests, isToolFailureOutput } from "./request-extractor.js";
+export type { CheckerEdit, CheckerToolInput, CheckerToolName, CommentCheckerHookInput, CommentCheckRequest, ImageContent, TextContent, ToolResultContent, ToolResultLike, } from "./types.js";

package/marketplace/plugins/litcodex/components/comment-checker/dist/core.js

@@ -0,0 +1,4 @@
+export { parseApplyPatchRequests } from "./apply-patch.js";
+export { toHookInput } from "./hook-input.js";
+export { isRecord } from "./record.js";
+export { extractCommentCheckRequests, isToolFailureOutput } from "./request-extractor.js";

package/marketplace/plugins/litcodex/components/comment-checker/dist/hook-input.d.ts

@@ -0,0 +1,6 @@
+import type { CommentCheckerHookInput, CommentCheckRequest } from "./types.js";
+export declare function toHookInput(request: CommentCheckRequest, context: {
+    readonly sessionId: string;
+    readonly cwd: string;
+    readonly transcriptPath?: string;
+}): CommentCheckerHookInput;

package/marketplace/plugins/litcodex/components/comment-checker/dist/hook-input.js

@@ -0,0 +1,10 @@
+export function toHookInput(request, context) {
+    return {
+        session_id: context.sessionId,
+        tool_name: request.toolName,
+        transcript_path: context.transcriptPath ?? "",
+        cwd: context.cwd,
+        hook_event_name: "PostToolUse",
+        tool_input: request.toolInput,
+    };
+}

package/marketplace/plugins/litcodex/components/comment-checker/dist/record.d.ts

@@ -0,0 +1,2 @@
+export declare function getString(input: Record<string, unknown>, keys: readonly string[]): string | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/marketplace/plugins/litcodex/components/comment-checker/dist/record.js

@@ -0,0 +1,11 @@
+export function getString(input, keys) {
+    for (const key of keys) {
+        const value = input[key];
+        if (typeof value === "string")
+            return value;
+    }
+    return undefined;
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}

package/marketplace/plugins/litcodex/components/comment-checker/dist/request-extractor.d.ts

@@ -0,0 +1,3 @@
+import type { CommentCheckRequest, ToolResultLike } from "./types.js";
+export declare function extractCommentCheckRequests(event: ToolResultLike): CommentCheckRequest[];
+export declare function isToolFailureOutput(text: string): boolean;

package/marketplace/plugins/litcodex/components/comment-checker/dist/request-extractor.js

@@ -0,0 +1,104 @@
+import { extractApplyPatchRequests } from "./apply-patch.js";
+import { getString, isRecord } from "./record.js";
+export function extractCommentCheckRequests(event) {
+    if (event.isError)
+        return [];
+    if (isToolFailureOutput(getContentText(event.content)))
+        return [];
+    const toolName = event.toolName.toLowerCase();
+    if (toolName === "write")
+        return extractWriteRequest(event);
+    if (toolName === "edit")
+        return extractEditRequest(event);
+    if (toolName === "multiedit" || toolName === "multi_edit")
+        return extractMultiEditRequest(event);
+    if (toolName === "apply_patch")
+        return extractApplyPatchRequests(event);
+    return [];
+}
+export function isToolFailureOutput(text) {
+    const lower = text.trim().toLowerCase();
+    return (lower.startsWith("error") ||
+        lower.includes("error:") ||
+        lower.includes("failed to") ||
+        lower.includes("could not"));
+}
+function extractWriteRequest(event) {
+    const filePath = getString(event.input, ["filePath", "file_path", "path"]);
+    const content = getString(event.input, ["content"]);
+    if (!filePath || content === undefined)
+        return [];
+    return [
+        {
+            sourceToolName: event.toolName,
+            toolName: "Write",
+            filePath,
+            toolInput: {
+                file_path: filePath,
+                content,
+            },
+        },
+    ];
+}
+function extractEditRequest(event) {
+    const filePath = getString(event.input, ["filePath", "file_path", "path"]);
+    const oldString = getString(event.input, ["oldString", "old_string"]);
+    const newString = getString(event.input, ["newString", "new_string"]);
+    if (!filePath || oldString === undefined || newString === undefined)
+        return [];
+    return [
+        {
+            sourceToolName: event.toolName,
+            toolName: "Edit",
+            filePath,
+            toolInput: {
+                file_path: filePath,
+                old_string: oldString,
+                new_string: newString,
+            },
+        },
+    ];
+}
+function extractMultiEditRequest(event) {
+    const filePath = getString(event.input, ["filePath", "file_path", "path"]);
+    const edits = getEdits(event.input["edits"]);
+    if (!filePath || edits.length === 0)
+        return [];
+    return [
+        {
+            sourceToolName: event.toolName,
+            toolName: "MultiEdit",
+            filePath,
+            toolInput: {
+                file_path: filePath,
+                edits,
+            },
+        },
+    ];
+}
+function getEdits(value) {
+    if (!Array.isArray(value))
+        return [];
+    const edits = [];
+    for (const item of value) {
+        if (!isRecord(item))
+            continue;
+        const oldString = getString(item, ["oldString", "old_string"]);
+        const newString = getString(item, ["newString", "new_string"]);
+        if (oldString === undefined || newString === undefined)
+            continue;
+        edits.push({
+            old_string: oldString,
+            new_string: newString,
+        });
+    }
+    return edits;
+}
+function getContentText(content) {
+    if (!content)
+        return "";
+    return content
+        .filter((block) => block.type === "text")
+        .map((block) => block.text)
+        .join("\n");
+}