ivorleaf 1.1.0

package/dist/render.js

@@ -0,0 +1,600 @@
+import chalk from "chalk";
+import { marked } from "marked";
+import { markedTerminal } from "marked-terminal";
+import { getActiveSession } from "./utils/activeSession.js";
+export const CLI_VERSION = "1.1.0";
+const PRIMARY_KEYS = [
+    "markdown", "content", "lesson_markdown", "workflow_markdown", "quiz_markdown",
+    "flashcards_markdown", "table_markdown", "citations_markdown", "output_markdown",
+    "lesson", "output", "result", "text", "response", "data",
+];
+const SOURCE_KEYS = new Set(["sources", "source_details", "references", "citations"]);
+const WARNING_KEYS = new Set(["warnings", "citation_warnings", "citation_warning"]);
+const WORKFLOW_KEYS = new Set(["available_actions", "workflows", "actions"]);
+const METADATA_KEYS = new Set([
+    "session_id", "sessionId", "id", "action", "action_name", "type", "status",
+    "created_at", "updated_at", "metadata", "usage", "plan", "organization",
+    ...SOURCE_KEYS, ...WARNING_KEYS, ...WORKFLOW_KEYS,
+]);
+const DEFAULT_SOURCE_ACTIONS = new Set(["citation_builder", "source_comparison"]);
+export function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+export function extractMarkdown(value) {
+    return extractPrimary(value) || "No displayable content was returned.";
+}
+export function extractSources(value) {
+    return uniqueValues(collectNamedValues(value, SOURCE_KEYS).flatMap(normalizeCollection));
+}
+export function formatResponse(value, options = {}, context = {}) {
+    const sections = [];
+    const rawContent = extractMarkdown(value).trim();
+    const content = context.kind === "workflow" && context.actionName === "table"
+        ? formatTableWorkflowMarkdown(rawContent)
+        : rawContent;
+    const title = context.kind === "workflow" ? workflowTitle(value, context.actionName) : null;
+    if (title && !startsWithEquivalentHeading(content, title))
+        sections.push(`# ${title}`);
+    sections.push(content);
+    const sources = extractSources(value);
+    const warnings = uniqueValues(collectNamedValues(value, WARNING_KEYS).flatMap(normalizeCollection));
+    const showFullSources = options.sources || DEFAULT_SOURCE_ACTIONS.has(context.actionName || "");
+    if (showFullSources && sources.length)
+        sections.push(formatSources(sources));
+    else if (context.kind === "lesson") {
+        if (sources.length)
+            sections.push(`Sources: ${sources.length} available`);
+        if (warnings.length)
+            sections.push(formatWarnings(warnings));
+    }
+    if (context.sessionId)
+        sections.push(`Session: ${context.sessionId}`);
+    if (options.debugResponse)
+        sections.push(formatDebugResponse(value, context, sources.length, warnings.length));
+    return sections.filter(Boolean).join("\n\n");
+}
+export function formatTableWorkflowMarkdown(markdown, width = terminalMarkdownWidth()) {
+    const lines = markdown.split(/\r?\n/);
+    const formatted = [];
+    for (let index = 0; index < lines.length;) {
+        if (!isMarkdownTableAt(lines, index)) {
+            formatted.push(lines[index]);
+            index += 1;
+            continue;
+        }
+        const block = [lines[index], lines[index + 1]];
+        index += 2;
+        while (index < lines.length && isTableRow(lines[index])) {
+            block.push(lines[index]);
+            index += 1;
+        }
+        formatted.push(formatTableBlock(block, width));
+    }
+    return formatted.join("\n").trim();
+}
+export async function renderResponse(value, options, context = {}) {
+    if (options.json)
+        return printJson(value);
+    const markdown = formatResponse(value, options, context);
+    const summary = responseSummary(value, context);
+    const shouldPager = shouldUsePager(markdown, options);
+    if (options.plain || options.noPager)
+        return console.log(markdown);
+    if (!process.stdout.isTTY && !options.pager)
+        return console.log(markdown);
+    const rendered = renderTerminalMarkdown(markdown);
+    if (shouldPager) {
+        if (canUseInteractivePager()) {
+            try {
+                return await renderInteractivePager(rendered, summary);
+            }
+            catch {
+                return console.log(formatPaginatedOutput(rendered, summary, { forceMarkers: true }));
+            }
+        }
+        return console.log(formatPaginatedOutput(rendered, summary, { forceMarkers: true }));
+    }
+    console.log(rendered);
+}
+export function renderTerminalMarkdown(markdown) {
+    marked.use(markedTerminal({
+        reflowText: true,
+        width: Math.min(Math.max(process.stdout.columns || 80, 50), 100),
+        tab: 2,
+        firstHeading: chalk.bold.green,
+        heading: chalk.bold.cyan,
+        strong: chalk.bold,
+        em: chalk.italic,
+        codespan: chalk.yellow,
+        blockquote: chalk.gray,
+        hr: chalk.dim,
+        link: chalk.cyan,
+        href: chalk.dim,
+        table: chalk.white,
+    }));
+    return String(marked.parse(markdown)).trimEnd();
+}
+export function formatPaginatedOutput(content, summary, options = {}) {
+    const height = Math.max(8, options.height || process.stdout.rows || 24);
+    const width = Math.max(40, options.width || process.stdout.columns || 80);
+    const header = formatFixedStatus(summary, width);
+    const footer = formatStickyFooter();
+    const headerHeight = header.split("\n").length;
+    const footerHeight = footer.split("\n").length;
+    const paneHeight = Math.max(3, height - headerHeight - footerHeight - 2);
+    const lines = wrapOutputLines(content, width);
+    const pages = [];
+    for (let start = 0; start < Math.max(lines.length, 1); start += paneHeight) {
+        const pageLines = lines.slice(start, start + paneHeight);
+        const page = [
+            header,
+            "─".repeat(width),
+            pageLines.join("\n"),
+            "",
+            footer,
+        ].join("\n").trimEnd();
+        const hasMore = start + paneHeight < lines.length;
+        pages.push(hasMore || options.forceMarkers ? `${page}\n--More--` : page);
+    }
+    return pages.join("\n\n");
+}
+function extractPrimary(value, seen = new Set()) {
+    if (typeof value === "string")
+        return value;
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (!value || typeof value !== "object" || seen.has(value))
+        return "";
+    seen.add(value);
+    if (Array.isArray(value))
+        return formatArray(value, seen);
+    const object = value;
+    for (const key of PRIMARY_KEYS) {
+        if (object[key] === undefined)
+            continue;
+        const content = extractPrimary(object[key], seen);
+        if (content)
+            return content;
+    }
+    return formatObject(object, seen);
+}
+function formatArray(items, seen) {
+    return items.map((item, index) => {
+        if (isObject(item)) {
+            const question = stringValue(item.question ?? item.prompt ?? item.front ?? item.term);
+            const answer = stringValue(item.answer ?? item.correct_answer ?? item.back ?? item.definition);
+            const explanation = stringValue(item.explanation ?? item.rationale);
+            const options = Array.isArray(item.options) ? item.options : Array.isArray(item.choices) ? item.choices : [];
+            if (question || answer || options.length) {
+                const lines = [`## ${index + 1}. ${question || "Item"}`];
+                if (options.length)
+                    lines.push(options.map(option => `- ${stringValue(option)}`).join("\n"));
+                if (answer)
+                    lines.push(`**Answer:** ${answer}`);
+                if (explanation)
+                    lines.push(explanation);
+                return lines.join("\n\n");
+            }
+        }
+        const rendered = extractPrimary(item, seen);
+        return rendered ? `- ${rendered.replace(/\n/g, "\n  ")}` : "";
+    }).filter(Boolean).join("\n\n");
+}
+function formatObject(object, seen) {
+    const sections = [];
+    for (const [key, value] of Object.entries(object)) {
+        if (METADATA_KEYS.has(key) || value === null || value === undefined)
+            continue;
+        const rendered = extractPrimary(value, seen);
+        if (!rendered)
+            continue;
+        if (typeof value === "string" && Object.keys(object).length === 1)
+            sections.push(rendered);
+        else
+            sections.push(`## ${humanize(key)}\n\n${rendered}`);
+    }
+    return sections.join("\n\n");
+}
+function responseSummary(value, context) {
+    const sources = extractSources(value);
+    const warnings = uniqueValues(collectNamedValues(value, WARNING_KEYS).flatMap(normalizeCollection));
+    const workflows = uniqueValues(collectNamedValues(value, WORKFLOW_KEYS).flatMap(normalizeCollection))
+        .map(workflow => typeof workflow === "string" ? workflow : stringValue(workflow))
+        .filter(Boolean)
+        .slice(0, 8);
+    return {
+        version: process.env.npm_package_version || CLI_VERSION,
+        command: context.command || context.actionName || context.kind || "command",
+        sessionId: context.sessionId || "None",
+        title: responseTitle(value, context),
+        sourceCount: sources.length,
+        warningCount: warnings.length,
+        workflows,
+    };
+}
+function responseTitle(value, context) {
+    const named = findNamedString(value, ["title", "subject", "topic", "name"]);
+    if (named)
+        return named;
+    const prompt = findNamedString(value, ["prompt", "query", "rewritten_prompt", "rewritten_query"]);
+    if (prompt)
+        return truncateText(prompt, 72);
+    const firstHeading = extractMarkdown(value).split(/\r?\n/).find(line => /^#{1,3}\s+\S/.test(line));
+    if (firstHeading)
+        return truncateText(firstHeading.replace(/^#{1,3}\s+/, "").trim(), 72);
+    return context.kind === "workflow" ? humanize(context.actionName || "workflow") : "Lesson";
+}
+function shouldUsePager(markdown, options) {
+    if (options.noPager || options.plain || options.json)
+        return false;
+    if (options.pager)
+        return true;
+    if (!process.stdout.isTTY)
+        return false;
+    const height = Math.max(8, process.stdout.rows || 24);
+    return wrapOutputLines(markdown, Math.max(40, process.stdout.columns || 80)).length > height - 6;
+}
+function canUseInteractivePager() {
+    return Boolean(process.stdin.isTTY
+        && process.stdout.isTTY
+        && typeof process.stdin.setRawMode === "function"
+        && typeof process.stdin.on === "function");
+}
+async function renderInteractivePager(content, summary) {
+    const height = Math.max(8, process.stdout.rows || 24);
+    const width = Math.max(40, process.stdout.columns || 80);
+    const header = formatFixedStatus(summary, width);
+    const footer = formatStickyFooter();
+    const paneHeight = Math.max(3, height - header.split("\n").length - footer.split("\n").length - 2);
+    const lines = wrapOutputLines(content, width);
+    let offset = 0;
+    const renderPage = () => {
+        const pageLines = lines.slice(offset, offset + paneHeight);
+        process.stdout.write("\x1b[2J\x1b[H");
+        process.stdout.write(`${header}\n${"─".repeat(width)}\n`);
+        process.stdout.write(`${pageLines.join("\n")}\n\n${footer}`);
+        if (offset + paneHeight < lines.length)
+            process.stdout.write("\n--More--");
+    };
+    const stdin = process.stdin;
+    const wasRaw = Boolean(stdin.isRaw);
+    try {
+        stdin.setRawMode(true);
+        stdin.resume();
+        renderPage();
+        while (offset + paneHeight < lines.length) {
+            const key = await readPagerKey();
+            if (key === "q" || key === "\u0003")
+                break;
+            if (key === "\r" || key === "\n" || key === " " || key === "\x1b[B") {
+                offset = Math.min(offset + paneHeight, Math.max(lines.length - paneHeight, 0));
+            }
+            else if (key === "\x1b[A") {
+                offset = Math.max(offset - paneHeight, 0);
+            }
+            else if (key === "s" || key === "c" || key === "w") {
+                renderPagerHelp(summary, key, width);
+                break;
+            }
+            else {
+                continue;
+            }
+            renderPage();
+        }
+        process.stdout.write("\n");
+    }
+    finally {
+        try {
+            stdin.setRawMode(wasRaw);
+        }
+        catch {
+            // Ignore terminal cleanup failures; the caller falls back to non-interactive output.
+        }
+        stdin.pause();
+    }
+}
+function readPagerKey() {
+    return new Promise(resolve => {
+        const onData = (chunk) => {
+            cleanup();
+            resolve(Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk));
+        };
+        const onError = () => {
+            cleanup();
+            resolve("q");
+        };
+        const cleanup = () => {
+            process.stdin.off("data", onData);
+            process.stdin.off("error", onError);
+        };
+        process.stdin.once("data", onData);
+        process.stdin.once("error", onError);
+    });
+}
+function renderPagerHelp(summary, key, width) {
+    const line = "─".repeat(width);
+    if (key === "s") {
+        process.stdout.write(`\n${line}\nSources: run ivorleaf sources\n`);
+        return;
+    }
+    if (key === "c") {
+        process.stdout.write(`\n${line}\nCitations: run ivorleaf citations${summary.sessionId !== "None" ? ` ${summary.sessionId}` : ""}\n`);
+        return;
+    }
+    const workflows = summary.workflows.length
+        ? summary.workflows.join(", ")
+        : "quiz, flashcards, citations, compare, continue";
+    process.stdout.write(`\n${line}\nWorkflows: ${workflows}\n`);
+}
+function formatFixedStatus(summary, width) {
+    const workflows = summary.workflows.length ? summary.workflows.join(", ") : "workflow menu";
+    const lines = [
+        `Ivorleaf CLI ${summary.version}`,
+        `Command: ${summary.command}`,
+        `Session: ${summary.sessionId}`,
+        `Topic: ${summary.title}`,
+        `Sources: ${summary.sourceCount}  Warnings: ${summary.warningCount}`,
+        `Workflows: ${workflows}`,
+    ];
+    return lines.map(line => truncateText(line, width)).join("\n");
+}
+function formatStickyFooter() {
+    return "q quit | ↑/↓ scroll | Enter continue | s sources | c citations | w workflows";
+}
+function wrapOutputLines(content, width) {
+    const max = Math.max(20, width);
+    return content.split(/\r?\n/).flatMap(line => {
+        const stripped = stripAnsi(line);
+        if (stripped.length <= max)
+            return [line];
+        const chunks = [];
+        let remaining = line;
+        while (stripAnsi(remaining).length > max) {
+            chunks.push(remaining.slice(0, max));
+            remaining = remaining.slice(max);
+        }
+        chunks.push(remaining);
+        return chunks;
+    });
+}
+function collectNamedValues(value, keys, seen = new Set()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return [];
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.flatMap(item => collectNamedValues(item, keys, seen));
+    const found = [];
+    for (const [key, child] of Object.entries(value)) {
+        if (keys.has(key))
+            found.push(child);
+        else
+            found.push(...collectNamedValues(child, keys, seen));
+    }
+    return found;
+}
+function normalizeCollection(value) {
+    if (value === null || value === undefined || value === "")
+        return [];
+    if (Array.isArray(value))
+        return value;
+    if (isObject(value))
+        return Object.values(value);
+    if (typeof value === "number")
+        return Array.from({ length: value }, () => null);
+    return [value];
+}
+function uniqueValues(values) {
+    const seen = new Set();
+    return values.filter(value => {
+        // Null placeholders preserve count-only metadata such as `sources: 3`.
+        if (value === null)
+            return true;
+        const key = value && typeof value === "object" ? JSON.stringify(value) : String(value);
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+export function formatSources(sources) {
+    const lines = sources.map((source, index) => {
+        const fallbackLabel = `S${index + 1}`;
+        if (typeof source === "string")
+            return `${fallbackLabel}. ${source}`;
+        if (!isObject(source))
+            return `${fallbackLabel}. Source ${index + 1}`;
+        const label = stringValue(source.id ?? source.source_label ?? source.label) || fallbackLabel;
+        const title = stringValue(source.title ?? source.name ?? source.citation) || `Source ${index + 1}`;
+        const provider = stringValue(source.provider ?? source.source ?? source.source_type);
+        const url = stringValue(source.url ?? source.href ?? source.link ?? source.doi ?? source.openalex_id);
+        const linkUrl = /^https?:\/\//i.test(url) ? url : "";
+        const author = stringValue(source.author ?? source.authors);
+        const relevance = formatRelevance(source.citation_relevance);
+        const status = stringValue(source.status ?? source.citation_priority ?? source.type);
+        const detail = stringValue(source.excerpt ?? source.snippet ?? source.summary);
+        const heading = linkUrl ? `${label}. [${title}](${linkUrl})` : `${label}. ${title}`;
+        return [
+            heading,
+            provider && `   Provider: ${provider}`,
+            author && `   Authors: ${author}`,
+            url && `   URL/DOI: ${url}`,
+            relevance && `   Relevance: ${relevance}`,
+            status && `   Status: ${status}`,
+            detail && `   ${detail}`,
+        ].filter(Boolean).join("\n");
+    });
+    return `## Sources\n\n${lines.join("\n")}`;
+}
+function formatWarnings(warnings) {
+    const lines = warnings.map(warning => {
+        if (typeof warning === "string")
+            return `- ${warning}`;
+        if (!isObject(warning))
+            return `- ${stringValue(warning) || "Citation warning"}`;
+        const message = stringValue(warning.message ?? warning.warning ?? warning.detail ?? warning.reason ?? warning.text);
+        return `- ${message || JSON.stringify(warning)}`;
+    });
+    return `Warnings:\n${lines.join("\n")}`;
+}
+function formatDebugResponse(value, context, sourceCount, warningCount) {
+    const object = isObject(value) ? value : {};
+    const route = isObject(object.route) ? object.route : {};
+    const usage = isObject(object.usage) ? object.usage : {};
+    const sessionValue = object.session_id ?? object.sessionId;
+    const lines = [
+        `Root keys: ${Object.keys(object).join(", ") || "(none)"}`,
+        `Top-level session_id: ${sessionValue === null || sessionValue === undefined ? String(sessionValue) : typeof sessionValue}`,
+        `Discovered session: ${context.sessionId || "None"}`,
+        `Plan: ${context.plan || "Unknown"}`,
+        `Route keys: ${Object.keys(route).join(", ") || "(none)"}`,
+        `Route client: ${stringValue(route.client) || "Unknown"}`,
+        `Usage keys: ${Object.keys(usage).join(", ") || "(none)"}`,
+        `Sources discovered: ${sourceCount}`,
+        `Citation warnings discovered: ${warningCount}`,
+    ];
+    return `## Debug Response\n\n${lines.join("\n")}`;
+}
+function formatRelevance(value) {
+    if (!isObject(value))
+        return "";
+    const score = typeof value.score === "number" ? value.score : null;
+    const rejected = typeof value.rejected === "boolean" ? value.rejected : null;
+    const reason = stringValue(value.reason);
+    const parts = [
+        score !== null && `score ${Number.isInteger(score) ? score : score.toFixed(2)}`,
+        rejected !== null && (rejected ? "rejected" : "accepted"),
+        reason,
+    ].filter(Boolean);
+    return parts.join("; ");
+}
+function workflowTitle(value, actionName) {
+    const title = findNamedString(value, ["workflow_title", "title", "name"]);
+    return title || humanize(actionName || "workflow");
+}
+function findNamedString(value, keys, seen = new Set()) {
+    if (!value || typeof value !== "object" || seen.has(value))
+        return null;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            const found = findNamedString(item, keys, seen);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    const object = value;
+    for (const key of keys)
+        if (typeof object[key] === "string")
+            return object[key];
+    for (const [key, child] of Object.entries(object)) {
+        if (SOURCE_KEYS.has(key) || WARNING_KEYS.has(key) || key === "metadata")
+            continue;
+        const found = findNamedString(child, keys, seen);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function startsWithEquivalentHeading(markdown, title) {
+    const first = markdown.split("\n", 1)[0].replace(/^#+\s*/, "").trim().toLowerCase();
+    return first === title.trim().toLowerCase();
+}
+function formatTableBlock(block, width) {
+    if (!isOversizedTable(block, width))
+        return block.join("\n");
+    const headers = splitTableRow(block[0]).map(cell => cell || "Field");
+    const records = block.slice(2).map(splitTableRow).filter(cells => cells.some(Boolean));
+    if (!headers.length || !records.length)
+        return block.join("\n");
+    return records.map((cells, index) => {
+        const fields = headers.map((header, cellIndex) => {
+            const value = cells[cellIndex]?.trim();
+            return value ? `**${header}:** ${value}` : "";
+        }).filter(Boolean);
+        return [`### Record ${index + 1}`, ...fields].join("\n\n");
+    }).join("\n\n---\n\n");
+}
+function isOversizedTable(block, width) {
+    const maxLineLength = Math.max(...block.map(line => stripAnsi(line).length));
+    if (maxLineLength > width)
+        return true;
+    const cells = block.filter((_, index) => index !== 1).flatMap(splitTableRow);
+    const longCellThreshold = Math.max(28, Math.floor(width * 0.35));
+    return cells.some(cell => cell.length > longCellThreshold);
+}
+function isMarkdownTableAt(lines, index) {
+    return index + 1 < lines.length && isTableRow(lines[index]) && isSeparatorRow(lines[index + 1]);
+}
+function isTableRow(line) {
+    const trimmed = line.trim();
+    return trimmed.includes("|") && splitTableRow(trimmed).length >= 2;
+}
+function isSeparatorRow(line) {
+    return splitTableRow(line).every(cell => /^:?-{3,}:?$/.test(cell.trim()));
+}
+function splitTableRow(line) {
+    const trimmed = line.trim().replace(/^\|/, "").replace(/\|$/, "");
+    const cells = [];
+    let current = "";
+    let escaped = false;
+    for (const char of trimmed) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (char === "|") {
+            cells.push(cleanTableCell(current));
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    cells.push(cleanTableCell(current));
+    return cells;
+}
+function cleanTableCell(cell) {
+    return cell.trim().replace(/\\\|/g, "|");
+}
+function terminalMarkdownWidth() {
+    return Math.min(Math.max(process.stdout.columns || 80, 50), 100);
+}
+function stripAnsi(value) {
+    return value.replace(/\u001b\[[0-9;]*m/g, "");
+}
+function humanize(value) {
+    return value.replace(/[_-]+/g, " ").replace(/\b\w/g, letter => letter.toUpperCase());
+}
+function truncateText(value, width) {
+    if (value.length <= width)
+        return value;
+    return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    if (Array.isArray(value))
+        return value.map(stringValue).filter(Boolean).join(", ");
+    return typeof value === "string" || typeof value === "number" ? String(value) : "";
+}
+export async function renderHeader(command, options = {}) {
+    const headerOptions = typeof options === "string" || options === null
+        ? { plan: options }
+        : options;
+    const session = headerOptions.sessionId ?? await getActiveSession();
+    console.log(`${chalk.bold("Ivorleaf CLI")} ${process.env.npm_package_version || CLI_VERSION}`);
+    console.log("─".repeat(40));
+    console.log(`Plan: ${headerOptions.plan || "Unknown"}`);
+    console.log(`Session: ${session || "None"}`);
+    console.log(`Command: ${command}\n`);
+}
+export function success(text) { return chalk.green(`✓ ${text}`); }
+export function failure(text) { return chalk.red(`✗ ${text}`); }
+//# sourceMappingURL=render.js.map

package/dist/utils/activeSession.js

@@ -0,0 +1,58 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+export const ACTIVE_SESSION_PATH = join(homedir(), ".ivorleaf", "active-session");
+export function getActiveSessionPath() {
+    return process.env.IVORLEAF_CONFIG_DIR
+        ? join(process.env.IVORLEAF_CONFIG_DIR, "active-session")
+        : ACTIVE_SESSION_PATH;
+}
+export function getActiveSessionMetadataPath() {
+    return join(dirname(getActiveSessionPath()), "active-session.json");
+}
+export async function getActiveSession() {
+    try {
+        return (await readFile(getActiveSessionPath(), "utf8")).trim() || null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function setActiveSession(sessionId) {
+    const path = getActiveSessionPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${sessionId}\n`, { mode: 0o600 });
+}
+export async function getActiveSessionMetadata() {
+    try {
+        const parsed = JSON.parse(await readFile(getActiveSessionMetadataPath(), "utf8"));
+        return parsed && typeof parsed === "object" && typeof parsed.sessionId === "string"
+            ? parsed
+            : null;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+export async function updateActiveSessionMetadata(metadata) {
+    const sessionId = metadata.sessionId.trim();
+    if (!sessionId)
+        return;
+    await setActiveSession(sessionId);
+    const path = getActiveSessionMetadataPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify({
+        ...metadata,
+        sessionId,
+        updatedAt: metadata.updatedAt || new Date().toISOString(),
+    }, null, 2)}\n`, { mode: 0o600 });
+}
+export async function clearActiveSession() {
+    await rm(getActiveSessionPath(), { force: true });
+    await rm(getActiveSessionMetadataPath(), { force: true });
+}
+//# sourceMappingURL=activeSession.js.map

package/dist/utils/prompt.js

@@ -0,0 +1,4 @@
+export function joinPromptParts(promptParts) {
+    return promptParts.join(" ").trim();
+}
+//# sourceMappingURL=prompt.js.map

package/dist/utils/recentSources.js

@@ -0,0 +1,27 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getActiveSessionPath } from "./activeSession.js";
+export function getRecentSourcesPath() {
+    return join(dirname(getActiveSessionPath()), "recent-sources.json");
+}
+export async function getRecentSources() {
+    try {
+        const text = await readFile(getRecentSourcesPath(), "utf8");
+        const parsed = JSON.parse(text);
+        return Array.isArray(parsed?.sources) ? parsed.sources : [];
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function setRecentSources(sources) {
+    const path = getRecentSourcesPath();
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    await writeFile(path, `${JSON.stringify({ sources }, null, 2)}\n`, { mode: 0o600 });
+}
+export async function clearRecentSources() {
+    await rm(getRecentSourcesPath(), { force: true });
+}
+//# sourceMappingURL=recentSources.js.map